cube-game-plus-plus/server/network/Server.cpp

#include <iostream>
#include <cstring>
#include <vector>
#include <atomic>
#include <thread>
#include <mutex>

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <poll.h>

#include "server/network/Server.h"

static void printError(const char* message) {
    std::cout << message << ": " << strerror(errno) << "\n";
}

struct ConnectedClient {

    ~ConnectedClient() {
        if(socket != -1) {
            if(shutdown(socket, SHUT_RDWR)) {
                printError("cannot shutdown client socket");
            }
            if(close(socket) == -1) {
                printError("cannot close client socket");
            }
        }
        if(th.joinable()) {
            th.join();
        } else {
            std::cout << "cannot join client connection thread\n";
        }
    }

    std::thread th = std::thread([]() {
    });
    int socket = -1;
};

struct InternServer final {
    InternServer() : listenerSocket(-1), listenerThread([]() {
    })
, shouldRun(true), clients(nullptr) {
    }

    ~InternServer() {
        shouldRun = false;
        listenerThread.join();

        if(listenerSocket != -1) {
            if(close(listenerSocket) == -1) {
                printError("cannot close listener socket");
            }
        }
        if(clients != nullptr) {
            delete[] clients;
        }
    }

    int listenerSocket;
    std::thread listenerThread;
    std::atomic_bool shouldRun;
    ConnectedClient* clients;
};

static InternServer server;

static void defaultFullServerClientConnect(int) {
    std::cout << "default onFullServerClientConnectFunction\n";
}

static void defaultClientConnect(int) {
    std::cout << "default onClientConnectFunction\n";
}

static void defaultClientPackage(int, Stream&) {
    std::cout << "default onClientPackageFunction\n";
}

static void defaultClientDisconnect(int) {
    std::cout << "default onClientDisconnectFunction\n";
}

static std::mutex clientMutex;
static u16 clientAmount = 0;
static u16 maxClients = 0;
static Server::FullServerClientConnectFunction onFullServerClientConnect = defaultFullServerClientConnect;
static Server::ClientConnectFunction onClientConnect = defaultClientConnect;
static Server::ClientPackageFunction onClientPackage = defaultClientPackage;
static Server::ClientDisconnectFunction onClientDisconnect = defaultClientDisconnect;

void Server::setFullServerClientConnectFunction(Server::FullServerClientConnectFunction f) {
    onFullServerClientConnect = f;
}

void Server::setClientConnectFunction(Server::ClientConnectFunction f) {
    onClientConnect = f;
}

void Server::setClientPackageFunction(Server::ClientPackageFunction f) {
    onClientPackage = f;
}

void Server::setClientDisconnectFunction(Server::ClientDisconnectFunction f) {
    onClientDisconnect = f;
}

static void listenOnClient(ConnectedClient& cc) {
    // poll data
    struct pollfd fds;
    fds.fd = cc.socket; // file descriptor for polling
    fds.events = POLLIN; // wait until data is ready to read
    fds.revents = 0; // return events - none

    onClientConnect(cc.socket);

    Stream st;
    while(server.shouldRun) {
        // nfds_t - 1 - amount of passed in structs
        // timeout - 100 - milliseconds to wait until an event occurs
        // returns 0 on timeout, -1 on error, and >0 on success
        int pollData = poll(&fds, 1, 100);
        if(pollData > 0) {
            st.readSocket(cc.socket);
            if(st.hasData()) {
                onClientPackage(cc.socket, st);
            } else {
                // client closed connection
                break;
            }
        } else if(pollData == -1) {
            printError("cannot poll from client");
            break;
        }
    }

    onClientDisconnect(cc.socket);

    // reset slot for another client
    if(server.shouldRun) {
        std::lock_guard<std::mutex> lg(clientMutex);
        if(close(cc.socket) == -1) {
            printError("cannot close socket of client");
        }
        cc.socket = -1;
        clientAmount--;
    }
}

static bool addClient(int clientSocket) {
    std::lock_guard<std::mutex> lg(clientMutex);
    if(clientAmount >= maxClients) {
        onFullServerClientConnect(clientSocket);
        return true;
    } else {
        // search for free slot
        uint16_t index = 0;
        while(index < maxClients) {
            if(server.clients[index].socket == -1) {
                break;
            }
            index++;
        }

        if(index >= maxClients) {
            std::cout << "cannot find free slot - even if there should be one\n";
            return true;
        }

        //ensure old thread has ended
        if(!server.clients[index].th.joinable()) {
            std::cout << "cannot join thread of non used client connection\n";
            return true;
        }
        server.clients[index].th.join();

        server.clients[index].socket = clientSocket;
        server.clients[index].th = std::thread(listenOnClient, std::ref(server.clients[index]));

        clientAmount++;

        return false;
    }
}

static void listenForClients() {
    while(server.shouldRun) {
        // wait until a connection arrives with timeout, this prevents being 
        // stuck in accept
        struct pollfd fds;
        fds.fd = server.listenerSocket; // file descriptor for polling
        fds.events = POLLIN; // wait until data is ready to read
        fds.revents = 0; // return events - none
        // nfds_t - 1 - amount of passed in structs
        // timeout - 100 - milliseconds to wait until an event occurs
        // returns 0 on timeout, -1 on error, and >0 on success
        int pollData = poll(&fds, 1, 100);
        if(pollData > 0) {
            struct sockaddr_in clientSocketData;
            // accepts an incoming client connection and stores the data in the
            // given struct, returns a nonnegative file descriptor on success
            socklen_t addrlen = sizeof (struct sockaddr_in);
            int clientSocket = accept(server.listenerSocket, (struct sockaddr*) &clientSocketData, &addrlen);
            if(clientSocket >= 0) {
                if(addClient(clientSocket)) {
                    if(close(clientSocket) == -1) {
                        printError("cannot close client socket");
                    }
                }
            } else {
                printError("accept error");
                break;
            }
        } else if(pollData == -1) {
            printError("poll error");
            break;
        }
    }
}

bool Server::start(u16 port, u16 inMaxClients) {
    // create socket for incoming connections
    // domain - AF_INET - IPv4 Internet protocols
    // type - SOCK_STREAM - two-way, connection-based byte streams
    // protocol - 0 - use standard protocol for the given socket type
    server.listenerSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(server.listenerSocket == -1) {
        printError("cannot create listener socket");
        return false;
    }

    // prevents clients from blocking the port if the server exits
    // this is useful if server and client run on the same system
    struct linger sl;
    sl.l_onoff = 1; // nonzero to linger on close
    sl.l_linger = 0; // time to linger
    // sockfd - listenerSocket - modified socket
    // level - SOL_SOCKET - manipulate options at the sockets API level
    // optname - SO_LINGER - identifier of the option
    if(setsockopt(server.listenerSocket, SOL_SOCKET, SO_LINGER, &sl, sizeof (struct linger)) == -1) {
        printError("cannot set non lingering");
        return false;
    }

    // specify binding data
    struct sockaddr_in connectSocketData;
    // clear padding
    memset(&connectSocketData, 0, sizeof (struct sockaddr_in));
    // IPv4 Internet protocols
    connectSocketData.sin_family = AF_INET;
    // port in network byte order
    connectSocketData.sin_port = htons(port);
    // address in network byte order, accept any incoming messages
    connectSocketData.sin_addr.s_addr = htons(INADDR_ANY);
    // bind the socket
    if(bind(server.listenerSocket, (struct sockaddr*) &connectSocketData, sizeof (struct sockaddr_in)) == -1) {
        printError("cannot bind listener socket");
        return false;
    }

    // mark the socket as handler for connection requests
    // backlog - 5 - max queue length of pending connections
    if(listen(server.listenerSocket, 5) == -1) {
        printError("cannot start listening on socket");
        return false;
    }

    server.shouldRun = true;

    maxClients = inMaxClients;
    server.clients = new ConnectedClient[inMaxClients];
    // join empty spawn thread
    server.listenerThread.join();
    server.listenerThread = std::thread(listenForClients);
    return true;
}