NetServer.cpp

Aller à la documentation de ce fichier.

/*! \file NetServer.cpp
    \brief Systeme serveur.

    Serveur multitache.

    \author     aerith (http://aerith.fr)
    \version    2.0
    \date       30/03/2008
*/

#include    "NetServer.h"

NetServer::NetServer(const char *pKeyFile, const char *pCertifFile)
{
    conInfo     = NULL;
    limit       = NET_LIMIT;
    sslCTX      = NULL;
    crypt       = NET_T_NORMAL;

    if(pKeyFile && pCertifFile)
    {
        SSL_METHOD  *sslMethode;

        SSL_library_init();
        SSL_load_error_strings();
        sslMethode = SSLv23_server_method();

        sslCTX = SSL_CTX_new(sslMethode);
        if(!sslCTX)
            throw ERROR_C_SSLCTXINIT;

        if(SSL_CTX_use_PrivateKey_file(sslCTX, pKeyFile, SSL_FILETYPE_PEM) < 1)
            throw ERROR_C_SSLKEY;

        if(SSL_CTX_use_certificate_file(sslCTX, pCertifFile, SSL_FILETYPE_PEM) < 1)
            throw ERROR_C_SSLCERTIF;

        if(SSL_CTX_check_private_key(sslCTX) < 1)
            throw ERROR_C_SSLCHECK;

        keyFile = pKeyFile;
        certifFile = pCertifFile;

        crypt = NET_T_SSL;
    }
}

NetServer::~NetServer()
{
    Stop();
}

void    ThreadWaitClient(NetServer *pServeur)
{
    pServeur->WaitClient();
}

void    ThreadGarbageClient(NetServer *pServeur)
{
    pServeur->GarbageClient();
}

void    NetServer::Start(unsigned int iPort, ROUTINE pRoutine, unsigned int iLimit)
{
    BEGIN

    if(!conInfo)
        throw ERROR_C_ALREADY_START;

    conInfo = new NetConnect(crypt);
    conInfo->port = iPort;

    limit = iLimit;
    routineClient = pRoutine;

    if(SocketLoad())
        throw ERROR_C_LOAD_DLL;

    conInfo->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(conInfo->sock < 0)
        throw ERROR_C_INIT_CONNECT;

    memset(&conInfo->sockName, 0, sizeof(conInfo->sockName));
    conInfo->sockName.sin_port = htons(conInfo->port);
    conInfo->sockName.sin_family = AF_INET;
    conInfo->sockName.sin_addr.s_addr = INADDR_ANY;

    if(bind(conInfo->sock,(struct sockaddr*)&conInfo->sockName, sizeof(conInfo->sockName)))
        throw ERROR_C_BIND_CONNECT;

    if(listen(conInfo->sock, limit))
        throw ERROR_C_LISTEN;

    if(ThreadStart(&threadGarbage, (ROUTINE)ThreadGarbageClient, this))
        throw ERROR_C_THREAD;

    if(ThreadStart(&threadClients, (ROUTINE)ThreadWaitClient, this))
        throw ERROR_C_THREAD;

    ENDBEGIN
}

void    NetServer::Stop()
{
    if(conInfo)
    {
        delete conInfo;
        conInfo = NULL;
    }

    ThreadWait(&threadClients);

    while(clients.size())
        KillClientNo(0);
    clients.clear();

    ThreadWait(&threadGarbage);
}

void    NetServer::GarbageClient()
{
    unsigned int    i;
    BEGIN

    do
    {
        for(i = 0; i < clients.size(); i++)
        {
            if(!clients[i]->ip.size())
            {
                SocketClose(clients[i]->sock);

                if(clients[i]->crypt == NET_T_SSL)
                {
                    SSL_shutdown(clients[i]->sslFD);
                    SSL_free(clients[i]->sslFD);
                }

                ThreadWait(&(clients[i]->thread));

                clients.erase(clients.begin() + i);
            }
        }
        TempWait(NET_GARBAGE);
    }
    while(conInfo);

    ENDBEGINPRINT

    ThreadExit(0);
}

void    NetServer::WaitClient()
{
    unsigned int    lenght = 0, err = 0;
    BEGIN

    while(conInfo)
    {
        if(clients.size() < limit)
        {
            err = 0;
            clients.push_back(new NetConnect(crypt));
            lenght = sizeof(clients.back()->sockName);
            clients.back()->sock = accept(conInfo->sock, (struct sockaddr*)&clients.back()->sockName, (socklen_t *)&lenght);

            if(clients.back()->sock != -1)
            {
                unsigned char *pIp = (unsigned char *)&clients.back()->sockName.sin_addr.s_addr;
                clients.back()->ip = ItoA(pIp[0]);
                clients.back()->ip += ItoA(pIp[1]);
                clients.back()->ip += ItoA(pIp[2]);
                clients.back()->ip += ItoA(pIp[3]);

                if(crypt == NET_T_SSL)
                {
                    clients.back()->sslFD = SSL_new(sslCTX);
                    if( (!clients.back()->sslFD) ||
                        (SSL_set_fd(clients.back()->sslFD, clients.back()->sock) < 1) ||
                        (SSL_accept(clients.back()->sslFD) < 1)
                    )
                    {
                        SSL_shutdown(clients.back()->sslFD);
                        SSL_free(clients.back()->sslFD);
                        err = 1;
                    }
                }

                if(!err)
                    if(!ThreadStart(&clients.back()->thread, routineClient, (PARAMETRE)clients.back()))
                        err = 1;
            }
            else
                err = 1;

            if(err)
                clients.erase(clients.begin() + clients.size());
        }
        else
            TempWait(NET_WAIT_FULL);
    }

    ENDBEGINPRINT

    ThreadExit(0);
}

void    NetServer::KillClient(unsigned int iId)
{
    for(unsigned int i = 0; i < clients.size(); i++)
        if(clients[i]->GetId() == iId)
            clients[i]->ip = "";
}

void    NetServer::KillClientNo(unsigned int iNo)
{
    if(iNo < clients.size())
        clients[iNo]->ip = "";
}

---