1. #include "stdafx.h"
2. #pragma comment(lib,"ws2_32.lib" )
3. /**==================[ Si Windows ]================**/
4. #if defined (WIN32) 
5. #include <winsock2.h>
7. /**================[ Si Gnu/Linux ]================**/
8. #elif defined (linux) 
10. #include <sys/types.h>
11. #include <sys/socket.h>
12. #include <netinet/in.h>
13. #include <arpa/inet.h>
14. #include <unistd.h>
16. #define INVALID_SOCKET -1
17. #define SOCKET_ERROR -1
19. #define closesocket(s) close (s)
20. typedef int SOCKET;
21. typedef struct sockaddr_in SOCKADDR_IN;
22. typedef struct sockaddr SOCKADDR;
24. /**===============[ Si Autre Systems ]==============**/
25. #else
26. #error not defined for this platform
27. #endif /**========[ Fin teste portabilite' ]========**/
29. /* Inclure les fichiers d'en-tete dont on a besoin */
30. #include <stdio.h>
31. #include <stdlib.h>
32. #include <string.h>
34. #define DEBUG 0 /** Aclive: 1,  Desactive: 0 **/
35. #define SERVER_PORT_LISTENING 10002
37. int App (void);
38. int ConnectWithClient ( SOCKET*, SOCKET* );
39. int CommunicatWithClient ( SOCKET );
40. int RecvData ( SOCKET socket, char *data );
43. /**************************************************************************
44. * Fonction main():
45. * La fonction principale ( le point d'entrer )...
46. ***************************************************************************/
47. int main (void)
48. {
49.    int flag_main_exit = EXIT_SUCCESS;
51. /**==================[ Si Windows ]================**/
52. #if defined (WIN32)
53.    WSADATA wsa_data;
54.    /* Si l'initialisation sous windows echoue */
55.    if ( WSAStartup (MAKEWORD (2, 2), &wsa_data) )
56.       return EXIT_FAILURE;
58.    puts ("Windows: winsock2: OK" );
59. #endif /**===========[ Fin teste Windows ]==========**/
62.    /* si app() retourne 1 c'est qu'elle a echoue' */
63.    if ( App () )
64.       flag_main_exit = EXIT_FAILURE;
67. /**==================[ Si Windows ]================**/
68. #if defined (WIN32)
69.    /* Fermer ce qu'on a initialiser avec WSAStartup */
70.    WSACleanup ();
71. #endif /**===========[ Fin teste Windows ]==========**/
73.    puts("\nFermeture du serveur ..." );
74.    getchar();
75.    return flag_main_exit;
76. }
79. /**************************************************************************
80. * Fonction App():
81. ** Le Serveur se connecte avec le client: ConnectToServer()
82. ** Si connexion etablie, passer a' la communication CommunicatWithClient()
83. ***************************************************************************/
84. int App (void)
85. {
86.    SOCKET sock, csock;
87.    int sock_err;
89.     if( ConnectWithClient (&csock, &sock) )
90.       return 1; /* retourne 1 s'il y eu probleme */
92.    if ( CommunicatWithClient(csock) )
93.       return 1; /* retourne 1 s'il y eu probleme */
95.    /* Fin de communication, fermer socket proprement */
96.    shutdown (sock, 2);   shutdown (csock, 2);
97.    sock_err = closesocket (sock), sock = INVALID_SOCKET;
98.    if (sock_err == SOCKET_ERROR)
99.    {
100.       perror("Error: sock.closesocket()" );
101.       return 1;
102.    }
104.    return 0;
105. }
109. /******************************************************************************
110. * Fonction: ConnectWithClient()
111. ** Connexion avec le client (avec sock), et recuperation d'infos
112. **        sur le client, sur csock ...
113. ******************************************************************************/
114. int ConnectWithClient ( SOCKET *csock, SOCKET *sock )
115. {
116.    /* Declaration de 2 structures de type SOCKADDR_IN */
117.    SOCKADDR_IN sin; /* pour le serveur */
118.    SOCKADDR_IN csin; /* pour le client */
120.    int sock_err, recsize;
122.    FILE* fichier = fopen("log.txt", "a" );
124.    /* ouverture du socket */
125.    if ( (*sock = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
126.    {
127.       perror("socket.open" );
128.       return 1; /* Creation du socket a echouer */
129.    }
131.    printf ("socket %d est maintenant ouvert en mode TCP/IP\n", *sock);
133.    sin.sin_addr.s_addr = htonl (INADDR_ANY); /* Pas besoin d'IP */
134.    sin.sin_port = htons (SERVER_PORT_LISTENING);  /* port d'ecoute */
135.    sin.sin_family = AF_INET;  /* famille du protocol (IP) */
137.    /* bind du socket serveur (sock) avec la structure sin du serveur */
138.    sock_err = bind (*sock, (SOCKADDR *) &sin, sizeof sin);
139.    if (sock_err == SOCKET_ERROR)
140.    {
141.       perror("Error: bind" );
142.       return 1;
143.    }
145.    /* ecoute sur le port */
146.    if ( (sock_err = listen (*sock, 5)) == SOCKET_ERROR)
147.    {
148.       perror("Error: listen" );
149.       return 1;
150.    }
151.    printf ("ecoute sur le port %d...\n", SERVER_PORT_LISTENING);
153.    /* attendre et accepter la connection du client en recuperant les infos
154.       sur le client dans csin, et en créant le socket du client csock */
155.    recsize = (int) sizeof csin;
156.    if( (*csock = accept(*sock, (SOCKADDR*) &csin, &recsize)) == INVALID_SOCKET)
157.    {
158.       perror("Error: accept" );
159.       return 1;
160.    }
161.    printf ("transmetteur connecte avec socket: %d    de: %s   port: %d\n",
162.                *csock,    inet_ntoa (csin.sin_addr)    ,htons (csin.sin_port));
164.    if(fichier != NULL)
165.    {
166.       fputs("-----------------------------------\n", fichier);
167.       fprintf(fichier, "transmetteur connecte avec socket: %d    de: %s   port: %d\n",
168.                *csock,    inet_ntoa (csin.sin_addr)    ,htons (csin.sin_port));
169.       fputs("-----------------------------------\n", fichier);
171.       fclose(fichier);
172.    }
174.    return 0;
175. }
179. /******************************************************************************
180. * Fonction: CommunicatWithClient()
181. ** Permet d'echanger des donnees avec le Client.   Recevoir ou Envoyer
182. ******************************************************************************/
183. int CommunicatWithClient ( SOCKET csock )
184. {
185.    char data[1024 + 1];
186.    int sock_err, err_close;
187.    FILE* fichier = fopen("log.txt", "a" );
189.    do
190.    {
191.       /* Attendre et recevoir des données envoyé par le client */
192.       if ( (sock_err = RecvData (csock, data)) == SOCKET_ERROR )
193.          break;
195.       else
196.       {
197.          data[sock_err] = '\0';
199.          printf("> %s\n", data);
201.          if(fichier != NULL)
202.             fprintf(fichier, "> %s\n", data);
203.       }
204.    }
205.    while (1);
207.    if(fichier != NULL)
208.       fclose(fichier);
210.    /* fermeture du socket client (csock), fin de la communication */
211.    shutdown (csock, 2);
212.    err_close = closesocket (csock), csock = INVALID_SOCKET;
213.    if (err_close == SOCKET_ERROR)
214.    {
215.       perror("Error: csock.closesocket()" );
216.       return 1;
217.    }
219.    return 0;
220. }
225. /******************************************************************************
226. * Fonction: RecvData()
227. ** Permet de recevoir proprement un Bloc de données
228. ** Retourne la taille de data reçu
229. ******************************************************************************/
230. int RecvData ( SOCKET sock, char *data )
231. {
232.    size_t len_data;
233.    size_t data_receved = 0;
234.    char textmode_lendata[255], *pend;
235.    int n;
237.    /* Recevoir la taille de data */
238.    n = recv(sock, textmode_lendata, sizeof textmode_lendata - 1, 0);
240.    if (n <= 0)
241.    {
242.       if( n == 0 )
243.          printf("Le transmetteur 'a Quitter...\n" );
244.       return SOCKET_ERROR;
245.    }
246.    else
247.    {
248.       textmode_lendata[n] = '\0';
249.       len_data = strtol (textmode_lendata, &pend, 10);
250.       if (*pend != '\n')
251.       {
252.          printf("Pas de donnees recues !\n" );
253.          return -1;
254.       }
255.    }
257.    /* TantQu'on as pas recu tout, on continue ... */
258.    while (data_receved < len_data)
259.    {
260.       n = recv (sock, data + data_receved, sizeof data - 1, 0);
262.       if (n > 0)
263.          data_receved += n;
264.       else
265.          return SOCKET_ERROR;
266.    }
268.    return ((int)data_receved);
269. }

data_receved = n - (pend - textmode_lendata);
memcpy(data, pend, data_receved);