NetServeurConnect.cpp

Aller à la documentation de ce fichier.

//##############################################################################
//#                                                                            #
//# fichier : ServeurConnect.cpp                        version : V2.0         #
//# projet  : ressource                                 date :  15/03/2005     #
//# par     : aerith                                                           #
//#                                                                            #
//# Methodes de la classe ServeurConnect                                       #
//#                                                                            #
//##############################################################################

#include    "ServeurConnect.h"
#include    "../portable/Tools.h"
#include    "../Erreurs.h"
#include    "../Protocol.h"

ServeurConnect::ServeurConnect()
{
    SockServ    = 0;
    Port        = 2000;
    Limite      = 100;
    NbClient    = 0;
    Running     = 0;
    Waiting     = 0;
}

ServeurConnect::~ServeurConnect()
{
    if(Running == 1)
        Stop();
}

int     ServeurConnect::LoadParameter(char *NomFichier)
{
    FILE *      Fichier;
    char        TempBuffer[TAILLE_BUFFER];
    BEGIN

    Fichier = fopen(NomFichier, "r");
    TRY if(Fichier)
    {
        while(!feof(Fichier))
        {
            if(fgets(TempBuffer, TAILLE_BUFFER, Fichier) != NULL)
            {
                if(strcmp(gettok2(TempBuffer, 0, "=\n"), "PORT") == 0)
                    Port = AtoD(gettok2(TempBuffer, 1, "=\n"));
                    
                if(strcmp(gettok2(TempBuffer, 0, "=\n"), "LIMITE") == 0)
                    Limite = AtoD(gettok2(TempBuffer, 1, "=\n"));
            }
        }
    }
    ENDTRY(2)

    fclose(Fichier);

    ENDBEGIN
}

int  ThreadWaitClient(ServeurConnect *pServeur)
{
    return pServeur->WaitClient();
}

int     ServeurConnect::Start(char *NomFichier, ROUTINE Routine)
{
    BEGIN

    SocketLoad();

    TRY if(Running == 0)
    {
        Running = 1;

        CERROR = LoadParameter(NomFichier);

        TRY RoutineGestionClient = Routine;

        TRY if((SockServ = socket(AF_INET, SOCK_STREAM, 0)) != -1)
        {
            ZeroMemory(&AdrSockServ, sizeof(AdrSockServ));
            AdrSockServ.sin_family = AF_INET;
            AdrSockServ.sin_port = Port;
            AdrSockServ.sin_addr.s_addr = INADDR_ANY;
        }
        ENDTRY(3)

        TRY if(!bind(SockServ,(struct sockaddr*)&AdrSockServ,sizeof(AdrSockServ)))
        {
        }
        ENDTRY(4)

        TRY if(!listen(SockServ, Limite))
        {
            Clients = new Connect[Limite];
        }
        ENDTRY(5)

        TRY if(!ThreadStart(&ThreadWait, (ROUTINE)ThreadWaitClient, this))
            CERROR = Main();
        ENDTRY(18)
    }
    ENDTRY(15)

    if(CERROR && Running)
        Stop();

    ENDBEGIN
}

int     ServeurConnect::Stop()
{
    BEGIN

    TRY if(Running == 1)
    {
        Running = 0;

        for(int i = 0; i < Limite; i++)
            DeconnectClient(i);

        if(SockServ)
            SocketClose(SockServ);
        SocketUnLoad();

        delete [] Clients;
    }
    ENDTRY(16)

    printf("\n\n\t*** Serveur stoper ***\n");

    ENDBEGIN
}

int     ServeurConnect::WaitClient()
{
    int     NoClient;
    char    Buffer[TAILLE_BUFFER];
    BEGIN LOC("ServeurConnect::WaitClient")

    TRY if(Waiting == 0)
    {
        while(Running == 1)
        {
            Waiting = 1;

            for(NoClient = 0; (NoClient < Limite) && (Clients[NoClient].Running); NoClient++);

            if(NoClient < Limite)
            {
                Clients[NoClient].Sock = accept(SockServ,(struct sockaddr*)&Clients[NoClient].sockName,&Clients[NoClient].nameLength);

                TRY if(Clients[NoClient].Sock != INVALID_SOCKET)
                    CERROR = VerifAuth(NoClient);
                ENDTRY(6)

                TRY
                {
                    sprintf(Clients[NoClient].Ip, "%d.%d.%d.%d",
                        Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b1,
                        Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b2,
                        Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b3,
                        Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b4
                    );
                    Clients[NoClient].Running = 1;

                    Menu();
                }

                TRY if(!ThreadStart(&Clients[NoClient].Thread, RoutineGestionClient, (PARAMETRE)NoClient))
                {
                }
                ENDTRY(7)
            }

            if(CERROR)
            {
                DeconnectClient(NoClient);
                CERROR = 0;
            }
        }
        
        Waiting = 0;
    }
    ENDTRY(15)

    PERROR

    ThreadExit(CERROR);
}

int     ServeurConnect::VerifAuth(int NoClient)
{
    BEGIN

    CERROR = Clients[NoClient].Receive();

    TRY if(AtoD(gettok2(Clients[NoClient].GetBuffer(), 0, " \n")) == IDENTIFIE)
    {
        if(strcmp(Pass, gettok2(Clients[NoClient].GetBuffer(), 1, " \n")) == 0)
        {
            sprintf(Clients[NoClient].GetBuffer(), "%i", IDENTIFIER);
            CERROR = Clients[NoClient].Send();
        }
        else
        {
            sprintf(Clients[NoClient].GetBuffer(), "%i", ERR_PASS);
            Send(NoClient);
            CERROR = 12;
        }
    }
    ENDTRY(13)

    ENDBEGIN
}

inline void ServeurConnect::DeconnectClient(int NoClient)
{
    if(Clients[NoClient].Running == 1)
    {
        Clients[NoClient].Running   = 0;
        
        SocketClose(Clients[NoClient].Sock);

        PrintStats();
    }
    
    Clients[NoClient].Sock      = 0;
    Clients[NoClient].Thread    = NULL;
    *Clients[NoClient].Ip       = 0;
    memset(Clients[NoClient].Buffer, 0, TAILLE_BUFFER);
}

void    ServeurConnect::Menu()
{
    NbClient = 0;

    for(int i = 0; (i < Limite); i++)
        if(Clients[i].Running == 1)
            NbClient++;

    MutexLock(&MutexEcran);
    
    ClearScreen();
    printf("Clients : %i/%i\n\n", NbClient, Limite);
    printf("--- Menu d'administration serveur ---\n");
    printf("\ts : stop le serveur\n");
    printf("\tl : liste les clients\n");
    printf("\ta : a propo de ce serveur\n\n");
    printf("  Choix : ");
    
    MutexUnLock(&MutexEcran);
}

void    ServeurConnect::ClientStats()
{
    MutexLock(&MutexEcran);

    ClearScreen();
    printf("Serveur en ecoute sur : %i\n\n", Port);
    for(int i = 0; i < Limite; i++)
        if(Clients[i].Running == 1)
            printf("IP : %s\tID : %i\n", Clients[i].Ip, i);

    printf("\nPressez entree pour le menu");
    fflush(stdin);
    getchar();
    
    MutexUnLock(&MutexEcran);
}

int     ServeurConnect::Main()
{
    char    Key;
    BEGIN

    do
    {
        PrintStats();
    
        fflush(stdin);
        Key = getchar();

        switch(Key)
        {
            case    'l' :
                ClientStats();
                break;
            case    'a' :
                MutexLock(&MutexEcran);

                ClearScreen();
                printf("\t------ Serveur GestionAsso V1.0a ------\n\n");
                printf("\t par Aerith (aeris_vallee@hotmail.com)\n\n");
                printf("\t    Sous Licence GPL  (www.gnu.org)\n\n\n");
                printf("Pressez entree pour le menu");
                fflush(stdin);
                getchar();

                MutexUnLock(&MutexEcran);
                break;
        }
    }
    while((Key != 's') && !CERROR);
    
    ThreadWait(&ThreadServ);

    CERROR = Stop();
                
    ENDBEGIN
}

---