Bonjour,
Je reçois des trames grace à ma socket cliente (qui doit être liée à une carte reseau), et renvoyer ces trames via une socket serveur (qui doit être liée à une autre carte reseau).
Voici mon code Source Client qui possede l'adresse IP d'un serveur :
/**********************************
THREAD POUR LA LECTURE DES TRAMES
***********************************/
//DWORD _stdcall Fthread(void*rien)
void FthreadClientAnglais(void *)
{
int continuer = TRUE;
int len;
char message[255];
int Nb_Caracteres_Recus;
char Message_Recu[255];
char szErr[255];
int intCheksum;
char strCheksum[1];
//SOCKET Desc_Socket_Cliente;
int Desc_Socket_Cliente;
SOCKADDR_IN Adresse_Socket_Serveur;
//WORD wVersionRequested;
WSADATA wsaData;
struct hostent *hostentptr;
//wVersionRequested=MAKEWORD(1,1);
strcpy(szErr,"Lancement de WSAStartup !\r\n");
printf("%s",szErr);
//WSAStartup(wVersionRequested,&wsaData);
//Init Winsock
if (WSAStartup(MAKEWORD(1,1),&wsaData)!=0)
{
printf("Impossible d'initialiser Winsok.\n\n");
}
else
{
printf("Winsock initialisé avec succès.\n\n");
}
strcpy(szErr,"Definition de la socket !\r\n");
printf("%s",szErr);
//getch();
Desc_Socket_Cliente=socket(AF_INET,SOCK_STREAM,0);
if (Desc_Socket_Cliente==INVALID_SOCKET)
printf("Erreur lors de la création de la socket : erreur %d.\n\n",WSAGetLastError());
else printf("Socket créée avec succès.\n\n");
strcpy(szErr,"Definition de la socket Terminée !\r\n");
printf("%s",szErr);
printf("IP du serveur Anglais Parametre : %s\n",ADRESSE_IP_SERVEUR_PARAMETRE);
printf("Port TCP Serveur Anglais : %d\n",Serveur_Anglais->intPortTCP);
hostentptr=gethostbyaddr
(
(const char *)ADRESSE_IP_SERVEUR_PARAMETRE,
4,
AF_INET
);
ZeroMemory(&Adresse_Socket_Serveur,sizeof(Adresse_Socket_Serveur));
Adresse_Socket_Serveur.sin_family=(*hostentptr).h_addrtype;
//Adresse_Socket_Serveur.sin_port=htons(PORT);
Adresse_Socket_Serveur.sin_port=htons(Serveur_Anglais->intPortTCP);
Adresse_Socket_Serveur.sin_addr=*((struct in_addr*)(*hostentptr).h_addr);
connect
(
Desc_Socket_Cliente,
(const struct sockaddr*)&Adresse_Socket_Serveur,
sizeof(Adresse_Socket_Serveur)
);
strcpy(szErr,"Attente Connexion du Serveur Anglais !\r\n");
printf("%s",szErr);
while(continuer)
{
Nb_Caracteres_Recus=recv
(
Desc_Socket_Cliente,
Message_Recu,
sizeof(Message_Recu),
0
);
printf("Nombre caractères reçus :%d\n",Nb_Caracteres_Recus);
if(Nb_Caracteres_Recus<=0)
{
continuer=FALSE;
}
else
{
strcpy(szErr,"Serveur Anglais CONNECTE !\r\n");
printf("%s",szErr);
indiquerTCP("CON");
strcpy(message,Message_Recu);
len=strlen(message);
SetTextColor(hDC,0x8F00);
SetBkColor(hDC,0);
Beep(500,100);
strcpy(szErr,message);
printf("%s\n",szErr);
intCheksum=fonctionCalculCsum(len,message);
_itoa(intCheksum,strCheksum,10);
//strCheksum[1]=0;
//Attribution de la Cheksum à la fin du message
strcat(message,strCheksum);
//len=strlen(message);
printf("Valeur cheksum : %d\n",intCheksum);
//Message_Francais_A_Emettre=message;
printf("Message : %s\n",message);
//printf("Message_Francais_A_Emettre : %s\n",Message_Francais_A_Emettre);
indiquerTCP_TRAMES_ANGLAISES(message);
indiquerTCP_TRAMES_FRANCAISE(message);
//ConvertirTRAMES_ANGLAISES_EN_TRAMES_FRANCAISE(message);
continuer=TRUE;
}
}
closesocket(Desc_Socket_Cliente);
WSACleanup();
indiquerTCP( "END" );
printf("\t\tOK:FIN RECEPTION TRAME SERVEUR ANGLAIS\r\n");
//return 0;
}
/***********************************/
BOOL DemarreClientpourServeurAnglais(void)
/***********************************/
{
DWORD ThreadId;
//HANDLE hThread;
ULONG hThread;
char szErr[255];
/*hThread = CreateThread
(
NULL,
0,
(LPTHREAD_START_ROUTINE)Fthread,
NULL,
0,
&ThreadId
);*/
hThread=_beginthread(FthreadClientAnglais,0,&ThreadId);
SetThreadPriority(HANDLE(hThread),THREAD_PRIORITY_HIGHEST);
strcpy(szErr,"Tache Serveur Anglais demarree\r\n");
printf("%s",szErr);
// <- GT
return TRUE;
}
Et voici mon code source du serveur avec lequel je dois renvoyer des trames sur les clients qui se connecteront.
#define Nb_Max_de_Client 10
/*************************************************/
void Fonction_Thread_Serveur(LPVOID param)
/*************************************************/
{
char strTaille[20];
//char *Message_Emis;
int intTailleMessage;
SOCKET Desc_Socket_Locale;
int fin=FALSE;
Desc_Socket_Locale=(SOCKET)param;
while(!fin)
{
//Pour tests ->
//printf("Reception message : %s",Message_Francais_A_Emettre);
// <- Pour tests
//Mettre une variable globale pour 'Message_Emis' ==> Message_Francais_A_Emettre
if (Message_Francais_A_Emettre!=NULL)
{
//Message_Emis="$VHFDF,C,01DF51DC,FBE00B2E,156800,1800,2*40";
printf("trame envoyee = %s\n",Message_Francais_A_Emettre);
//size_t intTailleMessage = sizeof(Message_Emis);
intTailleMessage = strlen(Message_Francais_A_Emettre);
send(Desc_Socket_Locale,Message_Francais_A_Emettre,intTailleMessage ,0);
_itoa(intTailleMessage ,strTaille,10);
//MessageBox(NULL,strTaille,"Taille de la trame",0);
Message_Francais_A_Emettre=NULL;
Sleep(5000);
//getch();
// GT Mis a vrai en temporaire ->
}
//fin=TRUE;
// <- GT Mis a vrai en temporaire
}
closesocket(Desc_Socket_Locale);
}
/*************************************************/
BOOL DemarreServeurFrancais(void)
/*************************************************/
{
int Code_Retour;
SOCKET Desc_Socket_Connection;
SOCKADDR_IN Adresse_Socket_Connection;
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested=MAKEWORD(1,1);
Code_Retour=WSAStartup(wVersionRequested,&wsaData);
if(Code_Retour!=0)
{
perror("WSAStartup\t");
//getch();
WSACleanup();
exit(errno);
}
printf("la version supportee est : %d.%d\n",
LOBYTE(wsaData.wHighVersion),
HIBYTE(wsaData.wHighVersion)
);
Desc_Socket_Connection=socket
(
AF_INET,
SOCK_STREAM,
0
);
printf("valeur de la socket = %d\n",Desc_Socket_Connection);
ZeroMemory(&Adresse_Socket_Connection,sizeof(Adresse_Socket_Connection));
Adresse_Socket_Connection.sin_family=AF_INET;
Adresse_Socket_Connection.sin_port=htons(Spationav->intPortTCP);
printf("Port TCP Client SPATIONAV : %d\n",Spationav->intPortTCP);
Code_Retour=bind
(
Desc_Socket_Connection,
(struct sockaddr*)&Adresse_Socket_Connection,
sizeof(Adresse_Socket_Connection)
);
if(Code_Retour!=0)
{
perror("bind\t");
//getch();
closesocket(Desc_Socket_Connection);
WSACleanup();
exit(errno);
}
Code_Retour=listen(Desc_Socket_Connection,Nb_Max_de_Client);
if(Code_Retour!=0)
{
perror("listen\n");
WSACleanup();
exit(errno);
}
printf("serveur Francais en attente d'une connection d'un client style SPATIONAV \n\n");
//printf("***************arret du serveur par<CTRL><C>**************\n\n");
//while(TRUE)
//do
{
SOCKET * pt_Nouveau_Socket_Serveur;
SOCKADDR_IN Adresse_Socket_Cliente;
int Longueur_Adresse;
HANDLE hthread;
DWORD threadID;
pt_Nouveau_Socket_Serveur = new SOCKET;
Longueur_Adresse = sizeof(Adresse_Socket_Cliente);
*pt_Nouveau_Socket_Serveur=accept
(
Desc_Socket_Connection,
(struct sockaddr*)&Adresse_Socket_Cliente,
&Longueur_Adresse
);
printf("connection accepte depuis le port client %d\n",
ntohs(Adresse_Socket_Cliente.sin_port));
hthread=CreateThread
(
NULL,
0,
(LPTHREAD_START_ROUTINE)Fonction_Thread_Serveur,
(LPVOID)*pt_Nouveau_Socket_Serveur,
0,
&threadID
);
}
//}while(TRUE);
return (0);
}
Comment puis-je associer mon client à une carte reseau et mon serveur à une autre carte reseau du même PC. (Je connais les 2 Adresses IP et les 2 ports TCP)
En esperant être assez clair.
Merci
Jeff.