[C/Socket]Programmer un proxy

Programmer un proxy [C/Socket] - C - Programmation

Marsh Posté le 08-04-2006 à 20:02:26    

Salut all, je cherche de la doc sur comment programmez un proxy minimal sans cache ou autre fioriture.
J'ai bien une idée, ouvrir deux sockets en parallèle (multithreading) de cette façon mais je ne suis pas du tout sur:
client -> socket 1 -> serveur
client <- socket 2 <- serveur
 
Donc avant de me lancer dans l'inconnu je vous demande de l'aide: des sources courtes ou des tutos.
merci :jap:

Reply

Marsh Posté le 08-04-2006 à 20:02:26   

Reply

Marsh Posté le 08-04-2006 à 23:55:03    

c'est un poil plus compliqué: il faut que tu lise la requête HTTP, et que tu envoye cette requête au serveur désignée dans la requête. Une fois la connexion effectuée tu lit les données reçues pour les transmettre au navigateur (socket en lecture/écriture, donc).
Le shemas ressemble plus à ça:
client <---> proxy <----> serveur
 
Note que certaines options dans les entêtes sont utiles (genre connexion:close), et que tu doit aussi envoyer les cookies, les formulaires et les fichiers joints.

Reply

Marsh Posté le 09-04-2006 à 17:11:00    

Pourquoi est ce qu'il est nécessaire de lire l'entête http?
Dans le cas d'utilisation d'un proxy l'adresse ip de destination est celle du proxy ou celle du site web?
L'entête est directement envoyé par le navigateur j'aurai pensé que le proxy l'envoyais directement sans traitement vers le site web.
Autre question: suivant ton schéma comment faire pour traiter en parallèle  les envois et les réponses, je pense que je suis obligé d'utiliser les threads non?
Merci de ton aide (PS: si t'as des sources je suis preneur)

Reply

Marsh Posté le 09-04-2006 à 18:15:20    

tiens j'avais fais un proxy smtp si ça peut t'aider, ya le source en C et le rapport ici :
http://kaiserzipo.free.fr/web/.dir [...] eseau&3=TP
 
et effectivement tu utilises plusieurs threads ;)


Message édité par Zipo le 09-04-2006 à 18:15:50

---------------
- mon feed-back
Reply

Marsh Posté le 09-04-2006 à 18:45:00    

Citation :


Pourquoi est ce qu'il est nécessaire de lire l'entête http?
Dans le cas d'utilisation d'un proxy l'adresse ip de destination est celle du proxy ou celle du site web?
L'entête est directement envoyé par le navigateur j'aurai pensé que le proxy l'envoyais directement sans traitement vers le site web.


 
Au niveau TCP, le navigateur envoye la requête au proxy, et non pas au serveur. C'est au proxy de prendre en charge la requête, et donc pour contacter le serveur il devra lire l'entête. Certaines options sur les sockets peuvent être fixées par le navigateur ou le serveur: par exemple les temps d'attente maximums. Le proxy devra en tenir compte. Je ne peut pas te donner une liste exhaustive des options d'entête qu'il te faudra traiter, mais tu trouvera plein de doc sur le web.
 

Citation :


Autre question: suivant ton schéma comment faire pour traiter en parallèle  les envois et les réponses, je pense que je suis obligé d'utiliser les threads non?


 
Tout à fait, la structure principale d'une proxy est la même que celle d'un serveur web!
 

Citation :


Merci de ton aide (PS: si t'as des sources je suis preneur)


 
Il y a plein de proxys en open source, une petite recherche sur le net et tu trouvera ton bonheur. Même si souvent ces proxys tournent sur Unix, tu peut les adapter pour Windows.
 
La meilleure source que tu puisse avoir c'est celle du serveur Apache sur apache.org!
 
Bon courage :)
 
(rem: c'est pas si dur, mais c'est long, j'avais fait un serveur web compatible HTTP/1.1, j'y avais intégré la plupart des gestion d'entêtes, mais il m'a fallu 6 mois)

Reply

Marsh Posté le 09-04-2006 à 19:43:50    

J'ai bien essayé de regarder des logiciels open, j'ai télécharger les sources de squid mais bon faut avoir un certain niveau, je maitrise bien le C/C++ et d'autre langage mais lire un tel projet c'est chaud.

Reply

Marsh Posté le 09-04-2006 à 20:24:36    

Entraîne toi sur le forum, debugger les programmes des autres c'est pas toujours évident.

Reply

Marsh Posté le 10-04-2006 à 09:51:25    

J'ai une petite idée d'algo, qu'en pensez vous? :

Code :
  1. Creer un nouveau thread à chaque nouvelle connexion
  2. recevoir paquet
  3. Analyser l'header http
  4. sortir le host
  5. envoyer le paquet vers host
  6. attendre réponse
  7. renvoyer la réponse au client

Reply

Marsh Posté le 10-04-2006 à 09:57:36    

C'est un bon début.

Reply

Marsh Posté le 12-04-2006 à 22:35:18    

J'ai créer un bou de code qui fonctionne a peu près, mais il y a beaucoup de bugs que je ne comprend, les connexions foires au bout d'un moment et j'ai beaucoup de bug d'affichage à croire que tout le code des pages web n'est pas transmit.
Si des âmes charitables veulent bien le tester  :jap: :
Pour configurer, dans firefox: paramètre de connexion -> proxy 127.0.0.1 port 3080
adresse pour télécharger directement: http://membres.lycos.fr/bobov/code/main.c
ou ici:

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <windows.h>
  5. #include <winsock2.h>
  6. #pragma comment(lib, "ws2_32.lib" )
  8. /**************
  9. * prototypes *
  10. **************/
  11. char * get_host(char * httpRequest);
  12. int proxy(SOCKET socket_client);
  14. /*************
  15. * functions *
  16. *************/
  18. /*
  19. * get_host()
  20. * fonction qui isole le header http (Host:)
  21. */
  23. char * get_host(char * httpRequest){
  24. unsigned short i = 0, j = 0;
  25. char * buffer = strstr(httpRequest, "Host: " );
  26. char * host = (char *)malloc(256 * sizeof(char));
  27. while( buffer[i] != '\n' )
  28.  i++;
  29. for(j = 6; j < i-1; j++)
  30.  host[j - 6] = buffer[j];
  31. host[j-6+1] = '\0';
  32. return host;
  33. }
  36. /*
  37. * proxy()
  38. */
  40. int proxy(SOCKET socket_client){
  41. SOCKET envoi;
  43.   SOCKADDR_IN server2;
  44.   struct hostent * structHost;
  47. char buffer[1024];
  48. char buffer2[1024*1024]; // 1 ko
  51. memset(buffer,'\0',sizeof(buffer));
  53. // On recoit la requete du navigateur
  55. int size = recv(socket_client, buffer, sizeof(buffer), 0);
  59.   printf("size : %d \r\n", size);
  61.   fprintf(stdout, "----\r\n%s----\r\n", buffer);
  63. // On récupère le header (Host:) de la requete  
  64. // pour pouvoir se connecter au serveur web
  66. char * host = get_host(buffer);
  67. printf("Host : [%s]\r\n", get_host(buffer));
  69. // On envoie la requete au serveur web
  70. // grace a un nouveau socket
  71.   if((structHost = gethostbyname(host)) == NULL){
  72.   fprintf(stderr,"Host error\n" );
  73. }
  75.   if((envoi = socket(AF_INET, SOCK_STREAM, 0)) == -1){
  76.  printf("socket error\r\n" );
  77. }
  79.     server2.sin_family = AF_INET;
  80.     server2.sin_port   = htons(80);
  81.  server2.sin_addr   = *((struct in_addr *)structHost->h_addr);
  82.  memset(&(server2.sin_zero),'\0',8);
  84.     if( connect(envoi,(struct sockaddr * )&server2,sizeof(struct sockaddr)) == -1){
  85.         printf("error connect\r\n" );
  86.         return -1;
  87.     }
  88.     send(envoi, buffer, strlen(buffer), 0);
  89.     memset(buffer2,'\0',sizeof(buffer2));
  91. // Reception des donnees a partir du serveur
  92. // et les renvoies au navigateur
  93.    while( (size = recv(envoi,buffer2,sizeof(buffer2),0)) != 0){
  94.     buffer2[size] = '\0';
  95.     fprintf(stdout, "%s", buffer2);
  96.     // Renvoie de la réponse au navigateur
  97.     send(socket_client, buffer2,strlen(buffer2),0);
  98.     memset(buffer2,'\0',sizeof(buffer2));
  99.    }
  101. //Nettoyage
  102.     closesocket(socket_client);
  103.     WSACleanup();
  104.     ExitThread(0);
  105.     return 0;
  106. }
  108. /**********
  109. * main() *
  110. **********/
  111. int main(int argc, char * argv[]){
  113. // Initialisation  
  114.     WSADATA WSAData;
  115.     WSAStartup(MAKEWORD(2,0), &WSAData);
  117. // Variables
  118.     SOCKET socket_local;
  119.     SOCKET socket_client;
  121.     SOCKADDR_IN server;
  122.     SOCKADDR_IN client;
  124.     DWORD  dwThreadID;
  128.     int sin_size = sizeof(SOCKADDR_IN);
  129.     socket_local = socket(AF_INET,SOCK_STREAM,0);
  131. // Configuration du proxy (port 3080)
  133.         server.sin_family      = AF_INET;
  134. server.sin_port        = htons(3080);
  135. server.sin_addr.s_addr = INADDR_ANY;
  136. memset(&(server.sin_zero),'\0',8);
  138.     bind(socket_local,(struct sockaddr * )&server,sizeof(struct sockaddr));
  140.     listen(socket_local,5);
  142. // Attente de connexion
  144. while(1)
  145. {
  146.  if( (socket_client = accept(socket_local,(struct sockaddr * )&client,&sin_size)) == -1)
  147.  {
  148.    fprintf(stderr, "Accept error.Error: %d\n", WSAGetLastError());
  149.    closesocket(socket_client);
  150.    WSACleanup();
  151.    return 1;
  152.  }
  153.  else
  154.  {
  155.   fprintf(stdout,"Connection de : %s \n",inet_ntoa(client.sin_addr));
  156. // On cree un thread par nouvelle connexion en
  157. // appelant la fonction proxy avec comme paramètre le socket client
  158.   CreateThread( NULL,
  159.      0,
  160.      (LPTHREAD_START_ROUTINE) proxy,
  161.      socket_client,
  162.      0,
  163.      &dwThreadID);
  164.  }
  165. }
  166.     return 0;
  167. }
  168. }


Edit: commentaires sur le code ajouté.


Message édité par psyphi le 14-04-2006 à 15:31:49
Reply

Marsh Posté le 12-04-2006 à 22:35:18   

Reply

Marsh Posté le 12-04-2006 à 22:40:22    

on sent que tu aimes commenter ton code toi :d

Message cité 1 fois
Message édité par Zipo le 12-04-2006 à 22:40:45

---------------
- mon feed-back
Reply

Marsh Posté le 12-04-2006 à 22:42:24    

:sweat: C'est vrai que je ne l'ai pas super commenté, généralement je commente mon code quand je sais que j'aurai des problèmes en le relisant mais la le principe est connu donc j'ai pas beaucoup commenté. Mais je vais corriger ca par la suite.  :D

Reply

Marsh Posté le 13-04-2006 à 01:41:16    

Zipo a écrit :

on sent que tu aimes commenter ton code toi :d


Il y a le minimum vital... Si on connait le sujet, il n'y pas trop de mystères...


---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 14-04-2006 à 15:27:48    

Voila j'ai édité mon message précédent et commenté mon code ;)

Reply

Marsh Posté le 18-04-2006 à 15:15:43    

J'ai fait une mise à jour du code proper et commenté cette fois ci, mais mon proxy ne fonctionne pas avec les images, qqun peut il m'aider?
Lien direct vers le .c : http://membres.lycos.fr/bobov/code/main.c  
(Configuration du navigateur: 127.0.0.1:8080)

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include <windows.h>
  6. #include <winsock2.h>
  7. #pragma comment(lib, "ws2_32.lib" )
  9. /**************
  10. * prototypes *
  11. **************/
  13. void display_error(char * errorType);
  14. char * get_host(char * httpRequest);
  15. int proxy(SOCKET socket_client);
  17. /*************
  18. * functions *
  19. *************/
  21. /*
  22. * display_error()
  23. */
  24. void display_error(char * errorType){
  25. LPVOID lpMsgBuf;
  26. FormatMessage(  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  27.     NULL,
  28.     GetLastError(),
  29.     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  30.     (LPTSTR) &lpMsgBuf,
  31.     0,
  32.     NULL);
  34. // Affichage du message dans une boite de dialogue
  35. MessageBox( NULL, lpMsgBuf, errorType, MB_OK | MB_ICONERROR );
  36. // Libération du buffer
  37. LocalFree( lpMsgBuf );
  38. }
  40. /*
  41. * get_host()
  42. * fonction qui isole le header http (Host:)
  43. */
  44. char * get_host(char * httpRequest){
  45. unsigned short i = 0, j = 0;
  47. char * buffer = strstr(httpRequest, "Host: " );
  48. char * host = (char *)malloc(256 * sizeof(char));
  49. memset(host, '\0', sizeof(host));
  51. while( buffer[i] != '\n' )
  52.  i++;
  54. for(j = 6; j < i-1; j++)
  55.  host[j - 6] = buffer[j];
  56. host[j-6+1] = '\0';
  58. return host;
  59. }
  61. /*
  62. * proxy()
  63. */
  64. int proxy(SOCKET socket_client){
  65. SOCKET envoi;
  66. SOCKADDR_IN server2;
  67. struct hostent * structHost;
  69. char buffer[1024*10]; // 10 ko
  70. char buffer2[1024*50]; // 50 ko
  72. memset(buffer,'\0', sizeof(buffer));
  73. memset(buffer2,'\0', sizeof(buffer));
  75. // On recoit la requete du navigateur
  76. int size = recv(socket_client, buffer, sizeof(buffer), 0);
  78. fprintf(stdout, "----Commande recue ----\r\n%s----\r\n", buffer);
  80. // On récupère le header (Host:) de la requete
  81. // pour pouvoir se connecter au serveur web
  82. char * host = get_host(buffer);
  83. //fprintf(stdout,"Host : [%s]\r\n", get_host(buffer));
  85. // On envoie la requete au serveur web
  86. // grace a un nouveau socket
  87. if((structHost = gethostbyname(host)) == NULL){
  88.   fprintf(stderr,"Host error\r\n" );
  89.   display_error("Host error !" );
  90.   return -1;
  91. }
  93. if((envoi = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET){
  94.  fprintf(stderr, "Socket error. Error: %d\r\n", WSAGetLastError());
  95.         display_error("Socket error !" );
  96.         return -1;
  97. }
  99.     server2.sin_family = AF_INET;
  100. server2.sin_port   = htons(80);
  101. server2.sin_addr   = *((struct in_addr *)structHost->h_addr);
  102. memset(&(server2.sin_zero),'\0',8);
  104.     if( connect(envoi,(struct sockaddr * )&server2,sizeof(struct sockaddr)) == -1){
  105.         fprintf(stderr,"Error connect\r\n" );
  106.         display_error("Connect Error !" );
  107.         return -1;
  108.     }
  110.     send(envoi, buffer, strlen(buffer), 0);
  112. // Reception des donnees a partir du serveur
  113. // et les renvoies au navigateur
  114.    while( (size = recv(envoi,buffer2,sizeof(buffer2),0)) != 0){
  115.     buffer2[size] = '\0';
  116.     //fprintf(stdout, "%s", buffer2);
  117. // Renvoie de la réponse au navigateur
  118.     send(socket_client, buffer2,strlen(buffer2),0);
  119.     memset(buffer2,'\0',sizeof(buffer2));
  120.    }
  122. //Nettoyage
  123.     closesocket(socket_client);
  124.     fprintf(stdout, "Exiting Thread.\r\n" );
  125.     ExitThread(0);
  127.     return 0;
  128. }
  130. /**********
  131. * main() *
  132. **********/
  133. int main(int argc, char * argv[]){
  135. // Initialisation
  136.     WSADATA WSAData;
  137. if( WSAStartup(MAKEWORD(2,0),&WSAData) != 0 )
  138.     {
  139.         fprintf(stderr, "WSAStartup error. Error: %d\r\n", WSAGetLastError());
  140.         display_error("WSAStartup error !" );
  141.         return 1;
  142.     }
  144. // Variables
  145.     SOCKET socket_local;
  146.     SOCKET socket_client;
  148.     SOCKADDR_IN server;
  149.     SOCKADDR_IN client;
  151. DWORD  dwThreadID;
  153.     int sin_size = sizeof(SOCKADDR_IN);
  155.     if( (socket_local = socket(AF_INET,SOCK_STREAM,0) ) == INVALID_SOCKET )
  156.     {
  157.         fprintf(stderr, "Socket error. Error: %d\r\n", WSAGetLastError());
  158.         display_error("Socket error !" );
  159.  WSACleanup();
  160.         return 1;
  161.     }
  163. // Configuration du proxy (port 8080)
  164. server.sin_family      = AF_INET;
  165. server.sin_port        = htons(8080);
  166. server.sin_addr.s_addr = INADDR_ANY;
  167. memset(&(server.sin_zero),'\0',8);
  169.     if( bind(socket_local,(struct sockaddr * )&server,sizeof(struct sockaddr)) == SOCKET_ERROR)
  170.     {
  171.  fprintf(stderr, "Bind error. Error: %d\r\n", WSAGetLastError());
  172.         display_error("Bind error !" );
  173.  closesocket(socket_client);
  174.  WSACleanup();
  175.         return 1;
  176.     }
  178.     listen(socket_local, SOMAXCONN);
  180. // Attente de connexion, si erreur on quitte le programme
  181. while(1)
  182. {
  183.  if( (socket_client = accept(socket_local,(struct sockaddr * )&client,&sin_size)) == INVALID_SOCKET )
  184.  {
  185.    fprintf(stderr, "Accept error.Error: %d\r\n", WSAGetLastError());
  186.    display_error("Accept error !" );
  187.    closesocket(socket_client);
  188.    WSACleanup();
  189.    return 1;
  190.  }
  191.  else
  192.  {
  193.   fprintf(stdout,"Connection de : %s \n",inet_ntoa(client.sin_addr));
  194. // On cree un thread par nouvelle connexion en
  195. // appelant la fonction proxy avec comme paramètre le socket client
  196. // Si erreur a la creation d un thread on quitte
  197.   if( CreateThread( NULL,
  198.        0,
  199.        (LPTHREAD_START_ROUTINE) proxy,
  200.        socket_client,
  201.        0,
  202.        &dwThreadID) == NULL )
  203.   {
  204.    fprintf(stderr, "CreateThread error.\r\n" );
  205.    display_error("CreateThread error !" );
  206.    return 1;
  207.   }
  208.  }
  209. }
  210.     return 0;
  211. }


Merci d'avance  :)

Reply

Marsh Posté le 18-04-2006 à 15:21:58    

oui! parceque les navigateurs moderne ne demandent pas l'image en entier. Ils en font la demande au serveur bout par bout, selon l'affichage necessaire. Par exemple, si l'internaute va directement au bas de la page, le téléchargement des images du haut de la page est interrompu après le bout courant et sera repris en dernier.
 
La  demande partiel est, il me semble le code HTTP 304. Tu doit le traiter spécialement.
 
Comme quoi, je t'avais dit, c'est pas aussi évident... :D Mais tu es sur la bonne voie.


Message édité par nargy le 18-04-2006 à 15:24:17
Reply

Marsh Posté le 18-04-2006 à 15:23:40    

heu non, c'est pas le code 304. là je me souviens plus. tu devrais le trouver sur le web.


Message édité par nargy le 18-04-2006 à 15:24:42
Reply

Marsh Posté le 18-04-2006 à 15:40:01    

:sweat:  :cry: ouin je pensais pas que c'était si dur que ça.
En tout cas heureusement que tu me dis ça car j'en pouvais de chercher sans comprendre, je pensais que ca venait de mon code.
Ou est ce que je vais trouver ce code spécifique dans les RFC ?

Reply

Marsh Posté le 18-04-2006 à 16:05:49    

> Ou est ce que je vais trouver ce code spécifique dans les RFC ?
- heu je l'avais trouvé, j'ai un poil la flemme de rechercher là. pourtant je l'ai presque sous les yeux, dans mes logs c'est affiché quelquepart. si, si, je t'assure :lol:
- indice: fait un debug de l'entête totale envoyée par le navigateur au proxy (jusqu'au double \n\n)

Reply

Marsh Posté le 18-04-2006 à 16:09:06    

ha tiens: 206 Partial Content

Reply

Marsh Posté le 18-04-2006 à 16:10:21    

Reply

Marsh Posté le 18-04-2006 à 17:21:03    

C'est quand même bizarre cette histoire je viens de trouver une autre source de proxy (enfin ! lol) et il ne gère nul part le 206 Partial Content et pourtant quand j'utilise son proxy avec la dernière version de firefox les images s'affichent.
source: http://www.cppfrance.com/code.aspx?ID=10846
Est ce que cela peut venir de mes threads?

Reply

Marsh Posté le 18-04-2006 à 17:30:29    

Effectivement je reviens de faire un test, en utilisant un buffer de 1 octets (char) au lieu de 1ko (char buffer2[1024]) pour la reception des données du serveur et cette fois les images s'affiches :-|.
C'est quand même bizarre ca. Faut que je trouve une solution car des buffers de 1octets pour le transfert c'est pas cool.


Message édité par psyphi le 18-04-2006 à 17:31:18
Reply

Marsh Posté le 20-04-2006 à 22:00:03    

Reply

Marsh Posté le 21-04-2006 à 10:32:35    

J'ai fait une grosse mise à jour du code, finis les gros plantage! :)  
Problème restant, navigation lente sur certain site, impossible de naviger sur certain site, le logiciel freeze par moment, il reste coincé dans la boucle de download.  :sweat:  
Tout est ici: http://www.cppfrance.com/codes/WIN [...] 37134.aspx
la source:

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include <windows.h>
  6. #include <winsock2.h>
  7. #pragma comment(lib, "ws2_32.lib" )
  9. /**************
  10. * prototypes *
  11. **************/
  13. void display_error(char * errorType);
  14. char * get_host(char * httpRequest);
  15. void cut_host_and_port(char * host, char * port);
  16. char * get_port(char * port);
  17. DWORD WINAPI proxy (LPVOID psocket);
  19. /*************
  20. * functions *
  21. *************/
  23. /*
  24. * display_error()
  25. * donne la raison de l'erreur sert au debugage
  26. */
  27. void display_error(char * errorType){
  28. LPVOID lpMsgBuf;
  29. FormatMessage(  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  30.     NULL,
  31.     GetLastError(),
  32.     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  33.     (LPTSTR) &lpMsgBuf,
  34.     0,
  35.     NULL);
  37. // Affichage du message dans une boite de dialogue
  38. MessageBox( NULL, lpMsgBuf, errorType, MB_OK | MB_ICONERROR );
  39. // Libération du buffer
  40. LocalFree( lpMsgBuf );
  41. }
  43. /*
  44. * get_host()
  45. * fonction qui isole le header http host qui suit le "Host:"
  46. */
  47. char * get_host(char * httpRequest){
  48. unsigned short i = 0, j = 0;
  50. char * buffer = (char *)malloc(2*1024 * sizeof(char));
  51. if( !(buffer = strstr(httpRequest, "Host: " )) ){
  52.  fprintf(stderr, "Can\'t find host in this request !\r\n" );
  53.  return "error";
  54. }
  55. else{
  56.  char * host = (char *)malloc(256 * sizeof(char));
  58.  while( buffer[i] != '\n' )
  59.   i++;
  61.  for(j = 6; j < i-1; j++)
  62.   host[j - 6] = buffer[j];
  63.  host[j-6+1] = '\0';
  65.  return host;
  66. }
  67. }
  69. /*
  70. * cut_host_and_port
  71. * separe le host de son port
  72. */
  73. void cut_host_and_port(char * host, char * port){
  74.  unsigned short i = 0;
  75.  unsigned short y = 0;
  76.  unsigned short size = strlen(host);
  77.  while(host[i] != ':')
  78.   i++;
  79.  host[i] = '\0';
  80.  i++;
  81.  for(y = 0; y < 5, i < size; i++, y++)
  82.   port[y] = host[i];
  83. }
  85. /*
  86. * proxy()
  87. */
  88. DWORD WINAPI proxy (LPVOID psocket){
  89. //Recuperation de la valeur du socket
  90. SOCKET * ps = psocket;
  91. SOCKET socket_client = *ps;
  92. //On a la valeur de la socket, on peut désallouer
  93. free(psocket);
  95. SOCKET envoi;
  96. SOCKADDR_IN server2;
  97. struct hostent * structHost;
  99. char buffer[1024*2];  // 2 ko
  100. char buffer2[1024*4];   // 4 ko
  102. memset(buffer,'\0', sizeof(buffer));
  103. memset(buffer2,'\0', sizeof(buffer2));
  105. // On recoit la requete du navigateur
  106. int size = recv(socket_client, buffer, sizeof(buffer), 0);
  108. fprintf(stdout, "----Commande recue ----\r\n%s----\r\n", buffer);
  110. // On récupère le header (Host:) de la requete
  111. // pour pouvoir se connecter au serveur web
  112. char * host = get_host(buffer);
  113. // Parfois host a la forme (Host: adresse:port
  114. // donc on creer une variable port pour récupérer ce dernier
  115. char * port = (char *)malloc(5 * sizeof(char));
  117. if( !strncmp(host, "error", 5) ){
  118.  fprintf(stderr, "get_host return error.\r\n" );
  119.  closesocket(socket_client);
  120.  //ExitThread(0);
  121.  return 1;
  122. }
  123. else if( strchr(host,':')){
  124.    cut_host_and_port(host, port);
  126.   }
  127.   else{
  128.    port = "80";
  129.   }
  131. fprintf(stdout,"Host : [%s], port : [%s]\r\n", host, port);
  134. // On envoie la requete au serveur web
  135. // grace a un nouveau socket
  136. if((structHost = gethostbyname(host)) == NULL){
  137.   fprintf(stderr,"Host error. Can't find %s\r\n", host);
  138.   closesocket(socket_client);
  139.   //ExitThread(0);
  140.   return 1;
  141. }
  143. if((envoi = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET){
  144.  fprintf(stderr, "Socket error. Error: %d\r\n", WSAGetLastError());
  145.  closesocket(socket_client);
  146.         display_error("Socket error !" );
  147.         //ExitThread(0);
  148.         return 1;
  149. }
  151.     server2.sin_family = AF_INET;
  152. server2.sin_port   = htons(atoi(port));
  153. server2.sin_addr   = *((struct in_addr *)structHost->h_addr);
  154. memset(&(server2.sin_zero),'\0',8);
  156.     if( connect(envoi,(struct sockaddr * )&server2, sizeof(struct sockaddr)) == -1){
  157.         fprintf(stderr,"Error connect\r\n" );
  158.  closesocket(socket_client);
  159.  closesocket(envoi);
  160.         //display_error("Connect Error !" );
  161.         //ExitThread(0);
  162.         return 1;
  163.     }
  165.     send(envoi, buffer, strlen(buffer), 0);
  167. // Reception des donnees a partir du serveur
  168. // et les renvoies au navigateur
  169. while( (size = recv(envoi, buffer2, sizeof(buffer2),0)) > 0){
  170.  //fprintf(stdout, "---buffer----\r\n%s\r\n----", buffer2);
  171. // Renvoie de la réponse au navigateur
  172.  buffer2[size]='\0';
  173.  send(socket_client, buffer2, size, 0);
  174.    }
  176. //Nettoyage
  177.     closesocket(socket_client);
  178.     closesocket(envoi);
  179.     fprintf(stdout, "Exiting Thread.\r\n" );
  180. //ExitThread(0);
  182.     return 0;
  183. }
  185. /**********
  186. * main() *
  187. **********/
  188. int main(int argc, char * argv[]){
  190. // Initialisation
  191.     WSADATA WSAData;
  192. if( WSAStartup(MAKEWORD(2,0),&WSAData) != 0 )
  193.     {
  194.         fprintf(stderr, "WSAStartup error. Error: %d\r\n", WSAGetLastError());
  195.         display_error("WSAStartup error !" );
  196.         return 1;
  197.     }
  199. // Variables
  200.     SOCKET socket_local;
  201.     SOCKET socket_client;
  203.     SOCKADDR_IN server;
  204.     SOCKADDR_IN client;
  206. DWORD  dwThreadID;
  207. int * paramThread = malloc(sizeof dwThreadID);
  209. if(paramThread == NULL){
  210.  display_error("Thread error !" );
  211.  return EXIT_FAILURE;
  212. }
  214.     int sin_size = sizeof(SOCKADDR_IN);
  216.     if( (socket_local = socket(AF_INET,SOCK_STREAM,0) ) == INVALID_SOCKET )
  217.     {
  218.         fprintf(stderr, "Socket error. Error: %d\r\n", WSAGetLastError());
  219.         display_error("Socket error !" );
  220.  WSACleanup();
  221.         return 1;
  222.     }
  224. // Configuration du proxy (port 8080)
  225. server.sin_family      = AF_INET;
  226. server.sin_port        = htons(8080);
  227. server.sin_addr.s_addr = INADDR_ANY;
  228. memset(&(server.sin_zero), '\0', 8);
  230.     if( bind(socket_local,(struct sockaddr * )&server,sizeof(struct sockaddr)) == SOCKET_ERROR)
  231.     {
  232.  fprintf(stderr, "Bind error. Error: %d\r\n", WSAGetLastError());
  233.         display_error("Bind error !" );
  234.  closesocket(socket_client);
  235.  WSACleanup();
  236.         return 1;
  237.     }
  239.     listen(socket_local, SOMAXCONN);
  241. // Attente de connexion, si erreur on quitte le programme
  242. while(1)
  243. {
  244.  if( (socket_client = accept(socket_local,(struct sockaddr * )&client,&sin_size)) == INVALID_SOCKET )
  245.  {
  246.    fprintf(stderr, "Accept error.Error: %d\r\n", WSAGetLastError());
  247.    display_error("Accept error !" );
  248.    closesocket(socket_client);
  249.    WSACleanup();
  250.    return 1;
  251.  }
  252.  else
  253.  {
  254.   fprintf(stdout,"Connection de : %s \n",inet_ntoa(client.sin_addr));
  255. // On cree un thread par nouvelle connexion en
  256. // appelant la fonction proxy avec comme paramètre le socket client
  257. // Si erreur a la creation d un thread on quitte
  258.   *paramThread = socket_client;
  259.   if( CreateThread( NULL,
  260.        0,
  261.        (LPTHREAD_START_ROUTINE) proxy,
  262.        paramThread,
  263.        0,
  264.        &dwThreadID) == NULL )
  265.   {
  266.    fprintf(stderr, "CreateThread error.\r\n" );
  267.    display_error("CreateThread error !" );
  268.    return 1;
  269.   }
  270.   //proxy(paramThread );
  271.  }
  272. }
  273.     return 0;
  274. }


Merci de ton aide nargy

Reply

Marsh Posté le 21-04-2006 à 10:40:52    

ouais le code est un peu gros, et en plus c'est du windoz. je peut pas tester là, et c'est balaise avec autant de code de compiler de tête.
je te conseillerai bien de rajouter du débug à fond, histoire de cibler le problème.

Reply

Marsh Posté le 21-04-2006 à 10:41:55    

pour le freeze, tu doit avoir un problème de communication thread.

Reply

Marsh Posté le 23-04-2006 à 00:44:52    

J'ai un nouveau problème, encore un  :fou: . Depuis que j'ai rajouté mes fonctions de parse de requete HTTP, le nombre de site qui fonctionne est bien meilleur qu'auparavant et je n'ai plus de freeze mais par contre le multithreading plante !!
J'ai des erreurs du type:
Citation:
0x0040155f emploie l'adresse mémoire 0x0014a0000. La mémoire ne peut pas être "read".
Quelqu'un saurait me dire de quoi cela peut provenir.
 
PS: si vous voulez une source fonctionnel commenté CreateThread et décommenté la ligne du dessous.
 
PS2: la source devenant trop longue je ne vais pas poluer le forum, elle est ici:
http://membres.lycos.fr/bobov/code/main.c
 
PS3: Merci nargy pour ton aide jusque ici.

Reply

Marsh Posté le 23-04-2006 à 00:56:56    

Il plante à sur l'index du forum chez moi. :o

----Accept: []
Cookie: []
Host: []
----
Can't find host in this request !
get_host return error.
Exiting Thread Normaly.
 
C:\dev\C>


Pour les dernières lignes


---------------
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn
Reply

Marsh Posté le 23-04-2006 à 00:59:48    

> 0x0040155f emploie l'adresse mémoire 0x0014a0000. La mémoire ne peut pas être "read".  
 
- indique que tu as un pointeur qui se balade dans le vide. il te faut un débuggeur, qui te dira à quelle ligne de ton programme tu accède à un pointeur qui n'a pas été initialisé, ou utilisé après avoir été libéré. Sans débuggeur, tu peut trouver mais moins facilement en ajoutant des printf de débug à chaque fonctions puis chaque ligne.

Message cité 1 fois
Reply

Marsh Posté le 23-04-2006 à 01:02:15    

:D oui, les entêtes n'ont pas d'ordre

Reply

Marsh Posté le 23-04-2006 à 01:03:14    

nargy a écrit :

> 0x0040155f emploie l'adresse mémoire 0x0014a0000. La mémoire ne peut pas être "read".  
 
- indique que tu as un pointeur qui se balade dans le vide. il te faut un débuggeur, qui te dira à quelle ligne de ton programme tu accède à un pointeur qui n'a pas été initialisé, ou utilisé après avoir été libéré. Sans débuggeur, tu peut trouver mais moins facilement en ajoutant des printf de débug à chaque fonctions puis chaque ligne.


Code :
  1. C:\\dev\\C\\proxy2.c:317: warning: 'socket_client' might be used uninitialized in this function


Si ça peut aider. :o


Message édité par tholdan le 23-04-2006 à 01:03:45

---------------
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn
Reply

Marsh Posté le 23-04-2006 à 01:43:33    

Le problème des erreurs de read provennait de l'espace mémoire des threads qui était mal initialisé à chaque nouveau thread.
Normalment c'est corrigé.
Tholdan t'a compilé avec quoi, j'ai pas ce warning la moi :?.
Sinon j'ai pas de plantage à l'index du forum, j'en ai pour les requetes POST par contre. C'est quoi ton navigateur?

Message cité 1 fois
Reply

Marsh Posté le 23-04-2006 à 01:49:53    

psyphi a écrit :

Le problème des erreurs de read provennait de l'espace mémoire des threads qui était mal initialisé à chaque nouveau thread.
Normalment c'est corrigé.
Tholdan t'a compilé avec quoi, j'ai pas ce warning la moi :?.
Sinon j'ai pas de plantage à l'index du forum, j'en ai pour les requetes POST par contre. C'est quoi ton navigateur?


GCC -Wall
Et firefox 1.5 comme navigateur.


Message édité par tholdan le 23-04-2006 à 01:50:17

---------------
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn
Reply

Marsh Posté le 26-04-2006 à 00:12:54    

Pour ceux que ça interesse j'ai fait une mise à jour du code avec l'implémentation de la requete POST.
http://www.cppfrance.com/code.aspx?ID=37134
En fait maintenant j'aimerais bien avoir le retour d'utilisateur :)

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed