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