Page principale | Liste alphabétique | Structures de données | Liste des fichiers | Champs de donnée | Portée globale | Pages associées

Référence de la classe ServeurConnect

#include <NetServeurConnect.h>


Fonctions membres publiques

 ServeurConnect ()
 ~ServeurConnect ()
int Start (char *NomFichier, ROUTINE Routine)
int Stop ()
int WaitClient ()
void DeconnectClient (int NoClient)

Champs de données

Connect * Clients

Fonctions membres privées

int LoadParameter (char *NomFichier)
int Menu ()
int Main ()
void ClientStats ()
int VerifAuth (int NoClient)

Attributs privés

SOCKET SockServ
SOCKADDR_IN AdrSockServ
int Port
int Limite
int NbClient
THREAD ThreadWait
int Waiting
ROUTINE RoutineGestionClient
int Running

Documentation des contructeurs et destructeur

ServeurConnect::ServeurConnect (   ) 
 

Définition à la ligne 16 du fichier NetServeurConnect.cpp.

00017 {
00018     SockServ    = 0;
00019     Port        = 2000;
00020     Limite      = 100;
00021     NbClient    = 0;
00022     Running     = 0;
00023     Waiting     = 0;
00024 }

ServeurConnect::~ServeurConnect (   ) 
 

Définition à la ligne 26 du fichier NetServeurConnect.cpp.

00027 {
00028     if(Running == 1)
00029         Stop();
00030 }

Documentation des fonctions membres

void ServeurConnect::ClientStats (   )  [private]
 

Définition à la ligne 255 du fichier NetServeurConnect.cpp.

00256 {
00257     MutexLock(&MutexEcran);
00258 
00259     ClearScreen();
00260     printf("Serveur en ecoute sur : %i\n\n", Port);
00261     for(int i = 0; i < Limite; i++)
00262         if(Clients[i].Running == 1)
00263             printf("IP : %s\tID : %i\n", Clients[i].Ip, i);
00264 
00265     printf("\nPressez entree pour le menu");
00266     fflush(stdin);
00267     getchar();
00268     
00269     MutexUnLock(&MutexEcran);
00270 }

void ServeurConnect::DeconnectClient (  int  NoClient  )  [inline]
 

Définition à la ligne 217 du fichier NetServeurConnect.cpp.

00218 {
00219     if(Clients[NoClient].Running == 1)
00220     {
00221         Clients[NoClient].Running   = 0;
00222         
00223         SocketClose(Clients[NoClient].Sock);
00224 
00225         PrintStats();
00226     }
00227     
00228     Clients[NoClient].Sock      = 0;
00229     Clients[NoClient].Thread    = NULL;
00230     *Clients[NoClient].Ip       = 0;
00231     memset(Clients[NoClient].Buffer, 0, TAILLE_BUFFER);
00232 }

int ServeurConnect::LoadParameter (  char *  NomFichier  )  [private]
 

Définition à la ligne 32 du fichier NetServeurConnect.cpp.

00033 {
00034     FILE *      Fichier;
00035     char        TempBuffer[TAILLE_BUFFER];
00036     BEGIN
00037 
00038     Fichier = fopen(NomFichier, "r");
00039     TRY if(Fichier)
00040     {
00041         while(!feof(Fichier))
00042         {
00043             if(fgets(TempBuffer, TAILLE_BUFFER, Fichier) != NULL)
00044             {
00045                 if(strcmp(gettok2(TempBuffer, 0, "=\n"), "PORT") == 0)
00046                     Port = AtoD(gettok2(TempBuffer, 1, "=\n"));
00047                     
00048                 if(strcmp(gettok2(TempBuffer, 0, "=\n"), "LIMITE") == 0)
00049                     Limite = AtoD(gettok2(TempBuffer, 1, "=\n"));
00050             }
00051         }
00052     }
00053     ENDTRY(2)
00054 
00055     fclose(Fichier);
00056 
00057     ENDBEGIN
00058 }

int ServeurConnect::Main (   )  [private]
 

Définition à la ligne 272 du fichier NetServeurConnect.cpp.

00273 {
00274     char    Key;
00275     BEGIN
00276 
00277     do
00278     {
00279         PrintStats();
00280     
00281         fflush(stdin);
00282         Key = getchar();
00283 
00284         switch(Key)
00285         {
00286             case    'l' :
00287                 ClientStats();
00288                 break;
00289             case    'a' :
00290                 MutexLock(&MutexEcran);
00291 
00292                 ClearScreen();
00293                 printf("\t------ Serveur GestionAsso V1.0a ------\n\n");
00294                 printf("\t par Aerith (aeris_vallee@hotmail.com)\n\n");
00295                 printf("\t    Sous Licence GPL  (www.gnu.org)\n\n\n");
00296                 printf("Pressez entree pour le menu");
00297                 fflush(stdin);
00298                 getchar();
00299 
00300                 MutexUnLock(&MutexEcran);
00301                 break;
00302         }
00303     }
00304     while((Key != 's') && !CERROR);
00305     
00306     ThreadWait(&ThreadServ);
00307 
00308     CERROR = Stop();
00309                 
00310     ENDBEGIN
00311 }

void ServeurConnect::Menu (   )  [private]
 

Définition à la ligne 234 du fichier NetServeurConnect.cpp.

00235 {
00236     NbClient = 0;
00237 
00238     for(int i = 0; (i < Limite); i++)
00239         if(Clients[i].Running == 1)
00240             NbClient++;
00241 
00242     MutexLock(&MutexEcran);
00243     
00244     ClearScreen();
00245     printf("Clients : %i/%i\n\n", NbClient, Limite);
00246     printf("--- Menu d'administration serveur ---\n");
00247     printf("\ts : stop le serveur\n");
00248     printf("\tl : liste les clients\n");
00249     printf("\ta : a propo de ce serveur\n\n");
00250     printf("  Choix : ");
00251     
00252     MutexUnLock(&MutexEcran);
00253 }

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

Définition à la ligne 65 du fichier NetServeurConnect.cpp.

00066 {
00067     BEGIN
00068 
00069     SocketLoad();
00070 
00071     TRY if(Running == 0)
00072     {
00073         Running = 1;
00074 
00075         CERROR = LoadParameter(NomFichier);
00076 
00077         TRY RoutineGestionClient = Routine;
00078 
00079         TRY if((SockServ = socket(AF_INET, SOCK_STREAM, 0)) != -1)
00080         {
00081             ZeroMemory(&AdrSockServ, sizeof(AdrSockServ));
00082             AdrSockServ.sin_family = AF_INET;
00083             AdrSockServ.sin_port = Port;
00084             AdrSockServ.sin_addr.s_addr = INADDR_ANY;
00085         }
00086         ENDTRY(3)
00087 
00088         TRY if(!bind(SockServ,(struct sockaddr*)&AdrSockServ,sizeof(AdrSockServ)))
00089         {
00090         }
00091         ENDTRY(4)
00092 
00093         TRY if(!listen(SockServ, Limite))
00094         {
00095             Clients = new Connect[Limite];
00096         }
00097         ENDTRY(5)
00098 
00099         TRY if(!ThreadStart(&ThreadWait, (ROUTINE)ThreadWaitClient, this))
00100             CERROR = Main();
00101         ENDTRY(18)
00102     }
00103     ENDTRY(15)
00104 
00105     if(CERROR && Running)
00106         Stop();
00107 
00108     ENDBEGIN
00109 }

int ServeurConnect::Stop (   ) 
 

Définition à la ligne 111 du fichier NetServeurConnect.cpp.

00112 {
00113     BEGIN
00114 
00115     TRY if(Running == 1)
00116     {
00117         Running = 0;
00118 
00119         for(int i = 0; i < Limite; i++)
00120             DeconnectClient(i);
00121 
00122         if(SockServ)
00123             SocketClose(SockServ);
00124         SocketUnLoad();
00125 
00126         delete [] Clients;
00127     }
00128     ENDTRY(16)
00129 
00130     printf("\n\n\t*** Serveur stoper ***\n");
00131 
00132     ENDBEGIN
00133 }

int ServeurConnect::VerifAuth (  int  NoClient  )  [private]
 

Définition à la ligne 192 du fichier NetServeurConnect.cpp.

00193 {
00194     BEGIN
00195 
00196     CERROR = Clients[NoClient].Receive();
00197 
00198     TRY if(AtoD(gettok2(Clients[NoClient].GetBuffer(), 0, " \n")) == IDENTIFIE)
00199     {
00200         if(strcmp(Pass, gettok2(Clients[NoClient].GetBuffer(), 1, " \n")) == 0)
00201         {
00202             sprintf(Clients[NoClient].GetBuffer(), "%i", IDENTIFIER);
00203             CERROR = Clients[NoClient].Send();
00204         }
00205         else
00206         {
00207             sprintf(Clients[NoClient].GetBuffer(), "%i", ERR_PASS);
00208             Send(NoClient);
00209             CERROR = 12;
00210         }
00211     }
00212     ENDTRY(13)
00213 
00214     ENDBEGIN
00215 }

int ServeurConnect::WaitClient (   ) 
 

Définition à la ligne 135 du fichier NetServeurConnect.cpp.

00136 {
00137     int     NoClient;
00138     char    Buffer[TAILLE_BUFFER];
00139     BEGIN LOC("ServeurConnect::WaitClient")
00140 
00141     TRY if(Waiting == 0)
00142     {
00143         while(Running == 1)
00144         {
00145             Waiting = 1;
00146 
00147             for(NoClient = 0; (NoClient < Limite) && (Clients[NoClient].Running); NoClient++);
00148 
00149             if(NoClient < Limite)
00150             {
00151                 Clients[NoClient].Sock = accept(SockServ,(struct sockaddr*)&Clients[NoClient].sockName,&Clients[NoClient].nameLength);
00152 
00153                 TRY if(Clients[NoClient].Sock != INVALID_SOCKET)
00154                     CERROR = VerifAuth(NoClient);
00155                 ENDTRY(6)
00156 
00157                 TRY
00158                 {
00159                     sprintf(Clients[NoClient].Ip, "%d.%d.%d.%d",
00160                         Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b1,
00161                         Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b2,
00162                         Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b3,
00163                         Clients[NoClient].sockName.sin_addr.S_un.S_un_b.s_b4
00164                     );
00165                     Clients[NoClient].Running = 1;
00166 
00167                     Menu();
00168                 }
00169 
00170                 TRY if(!ThreadStart(&Clients[NoClient].Thread, RoutineGestionClient, (PARAMETRE)NoClient))
00171                 {
00172                 }
00173                 ENDTRY(7)
00174             }
00175 
00176             if(CERROR)
00177             {
00178                 DeconnectClient(NoClient);
00179                 CERROR = 0;
00180             }
00181         }
00182         
00183         Waiting = 0;
00184     }
00185     ENDTRY(15)
00186 
00187     PERROR
00188 
00189     ThreadExit(CERROR);
00190 }

Documentation des champs

SOCKADDR_IN ServeurConnect::AdrSockServ [private]
 

Définition à la ligne 23 du fichier NetServeurConnect.h.

Connect* ServeurConnect::Clients
 

Définition à la ligne 63 du fichier NetServeurConnect.h.

int ServeurConnect::Limite [private]
 

Définition à la ligne 29 du fichier NetServeurConnect.h.

int ServeurConnect::NbClient [private]
 

Définition à la ligne 32 du fichier NetServeurConnect.h.

int ServeurConnect::Port [private]
 

Définition à la ligne 26 du fichier NetServeurConnect.h.

ROUTINE ServeurConnect::RoutineGestionClient [private]
 

Définition à la ligne 41 du fichier NetServeurConnect.h.

int ServeurConnect::Running [private]
 

Définition à la ligne 44 du fichier NetServeurConnect.h.

SOCKET ServeurConnect::SockServ [private]
 

Définition à la ligne 20 du fichier NetServeurConnect.h.

THREAD ServeurConnect::ThreadWait [private]
 

Définition à la ligne 35 du fichier NetServeurConnect.h.

int ServeurConnect::Waiting [private]
 

Définition à la ligne 38 du fichier NetServeurConnect.h.

La documentation de cette classe a été générée à partir des fichiers suivants:
Généré le Wed May 4 00:06:04 2005 pour Ressource par  doxygen 1.3.9.1