src/net/server.h

Go to the documentation of this file.

#ifndef SERVER_H
#define SERVER_H
#include <stdio.h>
#include <list>
#include <string>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/resource.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <arpa/inet.h>
#include <errno.h>

#include "engine/loop_thread_obj.h"
#include "tools/conf.h"
#include "tools/log.h"

template <class A>
class Server : public FastLoopThreadObj
{
        std::list<A*> clients;
        int fd;
        fd_set sock_set;
        int port;

public :
        Server(std::string name);
        ~Server();
        void Loop();
        void OnStop();
};

template <class A>
Server<A>::Server(std::string name) : FastLoopThreadObj(name)
{
        // Ignore broken pipe signal (elsewise we would break,
        // as soon as we are trying to write on client that closed)
        if( signal(SIGPIPE, SIG_IGN) == SIG_ERR )
                log(LogPanic, "Could not ignore SIGPIPE");

        fd = -1;

        Config conf;
        if(!conf.Get(name + "_port", port))
        {
                std::string conf_port = name + "_port";
                log(LogPanic, "Couldn't find configuration option %s", conf_port.c_str());
        }

        log(LogInfo, "Starting server listening on port %i", port);
        // Init the listening socket
        fd = socket(AF_INET, SOCK_STREAM, 0);
        int on = 1;
        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

        struct sockaddr_in address;
        address.sin_family = AF_INET;
        address.sin_addr.s_addr = htonl(INADDR_ANY);
        address.sin_port = htons(port);
        
        if ( bind(fd, (struct sockaddr*) &address, sizeof(address)) == -1 )
                log(LogPanic, "Could not bind to port %i : %s", port, strerror(errno));

        // 128 is the size of the connection queue
        // -> TODO : use a sysctl to get the max size accepted by the kernel
        // ( see 'man listen' )
        if ( listen(fd, 128) == -1 )
                log(LogPanic, "Unable to socket's queue size...\n");

        // Init the socket set:
        memset(&sock_set, 0, sizeof(sock_set));
        FD_ZERO(&sock_set);
        FD_SET(fd, &sock_set);
}

template <class A>
Server<A>::~Server()
{
}

template <class A>
void Server<A>::Loop()
{
        if(fd == -1)
                return;

        struct timeval timeout;
        fd_set acting_socket;
        memset(&timeout, 0, sizeof(struct timeval));

        timeout.tv_sec = 0;
        timeout.tv_usec = 100000;

        acting_socket = sock_set;
        // Lock the process until activity is detected
        if ( select(fd + 1, &acting_socket, NULL, NULL, &timeout) < 0)
        {
                if(timeout.tv_sec != 0 && timeout.tv_usec != 0)
                        log(LogPanic, "Error during select");
        }

        // Then check if there is any new incoming connection
        if( FD_ISSET(fd, &acting_socket) )
        {
                int client_fd;
                struct sockaddr_in client_address;
                socklen_t addr_size = sizeof(client_address);

                client_fd = accept(fd, (struct sockaddr*)&client_address, &addr_size);

                if(client_fd == -1)
                {
                        log(LogError, "Unable to accept client..");
                        return;
                }

                FD_SET(client_fd, &sock_set);

                // Get the adress of the client
                const int buflen = 256;
                char buf[buflen];
                char buf2[buflen];

                if(inet_ntop(AF_INET, &client_address.sin_addr.s_addr, buf, buflen) == NULL)
                        strcpy(buf, "Unknown address");
                snprintf(buf2, buflen, "%s:%i", buf, ntohs(client_address.sin_port));

                log(LogInfo, "New client from %s", buf2);

                A* c = new A(buf2, client_fd);
                c->Start();
                clients.push_back(c);
        }

        typename std::list<A*>::iterator c = clients.begin();
        while(c != clients.end())
        {
                if(!(*c)->IsConnected())
                {
                        (*c)->Stop();
                        delete (*c);
                        c = clients.erase(c);
                }
                else
                        ++c;
        }
}

template <class A>
void Server<A>::OnStop()
{
        if(fd == -1)
                return;

        typename std::list<A*>::iterator c = clients.begin();
        while(c != clients.end())
        {
                (*c)->Disconnect();
                (*c)->Stop();
                delete (*c);
                ++c;
        }
        FD_ZERO(&sock_set);
        close(fd);
}

#endif

---