?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Added My Computer.
[wine/dcerpc.git] / dlls / wininet / http.c
blob0d6f748fc5c78423b7578e19f5f9436c6fd1a30a
1 /*
2 * Wininet - Http Implementation
3 *
4 * Copyright 1999 Corel Corporation
5 * Copyright 2002 CodeWeavers Inc.
6 * Copyright 2002 TransGaming Technologies Inc.
7 * Copyright 2004 Mike McCormack for CodeWeavers
8 *
9 * Ulrich Czekalla
10 * Aric Stewart
11 * David Hammerton
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28 #include "config.h"
29
30 #include <sys/types.h>
31 #ifdef HAVE_SYS_SOCKET_H
32 # include <sys/socket.h>
33 #endif
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <errno.h>
41 #include <string.h>
42 #include <time.h>
43
44 #include "windef.h"
45 #include "winbase.h"
46 #include "wininet.h"
47 #include "winreg.h"
48 #include "winerror.h"
49 #define NO_SHLWAPI_STREAM
50 #include "shlwapi.h"
51
52 #include "internet.h"
53 #include "wine/debug.h"
54 #include "wine/unicode.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
57
58 #define HTTPHEADER " HTTP/1.0"
59 #define HTTPHOSTHEADER "\r\nHost: "
60 #define MAXHOSTNAME 100
61 #define MAX_FIELD_VALUE_LEN 256
62 #define MAX_FIELD_LEN 256
63
64
65 #define HTTP_REFERER "Referer"
66 #define HTTP_ACCEPT "Accept"
67 #define HTTP_USERAGENT "User-Agent"
68
69 #define HTTP_ADDHDR_FLAG_ADD 0x20000000
70 #define HTTP_ADDHDR_FLAG_ADD_IF_NEW 0x10000000
71 #define HTTP_ADDHDR_FLAG_COALESCE 0x40000000
72 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA 0x40000000
73 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON 0x01000000
74 #define HTTP_ADDHDR_FLAG_REPLACE 0x80000000
75 #define HTTP_ADDHDR_FLAG_REQ 0x02000000
76
77
78 BOOL HTTP_OpenConnection(LPWININETHTTPREQA lpwhr);
79 int HTTP_WriteDataToStream(LPWININETHTTPREQA lpwhr,
80 void *Buffer, int BytesToWrite);
81 int HTTP_ReadDataFromStream(LPWININETHTTPREQA lpwhr,
82 void *Buffer, int BytesToRead);
83 BOOL HTTP_GetResponseHeaders(LPWININETHTTPREQA lpwhr);
84 BOOL HTTP_ProcessHeader(LPWININETHTTPREQA lpwhr, LPCSTR field, LPCSTR value, DWORD dwModifier);
85 void HTTP_CloseConnection(LPWININETHTTPREQA lpwhr);
86 BOOL HTTP_InterpretHttpHeader(LPSTR buffer, LPSTR field, INT fieldlen, LPSTR value, INT valuelen);
87 INT HTTP_GetStdHeaderIndex(LPCSTR lpszField);
88 BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQA lpwhr, LPHTTPHEADERA lpHdr);
89 INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQA lpwhr, LPCSTR lpszField);
90 BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQA lpwhr, INT index);
91
92 /***********************************************************************
93 * HttpAddRequestHeadersA (WININET.@)
94 *
95 * Adds one or more HTTP header to the request handler
96 *
97 * RETURNS
98 * TRUE on success
99 * FALSE on failure
100 *
101 */
102 BOOL WINAPI HttpAddRequestHeadersA(HINTERNET hHttpRequest,
103 LPCSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
104 {
105 LPSTR lpszStart;
106 LPSTR lpszEnd;
107 LPSTR buffer;
108 CHAR value[MAX_FIELD_VALUE_LEN], field[MAX_FIELD_LEN];
109 BOOL bSuccess = FALSE;
110 LPWININETHTTPREQA lpwhr;
111
112 TRACE("%p, %s, %li, %li\n", hHttpRequest, lpszHeader, dwHeaderLength,
113 dwModifier);
114
115 lpwhr = (LPWININETHTTPREQA) WININET_GetObject( hHttpRequest );
116
117 if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
118 {
119 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
120 return FALSE;
121 }
122
123 if (!lpszHeader)
124 return TRUE;
125
126 TRACE("copying header: %s\n", lpszHeader);
127 buffer = WININET_strdup(lpszHeader);
128 lpszStart = buffer;
129
130 do
131 {
132 lpszEnd = lpszStart;
133
134 while (*lpszEnd != '\0')
135 {
136 if (*lpszEnd == '\r' && *(lpszEnd + 1) == '\n')
137 break;
138 lpszEnd++;
139 }
140
141 if (*lpszEnd == '\0')
142 break;
143
144 *lpszEnd = '\0';
145
146 TRACE("interpreting header %s\n", debugstr_a(lpszStart));
147 if (HTTP_InterpretHttpHeader(lpszStart, field, MAX_FIELD_LEN, value, MAX_FIELD_VALUE_LEN))
148 bSuccess = HTTP_ProcessHeader(lpwhr, field, value, dwModifier | HTTP_ADDHDR_FLAG_REQ);
149
150 lpszStart = lpszEnd + 2; /* Jump over \0\n */
151
152 } while (bSuccess);
153
154 HeapFree(GetProcessHeap(), 0, buffer);
155 return bSuccess;
156 }
157
158 /***********************************************************************
159 * HttpEndRequestA (WININET.@)
160 *
161 * Ends an HTTP request that was started by HttpSendRequestEx
162 *
163 * RETURNS
164 * TRUE if successful
165 * FALSE on failure
166 *
167 */
168 BOOL WINAPI HttpEndRequestA(HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersOut,
169 DWORD dwFlags, DWORD dwContext)
170 {
171 FIXME("stub\n");
172 return FALSE;
173 }
174
175 /***********************************************************************
176 * HttpEndRequestW (WININET.@)
177 *
178 * Ends an HTTP request that was started by HttpSendRequestEx
179 *
180 * RETURNS
181 * TRUE if successful
182 * FALSE on failure
183 *
184 */
185 BOOL WINAPI HttpEndRequestW(HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersOut,
186 DWORD dwFlags, DWORD dwContext)
187 {
188 FIXME("stub\n");
189 return FALSE;
190 }
191
192 /***********************************************************************
193 * HttpOpenRequestA (WININET.@)
194 *
195 * Open a HTTP request handle
196 *
197 * RETURNS
198 * HINTERNET a HTTP request handle on success
199 * NULL on failure
200 *
201 */
202 HINTERNET WINAPI HttpOpenRequestA(HINTERNET hHttpSession,
203 LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion,
204 LPCSTR lpszReferrer , LPCSTR *lpszAcceptTypes,
205 DWORD dwFlags, DWORD dwContext)
206 {
207 LPWININETHTTPSESSIONA lpwhs;
208 LPWININETAPPINFOA hIC = NULL;
209 HINTERNET handle = NULL;
210
211 TRACE("(%p, %s, %s, %s, %s, %p, %08lx, %08lx)\n", hHttpSession,
212 debugstr_a(lpszVerb), lpszObjectName,
213 debugstr_a(lpszVersion), debugstr_a(lpszReferrer), lpszAcceptTypes,
214 dwFlags, dwContext);
215 if(lpszAcceptTypes!=NULL)
216 {
217 int i;
218 for(i=0;lpszAcceptTypes[i]!=NULL;i++)
219 TRACE("\taccept type: %s\n",lpszAcceptTypes[i]);
220 }
221
222 lpwhs = (LPWININETHTTPSESSIONA) WININET_GetObject( hHttpSession );
223 if (NULL == lpwhs || lpwhs->hdr.htype != WH_HHTTPSESSION)
224 {
225 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
226 return NULL;
227 }
228 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
229
230 /*
231 * My tests seem to show that the windows version does not
232 * become asynchronous until after this point. And anyhow
233 * if this call was asynchronous then how would you get the
234 * necessary HINTERNET pointer returned by this function.
235 *
236 * I am leaving this here just in case I am wrong
237 *
238 * if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
239 */
240 if (0)
241 {
242 WORKREQUEST workRequest;
243 struct WORKREQ_HTTPOPENREQUESTA *req;
244
245 workRequest.asyncall = HTTPOPENREQUESTA;
246 workRequest.handle = hHttpSession;
247 req = &workRequest.u.HttpOpenRequestA;
248 req->lpszVerb = WININET_strdup(lpszVerb);
249 req->lpszObjectName = WININET_strdup(lpszObjectName);
250 if (lpszVersion)
251 req->lpszVersion = WININET_strdup(lpszVersion);
252 else
253 req->lpszVersion = 0;
254 if (lpszReferrer)
255 req->lpszReferrer = WININET_strdup(lpszReferrer);
256 else
257 req->lpszReferrer = 0;
258 req->lpszAcceptTypes = lpszAcceptTypes;
259 req->dwFlags = dwFlags;
260 req->dwContext = dwContext;
261
262 INTERNET_AsyncCall(&workRequest);
263 }
264 else
265 {
266 handle = HTTP_HttpOpenRequestA(hHttpSession, lpszVerb, lpszObjectName,
267 lpszVersion, lpszReferrer, lpszAcceptTypes,
268 dwFlags, dwContext);
269 }
270 TRACE("returning %p\n", handle);
271 return handle;
272 }
273
274
275 /***********************************************************************
276 * HttpOpenRequestW (WININET.@)
277 *
278 * Open a HTTP request handle
279 *
280 * RETURNS
281 * HINTERNET a HTTP request handle on success
282 * NULL on failure
283 *
284 * FIXME: This should be the other way around (A should call W)
285 */
286 HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession,
287 LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
288 LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
289 DWORD dwFlags, DWORD dwContext)
290 {
291 CHAR *szVerb = NULL, *szObjectName = NULL;
292 CHAR *szVersion = NULL, *szReferrer = NULL, **szAcceptTypes = NULL;
293 INT len;
294 INT acceptTypesCount;
295 HINTERNET rc = FALSE;
296 TRACE("(%p, %s, %s, %s, %s, %p, %08lx, %08lx)\n", hHttpSession,
297 debugstr_w(lpszVerb), debugstr_w(lpszObjectName),
298 debugstr_w(lpszVersion), debugstr_w(lpszReferrer), lpszAcceptTypes,
299 dwFlags, dwContext);
300
301 if (lpszVerb)
302 {
303 len = WideCharToMultiByte(CP_ACP, 0, lpszVerb, -1, NULL, 0, NULL, NULL);
304 szVerb = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR) );
305 if ( !szVerb )
306 goto end;
307 WideCharToMultiByte(CP_ACP, 0, lpszVerb, -1, szVerb, len, NULL, NULL);
308 }
309
310 if (lpszObjectName)
311 {
312 len = WideCharToMultiByte(CP_ACP, 0, lpszObjectName, -1, NULL, 0, NULL, NULL);
313 szObjectName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR) );
314 if ( !szObjectName )
315 goto end;
316 WideCharToMultiByte(CP_ACP, 0, lpszObjectName, -1, szObjectName, len, NULL, NULL);
317 }
318
319 if (lpszVersion)
320 {
321 len = WideCharToMultiByte(CP_ACP, 0, lpszVersion, -1, NULL, 0, NULL, NULL);
322 szVersion = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR));
323 if ( !szVersion )
324 goto end;
325 WideCharToMultiByte(CP_ACP, 0, lpszVersion, -1, szVersion, len, NULL, NULL);
326 }
327
328 if (lpszReferrer)
329 {
330 len = WideCharToMultiByte(CP_ACP, 0, lpszReferrer, -1, NULL, 0, NULL, NULL);
331 szReferrer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR));
332 if ( !szReferrer )
333 goto end;
334 WideCharToMultiByte(CP_ACP, 0, lpszReferrer, -1, szReferrer, len, NULL, NULL);
335 }
336
337 acceptTypesCount = 0;
338 if (lpszAcceptTypes)
339 {
340 while (lpszAcceptTypes[acceptTypesCount]) { acceptTypesCount++; } /* find out how many there are */
341 szAcceptTypes = HeapAlloc(GetProcessHeap(), 0, sizeof(CHAR *) * acceptTypesCount);
342 acceptTypesCount = 0;
343 while (lpszAcceptTypes[acceptTypesCount])
344 {
345 len = WideCharToMultiByte(CP_ACP, 0, lpszAcceptTypes[acceptTypesCount],
346 -1, NULL, 0, NULL, NULL);
347 szAcceptTypes[acceptTypesCount] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR));
348 if (!szAcceptTypes[acceptTypesCount] )
349 goto end;
350 WideCharToMultiByte(CP_ACP, 0, lpszAcceptTypes[acceptTypesCount],
351 -1, szAcceptTypes[acceptTypesCount], len, NULL, NULL);
352 acceptTypesCount++;
353 }
354 }
355 else szAcceptTypes = 0;
356
357 rc = HttpOpenRequestA(hHttpSession, (LPCSTR)szVerb, (LPCSTR)szObjectName,
358 (LPCSTR)szVersion, (LPCSTR)szReferrer,
359 (LPCSTR *)szAcceptTypes, dwFlags, dwContext);
360
361 end:
362 if (szAcceptTypes)
363 {
364 acceptTypesCount = 0;
365 while (szAcceptTypes[acceptTypesCount])
366 {
367 HeapFree(GetProcessHeap(), 0, szAcceptTypes[acceptTypesCount]);
368 acceptTypesCount++;
369 }
370 HeapFree(GetProcessHeap(), 0, szAcceptTypes);
371 }
372 if (szReferrer) HeapFree(GetProcessHeap(), 0, szReferrer);
373 if (szVersion) HeapFree(GetProcessHeap(), 0, szVersion);
374 if (szObjectName) HeapFree(GetProcessHeap(), 0, szObjectName);
375 if (szVerb) HeapFree(GetProcessHeap(), 0, szVerb);
376
377 return rc;
378 }
379
380 /***********************************************************************
381 * HTTP_Base64
382 */
383 static UINT HTTP_Base64( LPCSTR bin, LPSTR base64 )
384 {
385 UINT n = 0, x;
386 static LPSTR HTTP_Base64Enc =
387 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
388
389 while( bin[0] )
390 {
391 /* first 6 bits, all from bin[0] */
392 base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2];
393 x = (bin[0] & 3) << 4;
394
395 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
396 if( !bin[1] )
397 {
398 base64[n++] = HTTP_Base64Enc[x];
399 base64[n++] = '=';
400 base64[n++] = '=';
401 break;
402 }
403 base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ];
404 x = ( bin[1] & 0x0f ) << 2;
405
406 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
407 if( !bin[2] )
408 {
409 base64[n++] = HTTP_Base64Enc[x];
410 base64[n++] = '=';
411 break;
412 }
413 base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ];
414
415 /* last 6 bits, all from bin [2] */
416 base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ];
417 bin += 3;
418 }
419 base64[n] = 0;
420 return n;
421 }
422
423 /***********************************************************************
424 * HTTP_EncodeBasicAuth
425 *
426 * Encode the basic authentication string for HTTP 1.1
427 */
428 static LPSTR HTTP_EncodeBasicAuth( LPCSTR username, LPCSTR password)
429 {
430 UINT len;
431 LPSTR in, out, szBasic = "Basic ";
432
433 len = strlen( username ) + 1 + strlen ( password ) + 1;
434 in = HeapAlloc( GetProcessHeap(), 0, len );
435 if( !in )
436 return NULL;
437
438 len = strlen(szBasic) +
439 (strlen( username ) + 1 + strlen ( password ))*2 + 1 + 1;
440 out = HeapAlloc( GetProcessHeap(), 0, len );
441 if( out )
442 {
443 strcpy( in, username );
444 strcat( in, ":" );
445 strcat( in, password );
446 strcpy( out, szBasic );
447 HTTP_Base64( in, &out[strlen(out)] );
448 }
449 HeapFree( GetProcessHeap(), 0, in );
450
451 return out;
452 }
453
454 /***********************************************************************
455 * HTTP_InsertProxyAuthorization
456 *
457 * Insert the basic authorization field in the request header
458 */
459 BOOL HTTP_InsertProxyAuthorization( LPWININETHTTPREQA lpwhr,
460 LPCSTR username, LPCSTR password )
461 {
462 HTTPHEADERA hdr;
463 INT index;
464
465 hdr.lpszField = "Proxy-Authorization";
466 hdr.lpszValue = HTTP_EncodeBasicAuth( username, password );
467 hdr.wFlags = HDR_ISREQUEST;
468 hdr.wCount = 0;
469 if( !hdr.lpszValue )
470 return FALSE;
471
472 TRACE("Inserting %s = %s\n",
473 debugstr_a( hdr.lpszField ), debugstr_a( hdr.lpszValue ) );
474
475 /* remove the old proxy authorization header */
476 index = HTTP_GetCustomHeaderIndex( lpwhr, hdr.lpszField );
477 if( index >=0 )
478 HTTP_DeleteCustomHeader( lpwhr, index );
479
480 HTTP_InsertCustomHeader(lpwhr, &hdr);
481 HeapFree( GetProcessHeap(), 0, hdr.lpszValue );
482
483 return TRUE;
484 }
485
486 /***********************************************************************
487 * HTTP_DealWithProxy
488 */
489 static BOOL HTTP_DealWithProxy( LPWININETAPPINFOA hIC,
490 LPWININETHTTPSESSIONA lpwhs, LPWININETHTTPREQA lpwhr)
491 {
492 char buf[MAXHOSTNAME];
493 char proxy[MAXHOSTNAME + 15]; /* 15 == "http://" + sizeof(port#) + ":/\0" */
494 char* url, *szNul = "";
495 URL_COMPONENTSA UrlComponents;
496
497 memset( &UrlComponents, 0, sizeof UrlComponents );
498 UrlComponents.dwStructSize = sizeof UrlComponents;
499 UrlComponents.lpszHostName = buf;
500 UrlComponents.dwHostNameLength = MAXHOSTNAME;
501
502 if (strncasecmp(hIC->lpszProxy,"http://",strlen("http://")))
503 sprintf(proxy, "http://%s/", hIC->lpszProxy);
504 else
505 strcpy(proxy,hIC->lpszProxy);
506 if( !InternetCrackUrlA(proxy, 0, 0, &UrlComponents) )
507 return FALSE;
508 if( UrlComponents.dwHostNameLength == 0 )
509 return FALSE;
510
511 if( !lpwhr->lpszPath )
512 lpwhr->lpszPath = szNul;
513 TRACE("server='%s' path='%s'\n",
514 lpwhs->lpszServerName, lpwhr->lpszPath);
515 /* for constant 15 see above */
516 url = HeapAlloc(GetProcessHeap(), 0,
517 strlen(lpwhs->lpszServerName) + strlen(lpwhr->lpszPath) + 15);
518
519 if(UrlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
520 UrlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
521
522 sprintf(url, "http://%s:%d", lpwhs->lpszServerName,
523 lpwhs->nServerPort);
524 if( lpwhr->lpszPath[0] != '/' )
525 strcat( url, "/" );
526 strcat(url, lpwhr->lpszPath);
527 if(lpwhr->lpszPath != szNul)
528 HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
529 lpwhr->lpszPath = url;
530 /* FIXME: Do I have to free lpwhs->lpszServerName here ? */
531 lpwhs->lpszServerName = WININET_strdup(UrlComponents.lpszHostName);
532 lpwhs->nServerPort = UrlComponents.nPort;
533
534 return TRUE;
535 }
536
537 /***********************************************************************
538 * HTTP_HttpOpenRequestA (internal)
539 *
540 * Open a HTTP request handle
541 *
542 * RETURNS
543 * HINTERNET a HTTP request handle on success
544 * NULL on failure
545 *
546 */
547 HINTERNET WINAPI HTTP_HttpOpenRequestA(HINTERNET hHttpSession,
548 LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion,
549 LPCSTR lpszReferrer , LPCSTR *lpszAcceptTypes,
550 DWORD dwFlags, DWORD dwContext)
551 {
552 LPWININETHTTPSESSIONA lpwhs;
553 LPWININETAPPINFOA hIC = NULL;
554 LPWININETHTTPREQA lpwhr;
555 LPSTR lpszCookies;
556 LPSTR lpszUrl = NULL;
557 DWORD nCookieSize;
558 HINTERNET handle;
559
560 TRACE("--> \n");
561
562 lpwhs = (LPWININETHTTPSESSIONA) WININET_GetObject( hHttpSession );
563 if (NULL == lpwhs || lpwhs->hdr.htype != WH_HHTTPSESSION)
564 {
565 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
566 return NULL;
567 }
568
569 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
570
571 lpwhr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPREQA));
572 if (NULL == lpwhr)
573 {
574 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
575 return NULL;
576 }
577 handle = WININET_AllocHandle( &lpwhr->hdr );
578 if (NULL == handle)
579 {
580 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
581 HeapFree( GetProcessHeap(), 0, lpwhr );
582 return NULL;
583 }
584
585 lpwhr->hdr.htype = WH_HHTTPREQ;
586 lpwhr->hdr.lpwhparent = &lpwhs->hdr;
587 lpwhr->hdr.dwFlags = dwFlags;
588 lpwhr->hdr.dwContext = dwContext;
589 NETCON_init(&lpwhr->netConnection, dwFlags & INTERNET_FLAG_SECURE);
590
591 if (NULL != lpszObjectName && strlen(lpszObjectName)) {
592 DWORD needed = 0;
593 HRESULT rc;
594 rc = UrlEscapeA(lpszObjectName, NULL, &needed, URL_ESCAPE_SPACES_ONLY);
595 if (rc != E_POINTER)
596 needed = strlen(lpszObjectName)+1;
597 lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, needed);
598 rc = UrlEscapeA(lpszObjectName, lpwhr->lpszPath, &needed,
599 URL_ESCAPE_SPACES_ONLY);
600 if (rc)
601 {
602 ERR("Unable to escape string!(%s) (%ld)\n",lpszObjectName,rc);
603 strcpy(lpwhr->lpszPath,lpszObjectName);
604 }
605 }
606
607 if (NULL != lpszReferrer && strlen(lpszReferrer))
608 HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpszReferrer, HTTP_ADDHDR_FLAG_COALESCE);
609
610 if(lpszAcceptTypes!=NULL)
611 {
612 int i;
613 for(i=0;lpszAcceptTypes[i]!=NULL;i++)
614 HTTP_ProcessHeader(lpwhr, HTTP_ACCEPT, lpszAcceptTypes[i], HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_REQ|HTTP_ADDHDR_FLAG_ADD_IF_NEW);
615 }
616
617 if (NULL == lpszVerb)
618 lpwhr->lpszVerb = WININET_strdup("GET");
619 else if (strlen(lpszVerb))
620 lpwhr->lpszVerb = WININET_strdup(lpszVerb);
621
622 if (NULL != lpszReferrer && strlen(lpszReferrer))
623 {
624 char buf[MAXHOSTNAME];
625 URL_COMPONENTSA UrlComponents;
626
627 memset( &UrlComponents, 0, sizeof UrlComponents );
628 UrlComponents.dwStructSize = sizeof UrlComponents;
629 UrlComponents.lpszHostName = buf;
630 UrlComponents.dwHostNameLength = MAXHOSTNAME;
631
632 InternetCrackUrlA(lpszReferrer, 0, 0, &UrlComponents);
633 if (strlen(UrlComponents.lpszHostName))
634 lpwhr->lpszHostName = WININET_strdup(UrlComponents.lpszHostName);
635 } else {
636 lpwhr->lpszHostName = WININET_strdup(lpwhs->lpszServerName);
637 }
638 if (NULL != hIC->lpszProxy && hIC->lpszProxy[0] != 0)
639 HTTP_DealWithProxy( hIC, lpwhs, lpwhr );
640
641 if (hIC->lpszAgent)
642 {
643 char *agent_header = HeapAlloc(GetProcessHeap(), 0, strlen(hIC->lpszAgent) + 1 + 14);
644 sprintf(agent_header, "User-Agent: %s\r\n", hIC->lpszAgent);
645 HttpAddRequestHeadersA(handle, agent_header, strlen(agent_header),
646 HTTP_ADDREQ_FLAG_ADD);
647 HeapFree(GetProcessHeap(), 0, agent_header);
648 }
649
650 lpszUrl = HeapAlloc(GetProcessHeap(), 0, strlen(lpwhr->lpszHostName) + 1 + 7);
651 sprintf(lpszUrl, "http://%s", lpwhr->lpszHostName);
652 if (InternetGetCookieA(lpszUrl, NULL, NULL, &nCookieSize))
653 {
654 int cnt = 0;
655
656 lpszCookies = HeapAlloc(GetProcessHeap(), 0, nCookieSize + 1 + 8);
657
658 cnt += sprintf(lpszCookies, "Cookie: ");
659 InternetGetCookieA(lpszUrl, NULL, lpszCookies + cnt, &nCookieSize);
660 cnt += nCookieSize - 1;
661 sprintf(lpszCookies + cnt, "\r\n");
662
663 HttpAddRequestHeadersA(handle, lpszCookies, strlen(lpszCookies),
664 HTTP_ADDREQ_FLAG_ADD);
665 HeapFree(GetProcessHeap(), 0, lpszCookies);
666 }
667 HeapFree(GetProcessHeap(), 0, lpszUrl);
668
669
670
671 if (hIC->lpfnStatusCB)
672 {
673 INTERNET_ASYNC_RESULT iar;
674
675 iar.dwResult = (DWORD)handle;
676 iar.dwError = ERROR_SUCCESS;
677
678 SendAsyncCallback(hIC, hHttpSession, dwContext,
679 INTERNET_STATUS_HANDLE_CREATED, &iar,
680 sizeof(INTERNET_ASYNC_RESULT));
681 }
682
683 /*
684 * A STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on windows
685 */
686
687 /*
688 * According to my tests. The name is not resolved until a request is Opened
689 */
690 SendAsyncCallback(hIC, hHttpSession, dwContext,
691 INTERNET_STATUS_RESOLVING_NAME,
692 lpwhs->lpszServerName,
693 strlen(lpwhs->lpszServerName)+1);
694 if (!GetAddress(lpwhs->lpszServerName, lpwhs->nServerPort,
695 &lpwhs->phostent, &lpwhs->socketAddress))
696 {
697 INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
698 return NULL;
699 }
700
701 SendAsyncCallback(hIC, hHttpSession, lpwhr->hdr.dwContext,
702 INTERNET_STATUS_NAME_RESOLVED,
703 &(lpwhs->socketAddress),
704 sizeof(struct sockaddr_in));
705
706 TRACE("<-- %p\n", handle);
707 return handle;
708 }
709
710
711 /***********************************************************************
712 * HttpQueryInfoA (WININET.@)
713 *
714 * Queries for information about an HTTP request
715 *
716 * RETURNS
717 * TRUE on success
718 * FALSE on failure
719 *
720 */
721 BOOL WINAPI HttpQueryInfoA(HINTERNET hHttpRequest, DWORD dwInfoLevel,
722 LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
723 {
724 LPHTTPHEADERA lphttpHdr = NULL;
725 BOOL bSuccess = FALSE;
726 LPWININETHTTPREQA lpwhr;
727
728 if (TRACE_ON(wininet)) {
729 #define FE(x) { x, #x }
730 static const wininet_flag_info query_flags[] = {
731 FE(HTTP_QUERY_MIME_VERSION),
732 FE(HTTP_QUERY_CONTENT_TYPE),
733 FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
734 FE(HTTP_QUERY_CONTENT_ID),
735 FE(HTTP_QUERY_CONTENT_DESCRIPTION),
736 FE(HTTP_QUERY_CONTENT_LENGTH),
737 FE(HTTP_QUERY_CONTENT_LANGUAGE),
738 FE(HTTP_QUERY_ALLOW),
739 FE(HTTP_QUERY_PUBLIC),
740 FE(HTTP_QUERY_DATE),
741 FE(HTTP_QUERY_EXPIRES),
742 FE(HTTP_QUERY_LAST_MODIFIED),
743 FE(HTTP_QUERY_MESSAGE_ID),
744 FE(HTTP_QUERY_URI),
745 FE(HTTP_QUERY_DERIVED_FROM),
746 FE(HTTP_QUERY_COST),
747 FE(HTTP_QUERY_LINK),
748 FE(HTTP_QUERY_PRAGMA),
749 FE(HTTP_QUERY_VERSION),
750 FE(HTTP_QUERY_STATUS_CODE),
751 FE(HTTP_QUERY_STATUS_TEXT),
752 FE(HTTP_QUERY_RAW_HEADERS),
753 FE(HTTP_QUERY_RAW_HEADERS_CRLF),
754 FE(HTTP_QUERY_CONNECTION),
755 FE(HTTP_QUERY_ACCEPT),
756 FE(HTTP_QUERY_ACCEPT_CHARSET),
757 FE(HTTP_QUERY_ACCEPT_ENCODING),
758 FE(HTTP_QUERY_ACCEPT_LANGUAGE),
759 FE(HTTP_QUERY_AUTHORIZATION),
760 FE(HTTP_QUERY_CONTENT_ENCODING),
761 FE(HTTP_QUERY_FORWARDED),
762 FE(HTTP_QUERY_FROM),
763 FE(HTTP_QUERY_IF_MODIFIED_SINCE),
764 FE(HTTP_QUERY_LOCATION),
765 FE(HTTP_QUERY_ORIG_URI),
766 FE(HTTP_QUERY_REFERER),
767 FE(HTTP_QUERY_RETRY_AFTER),
768 FE(HTTP_QUERY_SERVER),
769 FE(HTTP_QUERY_TITLE),
770 FE(HTTP_QUERY_USER_AGENT),
771 FE(HTTP_QUERY_WWW_AUTHENTICATE),
772 FE(HTTP_QUERY_PROXY_AUTHENTICATE),
773 FE(HTTP_QUERY_ACCEPT_RANGES),
774 FE(HTTP_QUERY_SET_COOKIE),
775 FE(HTTP_QUERY_COOKIE),
776 FE(HTTP_QUERY_REQUEST_METHOD),
777 FE(HTTP_QUERY_REFRESH),
778 FE(HTTP_QUERY_CONTENT_DISPOSITION),
779 FE(HTTP_QUERY_AGE),
780 FE(HTTP_QUERY_CACHE_CONTROL),
781 FE(HTTP_QUERY_CONTENT_BASE),
782 FE(HTTP_QUERY_CONTENT_LOCATION),
783 FE(HTTP_QUERY_CONTENT_MD5),
784 FE(HTTP_QUERY_CONTENT_RANGE),
785 FE(HTTP_QUERY_ETAG),
786 FE(HTTP_QUERY_HOST),
787 FE(HTTP_QUERY_IF_MATCH),
788 FE(HTTP_QUERY_IF_NONE_MATCH),
789 FE(HTTP_QUERY_IF_RANGE),
790 FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
791 FE(HTTP_QUERY_MAX_FORWARDS),
792 FE(HTTP_QUERY_PROXY_AUTHORIZATION),
793 FE(HTTP_QUERY_RANGE),
794 FE(HTTP_QUERY_TRANSFER_ENCODING),
795 FE(HTTP_QUERY_UPGRADE),
796 FE(HTTP_QUERY_VARY),
797 FE(HTTP_QUERY_VIA),
798 FE(HTTP_QUERY_WARNING),
799 FE(HTTP_QUERY_CUSTOM)
800 };
801 static const wininet_flag_info modifier_flags[] = {
802 FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
803 FE(HTTP_QUERY_FLAG_SYSTEMTIME),
804 FE(HTTP_QUERY_FLAG_NUMBER),
805 FE(HTTP_QUERY_FLAG_COALESCE)
806 };
807 #undef FE
808 DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
809 DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
810 int i;
811
812 TRACE("(%p, 0x%08lx)--> %ld\n", hHttpRequest, dwInfoLevel, dwInfoLevel);
813 TRACE(" Attribute:");
814 for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
815 if (query_flags[i].val == info) {
816 DPRINTF(" %s", query_flags[i].name);
817 break;
818 }
819 }
820 if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
821 DPRINTF(" Unknown (%08lx)", info);
822 }
823
824 DPRINTF(" Modifier:");
825 for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
826 if (modifier_flags[i].val & info_mod) {
827 DPRINTF(" %s", modifier_flags[i].name);
828 info_mod &= ~ modifier_flags[i].val;
829 }
830 }
831
832 if (info_mod) {
833 DPRINTF(" Unknown (%08lx)", info_mod);
834 }
835 DPRINTF("\n");
836 }
837
838 lpwhr = (LPWININETHTTPREQA) WININET_GetObject( hHttpRequest );
839 if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
840 {
841 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
842 goto lend;
843 }
844
845 /* Find requested header structure */
846 if ((dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK) == HTTP_QUERY_CUSTOM)
847 {
848 INT index = HTTP_GetCustomHeaderIndex(lpwhr, (LPSTR)lpBuffer);
849
850 if (index < 0)
851 goto lend;
852
853 lphttpHdr = &lpwhr->pCustHeaders[index];
854 }
855 else
856 {
857 INT index = dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK;
858
859 if (index == HTTP_QUERY_RAW_HEADERS_CRLF || index == HTTP_QUERY_RAW_HEADERS)
860 {
861 INT i, delim, size = 0, cnt = 0;
862
863 delim = index == HTTP_QUERY_RAW_HEADERS_CRLF ? 2 : 1;
864
865 /* Calculate length of custom reuqest headers */
866 for (i = 0; i < lpwhr->nCustHeaders; i++)
867 {
868 if ((~lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST) && lpwhr->pCustHeaders[i].lpszField &&
869 lpwhr->pCustHeaders[i].lpszValue)
870 {
871 size += strlen(lpwhr->pCustHeaders[i].lpszField) +
872 strlen(lpwhr->pCustHeaders[i].lpszValue) + delim + 2;
873 }
874 }
875
876 /* Calculate the length of stadard request headers */
877 for (i = 0; i <= HTTP_QUERY_MAX; i++)
878 {
879 if ((~lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST) && lpwhr->StdHeaders[i].lpszField &&
880 lpwhr->StdHeaders[i].lpszValue)
881 {
882 size += strlen(lpwhr->StdHeaders[i].lpszField) +
883 strlen(lpwhr->StdHeaders[i].lpszValue) + delim + 2;
884 }
885 }
886 size += delim;
887
888 if (size + 1 > *lpdwBufferLength)
889 {
890 *lpdwBufferLength = size + 1;
891 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
892 goto lend;
893 }
894
895 /* Append standard request heades */
896 for (i = 0; i <= HTTP_QUERY_MAX; i++)
897 {
898 if ((~lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST) &&
899 lpwhr->StdHeaders[i].lpszField &&
900 lpwhr->StdHeaders[i].lpszValue)
901 {
902 cnt += sprintf((char*)lpBuffer + cnt, "%s: %s%s", lpwhr->StdHeaders[i].lpszField, lpwhr->StdHeaders[i].lpszValue,
903 index == HTTP_QUERY_RAW_HEADERS_CRLF ? "\r\n" : "\0");
904 }
905 }
906
907 /* Append custom request heades */
908 for (i = 0; i < lpwhr->nCustHeaders; i++)
909 {
910 if ((~lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST) &&
911 lpwhr->pCustHeaders[i].lpszField &&
912 lpwhr->pCustHeaders[i].lpszValue)
913 {
914 cnt += sprintf((char*)lpBuffer + cnt, "%s: %s%s",
915 lpwhr->pCustHeaders[i].lpszField, lpwhr->pCustHeaders[i].lpszValue,
916 index == HTTP_QUERY_RAW_HEADERS_CRLF ? "\r\n" : "\0");
917 }
918 }
919
920 strcpy((char*)lpBuffer + cnt, index == HTTP_QUERY_RAW_HEADERS_CRLF ? "\r\n" : "");
921
922 *lpdwBufferLength = cnt + delim;
923 bSuccess = TRUE;
924 goto lend;
925 }
926 else if (index >= 0 && index <= HTTP_QUERY_MAX && lpwhr->StdHeaders[index].lpszValue)
927 {
928 lphttpHdr = &lpwhr->StdHeaders[index];
929 }
930 else
931 goto lend;
932 }
933
934 /* Ensure header satisifies requested attributes */
935 if ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
936 (~lphttpHdr->wFlags & HDR_ISREQUEST))
937 goto lend;
938
939 /* coalesce value to reuqested type */
940 if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER)
941 {
942 *(int *)lpBuffer = atoi(lphttpHdr->lpszValue);
943 bSuccess = TRUE;
944
945 TRACE(" returning number : %d\n", *(int *)lpBuffer);
946 }
947 else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME)
948 {
949 time_t tmpTime;
950 struct tm tmpTM;
951 SYSTEMTIME *STHook;
952
953 tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
954
955 tmpTM = *gmtime(&tmpTime);
956 STHook = (SYSTEMTIME *) lpBuffer;
957 if(STHook==NULL)
958 goto lend;
959
960 STHook->wDay = tmpTM.tm_mday;
961 STHook->wHour = tmpTM.tm_hour;
962 STHook->wMilliseconds = 0;
963 STHook->wMinute = tmpTM.tm_min;
964 STHook->wDayOfWeek = tmpTM.tm_wday;
965 STHook->wMonth = tmpTM.tm_mon + 1;
966 STHook->wSecond = tmpTM.tm_sec;
967 STHook->wYear = tmpTM.tm_year;
968
969 bSuccess = TRUE;
970
971 TRACE(" returning time : %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
972 STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
973 STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
974 }
975 else if (dwInfoLevel & HTTP_QUERY_FLAG_COALESCE)
976 {
977 if (*lpdwIndex >= lphttpHdr->wCount)
978 {
979 INTERNET_SetLastError(ERROR_HTTP_HEADER_NOT_FOUND);
980 }
981 else
982 {
983 /* Copy strncpy(lpBuffer, lphttpHdr[*lpdwIndex], len); */
984 (*lpdwIndex)++;
985 }
986 }
987 else
988 {
989 INT len = strlen(lphttpHdr->lpszValue);
990
991 if (len + 1 > *lpdwBufferLength)
992 {
993 *lpdwBufferLength = len + 1;
994 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
995 goto lend;
996 }
997
998 strncpy(lpBuffer, lphttpHdr->lpszValue, len);
999 ((char*)lpBuffer)[len]=0;
1000 *lpdwBufferLength = len;
1001 bSuccess = TRUE;
1002
1003 TRACE(" returning string : '%s'\n", debugstr_a(lpBuffer));
1004 }
1005
1006 lend:
1007 TRACE("%d <--\n", bSuccess);
1008 return bSuccess;
1009 }
1010
1011 /***********************************************************************
1012 * HttpQueryInfoW (WININET.@)
1013 *
1014 * Queries for information about an HTTP request
1015 *
1016 * RETURNS
1017 * TRUE on success
1018 * FALSE on failure
1019 *
1020 */
1021 BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel,
1022 LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
1023 {
1024 BOOL result;
1025 DWORD charLen=*lpdwBufferLength;
1026 char* tempBuffer=HeapAlloc(GetProcessHeap(), 0, charLen);
1027 result=HttpQueryInfoA(hHttpRequest, dwInfoLevel, tempBuffer, &charLen, lpdwIndex);
1028 if((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
1029 (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME))
1030 {
1031 memcpy(lpBuffer,tempBuffer,charLen);
1032 }
1033 else
1034 {
1035 int nChars=MultiByteToWideChar(CP_ACP,0, tempBuffer,charLen,lpBuffer,*lpdwBufferLength);
1036 *lpdwBufferLength=nChars;
1037 }
1038 HeapFree(GetProcessHeap(), 0, tempBuffer);
1039 return result;
1040 }
1041
1042 /***********************************************************************
1043 * HttpSendRequestExA (WININET.@)
1044 *
1045 * Sends the specified request to the HTTP server and allows chunked
1046 * transfers
1047 */
1048 BOOL WINAPI HttpSendRequestExA(HINTERNET hRequest,
1049 LPINTERNET_BUFFERSA lpBuffersIn,
1050 LPINTERNET_BUFFERSA lpBuffersOut,
1051 DWORD dwFlags, DWORD dwContext)
1052 {
1053 FIXME("(%p, %p, %p, %08lx, %08lx): stub\n", hRequest, lpBuffersIn,
1054 lpBuffersOut, dwFlags, dwContext);
1055 return FALSE;
1056 }
1057
1058 /***********************************************************************
1059 * HttpSendRequestA (WININET.@)
1060 *
1061 * Sends the specified request to the HTTP server
1062 *
1063 * RETURNS
1064 * TRUE on success
1065 * FALSE on failure
1066 *
1067 */
1068 BOOL WINAPI HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
1069 DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1070 {
1071 LPWININETHTTPREQA lpwhr;
1072 LPWININETHTTPSESSIONA lpwhs = NULL;
1073 LPWININETAPPINFOA hIC = NULL;
1074
1075 TRACE("%p, %p (%s), %li, %p, %li)\n", hHttpRequest,
1076 lpszHeaders, debugstr_a(lpszHeaders), dwHeaderLength, lpOptional, dwOptionalLength);
1077
1078 lpwhr = (LPWININETHTTPREQA) WININET_GetObject( hHttpRequest );
1079 if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
1080 {
1081 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1082 return FALSE;
1083 }
1084
1085 lpwhs = (LPWININETHTTPSESSIONA) lpwhr->hdr.lpwhparent;
1086 if (NULL == lpwhs || lpwhs->hdr.htype != WH_HHTTPSESSION)
1087 {
1088 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1089 return FALSE;
1090 }
1091
1092 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
1093 if (NULL == hIC || hIC->hdr.htype != WH_HINIT)
1094 {
1095 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1096 return FALSE;
1097 }
1098
1099 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1100 {
1101 WORKREQUEST workRequest;
1102 struct WORKREQ_HTTPSENDREQUESTA *req;
1103
1104 workRequest.asyncall = HTTPSENDREQUESTA;
1105 workRequest.handle = hHttpRequest;
1106 req = &workRequest.u.HttpSendRequestA;
1107 if (lpszHeaders)
1108 req->lpszHeader = WININET_strdup(lpszHeaders);
1109 else
1110 req->lpszHeader = 0;
1111 req->dwHeaderLength = dwHeaderLength;
1112 req->lpOptional = lpOptional;
1113 req->dwOptionalLength = dwOptionalLength;
1114
1115 INTERNET_AsyncCall(&workRequest);
1116 /*
1117 * This is from windows.
1118 */
1119 SetLastError(ERROR_IO_PENDING);
1120 return 0;
1121 }
1122 else
1123 {
1124 return HTTP_HttpSendRequestA(hHttpRequest, lpszHeaders,
1125 dwHeaderLength, lpOptional, dwOptionalLength);
1126 }
1127 }
1128
1129 /***********************************************************************
1130 * HttpSendRequestW (WININET.@)
1131 *
1132 * Sends the specified request to the HTTP server
1133 *
1134 * RETURNS
1135 * TRUE on success
1136 * FALSE on failure
1137 *
1138 */
1139 BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
1140 DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1141 {
1142 BOOL result;
1143 char* szHeaders=NULL;
1144 DWORD nLen=dwHeaderLength;
1145 if(lpszHeaders!=NULL)
1146 {
1147 nLen=WideCharToMultiByte(CP_ACP,0,lpszHeaders,dwHeaderLength,NULL,0,NULL,NULL);
1148 szHeaders=HeapAlloc(GetProcessHeap(),0,nLen);
1149 WideCharToMultiByte(CP_ACP,0,lpszHeaders,dwHeaderLength,szHeaders,nLen,NULL,NULL);
1150 }
1151 result=HttpSendRequestA(hHttpRequest, szHeaders, nLen, lpOptional, dwOptionalLength);
1152 if(szHeaders!=NULL)
1153 HeapFree(GetProcessHeap(),0,szHeaders);
1154 return result;
1155 }
1156
1157 /***********************************************************************
1158 * HTTP_HandleRedirect (internal)
1159 */
1160 static BOOL HTTP_HandleRedirect(LPWININETHTTPREQA lpwhr, LPCSTR lpszUrl, LPCSTR lpszHeaders,
1161 DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength)
1162 {
1163 LPWININETHTTPSESSIONA lpwhs = (LPWININETHTTPSESSIONA) lpwhr->hdr.lpwhparent;
1164 LPWININETAPPINFOA hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
1165 char path[2048];
1166 HINTERNET handle;
1167
1168 if(lpszUrl[0]=='/')
1169 {
1170 /* if it's an absolute path, keep the same session info */
1171 strcpy(path,lpszUrl);
1172 }
1173 else if (NULL != hIC->lpszProxy && hIC->lpszProxy[0] != 0)
1174 {
1175 TRACE("Redirect through proxy\n");
1176 strcpy(path,lpszUrl);
1177 }
1178 else
1179 {
1180 URL_COMPONENTSA urlComponents;
1181 char protocol[32], hostName[MAXHOSTNAME], userName[1024];
1182 char password[1024], extra[1024];
1183 urlComponents.dwStructSize = sizeof(URL_COMPONENTSA);
1184 urlComponents.lpszScheme = protocol;
1185 urlComponents.dwSchemeLength = 32;
1186 urlComponents.lpszHostName = hostName;
1187 urlComponents.dwHostNameLength = MAXHOSTNAME;
1188 urlComponents.lpszUserName = userName;
1189 urlComponents.dwUserNameLength = 1024;
1190 urlComponents.lpszPassword = password;
1191 urlComponents.dwPasswordLength = 1024;
1192 urlComponents.lpszUrlPath = path;
1193 urlComponents.dwUrlPathLength = 2048;
1194 urlComponents.lpszExtraInfo = extra;
1195 urlComponents.dwExtraInfoLength = 1024;
1196 if(!InternetCrackUrlA(lpszUrl, strlen(lpszUrl), 0, &urlComponents))
1197 return FALSE;
1198
1199 if (urlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
1200 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
1201
1202 #if 0
1203 /*
1204 * This upsets redirects to binary files on sourceforge.net
1205 * and gives an html page instead of the target file
1206 * Examination of the HTTP request sent by native wininet.dll
1207 * reveals that it doesn't send a referrer in that case.
1208 * Maybe there's a flag that enables this, or maybe a referrer
1209 * shouldn't be added in case of a redirect.
1210 */
1211
1212 /* consider the current host as the referrer */
1213 if (NULL != lpwhs->lpszServerName && strlen(lpwhs->lpszServerName))
1214 HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpwhs->lpszServerName,
1215 HTTP_ADDHDR_FLAG_REQ|HTTP_ADDREQ_FLAG_REPLACE|
1216 HTTP_ADDHDR_FLAG_ADD_IF_NEW);
1217 #endif
1218
1219 if (NULL != lpwhs->lpszServerName)
1220 HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
1221 lpwhs->lpszServerName = WININET_strdup(hostName);
1222 if (NULL != lpwhs->lpszUserName)
1223 HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
1224 lpwhs->lpszUserName = WININET_strdup(userName);
1225 lpwhs->nServerPort = urlComponents.nPort;
1226
1227 if (NULL != lpwhr->lpszHostName)
1228 HeapFree(GetProcessHeap(), 0, lpwhr->lpszHostName);
1229 lpwhr->lpszHostName=WININET_strdup(hostName);
1230
1231 SendAsyncCallback(hIC, lpwhs, lpwhr->hdr.dwContext,
1232 INTERNET_STATUS_RESOLVING_NAME,
1233 lpwhs->lpszServerName,
1234 strlen(lpwhs->lpszServerName)+1);
1235
1236 if (!GetAddress(lpwhs->lpszServerName, lpwhs->nServerPort,
1237 &lpwhs->phostent, &lpwhs->socketAddress))
1238 {
1239 INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
1240 return FALSE;
1241 }
1242
1243 SendAsyncCallback(hIC, lpwhs, lpwhr->hdr.dwContext,
1244 INTERNET_STATUS_NAME_RESOLVED,
1245 &(lpwhs->socketAddress),
1246 sizeof(struct sockaddr_in));
1247
1248 }
1249
1250 if(lpwhr->lpszPath)
1251 HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
1252 lpwhr->lpszPath=NULL;
1253 if (strlen(path))
1254 {
1255 DWORD needed = 0;
1256 HRESULT rc;
1257 rc = UrlEscapeA(path, NULL, &needed, URL_ESCAPE_SPACES_ONLY);
1258 if (rc != E_POINTER)
1259 needed = strlen(path)+1;
1260 lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, needed);
1261 rc = UrlEscapeA(path, lpwhr->lpszPath, &needed,
1262 URL_ESCAPE_SPACES_ONLY);
1263 if (rc)
1264 {
1265 ERR("Unable to escape string!(%s) (%ld)\n",path,rc);
1266 strcpy(lpwhr->lpszPath,path);
1267 }
1268 }
1269
1270 handle = WININET_FindHandle( &lpwhr->hdr );
1271 return HttpSendRequestA(handle, lpszHeaders, dwHeaderLength, lpOptional, dwOptionalLength);
1272 }
1273
1274 /***********************************************************************
1275 * HTTP_HttpSendRequestA (internal)
1276 *
1277 * Sends the specified request to the HTTP server
1278 *
1279 * RETURNS
1280 * TRUE on success
1281 * FALSE on failure
1282 *
1283 */
1284 BOOL WINAPI HTTP_HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
1285 DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1286 {
1287 INT cnt;
1288 INT i;
1289 BOOL bSuccess = FALSE;
1290 LPSTR requestString = NULL;
1291 LPSTR lpszHeaders_r_n = NULL; /* lpszHeaders with atleast one pair of \r\n at the end */
1292 INT requestStringLen;
1293 INT responseLen;
1294 INT headerLength = 0;
1295 LPWININETHTTPREQA lpwhr;
1296 LPWININETHTTPSESSIONA lpwhs = NULL;
1297 LPWININETAPPINFOA hIC = NULL;
1298 BOOL loop_next = FALSE;
1299 int CustHeaderIndex;
1300
1301 TRACE("--> 0x%08lx\n", (ULONG)hHttpRequest);
1302
1303 /* Verify our tree of internet handles */
1304 lpwhr = (LPWININETHTTPREQA) WININET_GetObject( hHttpRequest );
1305 if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
1306 {
1307 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1308 return FALSE;
1309 }
1310
1311 lpwhs = (LPWININETHTTPSESSIONA) lpwhr->hdr.lpwhparent;
1312 if (NULL == lpwhs || lpwhs->hdr.htype != WH_HHTTPSESSION)
1313 {
1314 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1315 return FALSE;
1316 }
1317
1318 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
1319 if (NULL == hIC || hIC->hdr.htype != WH_HINIT)
1320 {
1321 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1322 return FALSE;
1323 }
1324
1325 /* Clear any error information */
1326 INTERNET_SetLastError(0);
1327
1328
1329 /* We must have a verb */
1330 if (NULL == lpwhr->lpszVerb)
1331 {
1332 goto lend;
1333 }
1334
1335 /* if we are using optional stuff, we must add the fixed header of that option length */
1336 if (lpOptional && dwOptionalLength)
1337 {
1338 char contentLengthStr[sizeof("Content-Length: ") + 20 /* int */ + 2 /* \n\r */];
1339 sprintf(contentLengthStr, "Content-Length: %li\r\n", dwOptionalLength);
1340 HttpAddRequestHeadersA(hHttpRequest, contentLengthStr, -1L, HTTP_ADDREQ_FLAG_ADD);
1341 }
1342
1343 do
1344 {
1345 TRACE("Going to url %s %s\n", debugstr_a(lpwhr->lpszHostName), debugstr_a(lpwhr->lpszPath));
1346 loop_next = FALSE;
1347
1348 /* If we don't have a path we set it to root */
1349 if (NULL == lpwhr->lpszPath)
1350 lpwhr->lpszPath = WININET_strdup("/");
1351
1352 if(strncmp(lpwhr->lpszPath, "http://", sizeof("http://") -1) != 0
1353 && lpwhr->lpszPath[0] != '/') /* not an absolute path ?? --> fix it !! */
1354 {
1355 char *fixurl = HeapAlloc(GetProcessHeap(), 0, strlen(lpwhr->lpszPath) + 2);
1356 *fixurl = '/';
1357 strcpy(fixurl + 1, lpwhr->lpszPath);
1358 HeapFree( GetProcessHeap(), 0, lpwhr->lpszPath );
1359 lpwhr->lpszPath = fixurl;
1360 }
1361
1362 /* Calculate length of request string */
1363 requestStringLen =
1364 strlen(lpwhr->lpszVerb) +
1365 strlen(lpwhr->lpszPath) +
1366 strlen(HTTPHEADER) +
1367 5; /* " \r\n\r\n" */
1368
1369 /* add "\r\n" to end of lpszHeaders if needed */
1370 if (lpszHeaders)
1371 {
1372 int len = strlen(lpszHeaders);
1373
1374 /* Check if the string is terminated with \r\n, but not if
1375 * the string is less that 2 characters long, because then
1376 * we would be looking at memory before the beginning of
1377 * the string. Besides, if it is less than 2 characters
1378 * long, then clearly, its not terminated with \r\n.
1379 */
1380 if ((len > 2) && (memcmp(lpszHeaders + (len - 2), "\r\n", 2) == 0))
1381 {
1382 lpszHeaders_r_n = WININET_strdup(lpszHeaders);
1383 }
1384 else
1385 {
1386 TRACE("Adding \r\n to lpszHeaders.\n");
1387 lpszHeaders_r_n = HeapAlloc( GetProcessHeap(), 0, strlen(lpszHeaders) + 3 );
1388 strcpy( lpszHeaders_r_n, lpszHeaders );
1389 strcpy( lpszHeaders_r_n + strlen(lpszHeaders), "\r\n" );
1390 }
1391 }
1392
1393 /* Add length of passed headers */
1394 if (lpszHeaders)
1395 {
1396 headerLength = -1 == dwHeaderLength ? strlen(lpszHeaders_r_n) : dwHeaderLength;
1397 requestStringLen += headerLength + 2; /* \r\n */
1398 }
1399
1400
1401 /* if there isa proxy username and password, add it to the headers */
1402 if( hIC && (hIC->lpszProxyUsername || hIC->lpszProxyPassword ) )
1403 {
1404 HTTP_InsertProxyAuthorization( lpwhr, hIC->lpszProxyUsername, hIC->lpszProxyPassword );
1405 }
1406
1407 /* Calculate length of custom request headers */
1408 for (i = 0; i < lpwhr->nCustHeaders; i++)
1409 {
1410 if (lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST)
1411 {
1412 requestStringLen += strlen(lpwhr->pCustHeaders[i].lpszField) +
1413 strlen(lpwhr->pCustHeaders[i].lpszValue) + 4; /*: \r\n */
1414 }
1415 }
1416
1417 /* Calculate the length of standard request headers */
1418 for (i = 0; i <= HTTP_QUERY_MAX; i++)
1419 {
1420 if (lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST)
1421 {
1422 requestStringLen += strlen(lpwhr->StdHeaders[i].lpszField) +
1423 strlen(lpwhr->StdHeaders[i].lpszValue) + 4; /*: \r\n */
1424 }
1425 }
1426
1427 if (lpwhr->lpszHostName)
1428 requestStringLen += (strlen(HTTPHOSTHEADER) + strlen(lpwhr->lpszHostName));
1429
1430 /* if there is optional data to send, add the length */
1431 if (lpOptional)
1432 {
1433 requestStringLen += dwOptionalLength;
1434 }
1435
1436 /* Allocate string to hold entire request */
1437 requestString = HeapAlloc(GetProcessHeap(), 0, requestStringLen + 1);
1438 if (NULL == requestString)
1439 {
1440 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1441 goto lend;
1442 }
1443
1444 /* Build request string */
1445 cnt = sprintf(requestString, "%s %s%s",
1446 lpwhr->lpszVerb,
1447 lpwhr->lpszPath,
1448 HTTPHEADER);
1449
1450 /* Append standard request headers */
1451 for (i = 0; i <= HTTP_QUERY_MAX; i++)
1452 {
1453 if (lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST)
1454 {
1455 cnt += sprintf(requestString + cnt, "\r\n%s: %s",
1456 lpwhr->StdHeaders[i].lpszField, lpwhr->StdHeaders[i].lpszValue);
1457 TRACE("Adding header %s (%s)\n",lpwhr->StdHeaders[i].lpszField,lpwhr->StdHeaders[i].lpszValue);
1458 }
1459 }
1460
1461 /* Append custom request heades */
1462 for (i = 0; i < lpwhr->nCustHeaders; i++)
1463 {
1464 if (lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST)
1465 {
1466 cnt += sprintf(requestString + cnt, "\r\n%s: %s",
1467 lpwhr->pCustHeaders[i].lpszField, lpwhr->pCustHeaders[i].lpszValue);
1468 TRACE("Adding custom header %s (%s)\n",lpwhr->pCustHeaders[i].lpszField,lpwhr->pCustHeaders[i].lpszValue);
1469 }
1470 }
1471
1472 if (lpwhr->lpszHostName)
1473 cnt += sprintf(requestString + cnt, "%s%s", HTTPHOSTHEADER, lpwhr->lpszHostName);
1474
1475 /* Append passed request headers */
1476 if (lpszHeaders_r_n)
1477 {
1478 strcpy(requestString + cnt, "\r\n");
1479 cnt += 2;
1480 strcpy(requestString + cnt, lpszHeaders_r_n);
1481 cnt += headerLength;
1482 /* only add \r\n if not already present */
1483 if (memcmp((requestString + cnt) - 2, "\r\n", 2) != 0)
1484 {
1485 strcpy(requestString + cnt, "\r\n");
1486 cnt += 2;
1487 }
1488 }
1489
1490 /* Set (header) termination string for request */
1491 if (memcmp((requestString + cnt) - 4, "\r\n\r\n", 4) != 0)
1492 { /* only add it if the request string doesn't already
1493 have the thing.. (could happen if the custom header
1494 added it */
1495 strcpy(requestString + cnt, "\r\n");
1496 cnt += 2;
1497 }
1498 else
1499 requestStringLen -= 2;
1500
1501 /* if optional data, append it */
1502 if (lpOptional)
1503 {
1504 memcpy(requestString + cnt, lpOptional, dwOptionalLength);
1505 cnt += dwOptionalLength;
1506 /* we also have to decrease the expected string length by two,
1507 * since we won't be adding on those following \r\n's */
1508 requestStringLen -= 2;
1509 }
1510 else
1511 { /* if there is no optional data, add on another \r\n just to be safe */
1512 /* termination for request */
1513 strcpy(requestString + cnt, "\r\n");
1514 cnt += 2;
1515 }
1516
1517 TRACE("(%s) len(%d)\n", requestString, requestStringLen);
1518 /* Send the request and store the results */
1519 if (!HTTP_OpenConnection(lpwhr))
1520 goto lend;
1521
1522 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1523 INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
1524
1525 NETCON_send(&lpwhr->netConnection, requestString, requestStringLen,
1526 0, &cnt);
1527
1528
1529 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1530 INTERNET_STATUS_REQUEST_SENT,
1531 &requestStringLen,sizeof(DWORD));
1532
1533 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1534 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
1535
1536 if (cnt < 0)
1537 goto lend;
1538
1539 responseLen = HTTP_GetResponseHeaders(lpwhr);
1540 if (responseLen)
1541 bSuccess = TRUE;
1542
1543 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1544 INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen,
1545 sizeof(DWORD));
1546
1547 /* process headers here. Is this right? */
1548 CustHeaderIndex = HTTP_GetCustomHeaderIndex(lpwhr, "Set-Cookie");
1549 if (CustHeaderIndex >= 0)
1550 {
1551 LPHTTPHEADERA setCookieHeader;
1552 int nPosStart = 0, nPosEnd = 0;
1553
1554 setCookieHeader = &lpwhr->pCustHeaders[CustHeaderIndex];
1555
1556 while (setCookieHeader->lpszValue[nPosEnd] != '\0')
1557 {
1558 LPSTR buf_cookie, cookie_name, cookie_data;
1559 LPSTR buf_url;
1560 LPSTR domain = NULL;
1561 int nEqualPos = 0;
1562 while (setCookieHeader->lpszValue[nPosEnd] != ';' && setCookieHeader->lpszValue[nPosEnd] != ',' &&
1563 setCookieHeader->lpszValue[nPosEnd] != '\0')
1564 {
1565 nPosEnd++;
1566 }
1567 if (setCookieHeader->lpszValue[nPosEnd] == ';')
1568 {
1569 /* fixme: not case sensitive, strcasestr is gnu only */
1570 int nDomainPosEnd = 0;
1571 int nDomainPosStart = 0, nDomainLength = 0;
1572 LPSTR lpszDomain = strstr(&setCookieHeader->lpszValue[nPosEnd], "domain=");
1573 if (lpszDomain)
1574 { /* they have specified their own domain, lets use it */
1575 while (lpszDomain[nDomainPosEnd] != ';' && lpszDomain[nDomainPosEnd] != ',' &&
1576 lpszDomain[nDomainPosEnd] != '\0')
1577 {
1578 nDomainPosEnd++;
1579 }
1580 nDomainPosStart = strlen("domain=");
1581 nDomainLength = (nDomainPosEnd - nDomainPosStart) + 1;
1582 domain = HeapAlloc(GetProcessHeap(), 0, nDomainLength + 1);
1583 strncpy(domain, &lpszDomain[nDomainPosStart], nDomainLength);
1584 domain[nDomainLength] = '\0';
1585 }
1586 }
1587 if (setCookieHeader->lpszValue[nPosEnd] == '\0') break;
1588 buf_cookie = HeapAlloc(GetProcessHeap(), 0, (nPosEnd - nPosStart) + 1);
1589 strncpy(buf_cookie, &setCookieHeader->lpszValue[nPosStart], (nPosEnd - nPosStart));
1590 buf_cookie[(nPosEnd - nPosStart)] = '\0';
1591 TRACE("%s\n", buf_cookie);
1592 while (buf_cookie[nEqualPos] != '=' && buf_cookie[nEqualPos] != '\0')
1593 {
1594 nEqualPos++;
1595 }
1596 if (buf_cookie[nEqualPos] == '\0' || buf_cookie[nEqualPos + 1] == '\0')
1597 {
1598 HeapFree(GetProcessHeap(), 0, buf_cookie);
1599 break;
1600 }
1601
1602 cookie_name = HeapAlloc(GetProcessHeap(), 0, nEqualPos + 1);
1603 strncpy(cookie_name, buf_cookie, nEqualPos);
1604 cookie_name[nEqualPos] = '\0';
1605 cookie_data = &buf_cookie[nEqualPos + 1];
1606
1607
1608 buf_url = HeapAlloc(GetProcessHeap(), 0, strlen((domain ? domain : lpwhr->lpszHostName)) + strlen(lpwhr->lpszPath) + 9);
1609 sprintf(buf_url, "http://%s/", (domain ? domain : lpwhr->lpszHostName)); /* FIXME PATH!!! */
1610 InternetSetCookieA(buf_url, cookie_name, cookie_data);
1611
1612 HeapFree(GetProcessHeap(), 0, buf_url);
1613 HeapFree(GetProcessHeap(), 0, buf_cookie);
1614 HeapFree(GetProcessHeap(), 0, cookie_name);
1615 if (domain) HeapFree(GetProcessHeap(), 0, domain);
1616 nPosStart = nPosEnd;
1617 }
1618 }
1619 }
1620 while (loop_next);
1621
1622 lend:
1623
1624 if (requestString)
1625 HeapFree(GetProcessHeap(), 0, requestString);
1626
1627 if (lpszHeaders)
1628 HeapFree(GetProcessHeap(), 0, lpszHeaders_r_n);
1629
1630 /* TODO: send notification for P3P header */
1631
1632 if(!(hIC->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT) && bSuccess)
1633 {
1634 DWORD dwCode,dwCodeLength=sizeof(DWORD),dwIndex=0;
1635 if(HttpQueryInfoA(hHttpRequest,HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,&dwCode,&dwCodeLength,&dwIndex) &&
1636 (dwCode==302 || dwCode==301))
1637 {
1638 char szNewLocation[2048];
1639 DWORD dwBufferSize=2048;
1640 dwIndex=0;
1641 if(HttpQueryInfoA(hHttpRequest,HTTP_QUERY_LOCATION,szNewLocation,&dwBufferSize,&dwIndex))
1642 {
1643 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1644 INTERNET_STATUS_REDIRECT, szNewLocation,
1645 dwBufferSize);
1646 return HTTP_HandleRedirect(lpwhr, szNewLocation, lpszHeaders,
1647 dwHeaderLength, lpOptional, dwOptionalLength);
1648 }
1649 }
1650 }
1651
1652 if (hIC->lpfnStatusCB)
1653 {
1654 INTERNET_ASYNC_RESULT iar;
1655
1656 iar.dwResult = (DWORD)bSuccess;
1657 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1658
1659 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1660 INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1661 sizeof(INTERNET_ASYNC_RESULT));
1662 }
1663
1664 TRACE("<--\n");
1665 return bSuccess;
1666 }
1667
1668
1669 /***********************************************************************
1670 * HTTP_Connect (internal)
1671 *
1672 * Create http session handle
1673 *
1674 * RETURNS
1675 * HINTERNET a session handle on success
1676 * NULL on failure
1677 *
1678 */
1679 HINTERNET HTTP_Connect(HINTERNET hInternet, LPCSTR lpszServerName,
1680 INTERNET_PORT nServerPort, LPCSTR lpszUserName,
1681 LPCSTR lpszPassword, DWORD dwFlags, DWORD dwContext)
1682 {
1683 BOOL bSuccess = FALSE;
1684 LPWININETAPPINFOA hIC = NULL;
1685 LPWININETHTTPSESSIONA lpwhs = NULL;
1686 HINTERNET handle = NULL;
1687
1688 TRACE("-->\n");
1689
1690 hIC = (LPWININETAPPINFOA) WININET_GetObject( hInternet );
1691 if( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
1692 goto lerror;
1693
1694 hIC->hdr.dwContext = dwContext;
1695
1696 lpwhs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPSESSIONA));
1697 if (NULL == lpwhs)
1698 {
1699 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1700 goto lerror;
1701 }
1702
1703 handle = WININET_AllocHandle( &lpwhs->hdr );
1704 if (NULL == handle)
1705 {
1706 ERR("Failed to alloc handle\n");
1707 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1708 goto lerror;
1709 }
1710
1711 /*
1712 * According to my tests. The name is not resolved until a request is sent
1713 */
1714
1715 if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
1716 nServerPort = INTERNET_DEFAULT_HTTP_PORT;
1717
1718 lpwhs->hdr.htype = WH_HHTTPSESSION;
1719 lpwhs->hdr.lpwhparent = &hIC->hdr;
1720 lpwhs->hdr.dwFlags = dwFlags;
1721 lpwhs->hdr.dwContext = dwContext;
1722 if(hIC->lpszProxy && hIC->dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
1723 if(strchr(hIC->lpszProxy, ' '))
1724 FIXME("Several proxies not implemented.\n");
1725 if(hIC->lpszProxyBypass)
1726 FIXME("Proxy bypass is ignored.\n");
1727 }
1728 if (NULL != lpszServerName)
1729 lpwhs->lpszServerName = WININET_strdup(lpszServerName);
1730 if (NULL != lpszUserName)
1731 lpwhs->lpszUserName = WININET_strdup(lpszUserName);
1732 lpwhs->nServerPort = nServerPort;
1733
1734 if (hIC->lpfnStatusCB)
1735 {
1736 INTERNET_ASYNC_RESULT iar;
1737
1738 iar.dwResult = (DWORD)handle;
1739 iar.dwError = ERROR_SUCCESS;
1740
1741 SendAsyncCallback(hIC, hInternet, dwContext,
1742 INTERNET_STATUS_HANDLE_CREATED, &iar,
1743 sizeof(INTERNET_ASYNC_RESULT));
1744 }
1745
1746 bSuccess = TRUE;
1747
1748 lerror:
1749 if (!bSuccess && lpwhs)
1750 {
1751 HeapFree(GetProcessHeap(), 0, lpwhs);
1752 WININET_FreeHandle( handle );
1753 lpwhs = NULL;
1754 }
1755
1756 /*
1757 * a INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
1758 * windows
1759 */
1760
1761 TRACE("%p --> %p\n", hInternet, handle);
1762 return handle;
1763 }
1764
1765
1766 /***********************************************************************
1767 * HTTP_OpenConnection (internal)
1768 *
1769 * Connect to a web server
1770 *
1771 * RETURNS
1772 *
1773 * TRUE on success
1774 * FALSE on failure
1775 */
1776 BOOL HTTP_OpenConnection(LPWININETHTTPREQA lpwhr)
1777 {
1778 BOOL bSuccess = FALSE;
1779 LPWININETHTTPSESSIONA lpwhs;
1780 LPWININETAPPINFOA hIC = NULL;
1781
1782 TRACE("-->\n");
1783
1784
1785 if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
1786 {
1787 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1788 goto lend;
1789 }
1790
1791 lpwhs = (LPWININETHTTPSESSIONA)lpwhr->hdr.lpwhparent;
1792
1793 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
1794 SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
1795 INTERNET_STATUS_CONNECTING_TO_SERVER,
1796 &(lpwhs->socketAddress),
1797 sizeof(struct sockaddr_in));
1798
1799 if (!NETCON_create(&lpwhr->netConnection, lpwhs->phostent->h_addrtype,
1800 SOCK_STREAM, 0))
1801 {
1802 WARN("Socket creation failed\n");
1803 goto lend;
1804 }
1805
1806 if (!NETCON_connect(&lpwhr->netConnection, (struct sockaddr *)&lpwhs->socketAddress,
1807 sizeof(lpwhs->socketAddress)))
1808 {
1809 WARN("Unable to connect to host (%s)\n", strerror(errno));
1810 goto lend;
1811 }
1812
1813 SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
1814 INTERNET_STATUS_CONNECTED_TO_SERVER,
1815 &(lpwhs->socketAddress),
1816 sizeof(struct sockaddr_in));
1817
1818 bSuccess = TRUE;
1819
1820 lend:
1821 TRACE("%d <--\n", bSuccess);
1822 return bSuccess;
1823 }
1824
1825
1826 /***********************************************************************
1827 * HTTP_GetResponseHeaders (internal)
1828 *
1829 * Read server response
1830 *
1831 * RETURNS
1832 *
1833 * TRUE on success
1834 * FALSE on error
1835 */
1836 BOOL HTTP_GetResponseHeaders(LPWININETHTTPREQA lpwhr)
1837 {
1838 INT cbreaks = 0;
1839 CHAR buffer[MAX_REPLY_LEN];
1840 DWORD buflen = MAX_REPLY_LEN;
1841 BOOL bSuccess = FALSE;
1842 INT rc = 0;
1843 CHAR value[MAX_FIELD_VALUE_LEN], field[MAX_FIELD_LEN];
1844
1845 TRACE("-->\n");
1846
1847 if (!NETCON_connected(&lpwhr->netConnection))
1848 goto lend;
1849
1850 /*
1851 * HACK peek at the buffer
1852 */
1853 NETCON_recv(&lpwhr->netConnection, buffer, buflen, MSG_PEEK, &rc);
1854
1855 /*
1856 * We should first receive 'HTTP/1.x nnn' where nnn is the status code.
1857 */
1858 buflen = MAX_REPLY_LEN;
1859 memset(buffer, 0, MAX_REPLY_LEN);
1860 if (!NETCON_getNextLine(&lpwhr->netConnection, buffer, &buflen))
1861 goto lend;
1862
1863 if (strncmp(buffer, "HTTP", 4) != 0)
1864 goto lend;
1865
1866 buffer[12]='\0';
1867 HTTP_ProcessHeader(lpwhr, "Status", buffer+9, (HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE));
1868
1869 /* Parse each response line */
1870 do
1871 {
1872 buflen = MAX_REPLY_LEN;
1873 if (NETCON_getNextLine(&lpwhr->netConnection, buffer, &buflen))
1874 {
1875 TRACE("got line %s, now interpretting\n", debugstr_a(buffer));
1876 if (!HTTP_InterpretHttpHeader(buffer, field, MAX_FIELD_LEN, value, MAX_FIELD_VALUE_LEN))
1877 break;
1878
1879 HTTP_ProcessHeader(lpwhr, field, value, (HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE));
1880 }
1881 else
1882 {
1883 cbreaks++;
1884 if (cbreaks >= 2)
1885 break;
1886 }
1887 }while(1);
1888
1889 bSuccess = TRUE;
1890
1891 lend:
1892
1893 TRACE("<--\n");
1894 if (bSuccess)
1895 return rc;
1896 else
1897 return FALSE;
1898 }
1899
1900
1901 /***********************************************************************
1902 * HTTP_InterpretHttpHeader (internal)
1903 *
1904 * Parse server response
1905 *
1906 * RETURNS
1907 *
1908 * TRUE on success
1909 * FALSE on error
1910 */
1911 INT stripSpaces(LPCSTR lpszSrc, LPSTR lpszStart, INT *len)
1912 {
1913 LPCSTR lpsztmp;
1914 INT srclen;
1915
1916 srclen = 0;
1917
1918 while (*lpszSrc == ' ' && *lpszSrc != '\0')
1919 lpszSrc++;
1920
1921 lpsztmp = lpszSrc;
1922 while(*lpsztmp != '\0')
1923 {
1924 if (*lpsztmp != ' ')
1925 srclen = lpsztmp - lpszSrc + 1;
1926
1927 lpsztmp++;
1928 }
1929
1930 *len = min(*len, srclen);
1931 strncpy(lpszStart, lpszSrc, *len);
1932 lpszStart[*len] = '\0';
1933
1934 return *len;
1935 }
1936
1937
1938 BOOL HTTP_InterpretHttpHeader(LPSTR buffer, LPSTR field, INT fieldlen, LPSTR value, INT valuelen)
1939 {
1940 CHAR *pd;
1941 BOOL bSuccess = FALSE;
1942
1943 TRACE("\n");
1944
1945 *field = '\0';
1946 *value = '\0';
1947
1948 pd = strchr(buffer, ':');
1949 if (pd)
1950 {
1951 *pd = '\0';
1952 if (stripSpaces(buffer, field, &fieldlen) > 0)
1953 {
1954 if (stripSpaces(pd+1, value, &valuelen) > 0)
1955 bSuccess = TRUE;
1956 }
1957 }
1958
1959 TRACE("%d: field(%s) Value(%s)\n", bSuccess, field, value);
1960 return bSuccess;
1961 }
1962
1963
1964 /***********************************************************************
1965 * HTTP_GetStdHeaderIndex (internal)
1966 *
1967 * Lookup field index in standard http header array
1968 *
1969 * FIXME: This should be stuffed into a hash table
1970 */
1971 INT HTTP_GetStdHeaderIndex(LPCSTR lpszField)
1972 {
1973 INT index = -1;
1974
1975 if (!strcasecmp(lpszField, "Content-Length"))
1976 index = HTTP_QUERY_CONTENT_LENGTH;
1977 else if (!strcasecmp(lpszField,"Status"))
1978 index = HTTP_QUERY_STATUS_CODE;
1979 else if (!strcasecmp(lpszField,"Content-Type"))
1980 index = HTTP_QUERY_CONTENT_TYPE;
1981 else if (!strcasecmp(lpszField,"Last-Modified"))
1982 index = HTTP_QUERY_LAST_MODIFIED;
1983 else if (!strcasecmp(lpszField,"Location"))
1984 index = HTTP_QUERY_LOCATION;
1985 else if (!strcasecmp(lpszField,"Accept"))
1986 index = HTTP_QUERY_ACCEPT;
1987 else if (!strcasecmp(lpszField,"Referer"))
1988 index = HTTP_QUERY_REFERER;
1989 else if (!strcasecmp(lpszField,"Content-Transfer-Encoding"))
1990 index = HTTP_QUERY_CONTENT_TRANSFER_ENCODING;
1991 else if (!strcasecmp(lpszField,"Date"))
1992 index = HTTP_QUERY_DATE;
1993 else if (!strcasecmp(lpszField,"Server"))
1994 index = HTTP_QUERY_SERVER;
1995 else if (!strcasecmp(lpszField,"Connection"))
1996 index = HTTP_QUERY_CONNECTION;
1997 else if (!strcasecmp(lpszField,"ETag"))
1998 index = HTTP_QUERY_ETAG;
1999 else if (!strcasecmp(lpszField,"Accept-Ranges"))
2000 index = HTTP_QUERY_ACCEPT_RANGES;
2001 else if (!strcasecmp(lpszField,"Expires"))
2002 index = HTTP_QUERY_EXPIRES;
2003 else if (!strcasecmp(lpszField,"Mime-Version"))
2004 index = HTTP_QUERY_MIME_VERSION;
2005 else if (!strcasecmp(lpszField,"Pragma"))
2006 index = HTTP_QUERY_PRAGMA;
2007 else if (!strcasecmp(lpszField,"Cache-Control"))
2008 index = HTTP_QUERY_CACHE_CONTROL;
2009 else if (!strcasecmp(lpszField,"Content-Length"))
2010 index = HTTP_QUERY_CONTENT_LENGTH;
2011 else if (!strcasecmp(lpszField,"User-Agent"))
2012 index = HTTP_QUERY_USER_AGENT;
2013 else if (!strcasecmp(lpszField,"Proxy-Authenticate"))
2014 index = HTTP_QUERY_PROXY_AUTHENTICATE;
2015 else
2016 {
2017 TRACE("Couldn't find %s in standard header table\n", lpszField);
2018 }
2019
2020 return index;
2021 }
2022
2023
2024 /***********************************************************************
2025 * HTTP_ProcessHeader (internal)
2026 *
2027 * Stuff header into header tables according to <dwModifier>
2028 *
2029 */
2030
2031 #define COALESCEFLASG (HTTP_ADDHDR_FLAG_COALESCE|HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
2032
2033 BOOL HTTP_ProcessHeader(LPWININETHTTPREQA lpwhr, LPCSTR field, LPCSTR value, DWORD dwModifier)
2034 {
2035 LPHTTPHEADERA lphttpHdr = NULL;
2036 BOOL bSuccess = FALSE;
2037 INT index;
2038
2039 TRACE("--> %s: %s - 0x%08x\n", field, value, (unsigned int)dwModifier);
2040
2041 /* Adjust modifier flags */
2042 if (dwModifier & COALESCEFLASG)
2043 dwModifier |= HTTP_ADDHDR_FLAG_ADD;
2044
2045 /* Try to get index into standard header array */
2046 index = HTTP_GetStdHeaderIndex(field);
2047 if (index >= 0)
2048 {
2049 lphttpHdr = &lpwhr->StdHeaders[index];
2050 }
2051 else /* Find or create new custom header */
2052 {
2053 index = HTTP_GetCustomHeaderIndex(lpwhr, field);
2054 if (index >= 0)
2055 {
2056 if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW)
2057 {
2058 return FALSE;
2059 }
2060 lphttpHdr = &lpwhr->pCustHeaders[index];
2061 }
2062 else
2063 {
2064 HTTPHEADERA hdr;
2065
2066 hdr.lpszField = (LPSTR)field;
2067 hdr.lpszValue = (LPSTR)value;
2068 hdr.wFlags = hdr.wCount = 0;
2069
2070 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2071 hdr.wFlags |= HDR_ISREQUEST;
2072
2073 return HTTP_InsertCustomHeader(lpwhr, &hdr);
2074 }
2075 }
2076
2077 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2078 lphttpHdr->wFlags |= HDR_ISREQUEST;
2079 else
2080 lphttpHdr->wFlags &= ~HDR_ISREQUEST;
2081
2082 if (!lphttpHdr->lpszValue && (dwModifier & (HTTP_ADDHDR_FLAG_ADD|HTTP_ADDHDR_FLAG_ADD_IF_NEW)))
2083 {
2084 INT slen;
2085
2086 if (!lpwhr->StdHeaders[index].lpszField)
2087 {
2088 lphttpHdr->lpszField = WININET_strdup(field);
2089
2090 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2091 lphttpHdr->wFlags |= HDR_ISREQUEST;
2092 }
2093
2094 slen = strlen(value) + 1;
2095 lphttpHdr->lpszValue = HeapAlloc(GetProcessHeap(), 0, slen);
2096 if (lphttpHdr->lpszValue)
2097 {
2098 memcpy(lphttpHdr->lpszValue, value, slen);
2099 bSuccess = TRUE;
2100 }
2101 else
2102 {
2103 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2104 }
2105 }
2106 else if (lphttpHdr->lpszValue)
2107 {
2108 if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
2109 {
2110 LPSTR lpsztmp;
2111 INT len;
2112
2113 len = strlen(value);
2114
2115 if (len <= 0)
2116 {
2117 /* if custom header delete from array */
2118 HeapFree(GetProcessHeap(), 0, lphttpHdr->lpszValue);
2119 lphttpHdr->lpszValue = NULL;
2120 bSuccess = TRUE;
2121 }
2122 else
2123 {
2124 lpsztmp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lphttpHdr->lpszValue, len+1);
2125 if (lpsztmp)
2126 {
2127 lphttpHdr->lpszValue = lpsztmp;
2128 strcpy(lpsztmp, value);
2129 bSuccess = TRUE;
2130 }
2131 else
2132 {
2133 WARN("HeapReAlloc (%d bytes) failed\n",len+1);
2134 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2135 }
2136 }
2137 }
2138 else if (dwModifier & COALESCEFLASG)
2139 {
2140 LPSTR lpsztmp;
2141 CHAR ch = 0;
2142 INT len = 0;
2143 INT origlen = strlen(lphttpHdr->lpszValue);
2144 INT valuelen = strlen(value);
2145
2146 if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA)
2147 {
2148 ch = ',';
2149 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
2150 }
2151 else if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
2152 {
2153 ch = ';';
2154 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
2155 }
2156
2157 len = origlen + valuelen + ((ch > 0) ? 1 : 0);
2158
2159 lpsztmp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lphttpHdr->lpszValue, len+1);
2160 if (lpsztmp)
2161 {
2162 /* FIXME: Increment lphttpHdr->wCount. Perhaps lpszValue should be an array */
2163 if (ch > 0)
2164 {
2165 lphttpHdr->lpszValue[origlen] = ch;
2166 origlen++;
2167 }
2168
2169 memcpy(&lphttpHdr->lpszValue[origlen], value, valuelen);
2170 lphttpHdr->lpszValue[len] = '\0';
2171 bSuccess = TRUE;
2172 }
2173 else
2174 {
2175 WARN("HeapReAlloc (%d bytes) failed\n",len+1);
2176 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2177 }
2178 }
2179 }
2180 TRACE("<-- %d\n",bSuccess);
2181 return bSuccess;
2182 }
2183
2184
2185 /***********************************************************************
2186 * HTTP_CloseConnection (internal)
2187 *
2188 * Close socket connection
2189 *
2190 */
2191 VOID HTTP_CloseConnection(LPWININETHTTPREQA lpwhr)
2192 {
2193
2194
2195 LPWININETHTTPSESSIONA lpwhs = NULL;
2196 LPWININETAPPINFOA hIC = NULL;
2197 HINTERNET handle;
2198
2199 TRACE("%p\n",lpwhr);
2200
2201 handle = WININET_FindHandle( &lpwhr->hdr );
2202 lpwhs = (LPWININETHTTPSESSIONA) lpwhr->hdr.lpwhparent;
2203 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
2204
2205 SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
2206 INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
2207
2208 if (NETCON_connected(&lpwhr->netConnection))
2209 {
2210 NETCON_close(&lpwhr->netConnection);
2211 }
2212
2213 SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
2214 INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
2215 }
2216
2217
2218 /***********************************************************************
2219 * HTTP_CloseHTTPRequestHandle (internal)
2220 *
2221 * Deallocate request handle
2222 *
2223 */
2224 void HTTP_CloseHTTPRequestHandle(LPWININETHTTPREQA lpwhr)
2225 {
2226 int i;
2227 LPWININETHTTPSESSIONA lpwhs = NULL;
2228 LPWININETAPPINFOA hIC = NULL;
2229 HINTERNET handle;
2230
2231 TRACE("\n");
2232
2233 if (NETCON_connected(&lpwhr->netConnection))
2234 HTTP_CloseConnection(lpwhr);
2235
2236 handle = WININET_FindHandle( &lpwhr->hdr );
2237 lpwhs = (LPWININETHTTPSESSIONA) lpwhr->hdr.lpwhparent;
2238 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
2239
2240 SendAsyncCallback(hIC, handle, lpwhr->hdr.dwContext,
2241 INTERNET_STATUS_HANDLE_CLOSING, lpwhr,
2242 sizeof(HINTERNET));
2243
2244 if (lpwhr->lpszPath)
2245 HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
2246 if (lpwhr->lpszVerb)
2247 HeapFree(GetProcessHeap(), 0, lpwhr->lpszVerb);
2248 if (lpwhr->lpszHostName)
2249 HeapFree(GetProcessHeap(), 0, lpwhr->lpszHostName);
2250
2251 for (i = 0; i <= HTTP_QUERY_MAX; i++)
2252 {
2253 if (lpwhr->StdHeaders[i].lpszField)
2254 HeapFree(GetProcessHeap(), 0, lpwhr->StdHeaders[i].lpszField);
2255 if (lpwhr->StdHeaders[i].lpszValue)
2256 HeapFree(GetProcessHeap(), 0, lpwhr->StdHeaders[i].lpszValue);
2257 }
2258
2259 for (i = 0; i < lpwhr->nCustHeaders; i++)
2260 {
2261 if (lpwhr->pCustHeaders[i].lpszField)
2262 HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszField);
2263 if (lpwhr->pCustHeaders[i].lpszValue)
2264 HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszValue);
2265 }
2266
2267 HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders);
2268 HeapFree(GetProcessHeap(), 0, lpwhr);
2269 }
2270
2271
2272 /***********************************************************************
2273 * HTTP_CloseHTTPSessionHandle (internal)
2274 *
2275 * Deallocate session handle
2276 *
2277 */
2278 void HTTP_CloseHTTPSessionHandle(LPWININETHTTPSESSIONA lpwhs)
2279 {
2280 LPWININETAPPINFOA hIC = NULL;
2281 HINTERNET handle;
2282
2283 TRACE("%p\n", lpwhs);
2284
2285 hIC = (LPWININETAPPINFOA) lpwhs->hdr.lpwhparent;
2286
2287 handle = WININET_FindHandle( &lpwhs->hdr );
2288 SendAsyncCallback(hIC, handle, lpwhs->hdr.dwContext,
2289 INTERNET_STATUS_HANDLE_CLOSING, lpwhs,
2290 sizeof(HINTERNET));
2291
2292 if (lpwhs->lpszServerName)
2293 HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
2294 if (lpwhs->lpszUserName)
2295 HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
2296 HeapFree(GetProcessHeap(), 0, lpwhs);
2297 }
2298
2299
2300 /***********************************************************************
2301 * HTTP_GetCustomHeaderIndex (internal)
2302 *
2303 * Return index of custom header from header array
2304 *
2305 */
2306 INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQA lpwhr, LPCSTR lpszField)
2307 {
2308 INT index;
2309
2310 TRACE("%s\n", lpszField);
2311
2312 for (index = 0; index < lpwhr->nCustHeaders; index++)
2313 {
2314 if (!strcasecmp(lpwhr->pCustHeaders[index].lpszField, lpszField))
2315 break;
2316
2317 }
2318
2319 if (index >= lpwhr->nCustHeaders)
2320 index = -1;
2321
2322 TRACE("Return: %d\n", index);
2323 return index;
2324 }
2325
2326
2327 /***********************************************************************
2328 * HTTP_InsertCustomHeader (internal)
2329 *
2330 * Insert header into array
2331 *
2332 */
2333 BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQA lpwhr, LPHTTPHEADERA lpHdr)
2334 {
2335 INT count;
2336 LPHTTPHEADERA lph = NULL;
2337 BOOL r = FALSE;
2338
2339 TRACE("--> %s: %s\n", lpHdr->lpszField, lpHdr->lpszValue);
2340 count = lpwhr->nCustHeaders + 1;
2341 if (count > 1)
2342 lph = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpwhr->pCustHeaders, sizeof(HTTPHEADERA) * count);
2343 else
2344 lph = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HTTPHEADERA) * count);
2345
2346 if (NULL != lph)
2347 {
2348 lpwhr->pCustHeaders = lph;
2349 lpwhr->pCustHeaders[count-1].lpszField = WININET_strdup(lpHdr->lpszField);
2350 lpwhr->pCustHeaders[count-1].lpszValue = WININET_strdup(lpHdr->lpszValue);
2351 lpwhr->pCustHeaders[count-1].wFlags = lpHdr->wFlags;
2352 lpwhr->pCustHeaders[count-1].wCount= lpHdr->wCount;
2353 lpwhr->nCustHeaders++;
2354 r = TRUE;
2355 }
2356 else
2357 {
2358 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2359 }
2360
2361 return r;
2362 }
2363
2364
2365 /***********************************************************************
2366 * HTTP_DeleteCustomHeader (internal)
2367 *
2368 * Delete header from array
2369 * If this function is called, the indexs may change.
2370 */
2371 BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQA lpwhr, INT index)
2372 {
2373 if( lpwhr->nCustHeaders <= 0 )
2374 return FALSE;
2375 if( lpwhr->nCustHeaders >= index )
2376 return FALSE;
2377 lpwhr->nCustHeaders--;
2378
2379 memmove( &lpwhr->pCustHeaders[index], &lpwhr->pCustHeaders[index+1],
2380 (lpwhr->nCustHeaders - index)* sizeof(HTTPHEADERA) );
2381 memset( &lpwhr->pCustHeaders[lpwhr->nCustHeaders], 0, sizeof(HTTPHEADERA) );
2382
2383 return TRUE;
2384 }
2385
2386 /***********************************************************************
2387 * IsHostInProxyBypassList (@)
2388 *
2389 * Undocumented
2390 *
2391 */
2392 BOOL WINAPI IsHostInProxyBypassList(DWORD flags, LPCSTR szHost, DWORD length)
2393 {
2394 FIXME("STUB: flags=%ld host=%s length=%ld\n",flags,szHost,length);
2395 return FALSE;
2396 }
widl and rpcrt4 development