projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Synchronize with trunk's revision r57599.
[reactos.git] / dll / win32 / winhttp / request.c
1 /*
2 * Copyright 2004 Mike McCormack for CodeWeavers
3 * Copyright 2006 Rob Shearman for CodeWeavers
4 * Copyright 2008, 2011 Hans Leidekker for CodeWeavers
5 * Copyright 2009 Juan Lang
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #include "config.h"
24 #include "wine/port.h"
25 #include "wine/debug.h"
26
27 #include <stdarg.h>
28 #ifdef HAVE_ARPA_INET_H
29 # include <arpa/inet.h>
30 #endif
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "ole2.h"
35 #include "initguid.h"
36 #include "httprequest.h"
37 #include "winhttp.h"
38
39 #include "winhttp_private.h"
40
41 #include "inet_ntop.c"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
44
45 static const WCHAR attr_accept[] = {'A','c','c','e','p','t',0};
46 static const WCHAR attr_accept_charset[] = {'A','c','c','e','p','t','-','C','h','a','r','s','e','t', 0};
47 static const WCHAR attr_accept_encoding[] = {'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',0};
48 static const WCHAR attr_accept_language[] = {'A','c','c','e','p','t','-','L','a','n','g','u','a','g','e',0};
49 static const WCHAR attr_accept_ranges[] = {'A','c','c','e','p','t','-','R','a','n','g','e','s',0};
50 static const WCHAR attr_age[] = {'A','g','e',0};
51 static const WCHAR attr_allow[] = {'A','l','l','o','w',0};
52 static const WCHAR attr_authorization[] = {'A','u','t','h','o','r','i','z','a','t','i','o','n',0};
53 static const WCHAR attr_cache_control[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',0};
54 static const WCHAR attr_connection[] = {'C','o','n','n','e','c','t','i','o','n',0};
55 static const WCHAR attr_content_base[] = {'C','o','n','t','e','n','t','-','B','a','s','e',0};
56 static const WCHAR attr_content_encoding[] = {'C','o','n','t','e','n','t','-','E','n','c','o','d','i','n','g',0};
57 static const WCHAR attr_content_id[] = {'C','o','n','t','e','n','t','-','I','D',0};
58 static const WCHAR attr_content_language[] = {'C','o','n','t','e','n','t','-','L','a','n','g','u','a','g','e',0};
59 static const WCHAR attr_content_length[] = {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0};
60 static const WCHAR attr_content_location[] = {'C','o','n','t','e','n','t','-','L','o','c','a','t','i','o','n',0};
61 static const WCHAR attr_content_md5[] = {'C','o','n','t','e','n','t','-','M','D','5',0};
62 static const WCHAR attr_content_range[] = {'C','o','n','t','e','n','t','-','R','a','n','g','e',0};
63 static const WCHAR attr_content_transfer_encoding[] = {'C','o','n','t','e','n','t','-','T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0};
64 static const WCHAR attr_content_type[] = {'C','o','n','t','e','n','t','-','T','y','p','e',0};
65 static const WCHAR attr_cookie[] = {'C','o','o','k','i','e',0};
66 static const WCHAR attr_date[] = {'D','a','t','e',0};
67 static const WCHAR attr_from[] = {'F','r','o','m',0};
68 static const WCHAR attr_etag[] = {'E','T','a','g',0};
69 static const WCHAR attr_expect[] = {'E','x','p','e','c','t',0};
70 static const WCHAR attr_expires[] = {'E','x','p','i','r','e','s',0};
71 static const WCHAR attr_host[] = {'H','o','s','t',0};
72 static const WCHAR attr_if_match[] = {'I','f','-','M','a','t','c','h',0};
73 static const WCHAR attr_if_modified_since[] = {'I','f','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
74 static const WCHAR attr_if_none_match[] = {'I','f','-','N','o','n','e','-','M','a','t','c','h',0};
75 static const WCHAR attr_if_range[] = {'I','f','-','R','a','n','g','e',0};
76 static const WCHAR attr_if_unmodified_since[] = {'I','f','-','U','n','m','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
77 static const WCHAR attr_last_modified[] = {'L','a','s','t','-','M','o','d','i','f','i','e','d',0};
78 static const WCHAR attr_location[] = {'L','o','c','a','t','i','o','n',0};
79 static const WCHAR attr_max_forwards[] = {'M','a','x','-','F','o','r','w','a','r','d','s',0};
80 static const WCHAR attr_mime_version[] = {'M','i','m','e','-','V','e','r','s','i','o','n',0};
81 static const WCHAR attr_pragma[] = {'P','r','a','g','m','a',0};
82 static const WCHAR attr_proxy_authenticate[] = {'P','r','o','x','y','-','A','u','t','h','e','n','t','i','c','a','t','e',0};
83 static const WCHAR attr_proxy_authorization[] = {'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',0};
84 static const WCHAR attr_proxy_connection[] = {'P','r','o','x','y','-','C','o','n','n','e','c','t','i','o','n',0};
85 static const WCHAR attr_public[] = {'P','u','b','l','i','c',0};
86 static const WCHAR attr_range[] = {'R','a','n','g','e',0};
87 static const WCHAR attr_referer[] = {'R','e','f','e','r','e','r',0};
88 static const WCHAR attr_retry_after[] = {'R','e','t','r','y','-','A','f','t','e','r',0};
89 static const WCHAR attr_server[] = {'S','e','r','v','e','r',0};
90 static const WCHAR attr_set_cookie[] = {'S','e','t','-','C','o','o','k','i','e',0};
91 static const WCHAR attr_status[] = {'S','t','a','t','u','s',0};
92 static const WCHAR attr_transfer_encoding[] = {'T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0};
93 static const WCHAR attr_unless_modified_since[] = {'U','n','l','e','s','s','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
94 static const WCHAR attr_upgrade[] = {'U','p','g','r','a','d','e',0};
95 static const WCHAR attr_uri[] = {'U','R','I',0};
96 static const WCHAR attr_user_agent[] = {'U','s','e','r','-','A','g','e','n','t',0};
97 static const WCHAR attr_vary[] = {'V','a','r','y',0};
98 static const WCHAR attr_via[] = {'V','i','a',0};
99 static const WCHAR attr_warning[] = {'W','a','r','n','i','n','g',0};
100 static const WCHAR attr_www_authenticate[] = {'W','W','W','-','A','u','t','h','e','n','t','i','c','a','t','e',0};
101
102 static const WCHAR *attribute_table[] =
103 {
104 attr_mime_version, /* WINHTTP_QUERY_MIME_VERSION = 0 */
105 attr_content_type, /* WINHTTP_QUERY_CONTENT_TYPE = 1 */
106 attr_content_transfer_encoding, /* WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
107 attr_content_id, /* WINHTTP_QUERY_CONTENT_ID = 3 */
108 NULL, /* WINHTTP_QUERY_CONTENT_DESCRIPTION = 4 */
109 attr_content_length, /* WINHTTP_QUERY_CONTENT_LENGTH = 5 */
110 attr_content_language, /* WINHTTP_QUERY_CONTENT_LANGUAGE = 6 */
111 attr_allow, /* WINHTTP_QUERY_ALLOW = 7 */
112 attr_public, /* WINHTTP_QUERY_PUBLIC = 8 */
113 attr_date, /* WINHTTP_QUERY_DATE = 9 */
114 attr_expires, /* WINHTTP_QUERY_EXPIRES = 10 */
115 attr_last_modified, /* WINHTTP_QUERY_LAST_MODIFIEDcw = 11 */
116 NULL, /* WINHTTP_QUERY_MESSAGE_ID = 12 */
117 attr_uri, /* WINHTTP_QUERY_URI = 13 */
118 attr_from, /* WINHTTP_QUERY_DERIVED_FROM = 14 */
119 NULL, /* WINHTTP_QUERY_COST = 15 */
120 NULL, /* WINHTTP_QUERY_LINK = 16 */
121 attr_pragma, /* WINHTTP_QUERY_PRAGMA = 17 */
122 NULL, /* WINHTTP_QUERY_VERSION = 18 */
123 attr_status, /* WINHTTP_QUERY_STATUS_CODE = 19 */
124 NULL, /* WINHTTP_QUERY_STATUS_TEXT = 20 */
125 NULL, /* WINHTTP_QUERY_RAW_HEADERS = 21 */
126 NULL, /* WINHTTP_QUERY_RAW_HEADERS_CRLF = 22 */
127 attr_connection, /* WINHTTP_QUERY_CONNECTION = 23 */
128 attr_accept, /* WINHTTP_QUERY_ACCEPT = 24 */
129 attr_accept_charset, /* WINHTTP_QUERY_ACCEPT_CHARSET = 25 */
130 attr_accept_encoding, /* WINHTTP_QUERY_ACCEPT_ENCODING = 26 */
131 attr_accept_language, /* WINHTTP_QUERY_ACCEPT_LANGUAGE = 27 */
132 attr_authorization, /* WINHTTP_QUERY_AUTHORIZATION = 28 */
133 attr_content_encoding, /* WINHTTP_QUERY_CONTENT_ENCODING = 29 */
134 NULL, /* WINHTTP_QUERY_FORWARDED = 30 */
135 NULL, /* WINHTTP_QUERY_FROM = 31 */
136 attr_if_modified_since, /* WINHTTP_QUERY_IF_MODIFIED_SINCE = 32 */
137 attr_location, /* WINHTTP_QUERY_LOCATION = 33 */
138 NULL, /* WINHTTP_QUERY_ORIG_URI = 34 */
139 attr_referer, /* WINHTTP_QUERY_REFERER = 35 */
140 attr_retry_after, /* WINHTTP_QUERY_RETRY_AFTER = 36 */
141 attr_server, /* WINHTTP_QUERY_SERVER = 37 */
142 NULL, /* WINHTTP_TITLE = 38 */
143 attr_user_agent, /* WINHTTP_QUERY_USER_AGENT = 39 */
144 attr_www_authenticate, /* WINHTTP_QUERY_WWW_AUTHENTICATE = 40 */
145 attr_proxy_authenticate, /* WINHTTP_QUERY_PROXY_AUTHENTICATE = 41 */
146 attr_accept_ranges, /* WINHTTP_QUERY_ACCEPT_RANGES = 42 */
147 attr_set_cookie, /* WINHTTP_QUERY_SET_COOKIE = 43 */
148 attr_cookie, /* WINHTTP_QUERY_COOKIE = 44 */
149 NULL, /* WINHTTP_QUERY_REQUEST_METHOD = 45 */
150 NULL, /* WINHTTP_QUERY_REFRESH = 46 */
151 NULL, /* WINHTTP_QUERY_CONTENT_DISPOSITION = 47 */
152 attr_age, /* WINHTTP_QUERY_AGE = 48 */
153 attr_cache_control, /* WINHTTP_QUERY_CACHE_CONTROL = 49 */
154 attr_content_base, /* WINHTTP_QUERY_CONTENT_BASE = 50 */
155 attr_content_location, /* WINHTTP_QUERY_CONTENT_LOCATION = 51 */
156 attr_content_md5, /* WINHTTP_QUERY_CONTENT_MD5 = 52 */
157 attr_content_range, /* WINHTTP_QUERY_CONTENT_RANGE = 53 */
158 attr_etag, /* WINHTTP_QUERY_ETAG = 54 */
159 attr_host, /* WINHTTP_QUERY_HOST = 55 */
160 attr_if_match, /* WINHTTP_QUERY_IF_MATCH = 56 */
161 attr_if_none_match, /* WINHTTP_QUERY_IF_NONE_MATCH = 57 */
162 attr_if_range, /* WINHTTP_QUERY_IF_RANGE = 58 */
163 attr_if_unmodified_since, /* WINHTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
164 attr_max_forwards, /* WINHTTP_QUERY_MAX_FORWARDS = 60 */
165 attr_proxy_authorization, /* WINHTTP_QUERY_PROXY_AUTHORIZATION = 61 */
166 attr_range, /* WINHTTP_QUERY_RANGE = 62 */
167 attr_transfer_encoding, /* WINHTTP_QUERY_TRANSFER_ENCODING = 63 */
168 attr_upgrade, /* WINHTTP_QUERY_UPGRADE = 64 */
169 attr_vary, /* WINHTTP_QUERY_VARY = 65 */
170 attr_via, /* WINHTTP_QUERY_VIA = 66 */
171 attr_warning, /* WINHTTP_QUERY_WARNING = 67 */
172 attr_expect, /* WINHTTP_QUERY_EXPECT = 68 */
173 attr_proxy_connection, /* WINHTTP_QUERY_PROXY_CONNECTION = 69 */
174 attr_unless_modified_since, /* WINHTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
175 NULL, /* WINHTTP_QUERY_PROXY_SUPPORT = 75 */
176 NULL, /* WINHTTP_QUERY_AUTHENTICATION_INFO = 76 */
177 NULL, /* WINHTTP_QUERY_PASSPORT_URLS = 77 */
178 NULL /* WINHTTP_QUERY_PASSPORT_CONFIG = 78 */
179 };
180
181 static DWORD CALLBACK task_thread( LPVOID param )
182 {
183 task_header_t *task = param;
184
185 task->proc( task );
186
187 release_object( &task->request->hdr );
188 heap_free( task );
189 return ERROR_SUCCESS;
190 }
191
192 static BOOL queue_task( task_header_t *task )
193 {
194 return QueueUserWorkItem( task_thread, task, WT_EXECUTELONGFUNCTION );
195 }
196
197 static void free_header( header_t *header )
198 {
199 heap_free( header->field );
200 heap_free( header->value );
201 heap_free( header );
202 }
203
204 static BOOL valid_token_char( WCHAR c )
205 {
206 if (c < 32 || c == 127) return FALSE;
207 switch (c)
208 {
209 case '(': case ')':
210 case '<': case '>':
211 case '@': case ',':
212 case ';': case ':':
213 case '\\': case '\"':
214 case '/': case '[':
215 case ']': case '?':
216 case '=': case '{':
217 case '}': case ' ':
218 case '\t':
219 return FALSE;
220 default:
221 return TRUE;
222 }
223 }
224
225 static header_t *parse_header( LPCWSTR string )
226 {
227 const WCHAR *p, *q;
228 header_t *header;
229 int len;
230
231 p = string;
232 if (!(q = strchrW( p, ':' )))
233 {
234 WARN("no ':' in line %s\n", debugstr_w(string));
235 return NULL;
236 }
237 if (q == string)
238 {
239 WARN("empty field name in line %s\n", debugstr_w(string));
240 return NULL;
241 }
242 while (*p != ':')
243 {
244 if (!valid_token_char( *p ))
245 {
246 WARN("invalid character in field name %s\n", debugstr_w(string));
247 return NULL;
248 }
249 p++;
250 }
251 len = q - string;
252 if (!(header = heap_alloc_zero( sizeof(header_t) ))) return NULL;
253 if (!(header->field = heap_alloc( (len + 1) * sizeof(WCHAR) )))
254 {
255 heap_free( header );
256 return NULL;
257 }
258 memcpy( header->field, string, len * sizeof(WCHAR) );
259 header->field[len] = 0;
260
261 q++; /* skip past colon */
262 while (*q == ' ') q++;
263 if (!*q)
264 {
265 WARN("no value in line %s\n", debugstr_w(string));
266 return header;
267 }
268 len = strlenW( q );
269 if (!(header->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
270 {
271 free_header( header );
272 return NULL;
273 }
274 memcpy( header->value, q, len * sizeof(WCHAR) );
275 header->value[len] = 0;
276
277 return header;
278 }
279
280 static int get_header_index( request_t *request, LPCWSTR field, int requested_index, BOOL request_only )
281 {
282 int index;
283
284 TRACE("%s\n", debugstr_w(field));
285
286 for (index = 0; index < request->num_headers; index++)
287 {
288 if (strcmpiW( request->headers[index].field, field )) continue;
289 if (request_only && !request->headers[index].is_request) continue;
290 if (!request_only && request->headers[index].is_request) continue;
291
292 if (!requested_index) break;
293 requested_index--;
294 }
295 if (index >= request->num_headers) index = -1;
296 TRACE("returning %d\n", index);
297 return index;
298 }
299
300 static BOOL insert_header( request_t *request, header_t *header )
301 {
302 DWORD count;
303 header_t *hdrs;
304
305 count = request->num_headers + 1;
306 if (count > 1)
307 hdrs = heap_realloc_zero( request->headers, sizeof(header_t) * count );
308 else
309 hdrs = heap_alloc_zero( sizeof(header_t) * count );
310
311 if (hdrs)
312 {
313 request->headers = hdrs;
314 request->headers[count - 1].field = strdupW( header->field );
315 request->headers[count - 1].value = strdupW( header->value );
316 request->headers[count - 1].is_request = header->is_request;
317 request->num_headers++;
318 return TRUE;
319 }
320 return FALSE;
321 }
322
323 static BOOL delete_header( request_t *request, DWORD index )
324 {
325 if (!request->num_headers) return FALSE;
326 if (index >= request->num_headers) return FALSE;
327 request->num_headers--;
328
329 heap_free( request->headers[index].field );
330 heap_free( request->headers[index].value );
331
332 memmove( &request->headers[index], &request->headers[index + 1], (request->num_headers - index) * sizeof(header_t) );
333 memset( &request->headers[request->num_headers], 0, sizeof(header_t) );
334 return TRUE;
335 }
336
337 static BOOL process_header( request_t *request, LPCWSTR field, LPCWSTR value, DWORD flags, BOOL request_only )
338 {
339 int index;
340 header_t *header;
341
342 TRACE("%s: %s 0x%08x\n", debugstr_w(field), debugstr_w(value), flags);
343
344 /* replace wins out over add */
345 if (flags & WINHTTP_ADDREQ_FLAG_REPLACE) flags &= ~WINHTTP_ADDREQ_FLAG_ADD;
346
347 if (flags & WINHTTP_ADDREQ_FLAG_ADD) index = -1;
348 else
349 index = get_header_index( request, field, 0, request_only );
350
351 if (index >= 0)
352 {
353 if (flags & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) return FALSE;
354 header = &request->headers[index];
355 }
356 else if (value)
357 {
358 header_t hdr;
359
360 hdr.field = (LPWSTR)field;
361 hdr.value = (LPWSTR)value;
362 hdr.is_request = request_only;
363
364 return insert_header( request, &hdr );
365 }
366 /* no value to delete */
367 else return TRUE;
368
369 if (flags & WINHTTP_ADDREQ_FLAG_REPLACE)
370 {
371 delete_header( request, index );
372 if (value)
373 {
374 header_t hdr;
375
376 hdr.field = (LPWSTR)field;
377 hdr.value = (LPWSTR)value;
378 hdr.is_request = request_only;
379
380 return insert_header( request, &hdr );
381 }
382 return TRUE;
383 }
384 else if (flags & (WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON))
385 {
386 WCHAR sep, *tmp;
387 int len, orig_len, value_len;
388
389 orig_len = strlenW( header->value );
390 value_len = strlenW( value );
391
392 if (flags & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) sep = ',';
393 else sep = ';';
394
395 len = orig_len + value_len + 2;
396 if ((tmp = heap_realloc( header->value, (len + 1) * sizeof(WCHAR) )))
397 {
398 header->value = tmp;
399
400 header->value[orig_len] = sep;
401 orig_len++;
402 header->value[orig_len] = ' ';
403 orig_len++;
404
405 memcpy( &header->value[orig_len], value, value_len * sizeof(WCHAR) );
406 header->value[len] = 0;
407 return TRUE;
408 }
409 }
410 return TRUE;
411 }
412
413 BOOL add_request_headers( request_t *request, LPCWSTR headers, DWORD len, DWORD flags )
414 {
415 BOOL ret = FALSE;
416 WCHAR *buffer, *p, *q;
417 header_t *header;
418
419 if (len == ~0u) len = strlenW( headers );
420 if (!len) return TRUE;
421 if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
422 strcpyW( buffer, headers );
423
424 p = buffer;
425 do
426 {
427 q = p;
428 while (*q)
429 {
430 if (q[0] == '\n' && q[1] == '\r')
431 {
432 q[0] = '\r';
433 q[1] = '\n';
434 }
435 if (q[0] == '\r' && q[1] == '\n') break;
436 q++;
437 }
438 if (!*p) break;
439 if (*q == '\r')
440 {
441 *q = 0;
442 q += 2; /* jump over \r\n */
443 }
444 if ((header = parse_header( p )))
445 {
446 ret = process_header( request, header->field, header->value, flags, TRUE );
447 free_header( header );
448 }
449 p = q;
450 } while (ret);
451
452 heap_free( buffer );
453 return ret;
454 }
455
456 /***********************************************************************
457 * WinHttpAddRequestHeaders (winhttp.@)
458 */
459 BOOL WINAPI WinHttpAddRequestHeaders( HINTERNET hrequest, LPCWSTR headers, DWORD len, DWORD flags )
460 {
461 BOOL ret;
462 request_t *request;
463
464 TRACE("%p, %s, 0x%x, 0x%08x\n", hrequest, debugstr_w(headers), len, flags);
465
466 if (!headers)
467 {
468 set_last_error( ERROR_INVALID_PARAMETER );
469 return FALSE;
470 }
471 if (!(request = (request_t *)grab_object( hrequest )))
472 {
473 set_last_error( ERROR_INVALID_HANDLE );
474 return FALSE;
475 }
476 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
477 {
478 release_object( &request->hdr );
479 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
480 return FALSE;
481 }
482
483 ret = add_request_headers( request, headers, len, flags );
484
485 release_object( &request->hdr );
486 return ret;
487 }
488
489 static WCHAR *build_request_path( request_t *request )
490 {
491 WCHAR *ret;
492
493 if (strcmpiW( request->connect->hostname, request->connect->servername ))
494 {
495 static const WCHAR http[] = { 'h','t','t','p',0 };
496 static const WCHAR https[] = { 'h','t','t','p','s',0 };
497 static const WCHAR fmt[] = { '%','s',':','/','/','%','s',0 };
498 LPCWSTR scheme = request->netconn.secure ? https : http;
499 int len;
500
501 len = strlenW( scheme ) + strlenW( request->connect->hostname );
502 /* 3 characters for '://', 1 for NUL. */
503 len += 4;
504 if (request->connect->hostport)
505 {
506 /* 1 for ':' between host and port, up to 5 for port */
507 len += 6;
508 }
509 if (request->path)
510 len += strlenW( request->path );
511 if ((ret = heap_alloc( len * sizeof(WCHAR) )))
512 {
513 sprintfW( ret, fmt, scheme, request->connect->hostname );
514 if (request->connect->hostport)
515 {
516 static const WCHAR colonFmt[] = { ':','%','u',0 };
517
518 sprintfW( ret + strlenW( ret ), colonFmt,
519 request->connect->hostport );
520 }
521 if (request->path)
522 strcatW( ret, request->path );
523 }
524 }
525 else
526 ret = request->path;
527 return ret;
528 }
529
530 static WCHAR *build_request_string( request_t *request )
531 {
532 static const WCHAR space[] = {' ',0};
533 static const WCHAR crlf[] = {'\r','\n',0};
534 static const WCHAR colon[] = {':',' ',0};
535 static const WCHAR twocrlf[] = {'\r','\n','\r','\n',0};
536
537 WCHAR *path, *ret;
538 const WCHAR **headers, **p;
539 unsigned int len, i = 0, j;
540
541 /* allocate space for an array of all the string pointers to be added */
542 len = request->num_headers * 4 + 7;
543 if (!(headers = heap_alloc( len * sizeof(LPCWSTR) ))) return NULL;
544
545 path = build_request_path( request );
546 headers[i++] = request->verb;
547 headers[i++] = space;
548 headers[i++] = path;
549 headers[i++] = space;
550 headers[i++] = request->version;
551
552 for (j = 0; j < request->num_headers; j++)
553 {
554 if (request->headers[j].is_request)
555 {
556 headers[i++] = crlf;
557 headers[i++] = request->headers[j].field;
558 headers[i++] = colon;
559 headers[i++] = request->headers[j].value;
560
561 TRACE("adding header %s (%s)\n", debugstr_w(request->headers[j].field),
562 debugstr_w(request->headers[j].value));
563 }
564 }
565 headers[i++] = twocrlf;
566 headers[i] = NULL;
567
568 len = 0;
569 for (p = headers; *p; p++) len += strlenW( *p );
570 len++;
571
572 if (!(ret = heap_alloc( len * sizeof(WCHAR) )))
573 goto out;
574 *ret = 0;
575 for (p = headers; *p; p++) strcatW( ret, *p );
576
577 out:
578 if (path != request->path)
579 heap_free( path );
580 heap_free( headers );
581 return ret;
582 }
583
584 #define QUERY_MODIFIER_MASK (WINHTTP_QUERY_FLAG_REQUEST_HEADERS | WINHTTP_QUERY_FLAG_SYSTEMTIME | WINHTTP_QUERY_FLAG_NUMBER)
585
586 static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index )
587 {
588 header_t *header = NULL;
589 BOOL request_only, ret = FALSE;
590 int requested_index, header_index = -1;
591 DWORD attr, len;
592
593 request_only = level & WINHTTP_QUERY_FLAG_REQUEST_HEADERS;
594 requested_index = index ? *index : 0;
595
596 attr = level & ~QUERY_MODIFIER_MASK;
597 switch (attr)
598 {
599 case WINHTTP_QUERY_CUSTOM:
600 {
601 header_index = get_header_index( request, name, requested_index, request_only );
602 break;
603 }
604 case WINHTTP_QUERY_RAW_HEADERS:
605 {
606 WCHAR *headers, *p, *q;
607
608 if (request_only)
609 headers = build_request_string( request );
610 else
611 headers = request->raw_headers;
612
613 if (!(p = headers)) return FALSE;
614 for (len = 0; *p; p++) if (*p != '\r') len++;
615
616 if (!buffer || (len + 1) * sizeof(WCHAR) > *buflen)
617 {
618 len++;
619 set_last_error( ERROR_INSUFFICIENT_BUFFER );
620 }
621 else
622 {
623 for (p = headers, q = buffer; *p; p++, q++)
624 {
625 if (*p != '\r') *q = *p;
626 else
627 {
628 *q = 0;
629 p++; /* skip '\n' */
630 }
631 }
632 *q = 0;
633 TRACE("returning data: %s\n", debugstr_wn(buffer, len));
634 ret = TRUE;
635 }
636 *buflen = len * sizeof(WCHAR);
637 if (request_only) heap_free( headers );
638 return ret;
639 }
640 case WINHTTP_QUERY_RAW_HEADERS_CRLF:
641 {
642 WCHAR *headers;
643
644 if (request_only)
645 headers = build_request_string( request );
646 else
647 headers = request->raw_headers;
648
649 if (!headers) return FALSE;
650 len = strlenW( headers ) * sizeof(WCHAR);
651 if (!buffer || len + sizeof(WCHAR) > *buflen)
652 {
653 len += sizeof(WCHAR);
654 set_last_error( ERROR_INSUFFICIENT_BUFFER );
655 }
656 else
657 {
658 memcpy( buffer, headers, len + sizeof(WCHAR) );
659 TRACE("returning data: %s\n", debugstr_wn(buffer, len / sizeof(WCHAR)));
660 ret = TRUE;
661 }
662 *buflen = len;
663 if (request_only) heap_free( headers );
664 return ret;
665 }
666 case WINHTTP_QUERY_VERSION:
667 len = strlenW( request->version ) * sizeof(WCHAR);
668 if (!buffer || len + sizeof(WCHAR) > *buflen)
669 {
670 len += sizeof(WCHAR);
671 set_last_error( ERROR_INSUFFICIENT_BUFFER );
672 }
673 else
674 {
675 strcpyW( buffer, request->version );
676 TRACE("returning string: %s\n", debugstr_w(buffer));
677 ret = TRUE;
678 }
679 *buflen = len;
680 return ret;
681
682 case WINHTTP_QUERY_STATUS_TEXT:
683 len = strlenW( request->status_text ) * sizeof(WCHAR);
684 if (!buffer || len + sizeof(WCHAR) > *buflen)
685 {
686 len += sizeof(WCHAR);
687 set_last_error( ERROR_INSUFFICIENT_BUFFER );
688 }
689 else
690 {
691 strcpyW( buffer, request->status_text );
692 TRACE("returning string: %s\n", debugstr_w(buffer));
693 ret = TRUE;
694 }
695 *buflen = len;
696 return ret;
697
698 default:
699 if (attr >= sizeof(attribute_table)/sizeof(attribute_table[0]) || !attribute_table[attr])
700 {
701 FIXME("attribute %u not implemented\n", attr);
702 return FALSE;
703 }
704 TRACE("attribute %s\n", debugstr_w(attribute_table[attr]));
705 header_index = get_header_index( request, attribute_table[attr], requested_index, request_only );
706 break;
707 }
708
709 if (header_index >= 0)
710 {
711 header = &request->headers[header_index];
712 }
713 if (!header || (request_only && !header->is_request))
714 {
715 set_last_error( ERROR_WINHTTP_HEADER_NOT_FOUND );
716 return FALSE;
717 }
718 if (index) *index += 1;
719 if (level & WINHTTP_QUERY_FLAG_NUMBER)
720 {
721 if (!buffer || sizeof(int) > *buflen)
722 {
723 set_last_error( ERROR_INSUFFICIENT_BUFFER );
724 }
725 else
726 {
727 int *number = buffer;
728 *number = atoiW( header->value );
729 TRACE("returning number: %d\n", *number);
730 ret = TRUE;
731 }
732 *buflen = sizeof(int);
733 }
734 else if (level & WINHTTP_QUERY_FLAG_SYSTEMTIME)
735 {
736 SYSTEMTIME *st = buffer;
737 if (!buffer || sizeof(SYSTEMTIME) > *buflen)
738 {
739 set_last_error( ERROR_INSUFFICIENT_BUFFER );
740 }
741 else if ((ret = WinHttpTimeToSystemTime( header->value, st )))
742 {
743 TRACE("returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
744 st->wYear, st->wMonth, st->wDay, st->wDayOfWeek,
745 st->wHour, st->wMinute, st->wSecond, st->wMilliseconds);
746 }
747 *buflen = sizeof(SYSTEMTIME);
748 }
749 else if (header->value)
750 {
751 len = strlenW( header->value ) * sizeof(WCHAR);
752 if (!buffer || len + sizeof(WCHAR) > *buflen)
753 {
754 len += sizeof(WCHAR);
755 set_last_error( ERROR_INSUFFICIENT_BUFFER );
756 }
757 else
758 {
759 strcpyW( buffer, header->value );
760 TRACE("returning string: %s\n", debugstr_w(buffer));
761 ret = TRUE;
762 }
763 *buflen = len;
764 }
765 return ret;
766 }
767
768 /***********************************************************************
769 * WinHttpQueryHeaders (winhttp.@)
770 */
771 BOOL WINAPI WinHttpQueryHeaders( HINTERNET hrequest, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index )
772 {
773 BOOL ret;
774 request_t *request;
775
776 TRACE("%p, 0x%08x, %s, %p, %p, %p\n", hrequest, level, debugstr_w(name), buffer, buflen, index);
777
778 if (!(request = (request_t *)grab_object( hrequest )))
779 {
780 set_last_error( ERROR_INVALID_HANDLE );
781 return FALSE;
782 }
783 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
784 {
785 release_object( &request->hdr );
786 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
787 return FALSE;
788 }
789
790 ret = query_headers( request, level, name, buffer, buflen, index );
791
792 release_object( &request->hdr );
793 return ret;
794 }
795
796 static LPWSTR concatenate_string_list( LPCWSTR *list, int len )
797 {
798 LPCWSTR *t;
799 LPWSTR str;
800
801 for( t = list; *t ; t++ )
802 len += strlenW( *t );
803 len++;
804
805 str = heap_alloc( len * sizeof(WCHAR) );
806 if (!str) return NULL;
807 *str = 0;
808
809 for( t = list; *t ; t++ )
810 strcatW( str, *t );
811
812 return str;
813 }
814
815 static LPWSTR build_header_request_string( request_t *request, LPCWSTR verb,
816 LPCWSTR path, LPCWSTR version )
817 {
818 static const WCHAR crlf[] = {'\r','\n',0};
819 static const WCHAR space[] = { ' ',0 };
820 static const WCHAR colon[] = { ':',' ',0 };
821 static const WCHAR twocrlf[] = {'\r','\n','\r','\n', 0};
822 LPWSTR requestString;
823 DWORD len, n;
824 LPCWSTR *req;
825 UINT i;
826 LPWSTR p;
827
828 /* allocate space for an array of all the string pointers to be added */
829 len = (request->num_headers) * 4 + 10;
830 req = heap_alloc( len * sizeof(LPCWSTR) );
831 if (!req) return NULL;
832
833 /* add the verb, path and HTTP version string */
834 n = 0;
835 req[n++] = verb;
836 req[n++] = space;
837 req[n++] = path;
838 req[n++] = space;
839 req[n++] = version;
840
841 /* Append custom request headers */
842 for (i = 0; i < request->num_headers; i++)
843 {
844 if (request->headers[i].is_request)
845 {
846 req[n++] = crlf;
847 req[n++] = request->headers[i].field;
848 req[n++] = colon;
849 req[n++] = request->headers[i].value;
850
851 TRACE("Adding custom header %s (%s)\n",
852 debugstr_w(request->headers[i].field),
853 debugstr_w(request->headers[i].value));
854 }
855 }
856
857 if( n >= len )
858 ERR("oops. buffer overrun\n");
859
860 req[n] = NULL;
861 requestString = concatenate_string_list( req, 4 );
862 heap_free( req );
863 if (!requestString) return NULL;
864
865 /*
866 * Set (header) termination string for request
867 * Make sure there's exactly two new lines at the end of the request
868 */
869 p = &requestString[strlenW(requestString)-1];
870 while ( (*p == '\n') || (*p == '\r') )
871 p--;
872 strcpyW( p+1, twocrlf );
873
874 return requestString;
875 }
876
877 static BOOL read_reply( request_t *request );
878
879 static BOOL secure_proxy_connect( request_t *request )
880 {
881 static const WCHAR verbConnect[] = {'C','O','N','N','E','C','T',0};
882 static const WCHAR fmt[] = {'%','s',':','%','u',0};
883 BOOL ret = FALSE;
884 LPWSTR path;
885 connect_t *connect = request->connect;
886
887 path = heap_alloc( (strlenW( connect->hostname ) + 13) * sizeof(WCHAR) );
888 if (path)
889 {
890 LPWSTR requestString;
891
892 sprintfW( path, fmt, connect->hostname, connect->hostport );
893 requestString = build_header_request_string( request, verbConnect,
894 path, http1_1 );
895 heap_free( path );
896 if (requestString)
897 {
898 LPSTR req_ascii = strdupWA( requestString );
899
900 heap_free( requestString );
901 if (req_ascii)
902 {
903 int len = strlen( req_ascii ), bytes_sent;
904
905 ret = netconn_send( &request->netconn, req_ascii, len, 0, &bytes_sent );
906 heap_free( req_ascii );
907 if (ret)
908 ret = read_reply( request );
909 }
910 }
911 }
912 return ret;
913 }
914
915 #ifndef INET6_ADDRSTRLEN
916 #define INET6_ADDRSTRLEN 46
917 #endif
918
919 static WCHAR *addr_to_str( const struct sockaddr *addr )
920 {
921 char buf[INET6_ADDRSTRLEN];
922 const void *src;
923
924 switch (addr->sa_family)
925 {
926 case AF_INET:
927 src = &((struct sockaddr_in *)addr)->sin_addr;
928 break;
929 case AF_INET6:
930 src = &((struct sockaddr_in6 *)addr)->sin6_addr;
931 break;
932 default:
933 WARN("unsupported address family %d\n", addr->sa_family);
934 return NULL;
935 }
936 if (!inet_ntop( addr->sa_family, src, buf, sizeof(buf) )) return NULL;
937 return strdupAW( buf );
938 }
939
940 static BOOL open_connection( request_t *request )
941 {
942 connect_t *connect;
943 WCHAR *addressW = NULL;
944 INTERNET_PORT port;
945 socklen_t slen;
946 struct sockaddr *saddr;
947 DWORD len;
948
949 if (netconn_connected( &request->netconn )) return TRUE;
950
951 connect = request->connect;
952 port = connect->serverport ? connect->serverport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
953 saddr = (struct sockaddr *)&connect->sockaddr;
954 slen = sizeof(struct sockaddr);
955
956 if (!connect->resolved)
957 {
958 len = strlenW( connect->servername ) + 1;
959 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, connect->servername, len );
960
961 if (!netconn_resolve( connect->servername, port, saddr, &slen, request->resolve_timeout )) return FALSE;
962 connect->resolved = TRUE;
963
964 if (!(addressW = addr_to_str( saddr ))) return FALSE;
965 len = strlenW( addressW ) + 1;
966 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, len );
967 }
968 if (!addressW && !(addressW = addr_to_str( saddr ))) return FALSE;
969 TRACE("connecting to %s:%u\n", debugstr_w(addressW), port);
970
971 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, 0 );
972
973 if (!netconn_create( &request->netconn, saddr->sa_family, SOCK_STREAM, 0 ))
974 {
975 heap_free( addressW );
976 return FALSE;
977 }
978 netconn_set_timeout( &request->netconn, TRUE, request->send_timeout );
979 netconn_set_timeout( &request->netconn, FALSE, request->recv_timeout );
980 if (!netconn_connect( &request->netconn, saddr, slen, request->connect_timeout ))
981 {
982 netconn_close( &request->netconn );
983 heap_free( addressW );
984 return FALSE;
985 }
986 if (request->hdr.flags & WINHTTP_FLAG_SECURE)
987 {
988 if (connect->session->proxy_server &&
989 strcmpiW( connect->hostname, connect->servername ))
990 {
991 if (!secure_proxy_connect( request ))
992 {
993 heap_free( addressW );
994 return FALSE;
995 }
996 }
997 if (!netconn_secure_connect( &request->netconn, connect->servername ))
998 {
999 netconn_close( &request->netconn );
1000 heap_free( addressW );
1001 return FALSE;
1002 }
1003 }
1004
1005 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, addressW, strlenW(addressW) + 1 );
1006
1007 heap_free( addressW );
1008 return TRUE;
1009 }
1010
1011 void close_connection( request_t *request )
1012 {
1013 if (!netconn_connected( &request->netconn )) return;
1014
1015 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, 0, 0 );
1016 netconn_close( &request->netconn );
1017 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0 );
1018 }
1019
1020 static BOOL add_host_header( request_t *request, DWORD modifier )
1021 {
1022 BOOL ret;
1023 DWORD len;
1024 WCHAR *host;
1025 static const WCHAR fmt[] = {'%','s',':','%','u',0};
1026 connect_t *connect = request->connect;
1027 INTERNET_PORT port;
1028
1029 port = connect->hostport ? connect->hostport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
1030
1031 if (port == INTERNET_DEFAULT_HTTP_PORT || port == INTERNET_DEFAULT_HTTPS_PORT)
1032 {
1033 return process_header( request, attr_host, connect->hostname, modifier, TRUE );
1034 }
1035 len = strlenW( connect->hostname ) + 7; /* sizeof(":65335") */
1036 if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
1037 sprintfW( host, fmt, connect->hostname, port );
1038 ret = process_header( request, attr_host, host, modifier, TRUE );
1039 heap_free( host );
1040 return ret;
1041 }
1042
1043 static BOOL send_request( request_t *request, LPCWSTR headers, DWORD headers_len, LPVOID optional,
1044 DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL async )
1045 {
1046 static const WCHAR keep_alive[] = {'K','e','e','p','-','A','l','i','v','e',0};
1047 static const WCHAR no_cache[] = {'n','o','-','c','a','c','h','e',0};
1048 static const WCHAR length_fmt[] = {'%','l','d',0};
1049
1050 BOOL ret = FALSE;
1051 connect_t *connect = request->connect;
1052 session_t *session = connect->session;
1053 WCHAR *req = NULL;
1054 char *req_ascii;
1055 int bytes_sent;
1056 DWORD len, i, flags;
1057
1058 flags = WINHTTP_ADDREQ_FLAG_ADD|WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA;
1059 for (i = 0; i < request->num_accept_types; i++)
1060 {
1061 process_header( request, attr_accept, request->accept_types[i], flags, TRUE );
1062 }
1063 if (session->agent)
1064 process_header( request, attr_user_agent, session->agent, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
1065
1066 if (connect->hostname)
1067 add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
1068
1069 if (total_len || (request->verb && !strcmpW( request->verb, postW )))
1070 {
1071 WCHAR length[21]; /* decimal long int + null */
1072 sprintfW( length, length_fmt, total_len );
1073 process_header( request, attr_content_length, length, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
1074 }
1075 if (!(request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE))
1076 {
1077 process_header( request, attr_connection, keep_alive, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
1078 }
1079 if (request->hdr.flags & WINHTTP_FLAG_REFRESH)
1080 {
1081 process_header( request, attr_pragma, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
1082 process_header( request, attr_cache_control, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
1083 }
1084 if (headers && !add_request_headers( request, headers, headers_len, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))
1085 {
1086 TRACE("failed to add request headers\n");
1087 return FALSE;
1088 }
1089 if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && !add_cookie_headers( request ))
1090 {
1091 WARN("failed to add cookie headers\n");
1092 return FALSE;
1093 }
1094
1095 if (context) request->hdr.context = context;
1096
1097 if (!(ret = open_connection( request ))) goto end;
1098 if (!(req = build_request_string( request ))) goto end;
1099
1100 if (!(req_ascii = strdupWA( req ))) goto end;
1101 TRACE("full request: %s\n", debugstr_a(req_ascii));
1102 len = strlen(req_ascii);
1103
1104 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
1105
1106 ret = netconn_send( &request->netconn, req_ascii, len, 0, &bytes_sent );
1107 heap_free( req_ascii );
1108 if (!ret) goto end;
1109
1110 if (optional_len && !netconn_send( &request->netconn, optional, optional_len, 0, &bytes_sent )) goto end;
1111 len += optional_len;
1112
1113 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_SENT, &len, sizeof(DWORD) );
1114
1115 end:
1116 if (async)
1117 {
1118 if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
1119 else
1120 {
1121 WINHTTP_ASYNC_RESULT result;
1122 result.dwResult = API_SEND_REQUEST;
1123 result.dwError = get_last_error();
1124 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
1125 }
1126 }
1127 heap_free( req );
1128 return ret;
1129 }
1130
1131 static void task_send_request( task_header_t *task )
1132 {
1133 send_request_t *s = (send_request_t *)task;
1134 send_request( s->hdr.request, s->headers, s->headers_len, s->optional, s->optional_len, s->total_len, s->context, TRUE );
1135 heap_free( s->headers );
1136 }
1137
1138 /***********************************************************************
1139 * WinHttpSendRequest (winhttp.@)
1140 */
1141 BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD headers_len,
1142 LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context )
1143 {
1144 BOOL ret;
1145 request_t *request;
1146
1147 TRACE("%p, %s, 0x%x, %u, %u, %lx\n",
1148 hrequest, debugstr_w(headers), headers_len, optional_len, total_len, context);
1149
1150 if (!(request = (request_t *)grab_object( hrequest )))
1151 {
1152 set_last_error( ERROR_INVALID_HANDLE );
1153 return FALSE;
1154 }
1155 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
1156 {
1157 release_object( &request->hdr );
1158 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1159 return FALSE;
1160 }
1161
1162 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
1163 {
1164 send_request_t *s;
1165
1166 if (!(s = heap_alloc( sizeof(send_request_t) ))) return FALSE;
1167 s->hdr.request = request;
1168 s->hdr.proc = task_send_request;
1169 s->headers = strdupW( headers );
1170 s->headers_len = headers_len;
1171 s->optional = optional;
1172 s->optional_len = optional_len;
1173 s->total_len = total_len;
1174 s->context = context;
1175
1176 addref_object( &request->hdr );
1177 ret = queue_task( (task_header_t *)s );
1178 }
1179 else
1180 ret = send_request( request, headers, headers_len, optional, optional_len, total_len, context, FALSE );
1181
1182 release_object( &request->hdr );
1183 return ret;
1184 }
1185
1186 #define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0]))
1187
1188 static DWORD auth_scheme_from_header( WCHAR *header )
1189 {
1190 static const WCHAR basic[] = {'B','a','s','i','c'};
1191 static const WCHAR ntlm[] = {'N','T','L','M'};
1192 static const WCHAR passport[] = {'P','a','s','s','p','o','r','t'};
1193 static const WCHAR digest[] = {'D','i','g','e','s','t'};
1194 static const WCHAR negotiate[] = {'N','e','g','o','t','i','a','t','e'};
1195
1196 if (!strncmpiW( header, basic, ARRAYSIZE(basic) ) &&
1197 (header[ARRAYSIZE(basic)] == ' ' || !header[ARRAYSIZE(basic)])) return WINHTTP_AUTH_SCHEME_BASIC;
1198
1199 if (!strncmpiW( header, ntlm, ARRAYSIZE(ntlm) ) &&
1200 (header[ARRAYSIZE(ntlm)] == ' ' || !header[ARRAYSIZE(ntlm)])) return WINHTTP_AUTH_SCHEME_NTLM;
1201
1202 if (!strncmpiW( header, passport, ARRAYSIZE(passport) ) &&
1203 (header[ARRAYSIZE(passport)] == ' ' || !header[ARRAYSIZE(passport)])) return WINHTTP_AUTH_SCHEME_PASSPORT;
1204
1205 if (!strncmpiW( header, digest, ARRAYSIZE(digest) ) &&
1206 (header[ARRAYSIZE(digest)] == ' ' || !header[ARRAYSIZE(digest)])) return WINHTTP_AUTH_SCHEME_DIGEST;
1207
1208 if (!strncmpiW( header, negotiate, ARRAYSIZE(negotiate) ) &&
1209 (header[ARRAYSIZE(negotiate)] == ' ' || !header[ARRAYSIZE(negotiate)])) return WINHTTP_AUTH_SCHEME_NEGOTIATE;
1210
1211 return 0;
1212 }
1213
1214 static BOOL query_auth_schemes( request_t *request, DWORD level, LPDWORD supported, LPDWORD first )
1215 {
1216 DWORD index = 0;
1217 BOOL ret = FALSE;
1218
1219 for (;;)
1220 {
1221 WCHAR *buffer;
1222 DWORD size, scheme;
1223
1224 size = 0;
1225 query_headers( request, level, NULL, NULL, &size, &index );
1226 if (get_last_error() != ERROR_INSUFFICIENT_BUFFER) break;
1227
1228 index--;
1229 if (!(buffer = heap_alloc( size ))) return FALSE;
1230 if (!query_headers( request, level, NULL, buffer, &size, &index ))
1231 {
1232 heap_free( buffer );
1233 return FALSE;
1234 }
1235 scheme = auth_scheme_from_header( buffer );
1236 if (first && index == 1) *first = scheme;
1237 *supported |= scheme;
1238
1239 heap_free( buffer );
1240 ret = TRUE;
1241 }
1242 return ret;
1243 }
1244
1245 /***********************************************************************
1246 * WinHttpQueryAuthSchemes (winhttp.@)
1247 */
1248 BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target )
1249 {
1250 BOOL ret = FALSE;
1251 request_t *request;
1252
1253 TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target);
1254
1255 if (!(request = (request_t *)grab_object( hrequest )))
1256 {
1257 set_last_error( ERROR_INVALID_HANDLE );
1258 return FALSE;
1259 }
1260 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
1261 {
1262 release_object( &request->hdr );
1263 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1264 return FALSE;
1265 }
1266
1267 if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first ))
1268 {
1269 *target = WINHTTP_AUTH_TARGET_SERVER;
1270 ret = TRUE;
1271 }
1272 else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first ))
1273 {
1274 *target = WINHTTP_AUTH_TARGET_PROXY;
1275 ret = TRUE;
1276 }
1277
1278 release_object( &request->hdr );
1279 return ret;
1280 }
1281
1282 static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 )
1283 {
1284 UINT n = 0, x;
1285 static const char base64enc[] =
1286 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1287
1288 while (len > 0)
1289 {
1290 /* first 6 bits, all from bin[0] */
1291 base64[n++] = base64enc[(bin[0] & 0xfc) >> 2];
1292 x = (bin[0] & 3) << 4;
1293
1294 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
1295 if (len == 1)
1296 {
1297 base64[n++] = base64enc[x];
1298 base64[n++] = '=';
1299 base64[n++] = '=';
1300 break;
1301 }
1302 base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)];
1303 x = (bin[1] & 0x0f) << 2;
1304
1305 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
1306 if (len == 2)
1307 {
1308 base64[n++] = base64enc[x];
1309 base64[n++] = '=';
1310 break;
1311 }
1312 base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)];
1313
1314 /* last 6 bits, all from bin [2] */
1315 base64[n++] = base64enc[bin[2] & 0x3f];
1316 bin += 3;
1317 len -= 3;
1318 }
1319 base64[n] = 0;
1320 return n;
1321 }
1322
1323 static BOOL set_credentials( request_t *request, DWORD target, DWORD scheme, LPCWSTR username, LPCWSTR password )
1324 {
1325 static const WCHAR basic[] = {'B','a','s','i','c',' ',0};
1326 const WCHAR *auth_scheme, *auth_target;
1327 WCHAR *auth_header;
1328 DWORD len, auth_data_len;
1329 char *auth_data;
1330 BOOL ret;
1331
1332 if (!username || !password)
1333 {
1334 set_last_error( ERROR_INVALID_PARAMETER );
1335 return FALSE;
1336 }
1337
1338 switch (target)
1339 {
1340 case WINHTTP_AUTH_TARGET_SERVER: auth_target = attr_authorization; break;
1341 case WINHTTP_AUTH_TARGET_PROXY: auth_target = attr_proxy_authorization; break;
1342 default:
1343 WARN("unknown target %x\n", target);
1344 return FALSE;
1345 }
1346 switch (scheme)
1347 {
1348 case WINHTTP_AUTH_SCHEME_BASIC:
1349 {
1350 int userlen = WideCharToMultiByte( CP_UTF8, 0, username, strlenW( username ), NULL, 0, NULL, NULL );
1351 int passlen = WideCharToMultiByte( CP_UTF8, 0, password, strlenW( password ), NULL, 0, NULL, NULL );
1352
1353 TRACE("basic authentication\n");
1354
1355 auth_scheme = basic;
1356 auth_data_len = userlen + 1 + passlen;
1357 if (!(auth_data = heap_alloc( auth_data_len ))) return FALSE;
1358
1359 WideCharToMultiByte( CP_UTF8, 0, username, -1, auth_data, userlen, NULL, NULL );
1360 auth_data[userlen] = ':';
1361 WideCharToMultiByte( CP_UTF8, 0, password, -1, auth_data + userlen + 1, passlen, NULL, NULL );
1362 break;
1363 }
1364 case WINHTTP_AUTH_SCHEME_NTLM:
1365 case WINHTTP_AUTH_SCHEME_PASSPORT:
1366 case WINHTTP_AUTH_SCHEME_DIGEST:
1367 case WINHTTP_AUTH_SCHEME_NEGOTIATE:
1368 FIXME("unimplemented authentication scheme %x\n", scheme);
1369 return FALSE;
1370 default:
1371 WARN("unknown authentication scheme %x\n", scheme);
1372 return FALSE;
1373 }
1374
1375 len = strlenW( auth_scheme ) + ((auth_data_len + 2) * 4) / 3;
1376 if (!(auth_header = heap_alloc( (len + 1) * sizeof(WCHAR) )))
1377 {
1378 heap_free( auth_data );
1379 return FALSE;
1380 }
1381 strcpyW( auth_header, auth_scheme );
1382 encode_base64( auth_data, auth_data_len, auth_header + strlenW( auth_header ) );
1383
1384 ret = process_header( request, auth_target, auth_header, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE );
1385
1386 heap_free( auth_data );
1387 heap_free( auth_header );
1388 return ret;
1389 }
1390
1391 /***********************************************************************
1392 * WinHttpSetCredentials (winhttp.@)
1393 */
1394 BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username,
1395 LPCWSTR password, LPVOID params )
1396 {
1397 BOOL ret;
1398 request_t *request;
1399
1400 TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest, target, scheme, debugstr_w(username), password, params);
1401
1402 if (!(request = (request_t *)grab_object( hrequest )))
1403 {
1404 set_last_error( ERROR_INVALID_HANDLE );
1405 return FALSE;
1406 }
1407 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
1408 {
1409 release_object( &request->hdr );
1410 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1411 return FALSE;
1412 }
1413
1414 ret = set_credentials( request, target, scheme, username, password );
1415
1416 release_object( &request->hdr );
1417 return ret;
1418 }
1419
1420 static BOOL handle_authorization( request_t *request, DWORD status )
1421 {
1422 DWORD schemes, level, target;
1423 const WCHAR *username, *password;
1424
1425 switch (status)
1426 {
1427 case 401:
1428 target = WINHTTP_AUTH_TARGET_SERVER;
1429 level = WINHTTP_QUERY_WWW_AUTHENTICATE;
1430 break;
1431
1432 case 407:
1433 target = WINHTTP_AUTH_TARGET_PROXY;
1434 level = WINHTTP_QUERY_PROXY_AUTHENTICATE;
1435 break;
1436
1437 default:
1438 WARN("unhandled status %u\n", status);
1439 return FALSE;
1440 }
1441
1442 if (!query_auth_schemes( request, level, &schemes, NULL )) return FALSE;
1443
1444 if (target == WINHTTP_AUTH_TARGET_SERVER)
1445 {
1446 username = request->connect->username;
1447 password = request->connect->password;
1448 }
1449 else
1450 {
1451 username = request->connect->session->proxy_username;
1452 password = request->connect->session->proxy_password;
1453 }
1454
1455 if (schemes & WINHTTP_AUTH_SCHEME_BASIC)
1456 return set_credentials( request, target, WINHTTP_AUTH_SCHEME_BASIC, username, password );
1457
1458 FIXME("unsupported authentication scheme\n");
1459 return FALSE;
1460 }
1461
1462 static void clear_response_headers( request_t *request )
1463 {
1464 unsigned int i;
1465
1466 for (i = 0; i < request->num_headers; i++)
1467 {
1468 if (!request->headers[i].field) continue;
1469 if (!request->headers[i].value) continue;
1470 if (request->headers[i].is_request) continue;
1471 delete_header( request, i );
1472 i--;
1473 }
1474 }
1475
1476 #define MAX_REPLY_LEN 1460
1477 #define INITIAL_HEADER_BUFFER_LEN 512
1478
1479 static BOOL read_reply( request_t *request )
1480 {
1481 static const WCHAR crlf[] = {'\r','\n',0};
1482
1483 char buffer[MAX_REPLY_LEN];
1484 DWORD buflen, len, offset, received_len, crlf_len = 2; /* strlenW(crlf) */
1485 char *status_code, *status_text;
1486 WCHAR *versionW, *status_textW, *raw_headers;
1487 WCHAR status_codeW[4]; /* sizeof("nnn") */
1488
1489 if (!netconn_connected( &request->netconn )) return FALSE;
1490
1491 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
1492
1493 received_len = 0;
1494 do
1495 {
1496 buflen = MAX_REPLY_LEN;
1497 if (!netconn_get_next_line( &request->netconn, buffer, &buflen )) return FALSE;
1498 received_len += buflen;
1499
1500 /* first line should look like 'HTTP/1.x nnn OK' where nnn is the status code */
1501 if (!(status_code = strchr( buffer, ' ' ))) return FALSE;
1502 status_code++;
1503 if (!(status_text = strchr( status_code, ' ' ))) return FALSE;
1504 if ((len = status_text - status_code) != sizeof("nnn") - 1) return FALSE;
1505 status_text++;
1506
1507 TRACE("version [%s] status code [%s] status text [%s]\n",
1508 debugstr_an(buffer, status_code - buffer - 1),
1509 debugstr_an(status_code, len),
1510 debugstr_a(status_text));
1511
1512 } while (!memcmp( status_code, "100", len )); /* ignore "100 Continue" responses */
1513
1514 /* we rely on the fact that the protocol is ascii */
1515 MultiByteToWideChar( CP_ACP, 0, status_code, len, status_codeW, len );
1516 status_codeW[len] = 0;
1517 if (!(process_header( request, attr_status, status_codeW, WINHTTP_ADDREQ_FLAG_REPLACE, FALSE ))) return FALSE;
1518
1519 len = status_code - buffer;
1520 if (!(versionW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
1521 MultiByteToWideChar( CP_ACP, 0, buffer, len - 1, versionW, len -1 );
1522 versionW[len - 1] = 0;
1523
1524 heap_free( request->version );
1525 request->version = versionW;
1526
1527 len = buflen - (status_text - buffer);
1528 if (!(status_textW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
1529 MultiByteToWideChar( CP_ACP, 0, status_text, len, status_textW, len );
1530
1531 heap_free( request->status_text );
1532 request->status_text = status_textW;
1533
1534 len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_LEN );
1535 if (!(raw_headers = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
1536 MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers, buflen );
1537 memcpy( raw_headers + buflen - 1, crlf, sizeof(crlf) );
1538
1539 heap_free( request->raw_headers );
1540 request->raw_headers = raw_headers;
1541
1542 offset = buflen + crlf_len - 1;
1543 for (;;)
1544 {
1545 header_t *header;
1546
1547 buflen = MAX_REPLY_LEN;
1548 if (!netconn_get_next_line( &request->netconn, buffer, &buflen )) goto end;
1549 received_len += buflen;
1550 if (!*buffer) break;
1551
1552 while (len - offset < buflen + crlf_len)
1553 {
1554 WCHAR *tmp;
1555 len *= 2;
1556 if (!(tmp = heap_realloc( raw_headers, len * sizeof(WCHAR) ))) return FALSE;
1557 request->raw_headers = raw_headers = tmp;
1558 }
1559 MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers + offset, buflen );
1560
1561 if (!(header = parse_header( raw_headers + offset ))) break;
1562 if (!(process_header( request, header->field, header->value, WINHTTP_ADDREQ_FLAG_ADD, FALSE )))
1563 {
1564 free_header( header );
1565 break;
1566 }
1567 free_header( header );
1568 memcpy( raw_headers + offset + buflen - 1, crlf, sizeof(crlf) );
1569 offset += buflen + crlf_len - 1;
1570 }
1571
1572 TRACE("raw headers: %s\n", debugstr_w(raw_headers));
1573
1574 end:
1575 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &received_len, sizeof(DWORD) );
1576 return TRUE;
1577 }
1578
1579 static BOOL handle_redirect( request_t *request, DWORD status )
1580 {
1581 BOOL ret = FALSE;
1582 DWORD size, len;
1583 URL_COMPONENTS uc;
1584 connect_t *connect = request->connect;
1585 INTERNET_PORT port;
1586 WCHAR *hostname = NULL, *location = NULL;
1587 int index;
1588
1589 size = 0;
1590 query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
1591 if (!(location = heap_alloc( size ))) return FALSE;
1592 if (!query_headers( request, WINHTTP_QUERY_LOCATION, NULL, location, &size, NULL )) goto end;
1593
1594 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, size / sizeof(WCHAR) + 1 );
1595
1596 memset( &uc, 0, sizeof(uc) );
1597 uc.dwStructSize = sizeof(uc);
1598 uc.dwSchemeLength = uc.dwHostNameLength = uc.dwUrlPathLength = uc.dwExtraInfoLength = ~0u;
1599
1600 if (!WinHttpCrackUrl( location, size / sizeof(WCHAR), 0, &uc )) /* assume relative redirect */
1601 {
1602 WCHAR *path, *p;
1603
1604 len = strlenW( location ) + 1;
1605 if (location[0] != '/') len++;
1606 if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
1607
1608 if (location[0] != '/') *p++ = '/';
1609 strcpyW( p, location );
1610
1611 heap_free( request->path );
1612 request->path = path;
1613 }
1614 else
1615 {
1616 if (uc.nScheme == INTERNET_SCHEME_HTTP && request->hdr.flags & WINHTTP_FLAG_SECURE)
1617 {
1618 TRACE("redirect from secure page to non-secure page\n");
1619 request->hdr.flags &= ~WINHTTP_FLAG_SECURE;
1620 }
1621 else if (uc.nScheme == INTERNET_SCHEME_HTTPS && !(request->hdr.flags & WINHTTP_FLAG_SECURE))
1622 {
1623 TRACE("redirect from non-secure page to secure page\n");
1624 request->hdr.flags |= WINHTTP_FLAG_SECURE;
1625 }
1626
1627 len = uc.dwHostNameLength;
1628 if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
1629 memcpy( hostname, uc.lpszHostName, len * sizeof(WCHAR) );
1630 hostname[len] = 0;
1631
1632 port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80);
1633 if (strcmpiW( connect->hostname, hostname ) || connect->serverport != port)
1634 {
1635 heap_free( connect->hostname );
1636 connect->hostname = hostname;
1637 connect->hostport = port;
1638 if (!(ret = set_server_for_hostname( connect, hostname, port ))) goto end;
1639
1640 netconn_close( &request->netconn );
1641 if (!(ret = netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE ))) goto end;
1642 }
1643 if (!(ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
1644 if (!(ret = open_connection( request ))) goto end;
1645
1646 heap_free( request->path );
1647 request->path = NULL;
1648 if (uc.dwUrlPathLength)
1649 {
1650 len = uc.dwUrlPathLength + uc.dwExtraInfoLength;
1651 if (!(request->path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
1652 strcpyW( request->path, uc.lpszUrlPath );
1653 }
1654 else request->path = strdupW( slashW );
1655 }
1656
1657 /* remove content-type/length headers */
1658 if ((index = get_header_index( request, attr_content_type, 0, TRUE )) >= 0) delete_header( request, index );
1659 if ((index = get_header_index( request, attr_content_length, 0, TRUE )) >= 0 ) delete_header( request, index );
1660
1661 if (status != HTTP_STATUS_REDIRECT_KEEP_VERB && !strcmpW( request->verb, postW ))
1662 {
1663 heap_free( request->verb );
1664 request->verb = strdupW( getW );
1665 }
1666 ret = TRUE;
1667
1668 end:
1669 if (!ret) heap_free( hostname );
1670 heap_free( location );
1671 return ret;
1672 }
1673
1674 static BOOL receive_data( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL async )
1675 {
1676 DWORD to_read;
1677 int bytes_read;
1678
1679 to_read = min( size, request->content_length - request->content_read );
1680 if (!netconn_recv( &request->netconn, buffer, to_read, async ? 0 : MSG_WAITALL, &bytes_read ))
1681 {
1682 if (bytes_read != to_read)
1683 {
1684 ERR("not all data received %d/%d\n", bytes_read, to_read);
1685 }
1686 /* always return success, even if the network layer returns an error */
1687 *read = 0;
1688 return TRUE;
1689 }
1690 request->content_read += bytes_read;
1691 *read = bytes_read;
1692 return TRUE;
1693 }
1694
1695 static DWORD get_chunk_size( const char *buffer )
1696 {
1697 const char *p;
1698 DWORD size = 0;
1699
1700 for (p = buffer; *p; p++)
1701 {
1702 if (*p >= '0' && *p <= '9') size = size * 16 + *p - '0';
1703 else if (*p >= 'a' && *p <= 'f') size = size * 16 + *p - 'a' + 10;
1704 else if (*p >= 'A' && *p <= 'F') size = size * 16 + *p - 'A' + 10;
1705 else if (*p == ';') break;
1706 }
1707 return size;
1708 }
1709
1710 static BOOL receive_data_chunked( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL async )
1711 {
1712 char reply[MAX_REPLY_LEN], *p = buffer;
1713 DWORD buflen, to_read, to_write = size;
1714 int bytes_read;
1715
1716 *read = 0;
1717 for (;;)
1718 {
1719 if (*read == size) break;
1720
1721 if (request->content_length == ~0u) /* new chunk */
1722 {
1723 buflen = sizeof(reply);
1724 if (!netconn_get_next_line( &request->netconn, reply, &buflen )) break;
1725
1726 if (!(request->content_length = get_chunk_size( reply )))
1727 {
1728 /* zero sized chunk marks end of transfer; read any trailing headers and return */
1729 read_reply( request );
1730 break;
1731 }
1732 }
1733 to_read = min( to_write, request->content_length - request->content_read );
1734
1735 if (!netconn_recv( &request->netconn, p, to_read, async ? 0 : MSG_WAITALL, &bytes_read ))
1736 {
1737 if (bytes_read != to_read)
1738 {
1739 ERR("Not all data received %d/%d\n", bytes_read, to_read);
1740 }
1741 /* always return success, even if the network layer returns an error */
1742 *read = 0;
1743 break;
1744 }
1745 if (!bytes_read) break;
1746
1747 request->content_read += bytes_read;
1748 to_write -= bytes_read;
1749 *read += bytes_read;
1750 p += bytes_read;
1751
1752 if (request->content_read == request->content_length) /* chunk complete */
1753 {
1754 request->content_read = 0;
1755 request->content_length = ~0u;
1756
1757 buflen = sizeof(reply);
1758 if (!netconn_get_next_line( &request->netconn, reply, &buflen ))
1759 {
1760 ERR("Malformed chunk\n");
1761 *read = 0;
1762 break;
1763 }
1764 }
1765 }
1766 return TRUE;
1767 }
1768
1769 static void finished_reading( request_t *request )
1770 {
1771 static const WCHAR closeW[] = {'c','l','o','s','e',0};
1772
1773 BOOL close = FALSE;
1774 WCHAR connection[20];
1775 DWORD size = sizeof(connection);
1776
1777 if (request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE) close = TRUE;
1778 else if (query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection, &size, NULL ) ||
1779 query_headers( request, WINHTTP_QUERY_PROXY_CONNECTION, NULL, connection, &size, NULL ))
1780 {
1781 if (!strcmpiW( connection, closeW )) close = TRUE;
1782 }
1783 else if (!strcmpW( request->version, http1_0 )) close = TRUE;
1784
1785 if (close) close_connection( request );
1786 request->content_length = ~0u;
1787 request->content_read = 0;
1788 }
1789
1790 static BOOL read_data( request_t *request, void *buffer, DWORD to_read, DWORD *read, BOOL async )
1791 {
1792 static const WCHAR chunked[] = {'c','h','u','n','k','e','d',0};
1793
1794 BOOL ret;
1795 WCHAR encoding[20];
1796 DWORD num_bytes, buflen = sizeof(encoding);
1797
1798 if (query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding, &buflen, NULL ) &&
1799 !strcmpiW( encoding, chunked ))
1800 {
1801 ret = receive_data_chunked( request, buffer, to_read, &num_bytes, async );
1802 }
1803 else
1804 ret = receive_data( request, buffer, to_read, &num_bytes, async );
1805
1806 if (async)
1807 {
1808 if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, num_bytes );
1809 else
1810 {
1811 WINHTTP_ASYNC_RESULT result;
1812 result.dwResult = API_READ_DATA;
1813 result.dwError = get_last_error();
1814 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
1815 }
1816 }
1817 if (ret)
1818 {
1819 if (read) *read = num_bytes;
1820 if (!num_bytes) finished_reading( request );
1821 }
1822 return ret;
1823 }
1824
1825 /* read any content returned by the server so that the connection can be reused */
1826 static void drain_content( request_t *request )
1827 {
1828 DWORD bytes_read;
1829 char buffer[2048];
1830
1831 if (!request->content_length)
1832 {
1833 finished_reading( request );
1834 return;
1835 }
1836 for (;;)
1837 {
1838 if (!read_data( request, buffer, sizeof(buffer), &bytes_read, FALSE ) || !bytes_read) return;
1839 }
1840 }
1841
1842 static void record_cookies( request_t *request )
1843 {
1844 unsigned int i;
1845
1846 for (i = 0; i < request->num_headers; i++)
1847 {
1848 header_t *set_cookie = &request->headers[i];
1849 if (!strcmpiW( set_cookie->field, attr_set_cookie ) && !set_cookie->is_request)
1850 {
1851 set_cookies( request, set_cookie->value );
1852 }
1853 }
1854 }
1855
1856 static BOOL receive_response( request_t *request, BOOL async )
1857 {
1858 BOOL ret;
1859 DWORD size, query, status;
1860
1861 for (;;)
1862 {
1863 if (!(ret = read_reply( request )))
1864 {
1865 set_last_error( ERROR_WINHTTP_INVALID_SERVER_RESPONSE );
1866 break;
1867 }
1868 size = sizeof(DWORD);
1869 query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
1870 if (!(ret = query_headers( request, query, NULL, &status, &size, NULL ))) break;
1871
1872 size = sizeof(DWORD);
1873 query = WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER;
1874 if (!query_headers( request, query, NULL, &request->content_length, &size, NULL ))
1875 request->content_length = ~0u;
1876
1877 if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES)) record_cookies( request );
1878
1879 if (status == HTTP_STATUS_MOVED || status == HTTP_STATUS_REDIRECT || status == HTTP_STATUS_REDIRECT_KEEP_VERB)
1880 {
1881 if (request->hdr.disable_flags & WINHTTP_DISABLE_REDIRECTS) break;
1882
1883 drain_content( request );
1884 if (!(ret = handle_redirect( request, status ))) break;
1885
1886 clear_response_headers( request );
1887 send_request( request, NULL, 0, NULL, 0, 0, 0, FALSE ); /* recurse synchronously */
1888 continue;
1889 }
1890 else if (status == 401 || status == 407)
1891 {
1892 if (request->hdr.disable_flags & WINHTTP_DISABLE_AUTHENTICATION) break;
1893
1894 drain_content( request );
1895 if (!handle_authorization( request, status ))
1896 {
1897 ret = TRUE;
1898 break;
1899 }
1900 clear_response_headers( request );
1901 send_request( request, NULL, 0, NULL, 0, 0, 0, FALSE );
1902 continue;
1903 }
1904 break;
1905 }
1906
1907 if (async)
1908 {
1909 if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NULL, 0 );
1910 else
1911 {
1912 WINHTTP_ASYNC_RESULT result;
1913 result.dwResult = API_RECEIVE_RESPONSE;
1914 result.dwError = get_last_error();
1915 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
1916 }
1917 }
1918 return ret;
1919 }
1920
1921 static void task_receive_response( task_header_t *task )
1922 {
1923 receive_response_t *r = (receive_response_t *)task;
1924 receive_response( r->hdr.request, TRUE );
1925 }
1926
1927 /***********************************************************************
1928 * WinHttpReceiveResponse (winhttp.@)
1929 */
1930 BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
1931 {
1932 BOOL ret;
1933 request_t *request;
1934
1935 TRACE("%p, %p\n", hrequest, reserved);
1936
1937 if (!(request = (request_t *)grab_object( hrequest )))
1938 {
1939 set_last_error( ERROR_INVALID_HANDLE );
1940 return FALSE;
1941 }
1942 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
1943 {
1944 release_object( &request->hdr );
1945 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1946 return FALSE;
1947 }
1948
1949 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
1950 {
1951 receive_response_t *r;
1952
1953 if (!(r = heap_alloc( sizeof(receive_response_t) ))) return FALSE;
1954 r->hdr.request = request;
1955 r->hdr.proc = task_receive_response;
1956
1957 addref_object( &request->hdr );
1958 ret = queue_task( (task_header_t *)r );
1959 }
1960 else
1961 ret = receive_response( request, FALSE );
1962
1963 release_object( &request->hdr );
1964 return ret;
1965 }
1966
1967 static BOOL query_data( request_t *request, LPDWORD available, BOOL async )
1968 {
1969 BOOL ret;
1970 DWORD num_bytes;
1971
1972 if ((ret = netconn_query_data_available( &request->netconn, &num_bytes )))
1973 {
1974 if (request->content_read < request->content_length)
1975 {
1976 if (!num_bytes)
1977 {
1978 char buffer[4096];
1979 size_t to_read = min( sizeof(buffer), request->content_length - request->content_read );
1980
1981 ret = netconn_recv( &request->netconn, buffer, to_read, MSG_PEEK, (int *)&num_bytes );
1982 if (ret && !num_bytes) WARN("expected more data to be available\n");
1983 }
1984 }
1985 else if (num_bytes)
1986 {
1987 WARN("extra data available %u\n", num_bytes);
1988 ret = FALSE;
1989 }
1990 }
1991 TRACE("%u bytes available\n", num_bytes);
1992
1993 if (async)
1994 {
1995 if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, &num_bytes, sizeof(DWORD) );
1996 else
1997 {
1998 WINHTTP_ASYNC_RESULT result;
1999 result.dwResult = API_QUERY_DATA_AVAILABLE;
2000 result.dwError = get_last_error();
2001 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2002 }
2003 }
2004 if (ret && available) *available = num_bytes;
2005 return ret;
2006 }
2007
2008 static void task_query_data( task_header_t *task )
2009 {
2010 query_data_t *q = (query_data_t *)task;
2011 query_data( q->hdr.request, q->available, TRUE );
2012 }
2013
2014 /***********************************************************************
2015 * WinHttpQueryDataAvailable (winhttp.@)
2016 */
2017 BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
2018 {
2019 BOOL ret;
2020 request_t *request;
2021
2022 TRACE("%p, %p\n", hrequest, available);
2023
2024 if (!(request = (request_t *)grab_object( hrequest )))
2025 {
2026 set_last_error( ERROR_INVALID_HANDLE );
2027 return FALSE;
2028 }
2029 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2030 {
2031 release_object( &request->hdr );
2032 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2033 return FALSE;
2034 }
2035
2036 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
2037 {
2038 query_data_t *q;
2039
2040 if (!(q = heap_alloc( sizeof(query_data_t) ))) return FALSE;
2041 q->hdr.request = request;
2042 q->hdr.proc = task_query_data;
2043 q->available = available;
2044
2045 addref_object( &request->hdr );
2046 ret = queue_task( (task_header_t *)q );
2047 }
2048 else
2049 ret = query_data( request, available, FALSE );
2050
2051 release_object( &request->hdr );
2052 return ret;
2053 }
2054
2055 static void task_read_data( task_header_t *task )
2056 {
2057 read_data_t *r = (read_data_t *)task;
2058 read_data( r->hdr.request, r->buffer, r->to_read, r->read, TRUE );
2059 }
2060
2061 /***********************************************************************
2062 * WinHttpReadData (winhttp.@)
2063 */
2064 BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD read )
2065 {
2066 BOOL ret;
2067 request_t *request;
2068
2069 TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_read, read);
2070
2071 if (!(request = (request_t *)grab_object( hrequest )))
2072 {
2073 set_last_error( ERROR_INVALID_HANDLE );
2074 return FALSE;
2075 }
2076 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2077 {
2078 release_object( &request->hdr );
2079 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2080 return FALSE;
2081 }
2082
2083 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
2084 {
2085 read_data_t *r;
2086
2087 if (!(r = heap_alloc( sizeof(read_data_t) ))) return FALSE;
2088 r->hdr.request = request;
2089 r->hdr.proc = task_read_data;
2090 r->buffer = buffer;
2091 r->to_read = to_read;
2092 r->read = read;
2093
2094 addref_object( &request->hdr );
2095 ret = queue_task( (task_header_t *)r );
2096 }
2097 else
2098 ret = read_data( request, buffer, to_read, read, FALSE );
2099
2100 release_object( &request->hdr );
2101 return ret;
2102 }
2103
2104 static BOOL write_data( request_t *request, LPCVOID buffer, DWORD to_write, LPDWORD written, BOOL async )
2105 {
2106 BOOL ret;
2107 int num_bytes;
2108
2109 ret = netconn_send( &request->netconn, buffer, to_write, 0, &num_bytes );
2110
2111 if (async)
2112 {
2113 if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &num_bytes, sizeof(DWORD) );
2114 else
2115 {
2116 WINHTTP_ASYNC_RESULT result;
2117 result.dwResult = API_WRITE_DATA;
2118 result.dwError = get_last_error();
2119 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2120 }
2121 }
2122 if (ret && written) *written = num_bytes;
2123 return ret;
2124 }
2125
2126 static void task_write_data( task_header_t *task )
2127 {
2128 write_data_t *w = (write_data_t *)task;
2129 write_data( w->hdr.request, w->buffer, w->to_write, w->written, TRUE );
2130 }
2131
2132 /***********************************************************************
2133 * WinHttpWriteData (winhttp.@)
2134 */
2135 BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write, LPDWORD written )
2136 {
2137 BOOL ret;
2138 request_t *request;
2139
2140 TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_write, written);
2141
2142 if (!(request = (request_t *)grab_object( hrequest )))
2143 {
2144 set_last_error( ERROR_INVALID_HANDLE );
2145 return FALSE;
2146 }
2147 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2148 {
2149 release_object( &request->hdr );
2150 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2151 return FALSE;
2152 }
2153
2154 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
2155 {
2156 write_data_t *w;
2157
2158 if (!(w = heap_alloc( sizeof(write_data_t) ))) return FALSE;
2159 w->hdr.request = request;
2160 w->hdr.proc = task_write_data;
2161 w->buffer = buffer;
2162 w->to_write = to_write;
2163 w->written = written;
2164
2165 addref_object( &request->hdr );
2166 ret = queue_task( (task_header_t *)w );
2167 }
2168 else
2169 ret = write_data( request, buffer, to_write, written, FALSE );
2170
2171 release_object( &request->hdr );
2172 return ret;
2173 }
2174
2175 enum request_state
2176 {
2177 REQUEST_STATE_UNINITIALIZED,
2178 REQUEST_STATE_INITIALIZED,
2179 REQUEST_STATE_CANCELLED,
2180 REQUEST_STATE_OPEN,
2181 REQUEST_STATE_SENT,
2182 REQUEST_STATE_RESPONSE_RECEIVED
2183 };
2184
2185 struct winhttp_request
2186 {
2187 IWinHttpRequest IWinHttpRequest_iface;
2188 LONG refs;
2189 CRITICAL_SECTION cs;
2190 enum request_state state;
2191 HINTERNET hsession;
2192 HINTERNET hconnect;
2193 HINTERNET hrequest;
2194 VARIANT data;
2195 WCHAR *verb;
2196 HANDLE thread;
2197 HANDLE wait;
2198 HANDLE cancel;
2199 char *buffer;
2200 DWORD offset;
2201 DWORD bytes_available;
2202 DWORD bytes_read;
2203 DWORD error;
2204 DWORD logon_policy;
2205 DWORD disable_feature;
2206 LONG resolve_timeout;
2207 LONG connect_timeout;
2208 LONG send_timeout;
2209 LONG receive_timeout;
2210 WINHTTP_PROXY_INFO proxy;
2211 };
2212
2213 static inline struct winhttp_request *impl_from_IWinHttpRequest( IWinHttpRequest *iface )
2214 {
2215 return CONTAINING_RECORD( iface, struct winhttp_request, IWinHttpRequest_iface );
2216 }
2217
2218 static ULONG WINAPI winhttp_request_AddRef(
2219 IWinHttpRequest *iface )
2220 {
2221 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2222 return InterlockedIncrement( &request->refs );
2223 }
2224
2225 /* critical section must be held */
2226 static void cancel_request( struct winhttp_request *request )
2227 {
2228 if (request->state <= REQUEST_STATE_CANCELLED) return;
2229 if (request->thread) SetEvent( request->cancel );
2230 request->state = REQUEST_STATE_CANCELLED;
2231 }
2232
2233 /* critical section must be held */
2234 static void free_request( struct winhttp_request *request )
2235 {
2236 if (request->state < REQUEST_STATE_INITIALIZED) return;
2237 WinHttpCloseHandle( request->hrequest );
2238 WinHttpCloseHandle( request->hconnect );
2239 WinHttpCloseHandle( request->hsession );
2240 CloseHandle( request->thread );
2241 CloseHandle( request->wait );
2242 CloseHandle( request->cancel );
2243 heap_free( (WCHAR *)request->proxy.lpszProxy );
2244 heap_free( (WCHAR *)request->proxy.lpszProxyBypass );
2245 heap_free( request->buffer );
2246 heap_free( request->verb );
2247 VariantClear( &request->data );
2248 }
2249
2250 static ULONG WINAPI winhttp_request_Release(
2251 IWinHttpRequest *iface )
2252 {
2253 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2254 LONG refs = InterlockedDecrement( &request->refs );
2255 if (!refs)
2256 {
2257 TRACE("destroying %p\n", request);
2258
2259 EnterCriticalSection( &request->cs );
2260 cancel_request( request );
2261 free_request( request );
2262 LeaveCriticalSection( &request->cs );
2263 request->cs.DebugInfo->Spare[0] = 0;
2264 DeleteCriticalSection( &request->cs );
2265 heap_free( request );
2266 }
2267 return refs;
2268 }
2269
2270 static HRESULT WINAPI winhttp_request_QueryInterface(
2271 IWinHttpRequest *iface,
2272 REFIID riid,
2273 void **obj )
2274 {
2275 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2276
2277 TRACE("%p, %s, %p\n", request, debugstr_guid(riid), obj );
2278
2279 if (IsEqualGUID( riid, &IID_IWinHttpRequest ) ||
2280 IsEqualGUID( riid, &IID_IDispatch ) ||
2281 IsEqualGUID( riid, &IID_IUnknown ))
2282 {
2283 *obj = iface;
2284 }
2285 else
2286 {
2287 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2288 return E_NOINTERFACE;
2289 }
2290 IWinHttpRequest_AddRef( iface );
2291 return S_OK;
2292 }
2293
2294 static HRESULT WINAPI winhttp_request_GetTypeInfoCount(
2295 IWinHttpRequest *iface,
2296 UINT *count )
2297 {
2298 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2299
2300 TRACE("%p, %p\n", request, count);
2301 *count = 1;
2302 return S_OK;
2303 }
2304
2305 enum type_id
2306 {
2307 IWinHttpRequest_tid,
2308 last_tid
2309 };
2310
2311 static ITypeLib *winhttp_typelib;
2312 static ITypeInfo *winhttp_typeinfo[last_tid];
2313
2314 static REFIID winhttp_tid_id[] =
2315 {
2316 &IID_IWinHttpRequest
2317 };
2318
2319 static HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
2320 {
2321 HRESULT hr;
2322
2323 if (!winhttp_typelib)
2324 {
2325 ITypeLib *typelib;
2326
2327 hr = LoadRegTypeLib( &LIBID_WinHttp, 5, 1, LOCALE_SYSTEM_DEFAULT, &typelib );
2328 if (FAILED(hr))
2329 {
2330 ERR("LoadRegTypeLib failed: %08x\n", hr);
2331 return hr;
2332 }
2333 if (InterlockedCompareExchangePointer( (void **)&winhttp_typelib, typelib, NULL ))
2334 ITypeLib_Release( typelib );
2335 }
2336 if (!winhttp_typeinfo[tid])
2337 {
2338 ITypeInfo *typeinfo;
2339
2340 hr = ITypeLib_GetTypeInfoOfGuid( winhttp_typelib, winhttp_tid_id[tid], &typeinfo );
2341 if (FAILED(hr))
2342 {
2343 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(winhttp_tid_id[tid]), hr);
2344 return hr;
2345 }
2346 if (InterlockedCompareExchangePointer( (void **)(winhttp_typeinfo + tid), typeinfo, NULL ))
2347 ITypeInfo_Release( typeinfo );
2348 }
2349 *ret = winhttp_typeinfo[tid];
2350 return S_OK;
2351 }
2352
2353 static HRESULT WINAPI winhttp_request_GetTypeInfo(
2354 IWinHttpRequest *iface,
2355 UINT index,
2356 LCID lcid,
2357 ITypeInfo **info )
2358 {
2359 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2360 TRACE("%p, %u, %u, %p\n", request, index, lcid, info);
2361
2362 return get_typeinfo( IWinHttpRequest_tid, info );
2363 }
2364
2365 static HRESULT WINAPI winhttp_request_GetIDsOfNames(
2366 IWinHttpRequest *iface,
2367 REFIID riid,
2368 LPOLESTR *names,
2369 UINT count,
2370 LCID lcid,
2371 DISPID *dispid )
2372 {
2373 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2374 ITypeInfo *typeinfo;
2375 HRESULT hr;
2376
2377 TRACE("%p, %s, %p, %u, %u, %p\n", request, debugstr_guid(riid), names, count, lcid, dispid);
2378
2379 if (!names || !count || !dispid) return E_INVALIDARG;
2380
2381 hr = get_typeinfo( IWinHttpRequest_tid, &typeinfo );
2382 if (SUCCEEDED(hr))
2383 {
2384 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
2385 ITypeInfo_Release( typeinfo );
2386 }
2387 return hr;
2388 }
2389
2390 static HRESULT WINAPI winhttp_request_Invoke(
2391 IWinHttpRequest *iface,
2392 DISPID member,
2393 REFIID riid,
2394 LCID lcid,
2395 WORD flags,
2396 DISPPARAMS *params,
2397 VARIANT *result,
2398 EXCEPINFO *excep_info,
2399 UINT *arg_err )
2400 {
2401 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2402 ITypeInfo *typeinfo;
2403 HRESULT hr;
2404
2405 TRACE("%p, %d, %s, %d, %d, %p, %p, %p, %p\n", request, member, debugstr_guid(riid),
2406 lcid, flags, params, result, excep_info, arg_err);
2407
2408 hr = get_typeinfo( IWinHttpRequest_tid, &typeinfo );
2409 if (SUCCEEDED(hr))
2410 {
2411 hr = ITypeInfo_Invoke( typeinfo, &request->IWinHttpRequest_iface, member, flags,
2412 params, result, excep_info, arg_err );
2413 ITypeInfo_Release( typeinfo );
2414 }
2415 return hr;
2416 }
2417
2418 static HRESULT WINAPI winhttp_request_SetProxy(
2419 IWinHttpRequest *iface,
2420 HTTPREQUEST_PROXY_SETTING proxy_setting,
2421 VARIANT proxy_server,
2422 VARIANT bypass_list )
2423 {
2424 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2425 DWORD err = ERROR_SUCCESS;
2426
2427 TRACE("%p, %u, %s, %s\n", request, proxy_setting, debugstr_variant(&proxy_server),
2428 debugstr_variant(&bypass_list));
2429
2430 EnterCriticalSection( &request->cs );
2431 switch (proxy_setting)
2432 {
2433 case HTTPREQUEST_PROXYSETTING_DEFAULT:
2434 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
2435 heap_free( (WCHAR *)request->proxy.lpszProxy );
2436 heap_free( (WCHAR *)request->proxy.lpszProxyBypass );
2437 request->proxy.lpszProxy = NULL;
2438 request->proxy.lpszProxyBypass = NULL;
2439 break;
2440
2441 case HTTPREQUEST_PROXYSETTING_DIRECT:
2442 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
2443 heap_free( (WCHAR *)request->proxy.lpszProxy );
2444 heap_free( (WCHAR *)request->proxy.lpszProxyBypass );
2445 request->proxy.lpszProxy = NULL;
2446 request->proxy.lpszProxyBypass = NULL;
2447 break;
2448
2449 case HTTPREQUEST_PROXYSETTING_PROXY:
2450 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
2451 if (V_VT( &proxy_server ) == VT_BSTR)
2452 {
2453 heap_free( (WCHAR *)request->proxy.lpszProxy );
2454 request->proxy.lpszProxy = strdupW( V_BSTR( &proxy_server ) );
2455 }
2456 if (V_VT( &bypass_list ) == VT_BSTR)
2457 {
2458 heap_free( (WCHAR *)request->proxy.lpszProxyBypass );
2459 request->proxy.lpszProxyBypass = strdupW( V_BSTR( &bypass_list ) );
2460 }
2461 break;
2462
2463 default:
2464 err = ERROR_INVALID_PARAMETER;
2465 break;
2466 }
2467 LeaveCriticalSection( &request->cs );
2468 return HRESULT_FROM_WIN32( err );
2469 }
2470
2471 static HRESULT WINAPI winhttp_request_SetCredentials(
2472 IWinHttpRequest *iface,
2473 BSTR username,
2474 BSTR password,
2475 HTTPREQUEST_SETCREDENTIALS_FLAGS flags )
2476 {
2477 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2478 DWORD target, scheme = WINHTTP_AUTH_SCHEME_BASIC; /* FIXME: query supported schemes */
2479 DWORD err = ERROR_SUCCESS;
2480
2481 TRACE("%p, %s, %p\n", request, debugstr_w(username), password);
2482
2483 EnterCriticalSection( &request->cs );
2484 if (request->state < REQUEST_STATE_OPEN)
2485 {
2486 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN;
2487 goto done;
2488 }
2489 switch (flags)
2490 {
2491 case HTTPREQUEST_SETCREDENTIALS_FOR_SERVER:
2492 target = WINHTTP_AUTH_TARGET_SERVER;
2493 break;
2494 case HTTPREQUEST_SETCREDENTIALS_FOR_PROXY:
2495 target = WINHTTP_AUTH_TARGET_PROXY;
2496 break;
2497 default:
2498 err = ERROR_INVALID_PARAMETER;
2499 goto done;
2500 }
2501 if (!WinHttpSetCredentials( request->hrequest, target, scheme, username, password, NULL ))
2502 {
2503 err = get_last_error();
2504 }
2505 done:
2506 LeaveCriticalSection( &request->cs );
2507 return HRESULT_FROM_WIN32( err );
2508 }
2509
2510 static void initialize_request( struct winhttp_request *request )
2511 {
2512 request->hrequest = NULL;
2513 request->hconnect = NULL;
2514 request->hsession = NULL;
2515 request->thread = NULL;
2516 request->wait = NULL;
2517 request->cancel = NULL;
2518 request->buffer = NULL;
2519 request->verb = NULL;
2520 request->offset = 0;
2521 request->bytes_available = 0;
2522 request->bytes_read = 0;
2523 request->error = ERROR_SUCCESS;
2524 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM;
2525 request->disable_feature = WINHTTP_DISABLE_AUTHENTICATION;
2526 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
2527 request->proxy.lpszProxy = NULL;
2528 request->proxy.lpszProxyBypass = NULL;
2529 request->resolve_timeout = 0;
2530 request->connect_timeout = 60000;
2531 request->send_timeout = 30000;
2532 request->receive_timeout = 30000;
2533 VariantInit( &request->data );
2534 request->state = REQUEST_STATE_INITIALIZED;
2535 }
2536
2537 static HRESULT WINAPI winhttp_request_Open(
2538 IWinHttpRequest *iface,
2539 BSTR method,
2540 BSTR url,
2541 VARIANT async )
2542 {
2543 static const WCHAR typeW[] = {'*','/','*',0};
2544 static const WCHAR *acceptW[] = {typeW, NULL};
2545 static const WCHAR httpsW[] = {'h','t','t','p','s'};
2546 static const WCHAR user_agentW[] = {
2547 'M','o','z','i','l','l','a','/','4','.','0',' ','(','c','o','m','p','a','t','i','b','l','e',';',' ',
2548 'W','i','n','3','2',';',' ','W','i','n','H','t','t','p','.','W','i','n','H','t','t','p',
2549 'R','e','q','u','e','s','t','.','5',')',0};
2550 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2551 HINTERNET hsession = NULL, hconnect = NULL, hrequest;
2552 URL_COMPONENTS uc;
2553 WCHAR *hostname, *path = NULL, *verb = NULL;
2554 DWORD err = ERROR_OUTOFMEMORY, len, flags = 0, request_flags = 0;
2555
2556 TRACE("%p, %s, %s, %s\n", request, debugstr_w(method), debugstr_w(url),
2557 debugstr_variant(&async));
2558
2559 if (!method || !url) return E_INVALIDARG;
2560
2561 memset( &uc, 0, sizeof(uc) );
2562 uc.dwStructSize = sizeof(uc);
2563 uc.dwSchemeLength = ~0u;
2564 uc.dwHostNameLength = ~0u;
2565 uc.dwUrlPathLength = ~0u;
2566 uc.dwExtraInfoLength = ~0u;
2567 if (!WinHttpCrackUrl( url, 0, 0, &uc )) return HRESULT_FROM_WIN32( get_last_error() );
2568
2569 EnterCriticalSection( &request->cs );
2570 if (request->state != REQUEST_STATE_INITIALIZED)
2571 {
2572 cancel_request( request );
2573 free_request( request );
2574 initialize_request( request );
2575 }
2576 if (!(hostname = heap_alloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) goto error;
2577 memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
2578 hostname[uc.dwHostNameLength] = 0;
2579
2580 if (!(path = heap_alloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) ))) goto error;
2581 memcpy( path, uc.lpszUrlPath, (uc.dwUrlPathLength + uc.dwExtraInfoLength) * sizeof(WCHAR) );
2582 path[uc.dwUrlPathLength + uc.dwExtraInfoLength] = 0;
2583
2584 if (!(verb = strdupW( method ))) goto error;
2585 if (V_BOOL( &async )) flags |= WINHTTP_FLAG_ASYNC;
2586 if (!(hsession = WinHttpOpen( user_agentW, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, NULL, NULL, flags )))
2587 {
2588 err = get_last_error();
2589 goto error;
2590 }
2591 if (!(hconnect = WinHttpConnect( hsession, hostname, uc.nPort, 0 )))
2592 {
2593 err = get_last_error();
2594 goto error;
2595 }
2596 len = sizeof(httpsW) / sizeof(WCHAR);
2597 if (uc.dwSchemeLength == len && !memcmp( uc.lpszScheme, httpsW, len * sizeof(WCHAR) ))
2598 {
2599 request_flags |= WINHTTP_FLAG_SECURE;
2600 }
2601 if (!(hrequest = WinHttpOpenRequest( hconnect, method, path, NULL, NULL, acceptW, request_flags )))
2602 {
2603 err = get_last_error();
2604 goto error;
2605 }
2606 if (flags & WINHTTP_FLAG_ASYNC)
2607 {
2608 request->wait = CreateEventW( NULL, FALSE, FALSE, NULL );
2609 request->cancel = CreateEventW( NULL, FALSE, FALSE, NULL );
2610 WinHttpSetOption( hrequest, WINHTTP_OPTION_CONTEXT_VALUE, &request, sizeof(request) );
2611 }
2612 request->state = REQUEST_STATE_OPEN;
2613 request->hsession = hsession;
2614 request->hconnect = hconnect;
2615 request->hrequest = hrequest;
2616 request->verb = verb;
2617 heap_free( hostname );
2618 heap_free( path );
2619 LeaveCriticalSection( &request->cs );
2620 return S_OK;
2621
2622 error:
2623 WinHttpCloseHandle( hconnect );
2624 WinHttpCloseHandle( hsession );
2625 heap_free( hostname );
2626 heap_free( path );
2627 heap_free( verb );
2628 LeaveCriticalSection( &request->cs );
2629 return HRESULT_FROM_WIN32( err );
2630 }
2631
2632 static HRESULT WINAPI winhttp_request_SetRequestHeader(
2633 IWinHttpRequest *iface,
2634 BSTR header,
2635 BSTR value )
2636 {
2637 static const WCHAR fmtW[] = {'%','s',':',' ','%','s','\r','\n',0};
2638 static const WCHAR emptyW[] = {0};
2639 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2640 DWORD len, err = ERROR_SUCCESS;
2641 WCHAR *str;
2642
2643 TRACE("%p, %s, %s\n", request, debugstr_w(header), debugstr_w(value));
2644
2645 if (!header) return E_INVALIDARG;
2646
2647 EnterCriticalSection( &request->cs );
2648 if (request->state < REQUEST_STATE_OPEN)
2649 {
2650 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN;
2651 goto done;
2652 }
2653 if (request->state >= REQUEST_STATE_SENT)
2654 {
2655 err = ERROR_WINHTTP_CANNOT_CALL_AFTER_SEND;
2656 goto done;
2657 }
2658 len = strlenW( header ) + 4;
2659 if (value) len += strlenW( value );
2660 if (!(str = heap_alloc( (len + 1) * sizeof(WCHAR) )))
2661 {
2662 err = ERROR_OUTOFMEMORY;
2663 goto done;
2664 }
2665 sprintfW( str, fmtW, header, value ? value : emptyW );
2666 if (!WinHttpAddRequestHeaders( request->hrequest, str, len, WINHTTP_ADDREQ_FLAG_REPLACE ))
2667 {
2668 err = get_last_error();
2669 }
2670 heap_free( str );
2671
2672 done:
2673 LeaveCriticalSection( &request->cs );
2674 return HRESULT_FROM_WIN32( err );
2675 }
2676
2677 static HRESULT WINAPI winhttp_request_GetResponseHeader(
2678 IWinHttpRequest *iface,
2679 BSTR header,
2680 BSTR *value )
2681 {
2682 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2683 DWORD size, err = ERROR_SUCCESS;
2684
2685 TRACE("%p, %p\n", request, header);
2686
2687 EnterCriticalSection( &request->cs );
2688 if (request->state < REQUEST_STATE_SENT)
2689 {
2690 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
2691 goto done;
2692 }
2693 if (!header || !value)
2694 {
2695 err = ERROR_INVALID_PARAMETER;
2696 goto done;
2697 }
2698 size = 0;
2699 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CUSTOM, header, NULL, &size, NULL ))
2700 {
2701 err = get_last_error();
2702 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
2703 }
2704 if (!(*value = SysAllocStringLen( NULL, size / sizeof(WCHAR) )))
2705 {
2706 err = ERROR_OUTOFMEMORY;
2707 goto done;
2708 }
2709 err = ERROR_SUCCESS;
2710 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CUSTOM, header, *value, &size, NULL ))
2711 {
2712 err = get_last_error();
2713 SysFreeString( *value );
2714 }
2715 done:
2716 LeaveCriticalSection( &request->cs );
2717 return HRESULT_FROM_WIN32( err );
2718 }
2719
2720 static HRESULT WINAPI winhttp_request_GetAllResponseHeaders(
2721 IWinHttpRequest *iface,
2722 BSTR *headers )
2723 {
2724 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2725 DWORD size, err = ERROR_SUCCESS;
2726
2727 TRACE("%p, %p\n", request, headers);
2728
2729 if (!headers) return E_INVALIDARG;
2730
2731 EnterCriticalSection( &request->cs );
2732 if (request->state < REQUEST_STATE_SENT)
2733 {
2734 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
2735 goto done;
2736 }
2737 size = 0;
2738 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, NULL, NULL, &size, NULL ))
2739 {
2740 err = get_last_error();
2741 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
2742 }
2743 if (!(*headers = SysAllocStringLen( NULL, size / sizeof(WCHAR) )))
2744 {
2745 err = ERROR_OUTOFMEMORY;
2746 goto done;
2747 }
2748 err = ERROR_SUCCESS;
2749 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, NULL, *headers, &size, NULL ))
2750 {
2751 err = get_last_error();
2752 SysFreeString( *headers );
2753 }
2754 done:
2755 LeaveCriticalSection( &request->cs );
2756 return HRESULT_FROM_WIN32( err );
2757 }
2758
2759 static void CALLBACK wait_status_callback( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD size )
2760 {
2761 struct winhttp_request *request = (struct winhttp_request *)context;
2762
2763 switch (status)
2764 {
2765 case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE:
2766 request->bytes_available = *(DWORD *)buffer;
2767 request->error = ERROR_SUCCESS;
2768 break;
2769 case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
2770 request->bytes_read = size;
2771 request->error = ERROR_SUCCESS;
2772 break;
2773 case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
2774 {
2775 WINHTTP_ASYNC_RESULT *result = (WINHTTP_ASYNC_RESULT *)buffer;
2776 request->error = result->dwError;
2777 break;
2778 }
2779 default: break;
2780 }
2781 SetEvent( request->wait );
2782 }
2783
2784 static void wait_set_status_callback( struct winhttp_request *request, DWORD status )
2785 {
2786 if (!request->wait) return;
2787 status |= WINHTTP_CALLBACK_STATUS_REQUEST_ERROR;
2788 WinHttpSetStatusCallback( request->hrequest, wait_status_callback, status, 0 );
2789 }
2790
2791 static DWORD wait_for_completion( struct winhttp_request *request )
2792 {
2793 HANDLE handles[2];
2794
2795 if (!request->wait)
2796 {
2797 request->error = ERROR_SUCCESS;
2798 return ERROR_SUCCESS;
2799 }
2800 handles[0] = request->wait;
2801 handles[1] = request->cancel;
2802 switch (WaitForMultipleObjects( 2, handles, FALSE, INFINITE ))
2803 {
2804 case WAIT_OBJECT_0:
2805 break;
2806 case WAIT_OBJECT_0 + 1:
2807 request->error = ERROR_CANCELLED;
2808 break;
2809 default:
2810 request->error = get_last_error();
2811 break;
2812 }
2813 return request->error;
2814 }
2815
2816 static HRESULT request_receive( struct winhttp_request *request )
2817 {
2818 DWORD err, size, total_bytes_read, buflen = 4096;
2819
2820 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE );
2821 if (!WinHttpReceiveResponse( request->hrequest, NULL ))
2822 {
2823 return HRESULT_FROM_WIN32( get_last_error() );
2824 }
2825 if ((err = wait_for_completion( request ))) return HRESULT_FROM_WIN32( err );
2826 if (!strcmpW( request->verb, headW ))
2827 {
2828 request->state = REQUEST_STATE_RESPONSE_RECEIVED;
2829 return S_OK;
2830 }
2831 if (!(request->buffer = heap_alloc( buflen ))) return E_OUTOFMEMORY;
2832 request->buffer[0] = 0;
2833 size = total_bytes_read = 0;
2834 do
2835 {
2836 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE );
2837 if (!WinHttpQueryDataAvailable( request->hrequest, &request->bytes_available ))
2838 {
2839 err = get_last_error();
2840 goto error;
2841 }
2842 if ((err = wait_for_completion( request ))) goto error;
2843 if (!request->bytes_available) break;
2844 size += request->bytes_available;
2845 if (buflen < size)
2846 {
2847 char *tmp;
2848 while (buflen < size) buflen *= 2;
2849 if (!(tmp = heap_realloc( request->buffer, buflen )))
2850 {
2851 err = ERROR_OUTOFMEMORY;
2852 goto error;
2853 }
2854 request->buffer = tmp;
2855 }
2856 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_READ_COMPLETE );
2857 if (!WinHttpReadData( request->hrequest, request->buffer + request->offset,
2858 request->bytes_available, &request->bytes_read ))
2859 {
2860 err = get_last_error();
2861 goto error;
2862 }
2863 if ((err = wait_for_completion( request ))) goto error;
2864 total_bytes_read += request->bytes_read;
2865 request->offset += request->bytes_read;
2866 } while (request->bytes_read);
2867
2868 request->state = REQUEST_STATE_RESPONSE_RECEIVED;
2869 return S_OK;
2870
2871 error:
2872 heap_free( request->buffer );
2873 request->buffer = NULL;
2874 return HRESULT_FROM_WIN32( err );
2875 }
2876
2877 static DWORD request_set_parameters( struct winhttp_request *request )
2878 {
2879 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_PROXY, &request->proxy,
2880 sizeof(request->proxy) )) return get_last_error();
2881
2882 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_AUTOLOGON_POLICY, &request->logon_policy,
2883 sizeof(request->logon_policy) )) return get_last_error();
2884
2885 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_DISABLE_FEATURE, &request->disable_feature,
2886 sizeof(request->disable_feature) )) return get_last_error();
2887
2888 if (!WinHttpSetTimeouts( request->hrequest,
2889 request->resolve_timeout,
2890 request->connect_timeout,
2891 request->send_timeout,
2892 request->receive_timeout )) return get_last_error();
2893 return ERROR_SUCCESS;
2894 }
2895
2896 static void request_set_utf8_content_type( struct winhttp_request *request )
2897 {
2898 static const WCHAR fmtW[] = {'%','s',':',' ','%','s',0};
2899 static const WCHAR text_plainW[] = {'t','e','x','t','/','p','l','a','i','n',0};
2900 static const WCHAR charset_utf8W[] = {'c','h','a','r','s','e','t','=','u','t','f','-','8',0};
2901 WCHAR headerW[64];
2902 int len;
2903
2904 len = sprintfW( headerW, fmtW, attr_content_type, text_plainW );
2905 WinHttpAddRequestHeaders( request->hrequest, headerW, len, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
2906 len = sprintfW( headerW, fmtW, attr_content_type, charset_utf8W );
2907 WinHttpAddRequestHeaders( request->hrequest, headerW, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
2908 }
2909
2910 static HRESULT request_send( struct winhttp_request *request )
2911 {
2912 SAFEARRAY *sa = NULL;
2913 VARIANT data;
2914 char *ptr = NULL;
2915 LONG size = 0;
2916 HRESULT hr;
2917 BOOL ret;
2918 DWORD err;
2919
2920 if ((err = request_set_parameters( request ))) return HRESULT_FROM_WIN32( err );
2921 if (strcmpW( request->verb, getW ))
2922 {
2923 VariantInit( &data );
2924 if (V_VT( &request->data ) == VT_BSTR)
2925 {
2926 UINT i, cp = CP_ACP;
2927 const WCHAR *str = V_BSTR( &request->data );
2928 int len = strlenW( str );
2929
2930 for (i = 0; i < len; i++)
2931 {
2932 if (str[i] > 127)
2933 {
2934 cp = CP_UTF8;
2935 break;
2936 }
2937 }
2938 size = WideCharToMultiByte( cp, 0, str, len, NULL, 0, NULL, NULL );
2939 if (!(ptr = heap_alloc( size ))) return E_OUTOFMEMORY;
2940 WideCharToMultiByte( cp, 0, str, len, ptr, size, NULL, NULL );
2941 if (cp == CP_UTF8) request_set_utf8_content_type( request );
2942 }
2943 else if (VariantChangeType( &data, &request->data, 0, VT_ARRAY|VT_UI1 ) == S_OK)
2944 {
2945 sa = V_ARRAY( &data );
2946 if ((hr = SafeArrayAccessData( sa, (void **)&ptr )) != S_OK) return hr;
2947 if ((hr = SafeArrayGetUBound( sa, 1, &size ) != S_OK))
2948 {
2949 SafeArrayUnaccessData( sa );
2950 return hr;
2951 }
2952 size++;
2953 }
2954 }
2955 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT );
2956 if (!(ret = WinHttpSendRequest( request->hrequest, NULL, 0, ptr, size, size, 0 )))
2957 {
2958 err = get_last_error();
2959 goto error;
2960 }
2961 if ((err = wait_for_completion( request ))) goto error;
2962 if (sa) SafeArrayUnaccessData( sa );
2963 else heap_free( ptr );
2964 request->state = REQUEST_STATE_SENT;
2965 return S_OK;
2966
2967 error:
2968 if (sa) SafeArrayUnaccessData( sa );
2969 else heap_free( ptr );
2970 return HRESULT_FROM_WIN32( err );
2971 }
2972
2973 static HRESULT request_send_and_receive( struct winhttp_request *request )
2974 {
2975 HRESULT hr = request_send( request );
2976 if (hr == S_OK) hr = request_receive( request );
2977 return hr;
2978 }
2979
2980 static DWORD CALLBACK send_and_receive_proc( void *arg )
2981 {
2982 struct winhttp_request *request = (struct winhttp_request *)arg;
2983 return request_send_and_receive( request );
2984 }
2985
2986 static HRESULT WINAPI winhttp_request_Send(
2987 IWinHttpRequest *iface,
2988 VARIANT body )
2989 {
2990 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
2991 HRESULT hr;
2992
2993 TRACE("%p, %s\n", request, debugstr_variant(&body));
2994
2995 EnterCriticalSection( &request->cs );
2996 if (request->state < REQUEST_STATE_OPEN)
2997 {
2998 LeaveCriticalSection( &request->cs );
2999 return HRESULT_FROM_WIN32( ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN );
3000 }
3001 if (request->state >= REQUEST_STATE_SENT)
3002 {
3003 LeaveCriticalSection( &request->cs );
3004 return S_OK;
3005 }
3006 VariantClear( &request->data );
3007 if ((hr = VariantCopyInd( &request->data, &body )) != S_OK) {
3008 LeaveCriticalSection( &request->cs );
3009 return hr;
3010 }
3011
3012 if (request->wait) /* async request */
3013 {
3014 if (!(request->thread = CreateThread( NULL, 0, send_and_receive_proc, request, 0, NULL )))
3015 {
3016 LeaveCriticalSection( &request->cs );
3017 return HRESULT_FROM_WIN32( get_last_error() );
3018 }
3019 }
3020 else hr = request_send_and_receive( request );
3021 LeaveCriticalSection( &request->cs );
3022 return hr;
3023 }
3024
3025 static HRESULT WINAPI winhttp_request_get_Status(
3026 IWinHttpRequest *iface,
3027 LONG *status )
3028 {
3029 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3030 DWORD err = ERROR_SUCCESS, flags, status_code, len = sizeof(status_code), index = 0;
3031
3032 TRACE("%p, %p\n", request, status);
3033
3034 if (!status) return E_INVALIDARG;
3035
3036 EnterCriticalSection( &request->cs );
3037 if (request->state < REQUEST_STATE_SENT)
3038 {
3039 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
3040 goto done;
3041 }
3042 flags = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
3043 if (!WinHttpQueryHeaders( request->hrequest, flags, NULL, &status_code, &len, &index ))
3044 {
3045 err = get_last_error();
3046 }
3047 *status = status_code;
3048
3049 done:
3050 LeaveCriticalSection( &request->cs );
3051 return HRESULT_FROM_WIN32( err );
3052 }
3053
3054 static HRESULT WINAPI winhttp_request_get_StatusText(
3055 IWinHttpRequest *iface,
3056 BSTR *status )
3057 {
3058 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3059 DWORD err = ERROR_SUCCESS, len = 0, index = 0;
3060
3061 TRACE("%p, %p\n", request, status);
3062
3063 if (!status) return E_INVALIDARG;
3064
3065 EnterCriticalSection( &request->cs );
3066 if (request->state < REQUEST_STATE_SENT)
3067 {
3068 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
3069 goto done;
3070 }
3071 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_STATUS_TEXT, NULL, NULL, &len, &index ))
3072 {
3073 err = get_last_error();
3074 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
3075 }
3076 if (!(*status = SysAllocStringLen( NULL, len / sizeof(WCHAR) )))
3077 {
3078 err = ERROR_OUTOFMEMORY;
3079 goto done;
3080 }
3081 index = 0;
3082 err = ERROR_SUCCESS;
3083 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_STATUS_TEXT, NULL, *status, &len, &index ))
3084 {
3085 err = get_last_error();
3086 SysFreeString( *status );
3087 }
3088 done:
3089 LeaveCriticalSection( &request->cs );
3090 return HRESULT_FROM_WIN32( err );
3091 }
3092
3093 static DWORD request_get_codepage( struct winhttp_request *request, UINT *codepage )
3094 {
3095 static const WCHAR utf8W[] = {'u','t','f','-','8',0};
3096 static const WCHAR charsetW[] = {'c','h','a','r','s','e','t',0};
3097 WCHAR *buffer, *p;
3098 DWORD size;
3099
3100 *codepage = CP_ACP;
3101 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, NULL, &size, NULL ) &&
3102 get_last_error() == ERROR_INSUFFICIENT_BUFFER)
3103 {
3104 if (!(buffer = heap_alloc( size ))) return ERROR_OUTOFMEMORY;
3105 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, buffer, &size, NULL ))
3106 {
3107 return get_last_error();
3108 }
3109 if ((p = strstrW( buffer, charsetW )))
3110 {
3111 p += strlenW( charsetW );
3112 while (*p == ' ') p++;
3113 if (*p++ == '=')
3114 {
3115 while (*p == ' ') p++;
3116 if (!strcmpiW( p, utf8W )) *codepage = CP_UTF8;
3117 }
3118 }
3119 heap_free( buffer );
3120 }
3121 return ERROR_SUCCESS;
3122 }
3123
3124 static HRESULT WINAPI winhttp_request_get_ResponseText(
3125 IWinHttpRequest *iface,
3126 BSTR *body )
3127 {
3128 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3129 UINT codepage;
3130 DWORD err = ERROR_SUCCESS;
3131 int len;
3132
3133 TRACE("%p, %p\n", request, body);
3134
3135 if (!body) return E_INVALIDARG;
3136
3137 EnterCriticalSection( &request->cs );
3138 if (request->state < REQUEST_STATE_SENT)
3139 {
3140 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
3141 goto done;
3142 }
3143 if ((err = request_get_codepage( request, &codepage ))) goto done;
3144 len = MultiByteToWideChar( codepage, 0, request->buffer, request->offset, NULL, 0 );
3145 if (!(*body = SysAllocStringLen( NULL, len )))
3146 {
3147 err = ERROR_OUTOFMEMORY;
3148 goto done;
3149 }
3150 MultiByteToWideChar( codepage, 0, request->buffer, request->offset, *body, len );
3151 (*body)[len] = 0;
3152
3153 done:
3154 LeaveCriticalSection( &request->cs );
3155 return HRESULT_FROM_WIN32( err );
3156 }
3157
3158 static HRESULT WINAPI winhttp_request_get_ResponseBody(
3159 IWinHttpRequest *iface,
3160 VARIANT *body )
3161 {
3162 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3163 SAFEARRAY *sa;
3164 HRESULT hr;
3165 DWORD err = ERROR_SUCCESS;
3166 char *ptr;
3167
3168 TRACE("%p, %p\n", request, body);
3169
3170 if (!body) return E_INVALIDARG;
3171
3172 EnterCriticalSection( &request->cs );
3173 if (!(sa = SafeArrayCreateVector( VT_UI1, 0, request->offset )))
3174 {
3175 err = ERROR_OUTOFMEMORY;
3176 goto done;
3177 }
3178 if ((hr = SafeArrayAccessData( sa, (void **)&ptr )) != S_OK)
3179 {
3180 SafeArrayDestroy( sa );
3181 LeaveCriticalSection( &request->cs );
3182 return hr;
3183 }
3184 memcpy( ptr, request->buffer, request->offset );
3185 if ((hr = SafeArrayUnaccessData( sa )) != S_OK)
3186 {
3187 SafeArrayDestroy( sa );
3188 LeaveCriticalSection( &request->cs );
3189 return hr;
3190 }
3191 V_VT( body ) = VT_ARRAY|VT_UI1;
3192 V_ARRAY( body ) = sa;
3193
3194 done:
3195 LeaveCriticalSection( &request->cs );
3196 return HRESULT_FROM_WIN32( err );
3197 }
3198
3199 static HRESULT WINAPI winhttp_request_get_ResponseStream(
3200 IWinHttpRequest *iface,
3201 VARIANT *body )
3202 {
3203 FIXME("\n");
3204 return E_NOTIMPL;
3205 }
3206
3207 static HRESULT WINAPI winhttp_request_get_Option(
3208 IWinHttpRequest *iface,
3209 WinHttpRequestOption option,
3210 VARIANT *value )
3211 {
3212 FIXME("\n");
3213 return E_NOTIMPL;
3214 }
3215
3216 static HRESULT WINAPI winhttp_request_put_Option(
3217 IWinHttpRequest *iface,
3218 WinHttpRequestOption option,
3219 VARIANT value )
3220 {
3221 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3222 HRESULT hr = S_OK;
3223
3224 TRACE("%p, %u, %s\n", request, option, debugstr_variant(&value));
3225
3226 EnterCriticalSection( &request->cs );
3227 switch (option)
3228 {
3229 case WinHttpRequestOption_EnableRedirects:
3230 {
3231 if (V_BOOL( &value ))
3232 request->disable_feature &= ~WINHTTP_DISABLE_REDIRECTS;
3233 else
3234 request->disable_feature |= WINHTTP_DISABLE_REDIRECTS;
3235 break;
3236 }
3237 default:
3238 FIXME("unimplemented option %u\n", option);
3239 hr = E_NOTIMPL;
3240 break;
3241 }
3242 LeaveCriticalSection( &request->cs );
3243 return hr;
3244 }
3245
3246 /* critical section must be held */
3247 static DWORD wait_for_response( struct winhttp_request *request, DWORD timeout )
3248 {
3249 HANDLE thread = request->thread;
3250 DWORD err, ret;
3251
3252 LeaveCriticalSection( &request->cs );
3253 while ((err = MsgWaitForMultipleObjects( 1, &thread, FALSE, timeout, QS_ALLINPUT )) == WAIT_OBJECT_0 + 1)
3254 {
3255 MSG msg;
3256 while (PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
3257 {
3258 TranslateMessage( &msg );
3259 DispatchMessageW( &msg );
3260 }
3261 }
3262 switch (err)
3263 {
3264 case WAIT_OBJECT_0:
3265 ret = ERROR_SUCCESS;
3266 break;
3267 case WAIT_TIMEOUT:
3268 ret = ERROR_TIMEOUT;
3269 break;
3270 case WAIT_FAILED:
3271 default:
3272 ret = get_last_error();
3273 break;
3274 }
3275 EnterCriticalSection( &request->cs );
3276 return ret;
3277 }
3278
3279 static HRESULT WINAPI winhttp_request_WaitForResponse(
3280 IWinHttpRequest *iface,
3281 VARIANT timeout,
3282 VARIANT_BOOL *succeeded )
3283 {
3284 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3285 DWORD err, msecs = (V_I4(&timeout) == -1) ? INFINITE : V_I4(&timeout) * 1000;
3286
3287 TRACE("%p, %s, %p\n", request, debugstr_variant(&timeout), succeeded);
3288
3289 EnterCriticalSection( &request->cs );
3290 if (!request->thread)
3291 {
3292 LeaveCriticalSection( &request->cs );
3293 return S_OK;
3294 }
3295 if (request->state >= REQUEST_STATE_RESPONSE_RECEIVED)
3296 {
3297 LeaveCriticalSection( &request->cs );
3298 return S_OK;
3299 }
3300 switch ((err = wait_for_response( request, msecs )))
3301 {
3302 case ERROR_TIMEOUT:
3303 if (succeeded) *succeeded = VARIANT_FALSE;
3304 err = ERROR_SUCCESS;
3305 break;
3306
3307 case ERROR_SUCCESS:
3308 if (succeeded) *succeeded = VARIANT_TRUE;
3309 break;
3310
3311 default: break;
3312 }
3313 LeaveCriticalSection( &request->cs );
3314 return HRESULT_FROM_WIN32( err );
3315 }
3316
3317 static HRESULT WINAPI winhttp_request_Abort(
3318 IWinHttpRequest *iface )
3319 {
3320 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3321
3322 TRACE("%p\n", request);
3323
3324 EnterCriticalSection( &request->cs );
3325 cancel_request( request );
3326 LeaveCriticalSection( &request->cs );
3327 return S_OK;
3328 }
3329
3330 static HRESULT WINAPI winhttp_request_SetTimeouts(
3331 IWinHttpRequest *iface,
3332 LONG resolve_timeout,
3333 LONG connect_timeout,
3334 LONG send_timeout,
3335 LONG receive_timeout )
3336 {
3337 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3338
3339 TRACE("%p, %d, %d, %d, %d\n", request, resolve_timeout, connect_timeout, send_timeout, receive_timeout);
3340
3341 EnterCriticalSection( &request->cs );
3342 request->resolve_timeout = resolve_timeout;
3343 request->connect_timeout = connect_timeout;
3344 request->send_timeout = send_timeout;
3345 request->receive_timeout = receive_timeout;
3346 LeaveCriticalSection( &request->cs );
3347 return S_OK;
3348 }
3349
3350 static HRESULT WINAPI winhttp_request_SetClientCertificate(
3351 IWinHttpRequest *iface,
3352 BSTR certificate )
3353 {
3354 FIXME("\n");
3355 return E_NOTIMPL;
3356 }
3357
3358 static HRESULT WINAPI winhttp_request_SetAutoLogonPolicy(
3359 IWinHttpRequest *iface,
3360 WinHttpRequestAutoLogonPolicy policy )
3361 {
3362 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3363 HRESULT hr = S_OK;
3364
3365 TRACE("%p, %u\n", request, policy );
3366
3367 EnterCriticalSection( &request->cs );
3368 switch (policy)
3369 {
3370 case AutoLogonPolicy_Always:
3371 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW;
3372 break;
3373 case AutoLogonPolicy_OnlyIfBypassProxy:
3374 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM;
3375 break;
3376 case AutoLogonPolicy_Never:
3377 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH;
3378 break;
3379 default: hr = E_INVALIDARG;
3380 break;
3381 }
3382 LeaveCriticalSection( &request->cs );
3383 return hr;
3384 }
3385
3386 static const struct IWinHttpRequestVtbl winhttp_request_vtbl =
3387 {
3388 winhttp_request_QueryInterface,
3389 winhttp_request_AddRef,
3390 winhttp_request_Release,
3391 winhttp_request_GetTypeInfoCount,
3392 winhttp_request_GetTypeInfo,
3393 winhttp_request_GetIDsOfNames,
3394 winhttp_request_Invoke,
3395 winhttp_request_SetProxy,
3396 winhttp_request_SetCredentials,
3397 winhttp_request_Open,
3398 winhttp_request_SetRequestHeader,
3399 winhttp_request_GetResponseHeader,
3400 winhttp_request_GetAllResponseHeaders,
3401 winhttp_request_Send,
3402 winhttp_request_get_Status,
3403 winhttp_request_get_StatusText,
3404 winhttp_request_get_ResponseText,
3405 winhttp_request_get_ResponseBody,
3406 winhttp_request_get_ResponseStream,
3407 winhttp_request_get_Option,
3408 winhttp_request_put_Option,
3409 winhttp_request_WaitForResponse,
3410 winhttp_request_Abort,
3411 winhttp_request_SetTimeouts,
3412 winhttp_request_SetClientCertificate,
3413 winhttp_request_SetAutoLogonPolicy
3414 };
3415
3416 HRESULT WinHttpRequest_create( IUnknown *unknown, void **obj )
3417 {
3418 struct winhttp_request *request;
3419
3420 TRACE("%p, %p\n", unknown, obj);
3421
3422 if (!(request = heap_alloc( sizeof(*request) ))) return E_OUTOFMEMORY;
3423 request->IWinHttpRequest_iface.lpVtbl = &winhttp_request_vtbl;
3424 request->refs = 1;
3425 request->state = REQUEST_STATE_UNINITIALIZED;
3426 request->proxy.lpszProxy = NULL;
3427 request->proxy.lpszProxyBypass = NULL;
3428 InitializeCriticalSection( &request->cs );
3429 request->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": winhttp_request.cs");
3430
3431 *obj = &request->IWinHttpRequest_iface;
3432 TRACE("returning iface %p\n", *obj);
3433 return S_OK;
3434 }
A free Windows-compatible Operating System