?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winhttp: Move close callback call to task_socket_close().
[wine.git] / dlls / winhttp / request.c
blobb31ba2480bbe5def468bc89ca3b44c80dc2ef630
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 #include <assert.h>
23 #include <stdarg.h>
24 #include <wchar.h>
25
26 #define COBJMACROS
27 #include "windef.h"
28 #include "winbase.h"
29 #include "ws2tcpip.h"
30 #include "ole2.h"
31 #include "initguid.h"
32 #include "httprequest.h"
33 #include "httprequestid.h"
34 #include "schannel.h"
35 #include "winhttp.h"
36 #include "ntsecapi.h"
37 #include "winternl.h"
38
39 #include "wine/debug.h"
40 #include "winhttp_private.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
43
44 #define DEFAULT_KEEP_ALIVE_TIMEOUT 30000
45
46 static const WCHAR *attribute_table[] =
47 {
48 L"Mime-Version", /* WINHTTP_QUERY_MIME_VERSION = 0 */
49 L"Content-Type" , /* WINHTTP_QUERY_CONTENT_TYPE = 1 */
50 L"Content-Transfer-Encoding", /* WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
51 L"Content-ID", /* WINHTTP_QUERY_CONTENT_ID = 3 */
52 NULL, /* WINHTTP_QUERY_CONTENT_DESCRIPTION = 4 */
53 L"Content-Length", /* WINHTTP_QUERY_CONTENT_LENGTH = 5 */
54 L"Content-Language", /* WINHTTP_QUERY_CONTENT_LANGUAGE = 6 */
55 L"Allow", /* WINHTTP_QUERY_ALLOW = 7 */
56 L"Public", /* WINHTTP_QUERY_PUBLIC = 8 */
57 L"Date", /* WINHTTP_QUERY_DATE = 9 */
58 L"Expires", /* WINHTTP_QUERY_EXPIRES = 10 */
59 L"Last-Modified", /* WINHTTP_QUERY_LAST_MODIFIEDcw = 11 */
60 NULL, /* WINHTTP_QUERY_MESSAGE_ID = 12 */
61 L"URI", /* WINHTTP_QUERY_URI = 13 */
62 L"From", /* WINHTTP_QUERY_DERIVED_FROM = 14 */
63 NULL, /* WINHTTP_QUERY_COST = 15 */
64 NULL, /* WINHTTP_QUERY_LINK = 16 */
65 L"Pragma", /* WINHTTP_QUERY_PRAGMA = 17 */
66 NULL, /* WINHTTP_QUERY_VERSION = 18 */
67 L"Status", /* WINHTTP_QUERY_STATUS_CODE = 19 */
68 NULL, /* WINHTTP_QUERY_STATUS_TEXT = 20 */
69 NULL, /* WINHTTP_QUERY_RAW_HEADERS = 21 */
70 NULL, /* WINHTTP_QUERY_RAW_HEADERS_CRLF = 22 */
71 L"Connection", /* WINHTTP_QUERY_CONNECTION = 23 */
72 L"Accept", /* WINHTTP_QUERY_ACCEPT = 24 */
73 L"Accept-Charset", /* WINHTTP_QUERY_ACCEPT_CHARSET = 25 */
74 L"Accept-Encoding", /* WINHTTP_QUERY_ACCEPT_ENCODING = 26 */
75 L"Accept-Language", /* WINHTTP_QUERY_ACCEPT_LANGUAGE = 27 */
76 L"Authorization", /* WINHTTP_QUERY_AUTHORIZATION = 28 */
77 L"Content-Encoding", /* WINHTTP_QUERY_CONTENT_ENCODING = 29 */
78 NULL, /* WINHTTP_QUERY_FORWARDED = 30 */
79 NULL, /* WINHTTP_QUERY_FROM = 31 */
80 L"If-Modified-Since", /* WINHTTP_QUERY_IF_MODIFIED_SINCE = 32 */
81 L"Location", /* WINHTTP_QUERY_LOCATION = 33 */
82 NULL, /* WINHTTP_QUERY_ORIG_URI = 34 */
83 L"Referer", /* WINHTTP_QUERY_REFERER = 35 */
84 L"Retry-After", /* WINHTTP_QUERY_RETRY_AFTER = 36 */
85 L"Server", /* WINHTTP_QUERY_SERVER = 37 */
86 NULL, /* WINHTTP_TITLE = 38 */
87 L"User-Agent", /* WINHTTP_QUERY_USER_AGENT = 39 */
88 L"WWW-Authenticate", /* WINHTTP_QUERY_WWW_AUTHENTICATE = 40 */
89 L"Proxy-Authenticate", /* WINHTTP_QUERY_PROXY_AUTHENTICATE = 41 */
90 L"Accept-Ranges", /* WINHTTP_QUERY_ACCEPT_RANGES = 42 */
91 L"Set-Cookie", /* WINHTTP_QUERY_SET_COOKIE = 43 */
92 L"Cookie", /* WINHTTP_QUERY_COOKIE = 44 */
93 NULL, /* WINHTTP_QUERY_REQUEST_METHOD = 45 */
94 NULL, /* WINHTTP_QUERY_REFRESH = 46 */
95 NULL, /* WINHTTP_QUERY_CONTENT_DISPOSITION = 47 */
96 L"Age", /* WINHTTP_QUERY_AGE = 48 */
97 L"Cache-Control", /* WINHTTP_QUERY_CACHE_CONTROL = 49 */
98 L"Content-Base", /* WINHTTP_QUERY_CONTENT_BASE = 50 */
99 L"Content-Location", /* WINHTTP_QUERY_CONTENT_LOCATION = 51 */
100 L"Content-MD5", /* WINHTTP_QUERY_CONTENT_MD5 = 52 */
101 L"Content-Range", /* WINHTTP_QUERY_CONTENT_RANGE = 53 */
102 L"ETag", /* WINHTTP_QUERY_ETAG = 54 */
103 L"Host", /* WINHTTP_QUERY_HOST = 55 */
104 L"If-Match", /* WINHTTP_QUERY_IF_MATCH = 56 */
105 L"If-None-Match", /* WINHTTP_QUERY_IF_NONE_MATCH = 57 */
106 L"If-Range", /* WINHTTP_QUERY_IF_RANGE = 58 */
107 L"If-Unmodified-Since", /* WINHTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
108 L"Max-Forwards", /* WINHTTP_QUERY_MAX_FORWARDS = 60 */
109 L"Proxy-Authorization", /* WINHTTP_QUERY_PROXY_AUTHORIZATION = 61 */
110 L"Range", /* WINHTTP_QUERY_RANGE = 62 */
111 L"Transfer-Encoding", /* WINHTTP_QUERY_TRANSFER_ENCODING = 63 */
112 L"Upgrade", /* WINHTTP_QUERY_UPGRADE = 64 */
113 L"Vary", /* WINHTTP_QUERY_VARY = 65 */
114 L"Via", /* WINHTTP_QUERY_VIA = 66 */
115 L"Warning", /* WINHTTP_QUERY_WARNING = 67 */
116 L"Expect", /* WINHTTP_QUERY_EXPECT = 68 */
117 L"Proxy-Connection", /* WINHTTP_QUERY_PROXY_CONNECTION = 69 */
118 L"Unless-Modified-Since", /* WINHTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
119 NULL, /* WINHTTP_QUERY_PROXY_SUPPORT = 75 */
120 NULL, /* WINHTTP_QUERY_AUTHENTICATION_INFO = 76 */
121 NULL, /* WINHTTP_QUERY_PASSPORT_URLS = 77 */
122 NULL /* WINHTTP_QUERY_PASSPORT_CONFIG = 78 */
123 };
124
125 static DWORD start_queue( struct queue *queue )
126 {
127 if (queue->pool) return ERROR_SUCCESS;
128
129 if (!(queue->pool = CreateThreadpool( NULL ))) return GetLastError();
130 SetThreadpoolThreadMinimum( queue->pool, 1 );
131 SetThreadpoolThreadMaximum( queue->pool, 1 );
132
133 memset( &queue->env, 0, sizeof(queue->env) );
134 queue->env.Version = 1;
135 queue->env.Pool = queue->pool;
136
137 TRACE("started %p\n", queue);
138 return ERROR_SUCCESS;
139 }
140
141 void stop_queue( struct queue *queue )
142 {
143 if (!queue->pool) return;
144 CloseThreadpool( queue->pool );
145 queue->pool = NULL;
146 TRACE("stopped %p\n", queue);
147 }
148
149 static DWORD queue_task( struct queue *queue, PTP_WORK_CALLBACK task, void *ctx )
150 {
151 TP_WORK *work;
152 DWORD ret;
153
154 if ((ret = start_queue( queue ))) return ret;
155
156 if (!(work = CreateThreadpoolWork( task, ctx, &queue->env ))) return GetLastError();
157 TRACE("queueing %p in %p\n", work, queue);
158 SubmitThreadpoolWork( work );
159 CloseThreadpoolWork( work );
160
161 return ERROR_SUCCESS;
162 }
163
164 static void free_header( struct header *header )
165 {
166 free( header->field );
167 free( header->value );
168 free( header );
169 }
170
171 static BOOL valid_token_char( WCHAR c )
172 {
173 if (c < 32 || c == 127) return FALSE;
174 switch (c)
175 {
176 case '(': case ')':
177 case '<': case '>':
178 case '@': case ',':
179 case ';': case ':':
180 case '\\': case '\"':
181 case '/': case '[':
182 case ']': case '?':
183 case '=': case '{':
184 case '}': case ' ':
185 case '\t':
186 return FALSE;
187 default:
188 return TRUE;
189 }
190 }
191
192 static struct header *parse_header( const WCHAR *string )
193 {
194 const WCHAR *p, *q;
195 struct header *header;
196 int len;
197
198 p = string;
199 if (!(q = wcschr( p, ':' )))
200 {
201 WARN("no ':' in line %s\n", debugstr_w(string));
202 return NULL;
203 }
204 if (q == string)
205 {
206 WARN("empty field name in line %s\n", debugstr_w(string));
207 return NULL;
208 }
209 while (*p != ':')
210 {
211 if (!valid_token_char( *p ))
212 {
213 WARN("invalid character in field name %s\n", debugstr_w(string));
214 return NULL;
215 }
216 p++;
217 }
218 len = q - string;
219 if (!(header = calloc( 1, sizeof(*header) ))) return NULL;
220 if (!(header->field = malloc( (len + 1) * sizeof(WCHAR) )))
221 {
222 free( header );
223 return NULL;
224 }
225 memcpy( header->field, string, len * sizeof(WCHAR) );
226 header->field[len] = 0;
227
228 q++; /* skip past colon */
229 while (*q == ' ') q++;
230 len = lstrlenW( q );
231
232 if (!(header->value = malloc( (len + 1) * sizeof(WCHAR) )))
233 {
234 free_header( header );
235 return NULL;
236 }
237 memcpy( header->value, q, len * sizeof(WCHAR) );
238 header->value[len] = 0;
239
240 return header;
241 }
242
243 static int get_header_index( struct request *request, const WCHAR *field, int requested_index, BOOL request_only )
244 {
245 int index;
246
247 TRACE("%s\n", debugstr_w(field));
248
249 for (index = 0; index < request->num_headers; index++)
250 {
251 if (wcsicmp( request->headers[index].field, field )) continue;
252 if (request_only && !request->headers[index].is_request) continue;
253 if (!request_only && request->headers[index].is_request) continue;
254
255 if (!requested_index) break;
256 requested_index--;
257 }
258 if (index >= request->num_headers) index = -1;
259 TRACE("returning %d\n", index);
260 return index;
261 }
262
263 static DWORD insert_header( struct request *request, struct header *header )
264 {
265 DWORD count = request->num_headers + 1;
266 struct header *hdrs;
267
268 if (request->headers)
269 {
270 if ((hdrs = realloc( request->headers, sizeof(*header) * count )))
271 memset( &hdrs[count - 1], 0, sizeof(*header) );
272 }
273 else hdrs = calloc( 1, sizeof(*header) );
274 if (!hdrs) return ERROR_OUTOFMEMORY;
275
276 request->headers = hdrs;
277 request->headers[count - 1].field = strdupW( header->field );
278 request->headers[count - 1].value = strdupW( header->value );
279 request->headers[count - 1].is_request = header->is_request;
280 request->num_headers = count;
281 return ERROR_SUCCESS;
282 }
283
284 static void delete_header( struct request *request, DWORD index )
285 {
286 if (!request->num_headers || index >= request->num_headers) return;
287 request->num_headers--;
288
289 free( request->headers[index].field );
290 free( request->headers[index].value );
291
292 memmove( &request->headers[index], &request->headers[index + 1],
293 (request->num_headers - index) * sizeof(struct header) );
294 memset( &request->headers[request->num_headers], 0, sizeof(struct header) );
295 }
296
297 DWORD process_header( struct request *request, const WCHAR *field, const WCHAR *value, DWORD flags, BOOL request_only )
298 {
299 int index;
300 struct header hdr;
301
302 TRACE("%s: %s 0x%08x\n", debugstr_w(field), debugstr_w(value), flags);
303
304 if ((index = get_header_index( request, field, 0, request_only )) >= 0)
305 {
306 if (flags & WINHTTP_ADDREQ_FLAG_ADD_IF_NEW) return ERROR_WINHTTP_HEADER_ALREADY_EXISTS;
307 }
308
309 if (flags & WINHTTP_ADDREQ_FLAG_REPLACE)
310 {
311 if (index >= 0)
312 {
313 delete_header( request, index );
314 if (!value || !value[0]) return ERROR_SUCCESS;
315 }
316 else if (!(flags & WINHTTP_ADDREQ_FLAG_ADD)) return ERROR_WINHTTP_HEADER_NOT_FOUND;
317
318 hdr.field = (LPWSTR)field;
319 hdr.value = (LPWSTR)value;
320 hdr.is_request = request_only;
321 return insert_header( request, &hdr );
322 }
323 else if (value)
324 {
325
326 if ((flags & (WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON)) &&
327 index >= 0)
328 {
329 WCHAR *tmp;
330 int len, len_orig, len_value;
331 struct header *header = &request->headers[index];
332
333 len_orig = lstrlenW( header->value );
334 len_value = lstrlenW( value );
335
336 len = len_orig + len_value + 2;
337 if (!(tmp = realloc( header->value, (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
338 header->value = tmp;
339 header->value[len_orig++] = (flags & WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA) ? ',' : ';';
340 header->value[len_orig++] = ' ';
341
342 memcpy( &header->value[len_orig], value, len_value * sizeof(WCHAR) );
343 header->value[len] = 0;
344 return ERROR_SUCCESS;
345 }
346 else
347 {
348 hdr.field = (LPWSTR)field;
349 hdr.value = (LPWSTR)value;
350 hdr.is_request = request_only;
351 return insert_header( request, &hdr );
352 }
353 }
354
355 return ERROR_SUCCESS;
356 }
357
358 DWORD add_request_headers( struct request *request, const WCHAR *headers, DWORD len, DWORD flags )
359 {
360 DWORD ret = ERROR_WINHTTP_INVALID_HEADER;
361 WCHAR *buffer, *p, *q;
362 struct header *header;
363
364 if (len == ~0u) len = lstrlenW( headers );
365 if (!len) return ERROR_SUCCESS;
366 if (!(buffer = malloc( (len + 1) * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
367 memcpy( buffer, headers, len * sizeof(WCHAR) );
368 buffer[len] = 0;
369
370 p = buffer;
371 do
372 {
373 q = p;
374 while (*q)
375 {
376 if (q[0] == '\n' && q[1] == '\r')
377 {
378 q[0] = '\r';
379 q[1] = '\n';
380 }
381 if (q[0] == '\r') break;
382 q++;
383 }
384 if (!*p) break;
385 if (*q == '\r')
386 {
387 *q = 0;
388 if (q[1] == '\n')
389 q += 2; /* jump over \r\n */
390 else
391 q++; /* jump over \r */
392 }
393 if ((header = parse_header( p )))
394 {
395 ret = process_header( request, header->field, header->value, flags, TRUE );
396 free_header( header );
397 }
398 p = q;
399 } while (!ret);
400
401 free( buffer );
402 return ret;
403 }
404
405 /***********************************************************************
406 * WinHttpAddRequestHeaders (winhttp.@)
407 */
408 BOOL WINAPI WinHttpAddRequestHeaders( HINTERNET hrequest, LPCWSTR headers, DWORD len, DWORD flags )
409 {
410 DWORD ret;
411 struct request *request;
412
413 TRACE("%p, %s, %u, 0x%08x\n", hrequest, debugstr_wn(headers, len), len, flags);
414
415 if (!headers || !len)
416 {
417 SetLastError( ERROR_INVALID_PARAMETER );
418 return FALSE;
419 }
420 if (!(request = (struct request *)grab_object( hrequest )))
421 {
422 SetLastError( ERROR_INVALID_HANDLE );
423 return FALSE;
424 }
425 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
426 {
427 release_object( &request->hdr );
428 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
429 return FALSE;
430 }
431
432 ret = add_request_headers( request, headers, len, flags );
433
434 release_object( &request->hdr );
435 SetLastError( ret );
436 return !ret;
437 }
438
439 static WCHAR *build_absolute_request_path( struct request *request, const WCHAR **path )
440 {
441 const WCHAR *scheme;
442 WCHAR *ret;
443 int len, offset;
444
445 scheme = (request->netconn ? request->netconn->secure : (request->hdr.flags & WINHTTP_FLAG_SECURE)) ? L"https" : L"http";
446
447 len = lstrlenW( scheme ) + lstrlenW( request->connect->hostname ) + 4; /* '://' + nul */
448 if (request->connect->hostport) len += 6; /* ':' between host and port, up to 5 for port */
449
450 len += lstrlenW( request->path );
451 if ((ret = malloc( len * sizeof(WCHAR) )))
452 {
453 offset = swprintf( ret, len, L"%s://%s", scheme, request->connect->hostname );
454 if (request->connect->hostport)
455 {
456 offset += swprintf( ret + offset, len - offset, L":%u", request->connect->hostport );
457 }
458 lstrcpyW( ret + offset, request->path );
459 if (path) *path = ret + offset;
460 }
461
462 return ret;
463 }
464
465 static WCHAR *build_request_string( struct request *request )
466 {
467 WCHAR *path, *ret;
468 unsigned int i, len;
469
470 if (!wcsicmp( request->connect->hostname, request->connect->servername )) path = request->path;
471 else if (!(path = build_absolute_request_path( request, NULL ))) return NULL;
472
473 len = lstrlenW( request->verb ) + 1 /* ' ' */;
474 len += lstrlenW( path ) + 1 /* ' ' */;
475 len += lstrlenW( request->version );
476
477 for (i = 0; i < request->num_headers; i++)
478 {
479 if (request->headers[i].is_request)
480 len += lstrlenW( request->headers[i].field ) + lstrlenW( request->headers[i].value ) + 4; /* '\r\n: ' */
481 }
482 len += 4; /* '\r\n\r\n' */
483
484 if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
485 {
486 lstrcpyW( ret, request->verb );
487 lstrcatW( ret, L" " );
488 lstrcatW( ret, path );
489 lstrcatW( ret, L" " );
490 lstrcatW( ret, request->version );
491
492 for (i = 0; i < request->num_headers; i++)
493 {
494 if (request->headers[i].is_request)
495 {
496 lstrcatW( ret, L"\r\n" );
497 lstrcatW( ret, request->headers[i].field );
498 lstrcatW( ret, L": " );
499 lstrcatW( ret, request->headers[i].value );
500 }
501 }
502 lstrcatW( ret, L"\r\n\r\n" );
503 }
504
505 if (path != request->path) free( path );
506 return ret;
507 }
508
509 #define QUERY_MODIFIER_MASK (WINHTTP_QUERY_FLAG_REQUEST_HEADERS | WINHTTP_QUERY_FLAG_SYSTEMTIME | WINHTTP_QUERY_FLAG_NUMBER)
510
511 static DWORD query_headers( struct request *request, DWORD level, const WCHAR *name, void *buffer, DWORD *buflen,
512 DWORD *index )
513 {
514 struct header *header = NULL;
515 BOOL request_only;
516 int requested_index, header_index = -1;
517 DWORD attr, len, ret = ERROR_WINHTTP_HEADER_NOT_FOUND;
518
519 request_only = level & WINHTTP_QUERY_FLAG_REQUEST_HEADERS;
520 requested_index = index ? *index : 0;
521
522 attr = level & ~QUERY_MODIFIER_MASK;
523 switch (attr)
524 {
525 case WINHTTP_QUERY_CUSTOM:
526 {
527 header_index = get_header_index( request, name, requested_index, request_only );
528 break;
529 }
530 case WINHTTP_QUERY_RAW_HEADERS:
531 {
532 WCHAR *headers, *p, *q;
533
534 if (request_only)
535 headers = build_request_string( request );
536 else
537 headers = request->raw_headers;
538
539 if (!(p = headers)) return ERROR_OUTOFMEMORY;
540 for (len = 0; *p; p++) if (*p != '\r') len++;
541
542 if (!buffer || len * sizeof(WCHAR) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
543 else
544 {
545 for (p = headers, q = buffer; *p; p++, q++)
546 {
547 if (*p != '\r') *q = *p;
548 else
549 {
550 *q = 0;
551 p++; /* skip '\n' */
552 }
553 }
554 TRACE("returning data: %s\n", debugstr_wn(buffer, len));
555 if (len) len--;
556 ret = ERROR_SUCCESS;
557 }
558 *buflen = len * sizeof(WCHAR);
559 if (request_only) free( headers );
560 return ret;
561 }
562 case WINHTTP_QUERY_RAW_HEADERS_CRLF:
563 {
564 WCHAR *headers;
565
566 if (request_only)
567 headers = build_request_string( request );
568 else
569 headers = request->raw_headers;
570
571 if (!headers) return ERROR_OUTOFMEMORY;
572 len = lstrlenW( headers ) * sizeof(WCHAR);
573 if (!buffer || len + sizeof(WCHAR) > *buflen)
574 {
575 len += sizeof(WCHAR);
576 ret = ERROR_INSUFFICIENT_BUFFER;
577 }
578 else
579 {
580 memcpy( buffer, headers, len + sizeof(WCHAR) );
581 TRACE("returning data: %s\n", debugstr_wn(buffer, len / sizeof(WCHAR)));
582 ret = ERROR_SUCCESS;
583 }
584 *buflen = len;
585 if (request_only) free( headers );
586 return ret;
587 }
588 case WINHTTP_QUERY_VERSION:
589 len = lstrlenW( request->version ) * sizeof(WCHAR);
590 if (!buffer || len + sizeof(WCHAR) > *buflen)
591 {
592 len += sizeof(WCHAR);
593 ret = ERROR_INSUFFICIENT_BUFFER;
594 }
595 else
596 {
597 lstrcpyW( buffer, request->version );
598 TRACE("returning string: %s\n", debugstr_w(buffer));
599 ret = ERROR_SUCCESS;
600 }
601 *buflen = len;
602 return ret;
603
604 case WINHTTP_QUERY_STATUS_TEXT:
605 len = lstrlenW( request->status_text ) * sizeof(WCHAR);
606 if (!buffer || len + sizeof(WCHAR) > *buflen)
607 {
608 len += sizeof(WCHAR);
609 ret = ERROR_INSUFFICIENT_BUFFER;
610 }
611 else
612 {
613 lstrcpyW( buffer, request->status_text );
614 TRACE("returning string: %s\n", debugstr_w(buffer));
615 ret = ERROR_SUCCESS;
616 }
617 *buflen = len;
618 return ret;
619
620 case WINHTTP_QUERY_REQUEST_METHOD:
621 len = lstrlenW( request->verb ) * sizeof(WCHAR);
622 if (!buffer || len + sizeof(WCHAR) > *buflen)
623 {
624 len += sizeof(WCHAR);
625 ret = ERROR_INSUFFICIENT_BUFFER;
626 }
627 else
628 {
629 lstrcpyW( buffer, request->verb );
630 TRACE("returning string: %s\n", debugstr_w(buffer));
631 ret = ERROR_SUCCESS;
632 }
633 *buflen = len;
634 return ret;
635
636 default:
637 if (attr >= ARRAY_SIZE(attribute_table)) return ERROR_INVALID_PARAMETER;
638 if (!attribute_table[attr])
639 {
640 FIXME("attribute %u not implemented\n", attr);
641 return ERROR_WINHTTP_HEADER_NOT_FOUND;
642 }
643 TRACE("attribute %s\n", debugstr_w(attribute_table[attr]));
644 header_index = get_header_index( request, attribute_table[attr], requested_index, request_only );
645 break;
646 }
647
648 if (header_index >= 0)
649 {
650 header = &request->headers[header_index];
651 }
652 if (!header || (request_only && !header->is_request)) return ERROR_WINHTTP_HEADER_NOT_FOUND;
653 if (level & WINHTTP_QUERY_FLAG_NUMBER)
654 {
655 if (!buffer || sizeof(int) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
656 else
657 {
658 int *number = buffer;
659 *number = wcstol( header->value, NULL, 10 );
660 TRACE("returning number: %d\n", *number);
661 ret = ERROR_SUCCESS;
662 }
663 *buflen = sizeof(int);
664 }
665 else if (level & WINHTTP_QUERY_FLAG_SYSTEMTIME)
666 {
667 SYSTEMTIME *st = buffer;
668 if (!buffer || sizeof(SYSTEMTIME) > *buflen) ret = ERROR_INSUFFICIENT_BUFFER;
669 else if (WinHttpTimeToSystemTime( header->value, st ))
670 {
671 TRACE("returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
672 st->wYear, st->wMonth, st->wDay, st->wDayOfWeek,
673 st->wHour, st->wMinute, st->wSecond, st->wMilliseconds);
674 ret = ERROR_SUCCESS;
675 }
676 *buflen = sizeof(SYSTEMTIME);
677 }
678 else if (header->value)
679 {
680 len = lstrlenW( header->value ) * sizeof(WCHAR);
681 if (!buffer || len + sizeof(WCHAR) > *buflen)
682 {
683 len += sizeof(WCHAR);
684 ret = ERROR_INSUFFICIENT_BUFFER;
685 }
686 else
687 {
688 lstrcpyW( buffer, header->value );
689 TRACE("returning string: %s\n", debugstr_w(buffer));
690 ret = ERROR_SUCCESS;
691 }
692 *buflen = len;
693 }
694 if (!ret && index) *index += 1;
695 return ret;
696 }
697
698 /***********************************************************************
699 * WinHttpQueryHeaders (winhttp.@)
700 */
701 BOOL WINAPI WinHttpQueryHeaders( HINTERNET hrequest, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index )
702 {
703 DWORD ret;
704 struct request *request;
705
706 TRACE("%p, 0x%08x, %s, %p, %p, %p\n", hrequest, level, debugstr_w(name), buffer, buflen, index);
707
708 if (!(request = (struct request *)grab_object( hrequest )))
709 {
710 SetLastError( ERROR_INVALID_HANDLE );
711 return FALSE;
712 }
713 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
714 {
715 release_object( &request->hdr );
716 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
717 return FALSE;
718 }
719
720 ret = query_headers( request, level, name, buffer, buflen, index );
721
722 release_object( &request->hdr );
723 SetLastError( ret );
724 return !ret;
725 }
726
727 static const struct
728 {
729 const WCHAR *str;
730 unsigned int len;
731 DWORD scheme;
732 }
733 auth_schemes[] =
734 {
735 { L"Basic", ARRAY_SIZE(L"Basic") - 1, WINHTTP_AUTH_SCHEME_BASIC },
736 { L"NTLM", ARRAY_SIZE(L"NTLM") - 1, WINHTTP_AUTH_SCHEME_NTLM },
737 { L"Passport", ARRAY_SIZE(L"Passport") - 1, WINHTTP_AUTH_SCHEME_PASSPORT },
738 { L"Digest", ARRAY_SIZE(L"Digest") - 1, WINHTTP_AUTH_SCHEME_DIGEST },
739 { L"Negotiate", ARRAY_SIZE(L"Negotiate") - 1, WINHTTP_AUTH_SCHEME_NEGOTIATE }
740 };
741
742 static enum auth_scheme scheme_from_flag( DWORD flag )
743 {
744 int i;
745
746 for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++) if (flag == auth_schemes[i].scheme) return i;
747 return SCHEME_INVALID;
748 }
749
750 static DWORD auth_scheme_from_header( const WCHAR *header )
751 {
752 unsigned int i;
753
754 for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++)
755 {
756 if (!wcsnicmp( header, auth_schemes[i].str, auth_schemes[i].len ) &&
757 (header[auth_schemes[i].len] == ' ' || !header[auth_schemes[i].len])) return auth_schemes[i].scheme;
758 }
759 return 0;
760 }
761
762 static DWORD query_auth_schemes( struct request *request, DWORD level, DWORD *supported, DWORD *first )
763 {
764 DWORD ret, index = 0, supported_schemes = 0, first_scheme = 0;
765
766 for (;;)
767 {
768 WCHAR *buffer;
769 DWORD size, scheme;
770
771 size = 0;
772 ret = query_headers( request, level, NULL, NULL, &size, &index );
773 if (ret != ERROR_INSUFFICIENT_BUFFER)
774 {
775 if (index) ret = ERROR_SUCCESS;
776 break;
777 }
778
779 if (!(buffer = malloc( size ))) return ERROR_OUTOFMEMORY;
780 if ((ret = query_headers( request, level, NULL, buffer, &size, &index )))
781 {
782 free( buffer );
783 return ret;
784 }
785 scheme = auth_scheme_from_header( buffer );
786 free( buffer );
787 if (!scheme) continue;
788
789 if (!first_scheme) first_scheme = scheme;
790 supported_schemes |= scheme;
791 }
792
793 if (!ret)
794 {
795 *supported = supported_schemes;
796 *first = first_scheme;
797 }
798 return ret;
799 }
800
801 /***********************************************************************
802 * WinHttpQueryAuthSchemes (winhttp.@)
803 */
804 BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target )
805 {
806 DWORD ret;
807 struct request *request;
808
809 TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target);
810
811 if (!(request = (struct request *)grab_object( hrequest )))
812 {
813 SetLastError( ERROR_INVALID_HANDLE );
814 return FALSE;
815 }
816 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
817 {
818 release_object( &request->hdr );
819 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
820 return FALSE;
821 }
822 if (!supported || !first || !target)
823 {
824 release_object( &request->hdr );
825 SetLastError( ERROR_INVALID_PARAMETER );
826 return FALSE;
827
828 }
829
830 if (!(ret = query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first )))
831 {
832 *target = WINHTTP_AUTH_TARGET_SERVER;
833 }
834 else if (!(ret = query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first )))
835 {
836 *target = WINHTTP_AUTH_TARGET_PROXY;
837 }
838 else ret = ERROR_INVALID_OPERATION;
839
840 release_object( &request->hdr );
841 SetLastError( ret );
842 return !ret;
843 }
844
845 static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 )
846 {
847 UINT n = 0, x;
848 static const char base64enc[] =
849 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
850
851 while (len > 0)
852 {
853 /* first 6 bits, all from bin[0] */
854 base64[n++] = base64enc[(bin[0] & 0xfc) >> 2];
855 x = (bin[0] & 3) << 4;
856
857 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
858 if (len == 1)
859 {
860 base64[n++] = base64enc[x];
861 base64[n++] = '=';
862 base64[n++] = '=';
863 break;
864 }
865 base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)];
866 x = (bin[1] & 0x0f) << 2;
867
868 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
869 if (len == 2)
870 {
871 base64[n++] = base64enc[x];
872 base64[n++] = '=';
873 break;
874 }
875 base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)];
876
877 /* last 6 bits, all from bin [2] */
878 base64[n++] = base64enc[bin[2] & 0x3f];
879 bin += 3;
880 len -= 3;
881 }
882 base64[n] = 0;
883 return n;
884 }
885
886 static inline char decode_char( WCHAR c )
887 {
888 if (c >= 'A' && c <= 'Z') return c - 'A';
889 if (c >= 'a' && c <= 'z') return c - 'a' + 26;
890 if (c >= '0' && c <= '9') return c - '0' + 52;
891 if (c == '+') return 62;
892 if (c == '/') return 63;
893 return 64;
894 }
895
896 static unsigned int decode_base64( const WCHAR *base64, unsigned int len, char *buf )
897 {
898 unsigned int i = 0;
899 char c0, c1, c2, c3;
900 const WCHAR *p = base64;
901
902 while (len > 4)
903 {
904 if ((c0 = decode_char( p[0] )) > 63) return 0;
905 if ((c1 = decode_char( p[1] )) > 63) return 0;
906 if ((c2 = decode_char( p[2] )) > 63) return 0;
907 if ((c3 = decode_char( p[3] )) > 63) return 0;
908
909 if (buf)
910 {
911 buf[i + 0] = (c0 << 2) | (c1 >> 4);
912 buf[i + 1] = (c1 << 4) | (c2 >> 2);
913 buf[i + 2] = (c2 << 6) | c3;
914 }
915 len -= 4;
916 i += 3;
917 p += 4;
918 }
919 if (p[2] == '=')
920 {
921 if ((c0 = decode_char( p[0] )) > 63) return 0;
922 if ((c1 = decode_char( p[1] )) > 63) return 0;
923
924 if (buf) buf[i] = (c0 << 2) | (c1 >> 4);
925 i++;
926 }
927 else if (p[3] == '=')
928 {
929 if ((c0 = decode_char( p[0] )) > 63) return 0;
930 if ((c1 = decode_char( p[1] )) > 63) return 0;
931 if ((c2 = decode_char( p[2] )) > 63) return 0;
932
933 if (buf)
934 {
935 buf[i + 0] = (c0 << 2) | (c1 >> 4);
936 buf[i + 1] = (c1 << 4) | (c2 >> 2);
937 }
938 i += 2;
939 }
940 else
941 {
942 if ((c0 = decode_char( p[0] )) > 63) return 0;
943 if ((c1 = decode_char( p[1] )) > 63) return 0;
944 if ((c2 = decode_char( p[2] )) > 63) return 0;
945 if ((c3 = decode_char( p[3] )) > 63) return 0;
946
947 if (buf)
948 {
949 buf[i + 0] = (c0 << 2) | (c1 >> 4);
950 buf[i + 1] = (c1 << 4) | (c2 >> 2);
951 buf[i + 2] = (c2 << 6) | c3;
952 }
953 i += 3;
954 }
955 return i;
956 }
957
958 static struct authinfo *alloc_authinfo(void)
959 {
960 struct authinfo *ret;
961
962 if (!(ret = malloc( sizeof(*ret) ))) return NULL;
963
964 SecInvalidateHandle( &ret->cred );
965 SecInvalidateHandle( &ret->ctx );
966 memset( &ret->exp, 0, sizeof(ret->exp) );
967 ret->scheme = 0;
968 ret->attr = 0;
969 ret->max_token = 0;
970 ret->data = NULL;
971 ret->data_len = 0;
972 ret->finished = FALSE;
973 return ret;
974 }
975
976 void destroy_authinfo( struct authinfo *authinfo )
977 {
978 if (!authinfo) return;
979
980 if (SecIsValidHandle( &authinfo->ctx ))
981 DeleteSecurityContext( &authinfo->ctx );
982 if (SecIsValidHandle( &authinfo->cred ))
983 FreeCredentialsHandle( &authinfo->cred );
984
985 free( authinfo->data );
986 free( authinfo );
987 }
988
989 static BOOL get_authvalue( struct request *request, DWORD level, DWORD scheme, WCHAR *buffer, DWORD len )
990 {
991 DWORD size, index = 0;
992 for (;;)
993 {
994 size = len;
995 if (query_headers( request, level, NULL, buffer, &size, &index )) return FALSE;
996 if (auth_scheme_from_header( buffer ) == scheme) break;
997 }
998 return TRUE;
999 }
1000
1001 static BOOL do_authorization( struct request *request, DWORD target, DWORD scheme_flag )
1002 {
1003 struct authinfo *authinfo, **auth_ptr;
1004 enum auth_scheme scheme = scheme_from_flag( scheme_flag );
1005 const WCHAR *auth_target, *username, *password;
1006 WCHAR auth_value[2048], *auth_reply;
1007 DWORD len = sizeof(auth_value), len_scheme, flags;
1008 BOOL ret, has_auth_value;
1009
1010 if (scheme == SCHEME_INVALID) return FALSE;
1011
1012 switch (target)
1013 {
1014 case WINHTTP_AUTH_TARGET_SERVER:
1015 has_auth_value = get_authvalue( request, WINHTTP_QUERY_WWW_AUTHENTICATE, scheme_flag, auth_value, len );
1016 auth_ptr = &request->authinfo;
1017 auth_target = L"Authorization";
1018 if (request->creds[TARGET_SERVER][scheme].username)
1019 {
1020 if (scheme != SCHEME_BASIC && !has_auth_value) return FALSE;
1021 username = request->creds[TARGET_SERVER][scheme].username;
1022 password = request->creds[TARGET_SERVER][scheme].password;
1023 }
1024 else
1025 {
1026 if (!has_auth_value) return FALSE;
1027 username = request->connect->username;
1028 password = request->connect->password;
1029 }
1030 break;
1031
1032 case WINHTTP_AUTH_TARGET_PROXY:
1033 if (!get_authvalue( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, scheme_flag, auth_value, len ))
1034 return FALSE;
1035 auth_ptr = &request->proxy_authinfo;
1036 auth_target = L"Proxy-Authorization";
1037 if (request->creds[TARGET_PROXY][scheme].username)
1038 {
1039 username = request->creds[TARGET_PROXY][scheme].username;
1040 password = request->creds[TARGET_PROXY][scheme].password;
1041 }
1042 else
1043 {
1044 username = request->connect->session->proxy_username;
1045 password = request->connect->session->proxy_password;
1046 }
1047 break;
1048
1049 default:
1050 WARN("unknown target %x\n", target);
1051 return FALSE;
1052 }
1053 authinfo = *auth_ptr;
1054
1055 switch (scheme)
1056 {
1057 case SCHEME_BASIC:
1058 {
1059 int userlen, passlen;
1060
1061 if (!username || !password) return FALSE;
1062 if ((!authinfo && !(authinfo = alloc_authinfo())) || authinfo->finished) return FALSE;
1063
1064 userlen = WideCharToMultiByte( CP_UTF8, 0, username, lstrlenW( username ), NULL, 0, NULL, NULL );
1065 passlen = WideCharToMultiByte( CP_UTF8, 0, password, lstrlenW( password ), NULL, 0, NULL, NULL );
1066
1067 authinfo->data_len = userlen + 1 + passlen;
1068 if (!(authinfo->data = malloc( authinfo->data_len ))) return FALSE;
1069
1070 WideCharToMultiByte( CP_UTF8, 0, username, -1, authinfo->data, userlen, NULL, NULL );
1071 authinfo->data[userlen] = ':';
1072 WideCharToMultiByte( CP_UTF8, 0, password, -1, authinfo->data + userlen + 1, passlen, NULL, NULL );
1073
1074 authinfo->scheme = SCHEME_BASIC;
1075 authinfo->finished = TRUE;
1076 break;
1077 }
1078 case SCHEME_NTLM:
1079 case SCHEME_NEGOTIATE:
1080 {
1081 SECURITY_STATUS status;
1082 SecBufferDesc out_desc, in_desc;
1083 SecBuffer out, in;
1084 ULONG flags = ISC_REQ_CONNECTION|ISC_REQ_USE_DCE_STYLE|ISC_REQ_MUTUAL_AUTH|ISC_REQ_DELEGATE;
1085 const WCHAR *p;
1086 BOOL first = FALSE;
1087
1088 if (!authinfo)
1089 {
1090 TimeStamp exp;
1091 SEC_WINNT_AUTH_IDENTITY_W id;
1092 WCHAR *domain, *user;
1093
1094 if (!username || !password || !(authinfo = alloc_authinfo())) return FALSE;
1095
1096 first = TRUE;
1097 domain = (WCHAR *)username;
1098 user = wcschr( username, '\\' );
1099
1100 if (user) user++;
1101 else
1102 {
1103 user = (WCHAR *)username;
1104 domain = NULL;
1105 }
1106 id.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1107 id.User = user;
1108 id.UserLength = lstrlenW( user );
1109 id.Domain = domain;
1110 id.DomainLength = domain ? user - domain - 1 : 0;
1111 id.Password = (WCHAR *)password;
1112 id.PasswordLength = lstrlenW( password );
1113
1114 status = AcquireCredentialsHandleW( NULL, (SEC_WCHAR *)auth_schemes[scheme].str,
1115 SECPKG_CRED_OUTBOUND, NULL, &id, NULL, NULL,
1116 &authinfo->cred, &exp );
1117 if (status == SEC_E_OK)
1118 {
1119 PSecPkgInfoW info;
1120 status = QuerySecurityPackageInfoW( (SEC_WCHAR *)auth_schemes[scheme].str, &info );
1121 if (status == SEC_E_OK)
1122 {
1123 authinfo->max_token = info->cbMaxToken;
1124 FreeContextBuffer( info );
1125 }
1126 }
1127 if (status != SEC_E_OK)
1128 {
1129 WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
1130 debugstr_w(auth_schemes[scheme].str), status);
1131 free( authinfo );
1132 return FALSE;
1133 }
1134 authinfo->scheme = scheme;
1135 }
1136 else if (authinfo->finished) return FALSE;
1137
1138 if ((lstrlenW( auth_value ) < auth_schemes[authinfo->scheme].len ||
1139 wcsnicmp( auth_value, auth_schemes[authinfo->scheme].str, auth_schemes[authinfo->scheme].len )))
1140 {
1141 ERR("authentication scheme changed from %s to %s\n",
1142 debugstr_w(auth_schemes[authinfo->scheme].str), debugstr_w(auth_value));
1143 destroy_authinfo( authinfo );
1144 *auth_ptr = NULL;
1145 return FALSE;
1146 }
1147 in.BufferType = SECBUFFER_TOKEN;
1148 in.cbBuffer = 0;
1149 in.pvBuffer = NULL;
1150
1151 in_desc.ulVersion = 0;
1152 in_desc.cBuffers = 1;
1153 in_desc.pBuffers = &in;
1154
1155 p = auth_value + auth_schemes[scheme].len;
1156 if (*p == ' ')
1157 {
1158 int len = lstrlenW( ++p );
1159 in.cbBuffer = decode_base64( p, len, NULL );
1160 if (!(in.pvBuffer = malloc( in.cbBuffer ))) {
1161 destroy_authinfo( authinfo );
1162 *auth_ptr = NULL;
1163 return FALSE;
1164 }
1165 decode_base64( p, len, in.pvBuffer );
1166 }
1167 out.BufferType = SECBUFFER_TOKEN;
1168 out.cbBuffer = authinfo->max_token;
1169 if (!(out.pvBuffer = malloc( authinfo->max_token )))
1170 {
1171 free( in.pvBuffer );
1172 destroy_authinfo( authinfo );
1173 *auth_ptr = NULL;
1174 return FALSE;
1175 }
1176 out_desc.ulVersion = 0;
1177 out_desc.cBuffers = 1;
1178 out_desc.pBuffers = &out;
1179
1180 status = InitializeSecurityContextW( first ? &authinfo->cred : NULL, first ? NULL : &authinfo->ctx,
1181 first ? request->connect->servername : NULL, flags, 0,
1182 SECURITY_NETWORK_DREP, in.pvBuffer ? &in_desc : NULL, 0,
1183 &authinfo->ctx, &out_desc, &authinfo->attr, &authinfo->exp );
1184 free( in.pvBuffer );
1185 if (status == SEC_E_OK)
1186 {
1187 free( authinfo->data );
1188 authinfo->data = out.pvBuffer;
1189 authinfo->data_len = out.cbBuffer;
1190 authinfo->finished = TRUE;
1191 TRACE("sending last auth packet\n");
1192 }
1193 else if (status == SEC_I_CONTINUE_NEEDED)
1194 {
1195 free( authinfo->data );
1196 authinfo->data = out.pvBuffer;
1197 authinfo->data_len = out.cbBuffer;
1198 TRACE("sending next auth packet\n");
1199 }
1200 else
1201 {
1202 ERR("InitializeSecurityContextW failed with error 0x%08x\n", status);
1203 free( out.pvBuffer );
1204 destroy_authinfo( authinfo );
1205 *auth_ptr = NULL;
1206 return FALSE;
1207 }
1208 break;
1209 }
1210 default:
1211 ERR("invalid scheme %u\n", scheme);
1212 return FALSE;
1213 }
1214 *auth_ptr = authinfo;
1215
1216 len_scheme = auth_schemes[authinfo->scheme].len;
1217 len = len_scheme + 1 + ((authinfo->data_len + 2) * 4) / 3;
1218 if (!(auth_reply = malloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
1219
1220 memcpy( auth_reply, auth_schemes[authinfo->scheme].str, len_scheme * sizeof(WCHAR) );
1221 auth_reply[len_scheme] = ' ';
1222 encode_base64( authinfo->data, authinfo->data_len, auth_reply + len_scheme + 1 );
1223
1224 flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
1225 ret = !process_header( request, auth_target, auth_reply, flags, TRUE );
1226 free( auth_reply );
1227 return ret;
1228 }
1229
1230 static WCHAR *build_proxy_connect_string( struct request *request )
1231 {
1232 WCHAR *ret, *host;
1233 unsigned int i;
1234 int len = lstrlenW( request->connect->hostname ) + 7;
1235
1236 if (!(host = malloc( len * sizeof(WCHAR) ))) return NULL;
1237 len = swprintf( host, len, L"%s:%u", request->connect->hostname, request->connect->hostport );
1238
1239 len += ARRAY_SIZE(L"CONNECT");
1240 len += ARRAY_SIZE(L"HTTP/1.1");
1241
1242 for (i = 0; i < request->num_headers; i++)
1243 {
1244 if (request->headers[i].is_request)
1245 len += lstrlenW( request->headers[i].field ) + lstrlenW( request->headers[i].value ) + 4; /* '\r\n: ' */
1246 }
1247 len += 4; /* '\r\n\r\n' */
1248
1249 if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
1250 {
1251 lstrcpyW( ret, L"CONNECT" );
1252 lstrcatW( ret, L" " );
1253 lstrcatW( ret, host );
1254 lstrcatW( ret, L" " );
1255 lstrcatW( ret, L"HTTP/1.1" );
1256
1257 for (i = 0; i < request->num_headers; i++)
1258 {
1259 if (request->headers[i].is_request)
1260 {
1261 lstrcatW( ret, L"\r\n" );
1262 lstrcatW( ret, request->headers[i].field );
1263 lstrcatW( ret, L": " );
1264 lstrcatW( ret, request->headers[i].value );
1265 }
1266 }
1267 lstrcatW( ret, L"\r\n\r\n" );
1268 }
1269
1270 free( host );
1271 return ret;
1272 }
1273
1274 static DWORD read_reply( struct request *request );
1275
1276 static DWORD secure_proxy_connect( struct request *request )
1277 {
1278 WCHAR *str;
1279 char *strA;
1280 int len, bytes_sent;
1281 DWORD ret;
1282
1283 if (!(str = build_proxy_connect_string( request ))) return ERROR_OUTOFMEMORY;
1284 strA = strdupWA( str );
1285 free( str );
1286 if (!strA) return ERROR_OUTOFMEMORY;
1287
1288 len = strlen( strA );
1289 ret = netconn_send( request->netconn, strA, len, &bytes_sent, NULL );
1290 free( strA );
1291 if (!ret) ret = read_reply( request );
1292
1293 return ret;
1294 }
1295
1296 static WCHAR *addr_to_str( struct sockaddr_storage *addr )
1297 {
1298 char buf[INET6_ADDRSTRLEN];
1299 void *src;
1300
1301 switch (addr->ss_family)
1302 {
1303 case AF_INET:
1304 src = &((struct sockaddr_in *)addr)->sin_addr;
1305 break;
1306 case AF_INET6:
1307 src = &((struct sockaddr_in6 *)addr)->sin6_addr;
1308 break;
1309 default:
1310 WARN("unsupported address family %d\n", addr->ss_family);
1311 return NULL;
1312 }
1313 if (!inet_ntop( addr->ss_family, src, buf, sizeof(buf) )) return NULL;
1314 return strdupAW( buf );
1315 }
1316
1317 static CRITICAL_SECTION connection_pool_cs;
1318 static CRITICAL_SECTION_DEBUG connection_pool_debug =
1319 {
1320 0, 0, &connection_pool_cs,
1321 { &connection_pool_debug.ProcessLocksList, &connection_pool_debug.ProcessLocksList },
1322 0, 0, { (DWORD_PTR)(__FILE__ ": connection_pool_cs") }
1323 };
1324 static CRITICAL_SECTION connection_pool_cs = { &connection_pool_debug, -1, 0, 0, 0, 0 };
1325
1326 static struct list connection_pool = LIST_INIT( connection_pool );
1327
1328 void release_host( struct hostdata *host )
1329 {
1330 LONG ref;
1331
1332 EnterCriticalSection( &connection_pool_cs );
1333 if (!(ref = --host->ref)) list_remove( &host->entry );
1334 LeaveCriticalSection( &connection_pool_cs );
1335 if (ref) return;
1336
1337 assert( list_empty( &host->connections ) );
1338 free( host->hostname );
1339 free( host );
1340 }
1341
1342 static BOOL connection_collector_running;
1343
1344 static void CALLBACK connection_collector( TP_CALLBACK_INSTANCE *instance, void *ctx )
1345 {
1346 unsigned int remaining_connections;
1347 struct netconn *netconn, *next_netconn;
1348 struct hostdata *host, *next_host;
1349 ULONGLONG now;
1350
1351 do
1352 {
1353 /* FIXME: Use more sophisticated method */
1354 Sleep(5000);
1355 remaining_connections = 0;
1356 now = GetTickCount64();
1357
1358 EnterCriticalSection(&connection_pool_cs);
1359
1360 LIST_FOR_EACH_ENTRY_SAFE(host, next_host, &connection_pool, struct hostdata, entry)
1361 {
1362 LIST_FOR_EACH_ENTRY_SAFE(netconn, next_netconn, &host->connections, struct netconn, entry)
1363 {
1364 if (netconn->keep_until < now)
1365 {
1366 TRACE("freeing %p\n", netconn);
1367 list_remove(&netconn->entry);
1368 netconn_close(netconn);
1369 }
1370 else remaining_connections++;
1371 }
1372 }
1373
1374 if (!remaining_connections) connection_collector_running = FALSE;
1375
1376 LeaveCriticalSection(&connection_pool_cs);
1377 } while(remaining_connections);
1378
1379 FreeLibraryWhenCallbackReturns( instance, winhttp_instance );
1380 }
1381
1382 static void cache_connection( struct netconn *netconn )
1383 {
1384 TRACE( "caching connection %p\n", netconn );
1385
1386 EnterCriticalSection( &connection_pool_cs );
1387
1388 netconn->keep_until = GetTickCount64() + DEFAULT_KEEP_ALIVE_TIMEOUT;
1389 list_add_head( &netconn->host->connections, &netconn->entry );
1390
1391 if (!connection_collector_running)
1392 {
1393 HMODULE module;
1394
1395 GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const WCHAR *)winhttp_instance, &module );
1396
1397 if (TrySubmitThreadpoolCallback( connection_collector, NULL, NULL )) connection_collector_running = TRUE;
1398 else FreeLibrary( winhttp_instance );
1399 }
1400
1401 LeaveCriticalSection( &connection_pool_cs );
1402 }
1403
1404 static DWORD map_secure_protocols( DWORD mask )
1405 {
1406 DWORD ret = 0;
1407 if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_SSL2) ret |= SP_PROT_SSL2_CLIENT;
1408 if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_SSL3) ret |= SP_PROT_SSL3_CLIENT;
1409 if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1) ret |= SP_PROT_TLS1_CLIENT;
1410 if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1) ret |= SP_PROT_TLS1_1_CLIENT;
1411 if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2) ret |= SP_PROT_TLS1_2_CLIENT;
1412 return ret;
1413 }
1414
1415 static DWORD ensure_cred_handle( struct request *request )
1416 {
1417 SECURITY_STATUS status = SEC_E_OK;
1418
1419 if (request->cred_handle_initialized) return ERROR_SUCCESS;
1420
1421 if (!request->cred_handle_initialized)
1422 {
1423 SCHANNEL_CRED cred;
1424 memset( &cred, 0, sizeof(cred) );
1425 cred.dwVersion = SCHANNEL_CRED_VERSION;
1426 cred.grbitEnabledProtocols = map_secure_protocols( request->connect->session->secure_protocols );
1427 if (request->client_cert)
1428 {
1429 cred.paCred = &request->client_cert;
1430 cred.cCreds = 1;
1431 }
1432 status = AcquireCredentialsHandleW( NULL, (WCHAR *)UNISP_NAME_W, SECPKG_CRED_OUTBOUND, NULL,
1433 &cred, NULL, NULL, &request->cred_handle, NULL );
1434 if (status == SEC_E_OK)
1435 request->cred_handle_initialized = TRUE;
1436 }
1437
1438 if (status != SEC_E_OK)
1439 {
1440 WARN( "AcquireCredentialsHandleW failed: 0x%08x\n", status );
1441 return status;
1442 }
1443 return ERROR_SUCCESS;
1444 }
1445
1446 static DWORD open_connection( struct request *request )
1447 {
1448 BOOL is_secure = request->hdr.flags & WINHTTP_FLAG_SECURE;
1449 struct hostdata *host = NULL, *iter;
1450 struct netconn *netconn = NULL;
1451 struct connect *connect;
1452 WCHAR *addressW = NULL;
1453 INTERNET_PORT port;
1454 DWORD ret, len;
1455
1456 if (request->netconn) goto done;
1457
1458 connect = request->connect;
1459 port = connect->serverport ? connect->serverport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
1460
1461 EnterCriticalSection( &connection_pool_cs );
1462
1463 LIST_FOR_EACH_ENTRY( iter, &connection_pool, struct hostdata, entry )
1464 {
1465 if (iter->port == port && !wcscmp( connect->servername, iter->hostname ) && !is_secure == !iter->secure)
1466 {
1467 host = iter;
1468 host->ref++;
1469 break;
1470 }
1471 }
1472
1473 if (!host)
1474 {
1475 if ((host = malloc( sizeof(*host) )))
1476 {
1477 host->ref = 1;
1478 host->secure = is_secure;
1479 host->port = port;
1480 list_init( &host->connections );
1481 if ((host->hostname = strdupW( connect->servername )))
1482 {
1483 list_add_head( &connection_pool, &host->entry );
1484 }
1485 else
1486 {
1487 free( host );
1488 host = NULL;
1489 }
1490 }
1491 }
1492
1493 LeaveCriticalSection( &connection_pool_cs );
1494
1495 if (!host) return ERROR_OUTOFMEMORY;
1496
1497 for (;;)
1498 {
1499 EnterCriticalSection( &connection_pool_cs );
1500 if (!list_empty( &host->connections ))
1501 {
1502 netconn = LIST_ENTRY( list_head( &host->connections ), struct netconn, entry );
1503 list_remove( &netconn->entry );
1504 }
1505 LeaveCriticalSection( &connection_pool_cs );
1506 if (!netconn) break;
1507
1508 if (netconn_is_alive( netconn )) break;
1509 TRACE("connection %p no longer alive, closing\n", netconn);
1510 netconn_close( netconn );
1511 netconn = NULL;
1512 }
1513
1514 if (!connect->resolved && netconn)
1515 {
1516 connect->sockaddr = netconn->sockaddr;
1517 connect->resolved = TRUE;
1518 }
1519
1520 if (!connect->resolved)
1521 {
1522 len = lstrlenW( host->hostname ) + 1;
1523 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, host->hostname, len );
1524
1525 if ((ret = netconn_resolve( host->hostname, port, &connect->sockaddr, request->resolve_timeout )))
1526 {
1527 release_host( host );
1528 return ret;
1529 }
1530 connect->resolved = TRUE;
1531
1532 if (!(addressW = addr_to_str( &connect->sockaddr )))
1533 {
1534 release_host( host );
1535 return ERROR_OUTOFMEMORY;
1536 }
1537 len = lstrlenW( addressW ) + 1;
1538 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, len );
1539 }
1540
1541 if (!netconn)
1542 {
1543 if (!addressW && !(addressW = addr_to_str( &connect->sockaddr )))
1544 {
1545 release_host( host );
1546 return ERROR_OUTOFMEMORY;
1547 }
1548
1549 TRACE("connecting to %s:%u\n", debugstr_w(addressW), port);
1550
1551 len = lstrlenW( addressW ) + 1;
1552 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, len );
1553
1554 if ((ret = netconn_create( host, &connect->sockaddr, request->connect_timeout, &netconn )))
1555 {
1556 free( addressW );
1557 release_host( host );
1558 return ret;
1559 }
1560 netconn_set_timeout( netconn, TRUE, request->send_timeout );
1561 netconn_set_timeout( netconn, FALSE, request->receive_response_timeout );
1562
1563 request->netconn = netconn;
1564
1565 if (is_secure)
1566 {
1567 if (connect->session->proxy_server && wcsicmp( connect->hostname, connect->servername ))
1568 {
1569 if ((ret = secure_proxy_connect( request )))
1570 {
1571 request->netconn = NULL;
1572 free( addressW );
1573 netconn_close( netconn );
1574 return ret;
1575 }
1576 }
1577
1578 CertFreeCertificateContext( request->server_cert );
1579 request->server_cert = NULL;
1580
1581 if ((ret = ensure_cred_handle( request )) ||
1582 (ret = netconn_secure_connect( netconn, connect->hostname, request->security_flags,
1583 &request->cred_handle, request->check_revocation )))
1584 {
1585 request->netconn = NULL;
1586 free( addressW );
1587 netconn_close( netconn );
1588 return ret;
1589 }
1590 }
1591
1592 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, addressW, lstrlenW(addressW) + 1 );
1593 }
1594 else
1595 {
1596 TRACE("using connection %p\n", netconn);
1597
1598 netconn_set_timeout( netconn, TRUE, request->send_timeout );
1599 netconn_set_timeout( netconn, FALSE, request->receive_response_timeout );
1600 request->netconn = netconn;
1601 }
1602
1603 if (netconn->secure && !(request->server_cert = netconn_get_certificate( netconn )))
1604 {
1605 free( addressW );
1606 netconn_close( netconn );
1607 return ERROR_WINHTTP_SECURE_FAILURE;
1608 }
1609
1610 done:
1611 request->read_pos = request->read_size = 0;
1612 request->read_chunked = FALSE;
1613 request->read_chunked_size = ~0u;
1614 request->read_chunked_eof = FALSE;
1615 free( addressW );
1616 return ERROR_SUCCESS;
1617 }
1618
1619 void close_connection( struct request *request )
1620 {
1621 if (!request->netconn) return;
1622
1623 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, 0, 0 );
1624 netconn_close( request->netconn );
1625 request->netconn = NULL;
1626 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0 );
1627 }
1628
1629 static DWORD add_host_header( struct request *request, DWORD modifier )
1630 {
1631 DWORD ret, len;
1632 WCHAR *host;
1633 struct connect *connect = request->connect;
1634 INTERNET_PORT port;
1635
1636 port = connect->hostport ? connect->hostport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
1637
1638 if (port == INTERNET_DEFAULT_HTTP_PORT || port == INTERNET_DEFAULT_HTTPS_PORT)
1639 {
1640 return process_header( request, L"Host", connect->hostname, modifier, TRUE );
1641 }
1642 len = lstrlenW( connect->hostname ) + 7; /* sizeof(":65335") */
1643 if (!(host = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
1644 swprintf( host, len, L"%s:%u", connect->hostname, port );
1645 ret = process_header( request, L"Host", host, modifier, TRUE );
1646 free( host );
1647 return ret;
1648 }
1649
1650 static void clear_response_headers( struct request *request )
1651 {
1652 unsigned int i;
1653
1654 for (i = 0; i < request->num_headers; i++)
1655 {
1656 if (!request->headers[i].field) continue;
1657 if (!request->headers[i].value) continue;
1658 if (request->headers[i].is_request) continue;
1659 delete_header( request, i );
1660 i--;
1661 }
1662 }
1663
1664 /* remove some amount of data from the read buffer */
1665 static void remove_data( struct request *request, int count )
1666 {
1667 if (!(request->read_size -= count)) request->read_pos = 0;
1668 else request->read_pos += count;
1669 }
1670
1671 /* read some more data into the read buffer */
1672 static DWORD read_more_data( struct request *request, int maxlen, BOOL notify )
1673 {
1674 int len;
1675 DWORD ret;
1676
1677 if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
1678
1679 if (request->read_size && request->read_pos)
1680 {
1681 /* move existing data to the start of the buffer */
1682 memmove( request->read_buf, request->read_buf + request->read_pos, request->read_size );
1683 request->read_pos = 0;
1684 }
1685 if (maxlen == -1) maxlen = sizeof(request->read_buf);
1686
1687 if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
1688
1689 ret = netconn_recv( request->netconn, request->read_buf + request->read_size,
1690 maxlen - request->read_size, 0, &len );
1691
1692 if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &len, sizeof(len) );
1693
1694 request->read_size += len;
1695 return ret;
1696 }
1697
1698 /* discard data contents until we reach end of line */
1699 static DWORD discard_eol( struct request *request, BOOL notify )
1700 {
1701 DWORD ret;
1702 do
1703 {
1704 char *eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
1705 if (eol)
1706 {
1707 remove_data( request, (eol + 1) - (request->read_buf + request->read_pos) );
1708 break;
1709 }
1710 request->read_pos = request->read_size = 0; /* discard everything */
1711 if ((ret = read_more_data( request, -1, notify ))) return ret;
1712 } while (request->read_size);
1713 return ERROR_SUCCESS;
1714 }
1715
1716 /* read the size of the next chunk */
1717 static DWORD start_next_chunk( struct request *request, BOOL notify )
1718 {
1719 DWORD ret, chunk_size = 0;
1720
1721 assert(!request->read_chunked_size || request->read_chunked_size == ~0u);
1722
1723 if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
1724
1725 /* read terminator for the previous chunk */
1726 if (!request->read_chunked_size && (ret = discard_eol( request, notify ))) return ret;
1727
1728 for (;;)
1729 {
1730 while (request->read_size)
1731 {
1732 char ch = request->read_buf[request->read_pos];
1733 if (ch >= '0' && ch <= '9') chunk_size = chunk_size * 16 + ch - '0';
1734 else if (ch >= 'a' && ch <= 'f') chunk_size = chunk_size * 16 + ch - 'a' + 10;
1735 else if (ch >= 'A' && ch <= 'F') chunk_size = chunk_size * 16 + ch - 'A' + 10;
1736 else if (ch == ';' || ch == '\r' || ch == '\n')
1737 {
1738 TRACE("reading %u byte chunk\n", chunk_size);
1739
1740 if (request->content_length == ~0u) request->content_length = chunk_size;
1741 else request->content_length += chunk_size;
1742
1743 request->read_chunked_size = chunk_size;
1744 if (!chunk_size) request->read_chunked_eof = TRUE;
1745
1746 return discard_eol( request, notify );
1747 }
1748 remove_data( request, 1 );
1749 }
1750 if ((ret = read_more_data( request, -1, notify ))) return ret;
1751 if (!request->read_size)
1752 {
1753 request->content_length = request->content_read = 0;
1754 request->read_chunked_size = 0;
1755 return ERROR_SUCCESS;
1756 }
1757 }
1758 }
1759
1760 static DWORD refill_buffer( struct request *request, BOOL notify )
1761 {
1762 int len = sizeof(request->read_buf);
1763 DWORD ret;
1764
1765 if (request->read_chunked)
1766 {
1767 if (request->read_chunked_eof) return ERROR_INSUFFICIENT_BUFFER;
1768 if (request->read_chunked_size == ~0u || !request->read_chunked_size)
1769 {
1770 if ((ret = start_next_chunk( request, notify ))) return ret;
1771 }
1772 len = min( len, request->read_chunked_size );
1773 }
1774 else if (request->content_length != ~0u)
1775 {
1776 len = min( len, request->content_length - request->content_read );
1777 }
1778
1779 if (len <= request->read_size) return ERROR_SUCCESS;
1780 if ((ret = read_more_data( request, len, notify ))) return ret;
1781 if (!request->read_size) request->content_length = request->content_read = 0;
1782 return ERROR_SUCCESS;
1783 }
1784
1785 static void finished_reading( struct request *request )
1786 {
1787 BOOL close = FALSE;
1788 WCHAR connection[20];
1789 DWORD size = sizeof(connection);
1790
1791 if (!request->netconn) return;
1792
1793 if (request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE) close = TRUE;
1794 else if (!query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection, &size, NULL ) ||
1795 !query_headers( request, WINHTTP_QUERY_PROXY_CONNECTION, NULL, connection, &size, NULL ))
1796 {
1797 if (!wcsicmp( connection, L"close" )) close = TRUE;
1798 }
1799 else if (!wcscmp( request->version, L"HTTP/1.0" )) close = TRUE;
1800
1801 if (close)
1802 netconn_close( request->netconn );
1803 else
1804 cache_connection( request->netconn );
1805 request->netconn = NULL;
1806 }
1807
1808 /* return the size of data available to be read immediately */
1809 static DWORD get_available_data( struct request *request )
1810 {
1811 if (request->read_chunked) return min( request->read_chunked_size, request->read_size );
1812 return request->read_size;
1813 }
1814
1815 /* check if we have reached the end of the data to read */
1816 static BOOL end_of_read_data( struct request *request )
1817 {
1818 if (!request->content_length) return TRUE;
1819 if (request->read_chunked) return request->read_chunked_eof;
1820 if (request->content_length == ~0u) return FALSE;
1821 return (request->content_length == request->content_read);
1822 }
1823
1824 static DWORD read_data( struct request *request, void *buffer, DWORD size, DWORD *read, BOOL async )
1825 {
1826 int count, bytes_read = 0;
1827 DWORD ret = ERROR_SUCCESS;
1828
1829 if (end_of_read_data( request )) goto done;
1830
1831 while (size)
1832 {
1833 if (!(count = get_available_data( request )))
1834 {
1835 if ((ret = refill_buffer( request, async ))) goto done;
1836 if (!(count = get_available_data( request ))) goto done;
1837 }
1838 count = min( count, size );
1839 memcpy( (char *)buffer + bytes_read, request->read_buf + request->read_pos, count );
1840 remove_data( request, count );
1841 if (request->read_chunked) request->read_chunked_size -= count;
1842 size -= count;
1843 bytes_read += count;
1844 request->content_read += count;
1845 if (end_of_read_data( request )) goto done;
1846 }
1847 if (request->read_chunked && !request->read_chunked_size) ret = refill_buffer( request, async );
1848
1849 done:
1850 TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, request->content_read, request->content_length );
1851 if (end_of_read_data( request )) finished_reading( request );
1852 if (async)
1853 {
1854 if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
1855 else
1856 {
1857 WINHTTP_ASYNC_RESULT result;
1858 result.dwResult = API_READ_DATA;
1859 result.dwError = ret;
1860 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
1861 }
1862 }
1863
1864 if (!ret && read) *read = bytes_read;
1865 return ret;
1866 }
1867
1868 /* read any content returned by the server so that the connection can be reused */
1869 static void drain_content( struct request *request )
1870 {
1871 DWORD size, bytes_read, bytes_total = 0, bytes_left = request->content_length - request->content_read;
1872 char buffer[2048];
1873
1874 refill_buffer( request, FALSE );
1875 for (;;)
1876 {
1877 if (request->read_chunked) size = sizeof(buffer);
1878 else size = min( sizeof(buffer), bytes_left - bytes_total );
1879
1880 if (read_data( request, buffer, size, &bytes_read, FALSE ) || !bytes_read) return;
1881 bytes_total += bytes_read;
1882 }
1883 }
1884
1885 enum escape_flags
1886 {
1887 ESCAPE_FLAG_NON_PRINTABLE = 0x01,
1888 ESCAPE_FLAG_SPACE = 0x02,
1889 ESCAPE_FLAG_PERCENT = 0x04,
1890 ESCAPE_FLAG_UNSAFE = 0x08,
1891 ESCAPE_FLAG_DEL = 0x10,
1892 ESCAPE_FLAG_8BIT = 0x20,
1893 ESCAPE_FLAG_STRIP_CRLF = 0x40,
1894 };
1895
1896 #define ESCAPE_MASK_DEFAULT (ESCAPE_FLAG_NON_PRINTABLE | ESCAPE_FLAG_SPACE | ESCAPE_FLAG_UNSAFE |\
1897 ESCAPE_FLAG_DEL | ESCAPE_FLAG_8BIT)
1898 #define ESCAPE_MASK_PERCENT (ESCAPE_FLAG_PERCENT | ESCAPE_MASK_DEFAULT)
1899 #define ESCAPE_MASK_DISABLE (ESCAPE_FLAG_SPACE | ESCAPE_FLAG_8BIT | ESCAPE_FLAG_STRIP_CRLF)
1900
1901 static inline BOOL need_escape( char ch, enum escape_flags flags )
1902 {
1903 static const char unsafe[] = "\"#<>[\\]^`{|}";
1904 const char *ptr = unsafe;
1905
1906 if ((flags & ESCAPE_FLAG_SPACE) && ch == ' ') return TRUE;
1907 if ((flags & ESCAPE_FLAG_PERCENT) && ch == '%') return TRUE;
1908 if ((flags & ESCAPE_FLAG_NON_PRINTABLE) && ch < 0x20) return TRUE;
1909 if ((flags & ESCAPE_FLAG_DEL) && ch == 0x7f) return TRUE;
1910 if ((flags & ESCAPE_FLAG_8BIT) && (ch & 0x80)) return TRUE;
1911 if ((flags & ESCAPE_FLAG_UNSAFE)) while (*ptr) { if (ch == *ptr++) return TRUE; }
1912 return FALSE;
1913 }
1914
1915 static DWORD escape_string( const char *src, DWORD len, char *dst, enum escape_flags flags )
1916 {
1917 static const char hex[] = "0123456789ABCDEF";
1918 DWORD i, ret = len;
1919 char *ptr = dst;
1920
1921 for (i = 0; i < len; i++)
1922 {
1923 if ((flags & ESCAPE_FLAG_STRIP_CRLF) && (src[i] == '\r' || src[i] == '\n'))
1924 {
1925 ret--;
1926 continue;
1927 }
1928 if (need_escape( src[i], flags ))
1929 {
1930 if (dst)
1931 {
1932 ptr[0] = '%';
1933 ptr[1] = hex[(src[i] >> 4) & 0xf];
1934 ptr[2] = hex[src[i] & 0xf];
1935 ptr += 3;
1936 }
1937 ret += 2;
1938 }
1939 else if (dst) *ptr++ = src[i];
1940 }
1941
1942 if (dst) dst[ret] = 0;
1943 return ret;
1944 }
1945
1946 static DWORD str_to_wire( const WCHAR *src, int src_len, char *dst, enum escape_flags flags )
1947 {
1948 DWORD len;
1949 char *utf8;
1950
1951 if (src_len < 0) src_len = lstrlenW( src );
1952 len = WideCharToMultiByte( CP_UTF8, 0, src, src_len, NULL, 0, NULL, NULL );
1953 if (!(utf8 = malloc( len ))) return 0;
1954
1955 WideCharToMultiByte( CP_UTF8, 0, src, -1, utf8, len, NULL, NULL );
1956 len = escape_string( utf8, len, dst, flags );
1957 free( utf8 );
1958
1959 return len;
1960 }
1961
1962 static char *build_wire_path( struct request *request, DWORD *ret_len )
1963 {
1964 WCHAR *full_path;
1965 const WCHAR *start, *path, *query = NULL;
1966 DWORD len, len_path = 0, len_query = 0;
1967 enum escape_flags path_flags, query_flags;
1968 char *ret;
1969
1970 if (!wcsicmp( request->connect->hostname, request->connect->servername )) start = full_path = request->path;
1971 else if (!(full_path = build_absolute_request_path( request, &start ))) return NULL;
1972
1973 len = lstrlenW( full_path );
1974 if ((path = wcschr( start, '/' )))
1975 {
1976 len_path = lstrlenW( path );
1977 if ((query = wcschr( path, '?' )))
1978 {
1979 len_query = lstrlenW( query );
1980 len_path -= len_query;
1981 }
1982 }
1983
1984 if (request->hdr.flags & WINHTTP_FLAG_ESCAPE_DISABLE) path_flags = ESCAPE_MASK_DISABLE;
1985 else if (request->hdr.flags & WINHTTP_FLAG_ESCAPE_PERCENT) path_flags = ESCAPE_MASK_PERCENT;
1986 else path_flags = ESCAPE_MASK_DEFAULT;
1987
1988 if (request->hdr.flags & WINHTTP_FLAG_ESCAPE_DISABLE_QUERY) query_flags = ESCAPE_MASK_DISABLE;
1989 else query_flags = path_flags;
1990
1991 *ret_len = str_to_wire( full_path, len - len_path - len_query, NULL, 0 );
1992 if (path) *ret_len += str_to_wire( path, len_path, NULL, path_flags );
1993 if (query) *ret_len += str_to_wire( query, len_query, NULL, query_flags );
1994
1995 if ((ret = malloc( *ret_len + 1 )))
1996 {
1997 len = str_to_wire( full_path, len - len_path - len_query, ret, 0 );
1998 if (path) len += str_to_wire( path, len_path, ret + len, path_flags );
1999 if (query) str_to_wire( query, len_query, ret + len, query_flags );
2000 }
2001
2002 if (full_path != request->path) free( full_path );
2003 return ret;
2004 }
2005
2006 static char *build_wire_request( struct request *request, DWORD *len )
2007 {
2008 char *path, *ptr, *ret;
2009 DWORD i, len_path;
2010
2011 if (!(path = build_wire_path( request, &len_path ))) return NULL;
2012
2013 *len = str_to_wire( request->verb, -1, NULL, 0 ) + 1; /* ' ' */
2014 *len += len_path + 1; /* ' ' */
2015 *len += str_to_wire( request->version, -1, NULL, 0 );
2016
2017 for (i = 0; i < request->num_headers; i++)
2018 {
2019 if (request->headers[i].is_request)
2020 {
2021 *len += str_to_wire( request->headers[i].field, -1, NULL, 0 ) + 2; /* ': ' */
2022 *len += str_to_wire( request->headers[i].value, -1, NULL, 0 ) + 2; /* '\r\n' */
2023 }
2024 }
2025 *len += 4; /* '\r\n\r\n' */
2026
2027 if ((ret = ptr = malloc( *len + 1 )))
2028 {
2029 ptr += str_to_wire( request->verb, -1, ptr, 0 );
2030 *ptr++ = ' ';
2031 memcpy( ptr, path, len_path );
2032 ptr += len_path;
2033 *ptr++ = ' ';
2034 ptr += str_to_wire( request->version, -1, ptr, 0 );
2035
2036 for (i = 0; i < request->num_headers; i++)
2037 {
2038 if (request->headers[i].is_request)
2039 {
2040 *ptr++ = '\r';
2041 *ptr++ = '\n';
2042 ptr += str_to_wire( request->headers[i].field, -1, ptr, 0 );
2043 *ptr++ = ':';
2044 *ptr++ = ' ';
2045 ptr += str_to_wire( request->headers[i].value, -1, ptr, 0 );
2046 }
2047 }
2048 memcpy( ptr, "\r\n\r\n", sizeof("\r\n\r\n") );
2049 }
2050
2051 free( path );
2052 return ret;
2053 }
2054
2055 static WCHAR *create_websocket_key(void)
2056 {
2057 WCHAR *ret;
2058 char buf[16];
2059 DWORD base64_len = ((sizeof(buf) + 2) * 4) / 3;
2060 if (!RtlGenRandom( buf, sizeof(buf) )) return NULL;
2061 if ((ret = malloc( (base64_len + 1) * sizeof(WCHAR) ))) encode_base64( buf, sizeof(buf), ret );
2062 return ret;
2063 }
2064
2065 static DWORD add_websocket_key_header( struct request *request )
2066 {
2067 WCHAR *key = create_websocket_key();
2068 if (!key) return ERROR_OUTOFMEMORY;
2069 process_header( request, L"Sec-WebSocket-Key", key, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, TRUE );
2070 free( key );
2071 return ERROR_SUCCESS;
2072 }
2073
2074 static DWORD send_request( struct request *request, const WCHAR *headers, DWORD headers_len, void *optional,
2075 DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL async )
2076 {
2077 struct connect *connect = request->connect;
2078 struct session *session = connect->session;
2079 char *wire_req;
2080 int bytes_sent;
2081 DWORD ret, len;
2082
2083 drain_content( request );
2084 clear_response_headers( request );
2085
2086 if (session->agent)
2087 process_header( request, L"User-Agent", session->agent, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2088
2089 if (connect->hostname)
2090 add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
2091
2092 if (request->creds[TARGET_SERVER][SCHEME_BASIC].username)
2093 do_authorization( request, WINHTTP_AUTH_TARGET_SERVER, WINHTTP_AUTH_SCHEME_BASIC );
2094
2095 if (total_len || (request->verb && !wcscmp( request->verb, L"POST" )))
2096 {
2097 WCHAR length[21]; /* decimal long int + null */
2098 swprintf( length, ARRAY_SIZE(length), L"%ld", total_len );
2099 process_header( request, L"Content-Length", length, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2100 }
2101 if (request->flags & REQUEST_FLAG_WEBSOCKET_UPGRADE)
2102 {
2103 process_header( request, L"Upgrade", L"websocket", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2104 process_header( request, L"Connection", L"Upgrade", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2105 process_header( request, L"Sec-WebSocket-Version", L"13", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2106 if ((ret = add_websocket_key_header( request ))) return ret;
2107 }
2108 else if (!(request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE))
2109 {
2110 process_header( request, L"Connection", L"Keep-Alive", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2111 }
2112 if (request->hdr.flags & WINHTTP_FLAG_REFRESH)
2113 {
2114 process_header( request, L"Pragma", L"no-cache", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2115 process_header( request, L"Cache-Control", L"no-cache", WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
2116 }
2117 if (headers && (ret = add_request_headers( request, headers, headers_len,
2118 WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE )))
2119 {
2120 TRACE("failed to add request headers: %u\n", ret);
2121 return ret;
2122 }
2123 if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && (ret = add_cookie_headers( request )))
2124 {
2125 WARN("failed to add cookie headers: %u\n", ret);
2126 return ret;
2127 }
2128
2129 if (context) request->hdr.context = context;
2130
2131 if ((ret = open_connection( request ))) goto end;
2132 if (!(wire_req = build_wire_request( request, &len )))
2133 {
2134 ret = ERROR_OUTOFMEMORY;
2135 goto end;
2136 }
2137 TRACE("full request: %s\n", debugstr_a(wire_req));
2138
2139 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
2140
2141 ret = netconn_send( request->netconn, wire_req, len, &bytes_sent, NULL );
2142 free( wire_req );
2143 if (ret) goto end;
2144
2145 if (optional_len)
2146 {
2147 if ((ret = netconn_send( request->netconn, optional, optional_len, &bytes_sent, NULL ))) goto end;
2148 request->optional = optional;
2149 request->optional_len = optional_len;
2150 len += optional_len;
2151 }
2152 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_SENT, &len, sizeof(len) );
2153
2154 end:
2155 if (async)
2156 {
2157 if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
2158 else
2159 {
2160 WINHTTP_ASYNC_RESULT result;
2161 result.dwResult = API_SEND_REQUEST;
2162 result.dwError = ret;
2163 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2164 }
2165 }
2166 return ret;
2167 }
2168
2169 static void CALLBACK task_send_request( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
2170 {
2171 struct send_request *s = ctx;
2172
2173 TRACE("running %p\n", work);
2174 send_request( s->request, s->headers, s->headers_len, s->optional, s->optional_len, s->total_len, s->context, TRUE );
2175
2176 release_object( &s->request->hdr );
2177 free( s->headers );
2178 free( s );
2179 }
2180
2181 /***********************************************************************
2182 * WinHttpSendRequest (winhttp.@)
2183 */
2184 BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD headers_len,
2185 LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context )
2186 {
2187 DWORD ret;
2188 struct request *request;
2189
2190 TRACE("%p, %s, %u, %p, %u, %u, %lx\n", hrequest, debugstr_wn(headers, headers_len), headers_len, optional,
2191 optional_len, total_len, context);
2192
2193 if (!(request = (struct request *)grab_object( hrequest )))
2194 {
2195 SetLastError( ERROR_INVALID_HANDLE );
2196 return FALSE;
2197 }
2198 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2199 {
2200 release_object( &request->hdr );
2201 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2202 return FALSE;
2203 }
2204
2205 if (headers && !headers_len) headers_len = lstrlenW( headers );
2206
2207 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
2208 {
2209 struct send_request *s;
2210
2211 if (!(s = malloc( sizeof(*s) ))) return FALSE;
2212 s->request = request;
2213 s->headers = strdupW( headers );
2214 s->headers_len = headers_len;
2215 s->optional = optional;
2216 s->optional_len = optional_len;
2217 s->total_len = total_len;
2218 s->context = context;
2219
2220 addref_object( &request->hdr );
2221 if ((ret = queue_task( &request->queue, task_send_request, s )))
2222 {
2223 release_object( &request->hdr );
2224 free( s->headers );
2225 free( s );
2226 }
2227 }
2228 else ret = send_request( request, headers, headers_len, optional, optional_len, total_len, context, FALSE );
2229
2230 release_object( &request->hdr );
2231 SetLastError( ret );
2232 return !ret;
2233 }
2234
2235 static DWORD set_credentials( struct request *request, DWORD target, DWORD scheme_flag, const WCHAR *username,
2236 const WCHAR *password )
2237 {
2238 enum auth_scheme scheme = scheme_from_flag( scheme_flag );
2239
2240 if (scheme == SCHEME_INVALID || ((scheme == SCHEME_BASIC || scheme == SCHEME_DIGEST) && (!username || !password)))
2241 {
2242 return ERROR_INVALID_PARAMETER;
2243 }
2244 switch (target)
2245 {
2246 case WINHTTP_AUTH_TARGET_SERVER:
2247 {
2248 free( request->creds[TARGET_SERVER][scheme].username );
2249 if (!username) request->creds[TARGET_SERVER][scheme].username = NULL;
2250 else if (!(request->creds[TARGET_SERVER][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
2251
2252 free( request->creds[TARGET_SERVER][scheme].password );
2253 if (!password) request->creds[TARGET_SERVER][scheme].password = NULL;
2254 else if (!(request->creds[TARGET_SERVER][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
2255 break;
2256 }
2257 case WINHTTP_AUTH_TARGET_PROXY:
2258 {
2259 free( request->creds[TARGET_PROXY][scheme].username );
2260 if (!username) request->creds[TARGET_PROXY][scheme].username = NULL;
2261 else if (!(request->creds[TARGET_PROXY][scheme].username = strdupW( username ))) return ERROR_OUTOFMEMORY;
2262
2263 free( request->creds[TARGET_PROXY][scheme].password );
2264 if (!password) request->creds[TARGET_PROXY][scheme].password = NULL;
2265 else if (!(request->creds[TARGET_PROXY][scheme].password = strdupW( password ))) return ERROR_OUTOFMEMORY;
2266 break;
2267 }
2268 default:
2269 WARN("unknown target %u\n", target);
2270 return ERROR_INVALID_PARAMETER;
2271 }
2272 return ERROR_SUCCESS;
2273 }
2274
2275 /***********************************************************************
2276 * WinHttpSetCredentials (winhttp.@)
2277 */
2278 BOOL WINAPI WinHttpSetCredentials( HINTERNET hrequest, DWORD target, DWORD scheme, LPCWSTR username,
2279 LPCWSTR password, LPVOID params )
2280 {
2281 DWORD ret;
2282 struct request *request;
2283
2284 TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest, target, scheme, debugstr_w(username), password, params);
2285
2286 if (!(request = (struct request *)grab_object( hrequest )))
2287 {
2288 SetLastError( ERROR_INVALID_HANDLE );
2289 return FALSE;
2290 }
2291 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2292 {
2293 release_object( &request->hdr );
2294 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2295 return FALSE;
2296 }
2297
2298 ret = set_credentials( request, target, scheme, username, password );
2299
2300 release_object( &request->hdr );
2301 SetLastError( ret );
2302 return !ret;
2303 }
2304
2305 static DWORD handle_authorization( struct request *request, DWORD status )
2306 {
2307 DWORD ret, i, schemes, first, level, target;
2308
2309 switch (status)
2310 {
2311 case HTTP_STATUS_DENIED:
2312 target = WINHTTP_AUTH_TARGET_SERVER;
2313 level = WINHTTP_QUERY_WWW_AUTHENTICATE;
2314 break;
2315
2316 case HTTP_STATUS_PROXY_AUTH_REQ:
2317 target = WINHTTP_AUTH_TARGET_PROXY;
2318 level = WINHTTP_QUERY_PROXY_AUTHENTICATE;
2319 break;
2320
2321 default:
2322 ERR("unhandled status %u\n", status);
2323 return ERROR_WINHTTP_INTERNAL_ERROR;
2324 }
2325
2326 if ((ret = query_auth_schemes( request, level, &schemes, &first ))) return ret;
2327 if (do_authorization( request, target, first )) return ERROR_SUCCESS;
2328
2329 schemes &= ~first;
2330 for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++)
2331 {
2332 if (!(schemes & auth_schemes[i].scheme)) continue;
2333 if (do_authorization( request, target, auth_schemes[i].scheme )) return ERROR_SUCCESS;
2334 }
2335 return ERROR_WINHTTP_LOGIN_FAILURE;
2336 }
2337
2338 /* set the request content length based on the headers */
2339 static void set_content_length( struct request *request, DWORD status )
2340 {
2341 WCHAR encoding[20];
2342 DWORD buflen = sizeof(request->content_length);
2343
2344 if (status == HTTP_STATUS_NO_CONTENT || status == HTTP_STATUS_NOT_MODIFIED ||
2345 status == HTTP_STATUS_SWITCH_PROTOCOLS || !wcscmp( request->verb, L"HEAD" ))
2346 {
2347 request->content_length = 0;
2348 }
2349 else
2350 {
2351 if (query_headers( request, WINHTTP_QUERY_CONTENT_LENGTH|WINHTTP_QUERY_FLAG_NUMBER,
2352 NULL, &request->content_length, &buflen, NULL ))
2353 request->content_length = ~0u;
2354
2355 buflen = sizeof(encoding);
2356 if (!query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding, &buflen, NULL ) &&
2357 !wcsicmp( encoding, L"chunked" ))
2358 {
2359 request->content_length = ~0u;
2360 request->read_chunked = TRUE;
2361 request->read_chunked_size = ~0u;
2362 request->read_chunked_eof = FALSE;
2363 }
2364 }
2365 request->content_read = 0;
2366 }
2367
2368 static DWORD read_line( struct request *request, char *buffer, DWORD *len )
2369 {
2370 int count, bytes_read, pos = 0;
2371 DWORD ret;
2372
2373 for (;;)
2374 {
2375 char *eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
2376 if (eol)
2377 {
2378 count = eol - (request->read_buf + request->read_pos);
2379 bytes_read = count + 1;
2380 }
2381 else count = bytes_read = request->read_size;
2382
2383 count = min( count, *len - pos );
2384 memcpy( buffer + pos, request->read_buf + request->read_pos, count );
2385 pos += count;
2386 remove_data( request, bytes_read );
2387 if (eol) break;
2388
2389 if ((ret = read_more_data( request, -1, TRUE ))) return ret;
2390 if (!request->read_size)
2391 {
2392 *len = 0;
2393 TRACE("returning empty string\n");
2394 return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
2395 }
2396 }
2397 if (pos < *len)
2398 {
2399 if (pos && buffer[pos - 1] == '\r') pos--;
2400 *len = pos + 1;
2401 }
2402 buffer[*len - 1] = 0;
2403 TRACE("returning %s\n", debugstr_a(buffer));
2404 return ERROR_SUCCESS;
2405 }
2406
2407 #define MAX_REPLY_LEN 1460
2408 #define INITIAL_HEADER_BUFFER_LEN 512
2409
2410 static DWORD read_reply( struct request *request )
2411 {
2412 char buffer[MAX_REPLY_LEN];
2413 DWORD ret, buflen, len, offset, crlf_len = 2; /* lstrlenW(crlf) */
2414 char *status_code, *status_text;
2415 WCHAR *versionW, *status_textW, *raw_headers;
2416 WCHAR status_codeW[4]; /* sizeof("nnn") */
2417
2418 if (!request->netconn) return ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
2419
2420 do
2421 {
2422 buflen = MAX_REPLY_LEN;
2423 if ((ret = read_line( request, buffer, &buflen ))) return ret;
2424
2425 /* first line should look like 'HTTP/1.x nnn OK' where nnn is the status code */
2426 if (!(status_code = strchr( buffer, ' ' ))) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
2427 status_code++;
2428 if (!(status_text = strchr( status_code, ' ' ))) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
2429 if ((len = status_text - status_code) != sizeof("nnn") - 1) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
2430 status_text++;
2431
2432 TRACE("version [%s] status code [%s] status text [%s]\n",
2433 debugstr_an(buffer, status_code - buffer - 1),
2434 debugstr_an(status_code, len),
2435 debugstr_a(status_text));
2436
2437 } while (!memcmp( status_code, "100", len )); /* ignore "100 Continue" responses */
2438
2439 /* we rely on the fact that the protocol is ascii */
2440 MultiByteToWideChar( CP_ACP, 0, status_code, len, status_codeW, len );
2441 status_codeW[len] = 0;
2442 if ((ret = process_header( request, L"Status", status_codeW,
2443 WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, FALSE ))) return ret;
2444
2445 len = status_code - buffer;
2446 if (!(versionW = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
2447 MultiByteToWideChar( CP_ACP, 0, buffer, len - 1, versionW, len -1 );
2448 versionW[len - 1] = 0;
2449
2450 free( request->version );
2451 request->version = versionW;
2452
2453 len = buflen - (status_text - buffer);
2454 if (!(status_textW = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
2455 MultiByteToWideChar( CP_ACP, 0, status_text, len, status_textW, len );
2456
2457 free( request->status_text );
2458 request->status_text = status_textW;
2459
2460 len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_LEN );
2461 if (!(raw_headers = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
2462 MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers, buflen );
2463 memcpy( raw_headers + buflen - 1, L"\r\n", sizeof(L"\r\n") );
2464
2465 free( request->raw_headers );
2466 request->raw_headers = raw_headers;
2467
2468 offset = buflen + crlf_len - 1;
2469 for (;;)
2470 {
2471 struct header *header;
2472
2473 buflen = MAX_REPLY_LEN;
2474 if (read_line( request, buffer, &buflen )) return ERROR_SUCCESS;
2475 if (!*buffer) buflen = 1;
2476
2477 while (len - offset < buflen + crlf_len)
2478 {
2479 WCHAR *tmp;
2480 len *= 2;
2481 if (!(tmp = realloc( raw_headers, len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
2482 request->raw_headers = raw_headers = tmp;
2483 }
2484 if (!*buffer)
2485 {
2486 memcpy( raw_headers + offset, L"\r\n", sizeof(L"\r\n") );
2487 break;
2488 }
2489 MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers + offset, buflen );
2490
2491 if (!(header = parse_header( raw_headers + offset ))) break;
2492 if ((ret = process_header( request, header->field, header->value, WINHTTP_ADDREQ_FLAG_ADD, FALSE )))
2493 {
2494 free_header( header );
2495 break;
2496 }
2497 free_header( header );
2498 memcpy( raw_headers + offset + buflen - 1, L"\r\n", sizeof(L"\r\n") );
2499 offset += buflen + crlf_len - 1;
2500 }
2501
2502 TRACE("raw headers: %s\n", debugstr_w(raw_headers));
2503 return ret;
2504 }
2505
2506 static void record_cookies( struct request *request )
2507 {
2508 unsigned int i;
2509
2510 for (i = 0; i < request->num_headers; i++)
2511 {
2512 struct header *set_cookie = &request->headers[i];
2513 if (!wcsicmp( set_cookie->field, L"Set-Cookie" ) && !set_cookie->is_request)
2514 {
2515 set_cookies( request, set_cookie->value );
2516 }
2517 }
2518 }
2519
2520 static DWORD get_redirect_url( struct request *request, WCHAR **ret_url, DWORD *ret_len )
2521 {
2522 DWORD size, ret;
2523 WCHAR *url;
2524
2525 ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
2526 if (ret != ERROR_INSUFFICIENT_BUFFER) return ret;
2527 if (!(url = malloc( size ))) return ERROR_OUTOFMEMORY;
2528 if ((ret = query_headers( request, WINHTTP_QUERY_LOCATION, NULL, url, &size, NULL )))
2529 {
2530 free( url );
2531 return ret;
2532 }
2533 *ret_url = url;
2534 *ret_len = size / sizeof(WCHAR);
2535 return ERROR_SUCCESS;
2536 }
2537
2538 static DWORD handle_redirect( struct request *request, DWORD status )
2539 {
2540 DWORD ret, len, len_loc = 0;
2541 URL_COMPONENTS uc;
2542 struct connect *connect = request->connect;
2543 INTERNET_PORT port;
2544 WCHAR *hostname = NULL, *location = NULL;
2545
2546 if ((ret = get_redirect_url( request, &location, &len_loc ))) return ret;
2547
2548 memset( &uc, 0, sizeof(uc) );
2549 uc.dwStructSize = sizeof(uc);
2550 uc.dwSchemeLength = uc.dwHostNameLength = uc.dwUrlPathLength = uc.dwExtraInfoLength = ~0u;
2551
2552 if (!WinHttpCrackUrl( location, len_loc, 0, &uc )) /* assume relative redirect */
2553 {
2554 WCHAR *path, *p;
2555
2556 ret = ERROR_OUTOFMEMORY;
2557 if (location[0] == '/')
2558 {
2559 if (!(path = malloc( (len_loc + 1) * sizeof(WCHAR) ))) goto end;
2560 memcpy( path, location, len_loc * sizeof(WCHAR) );
2561 path[len_loc] = 0;
2562 }
2563 else
2564 {
2565 if ((p = wcsrchr( request->path, '/' ))) *p = 0;
2566 len = lstrlenW( request->path ) + 1 + len_loc;
2567 if (!(path = malloc( (len + 1) * sizeof(WCHAR) ))) goto end;
2568 lstrcpyW( path, request->path );
2569 lstrcatW( path, L"/" );
2570 memcpy( path + lstrlenW(path), location, len_loc * sizeof(WCHAR) );
2571 path[len_loc] = 0;
2572 }
2573 free( request->path );
2574 request->path = path;
2575 ret = ERROR_SUCCESS;
2576
2577 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_loc + 1 );
2578 }
2579 else
2580 {
2581 if (uc.nScheme == INTERNET_SCHEME_HTTP && request->hdr.flags & WINHTTP_FLAG_SECURE)
2582 {
2583 if (request->hdr.redirect_policy == WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP)
2584 {
2585 ret = ERROR_WINHTTP_REDIRECT_FAILED;
2586 goto end;
2587 }
2588 TRACE("redirect from secure page to non-secure page\n");
2589 request->hdr.flags &= ~WINHTTP_FLAG_SECURE;
2590 }
2591 else if (uc.nScheme == INTERNET_SCHEME_HTTPS && !(request->hdr.flags & WINHTTP_FLAG_SECURE))
2592 {
2593 TRACE("redirect from non-secure page to secure page\n");
2594 request->hdr.flags |= WINHTTP_FLAG_SECURE;
2595 }
2596
2597 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_loc + 1 );
2598
2599 len = uc.dwHostNameLength;
2600 if (!(hostname = malloc( (len + 1) * sizeof(WCHAR) )))
2601 {
2602 ret = ERROR_OUTOFMEMORY;
2603 goto end;
2604 }
2605 memcpy( hostname, uc.lpszHostName, len * sizeof(WCHAR) );
2606 hostname[len] = 0;
2607
2608 port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80);
2609 if (wcsicmp( connect->hostname, hostname ) || connect->serverport != port)
2610 {
2611 free( connect->hostname );
2612 connect->hostname = hostname;
2613 connect->hostport = port;
2614 if (!set_server_for_hostname( connect, hostname, port ))
2615 {
2616 ret = ERROR_OUTOFMEMORY;
2617 goto end;
2618 }
2619
2620 netconn_close( request->netconn );
2621 request->netconn = NULL;
2622 request->content_length = request->content_read = 0;
2623 request->read_pos = request->read_size = 0;
2624 request->read_chunked = request->read_chunked_eof = FALSE;
2625 }
2626 else free( hostname );
2627
2628 if ((ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
2629 if ((ret = open_connection( request ))) goto end;
2630
2631 free( request->path );
2632 request->path = NULL;
2633 if (uc.dwUrlPathLength)
2634 {
2635 len = uc.dwUrlPathLength + uc.dwExtraInfoLength;
2636 if (!(request->path = malloc( (len + 1) * sizeof(WCHAR) ))) goto end;
2637 memcpy( request->path, uc.lpszUrlPath, (len + 1) * sizeof(WCHAR) );
2638 request->path[len] = 0;
2639 }
2640 else request->path = strdupW( L"/" );
2641 }
2642
2643 if (status != HTTP_STATUS_REDIRECT_KEEP_VERB && !wcscmp( request->verb, L"POST" ))
2644 {
2645 free( request->verb );
2646 request->verb = strdupW( L"GET" );
2647 request->optional = NULL;
2648 request->optional_len = 0;
2649 }
2650
2651 end:
2652 free( location );
2653 return ret;
2654 }
2655
2656 static BOOL is_passport_request( struct request *request )
2657 {
2658 static const WCHAR passportW[] = {'P','a','s','s','p','o','r','t','1','.','4'};
2659 WCHAR buf[1024];
2660 DWORD len = ARRAY_SIZE(buf);
2661
2662 if (!(request->connect->session->passport_flags & WINHTTP_ENABLE_PASSPORT_AUTH) ||
2663 query_headers( request, WINHTTP_QUERY_WWW_AUTHENTICATE, NULL, buf, &len, NULL )) return FALSE;
2664
2665 if (!wcsnicmp( buf, passportW, ARRAY_SIZE(passportW) ) &&
2666 (buf[ARRAY_SIZE(passportW)] == ' ' || !buf[ARRAY_SIZE(passportW)])) return TRUE;
2667
2668 return FALSE;
2669 }
2670
2671 static DWORD handle_passport_redirect( struct request *request )
2672 {
2673 DWORD ret, flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
2674 int i, len = lstrlenW( request->raw_headers );
2675 WCHAR *p = request->raw_headers;
2676
2677 if ((ret = process_header( request, L"Status", L"401", flags, FALSE ))) return ret;
2678
2679 for (i = 0; i < len; i++)
2680 {
2681 if (i <= len - 3 && p[i] == '3' && p[i + 1] == '0' && p[i + 2] == '2')
2682 {
2683 p[i] = '4';
2684 p[i + 2] = '1';
2685 break;
2686 }
2687 }
2688 return ERROR_SUCCESS;
2689 }
2690
2691 static DWORD receive_response( struct request *request, BOOL async )
2692 {
2693 DWORD ret, size, query, status;
2694
2695 if (!request->netconn) return ERROR_WINHTTP_INCORRECT_HANDLE_STATE;
2696
2697 netconn_set_timeout( request->netconn, FALSE, request->receive_response_timeout );
2698 for (;;)
2699 {
2700 if ((ret = read_reply( request ))) break;
2701
2702 size = sizeof(DWORD);
2703 query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
2704 if ((ret = query_headers( request, query, NULL, &status, &size, NULL ))) break;
2705
2706 set_content_length( request, status );
2707
2708 if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES)) record_cookies( request );
2709
2710 if (status == HTTP_STATUS_REDIRECT && is_passport_request( request ))
2711 {
2712 ret = handle_passport_redirect( request );
2713 }
2714 else if (status == HTTP_STATUS_MOVED || status == HTTP_STATUS_REDIRECT || status == HTTP_STATUS_REDIRECT_KEEP_VERB)
2715 {
2716 if (request->hdr.disable_flags & WINHTTP_DISABLE_REDIRECTS ||
2717 request->hdr.redirect_policy == WINHTTP_OPTION_REDIRECT_POLICY_NEVER) break;
2718
2719 if (++request->redirect_count > request->max_redirects) return ERROR_WINHTTP_REDIRECT_FAILED;
2720
2721 if ((ret = handle_redirect( request, status ))) break;
2722
2723 /* recurse synchronously */
2724 if (!(ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
2725 }
2726 else if (status == HTTP_STATUS_DENIED || status == HTTP_STATUS_PROXY_AUTH_REQ)
2727 {
2728 if (request->hdr.disable_flags & WINHTTP_DISABLE_AUTHENTICATION) break;
2729
2730 if (handle_authorization( request, status )) break;
2731
2732 /* recurse synchronously */
2733 if (!(ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
2734 }
2735 break;
2736 }
2737
2738 if (request->netconn) netconn_set_timeout( request->netconn, FALSE, request->receive_timeout );
2739 if (request->content_length) ret = refill_buffer( request, FALSE );
2740
2741 if (async)
2742 {
2743 if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NULL, 0 );
2744 else
2745 {
2746 WINHTTP_ASYNC_RESULT result;
2747 result.dwResult = API_RECEIVE_RESPONSE;
2748 result.dwError = ret;
2749 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2750 }
2751 }
2752 return ret;
2753 }
2754
2755 static void CALLBACK task_receive_response( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
2756 {
2757 struct receive_response *r = ctx;
2758
2759 TRACE("running %p\n", work);
2760 receive_response( r->request, TRUE );
2761
2762 release_object( &r->request->hdr );
2763 free( r );
2764 }
2765
2766 /***********************************************************************
2767 * WinHttpReceiveResponse (winhttp.@)
2768 */
2769 BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
2770 {
2771 DWORD ret;
2772 struct request *request;
2773
2774 TRACE("%p, %p\n", hrequest, reserved);
2775
2776 if (!(request = (struct request *)grab_object( hrequest )))
2777 {
2778 SetLastError( ERROR_INVALID_HANDLE );
2779 return FALSE;
2780 }
2781 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2782 {
2783 release_object( &request->hdr );
2784 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2785 return FALSE;
2786 }
2787
2788 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
2789 {
2790 struct receive_response *r;
2791
2792 if (!(r = malloc( sizeof(*r) ))) return FALSE;
2793 r->request = request;
2794
2795 addref_object( &request->hdr );
2796 if ((ret = queue_task( &request->queue, task_receive_response, r )))
2797 {
2798 release_object( &request->hdr );
2799 free( r );
2800 }
2801 }
2802 else ret = receive_response( request, FALSE );
2803
2804 release_object( &request->hdr );
2805 SetLastError( ret );
2806 return !ret;
2807 }
2808
2809 static DWORD query_data_ready( struct request *request )
2810 {
2811 DWORD count;
2812
2813 count = get_available_data( request );
2814 if (!request->read_chunked && request->netconn) count += netconn_query_data_available( request->netconn );
2815
2816 return count;
2817 }
2818
2819 static BOOL skip_async_queue( struct request *request )
2820 {
2821 return request->hdr.recursion_count < 3 && (end_of_read_data( request ) || query_data_ready( request ));
2822 }
2823
2824 static DWORD query_data_available( struct request *request, DWORD *available, BOOL async )
2825 {
2826 DWORD ret = ERROR_SUCCESS, count = 0;
2827
2828 if (end_of_read_data( request )) goto done;
2829
2830 if (!(count = query_data_ready( request )))
2831 {
2832 if ((ret = refill_buffer( request, async ))) goto done;
2833 count = query_data_ready( request );
2834 }
2835
2836 done:
2837 TRACE("%u bytes available\n", count);
2838 if (async)
2839 {
2840 if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, &count, sizeof(count) );
2841 else
2842 {
2843 WINHTTP_ASYNC_RESULT result;
2844 result.dwResult = API_QUERY_DATA_AVAILABLE;
2845 result.dwError = ret;
2846 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2847 }
2848 }
2849
2850 if (!ret && available) *available = count;
2851 return ret;
2852 }
2853
2854 static void CALLBACK task_query_data_available( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
2855 {
2856 struct query_data *q = ctx;
2857
2858 TRACE("running %p\n", work);
2859 query_data_available( q->request, q->available, TRUE );
2860
2861 release_object( &q->request->hdr );
2862 free( q );
2863 }
2864
2865 /***********************************************************************
2866 * WinHttpQueryDataAvailable (winhttp.@)
2867 */
2868 BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
2869 {
2870 DWORD ret;
2871 struct request *request;
2872 BOOL async;
2873
2874 TRACE("%p, %p\n", hrequest, available);
2875
2876 if (!(request = (struct request *)grab_object( hrequest )))
2877 {
2878 SetLastError( ERROR_INVALID_HANDLE );
2879 return FALSE;
2880 }
2881 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2882 {
2883 release_object( &request->hdr );
2884 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2885 return FALSE;
2886 }
2887
2888 if ((async = request->connect->hdr.flags & WINHTTP_FLAG_ASYNC) && !skip_async_queue( request ))
2889 {
2890 struct query_data *q;
2891
2892 if (!(q = malloc( sizeof(*q) ))) return FALSE;
2893 q->request = request;
2894 q->available = available;
2895
2896 addref_object( &request->hdr );
2897 if ((ret = queue_task( &request->queue, task_query_data_available, q )))
2898 {
2899 release_object( &request->hdr );
2900 free( q );
2901 }
2902 else ret = ERROR_IO_PENDING;
2903 }
2904 else ret = query_data_available( request, available, async );
2905
2906 release_object( &request->hdr );
2907 SetLastError( ret );
2908 return !ret || ret == ERROR_IO_PENDING;
2909 }
2910
2911 static void CALLBACK task_read_data( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
2912 {
2913 struct read_data *r = ctx;
2914
2915 TRACE("running %p\n", work);
2916 read_data( r->request, r->buffer, r->to_read, r->read, TRUE );
2917
2918 release_object( &r->request->hdr );
2919 free( r );
2920 }
2921
2922 /***********************************************************************
2923 * WinHttpReadData (winhttp.@)
2924 */
2925 BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD read )
2926 {
2927 DWORD ret;
2928 struct request *request;
2929 BOOL async;
2930
2931 TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_read, read);
2932
2933 if (!(request = (struct request *)grab_object( hrequest )))
2934 {
2935 SetLastError( ERROR_INVALID_HANDLE );
2936 return FALSE;
2937 }
2938 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
2939 {
2940 release_object( &request->hdr );
2941 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2942 return FALSE;
2943 }
2944
2945 if ((async = request->connect->hdr.flags & WINHTTP_FLAG_ASYNC) && !skip_async_queue( request ))
2946 {
2947 struct read_data *r;
2948
2949 if (!(r = malloc( sizeof(*r) ))) return FALSE;
2950 r->request = request;
2951 r->buffer = buffer;
2952 r->to_read = to_read;
2953 r->read = read;
2954
2955 addref_object( &request->hdr );
2956 if ((ret = queue_task( &request->queue, task_read_data, r )))
2957 {
2958 release_object( &request->hdr );
2959 free( r );
2960 }
2961 else ret = ERROR_IO_PENDING;
2962 }
2963 else ret = read_data( request, buffer, to_read, read, async );
2964
2965 release_object( &request->hdr );
2966 SetLastError( ret );
2967 return !ret || ret == ERROR_IO_PENDING;
2968 }
2969
2970 static DWORD write_data( struct request *request, const void *buffer, DWORD to_write, DWORD *written, BOOL async )
2971 {
2972 DWORD ret;
2973 int num_bytes;
2974
2975 ret = netconn_send( request->netconn, buffer, to_write, &num_bytes, NULL );
2976
2977 if (async)
2978 {
2979 if (!ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &num_bytes, sizeof(num_bytes) );
2980 else
2981 {
2982 WINHTTP_ASYNC_RESULT result;
2983 result.dwResult = API_WRITE_DATA;
2984 result.dwError = ret;
2985 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
2986 }
2987 }
2988 if (!ret && written) *written = num_bytes;
2989 return ret;
2990 }
2991
2992 static void CALLBACK task_write_data( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
2993 {
2994 struct write_data *w = ctx;
2995
2996 TRACE("running %p\n", work);
2997 write_data( w->request, w->buffer, w->to_write, w->written, TRUE );
2998
2999 release_object( &w->request->hdr );
3000 free( w );
3001 }
3002
3003 /***********************************************************************
3004 * WinHttpWriteData (winhttp.@)
3005 */
3006 BOOL WINAPI WinHttpWriteData( HINTERNET hrequest, LPCVOID buffer, DWORD to_write, LPDWORD written )
3007 {
3008 DWORD ret;
3009 struct request *request;
3010
3011 TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_write, written);
3012
3013 if (!(request = (struct request *)grab_object( hrequest )))
3014 {
3015 SetLastError( ERROR_INVALID_HANDLE );
3016 return FALSE;
3017 }
3018 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
3019 {
3020 release_object( &request->hdr );
3021 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
3022 return FALSE;
3023 }
3024
3025 if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3026 {
3027 struct write_data *w;
3028
3029 if (!(w = malloc( sizeof(*w) ))) return FALSE;
3030 w->request = request;
3031 w->buffer = buffer;
3032 w->to_write = to_write;
3033 w->written = written;
3034
3035 addref_object( &request->hdr );
3036 if ((ret = queue_task( &request->queue, task_write_data, w )))
3037 {
3038 release_object( &request->hdr );
3039 free( w );
3040 }
3041 }
3042 else ret = write_data( request, buffer, to_write, written, FALSE );
3043
3044 release_object( &request->hdr );
3045 SetLastError( ret );
3046 return !ret;
3047 }
3048
3049 static BOOL socket_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
3050 {
3051 FIXME("unimplemented option %u\n", option);
3052 SetLastError( ERROR_WINHTTP_INVALID_OPTION );
3053 return FALSE;
3054 }
3055
3056 static void socket_destroy( struct object_header *hdr )
3057 {
3058 struct socket *socket = (struct socket *)hdr;
3059
3060 TRACE("%p\n", socket);
3061
3062 stop_queue( &socket->send_q );
3063 stop_queue( &socket->recv_q );
3064
3065 release_object( &socket->request->hdr );
3066 free( socket->send_frame_buffer );
3067 free( socket );
3068 }
3069
3070 static BOOL socket_set_option( struct object_header *hdr, DWORD option, void *buffer, DWORD buflen )
3071 {
3072 FIXME("unimplemented option %u\n", option);
3073 SetLastError( ERROR_WINHTTP_INVALID_OPTION );
3074 return FALSE;
3075 }
3076
3077 static const struct object_vtbl socket_vtbl =
3078 {
3079 socket_destroy,
3080 socket_query_option,
3081 socket_set_option,
3082 };
3083
3084 HINTERNET WINAPI WinHttpWebSocketCompleteUpgrade( HINTERNET hrequest, DWORD_PTR context )
3085 {
3086 struct socket *socket;
3087 struct request *request;
3088 HINTERNET hsocket = NULL;
3089
3090 TRACE("%p, %08lx\n", hrequest, context);
3091
3092 if (!(request = (struct request *)grab_object( hrequest )))
3093 {
3094 SetLastError( ERROR_INVALID_HANDLE );
3095 return NULL;
3096 }
3097 if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
3098 {
3099 release_object( &request->hdr );
3100 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
3101 return NULL;
3102 }
3103 if (!(socket = calloc( 1, sizeof(*socket) )))
3104 {
3105 release_object( &request->hdr );
3106 return NULL;
3107 }
3108 socket->hdr.type = WINHTTP_HANDLE_TYPE_SOCKET;
3109 socket->hdr.vtbl = &socket_vtbl;
3110 socket->hdr.refs = 1;
3111 socket->hdr.callback = request->hdr.callback;
3112 socket->hdr.notify_mask = request->hdr.notify_mask;
3113 socket->hdr.context = context;
3114
3115 addref_object( &request->hdr );
3116 socket->request = request;
3117
3118 if ((hsocket = alloc_handle( &socket->hdr )))
3119 {
3120 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hsocket, sizeof(hsocket) );
3121 }
3122
3123 release_object( &socket->hdr );
3124 release_object( &request->hdr );
3125 TRACE("returning %p\n", hsocket);
3126 if (hsocket) SetLastError( ERROR_SUCCESS );
3127 return hsocket;
3128 }
3129
3130 static DWORD send_bytes( struct socket *socket, char *bytes, int len, WSAOVERLAPPED *ovr )
3131 {
3132 int count;
3133 DWORD err;
3134 if ((err = netconn_send( socket->request->netconn, bytes, len, &count, ovr ))) return err;
3135 return (count == len) ? ERROR_SUCCESS : ERROR_INTERNAL_ERROR;
3136 }
3137
3138 #define FIN_BIT (1 << 7)
3139 #define MASK_BIT (1 << 7)
3140 #define RESERVED_BIT (7 << 4)
3141 #define CONTROL_BIT (1 << 3)
3142
3143 static DWORD send_frame( struct socket *socket, enum socket_opcode opcode, USHORT status, const char *buf,
3144 DWORD buflen, BOOL final, WSAOVERLAPPED *ovr )
3145 {
3146 DWORD i = 0, j, offset = 2, len = buflen;
3147 DWORD buffer_size, ret = 0, send_size;
3148 char hdr[14], *mask = NULL;
3149 char *ptr;
3150
3151 TRACE( "sending %02x frame, len %u.\n", opcode, len );
3152
3153 if (opcode == SOCKET_OPCODE_CLOSE) len += sizeof(status);
3154
3155 hdr[0] = final ? (char)FIN_BIT : 0;
3156 hdr[0] |= opcode;
3157 hdr[1] = (char)MASK_BIT;
3158 if (len < 126) hdr[1] |= len;
3159 else if (len < 65536)
3160 {
3161 hdr[1] |= 126;
3162 hdr[2] = len >> 8;
3163 hdr[3] = len & 0xff;
3164 offset += 2;
3165 }
3166 else
3167 {
3168 hdr[1] |= 127;
3169 hdr[2] = hdr[3] = hdr[4] = hdr[5] = 0;
3170 hdr[6] = len >> 24;
3171 hdr[7] = (len >> 16) & 0xff;
3172 hdr[8] = (len >> 8) & 0xff;
3173 hdr[9] = len & 0xff;
3174 offset += 8;
3175 }
3176
3177 buffer_size = len + offset;
3178 if (len) buffer_size += 4;
3179 assert( buffer_size - len < MAX_FRAME_BUFFER_SIZE );
3180 if (ovr && buffer_size > MAX_FRAME_BUFFER_SIZE) return WSAEWOULDBLOCK;
3181 if (buffer_size > socket->send_frame_buffer_size && socket->send_frame_buffer_size < MAX_FRAME_BUFFER_SIZE)
3182 {
3183 DWORD new_size;
3184 void *new;
3185
3186 new_size = min( buffer_size, MAX_FRAME_BUFFER_SIZE );
3187 if (!(new = realloc( socket->send_frame_buffer, new_size )))
3188 {
3189 ERR("Out of memory, buffer_size %u.\n", buffer_size);
3190 return ERROR_OUTOFMEMORY;
3191 }
3192 socket->send_frame_buffer = new;
3193 socket->send_frame_buffer_size = new_size;
3194 }
3195 ptr = socket->send_frame_buffer;
3196
3197 memcpy(ptr, hdr, offset);
3198 ptr += offset;
3199 if (len)
3200 {
3201 mask = &hdr[offset];
3202 RtlGenRandom( mask, 4 );
3203 memcpy( ptr, mask, 4 );
3204 ptr += 4;
3205 }
3206
3207 if (opcode == SOCKET_OPCODE_CLOSE) /* prepend status code */
3208 {
3209 *ptr++ = (status >> 8) ^ mask[i++ % 4];
3210 *ptr++ = (status & 0xff) ^ mask[i++ % 4];
3211 }
3212
3213 offset = ptr - socket->send_frame_buffer;
3214 send_size = offset + buflen;
3215 while (1)
3216 {
3217 j = 0;
3218 while (j < buflen && offset < MAX_FRAME_BUFFER_SIZE)
3219 socket->send_frame_buffer[offset++] = buf[j++] ^ mask[i++ % 4];
3220
3221 if ((ret = send_bytes( socket, socket->send_frame_buffer, offset, ovr ))) return ret;
3222
3223 if (!(send_size -= offset)) break;
3224 offset = 0;
3225 buf += j;
3226 buflen -= j;
3227 }
3228 return ERROR_SUCCESS;
3229 }
3230
3231 static DWORD complete_send_frame( struct socket *socket, WSAOVERLAPPED *ovr )
3232 {
3233 DWORD retflags, len;
3234
3235 if (!WSAGetOverlappedResult( socket->request->netconn->socket, ovr, &len, TRUE, &retflags ))
3236 return WSAGetLastError();
3237
3238 return ERROR_SUCCESS;
3239 }
3240
3241 static void send_io_complete( struct object_header *hdr )
3242 {
3243 LONG count = InterlockedDecrement( &hdr->pending_sends );
3244 assert( count >= 0 );
3245 }
3246
3247 static enum socket_opcode map_buffer_type( WINHTTP_WEB_SOCKET_BUFFER_TYPE type )
3248 {
3249 switch (type)
3250 {
3251 case WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE: return SOCKET_OPCODE_TEXT;
3252 case WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE: return SOCKET_OPCODE_BINARY;
3253 case WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE: return SOCKET_OPCODE_CLOSE;
3254 default:
3255 FIXME("buffer type %u not supported\n", type);
3256 return SOCKET_OPCODE_INVALID;
3257 }
3258 }
3259
3260 static void socket_send_complete( struct socket *socket, DWORD ret, WINHTTP_WEB_SOCKET_BUFFER_TYPE type, DWORD len )
3261 {
3262 if (!ret)
3263 {
3264 WINHTTP_WEB_SOCKET_STATUS status;
3265 status.dwBytesTransferred = len;
3266 status.eBufferType = type;
3267 send_callback( &socket->hdr, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &status, sizeof(status) );
3268 }
3269 else
3270 {
3271 WINHTTP_WEB_SOCKET_ASYNC_RESULT result;
3272 result.AsyncResult.dwResult = API_WRITE_DATA;
3273 result.AsyncResult.dwError = ret;
3274 result.Operation = WINHTTP_WEB_SOCKET_SEND_OPERATION;
3275 send_callback( &socket->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
3276 }
3277 }
3278
3279 static DWORD socket_send( struct socket *socket, WINHTTP_WEB_SOCKET_BUFFER_TYPE type, const void *buf, DWORD len,
3280 WSAOVERLAPPED *ovr )
3281 {
3282 enum socket_opcode opcode = map_buffer_type( type );
3283
3284 return send_frame( socket, opcode, 0, buf, len, TRUE, ovr );
3285 }
3286
3287 static void CALLBACK task_socket_send( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
3288 {
3289 struct socket_send *s = ctx;
3290 DWORD ret;
3291
3292 TRACE("running %p\n", work);
3293
3294 if (s->complete_async) ret = complete_send_frame( s->socket, &s->ovr );
3295 else ret = socket_send( s->socket, s->type, s->buf, s->len, NULL );
3296
3297 send_io_complete( &s->socket->hdr );
3298 socket_send_complete( s->socket, ret, s->type, s->len );
3299
3300 release_object( &s->socket->hdr );
3301 free( s );
3302 }
3303
3304 DWORD WINAPI WinHttpWebSocketSend( HINTERNET hsocket, WINHTTP_WEB_SOCKET_BUFFER_TYPE type, void *buf, DWORD len )
3305 {
3306 struct socket *socket;
3307 DWORD ret = 0;
3308
3309 TRACE("%p, %u, %p, %u\n", hsocket, type, buf, len);
3310
3311 if (len && !buf) return ERROR_INVALID_PARAMETER;
3312 if (type != WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE && type != WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE)
3313 {
3314 FIXME("buffer type %u not supported\n", type);
3315 return ERROR_NOT_SUPPORTED;
3316 }
3317
3318 if (!(socket = (struct socket *)grab_object( hsocket ))) return ERROR_INVALID_HANDLE;
3319 if (socket->hdr.type != WINHTTP_HANDLE_TYPE_SOCKET)
3320 {
3321 release_object( &socket->hdr );
3322 return ERROR_WINHTTP_INCORRECT_HANDLE_TYPE;
3323 }
3324 if (socket->state != SOCKET_STATE_OPEN)
3325 {
3326 release_object( &socket->hdr );
3327 return ERROR_INVALID_OPERATION;
3328 }
3329
3330 if (socket->request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3331 {
3332 BOOL async_send, complete_async = FALSE;
3333 struct socket_send *s;
3334
3335 if (!(s = malloc( sizeof(*s) )))
3336 {
3337 release_object( &socket->hdr );
3338 return ERROR_OUTOFMEMORY;
3339 }
3340
3341 async_send = InterlockedIncrement( &socket->hdr.pending_sends ) > 1 || socket->hdr.recursion_count >= 3;
3342 if (!async_send)
3343 {
3344 memset( &s->ovr, 0, sizeof(s->ovr) );
3345 if ((ret = socket_send( socket, type, buf, len, &s->ovr )) == WSA_IO_PENDING)
3346 {
3347 async_send = TRUE;
3348 complete_async = TRUE;
3349 }
3350 else if (ret == WSAEWOULDBLOCK) async_send = TRUE;
3351 }
3352
3353 if (async_send)
3354 {
3355 s->complete_async = complete_async;
3356 s->socket = socket;
3357 s->type = type;
3358 s->buf = buf;
3359 s->len = len;
3360
3361 addref_object( &socket->hdr );
3362 if ((ret = queue_task( &socket->send_q, task_socket_send, s )))
3363 {
3364 InterlockedDecrement( &socket->hdr.pending_sends );
3365 release_object( &socket->hdr );
3366 free( s );
3367 }
3368 else ++socket->hdr.pending_sends;
3369 }
3370 else
3371 {
3372 InterlockedDecrement( &socket->hdr.pending_sends );
3373 free( s );
3374 socket_send_complete( socket, ret, type, len );
3375 ret = ERROR_SUCCESS;
3376 }
3377 }
3378 else ret = socket_send( socket, type, buf, len, NULL );
3379
3380 release_object( &socket->hdr );
3381 return ret;
3382 }
3383
3384 static DWORD receive_bytes( struct socket *socket, char *buf, DWORD len, DWORD *ret_len, BOOL read_full_buffer )
3385 {
3386 DWORD err, size = 0, needed = len;
3387 char *ptr = buf;
3388 int received;
3389
3390 if (socket->request->read_size)
3391 {
3392 size = min( needed, socket->request->read_size );
3393 memcpy( ptr, socket->request->read_buf + socket->request->read_pos, size );
3394 remove_data( socket->request, size );
3395 needed -= size;
3396 ptr += size;
3397 }
3398 while (size != len)
3399 {
3400 if ((err = netconn_recv( socket->request->netconn, ptr, needed, 0, &received ))) return err;
3401 if (!received) break;
3402 size += received;
3403 if (!read_full_buffer) break;
3404 needed -= received;
3405 ptr += received;
3406 }
3407 *ret_len = size;
3408 if (size != len && (read_full_buffer || !size)) return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
3409 return ERROR_SUCCESS;
3410 }
3411
3412 static BOOL is_supported_opcode( enum socket_opcode opcode )
3413 {
3414 switch (opcode)
3415 {
3416 case SOCKET_OPCODE_TEXT:
3417 case SOCKET_OPCODE_BINARY:
3418 case SOCKET_OPCODE_CLOSE:
3419 case SOCKET_OPCODE_PING:
3420 case SOCKET_OPCODE_PONG:
3421 return TRUE;
3422 default:
3423 FIXME( "opcode %02x not handled\n", opcode );
3424 return FALSE;
3425 }
3426 }
3427
3428 static DWORD receive_frame( struct socket *socket, DWORD *ret_len, enum socket_opcode *opcode )
3429 {
3430 DWORD ret, len, count;
3431 char hdr[2];
3432
3433 if ((ret = receive_bytes( socket, hdr, sizeof(hdr), &count, TRUE ))) return ret;
3434 if ((hdr[0] & RESERVED_BIT) || (hdr[1] & MASK_BIT) || !is_supported_opcode( hdr[0] & 0xf ))
3435 {
3436 return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
3437 }
3438 *opcode = hdr[0] & 0xf;
3439 TRACE("received %02x frame\n", *opcode);
3440
3441 len = hdr[1] & ~MASK_BIT;
3442 if (len == 126)
3443 {
3444 USHORT len16;
3445 if ((ret = receive_bytes( socket, (char *)&len16, sizeof(len16), &count, TRUE ))) return ret;
3446 len = RtlUshortByteSwap( len16 );
3447 }
3448 else if (len == 127)
3449 {
3450 ULONGLONG len64;
3451 if ((ret = receive_bytes( socket, (char *)&len64, sizeof(len64), &count, TRUE ))) return ret;
3452 if ((len64 = RtlUlonglongByteSwap( len64 )) > ~0u) return ERROR_NOT_SUPPORTED;
3453 len = len64;
3454 }
3455
3456 *ret_len = len;
3457 return ERROR_SUCCESS;
3458 }
3459
3460 static void CALLBACK task_socket_send_pong( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
3461 {
3462 struct socket_send *s = ctx;
3463
3464 TRACE("running %p\n", work);
3465 send_frame( s->socket, SOCKET_OPCODE_PONG, 0, NULL, 0, TRUE, NULL );
3466 send_io_complete( &s->socket->hdr );
3467
3468 release_object( &s->socket->hdr );
3469 free( s );
3470 }
3471
3472 static DWORD socket_send_pong( struct socket *socket )
3473 {
3474 if (socket->request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3475 {
3476 struct socket_send *s;
3477 DWORD ret;
3478
3479 if (!(s = malloc( sizeof(*s) ))) return ERROR_OUTOFMEMORY;
3480 s->socket = socket;
3481
3482 addref_object( &socket->hdr );
3483 InterlockedIncrement( &socket->hdr.pending_sends );
3484 if ((ret = queue_task( &socket->send_q, task_socket_send_pong, s )))
3485 {
3486 InterlockedDecrement( &socket->hdr.pending_sends );
3487 release_object( &socket->hdr );
3488 free( s );
3489 }
3490 return ret;
3491 }
3492 return send_frame( socket, SOCKET_OPCODE_PONG, 0, NULL, 0, TRUE, NULL );
3493 }
3494
3495 static DWORD socket_drain( struct socket *socket )
3496 {
3497 DWORD ret, count;
3498
3499 while (socket->read_size)
3500 {
3501 char buf[1024];
3502 if ((ret = receive_bytes( socket, buf, min(socket->read_size, sizeof(buf)), &count, TRUE ))) return ret;
3503 socket->read_size -= count;
3504 }
3505 return ERROR_SUCCESS;
3506 }
3507
3508 static DWORD handle_control_frame( struct socket *socket )
3509 {
3510 switch (socket->opcode)
3511 {
3512 case SOCKET_OPCODE_PING:
3513 return socket_send_pong( socket );
3514
3515 case SOCKET_OPCODE_PONG:
3516 return socket_drain( socket );
3517
3518 default:
3519 ERR("unhandled control opcode %02x\n", socket->opcode);
3520 return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
3521 }
3522
3523 return ERROR_SUCCESS;
3524 }
3525
3526 static WINHTTP_WEB_SOCKET_BUFFER_TYPE map_opcode( enum socket_opcode opcode, BOOL fragment )
3527 {
3528 switch (opcode)
3529 {
3530 case SOCKET_OPCODE_TEXT:
3531 if (fragment) return WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE;
3532 return WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE;
3533
3534 case SOCKET_OPCODE_BINARY:
3535 if (fragment) return WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE;
3536 return WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE;
3537
3538 case SOCKET_OPCODE_CLOSE:
3539 return WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE;
3540
3541 default:
3542 FIXME("opcode %02x not handled\n", opcode);
3543 return ~0u;
3544 }
3545 }
3546
3547 static DWORD socket_receive( struct socket *socket, void *buf, DWORD len, DWORD *ret_len,
3548 WINHTTP_WEB_SOCKET_BUFFER_TYPE *ret_type, BOOL async )
3549 {
3550 DWORD count, ret = ERROR_SUCCESS;
3551
3552 if (!socket->read_size)
3553 {
3554 for (;;)
3555 {
3556 if (!(ret = receive_frame( socket, &socket->read_size, &socket->opcode )))
3557 {
3558 if (!(socket->opcode & CONTROL_BIT) || (ret = handle_control_frame( socket ))) break;
3559 }
3560 else if (ret == WSAETIMEDOUT) ret = socket_send_pong( socket );
3561 if (ret) break;
3562 }
3563 }
3564 if (!ret) ret = receive_bytes( socket, buf, min(len, socket->read_size), &count, FALSE );
3565 if (!ret)
3566 {
3567 if (count < socket->read_size)
3568 WARN("Short read.\n");
3569
3570 socket->read_size -= count;
3571 if (!async)
3572 {
3573 *ret_len = count;
3574 *ret_type = map_opcode( socket->opcode, socket->read_size != 0 );
3575 }
3576 }
3577 if (async)
3578 {
3579 if (!ret)
3580 {
3581 WINHTTP_WEB_SOCKET_STATUS status;
3582 status.dwBytesTransferred = count;
3583 status.eBufferType = map_opcode( socket->opcode, socket->read_size != 0 );
3584 send_callback( &socket->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, &status, sizeof(status) );
3585 }
3586 else
3587 {
3588 WINHTTP_WEB_SOCKET_ASYNC_RESULT result;
3589 result.AsyncResult.dwResult = API_READ_DATA;
3590 result.AsyncResult.dwError = ret;
3591 result.Operation = WINHTTP_WEB_SOCKET_RECEIVE_OPERATION;
3592 send_callback( &socket->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
3593 }
3594 }
3595 return ret;
3596 }
3597
3598 static void CALLBACK task_socket_receive( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
3599 {
3600 struct socket_receive *r = ctx;
3601
3602 TRACE("running %p\n", work);
3603 socket_receive( r->socket, r->buf, r->len, NULL, NULL, TRUE );
3604
3605 release_object( &r->socket->hdr );
3606 free( r );
3607 }
3608
3609 DWORD WINAPI WinHttpWebSocketReceive( HINTERNET hsocket, void *buf, DWORD len, DWORD *ret_len,
3610 WINHTTP_WEB_SOCKET_BUFFER_TYPE *ret_type )
3611 {
3612 struct socket *socket;
3613 DWORD ret;
3614
3615 TRACE("%p, %p, %u, %p, %p\n", hsocket, buf, len, ret_len, ret_type);
3616
3617 if (!buf || !len) return ERROR_INVALID_PARAMETER;
3618
3619 if (!(socket = (struct socket *)grab_object( hsocket ))) return ERROR_INVALID_HANDLE;
3620 if (socket->hdr.type != WINHTTP_HANDLE_TYPE_SOCKET)
3621 {
3622 release_object( &socket->hdr );
3623 return ERROR_WINHTTP_INCORRECT_HANDLE_TYPE;
3624 }
3625 if (socket->state > SOCKET_STATE_SHUTDOWN)
3626 {
3627 release_object( &socket->hdr );
3628 return ERROR_INVALID_OPERATION;
3629 }
3630
3631 if (socket->request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3632 {
3633 struct socket_receive *r;
3634
3635 if (!(r = malloc( sizeof(*r) ))) return FALSE;
3636 r->socket = socket;
3637 r->buf = buf;
3638 r->len = len;
3639
3640 addref_object( &socket->hdr );
3641 if ((ret = queue_task( &socket->recv_q, task_socket_receive, r )))
3642 {
3643 release_object( &socket->hdr );
3644 free( r );
3645 }
3646 }
3647 else ret = socket_receive( socket, buf, len, ret_len, ret_type, FALSE );
3648
3649 release_object( &socket->hdr );
3650 return ret;
3651 }
3652
3653 static void CALLBACK task_socket_shutdown( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
3654 {
3655 struct socket_shutdown *s = ctx;
3656 DWORD ret;
3657
3658 TRACE("running %p\n", work);
3659
3660 ret = send_frame( s->socket, SOCKET_OPCODE_CLOSE, s->status, s->reason, s->len, TRUE, NULL );
3661 send_io_complete( &s->socket->hdr );
3662
3663 if (s->send_callback)
3664 {
3665 if (!ret) send_callback( &s->socket->hdr, WINHTTP_CALLBACK_STATUS_SHUTDOWN_COMPLETE, NULL, 0 );
3666 else
3667 {
3668 WINHTTP_WEB_SOCKET_ASYNC_RESULT result;
3669 result.AsyncResult.dwResult = API_WRITE_DATA;
3670 result.AsyncResult.dwError = ret;
3671 result.Operation = WINHTTP_WEB_SOCKET_SHUTDOWN_OPERATION;
3672 send_callback( &s->socket->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
3673 }
3674 }
3675 release_object( &s->socket->hdr );
3676 free( s );
3677 }
3678
3679 static DWORD send_socket_shutdown( struct socket *socket, USHORT status, const void *reason, DWORD len,
3680 BOOL send_callback)
3681 {
3682 DWORD ret;
3683
3684 socket->state = SOCKET_STATE_SHUTDOWN;
3685
3686 if (socket->request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3687 {
3688 struct socket_shutdown *s;
3689
3690 if (!(s = malloc( sizeof(*s) ))) return FALSE;
3691 s->socket = socket;
3692 s->status = status;
3693 memcpy( s->reason, reason, len );
3694 s->len = len;
3695 s->send_callback = send_callback;
3696
3697 addref_object( &socket->hdr );
3698 InterlockedIncrement( &socket->hdr.pending_sends );
3699 if ((ret = queue_task( &socket->send_q, task_socket_shutdown, s )))
3700 {
3701 InterlockedDecrement( &socket->hdr.pending_sends );
3702 release_object( &socket->hdr );
3703 free( s );
3704 }
3705 }
3706 else ret = send_frame( socket, SOCKET_OPCODE_CLOSE, status, reason, len, TRUE, NULL );
3707
3708 return ret;
3709 }
3710
3711 DWORD WINAPI WinHttpWebSocketShutdown( HINTERNET hsocket, USHORT status, void *reason, DWORD len )
3712 {
3713 struct socket *socket;
3714 DWORD ret;
3715
3716 TRACE("%p, %u, %p, %u\n", hsocket, status, reason, len);
3717
3718 if ((len && !reason) || len > sizeof(socket->reason)) return ERROR_INVALID_PARAMETER;
3719
3720 if (!(socket = (struct socket *)grab_object( hsocket ))) return ERROR_INVALID_HANDLE;
3721 if (socket->hdr.type != WINHTTP_HANDLE_TYPE_SOCKET)
3722 {
3723 release_object( &socket->hdr );
3724 return ERROR_WINHTTP_INCORRECT_HANDLE_TYPE;
3725 }
3726 if (socket->state >= SOCKET_STATE_SHUTDOWN)
3727 {
3728 release_object( &socket->hdr );
3729 return ERROR_INVALID_OPERATION;
3730 }
3731
3732 ret = send_socket_shutdown( socket, status, reason, len, TRUE );
3733 release_object( &socket->hdr );
3734 return ret;
3735 }
3736
3737 static DWORD socket_close( struct socket *socket )
3738 {
3739 DWORD ret, count;
3740
3741 if ((ret = socket_drain( socket ))) return ret;
3742
3743 while (1)
3744 {
3745 if ((ret = receive_frame( socket, &count, &socket->opcode ))) return ret;
3746 if (socket->opcode == SOCKET_OPCODE_CLOSE) break;
3747
3748 socket->read_size = count;
3749 if ((ret = socket_drain( socket ))) return ret;
3750 }
3751
3752 if ((count && (count < sizeof(socket->status) || count > sizeof(socket->status) + sizeof(socket->reason))))
3753 return ERROR_WINHTTP_INVALID_SERVER_RESPONSE;
3754
3755 if (count)
3756 {
3757 DWORD reason_len = count - sizeof(socket->status);
3758 if ((ret = receive_bytes( socket, (char *)&socket->status, sizeof(socket->status), &count, TRUE ))) return ret;
3759 socket->status = RtlUshortByteSwap( socket->status );
3760 if ((ret = receive_bytes( socket, socket->reason, reason_len, &socket->reason_len, TRUE ))) return ret;
3761 }
3762 socket->state = SOCKET_STATE_CLOSED;
3763
3764 return ERROR_SUCCESS;
3765 }
3766
3767 static void CALLBACK task_socket_close( TP_CALLBACK_INSTANCE *instance, void *ctx, TP_WORK *work )
3768 {
3769 struct socket_shutdown *s = ctx;
3770 DWORD ret;
3771
3772 ret = socket_close( s->socket );
3773
3774 if (!ret) send_callback( &s->socket->hdr, WINHTTP_CALLBACK_STATUS_CLOSE_COMPLETE, NULL, 0 );
3775 else
3776 {
3777 WINHTTP_WEB_SOCKET_ASYNC_RESULT result;
3778 result.AsyncResult.dwResult = API_READ_DATA; /* FIXME */
3779 result.AsyncResult.dwError = ret;
3780 result.Operation = WINHTTP_WEB_SOCKET_CLOSE_OPERATION;
3781 send_callback( &s->socket->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR, &result, sizeof(result) );
3782 }
3783
3784 TRACE("running %p\n", work);
3785 release_object( &s->socket->hdr );
3786 free( s );
3787 }
3788
3789 DWORD WINAPI WinHttpWebSocketClose( HINTERNET hsocket, USHORT status, void *reason, DWORD len )
3790 {
3791 struct socket *socket;
3792 DWORD ret;
3793
3794 TRACE("%p, %u, %p, %u\n", hsocket, status, reason, len);
3795
3796 if ((len && !reason) || len > sizeof(socket->reason)) return ERROR_INVALID_PARAMETER;
3797
3798 if (!(socket = (struct socket *)grab_object( hsocket ))) return ERROR_INVALID_HANDLE;
3799 if (socket->hdr.type != WINHTTP_HANDLE_TYPE_SOCKET)
3800 {
3801 release_object( &socket->hdr );
3802 return ERROR_WINHTTP_INCORRECT_HANDLE_TYPE;
3803 }
3804 if (socket->state >= SOCKET_STATE_CLOSED)
3805 {
3806 release_object( &socket->hdr );
3807 return ERROR_INVALID_OPERATION;
3808 }
3809
3810 if (socket->state < SOCKET_STATE_SHUTDOWN
3811 && (ret = send_socket_shutdown( socket, status, reason, len, FALSE ))) goto done;
3812
3813 if (socket->request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
3814 {
3815 struct socket_shutdown *s;
3816
3817 if (!(s = calloc( 1, sizeof(*s) ))) return FALSE;
3818 s->socket = socket;
3819
3820 addref_object( &socket->hdr );
3821 if ((ret = queue_task( &socket->recv_q, task_socket_close, s )))
3822 {
3823 release_object( &socket->hdr );
3824 free( s );
3825 }
3826 }
3827 else ret = socket_close( socket );
3828
3829 done:
3830 release_object( &socket->hdr );
3831 return ret;
3832 }
3833
3834 DWORD WINAPI WinHttpWebSocketQueryCloseStatus( HINTERNET hsocket, USHORT *status, void *reason, DWORD len,
3835 DWORD *ret_len )
3836 {
3837 struct socket *socket;
3838 DWORD ret;
3839
3840 TRACE("%p, %p, %p, %u, %p\n", hsocket, status, reason, len, ret_len);
3841
3842 if (!status || (len && !reason) || !ret_len) return ERROR_INVALID_PARAMETER;
3843
3844 if (!(socket = (struct socket *)grab_object( hsocket ))) return ERROR_INVALID_HANDLE;
3845 if (socket->hdr.type != WINHTTP_HANDLE_TYPE_SOCKET)
3846 {
3847 release_object( &socket->hdr );
3848 return ERROR_WINHTTP_INCORRECT_HANDLE_TYPE;
3849 }
3850 if (socket->state < SOCKET_STATE_CLOSED)
3851 {
3852 release_object( &socket->hdr );
3853 return ERROR_INVALID_OPERATION;
3854 }
3855
3856 *status = socket->status;
3857 *ret_len = socket->reason_len;
3858 if (socket->reason_len > len) ret = ERROR_INSUFFICIENT_BUFFER;
3859 else
3860 {
3861 memcpy( reason, socket->reason, socket->reason_len );
3862 ret = ERROR_SUCCESS;
3863 }
3864
3865 release_object( &socket->hdr );
3866 return ret;
3867 }
3868
3869 enum request_state
3870 {
3871 REQUEST_STATE_INITIALIZED,
3872 REQUEST_STATE_CANCELLED,
3873 REQUEST_STATE_OPEN,
3874 REQUEST_STATE_SENT,
3875 REQUEST_STATE_RESPONSE_RECEIVED
3876 };
3877
3878 struct winhttp_request
3879 {
3880 IWinHttpRequest IWinHttpRequest_iface;
3881 LONG refs;
3882 CRITICAL_SECTION cs;
3883 enum request_state state;
3884 HINTERNET hsession;
3885 HINTERNET hconnect;
3886 HINTERNET hrequest;
3887 VARIANT data;
3888 WCHAR *verb;
3889 HANDLE done;
3890 HANDLE wait;
3891 HANDLE cancel;
3892 BOOL proc_running;
3893 char *buffer;
3894 DWORD offset;
3895 DWORD bytes_available;
3896 DWORD bytes_read;
3897 DWORD error;
3898 DWORD logon_policy;
3899 DWORD disable_feature;
3900 LONG resolve_timeout;
3901 LONG connect_timeout;
3902 LONG send_timeout;
3903 LONG receive_timeout;
3904 WINHTTP_PROXY_INFO proxy;
3905 BOOL async;
3906 UINT url_codepage;
3907 };
3908
3909 static inline struct winhttp_request *impl_from_IWinHttpRequest( IWinHttpRequest *iface )
3910 {
3911 return CONTAINING_RECORD( iface, struct winhttp_request, IWinHttpRequest_iface );
3912 }
3913
3914 static ULONG WINAPI winhttp_request_AddRef(
3915 IWinHttpRequest *iface )
3916 {
3917 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3918 return InterlockedIncrement( &request->refs );
3919 }
3920
3921 /* critical section must be held */
3922 static void cancel_request( struct winhttp_request *request )
3923 {
3924 if (request->state <= REQUEST_STATE_CANCELLED) return;
3925
3926 if (request->proc_running)
3927 {
3928 SetEvent( request->cancel );
3929 LeaveCriticalSection( &request->cs );
3930
3931 WaitForSingleObject( request->done, INFINITE );
3932
3933 EnterCriticalSection( &request->cs );
3934 }
3935 request->state = REQUEST_STATE_CANCELLED;
3936 }
3937
3938 /* critical section must be held */
3939 static void free_request( struct winhttp_request *request )
3940 {
3941 if (request->state < REQUEST_STATE_INITIALIZED) return;
3942 WinHttpCloseHandle( request->hrequest );
3943 WinHttpCloseHandle( request->hconnect );
3944 WinHttpCloseHandle( request->hsession );
3945 CloseHandle( request->done );
3946 CloseHandle( request->wait );
3947 CloseHandle( request->cancel );
3948 free( request->proxy.lpszProxy );
3949 free( request->proxy.lpszProxyBypass );
3950 free( request->buffer );
3951 free( request->verb );
3952 VariantClear( &request->data );
3953 }
3954
3955 static ULONG WINAPI winhttp_request_Release(
3956 IWinHttpRequest *iface )
3957 {
3958 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3959 LONG refs = InterlockedDecrement( &request->refs );
3960 if (!refs)
3961 {
3962 TRACE("destroying %p\n", request);
3963
3964 EnterCriticalSection( &request->cs );
3965 cancel_request( request );
3966 free_request( request );
3967 LeaveCriticalSection( &request->cs );
3968 request->cs.DebugInfo->Spare[0] = 0;
3969 DeleteCriticalSection( &request->cs );
3970 free( request );
3971 }
3972 return refs;
3973 }
3974
3975 static HRESULT WINAPI winhttp_request_QueryInterface(
3976 IWinHttpRequest *iface,
3977 REFIID riid,
3978 void **obj )
3979 {
3980 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
3981
3982 TRACE("%p, %s, %p\n", request, debugstr_guid(riid), obj );
3983
3984 if (IsEqualGUID( riid, &IID_IWinHttpRequest ) ||
3985 IsEqualGUID( riid, &IID_IDispatch ) ||
3986 IsEqualGUID( riid, &IID_IUnknown ))
3987 {
3988 *obj = iface;
3989 }
3990 else
3991 {
3992 FIXME("interface %s not implemented\n", debugstr_guid(riid));
3993 return E_NOINTERFACE;
3994 }
3995 IWinHttpRequest_AddRef( iface );
3996 return S_OK;
3997 }
3998
3999 static HRESULT WINAPI winhttp_request_GetTypeInfoCount(
4000 IWinHttpRequest *iface,
4001 UINT *count )
4002 {
4003 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4004
4005 TRACE("%p, %p\n", request, count);
4006 *count = 1;
4007 return S_OK;
4008 }
4009
4010 enum type_id
4011 {
4012 IWinHttpRequest_tid,
4013 last_tid
4014 };
4015
4016 static ITypeLib *winhttp_typelib;
4017 static ITypeInfo *winhttp_typeinfo[last_tid];
4018
4019 static REFIID winhttp_tid_id[] =
4020 {
4021 &IID_IWinHttpRequest
4022 };
4023
4024 static HRESULT get_typeinfo( enum type_id tid, ITypeInfo **ret )
4025 {
4026 HRESULT hr;
4027
4028 if (!winhttp_typelib)
4029 {
4030 ITypeLib *typelib;
4031
4032 hr = LoadRegTypeLib( &LIBID_WinHttp, 5, 1, LOCALE_SYSTEM_DEFAULT, &typelib );
4033 if (FAILED(hr))
4034 {
4035 ERR("LoadRegTypeLib failed: %08x\n", hr);
4036 return hr;
4037 }
4038 if (InterlockedCompareExchangePointer( (void **)&winhttp_typelib, typelib, NULL ))
4039 ITypeLib_Release( typelib );
4040 }
4041 if (!winhttp_typeinfo[tid])
4042 {
4043 ITypeInfo *typeinfo;
4044
4045 hr = ITypeLib_GetTypeInfoOfGuid( winhttp_typelib, winhttp_tid_id[tid], &typeinfo );
4046 if (FAILED(hr))
4047 {
4048 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(winhttp_tid_id[tid]), hr);
4049 return hr;
4050 }
4051 if (InterlockedCompareExchangePointer( (void **)(winhttp_typeinfo + tid), typeinfo, NULL ))
4052 ITypeInfo_Release( typeinfo );
4053 }
4054 *ret = winhttp_typeinfo[tid];
4055 ITypeInfo_AddRef(winhttp_typeinfo[tid]);
4056 return S_OK;
4057 }
4058
4059 void release_typelib(void)
4060 {
4061 unsigned i;
4062
4063 for (i = 0; i < ARRAY_SIZE(winhttp_typeinfo); i++)
4064 if (winhttp_typeinfo[i])
4065 ITypeInfo_Release(winhttp_typeinfo[i]);
4066
4067 if (winhttp_typelib)
4068 ITypeLib_Release(winhttp_typelib);
4069 }
4070
4071 static HRESULT WINAPI winhttp_request_GetTypeInfo(
4072 IWinHttpRequest *iface,
4073 UINT index,
4074 LCID lcid,
4075 ITypeInfo **info )
4076 {
4077 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4078 TRACE("%p, %u, %u, %p\n", request, index, lcid, info);
4079
4080 return get_typeinfo( IWinHttpRequest_tid, info );
4081 }
4082
4083 static HRESULT WINAPI winhttp_request_GetIDsOfNames(
4084 IWinHttpRequest *iface,
4085 REFIID riid,
4086 LPOLESTR *names,
4087 UINT count,
4088 LCID lcid,
4089 DISPID *dispid )
4090 {
4091 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4092 ITypeInfo *typeinfo;
4093 HRESULT hr;
4094
4095 TRACE("%p, %s, %p, %u, %u, %p\n", request, debugstr_guid(riid), names, count, lcid, dispid);
4096
4097 if (!names || !count || !dispid) return E_INVALIDARG;
4098
4099 hr = get_typeinfo( IWinHttpRequest_tid, &typeinfo );
4100 if (SUCCEEDED(hr))
4101 {
4102 hr = ITypeInfo_GetIDsOfNames( typeinfo, names, count, dispid );
4103 ITypeInfo_Release( typeinfo );
4104 }
4105 return hr;
4106 }
4107
4108 static HRESULT WINAPI winhttp_request_Invoke(
4109 IWinHttpRequest *iface,
4110 DISPID member,
4111 REFIID riid,
4112 LCID lcid,
4113 WORD flags,
4114 DISPPARAMS *params,
4115 VARIANT *result,
4116 EXCEPINFO *excep_info,
4117 UINT *arg_err )
4118 {
4119 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4120 ITypeInfo *typeinfo;
4121 HRESULT hr;
4122
4123 TRACE("%p, %d, %s, %d, %d, %p, %p, %p, %p\n", request, member, debugstr_guid(riid),
4124 lcid, flags, params, result, excep_info, arg_err);
4125
4126 if (!IsEqualIID( riid, &IID_NULL )) return DISP_E_UNKNOWNINTERFACE;
4127
4128 if (member == DISPID_HTTPREQUEST_OPTION)
4129 {
4130 VARIANT ret_value, option;
4131 UINT err_pos;
4132
4133 if (!result) result = &ret_value;
4134 if (!arg_err) arg_err = &err_pos;
4135
4136 VariantInit( &option );
4137 VariantInit( result );
4138
4139 if (!flags) return S_OK;
4140
4141 if (flags == DISPATCH_PROPERTYPUT)
4142 {
4143 hr = DispGetParam( params, 0, VT_I4, &option, arg_err );
4144 if (FAILED(hr)) return hr;
4145
4146 hr = IWinHttpRequest_put_Option( &request->IWinHttpRequest_iface, V_I4( &option ), params->rgvarg[0] );
4147 if (FAILED(hr))
4148 WARN("put_Option(%d) failed: %x\n", V_I4( &option ), hr);
4149 return hr;
4150 }
4151 else if (flags & (DISPATCH_PROPERTYGET | DISPATCH_METHOD))
4152 {
4153 hr = DispGetParam( params, 0, VT_I4, &option, arg_err );
4154 if (FAILED(hr)) return hr;
4155
4156 hr = IWinHttpRequest_get_Option( &request->IWinHttpRequest_iface, V_I4( &option ), result );
4157 if (FAILED(hr))
4158 WARN("get_Option(%d) failed: %x\n", V_I4( &option ), hr);
4159 return hr;
4160 }
4161
4162 FIXME("unsupported flags %x\n", flags);
4163 return E_NOTIMPL;
4164 }
4165
4166 /* fallback to standard implementation */
4167
4168 hr = get_typeinfo( IWinHttpRequest_tid, &typeinfo );
4169 if (SUCCEEDED(hr))
4170 {
4171 hr = ITypeInfo_Invoke( typeinfo, &request->IWinHttpRequest_iface, member, flags,
4172 params, result, excep_info, arg_err );
4173 ITypeInfo_Release( typeinfo );
4174 }
4175 return hr;
4176 }
4177
4178 static HRESULT WINAPI winhttp_request_SetProxy(
4179 IWinHttpRequest *iface,
4180 HTTPREQUEST_PROXY_SETTING proxy_setting,
4181 VARIANT proxy_server,
4182 VARIANT bypass_list )
4183 {
4184 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4185 DWORD err = ERROR_SUCCESS;
4186
4187 TRACE("%p, %u, %s, %s\n", request, proxy_setting, debugstr_variant(&proxy_server),
4188 debugstr_variant(&bypass_list));
4189
4190 EnterCriticalSection( &request->cs );
4191 switch (proxy_setting)
4192 {
4193 case HTTPREQUEST_PROXYSETTING_DEFAULT:
4194 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
4195 free( request->proxy.lpszProxy );
4196 free( request->proxy.lpszProxyBypass );
4197 request->proxy.lpszProxy = NULL;
4198 request->proxy.lpszProxyBypass = NULL;
4199 break;
4200
4201 case HTTPREQUEST_PROXYSETTING_DIRECT:
4202 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
4203 free( request->proxy.lpszProxy );
4204 free( request->proxy.lpszProxyBypass );
4205 request->proxy.lpszProxy = NULL;
4206 request->proxy.lpszProxyBypass = NULL;
4207 break;
4208
4209 case HTTPREQUEST_PROXYSETTING_PROXY:
4210 request->proxy.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
4211 if (V_VT( &proxy_server ) == VT_BSTR)
4212 {
4213 free( request->proxy.lpszProxy );
4214 request->proxy.lpszProxy = strdupW( V_BSTR( &proxy_server ) );
4215 }
4216 if (V_VT( &bypass_list ) == VT_BSTR)
4217 {
4218 free( request->proxy.lpszProxyBypass );
4219 request->proxy.lpszProxyBypass = strdupW( V_BSTR( &bypass_list ) );
4220 }
4221 break;
4222
4223 default:
4224 err = ERROR_INVALID_PARAMETER;
4225 break;
4226 }
4227 LeaveCriticalSection( &request->cs );
4228 return HRESULT_FROM_WIN32( err );
4229 }
4230
4231 static HRESULT WINAPI winhttp_request_SetCredentials(
4232 IWinHttpRequest *iface,
4233 BSTR username,
4234 BSTR password,
4235 HTTPREQUEST_SETCREDENTIALS_FLAGS flags )
4236 {
4237 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4238 DWORD target, scheme = WINHTTP_AUTH_SCHEME_BASIC; /* FIXME: query supported schemes */
4239 DWORD err = ERROR_SUCCESS;
4240
4241 TRACE("%p, %s, %p, 0x%08x\n", request, debugstr_w(username), password, flags);
4242
4243 EnterCriticalSection( &request->cs );
4244 if (request->state < REQUEST_STATE_OPEN)
4245 {
4246 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN;
4247 goto done;
4248 }
4249 switch (flags)
4250 {
4251 case HTTPREQUEST_SETCREDENTIALS_FOR_SERVER:
4252 target = WINHTTP_AUTH_TARGET_SERVER;
4253 break;
4254 case HTTPREQUEST_SETCREDENTIALS_FOR_PROXY:
4255 target = WINHTTP_AUTH_TARGET_PROXY;
4256 break;
4257 default:
4258 err = ERROR_INVALID_PARAMETER;
4259 goto done;
4260 }
4261 if (!WinHttpSetCredentials( request->hrequest, target, scheme, username, password, NULL ))
4262 {
4263 err = GetLastError();
4264 }
4265 done:
4266 LeaveCriticalSection( &request->cs );
4267 return HRESULT_FROM_WIN32( err );
4268 }
4269
4270 static void initialize_request( struct winhttp_request *request )
4271 {
4272 request->wait = CreateEventW( NULL, FALSE, FALSE, NULL );
4273 request->cancel = CreateEventW( NULL, FALSE, FALSE, NULL );
4274 request->done = CreateEventW( NULL, FALSE, FALSE, NULL );
4275 request->connect_timeout = 60000;
4276 request->send_timeout = 30000;
4277 request->receive_timeout = 30000;
4278 request->url_codepage = CP_UTF8;
4279 VariantInit( &request->data );
4280 request->state = REQUEST_STATE_INITIALIZED;
4281 }
4282
4283 static void reset_request( struct winhttp_request *request )
4284 {
4285 cancel_request( request );
4286 WinHttpCloseHandle( request->hrequest );
4287 request->hrequest = NULL;
4288 WinHttpCloseHandle( request->hconnect );
4289 request->hconnect = NULL;
4290 free( request->buffer );
4291 request->buffer = NULL;
4292 free( request->verb );
4293 request->verb = NULL;
4294 request->offset = 0;
4295 request->bytes_available = 0;
4296 request->bytes_read = 0;
4297 request->error = ERROR_SUCCESS;
4298 request->logon_policy = 0;
4299 request->disable_feature = 0;
4300 request->async = FALSE;
4301 request->connect_timeout = 60000;
4302 request->send_timeout = 30000;
4303 request->receive_timeout = 30000;
4304 request->url_codepage = CP_UTF8;
4305 free( request->proxy.lpszProxy );
4306 request->proxy.lpszProxy = NULL;
4307 free( request->proxy.lpszProxyBypass );
4308 request->proxy.lpszProxyBypass = NULL;
4309 VariantClear( &request->data );
4310 request->state = REQUEST_STATE_INITIALIZED;
4311 }
4312
4313 static HRESULT WINAPI winhttp_request_Open(
4314 IWinHttpRequest *iface,
4315 BSTR method,
4316 BSTR url,
4317 VARIANT async )
4318 {
4319 static const WCHAR httpsW[] = {'h','t','t','p','s'};
4320 static const WCHAR *acceptW[] = {L"*/*", NULL};
4321 static const WCHAR user_agentW[] = L"Mozilla/4.0 (compatible; Win32; WinHttp.WinHttpRequest.5)";
4322 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4323 URL_COMPONENTS uc;
4324 WCHAR *hostname, *path = NULL, *verb = NULL;
4325 DWORD err = ERROR_OUTOFMEMORY, len, flags = 0;
4326
4327 TRACE("%p, %s, %s, %s\n", request, debugstr_w(method), debugstr_w(url),
4328 debugstr_variant(&async));
4329
4330 if (!method || !url) return E_INVALIDARG;
4331
4332 memset( &uc, 0, sizeof(uc) );
4333 uc.dwStructSize = sizeof(uc);
4334 uc.dwSchemeLength = ~0u;
4335 uc.dwHostNameLength = ~0u;
4336 uc.dwUrlPathLength = ~0u;
4337 uc.dwExtraInfoLength = ~0u;
4338 if (!WinHttpCrackUrl( url, 0, 0, &uc )) return HRESULT_FROM_WIN32( GetLastError() );
4339
4340 EnterCriticalSection( &request->cs );
4341 reset_request( request );
4342
4343 if (!(hostname = malloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) goto error;
4344 memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
4345 hostname[uc.dwHostNameLength] = 0;
4346
4347 if (!(path = malloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) ))) goto error;
4348 memcpy( path, uc.lpszUrlPath, (uc.dwUrlPathLength + uc.dwExtraInfoLength) * sizeof(WCHAR) );
4349 path[uc.dwUrlPathLength + uc.dwExtraInfoLength] = 0;
4350
4351 if (!(verb = strdupW( method ))) goto error;
4352 if (SUCCEEDED( VariantChangeType( &async, &async, 0, VT_BOOL )) && V_BOOL( &async )) request->async = TRUE;
4353 else request->async = FALSE;
4354
4355 if (!request->hsession)
4356 {
4357 if (!(request->hsession = WinHttpOpen( user_agentW, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, NULL, NULL,
4358 WINHTTP_FLAG_ASYNC )))
4359 {
4360 err = GetLastError();
4361 goto error;
4362 }
4363 if (!(request->hconnect = WinHttpConnect( request->hsession, hostname, uc.nPort, 0 )))
4364 {
4365 WinHttpCloseHandle( request->hsession );
4366 request->hsession = NULL;
4367 err = GetLastError();
4368 goto error;
4369 }
4370 }
4371 else if (!(request->hconnect = WinHttpConnect( request->hsession, hostname, uc.nPort, 0 )))
4372 {
4373 err = GetLastError();
4374 goto error;
4375 }
4376
4377 len = ARRAY_SIZE( httpsW );
4378 if (uc.dwSchemeLength == len && !memcmp( uc.lpszScheme, httpsW, len * sizeof(WCHAR) ))
4379 {
4380 flags |= WINHTTP_FLAG_SECURE;
4381 }
4382 if (!(request->hrequest = WinHttpOpenRequest( request->hconnect, method, path, NULL, NULL, acceptW, flags )))
4383 {
4384 err = GetLastError();
4385 goto error;
4386 }
4387 WinHttpSetOption( request->hrequest, WINHTTP_OPTION_CONTEXT_VALUE, &request, sizeof(request) );
4388
4389 request->state = REQUEST_STATE_OPEN;
4390 request->verb = verb;
4391 free( hostname );
4392 free( path );
4393 LeaveCriticalSection( &request->cs );
4394 return S_OK;
4395
4396 error:
4397 WinHttpCloseHandle( request->hconnect );
4398 request->hconnect = NULL;
4399 free( hostname );
4400 free( path );
4401 free( verb );
4402 LeaveCriticalSection( &request->cs );
4403 return HRESULT_FROM_WIN32( err );
4404 }
4405
4406 static HRESULT WINAPI winhttp_request_SetRequestHeader(
4407 IWinHttpRequest *iface,
4408 BSTR header,
4409 BSTR value )
4410 {
4411 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4412 DWORD len, err = ERROR_SUCCESS;
4413 WCHAR *str;
4414
4415 TRACE("%p, %s, %s\n", request, debugstr_w(header), debugstr_w(value));
4416
4417 if (!header) return E_INVALIDARG;
4418
4419 EnterCriticalSection( &request->cs );
4420 if (request->state < REQUEST_STATE_OPEN)
4421 {
4422 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN;
4423 goto done;
4424 }
4425 if (request->state >= REQUEST_STATE_SENT)
4426 {
4427 err = ERROR_WINHTTP_CANNOT_CALL_AFTER_SEND;
4428 goto done;
4429 }
4430 len = lstrlenW( header ) + 4;
4431 if (value) len += lstrlenW( value );
4432 if (!(str = malloc( (len + 1) * sizeof(WCHAR) )))
4433 {
4434 err = ERROR_OUTOFMEMORY;
4435 goto done;
4436 }
4437 swprintf( str, len + 1, L"%s: %s\r\n", header, value ? value : L"" );
4438 if (!WinHttpAddRequestHeaders( request->hrequest, str, len,
4439 WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))
4440 {
4441 err = GetLastError();
4442 }
4443 free( str );
4444
4445 done:
4446 LeaveCriticalSection( &request->cs );
4447 return HRESULT_FROM_WIN32( err );
4448 }
4449
4450 static HRESULT WINAPI winhttp_request_GetResponseHeader(
4451 IWinHttpRequest *iface,
4452 BSTR header,
4453 BSTR *value )
4454 {
4455 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4456 DWORD size, err = ERROR_SUCCESS;
4457
4458 TRACE("%p, %p\n", request, header);
4459
4460 EnterCriticalSection( &request->cs );
4461 if (request->state < REQUEST_STATE_SENT)
4462 {
4463 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4464 goto done;
4465 }
4466 if (!header || !value)
4467 {
4468 err = ERROR_INVALID_PARAMETER;
4469 goto done;
4470 }
4471 size = 0;
4472 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CUSTOM, header, NULL, &size, NULL ))
4473 {
4474 err = GetLastError();
4475 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
4476 }
4477 if (!(*value = SysAllocStringLen( NULL, size / sizeof(WCHAR) )))
4478 {
4479 err = ERROR_OUTOFMEMORY;
4480 goto done;
4481 }
4482 err = ERROR_SUCCESS;
4483 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CUSTOM, header, *value, &size, NULL ))
4484 {
4485 err = GetLastError();
4486 SysFreeString( *value );
4487 }
4488 done:
4489 LeaveCriticalSection( &request->cs );
4490 return HRESULT_FROM_WIN32( err );
4491 }
4492
4493 static HRESULT WINAPI winhttp_request_GetAllResponseHeaders(
4494 IWinHttpRequest *iface,
4495 BSTR *headers )
4496 {
4497 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4498 DWORD size, err = ERROR_SUCCESS;
4499
4500 TRACE("%p, %p\n", request, headers);
4501
4502 if (!headers) return E_INVALIDARG;
4503
4504 EnterCriticalSection( &request->cs );
4505 if (request->state < REQUEST_STATE_SENT)
4506 {
4507 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4508 goto done;
4509 }
4510 size = 0;
4511 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, NULL, NULL, &size, NULL ))
4512 {
4513 err = GetLastError();
4514 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
4515 }
4516 if (!(*headers = SysAllocStringLen( NULL, size / sizeof(WCHAR) )))
4517 {
4518 err = ERROR_OUTOFMEMORY;
4519 goto done;
4520 }
4521 err = ERROR_SUCCESS;
4522 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_RAW_HEADERS_CRLF, NULL, *headers, &size, NULL ))
4523 {
4524 err = GetLastError();
4525 SysFreeString( *headers );
4526 }
4527 done:
4528 LeaveCriticalSection( &request->cs );
4529 return HRESULT_FROM_WIN32( err );
4530 }
4531
4532 static void CALLBACK wait_status_callback( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD size )
4533 {
4534 struct winhttp_request *request = (struct winhttp_request *)context;
4535
4536 switch (status)
4537 {
4538 case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE:
4539 request->bytes_available = *(DWORD *)buffer;
4540 request->error = ERROR_SUCCESS;
4541 break;
4542 case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
4543 request->bytes_read = size;
4544 request->error = ERROR_SUCCESS;
4545 break;
4546 case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
4547 {
4548 WINHTTP_ASYNC_RESULT *result = (WINHTTP_ASYNC_RESULT *)buffer;
4549 request->error = result->dwError;
4550 break;
4551 }
4552 default:
4553 request->error = ERROR_SUCCESS;
4554 break;
4555 }
4556 SetEvent( request->wait );
4557 }
4558
4559 static void wait_set_status_callback( struct winhttp_request *request, DWORD status )
4560 {
4561 status |= WINHTTP_CALLBACK_STATUS_REQUEST_ERROR;
4562 WinHttpSetStatusCallback( request->hrequest, wait_status_callback, status, 0 );
4563 }
4564
4565 static DWORD wait_for_completion( struct winhttp_request *request )
4566 {
4567 HANDLE handles[2] = { request->wait, request->cancel };
4568 DWORD ret;
4569
4570 switch (WaitForMultipleObjects( 2, handles, FALSE, INFINITE ))
4571 {
4572 case WAIT_OBJECT_0:
4573 ret = request->error;
4574 break;
4575 case WAIT_OBJECT_0 + 1:
4576 ret = request->error = ERROR_CANCELLED;
4577 SetEvent( request->done );
4578 break;
4579 default:
4580 ret = request->error = GetLastError();
4581 break;
4582 }
4583 return ret;
4584 }
4585
4586 static HRESULT request_receive( struct winhttp_request *request )
4587 {
4588 DWORD err, size, buflen = 4096;
4589
4590 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE );
4591 if (!WinHttpReceiveResponse( request->hrequest, NULL ))
4592 {
4593 return HRESULT_FROM_WIN32( GetLastError() );
4594 }
4595 if ((err = wait_for_completion( request ))) return HRESULT_FROM_WIN32( err );
4596 if (!wcscmp( request->verb, L"HEAD" ))
4597 {
4598 request->state = REQUEST_STATE_RESPONSE_RECEIVED;
4599 return S_OK;
4600 }
4601 if (!(request->buffer = malloc( buflen ))) return E_OUTOFMEMORY;
4602 request->buffer[0] = 0;
4603 size = 0;
4604 do
4605 {
4606 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE );
4607 if (!WinHttpQueryDataAvailable( request->hrequest, &request->bytes_available ))
4608 {
4609 err = GetLastError();
4610 goto error;
4611 }
4612 if ((err = wait_for_completion( request ))) goto error;
4613 if (!request->bytes_available) break;
4614 size += request->bytes_available;
4615 if (buflen < size)
4616 {
4617 char *tmp;
4618 while (buflen < size) buflen *= 2;
4619 if (!(tmp = realloc( request->buffer, buflen )))
4620 {
4621 err = ERROR_OUTOFMEMORY;
4622 goto error;
4623 }
4624 request->buffer = tmp;
4625 }
4626 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_READ_COMPLETE );
4627 if (!WinHttpReadData( request->hrequest, request->buffer + request->offset,
4628 request->bytes_available, &request->bytes_read ))
4629 {
4630 err = GetLastError();
4631 goto error;
4632 }
4633 if ((err = wait_for_completion( request ))) goto error;
4634 request->offset += request->bytes_read;
4635 } while (request->bytes_read);
4636
4637 request->state = REQUEST_STATE_RESPONSE_RECEIVED;
4638 return S_OK;
4639
4640 error:
4641 free( request->buffer );
4642 request->buffer = NULL;
4643 return HRESULT_FROM_WIN32( err );
4644 }
4645
4646 static DWORD request_set_parameters( struct winhttp_request *request )
4647 {
4648 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_PROXY, &request->proxy,
4649 sizeof(request->proxy) )) return GetLastError();
4650
4651 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_AUTOLOGON_POLICY, &request->logon_policy,
4652 sizeof(request->logon_policy) )) return GetLastError();
4653
4654 if (!WinHttpSetOption( request->hrequest, WINHTTP_OPTION_DISABLE_FEATURE, &request->disable_feature,
4655 sizeof(request->disable_feature) )) return GetLastError();
4656
4657 if (!WinHttpSetTimeouts( request->hrequest,
4658 request->resolve_timeout,
4659 request->connect_timeout,
4660 request->send_timeout,
4661 request->receive_timeout )) return GetLastError();
4662 return ERROR_SUCCESS;
4663 }
4664
4665 static void request_set_utf8_content_type( struct winhttp_request *request )
4666 {
4667 WCHAR headerW[64];
4668 int len;
4669
4670 len = swprintf( headerW, ARRAY_SIZE(headerW), L"%s: %s", L"Content-Type", L"text/plain" );
4671 WinHttpAddRequestHeaders( request->hrequest, headerW, len, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
4672
4673 len = swprintf( headerW, ARRAY_SIZE(headerW), L"%s: %s", L"Content-Type", L"charset=utf-8" );
4674 WinHttpAddRequestHeaders( request->hrequest, headerW, len, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON );
4675 }
4676
4677 static HRESULT request_send( struct winhttp_request *request )
4678 {
4679 SAFEARRAY *sa = NULL;
4680 VARIANT data;
4681 char *ptr = NULL;
4682 LONG size = 0;
4683 HRESULT hr;
4684 DWORD err;
4685
4686 if ((err = request_set_parameters( request ))) return HRESULT_FROM_WIN32( err );
4687 if (wcscmp( request->verb, L"GET" ))
4688 {
4689 VariantInit( &data );
4690 if (V_VT( &request->data ) == VT_BSTR)
4691 {
4692 UINT cp = CP_ACP;
4693 const WCHAR *str = V_BSTR( &request->data );
4694 int i, len = lstrlenW( str );
4695
4696 for (i = 0; i < len; i++)
4697 {
4698 if (str[i] > 127)
4699 {
4700 cp = CP_UTF8;
4701 break;
4702 }
4703 }
4704 size = WideCharToMultiByte( cp, 0, str, len, NULL, 0, NULL, NULL );
4705 if (!(ptr = malloc( size ))) return E_OUTOFMEMORY;
4706 WideCharToMultiByte( cp, 0, str, len, ptr, size, NULL, NULL );
4707 if (cp == CP_UTF8) request_set_utf8_content_type( request );
4708 }
4709 else if (VariantChangeType( &data, &request->data, 0, VT_ARRAY|VT_UI1 ) == S_OK)
4710 {
4711 sa = V_ARRAY( &data );
4712 if ((hr = SafeArrayAccessData( sa, (void **)&ptr )) != S_OK) return hr;
4713 if ((hr = SafeArrayGetUBound( sa, 1, &size )) != S_OK)
4714 {
4715 SafeArrayUnaccessData( sa );
4716 return hr;
4717 }
4718 size++;
4719 }
4720 }
4721 wait_set_status_callback( request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT );
4722 if (!WinHttpSendRequest( request->hrequest, NULL, 0, ptr, size, size, 0 ))
4723 {
4724 err = GetLastError();
4725 goto error;
4726 }
4727 if ((err = wait_for_completion( request ))) goto error;
4728 if (sa) SafeArrayUnaccessData( sa );
4729 else free( ptr );
4730 request->state = REQUEST_STATE_SENT;
4731 return S_OK;
4732
4733 error:
4734 if (sa) SafeArrayUnaccessData( sa );
4735 else free( ptr );
4736 return HRESULT_FROM_WIN32( err );
4737 }
4738
4739 static void CALLBACK send_and_receive_proc( TP_CALLBACK_INSTANCE *instance, void *ctx )
4740 {
4741 struct winhttp_request *request = (struct winhttp_request *)ctx;
4742 if (request_send( request ) == S_OK) request_receive( request );
4743 SetEvent( request->done );
4744 }
4745
4746 /* critical section must be held */
4747 static DWORD request_wait( struct winhttp_request *request, DWORD timeout )
4748 {
4749 HANDLE done = request->done;
4750 DWORD err, ret;
4751
4752 LeaveCriticalSection( &request->cs );
4753 while ((err = MsgWaitForMultipleObjects( 1, &done, FALSE, timeout, QS_ALLINPUT )) == WAIT_OBJECT_0 + 1)
4754 {
4755 MSG msg;
4756 while (PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
4757 {
4758 TranslateMessage( &msg );
4759 DispatchMessageW( &msg );
4760 }
4761 }
4762 switch (err)
4763 {
4764 case WAIT_OBJECT_0:
4765 ret = request->error;
4766 break;
4767 case WAIT_TIMEOUT:
4768 ret = ERROR_TIMEOUT;
4769 break;
4770 default:
4771 ret = GetLastError();
4772 break;
4773 }
4774 EnterCriticalSection( &request->cs );
4775 if (err == WAIT_OBJECT_0) request->proc_running = FALSE;
4776 return ret;
4777 }
4778
4779 static HRESULT WINAPI winhttp_request_Send(
4780 IWinHttpRequest *iface,
4781 VARIANT body )
4782 {
4783 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4784 HRESULT hr;
4785
4786 TRACE("%p, %s\n", request, debugstr_variant(&body));
4787
4788 EnterCriticalSection( &request->cs );
4789 if (request->state < REQUEST_STATE_OPEN)
4790 {
4791 LeaveCriticalSection( &request->cs );
4792 return HRESULT_FROM_WIN32( ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN );
4793 }
4794 if (request->state >= REQUEST_STATE_SENT)
4795 {
4796 LeaveCriticalSection( &request->cs );
4797 return S_OK;
4798 }
4799 VariantClear( &request->data );
4800 if ((hr = VariantCopyInd( &request->data, &body )) != S_OK)
4801 {
4802 LeaveCriticalSection( &request->cs );
4803 return hr;
4804 }
4805 if (!TrySubmitThreadpoolCallback( send_and_receive_proc, request, NULL ))
4806 {
4807 LeaveCriticalSection( &request->cs );
4808 return HRESULT_FROM_WIN32( GetLastError() );
4809 }
4810 request->proc_running = TRUE;
4811 if (!request->async)
4812 {
4813 hr = HRESULT_FROM_WIN32( request_wait( request, INFINITE ) );
4814 }
4815 LeaveCriticalSection( &request->cs );
4816 return hr;
4817 }
4818
4819 static HRESULT WINAPI winhttp_request_get_Status(
4820 IWinHttpRequest *iface,
4821 LONG *status )
4822 {
4823 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4824 DWORD err = ERROR_SUCCESS, flags, status_code, len = sizeof(status_code), index = 0;
4825
4826 TRACE("%p, %p\n", request, status);
4827
4828 if (!status) return E_INVALIDARG;
4829
4830 EnterCriticalSection( &request->cs );
4831 if (request->state < REQUEST_STATE_SENT)
4832 {
4833 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4834 goto done;
4835 }
4836 flags = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
4837 if (!WinHttpQueryHeaders( request->hrequest, flags, NULL, &status_code, &len, &index ))
4838 {
4839 err = GetLastError();
4840 goto done;
4841 }
4842 *status = status_code;
4843
4844 done:
4845 LeaveCriticalSection( &request->cs );
4846 return HRESULT_FROM_WIN32( err );
4847 }
4848
4849 static HRESULT WINAPI winhttp_request_get_StatusText(
4850 IWinHttpRequest *iface,
4851 BSTR *status )
4852 {
4853 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4854 DWORD err = ERROR_SUCCESS, len = 0, index = 0;
4855
4856 TRACE("%p, %p\n", request, status);
4857
4858 if (!status) return E_INVALIDARG;
4859
4860 EnterCriticalSection( &request->cs );
4861 if (request->state < REQUEST_STATE_SENT)
4862 {
4863 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4864 goto done;
4865 }
4866 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_STATUS_TEXT, NULL, NULL, &len, &index ))
4867 {
4868 err = GetLastError();
4869 if (err != ERROR_INSUFFICIENT_BUFFER) goto done;
4870 }
4871 if (!(*status = SysAllocStringLen( NULL, len / sizeof(WCHAR) )))
4872 {
4873 err = ERROR_OUTOFMEMORY;
4874 goto done;
4875 }
4876 index = 0;
4877 err = ERROR_SUCCESS;
4878 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_STATUS_TEXT, NULL, *status, &len, &index ))
4879 {
4880 err = GetLastError();
4881 SysFreeString( *status );
4882 }
4883 done:
4884 LeaveCriticalSection( &request->cs );
4885 return HRESULT_FROM_WIN32( err );
4886 }
4887
4888 static DWORD request_get_codepage( struct winhttp_request *request, UINT *codepage )
4889 {
4890 WCHAR *buffer, *p;
4891 DWORD size;
4892
4893 *codepage = CP_ACP;
4894 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, NULL, &size, NULL ) &&
4895 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
4896 {
4897 if (!(buffer = malloc( size ))) return ERROR_OUTOFMEMORY;
4898 if (!WinHttpQueryHeaders( request->hrequest, WINHTTP_QUERY_CONTENT_TYPE, NULL, buffer, &size, NULL ))
4899 {
4900 return GetLastError();
4901 }
4902 if ((p = wcsstr( buffer, L"charset" )))
4903 {
4904 p += lstrlenW( L"charset" );
4905 while (*p == ' ') p++;
4906 if (*p++ == '=')
4907 {
4908 while (*p == ' ') p++;
4909 if (!wcsicmp( p, L"utf-8" )) *codepage = CP_UTF8;
4910 }
4911 }
4912 free( buffer );
4913 }
4914 return ERROR_SUCCESS;
4915 }
4916
4917 static HRESULT WINAPI winhttp_request_get_ResponseText(
4918 IWinHttpRequest *iface,
4919 BSTR *body )
4920 {
4921 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4922 UINT codepage;
4923 DWORD err = ERROR_SUCCESS;
4924 int len;
4925
4926 TRACE("%p, %p\n", request, body);
4927
4928 if (!body) return E_INVALIDARG;
4929
4930 EnterCriticalSection( &request->cs );
4931 if (request->state < REQUEST_STATE_SENT)
4932 {
4933 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4934 goto done;
4935 }
4936 if ((err = request_get_codepage( request, &codepage ))) goto done;
4937 len = MultiByteToWideChar( codepage, 0, request->buffer, request->offset, NULL, 0 );
4938 if (!(*body = SysAllocStringLen( NULL, len )))
4939 {
4940 err = ERROR_OUTOFMEMORY;
4941 goto done;
4942 }
4943 MultiByteToWideChar( codepage, 0, request->buffer, request->offset, *body, len );
4944 (*body)[len] = 0;
4945
4946 done:
4947 LeaveCriticalSection( &request->cs );
4948 return HRESULT_FROM_WIN32( err );
4949 }
4950
4951 static HRESULT WINAPI winhttp_request_get_ResponseBody(
4952 IWinHttpRequest *iface,
4953 VARIANT *body )
4954 {
4955 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
4956 SAFEARRAY *sa;
4957 HRESULT hr;
4958 DWORD err = ERROR_SUCCESS;
4959 char *ptr;
4960
4961 TRACE("%p, %p\n", request, body);
4962
4963 if (!body) return E_INVALIDARG;
4964
4965 EnterCriticalSection( &request->cs );
4966 if (request->state < REQUEST_STATE_SENT)
4967 {
4968 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
4969 goto done;
4970 }
4971 if (!(sa = SafeArrayCreateVector( VT_UI1, 0, request->offset )))
4972 {
4973 err = ERROR_OUTOFMEMORY;
4974 goto done;
4975 }
4976 if ((hr = SafeArrayAccessData( sa, (void **)&ptr )) != S_OK)
4977 {
4978 SafeArrayDestroy( sa );
4979 LeaveCriticalSection( &request->cs );
4980 return hr;
4981 }
4982 memcpy( ptr, request->buffer, request->offset );
4983 if ((hr = SafeArrayUnaccessData( sa )) != S_OK)
4984 {
4985 SafeArrayDestroy( sa );
4986 LeaveCriticalSection( &request->cs );
4987 return hr;
4988 }
4989 V_VT( body ) = VT_ARRAY|VT_UI1;
4990 V_ARRAY( body ) = sa;
4991
4992 done:
4993 LeaveCriticalSection( &request->cs );
4994 return HRESULT_FROM_WIN32( err );
4995 }
4996
4997 struct stream
4998 {
4999 IStream IStream_iface;
5000 LONG refs;
5001 char *data;
5002 ULARGE_INTEGER pos, size;
5003 };
5004
5005 static inline struct stream *impl_from_IStream( IStream *iface )
5006 {
5007 return CONTAINING_RECORD( iface, struct stream, IStream_iface );
5008 }
5009
5010 static HRESULT WINAPI stream_QueryInterface( IStream *iface, REFIID riid, void **obj )
5011 {
5012 struct stream *stream = impl_from_IStream( iface );
5013
5014 TRACE("%p, %s, %p\n", stream, debugstr_guid(riid), obj);
5015
5016 if (IsEqualGUID( riid, &IID_IStream ) || IsEqualGUID( riid, &IID_IUnknown ))
5017 {
5018 *obj = iface;
5019 }
5020 else
5021 {
5022 FIXME("interface %s not implemented\n", debugstr_guid(riid));
5023 return E_NOINTERFACE;
5024 }
5025 IStream_AddRef( iface );
5026 return S_OK;
5027 }
5028
5029 static ULONG WINAPI stream_AddRef( IStream *iface )
5030 {
5031 struct stream *stream = impl_from_IStream( iface );
5032 return InterlockedIncrement( &stream->refs );
5033 }
5034
5035 static ULONG WINAPI stream_Release( IStream *iface )
5036 {
5037 struct stream *stream = impl_from_IStream( iface );
5038 LONG refs = InterlockedDecrement( &stream->refs );
5039 if (!refs)
5040 {
5041 free( stream->data );
5042 free( stream );
5043 }
5044 return refs;
5045 }
5046
5047 static HRESULT WINAPI stream_Read( IStream *iface, void *buf, ULONG len, ULONG *read )
5048 {
5049 struct stream *stream = impl_from_IStream( iface );
5050 ULONG size;
5051
5052 if (stream->pos.QuadPart >= stream->size.QuadPart)
5053 {
5054 *read = 0;
5055 return S_FALSE;
5056 }
5057
5058 size = min( stream->size.QuadPart - stream->pos.QuadPart, len );
5059 memcpy( buf, stream->data + stream->pos.QuadPart, size );
5060 stream->pos.QuadPart += size;
5061 *read = size;
5062
5063 return S_OK;
5064 }
5065
5066 static HRESULT WINAPI stream_Write( IStream *iface, const void *buf, ULONG len, ULONG *written )
5067 {
5068 FIXME("\n");
5069 return E_NOTIMPL;
5070 }
5071
5072 static HRESULT WINAPI stream_Seek( IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *newpos )
5073 {
5074 struct stream *stream = impl_from_IStream( iface );
5075
5076 if (origin == STREAM_SEEK_SET)
5077 stream->pos.QuadPart = move.QuadPart;
5078 else if (origin == STREAM_SEEK_CUR)
5079 stream->pos.QuadPart += move.QuadPart;
5080 else if (origin == STREAM_SEEK_END)
5081 stream->pos.QuadPart = stream->size.QuadPart - move.QuadPart;
5082
5083 if (newpos) newpos->QuadPart = stream->pos.QuadPart;
5084 return S_OK;
5085 }
5086
5087 static HRESULT WINAPI stream_SetSize( IStream *iface, ULARGE_INTEGER newsize )
5088 {
5089 FIXME("\n");
5090 return E_NOTIMPL;
5091 }
5092
5093 static HRESULT WINAPI stream_CopyTo( IStream *iface, IStream *stream, ULARGE_INTEGER len, ULARGE_INTEGER *read,
5094 ULARGE_INTEGER *written )
5095 {
5096 FIXME("\n");
5097 return E_NOTIMPL;
5098 }
5099
5100 static HRESULT WINAPI stream_Commit( IStream *iface, DWORD flags )
5101 {
5102 FIXME("\n");
5103 return E_NOTIMPL;
5104 }
5105
5106 static HRESULT WINAPI stream_Revert( IStream *iface )
5107 {
5108 FIXME("\n");
5109 return E_NOTIMPL;
5110 }
5111
5112 static HRESULT WINAPI stream_LockRegion( IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype )
5113 {
5114 FIXME("\n");
5115 return E_NOTIMPL;
5116 }
5117
5118 static HRESULT WINAPI stream_UnlockRegion( IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER len, DWORD locktype )
5119 {
5120 FIXME("\n");
5121 return E_NOTIMPL;
5122 }
5123
5124 static HRESULT WINAPI stream_Stat( IStream *iface, STATSTG *stg, DWORD flag )
5125 {
5126 FIXME("\n");
5127 return E_NOTIMPL;
5128 }
5129
5130 static HRESULT WINAPI stream_Clone( IStream *iface, IStream **stream )
5131 {
5132 FIXME("\n");
5133 return E_NOTIMPL;
5134 }
5135
5136 static const IStreamVtbl stream_vtbl =
5137 {
5138 stream_QueryInterface,
5139 stream_AddRef,
5140 stream_Release,
5141 stream_Read,
5142 stream_Write,
5143 stream_Seek,
5144 stream_SetSize,
5145 stream_CopyTo,
5146 stream_Commit,
5147 stream_Revert,
5148 stream_LockRegion,
5149 stream_UnlockRegion,
5150 stream_Stat,
5151 stream_Clone
5152 };
5153
5154 static HRESULT WINAPI winhttp_request_get_ResponseStream(
5155 IWinHttpRequest *iface,
5156 VARIANT *body )
5157 {
5158 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5159 DWORD err = ERROR_SUCCESS;
5160 struct stream *stream;
5161
5162 TRACE("%p, %p\n", request, body);
5163
5164 if (!body) return E_INVALIDARG;
5165
5166 EnterCriticalSection( &request->cs );
5167 if (request->state < REQUEST_STATE_SENT)
5168 {
5169 err = ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND;
5170 goto done;
5171 }
5172 if (!(stream = malloc( sizeof(*stream) )))
5173 {
5174 err = ERROR_OUTOFMEMORY;
5175 goto done;
5176 }
5177 stream->IStream_iface.lpVtbl = &stream_vtbl;
5178 stream->refs = 1;
5179 if (!(stream->data = malloc( request->offset )))
5180 {
5181 free( stream );
5182 err = ERROR_OUTOFMEMORY;
5183 goto done;
5184 }
5185 memcpy( stream->data, request->buffer, request->offset );
5186 stream->pos.QuadPart = 0;
5187 stream->size.QuadPart = request->offset;
5188 V_VT( body ) = VT_UNKNOWN;
5189 V_UNKNOWN( body ) = (IUnknown *)&stream->IStream_iface;
5190
5191 done:
5192 LeaveCriticalSection( &request->cs );
5193 return HRESULT_FROM_WIN32( err );
5194 }
5195
5196 static HRESULT WINAPI winhttp_request_get_Option(
5197 IWinHttpRequest *iface,
5198 WinHttpRequestOption option,
5199 VARIANT *value )
5200 {
5201 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5202 HRESULT hr = S_OK;
5203
5204 TRACE("%p, %u, %p\n", request, option, value);
5205
5206 EnterCriticalSection( &request->cs );
5207 switch (option)
5208 {
5209 case WinHttpRequestOption_URLCodePage:
5210 V_VT( value ) = VT_I4;
5211 V_I4( value ) = request->url_codepage;
5212 break;
5213 default:
5214 FIXME("unimplemented option %u\n", option);
5215 hr = E_NOTIMPL;
5216 break;
5217 }
5218 LeaveCriticalSection( &request->cs );
5219 return hr;
5220 }
5221
5222 static HRESULT WINAPI winhttp_request_put_Option(
5223 IWinHttpRequest *iface,
5224 WinHttpRequestOption option,
5225 VARIANT value )
5226 {
5227 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5228 HRESULT hr = S_OK;
5229
5230 TRACE("%p, %u, %s\n", request, option, debugstr_variant(&value));
5231
5232 EnterCriticalSection( &request->cs );
5233 switch (option)
5234 {
5235 case WinHttpRequestOption_EnableRedirects:
5236 {
5237 if (V_BOOL( &value ))
5238 request->disable_feature &= ~WINHTTP_DISABLE_REDIRECTS;
5239 else
5240 request->disable_feature |= WINHTTP_DISABLE_REDIRECTS;
5241 break;
5242 }
5243 case WinHttpRequestOption_URLCodePage:
5244 {
5245 VARIANT cp;
5246 VariantInit( &cp );
5247 hr = VariantChangeType( &cp, &value, 0, VT_UI4 );
5248 if (SUCCEEDED( hr ))
5249 {
5250 request->url_codepage = V_UI4( &cp );
5251 TRACE("URL codepage: %u\n", request->url_codepage);
5252 }
5253 else if (V_VT( &value ) == VT_BSTR && !wcsicmp( V_BSTR( &value ), L"utf-8" ))
5254 {
5255 TRACE("URL codepage: UTF-8\n");
5256 request->url_codepage = CP_UTF8;
5257 hr = S_OK;
5258 }
5259 else
5260 FIXME("URL codepage %s is not recognized\n", debugstr_variant( &value ));
5261 break;
5262 }
5263 default:
5264 FIXME("unimplemented option %u\n", option);
5265 hr = E_NOTIMPL;
5266 break;
5267 }
5268 LeaveCriticalSection( &request->cs );
5269 return hr;
5270 }
5271
5272 static HRESULT WINAPI winhttp_request_WaitForResponse(
5273 IWinHttpRequest *iface,
5274 VARIANT timeout,
5275 VARIANT_BOOL *succeeded )
5276 {
5277 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5278 DWORD err, msecs = (V_I4(&timeout) == -1) ? INFINITE : V_I4(&timeout) * 1000;
5279
5280 TRACE("%p, %s, %p\n", request, debugstr_variant(&timeout), succeeded);
5281
5282 EnterCriticalSection( &request->cs );
5283 if (request->state >= REQUEST_STATE_RESPONSE_RECEIVED)
5284 {
5285 LeaveCriticalSection( &request->cs );
5286 return S_OK;
5287 }
5288 switch ((err = request_wait( request, msecs )))
5289 {
5290 case ERROR_TIMEOUT:
5291 if (succeeded) *succeeded = VARIANT_FALSE;
5292 err = ERROR_SUCCESS;
5293 break;
5294
5295 default:
5296 if (succeeded) *succeeded = VARIANT_TRUE;
5297 break;
5298 }
5299 LeaveCriticalSection( &request->cs );
5300 return HRESULT_FROM_WIN32( err );
5301 }
5302
5303 static HRESULT WINAPI winhttp_request_Abort(
5304 IWinHttpRequest *iface )
5305 {
5306 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5307
5308 TRACE("%p\n", request);
5309
5310 EnterCriticalSection( &request->cs );
5311 cancel_request( request );
5312 LeaveCriticalSection( &request->cs );
5313 return S_OK;
5314 }
5315
5316 static HRESULT WINAPI winhttp_request_SetTimeouts(
5317 IWinHttpRequest *iface,
5318 LONG resolve_timeout,
5319 LONG connect_timeout,
5320 LONG send_timeout,
5321 LONG receive_timeout )
5322 {
5323 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5324
5325 TRACE("%p, %d, %d, %d, %d\n", request, resolve_timeout, connect_timeout, send_timeout, receive_timeout);
5326
5327 EnterCriticalSection( &request->cs );
5328 request->resolve_timeout = resolve_timeout;
5329 request->connect_timeout = connect_timeout;
5330 request->send_timeout = send_timeout;
5331 request->receive_timeout = receive_timeout;
5332 LeaveCriticalSection( &request->cs );
5333 return S_OK;
5334 }
5335
5336 static HRESULT WINAPI winhttp_request_SetClientCertificate(
5337 IWinHttpRequest *iface,
5338 BSTR certificate )
5339 {
5340 FIXME("\n");
5341 return E_NOTIMPL;
5342 }
5343
5344 static HRESULT WINAPI winhttp_request_SetAutoLogonPolicy(
5345 IWinHttpRequest *iface,
5346 WinHttpRequestAutoLogonPolicy policy )
5347 {
5348 struct winhttp_request *request = impl_from_IWinHttpRequest( iface );
5349 HRESULT hr = S_OK;
5350
5351 TRACE("%p, %u\n", request, policy );
5352
5353 EnterCriticalSection( &request->cs );
5354 switch (policy)
5355 {
5356 case AutoLogonPolicy_Always:
5357 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW;
5358 break;
5359 case AutoLogonPolicy_OnlyIfBypassProxy:
5360 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM;
5361 break;
5362 case AutoLogonPolicy_Never:
5363 request->logon_policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH;
5364 break;
5365 default: hr = E_INVALIDARG;
5366 break;
5367 }
5368 LeaveCriticalSection( &request->cs );
5369 return hr;
5370 }
5371
5372 static const struct IWinHttpRequestVtbl winhttp_request_vtbl =
5373 {
5374 winhttp_request_QueryInterface,
5375 winhttp_request_AddRef,
5376 winhttp_request_Release,
5377 winhttp_request_GetTypeInfoCount,
5378 winhttp_request_GetTypeInfo,
5379 winhttp_request_GetIDsOfNames,
5380 winhttp_request_Invoke,
5381 winhttp_request_SetProxy,
5382 winhttp_request_SetCredentials,
5383 winhttp_request_Open,
5384 winhttp_request_SetRequestHeader,
5385 winhttp_request_GetResponseHeader,
5386 winhttp_request_GetAllResponseHeaders,
5387 winhttp_request_Send,
5388 winhttp_request_get_Status,
5389 winhttp_request_get_StatusText,
5390 winhttp_request_get_ResponseText,
5391 winhttp_request_get_ResponseBody,
5392 winhttp_request_get_ResponseStream,
5393 winhttp_request_get_Option,
5394 winhttp_request_put_Option,
5395 winhttp_request_WaitForResponse,
5396 winhttp_request_Abort,
5397 winhttp_request_SetTimeouts,
5398 winhttp_request_SetClientCertificate,
5399 winhttp_request_SetAutoLogonPolicy
5400 };
5401
5402 HRESULT WinHttpRequest_create( void **obj )
5403 {
5404 struct winhttp_request *request;
5405
5406 TRACE("%p\n", obj);
5407
5408 if (!(request = calloc( 1, sizeof(*request) ))) return E_OUTOFMEMORY;
5409 request->IWinHttpRequest_iface.lpVtbl = &winhttp_request_vtbl;
5410 request->refs = 1;
5411 InitializeCriticalSection( &request->cs );
5412 request->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": winhttp_request.cs");
5413 initialize_request( request );
5414
5415 *obj = &request->IWinHttpRequest_iface;
5416 TRACE("returning iface %p\n", *obj);
5417 return S_OK;
5418 }
Windows API implementation