Created common and client Session classes

Author: drclaws

CMakeLists.txt

@@ -6,14 +6,14 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
 set(INCLUDE_PATH simple_lib/include)
 
 # Common static lib
-add_library(simple_lib STATIC simple_lib/src/common.cpp)
+add_library(simple_lib STATIC simple_lib/src/common.cpp simple_lib/src/Session.cpp)
 
 # Server
 project(simple_server)
 add_executable(${PROJECT_NAME} server/main.cpp)
 
-target_sources(${PROJECT_NAME} PRIVATE server/Session.cpp server/Session.hpp)
 target_sources(${PROJECT_NAME} PRIVATE server/Server.cpp server/Server.hpp)
+target_sources(${PROJECT_NAME} PRIVATE server/SessionServer.cpp server/SessionServer.hpp)
 target_sources(${PROJECT_NAME} PRIVATE server/SessionTcp.cpp server/SessionTcp.hpp)
 target_sources(${PROJECT_NAME} PRIVATE server/SessionUdp.cpp server/SessionUdp.hpp)
 
@@ -28,6 +28,7 @@ project(simple_client)
 add_executable(${PROJECT_NAME} client/main.cpp)
 
 target_sources(${PROJECT_NAME} PRIVATE client/MainConsole.cpp client/MainConsole.hpp)
+target_sources(${PROJECT_NAME} PRIVATE client/SessionClient.cpp client/SessionClient.hpp)
 
 target_include_directories(${PROJECT_NAME} PUBLIC ${INCLUDE_PATH})
 target_link_libraries(${PROJECT_NAME} simple_lib)

client/SessionClient.cpp

@@ -0,0 +1,19 @@
+#include "SessionClient.hpp"
+
+#include <sys/socket.h>
+#include <sys/epoll.h>
+
+#include <unistd.h>
+
+namespace simpleApp
+{
+    SessionClient::SessionClient(int epollfd) : Session(epollfd)
+    {
+
+    }
+
+    SessionClient::~SessionClient()
+    {
+        
+    }
+}

client/SessionClient.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <simple_lib/common.h>
+#include <simple_lib/Session.hpp>
+
+namespace simpleApp
+{
+    class SessionClient : public Session
+    {
+    public:
+        virtual ~SessionClient();
+
+        virtual int init() = 0;
+        virtual int proceed(int fd) = 0;
+        
+    protected:
+        SessionClient(int epollfd);
+    };
+}

server/Server.cpp

@@ -1,3 +1,5 @@
+#include "Server.hpp"
+
 #include <iostream>
 #include <set>
 #include <vector>
@@ -13,8 +15,7 @@
 
 #include <simple_lib/common.h>
 
-#include "Server.hpp"
-#include "Session.hpp"
+#include "SessionServer.hpp"
 #include "SessionUdp.hpp"
 #include "SessionTcp.hpp"
 
@@ -46,7 +47,7 @@ namespace simpleApp
         return modeEpoll(epollfd, EPOLL_CTL_DEL, fd, 0, 0);
     }
 
-    inline socket_t createTcpSocket(uint16_t port, int& err)
+    inline socket_t createTcpSocket(int& err)
     {
         socket_t newSocket = socket(AF_INET, SOCK_STREAM, 0);
         if (newSocket == -1)
@@ -72,7 +73,7 @@ namespace simpleApp
         sockaddr_in serverTcpAddress;
         bzero(&serverTcpAddress, sizeof(serverTcpAddress));
         serverTcpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-        serverTcpAddress.sin_port = htons(port);
+        serverTcpAddress.sin_port = htons(PUBLIC_PORT);
         serverTcpAddress.sin_family = AF_INET;
 
         if (bind(newSocket, (sockaddr *)&serverTcpAddress, sizeof(serverTcpAddress)) == -1)
@@ -94,7 +95,7 @@ namespace simpleApp
         return newSocket;
     }
 
-    inline socket_t createUdpSocket(uint16_t& port, int& err)
+    inline socket_t createUdpSocket(int& err)
     {
         socket_t newSocket = socket(AF_INET, SOCK_DGRAM, 0);
 
@@ -121,7 +122,7 @@ namespace simpleApp
         sockaddr_in serverUdpAddress;
         bzero(&serverUdpAddress, sizeof(serverUdpAddress));
         serverUdpAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-        serverUdpAddress.sin_port = htons(port);
+        serverUdpAddress.sin_port = htons(PUBLIC_PORT);
         serverUdpAddress.sin_family = AF_INET;
 
         if (bind(newSocket, (sockaddr *)&serverUdpAddress, sizeof(serverUdpAddress)) == -1)
@@ -146,7 +147,7 @@ namespace simpleApp
             close(this->stopEventFd);
     }
 
-    int Server::serverLoop(uint16_t port)
+    int Server::serverLoop()
     {
         if(this->stopEventFd == -1)
         {
@@ -157,12 +158,12 @@ namespace simpleApp
         std::cout << "Starting server" << std::endl << std::flush;
 
         int err;
-        socket_t masterTcpSocket = createTcpSocket(port, err);
+        socket_t masterTcpSocket = createTcpSocket(err);
 
         if (masterTcpSocket == -1)
             std::cout << "TCP master socket initialization failed with code " << err << std::endl << std::flush;
 
-        socket_t masterUdpSocket = createUdpSocket(port, err);
+        socket_t masterUdpSocket = createUdpSocket(err);
 
         if (masterUdpSocket == -1)
             std::cout << "UDP master socket initialization failed with code " << err << std::endl << std::flush;
@@ -224,24 +225,24 @@ namespace simpleApp
                 const size_t MAX_EVENTS_BUFFER = 10000;
                 epoll_event * events = static_cast<epoll_event *>(calloc(MAX_EVENTS_BUFFER, sizeof(epoll_event)));
 
-                std::set<Session*> slaveSocketsMap = std::set<Session *>();
+                std::set<SessionServer*> slaveSocketsMap = std::set<SessionServer *>();
 
                 bool stopEventHappened = false;
 
-                auto initSession = [&slaveSocketsMap, &masterTcpSocket, &masterUdpSocket, &epollfd, port](epoll_event& event)
+                auto initSession = [&slaveSocketsMap, &masterTcpSocket, &masterUdpSocket, &epollfd](epoll_event& event)
                 {
-                    Session* clientSession;
+                    SessionServer* clientSession;
                     session_result result;
 
                     if (event.data.ptr == &masterTcpSocket)
                     {
                         clientSession = new SessionTcp(epollfd);
-                        result = clientSession->init(masterTcpSocket, port);
+                        result = clientSession->init(masterTcpSocket);
                     }
                     else if (event.data.ptr == &masterUdpSocket)
                     {
                         clientSession = new SessionUdp(epollfd);
-                        result = clientSession->init(masterUdpSocket, port);
+                        result = clientSession->init(masterUdpSocket);
                     }
                     else
                         return false;
@@ -310,7 +311,7 @@ namespace simpleApp
                 };
                 while (!stopEventHappened)
                 {
-                    std::set<Session*> slavesForRemove = std::set<Session*>();
+                    std::set<SessionServer*> slavesForRemove = std::set<SessionServer*>();
                     int N = epoll_wait(epollfd, events, MAX_EVENTS_BUFFER, -1);
                     for (size_t i = 0; static_cast<int>(i) < N; i++)
                     {
@@ -344,7 +345,7 @@ namespace simpleApp
                         }
                         else
                         {
-                            auto clientSession = reinterpret_cast<Session*>(events[i].data.ptr);
+                            auto clientSession = reinterpret_cast<SessionServer*>(events[i].data.ptr);
                             if(slaveSocketsMap.find(clientSession) == slaveSocketsMap.end())
                             {
                                 std::cout << "Unknown event happened" << std::endl;

server/Server.hpp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <stdint.h>
-
 namespace simpleApp 
 {
     class Server
@@ -10,7 +8,7 @@ namespace simpleApp
         Server();  
         ~Server();
 
-        int serverLoop(uint16_t port);
+        int serverLoop();
 
         int initStop();
 

server/Session.cpp server/SessionServer.cppserver/Session.cpp renamed to server/SessionServer.cpp

@@ -1,4 +1,4 @@
-#include "Session.hpp"
+#include "SessionServer.hpp"
 
 #include <sys/socket.h>
 #include <sys/epoll.h>
@@ -7,32 +7,21 @@
 
 namespace simpleApp
 {
-    Session::Session(int epollfd, std::string name) : epollfd(epollfd), _name(name)
+    SessionServer::SessionServer(int epollfd, std::string name) : Session(epollfd), _name(name)
     {
 
     }
 
-    Session::~Session()
+    SessionServer::~SessionServer()
     {
-        this->sessionClose();
+        
     }
 
-    std::string Session::getName()
+    std::string SessionServer::getName()
     {
         return this->_name;
     }
 
-    void Session::sessionClose()
-    {
-        if (this->_socket != -1)
-        {
-            epoll_ctl(this->epollfd, EPOLL_CTL_DEL, this->_socket, 0);
-            shutdown(this->_socket, SHUT_RDWR);
-            close(this->_socket);
-            this->_socket = -1;
-        }
-    }
-
     std::string addressToString(sockaddr_in& address)
     {
         auto portConverted = ntohs(address.sin_port);

server/Session.hpp server/SessionServer.hppserver/Session.hpp renamed to server/SessionServer.hpp

@@ -7,29 +7,26 @@
 
 
 #include <simple_lib/common.h>
+#include <simple_lib/Session.hpp>
 
 #include "session_result.h"
 
 namespace simpleApp
 {
-    class Session 
+    class SessionServer : public Session
     {
     public:
-        virtual ~Session();
+        virtual ~SessionServer();
 
-        virtual session_result init(socket_t masterSocket, uint16_t port) = 0;
+        virtual session_result init(socket_t masterSocket) = 0;
         virtual session_result proceed() = 0;
 
         std::string getName();
 
     protected:
-        socket_t _socket = -1;
-        int epollfd;
         std::string _name;
 
-        Session(int epollfd, std::string name = "");
-
-        void sessionClose();
+        SessionServer(int epollfd, std::string name = "");
     };
 
     std::string addressToString(sockaddr_in& address);

server/SessionTcp.cpp

@@ -12,7 +12,7 @@
 
 namespace simpleApp
 {
-    SessionTcp::SessionTcp(int epollfd) : Session(epollfd, std::string("TCP"))
+    SessionTcp::SessionTcp(int epollfd) : SessionServer(epollfd, std::string("TCP"))
     {
 
     }
@@ -22,7 +22,7 @@ namespace simpleApp
 
     }
 
-    session_result SessionTcp::init(socket_t masterSocket, uint16_t port)
+    session_result SessionTcp::init(socket_t masterSocket)
     {
         sockaddr_in address;
         socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_in));

server/SessionTcp.hpp

@@ -2,18 +2,18 @@
 
 #include <simple_lib/common.h>
 
-#include "Session.hpp"
+#include "SessionServer.hpp"
 #include "session_result.h"
 
 namespace simpleApp
 {
-    class SessionTcp : public Session
+    class SessionTcp : public SessionServer
     {
     public:
         SessionTcp(int epollfd);
         ~SessionTcp();
 
-        session_result init(socket_t masterSocket, uint16_t port) override;
+        session_result init(socket_t masterSocket) override;
 
         session_result proceed() override;
     };

server/SessionUdp.cpp

@@ -14,7 +14,7 @@
 
 namespace simpleApp
 {
-    SessionUdp::SessionUdp(int epollfd) : Session(epollfd, std::string("UDP"))
+    SessionUdp::SessionUdp(int epollfd) : SessionServer(epollfd, std::string("UDP"))
     {
 
     }
@@ -41,7 +41,7 @@ namespace simpleApp
         }
     }
 
-    session_result SessionUdp::init(socket_t masterSocket, uint16_t port)
+    session_result SessionUdp::init(socket_t masterSocket)
     {
         const size_t buffCheckLength = sizeof(msg_headers) + 1;
         uint8_t msgBuff[buffCheckLength];
@@ -63,7 +63,7 @@ namespace simpleApp
         if (*(reinterpret_cast<msg_headers *>(msgBuff)) != msg_headers::client_connup)
             return session_result(session_status::init_udp_wrong_header);
 
-        auto initSocket = [this, port, &address]()
+        auto initSocket = [this, &address]()
         {
             this->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
 
@@ -125,7 +125,7 @@ namespace simpleApp
             sockaddr_in socketBindAddress;
             bzero(&socketBindAddress, sizeof(socketBindAddress));
             socketBindAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-            socketBindAddress.sin_port = htons(port);
+            socketBindAddress.sin_port = htons(PUBLIC_PORT);
             socketBindAddress.sin_family = AF_INET;
 
             if (bind(this->_socket, (sockaddr *)&socketBindAddress, sizeof(socketBindAddress)) == -1)