ServerCore/TCPServer.h

#ifndef __TCPServer_h__
# define __TCPServer_h__

# include "Command.h"
# include "CommandList.h"
# include "IPAddressList.h"
# include "Socket.h"
# include "SubscriptionManager.h"
# include "TCPSession.h"
# include "TCPSocket.h"
# include "TLSInfo.h"

namespace core {
   
   ///
   /// TCPServer
   ///
   /// Manage a socket connection as a TCP server type. Connections to the socket are processed through
   /// the accept functionality.
   ///
   /// A list of connections is maintained in a vector object.
   ///
   /// This object extends the Command object as well so it can be added to a Console object and
   /// process commands to display status information.
   ///
   
   class TCPServer : public TCPSocket, public Command {
      
    public:
      
      ///
      /// The constructor for the TCPServer object.
      ///
      /// @param ePoll the EPoll instance that manages the socket.
      /// @param url the IP address for the socket to receive connection requests.
      /// @param port the port number that the socket will listen on.
      /// @param commandName the name of the command used to invoke the status display for this object.
      ///
      
      TCPServer(EPoll &ePoll, IPAddress address, TLSInfo *tlsInfo, std::string delimiter = " ", int depth = 10, std::string text = "");
      
      ///
      /// The destructor for this object.
      ///
      
      virtual ~TCPServer();
      
      virtual void sessionErrorHandler(std::string errorString, std::stringstream &out);
      
      ///
      /// getSocketAccept is designed to allow a polymorphic extension of this object to
      /// return a type of object that extends the definition of the server socket.
      /// Returning the appropriate session object that extends from Session provides
      /// the mechanism where the server can select the protocol dialog for the desired
      /// service.
      ///
      
      virtual TCPSession *getSocketAccept(EPoll &epoll);
      
      ///
      /// The list of sessions that are currently open and being maintained by this object.
      ///
      
      std::vector<TCPSession *> sessions;
      
      ///
      /// The commands object is a CommandList and is used to store Command objects to be
      /// parsed and run as data comes into the session.
      ///
      
      CommandList commands;
      
      ///
      /// If not NULL the blacklist object can be assigned to this server socket and the server
      /// IP addresses connecting to the server attempting to accept a socket are contained in
      /// this list then the connection is rejected and no accept is granted.
      ///
      
      IPAddressList *blackList;
      
      ///
      /// If not NULL the blacklist object can be assigned to this server socket and the server
      /// IP addresses connecting to the server attempting to accept a socket are contained in
      /// this list then the connection is rejected and no accept is granted.
      ///
      
      IPAddressList *whiteList;
      
      void removeFromSessionList(TCPSession *session);
      
      void output(std::stringstream &out); ///< Output the consoles array to the console.
      
      ///
      ///
      ///
      
      void sendToAll(std::stringstream &out);
      
      ///
      /// Use this sendToAll method to output the contents of the out stream
      /// to all the connections on the server excluding the sender session.
      ///
      
      void sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter);
      
      ///
      /// Use this sendToAll method to output the contents of the out stream
      /// to all the connections on the server excluding the sender session
      /// and the entries identified by the passed in filter object.
      ///
      
      void sendToAll(std::stringstream &out, TCPSession &sender);
      
      ///
      /// The Subscription Manager tracks all subscriptions on the server.
      ///
      
      SubscriptionManager subscriptions;
      
      ///
      /// Use the getSessionByAlias to retrieve a session pointer by the value
      /// of the alias pointer.
      ///
      
      TCPSession *getSessionByAlias(void *alias);
      
    protected:
      ///
      /// This method is called by the lower socket when a connection request comes into
      /// the listening and bound server port.
      ///

      void connectionRequest() override;

      ///
      /// The listening socket itself is never a TLS peer - accepting a
      /// connection on it surfaces as a plain read() failing with ENOTCONN
      /// (see Socket::receiveData(), which is what actually detects and
      /// dispatches to connectionRequest() above). When this server is
      /// TLS-configured, TCPSocket::receiveData()'s normal ctx-based
      /// dispatch would instead route that same event through
      /// TLS::receiveData()/SSL_read() against a listening fd that was
      /// never SSL_accept()-ed at all (real per-connection sessions are
      /// the only sockets TLS applies to) - confirmed via a real crash
      /// (SIGSEGV inside SSL_read, called with `this` pointing at this
      /// server object, not a session). Always using the plain path here,
      /// regardless of whether tlsInfo is set, keeps connection-detection
      /// working the same way with or without TLS configured.
      ///

      void receiveData(coreutils::ZString &buffer) override;
      
      ///
      /// This method is called when the Command associated with this object is requested
      /// because a user has typed in the associated command name on a command entry line.
      ///
      /// @param the session object to write the output to.
      ///
      
      int processCommand(coreutils::ZString &request, TCPSession &session) override;
      
    private:
      TCPSession *accept();
      std::mutex lock;
   };
   
}

#endif