From a39188254148fcb05ea64aa1190b485a78f844ce Mon Sep 17 00:00:00 2001 From: Brad Arant Date: Tue, 30 Jul 2024 15:59:25 -0700 Subject: [PATCH] Made server a pointer for eliminating TCPSession2. --- ConsoleServer.cpp | 2 +- ConsoleSession.cpp | 4 +- ConsoleSession.h | 2 +- Makefile | 91 ------------ SubscriptionManager.cpp | 2 +- TCPServer.cpp | 16 +-- TCPServer.h | 298 ++++++++++++++++++++-------------------- TCPSession.cpp | 18 ++- TCPSession.h | 262 ++++++++++++++++++----------------- TCPSession2.cpp | 44 ------ TCPSession2.h | 25 ---- TCPSocket.h | 25 +++- TerminalSession.cpp | 6 +- TerminalSession.h | 2 +- 14 files changed, 336 insertions(+), 461 deletions(-) delete mode 100644 Makefile diff --git a/ConsoleServer.cpp b/ConsoleServer.cpp index 8160498..d5e81ea 100644 --- a/ConsoleServer.cpp +++ b/ConsoleServer.cpp @@ -15,7 +15,7 @@ namespace core { } TCPSession * ConsoleServer::getSocketAccept(EPoll &ePoll) { - return new ConsoleSession(ePoll, *this); + return new ConsoleSession(ePoll, this); } } diff --git a/ConsoleSession.cpp b/ConsoleSession.cpp index 06627ee..ae4ef71 100644 --- a/ConsoleSession.cpp +++ b/ConsoleSession.cpp @@ -4,7 +4,7 @@ namespace core { - ConsoleSession::ConsoleSession(EPoll &ePoll, TCPServer &server) : TerminalSession(ePoll, server) {} + ConsoleSession::ConsoleSession(EPoll &ePoll, TCPServer *server) : TerminalSession(ePoll, server) {} ConsoleSession::~ConsoleSession() {} @@ -75,7 +75,7 @@ namespace core { } void ConsoleSession::doCommand(coreutils::ZString &request) { - server.commands.processRequest(request, *this); + server->commands.processRequest(request, *this); } } diff --git a/ConsoleSession.h b/ConsoleSession.h index f3ae21a..b1369ff 100644 --- a/ConsoleSession.h +++ b/ConsoleSession.h @@ -20,7 +20,7 @@ namespace core { class ConsoleSession : public TerminalSession { public: - ConsoleSession(EPoll &ePoll, TCPServer &server); + ConsoleSession(EPoll &ePoll, TCPServer *server); ~ConsoleSession(); void writeLog(std::string data); diff --git a/Makefile b/Makefile deleted file mode 100644 index 0811f9a..0000000 --- a/Makefile +++ /dev/null @@ -1,91 +0,0 @@ -# -# 'make' build executable file 'main' -# 'make clean' removes all .o and executable files -# - -# define the Cpp compiler to use -CXX = g++ - -# define any compile-time flags -CXXFLAGS := -std=c++17 -Wall -Wextra -g - -# define library paths in addition to /usr/lib -# if I wanted to include libraries not in /usr/lib I'd specify -# their path using -Lpath, something like: -LFLAGS = - -# define output directory -OUTPUT := output - -# define source directory -SRC := src - -# define include directory -INCLUDE := include - -# define lib directory -LIB := lib - -ifeq ($(OS),Windows_NT) -MAIN := main.exe -SOURCEDIRS := $(SRC) -INCLUDEDIRS := $(INCLUDE) -LIBDIRS := $(LIB) -FIXPATH = $(subst /,\,$1) -RM := del /q /f -MD := mkdir -else -MAIN := main -SOURCEDIRS := $(shell find $(SRC) -type d) -INCLUDEDIRS := $(shell find $(INCLUDE) -type d) -LIBDIRS := $(shell find $(LIB) -type d) -FIXPATH = $1 -RM = rm -f -MD := mkdir -p -endif - -# define any directories containing header files other than /usr/include -INCLUDES := $(patsubst %,-I%, $(INCLUDEDIRS:%/=%)) - -# define the C libs -LIBS := $(patsubst %,-L%, $(LIBDIRS:%/=%)) - -# define the C source files -SOURCES := $(wildcard $(patsubst %,%/*.cpp, $(SOURCEDIRS))) - -# define the C object files -OBJECTS := $(SOURCES:.cpp=.o) - -# -# The following part of the makefile is generic; it can be used to -# build any executable just by changing the definitions above and by -# deleting dependencies appended to the file from 'make depend' -# - -OUTPUTMAIN := $(call FIXPATH,$(OUTPUT)/$(MAIN)) - -all: $(OUTPUT) $(MAIN) - @echo Executing 'all' complete! - -$(OUTPUT): - $(MD) $(OUTPUT) - -$(MAIN): $(OBJECTS) - $(CXX) $(CXXFLAGS) $(INCLUDES) -o $(OUTPUTMAIN) $(OBJECTS) $(LFLAGS) $(LIBS) - -# this is a suffix replacement rule for building .o's from .c's -# it uses automatic variables $<: the name of the prerequisite of -# the rule(a .c file) and $@: the name of the target of the rule (a .o file) -# (see the gnu make manual section about automatic variables) -.cpp.o: - $(CXX) $(CXXFLAGS) $(INCLUDES) -c $< -o $@ - -.PHONY: clean -clean: - $(RM) $(OUTPUTMAIN) - $(RM) $(call FIXPATH,$(OBJECTS)) - @echo Cleanup complete! - -run: all - ./$(OUTPUTMAIN) - @echo Executing 'run: all' complete! \ No newline at end of file diff --git a/SubscriptionManager.cpp b/SubscriptionManager.cpp index 02b348f..5aff1b1 100644 --- a/SubscriptionManager.cpp +++ b/SubscriptionManager.cpp @@ -67,7 +67,7 @@ namespace core { std::stringstream out; coreutils::Log(coreutils::LOG_DEBUG_1) << request[2]; std::string invitee = request[2].str(); - TCPSession *tempSession = session.server.getSessionByAlias(&invitee); + TCPSession *tempSession = session.server->getSessionByAlias(&invitee); std::stringstream temp; temp << "invite:" << request[1] << ":" << *(std::string *)session.alias; tempSession->write(temp.str()); diff --git a/TCPServer.cpp b/TCPServer.cpp index fdf09db..ae11e0e 100644 --- a/TCPServer.cpp +++ b/TCPServer.cpp @@ -9,13 +9,13 @@ namespace core { TCPServer::TCPServer(EPoll &ePoll, IPAddress address, std::string delimiter, int depth, std::string text) : TCPSocket(ePoll, text), commands(delimiter, depth) { - commands.add(subscriptions, "publish"); - commands.add(subscriptions, "unpublish"); - commands.add(subscriptions, "subscribe"); - commands.add(subscriptions, "unsubscribe"); - commands.add(subscriptions, "catalog"); - commands.add(subscriptions, "event"); - commands.add(subscriptions, "invite"); +// commands.add(subscriptions, "publish"); // This needs to be removed and put into the servers that +// commands.add(subscriptions, "unpublish"); // Others make. Plus it should be in a manager object that +// commands.add(subscriptions, "subscribe"); // encapsulates all of the function. +// commands.add(subscriptions, "unsubscribe"); +// commands.add(subscriptions, "catalog"); +// commands.add(subscriptions, "event"); +// commands.add(subscriptions, "invite"); setDescriptor(socket(AF_INET, SOCK_STREAM, 0)); int yes = 1; @@ -84,7 +84,7 @@ namespace core { } TCPSession * TCPServer::getSocketAccept(EPoll &ePoll) { - return new TCPSession(ePoll, *this); + return new TCPSession(ePoll, this); } void TCPServer::output(std::stringstream &out) { diff --git a/TCPServer.h b/TCPServer.h index e07f5c2..e766919 100644 --- a/TCPServer.h +++ b/TCPServer.h @@ -1,155 +1,155 @@ #ifndef __TCPServer_h__ -#define __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" - -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 BMACommand 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, 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 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: - /// - /// Override the virtual dataReceived since for the server these - /// are requests to accept the new connection socket. - /// No data is to be read or written when this method is called. It is the response to - /// the fact that a new connection is coming into the system - /// - /// @param data the pointer to the buffer containing the received data. - /// @param length the length of the associated data buffer. - /// - - void onDataReceived(std::string data) 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; - }; +# include "Command.h" +# include "CommandList.h" +# include "IPAddressList.h" +# include "Socket.h" +# include "SubscriptionManager.h" +# include "TCPSession.h" +# include "TCPSocket.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 BMACommand 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, 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 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: + /// + /// Override the virtual dataReceived since for the server these + /// are requests to accept the new connection socket. + /// No data is to be read or written when this method is called. It is the response to + /// the fact that a new connection is coming into the system + /// + /// @param data the pointer to the buffer containing the received data. + /// @param length the length of the associated data buffer. + /// + + void onDataReceived(std::string data) 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 diff --git a/TCPSession.cpp b/TCPSession.cpp index 1d159ae..3381306 100644 --- a/TCPSession.cpp +++ b/TCPSession.cpp @@ -4,10 +4,16 @@ #include "TCPServer.h" #include "uuid/uuid.h" -namespace core -{ +namespace core { - TCPSession::TCPSession(EPoll &ePoll, TCPServer &server, std::string text) : TCPSocket(ePoll, server.ctx, text), server(server) { + TCPSession::TCPSession(EPoll &ePoll, std::string text) : TCPSocket(ePoll, text) { + uuid_t uuidObject; + uuid_generate(uuidObject); + coreutils::Log(coreutils::LOG_DEBUG_1) << uuidObject; + alias = (void *)uuidObject; + } + + TCPSession::TCPSession(EPoll &ePoll, TCPServer *server, std::string text) : TCPSocket(ePoll, server->ctx, text), server(server) { uuid_t uuidObject; uuid_generate(uuidObject); coreutils::Log(coreutils::LOG_DEBUG_1) << uuidObject; @@ -15,8 +21,8 @@ namespace core } TCPSession::~TCPSession() { - server.removeFromSessionList(this); - server.subscriptions.removeSessionSubscriptions(*this); + server->removeFromSessionList(this); + server->subscriptions.removeSessionSubscriptions(*this); } void TCPSession::output(std::stringstream &data) { @@ -25,7 +31,7 @@ namespace core void TCPSession::protocol(coreutils::ZString &data) { if (data.getLength() != 0) { - if (!server.commands.processRequest(data, *this)) { + if (!server->commands.processRequest(data, *this)) { coreutils::Log(coreutils::LOG_DEBUG_1) << "Received data could not be parsed: " << data.str(); } } diff --git a/TCPSession.h b/TCPSession.h index 717e8ab..f6d37c0 100644 --- a/TCPSession.h +++ b/TCPSession.h @@ -1,136 +1,144 @@ #ifndef __Session_h__ -#define __Session_h__ +# define __Session_h__ -#include "SessionFilter.h" -#include "TCPSocket.h" -#include +# include "SessionFilter.h" +# include "TCPSocket.h" +# include namespace core { - - class Command; - class TCPServer; - - /// - /// TCPSession - /// - /// TCPSession defines the nature of the interaction with the client - /// and stores persistent data for a defined session. TCPSession objects - /// are not sockets but instead provide a communications control - /// mechanism. Protocol conversations are provided through extensions - /// from this object. - /// - /// - /// - - class TCPSession : public TCPSocket { - - public: - /// - /// - /// - - TCPSession(EPoll &ePoll, TCPServer &server, std::string text = ""); - - /// - /// - /// - - virtual ~TCPSession(); - - Command *grab = NULL; - - virtual void output(std::stringstream &data); - - /// - /// The send method is used to output the contents of the out stream - /// to the session containing the stream. - /// - - void send(); - - /// - /// Use this method to terminate this TCPSession. - /// - - void terminate(); - - /// - /// - /// - - TCPServer &server; - - /// - /// Use out to send data to the session socket or other session sockets. - /// - - std::stringstream out; - - /// - /// uuid is generated automatically when the session object is instantiated. This - /// value can be used to uniquely identify a session and is the default value - /// pointed to by the alias pointer. - /// - - char uuid[37]; - - /// - /// alias is a void pointer that can be set to point to any object that identifies - /// this session uniquely. Using this approach, inheriting objects can determine - /// how it knows the contacts that this server manages. - /// - - void *alias; - - /// - /// - /// - - virtual bool compareAlias(void *alias); - - virtual void outputAlias(std::stringstream &out); - - protected: - /// - /// - /// - - virtual void onRegistered() override; - - /// - /// Override the onLineReceived method to receive a string of characters that - /// represents a single line of data terminated by a LF or CRLF. If onDataReceived - /// was overriden this method will not be called unless the onDataReceived calls - /// this method explicitly using the class and member name. - /// - - virtual void onLineReceived(coreutils::ZString &line) override; - - /// - /// This method is called from within the protocol method when protocol is called - /// on the initial connection where the data is an empty string. Use this method - /// to deliver a message to the connection upon connection. - /// - - virtual void onConnected(); - - /// - /// Override the protocol method to manage and control the session communications - /// in your inherited session. If you do not override this method then the Session - /// default will process the 'commands' added to the server object using the - /// processRequest method on the session input. - /// - /// When data is received within the session two modes are available to pass the - /// data through the protocol method: LINE or BLOCK. - /// - - virtual void protocol(coreutils::ZString &data); - - private: - std::mutex mtx; - }; + class Command; + class TCPServer; + + /// + /// TCPSession + /// + /// TCPSession defines the nature of the interaction with the client + /// and stores persistent data for a defined session. TCPSession objects + /// are not sockets but instead provide a communications control + /// mechanism. Protocol conversations are provided through extensions + /// from this object. + /// + /// + /// + + class TCPSession : public TCPSocket { + + public: + + /// + /// + /// + + TCPSession(EPoll &ePoll, std::string text = ""); + /// + /// + /// + + TCPSession(EPoll &ePoll, TCPServer *server, std::string text = ""); + + /// + /// + /// + + virtual ~TCPSession(); + + Command *grab = NULL; + + virtual void output(std::stringstream &data); + + /// + /// The send method is used to output the contents of the out stream + /// to the session containing the stream. + /// + + void send(); + + /// + /// Use this method to terminate this TCPSession. + /// + + void terminate(); + + /// + /// This is a pointer to the server that was used to 'spawn' the server connection. + /// If the session is just client side connection this pointer should be NULL; + /// + + TCPServer *server; + + /// + /// Use out to send data to the session socket or other session sockets. + /// + + std::stringstream out; + + /// + /// uuid is generated automatically when the session object is instantiated. This + /// value can be used to uniquely identify a session and is the default value + /// pointed to by the alias pointer. + /// + + char uuid[37]; + + /// + /// alias is a void pointer that can be set to point to any object that identifies + /// this session uniquely. Using this approach, inheriting objects can determine + /// how it knows the contacts that this server manages. + /// + + void *alias; + + /// + /// + /// + + virtual bool compareAlias(void *alias); + + virtual void outputAlias(std::stringstream &out); + + protected: + /// + /// + /// + + virtual void onRegistered() override; + + /// + /// Override the onLineReceived method to receive a string of characters that + /// represents a single line of data terminated by a LF or CRLF. If onDataReceived + /// was overriden this method will not be called unless the onDataReceived calls + /// this method explicitly using the class and member name. + /// + + virtual void onLineReceived(coreutils::ZString &line) override; + + /// + /// This method is called from within the protocol method when protocol is called + /// on the initial connection where the data is an empty string. Use this method + /// to deliver a message to the connection upon connection. + /// + + virtual void onConnected(); + + /// + /// Override the protocol method to manage and control the session communications + /// in your inherited session. If you do not override this method then the Session + /// default will process the 'commands' added to the server object using the + /// processRequest method on the session input. + /// + /// When data is received within the session two modes are available to pass the + /// data through the protocol method: LINE or BLOCK. + /// + + virtual void protocol(coreutils::ZString &data); + + private: + std::mutex mtx; + + }; + } #endif diff --git a/TCPSession2.cpp b/TCPSession2.cpp index af272aa..a175dfb 100644 --- a/TCPSession2.cpp +++ b/TCPSession2.cpp @@ -23,55 +23,11 @@ namespace core { void TCPSession2::onConnected() {} - void TCPSession2::onDataReceived(coreutils::ZString &data) { - if(data.getLength() > 0) { - lineBuffer = (char *)realloc(lineBuffer, lineBufferSize + data.getLength()); - memcpy(lineBuffer + lineBufferSize, data.getData(), data.getLength()); - lineBufferSize += data.getLength(); - while(lineBufferSize > 0) { - if(blockSize == 0) { - lineLength = strcspn(lineBuffer, "\r\n"); - if(lineLength == lineBufferSize) - break; - coreutils::ZString zLine(lineBuffer, lineLength); - onLineReceived(zLine); - if(lineBuffer[lineLength] == '\r') - ++lineLength; - if(lineBuffer[lineLength] == '\n') - ++lineLength; - lineBufferSize -= lineLength; - if(lineBufferSize > 0) - memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize); - lineBuffer = (char *)realloc(lineBuffer, lineBufferSize); - } else if(lineBufferSize >= blockLength) { - coreutils::ZString zBlock(lineBuffer, blockLength); - onBlockReceived(zBlock); - lineBufferSize -= blockLength; - if(lineBufferSize > 0) - memmove(lineBuffer, lineBuffer + blockLength, lineBufferSize); - lineBuffer = (char *)realloc(lineBuffer, lineBufferSize); - } - } - } - } void TCPSession2::setBlockSize(int blockSize) { this->blockSize = blockSize; } - void TCPSession2::onLineReceived(coreutils::ZString &line) { - protocol(line); - send(); - if(term) - TCPSocket::shutdown("termination requested"); - } - - void TCPSession2::onBlockReceived(coreutils::ZString &block) { - coreutils::Log(coreutils::LOG_DEBUG_3) << "[" << block.getLength() << "]"; - if(term) - TCPSocket::shutdown("termination requested"); - } - void TCPSession2::send() { if(out.tellp() > 0) TCPSocket::write(out.str()); diff --git a/TCPSession2.h b/TCPSession2.h index 8ad4a20..cdb38b6 100644 --- a/TCPSession2.h +++ b/TCPSession2.h @@ -70,31 +70,6 @@ namespace core { virtual void onRegistered() override; - /// - /// Override this method to receive data directly from the socket as data is - /// received. If you need data split by line termination characters then - /// override the onLineReceived method instead. - /// - virtual void onDataReceived(coreutils::ZString &data) override; - - /// - /// Override the onLineReceived method to receive a string of characters that - /// represents a single line of data terminated by a LF or CRLF. If onDataReceived - /// was overriden this method will not be called unless the onDataReceived calls - /// this method explicitly using the class and member name. - /// - - virtual void onLineReceived(coreutils::ZString &line); - - /// - /// Override the onBlockReceived method to receive a string of characters that - /// represents a single block of data of length determined by the block length value. If - /// onDataReceived was overriden this method will not be called unless the onDataReceived - /// calls this method explicitly using the class and member name. - /// - - virtual void onBlockReceived(coreutils::ZString &block); - /// /// This method is called from within the protocol method when protocol is called /// on the initial connection where the data is an empty string. Use this method diff --git a/TCPSocket.h b/TCPSocket.h index ed13661..3cad4cb 100644 --- a/TCPSocket.h +++ b/TCPSocket.h @@ -22,11 +22,34 @@ namespace core { public: + /// + /// + /// + TCPSocket(EPoll &ePoll); + + /// + /// + /// + TCPSocket(EPoll &ePoll, std::string text); + + /// + /// + /// + TCPSocket(EPoll &ePoll, SSL_CTX *ctx, std::string text); + + /// + /// + /// + virtual ~TCPSocket(); + /// + /// + /// + void connect(IPAddress &address); IPAddress ipAddress; @@ -34,7 +57,7 @@ namespace core { /// /// The output method is called by a socket session (TCPSession) and /// will output the detail information for the client socket. When extending - /// BMATCPSocket or BMASession you can override the method to add attributes + /// TCPSocket or TCPSession you can override the method to add attributes /// to the list. /// diff --git a/TerminalSession.cpp b/TerminalSession.cpp index 5f395bf..c35e688 100644 --- a/TerminalSession.cpp +++ b/TerminalSession.cpp @@ -3,11 +3,9 @@ namespace core { - TerminalSession::TerminalSession(EPoll &ePoll, TCPServer &server) : TCPSession(ePoll, server) { - } + TerminalSession::TerminalSession(EPoll &ePoll, TCPServer *server) : TCPSession(ePoll, server) {} - TerminalSession::~TerminalSession() { - } + TerminalSession::~TerminalSession() {} int TerminalSession::getLines() { struct winsize size; diff --git a/TerminalSession.h b/TerminalSession.h index fd2495e..45c819d 100644 --- a/TerminalSession.h +++ b/TerminalSession.h @@ -29,7 +29,7 @@ namespace core { class TerminalSession : public TCPSession { public: - TerminalSession(EPoll &ePoll, TCPServer &server); + TerminalSession(EPoll &ePoll, TCPServer *server); ~TerminalSession(); int getLines();