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 ClientConnect

#include <NetClientConnect.h>


Fonctions membres publiques

 ClientConnect (int iNoInfo=0)
 ~ClientConnect ()
int LoadParameter (char *NomFichier)
int Start (char *NomFichier)
int Stop ()
int Send ()
int Receive ()
char * GetBuffer ()
int SetBufferManu (char *pBuffer)
int SetBufferSize (int iSize)
int SetBuffer (char *pBuffer)
int GetBufferSize ()

Fonctions membres privées

int Identifie ()
int ToWindow (char *Label, int Delai=0)

Attributs privés

SOCKET Sock
SOCKADDR_IN AdrSock
char Ip [TAILLE_IP]
char Pass [TAILLE_PASS]
int Port
char Buffer [TAILLE_BUFFER]
int BufferSize
int Running
int NoInfo

Documentation des contructeurs et destructeur

ClientConnect::ClientConnect (  int  iNoInfo = 0  ) 
 

Définition à la ligne 14 du fichier NetClientConnect.cpp.

00015 {
00016     NoInfo  = iNoInfo;
00017     Sock    = 0;
00018     strcpy(Ip, "localhost");
00019     Port    = 2000;
00020     strcpy(Pass, "");
00021     Running = 0;
00022     memset(Buffer, 0, TAILLE_BUFFER);
00023 }

ClientConnect::~ClientConnect (   ) 
 

Définition à la ligne 25 du fichier NetClientConnect.cpp.

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

Documentation des fonctions membres

char* ClientConnect::GetBuffer (   )  [inline]
 

Définition à la ligne 120 du fichier NetClientConnect.h.

00121     {
00122         return Buffer;
00123     };

int ClientConnect::GetBufferSize (   )  [inline]
 

Définition à la ligne 155 du fichier NetClientConnect.h.

00156     {
00157         return BufferSize;
00158     };

int ClientConnect::Identifie (   )  [private]
 

Définition à la ligne 119 du fichier NetClientConnect.cpp.

00120 {
00121     int     ErrorCode = 0;
00122 
00123     if(!NoInfo)
00124         ToWindow("Autentification ...", 1000);
00125 
00126     sprintf(Buffer, "%d %s\n", IDENTIFIE, Pass);
00127     BufferSize = strlen(Buffer);
00128 
00129     ErrorCode = Send();
00130 
00131     if(!ErrorCode)
00132         ErrorCode = Receive();
00133 
00134     if(!ErrorCode)
00135     {
00136         switch (AtoD(Buffer))
00137         {
00138             case    IDENTIFIER  :
00139                 break;
00140             case    ERR_PASS    :
00141                 ErrorCode = 12;
00142                 break;
00143             default :
00144                 ErrorCode = 13;
00145                 break;
00146         }
00147     }
00148 
00149     return ErrorCode;
00150 }

int ClientConnect::LoadParameter (  char *  NomFichier  ) 
 

Définition à la ligne 31 du fichier NetClientConnect.cpp.

00032 {
00033     FILE *      Fichier;
00034     char        BufferTemp[TAILLE_BUFFER];
00035     int         ErrorCode = 0;
00036 
00037     Fichier = fopen(NomFichier, "r");
00038     if(Fichier)
00039     {
00040         while(!feof(Fichier))
00041         {
00042             if(fgets(BufferTemp, TAILLE_BUFFER, Fichier) != NULL)
00043             {
00044                 if(strcmp(gettok2(BufferTemp, 0, "=\n"), "IP") == 0)
00045                     strcpy(Ip, gettok2(BufferTemp, 1, "=\n"));
00046                 if(strcmp(gettok2(BufferTemp, 0, "=\n"), "PORT") == 0)
00047                     Port = AtoD(gettok2(BufferTemp, 1, "=\n"));
00048                 if(strcmp(gettok2(BufferTemp, 0, "=\n"), "PASS") == 0)
00049                     strcpy(Pass, gettok2(BufferTemp, 1, "=\n"));
00050             }
00051         }
00052     }
00053     else
00054         ErrorCode = 2;
00055 
00056     fclose(Fichier);
00057 
00058     if(ErrorCode)
00059         ToWindow(GetError(ErrorCode));
00060 
00061     return ErrorCode;
00062 }

int ClientConnect::Receive (   )  [inline]
 

Définition à la ligne 99 du fichier NetClientConnect.h.

00100     {
00101         int ErrorCode = 0;
00102 
00103         if(!Sock)
00104             ErrorCode = 8;
00105         else
00106         {
00107             memset(Buffer, 0, TAILLE_BUFFER);
00108 
00109             if(Sock)
00110                 BufferSize = recv(Sock, Buffer, TAILLE_BUFFER, 0);
00111 
00112             if(!BufferSize)
00113                 ErrorCode = 8;
00114         }
00115 
00116         return ErrorCode;
00117     };

int ClientConnect::Send (   )  [inline]
 

Définition à la ligne 81 du fichier NetClientConnect.h.

00082     {
00083         int ErrorCode = 0;
00084 
00085         if(!Sock)
00086             ErrorCode = 8;
00087         else
00088         {
00089             BufferSize = send(Sock, Buffer, BufferSize, 0);
00090 
00091             if(!BufferSize)
00092                 ErrorCode = 8;
00093         }
00094 
00095         return ErrorCode;
00096     };

int ClientConnect::SetBuffer (  char *  pBuffer  )  [inline]
 

Définition à la ligne 146 du fichier NetClientConnect.h.

00147     {
00148         SetBufferSize(strlen(pBuffer));
00149         SetBufferManu(pBuffer);
00150 
00151         return BufferSize;
00152     };

int ClientConnect::SetBufferManu (  char *  pBuffer  )  [inline]
 

Définition à la ligne 126 du fichier NetClientConnect.h.

00127     {
00128         memset(Buffer, 0, TAILLE_BUFFER);
00129         memcpy(Buffer, pBuffer, BufferSize);
00130 
00131         return BufferSize;
00132     };

int ClientConnect::SetBufferSize (  int  iSize  )  [inline]
 

Définition à la ligne 135 du fichier NetClientConnect.h.

00136     {
00137         if(iSize > TAILLE_BUFFER)
00138             BufferSize = TAILLE_BUFFER;
00139         else
00140             BufferSize = iSize;
00141 
00142         return BufferSize;
00143     };

int ClientConnect::Start (  char *  NomFichier  ) 
 

Définition à la ligne 64 du fichier NetClientConnect.cpp.

00065 {
00066     struct      hostent *hostentptr;
00067     char        BufferTemp[TAILLE_BUFFER];
00068     int         ErrorCode = 0;
00069     SocketLoad();
00070 
00071     if(Running == 0)
00072     {
00073         Running = 1;
00074         *BufferTemp = 0;
00075 
00076         ErrorCode = LoadParameter(NomFichier);
00077         if(!ErrorCode)
00078         {
00079             if((Sock = socket(AF_INET,SOCK_STREAM,0)) != -1)
00080             {
00081                 if((hostentptr = gethostbyname(Ip)) != NULL)
00082                 {
00083                     ZeroMemory(&AdrSock, sizeof(AdrSock));
00084                     AdrSock.sin_family = (*hostentptr).h_addrtype;
00085                     AdrSock.sin_port = Port;
00086                     AdrSock.sin_addr = *((struct in_addr *)(*hostentptr).h_addr);
00087 
00088                     if(!NoInfo)
00089                     {
00090                         sprintf(BufferTemp, "Connexion a %s:%d ...", Ip, Port);
00091                         ToWindow(BufferTemp, 1000);
00092                     }
00093 
00094                     if(!connect(Sock, (const struct sockaddr *) &AdrSock, sizeof(AdrSock)))
00095                     {
00096                         ErrorCode = Identifie();
00097                         if(!ErrorCode && !NoInfo)
00098                             ToWindow("Connection etablie", 1000);
00099                     }
00100                     else
00101                         ErrorCode = 11;
00102                 }
00103                 else
00104                     ErrorCode = 10;
00105             }
00106             else
00107                 ErrorCode = 3;
00108         }
00109     }
00110     else
00111         ErrorCode = 15;
00112 
00113     if(ErrorCode)
00114         Stop();
00115 
00116     return ErrorCode;
00117 }

int ClientConnect::Stop (   ) 
 

Définition à la ligne 152 du fichier NetClientConnect.cpp.

00153 {
00154     int     ErrorCode = 0;
00155 
00156     if(Running == 1)
00157     {
00158         Running = 0;
00159 
00160         if(Sock)
00161             SocketClose(Sock);
00162         SocketUnLoad();
00163     }
00164     else
00165         ErrorCode = 16;
00166 
00167     return ErrorCode;
00168 }

int ClientConnect::ToWindow (  char *  Label,
int  Delai = 0
)  [private]
 

Définition à la ligne 170 du fichier NetClientConnect.cpp.

00171 {
00172     #ifndef nogtk
00173         GtkWidget   *pWindow;
00174         GtkWidget   *pLabel;
00175 
00176         pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
00177         gtk_window_set_title(GTK_WINDOW(pWindow), "Etat connection");
00178         gtk_window_set_default_size(GTK_WINDOW(pWindow), 300, 50);
00179         gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
00180 
00181         pLabel = gtk_label_new(_(Text));
00182         gtk_container_add(GTK_CONTAINER(pWindow), pLabel);
00183 
00184         gtk_widget_show_all(pWindow);
00185 
00186         g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
00187 
00188         if(Delai)
00189             g_timeout_add(Delai, (GSourceFunc)KillWindow, NULL);
00190 
00191         gtk_main();
00192 
00193         if(GTK_IS_WIDGET(pWindow))
00194             gtk_widget_destroy(pWindow);
00195     #else
00196         printf("%s\n", Text);
00197 
00198         if(Delai)
00199             Sleep(Delai);
00200     #endif
00201 
00202     return 0;
00203 }

Documentation des champs

SOCKADDR_IN ClientConnect::AdrSock [private]
 

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

char ClientConnect::Buffer[TAILLE_BUFFER] [private]
 

Définition à la ligne 47 du fichier NetClientConnect.h.

int ClientConnect::BufferSize [private]
 

Définition à la ligne 50 du fichier NetClientConnect.h.

char ClientConnect::Ip[TAILLE_IP] [private]
 

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

int ClientConnect::NoInfo [private]
 

Définition à la ligne 56 du fichier NetClientConnect.h.

char ClientConnect::Pass[TAILLE_PASS] [private]
 

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

int ClientConnect::Port [private]
 

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

int ClientConnect::Running [private]
 

Définition à la ligne 53 du fichier NetClientConnect.h.

SOCKET ClientConnect::Sock [private]
 

Définition à la ligne 32 du fichier NetClientConnect.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