BaseTCPServer.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <future>
#include <unordered_map>
#include <vector>
 
#ifdef __LINUX__
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#else
#include <WinSock2.h>
#include <WS2tcpip.h>
#endif // __LINUX__
 
#include "WebServerException.h"
 
#ifdef __LINUX__
#ifndef WINDOWS_STYLE_DEFINITION
#define WINDOWS_STYLE_DEFINITION
 
#define closesocket close
#define SOCKET int
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define DWORD uint32_t
 
#endif // WINDOWS_STYLE_DEFINITION
#endif // __LINUX__
 
namespace web
{
    class BaseTCPServer
    {
    private:
        class ClientData
        {
        private:
            std::unordered_map<std::string, std::vector<SOCKET>> data;
            mutable std::mutex dataMutex;
 
        public:
            ClientData() = default;
 
            void add(const std::string& ip, SOCKET socket);
 
            void remove(const std::string& ip, SOCKET socket);
 
            std::vector<SOCKET> extract(const std::string& ip);
 
            void clear();
 
            std::vector<std::pair<std::string, std::vector<SOCKET>>> getClients() const;
 
            size_t getNumberOfClients() const;
 
            size_t getNumberOfConnections() const;
 
            ~ClientData() = default;
        };
 
    public:
        static constexpr size_t ipV4Size = 16;
 
    protected:
        ClientData data;
        std::string ip;
        std::string port;
        SOCKET listenSocket;
        DWORD timeout;
        bool freeDLL;
        bool isRunning;
        const bool multiThreading;
        std::future<void> handle;
 
        u_long blockingMode;
 
        u_long listenSocketBlockingMode;
 
    protected:
        void createListenSocket();
 
        virtual void receiveConnections(const std::function<void()>& onStartServer, std::exception** outException);
 
        virtual void serve(std::string ip, SOCKET clientSocket, sockaddr address);
 
        virtual void clientConnection(const std::string& ip, SOCKET clientSocket, sockaddr address, std::function<void()>& cleanup) = 0;
 
        virtual void onConnectionReceive(SOCKET clientSocket, sockaddr address);
 
        virtual void onInvalidConnectionReceive();
 
        virtual bool autoCloseSocket() const;
        
    protected:
        template<typename DataT>
        static int sendBytes(SOCKET clientSocket, const DataT* const data, int size);
 
        template<typename DataT>
        static int receiveBytes(SOCKET clientSocket, DataT* const data, int size);
 
    public:
        static std::string getClientIpV4(sockaddr address);
 
        std::string getServerIpV4() const;
 
        static uint16_t getClientPortV4(sockaddr address);
 
        uint16_t getServerPortV4() const;
 
        static std::string getVersion();
 
    public:
        BaseTCPServer(std::string_view port, std::string_view ip = "0.0.0.0", DWORD timeout = 0, bool multiThreading = true, u_long listenSocketBlockingMode = 0, bool freeDLL = true);
 
        virtual void start(bool wait = false, const std::function<void()>& onStartServer = []() {}, std::exception** outException = nullptr);
 
        virtual void stop(bool wait = true);
 
        virtual void kick(const std::string& ip);
 
        virtual void kickAll();
 
        bool isServerRunning() const;
 
        bool isListenSocketInBlockingMode() const;
 
        bool isAcceptedSocketsInBlockingMode() const;
 
        void setAcceptedSocketsBlockingMode(bool block);
 
        size_t getNumberOfClients() const;
 
        size_t getNumberOfConnections() const;
 
        std::vector<std::pair<std::string, std::vector<SOCKET>>> getClients() const;
 
        std::string_view getIp() const;
        
        std::string_view getPort() const;
 
        virtual ~BaseTCPServer();
    };
 
    template<typename DataT>
    int BaseTCPServer::sendBytes(SOCKET clientSocket, const DataT* const data, int size)
    {
        int lastSend = 0;
        int totalSent = 0;
 
        do
        {
            lastSend = send(clientSocket, reinterpret_cast<const char*>(data) + totalSent, size - totalSent, NULL);
 
            if (lastSend == SOCKET_ERROR)
            {
                THROW_WEB_SERVER_EXCEPTION;
            }
            else if (!lastSend)
            {
                return totalSent;
            }
 
            totalSent += lastSend;
 
        } while (totalSent < size);
 
        return totalSent;
    }
 
    template<typename DataT>
    int BaseTCPServer::receiveBytes(SOCKET clientSocket, DataT* const data, int size)
    {
        int lastReceive = recv(clientSocket, reinterpret_cast<char*>(data), size, NULL);
 
        if (lastReceive == SOCKET_ERROR)
        {
            THROW_WEB_SERVER_EXCEPTION;
        }
 
        return lastReceive;
    }
}