[C]Proxy

Version imprimable

[C]Proxy

Bonjour à tous je viens posté ici en dernier recours, je trouve peu de personne pour m'aider sur les autres sites :cry:.
Voila un proxy que j'ai conçu en C avec l'API win32. J'en serai presque satisfait sauf que j'ai un problème avec les images.
Ces dernières ne s'affichent pas dans le navigateur si j'utilise un buffer supérieur à un octet. Or utiliser un buffer de 1 octet rend le transfert très long, je suis donc coincé et j'en appel à votre aide.
Le bout de code qui pose problème est la boucle while( ... recv ... ) encadré par les géants printf() debut et fin ;) dans la fonction proxy.
J'ai essayé de commenté le plus possible le code afin que chacun puisse le comprendre aisément.
La source ce trouve ici: http://membres.lycos.fr/bobov/code/main.c

Code:

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

19/04/2006, 11h02
fearyourself
Montre le code que tu utilises lorsque tu as un tampon plus grand qu'un caractère...

J'aimerais voir le code de déclaration du buffer2 et ce que tu mets entre tes deux grands printf...

Je ne peux pas faire mieux à cause de:
Code:

1 2 3 #include <windows.h> #include <winsock2.h>
Jc

Désolé c'est que ce code est only for win32. Mais je le porterais peut être par la suite sous nux.
Voila le code que je met quand je déclare un buffer2 ainsi:
char buffer2[1024];
Code:

1 2 3 4 5 6 7 8 printf("Debut ###################################### \r\n"); while( (size = recv(envoi, buffer2, sizeof(buffer2),0)) > 0){ buffer2[size] = '\0'; // Renvoie de la réponse au navigateur send(socket_client, buffer2, strlen(buffer2),0); } printf("FIN ###################################### \r\n");
J'ai exactement le même nombre d'octet reçu et envoyé que lorsque j'ai un buffer de un octet sauf que les images ne s'affichent pas.

J'ai remarqué aussi autre chose, c'est que lorsque il s'agit d'une page html la boucle se termine aussitôt que la page est reçue mais dans le cas d'une image une fois la totalité de l'image réçue, la boucle mais très longtemps avant de se terminer, 2 à 5 min!!! Je crois qu'elle reste coincé sur le recv!
Faudrait peut etre que j'essaye le code sous linux pour voir si j'ai le même problème.

19/04/2006, 12h14
crocodilex

C'est pourquoi faire ça ? :

Code:

buffer2[size] = '\0';

Une image c'est bien du binaire ?
Il n'y a pas besoin de rajouter de caractère null en fin de buffer.

Et ça ? :

Code:

send(socket_client, buffer2, strlen(buffer2),0);

strxxx c'est pour "string"......
Donc ca risque de ne pas bien marcher ton truc avec du binaire.
19/04/2006, 12h25
psyphi

Grummbll (pour être poli) c'est exactement ce que je viens de trouver.
Si je replace:

Code:

send(socket_client, buffer2, strlen(buffer2),0);

par

Code:

send(socket_client, buffer2, size,0);

Ca marche, j'ai bien le transfert d'image mais j'ai toujours cette histoire de boucle qui a du mal à se terminer après le transfert d'une image. Grr, plus que ca et mon proxy sera quasiment opérationnel, encore deux, trois bug d'erreur avec arrêt inopiné.

Sinon j'ai une autre question, venant du monde de linux je ne suis pas un pro de la prog avec l'API win32.
Pouvez vous me dire ce que signifie ce warning:

Citation:

main.c:209: warning: passing arg 4 of `CreateThread' makes pointer from integer without a cast

Malgré ce warning, la socket se transmet bien dans chacun de mes threads.

PS: je developpe avec MINGW (gcc) et code::blocks sous windows Xp.

En tout cas merci de vos aides.

Citation:

Envoyé par psyphi

Pouvez vous me dire ce que signifie ce warning:

Citation:

main.c:209: warning: passing arg 4 of `CreateThread' makes pointer from integer without a cast

Malgré ce warning, la socket se transmet bien dans chacun de mes threads.

Ben tout simplement que l'argument 4 n'a pas le type attendu.
En regardant le prototype de la fonction :
Code:

1 2 3 4 5 6 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
on voit que l'argument 4 est de type "LPVOID"
Donc si tu fais ça :
Code:

1 2 3 4 5 6 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) proxy, (LPVOID)socket_client, 0, &dwThreadID) == NULL )
je pense qu'il n'y aura plus ce warning.

19/04/2006, 12h53
fearyourself

Citation:

Envoyé par psyphi

Ca marche, j'ai bien le transfert d'image mais j'ai toujours cette histoire de boucle qui a du mal à se terminer après le transfert d'une image.

Il faudrait vérifier que de l'autre côté, ils ferment bien la socket pour que tu puisses sortir du while.

Citation:

Sinon j'ai une autre question, venant du monde de linux je ne suis pas un pro de la prog avec l'API win32.

Ce warning existe aussi sous linux, le paramètre que tu passes à la fonction qui gérera le thread est supposé être un pointeur vers une zone mémoire. Il serait bon de lui envoyé l'adresse qui contient ta socket à la place de la valeur de la socket.

Jc
19/04/2006, 12h58
fearyourself
Citation:
Envoyé par crocodilex

Donc si tu fais ça :

Code:

1 2 3 4 5 6 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) proxy, (LPVOID)socket_client, 0, &dwThreadID) == NULL )

je pense qu'il n'y aura plus ce warning.
C'est exactement pour ce genre de choses qu'on dit que faire des casts est une horreur et une source d'erreur. Tu casts pour enlever le warning mais pas pour réparer le problème.

Si une fonction demande un pointeur, on donne un pointeur pas un entier déguisé en pointeur pour faire plaisir...

Jc
19/04/2006, 13h14
crocodilex

Citation:

Envoyé par fearyourself

C'est exactement pour ce genre de choses qu'on dit que faire des casts est une horreur et une source d'erreur. Tu casts pour enlever le warning mais pas pour réparer le problème.

Si une fonction demande un pointeur, on donne un pointeur pas un entier déguisé en pointeur pour faire plaisir...

Jc

Exact....je suis allé un peu trop vite.
Toute mes excuses :oops:
19/04/2006, 13h17
psyphi

Citation:

Il faudrait vérifier que de l'autre côté, ils ferment bien la socket pour que tu puisses sortir du while

Comment je peux faire ça, ça ne dépend pas de moi mais du navigateur?

Citation:

C'est exactement pour ce genre de choses qu'on dit que faire des casts est une horreur et une source d'erreur. Tu casts pour enlever le warning mais pas pour réparer le problème.

Comment faire alors? Faire de mon socket un pointeur dès le départ? Il me semble que j'avais déjà essayé et qu'alors il n'y avait plus un socket par thread mais que chaque thread se partageait le même socket et donc mon code ne fonctionnait plus.
19/04/2006, 13h24
fearyourself

Citation:

Envoyé par psyphi

Comment faire alors? Faire de mon socket un pointeur dès le départ?

Non passer l'adresse de socket à la fonction thread.

Citation:

Il me semble que j'avais déjà essayé et qu'alors il n'y avait plus un socket par thread mais que chaque thread se partageait le même socket et donc mon code ne fonctionnait plus.

La seule façon de le faire correctement et d'allouer dynamiquement une zone mémoire par thread que chaque thread désallouera à la fin de sa fonction ou lorsqu'il n'en a plus besoin.

Jc
19/04/2006, 19h36
psyphi

Citation:

La seule façon de le faire correctement et d'allouer dynamiquement une zone mémoire par thread que chaque thread désallouera à la fin de sa fonction ou lorsqu'il n'en a plus besoin.

:aie: tu pourrais détailler un peu, si t'as pas le temps donne moi juste un lien bien détaillé.
Comme ça j'en serai quitte une bonne fois pour toute avec la gestion des threads.

Citation:

Envoyé par psyphi

:aie: tu pourrais détailler un peu, si t'as pas le temps donne moi juste un lien bien détaillé.
Comme ça j'en serai quitte une bonne fois pour toute avec la gestion des threads.

Toi tu fais:
Code:

1 2 3 4 5 6 7 if( CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE) proxy, socket_client, 0, &dwThreadID) == NULL )
Mais il faudrait plutôt faire:
[EDIT]
code corrigé
[/EDIT]
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int *paramThread = malloc(sizeof dwThreadID); if(paramThread == NULL) { //Gestion erreur ou juste: return EXIT_FAILURE; } *paramThread = socket_client; if( CreateThread( NULL, 0, proxy, paramThread, 0, &dwThreadID) == NULL )
Ensuite dans ta fonction socket_client qui sera défini comme ceci:
Code:

1 2 3 4 5 6 7 8 9 10 DWORD WINAPI proxy (LPVOID psocket) { SOCKET *ps = psocket; SOCKET s = *ps; //On a la valeur de la socket, on peut désallouer free(psocket); //Reste de la fonction... }
Disons que je ne pense pas que la facon dont tu l'as codé posera forcément des problèmes. Mais il faut savoir qu'il faut éviter les casts. Si tu as un warning, traite le comme une erreur. Ta fonction avait le mauvais prototype par rapport à ce que voulais CreateThread, c'est mauvais signe...

Ensuite, c'est légèrement plus lourd comme solution puisqu'il faut allouer et désallouer mais, au moins, on a respecter les types des paramétres de la fonction et tout le monde sera content (au moins moi je le serais...)

Jc

Arf le code que tu m'as donnés me rajoute une erreur dans le dernier argument de CreateThread.
J'ai donc essayé de modifier le code ainsi:
Code:

1 2 3 4 5 6 7 8 DWORD dwThreadID; LPDWORD paramThread = malloc(sizeof dwThreadID); if(paramThread == NULL){ display_error("Thread error !"); return EXIT_FAILURE; }
Je fais la création de thread ainsi:
Code:

1 2 3 4 5 6 CreateThread( NULL, 0, proxy, &socket_client, 0, paramThread) == NULL )
Et ma fonction proxy contient ceci pour récupérer le contenu du socket:
Code:

1 2 3 4 5 6 7 8 DWORD WINAPI proxy (LPVOID psocket){ //Recuperation de la valeur du socket SOCKET *ps = psocket; SOCKET socket_client = *ps; //On a la valeur de la socket, on peut désallouer free(psocket); etc ...
Plus d'erreur de compilation mais au bout de deux threads le programme plante et me demande si je veux envoyer l'erreur :(.
J'arrive pas à savoir d'où ca vient.

20/04/2006, 15h05
fearyourself

Excuse moi j'ai été trop rapide lors de la dernière réponse... J'ai corrigé le code...

Merci grâce à toi je n'ai plus d'erreur du type:

Citation:

0x00401489 emploie l'adresse mémoire 0x00000000. La mémoire ne peut pas être "read".

Par contre c'est quoi exactement la signification et le type de :

Code:

DWORD WINAPI

Que pensez vous d'un buffer de 1ko pour le transfert des données c'est trop gros/petit existe t'il une taille par défaut?

Enfin j'ai toujours un problème de chargement des pages, parfoit la fonction se bloque sur une image ou sur le téléchargement d'une pub (par exemple lors de la connexion à googlesyndication).

Sinon je crois que la moindre des choses c'est que je poste le nouveau code, un peu amélioré, avec une meilleur gestion des erreurs.
Je suis preneur d'autres remarques :).
Et merci fearyourself.

Code:

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

20/04/2006, 16h39
fearyourself

Citation:

Envoyé par psyphi

Que pensez vous d'un buffer de 1ko pour le transfert des données c'est trop gros/petit existe t'il une taille par défaut?

Je mettrais 4ko voir 16ko. Mais sans vraiment avoir une raison spécifique...

Citation:

Et merci fearyourself.

De rien,
Jc
20/04/2006, 20h11
psyphi

J'ai encore une autre question quand je dois quitter la fonction proxy pour cause d'erreur vaut mieu que je fasse un return ou un ExitThread?
20/04/2006, 21h08
fearyourself

Citation:

Envoyé par psyphi

J'ai encore une autre question quand je dois quitter la fonction proxy pour cause d'erreur vaut mieu que je fasse un return ou un ExitThread?

En principe, si tu es dans la fonction de départ du thread alors un return suffit, la fonction ExitThread sera appelé ensuite.

Ceci est vrai avec les pthread et je suppose que la version thread Windows a fait pareil...

Jc
23/04/2006, 00h41
psyphi

J'ai un nouveau problème, encore un :?. Depuis que j'ai rajouté mes fonctions de parse de requete HTTP, le nombre de site qui fonctionne est bien meilleur qu'auparavant 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
23/04/2006, 01h00
fearyourself

Citation:

Envoyé par psyphi

J'ai un nouveau problème, encore un :?. Depuis que j'ai rajouté mes fonctions de parse de requete HTTP, le nombre de site qui fonctionne est bien meilleur qu'auparavant mais par contre le multithreading plante !!

Logique, tu alloues une seule fois ton espace pour paramThread et tu le désalloues à chaque création d'un thread... Cela ne t'étonne pas?

Il faut créer la zone mémoire pour chaque thread et désallouer la zone unique de chaque thread une seule fois...

Jc

Heu maintenant que tu le dis si :mrgreen:
Par contre ca marchait comme ca avant que je fasse de nouvelles modifs, ca ca me semble bizarre.
En tout cas ca à l'air de fonctionner à merveille pour le moment, je vais continuer mes tests.
Autre chose, qqun sait se servir de gdb, quand je lance un debug de mon programme dès le début il me dit:
Code:

1 2 3 4 5 6 7 8 9 #0 0x77e83c00 _libws2_32_a_iname (??:??) #1 0x62e47258 _libws2_32_a_iname (??:??) #2 0x0022fc54 ?? (??:??) #3 0x77ed360b _libws2_32_a_iname (??:??) #4 0x62e70c3e _libws2_32_a_iname (??:??) #5 0x62e6afb9 _libws2_32_a_iname (??:??) #6 0x719977f2 _libws2_32_a_iname (??:??) #7 0x719f8916 _libws2_32_a_iname (??:??) #8 0x00401f93 main (??:??)

Problème avec free()

J'ai un petit soucis de propreté:
Si je met un free dans ma fonction mon programme plante, alors que normalement il est nécéssaire d'en mettre un non?:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
short get_header_if_exist(char * httpRequest, char * headerName, char * Header){
    unsigned short i = 0;
    char * buffer = calloc(HALF_SIZE, sizeof(char));
// On verifie l allocation memoire
    if(buffer == NULL){
        fprintf(stderr,"Allocation impossible");
        display_error("calloc() Error");
        exit(EXIT_FAILURE);
    }
 
    if( (buffer = strstr(httpRequest, headerName)) )
    {
        while(buffer[i] != '\r' && buffer[i] != '\n')
        {
            Header[i] = buffer[i];
            i++;
        }
        Header[i] = '\0';
//free(buffer) qui fait tout planter
        return 0;
    }else{
        Header[0] = '\0';
        free(buffer);
        return 1;
    }
}

24/04/2006, 16h01
fearyourself

Juste parce que la signature de strstr est:

Code:

char *strstr(const char *haystack, const char *needle);

Cela ne veut pas dire qu'il faut allouer de l'espace lorsqu'on appelle cette fonction..

Jc
24/04/2006, 16h09
psyphi

Oui effectivement, je comprends. Donc de plus mon code utilisait de la mémoire pour rien?
24/04/2006, 16h50
fearyourself

Citation:

Envoyé par psyphi

Oui effectivement, je comprends. Donc de plus mon code utilisait de la mémoire pour rien?

Exact

Jc