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