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
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.
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.
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
24 #include "wine/port.h"
25 #include "wine/debug.h"
28 #ifdef HAVE_ARPA_INET_H
29 # include <arpa/inet.h>
36 #include "httprequest.h"
39 #include "winhttp_private.h"
41 #include "inet_ntop.c"
43 WINE_DEFAULT_DEBUG_CHANNEL(winhttp
);
45 static const WCHAR attr_accept
[] = {'A','c','c','e','p','t',0};
46 static const WCHAR attr_accept_charset
[] = {'A','c','c','e','p','t','-','C','h','a','r','s','e','t', 0};
47 static const WCHAR attr_accept_encoding
[] = {'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',0};
48 static const WCHAR attr_accept_language
[] = {'A','c','c','e','p','t','-','L','a','n','g','u','a','g','e',0};
49 static const WCHAR attr_accept_ranges
[] = {'A','c','c','e','p','t','-','R','a','n','g','e','s',0};
50 static const WCHAR attr_age
[] = {'A','g','e',0};
51 static const WCHAR attr_allow
[] = {'A','l','l','o','w',0};
52 static const WCHAR attr_authorization
[] = {'A','u','t','h','o','r','i','z','a','t','i','o','n',0};
53 static const WCHAR attr_cache_control
[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',0};
54 static const WCHAR attr_connection
[] = {'C','o','n','n','e','c','t','i','o','n',0};
55 static const WCHAR attr_content_base
[] = {'C','o','n','t','e','n','t','-','B','a','s','e',0};
56 static const WCHAR attr_content_encoding
[] = {'C','o','n','t','e','n','t','-','E','n','c','o','d','i','n','g',0};
57 static const WCHAR attr_content_id
[] = {'C','o','n','t','e','n','t','-','I','D',0};
58 static const WCHAR attr_content_language
[] = {'C','o','n','t','e','n','t','-','L','a','n','g','u','a','g','e',0};
59 static const WCHAR attr_content_length
[] = {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0};
60 static const WCHAR attr_content_location
[] = {'C','o','n','t','e','n','t','-','L','o','c','a','t','i','o','n',0};
61 static const WCHAR attr_content_md5
[] = {'C','o','n','t','e','n','t','-','M','D','5',0};
62 static const WCHAR attr_content_range
[] = {'C','o','n','t','e','n','t','-','R','a','n','g','e',0};
63 static const WCHAR attr_content_transfer_encoding
[] = {'C','o','n','t','e','n','t','-','T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0};
64 static const WCHAR attr_content_type
[] = {'C','o','n','t','e','n','t','-','T','y','p','e',0};
65 static const WCHAR attr_cookie
[] = {'C','o','o','k','i','e',0};
66 static const WCHAR attr_date
[] = {'D','a','t','e',0};
67 static const WCHAR attr_from
[] = {'F','r','o','m',0};
68 static const WCHAR attr_etag
[] = {'E','T','a','g',0};
69 static const WCHAR attr_expect
[] = {'E','x','p','e','c','t',0};
70 static const WCHAR attr_expires
[] = {'E','x','p','i','r','e','s',0};
71 static const WCHAR attr_host
[] = {'H','o','s','t',0};
72 static const WCHAR attr_if_match
[] = {'I','f','-','M','a','t','c','h',0};
73 static const WCHAR attr_if_modified_since
[] = {'I','f','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
74 static const WCHAR attr_if_none_match
[] = {'I','f','-','N','o','n','e','-','M','a','t','c','h',0};
75 static const WCHAR attr_if_range
[] = {'I','f','-','R','a','n','g','e',0};
76 static const WCHAR attr_if_unmodified_since
[] = {'I','f','-','U','n','m','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
77 static const WCHAR attr_last_modified
[] = {'L','a','s','t','-','M','o','d','i','f','i','e','d',0};
78 static const WCHAR attr_location
[] = {'L','o','c','a','t','i','o','n',0};
79 static const WCHAR attr_max_forwards
[] = {'M','a','x','-','F','o','r','w','a','r','d','s',0};
80 static const WCHAR attr_mime_version
[] = {'M','i','m','e','-','V','e','r','s','i','o','n',0};
81 static const WCHAR attr_pragma
[] = {'P','r','a','g','m','a',0};
82 static const WCHAR attr_proxy_authenticate
[] = {'P','r','o','x','y','-','A','u','t','h','e','n','t','i','c','a','t','e',0};
83 static const WCHAR attr_proxy_authorization
[] = {'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',0};
84 static const WCHAR attr_proxy_connection
[] = {'P','r','o','x','y','-','C','o','n','n','e','c','t','i','o','n',0};
85 static const WCHAR attr_public
[] = {'P','u','b','l','i','c',0};
86 static const WCHAR attr_range
[] = {'R','a','n','g','e',0};
87 static const WCHAR attr_referer
[] = {'R','e','f','e','r','e','r',0};
88 static const WCHAR attr_retry_after
[] = {'R','e','t','r','y','-','A','f','t','e','r',0};
89 static const WCHAR attr_server
[] = {'S','e','r','v','e','r',0};
90 static const WCHAR attr_set_cookie
[] = {'S','e','t','-','C','o','o','k','i','e',0};
91 static const WCHAR attr_status
[] = {'S','t','a','t','u','s',0};
92 static const WCHAR attr_transfer_encoding
[] = {'T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0};
93 static const WCHAR attr_unless_modified_since
[] = {'U','n','l','e','s','s','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0};
94 static const WCHAR attr_upgrade
[] = {'U','p','g','r','a','d','e',0};
95 static const WCHAR attr_uri
[] = {'U','R','I',0};
96 static const WCHAR attr_user_agent
[] = {'U','s','e','r','-','A','g','e','n','t',0};
97 static const WCHAR attr_vary
[] = {'V','a','r','y',0};
98 static const WCHAR attr_via
[] = {'V','i','a',0};
99 static const WCHAR attr_warning
[] = {'W','a','r','n','i','n','g',0};
100 static const WCHAR attr_www_authenticate
[] = {'W','W','W','-','A','u','t','h','e','n','t','i','c','a','t','e',0};
102 static const WCHAR
*attribute_table
[] =
104 attr_mime_version
, /* WINHTTP_QUERY_MIME_VERSION = 0 */
105 attr_content_type
, /* WINHTTP_QUERY_CONTENT_TYPE = 1 */
106 attr_content_transfer_encoding
, /* WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
107 attr_content_id
, /* WINHTTP_QUERY_CONTENT_ID = 3 */
108 NULL
, /* WINHTTP_QUERY_CONTENT_DESCRIPTION = 4 */
109 attr_content_length
, /* WINHTTP_QUERY_CONTENT_LENGTH = 5 */
110 attr_content_language
, /* WINHTTP_QUERY_CONTENT_LANGUAGE = 6 */
111 attr_allow
, /* WINHTTP_QUERY_ALLOW = 7 */
112 attr_public
, /* WINHTTP_QUERY_PUBLIC = 8 */
113 attr_date
, /* WINHTTP_QUERY_DATE = 9 */
114 attr_expires
, /* WINHTTP_QUERY_EXPIRES = 10 */
115 attr_last_modified
, /* WINHTTP_QUERY_LAST_MODIFIEDcw = 11 */
116 NULL
, /* WINHTTP_QUERY_MESSAGE_ID = 12 */
117 attr_uri
, /* WINHTTP_QUERY_URI = 13 */
118 attr_from
, /* WINHTTP_QUERY_DERIVED_FROM = 14 */
119 NULL
, /* WINHTTP_QUERY_COST = 15 */
120 NULL
, /* WINHTTP_QUERY_LINK = 16 */
121 attr_pragma
, /* WINHTTP_QUERY_PRAGMA = 17 */
122 NULL
, /* WINHTTP_QUERY_VERSION = 18 */
123 attr_status
, /* WINHTTP_QUERY_STATUS_CODE = 19 */
124 NULL
, /* WINHTTP_QUERY_STATUS_TEXT = 20 */
125 NULL
, /* WINHTTP_QUERY_RAW_HEADERS = 21 */
126 NULL
, /* WINHTTP_QUERY_RAW_HEADERS_CRLF = 22 */
127 attr_connection
, /* WINHTTP_QUERY_CONNECTION = 23 */
128 attr_accept
, /* WINHTTP_QUERY_ACCEPT = 24 */
129 attr_accept_charset
, /* WINHTTP_QUERY_ACCEPT_CHARSET = 25 */
130 attr_accept_encoding
, /* WINHTTP_QUERY_ACCEPT_ENCODING = 26 */
131 attr_accept_language
, /* WINHTTP_QUERY_ACCEPT_LANGUAGE = 27 */
132 attr_authorization
, /* WINHTTP_QUERY_AUTHORIZATION = 28 */
133 attr_content_encoding
, /* WINHTTP_QUERY_CONTENT_ENCODING = 29 */
134 NULL
, /* WINHTTP_QUERY_FORWARDED = 30 */
135 NULL
, /* WINHTTP_QUERY_FROM = 31 */
136 attr_if_modified_since
, /* WINHTTP_QUERY_IF_MODIFIED_SINCE = 32 */
137 attr_location
, /* WINHTTP_QUERY_LOCATION = 33 */
138 NULL
, /* WINHTTP_QUERY_ORIG_URI = 34 */
139 attr_referer
, /* WINHTTP_QUERY_REFERER = 35 */
140 attr_retry_after
, /* WINHTTP_QUERY_RETRY_AFTER = 36 */
141 attr_server
, /* WINHTTP_QUERY_SERVER = 37 */
142 NULL
, /* WINHTTP_TITLE = 38 */
143 attr_user_agent
, /* WINHTTP_QUERY_USER_AGENT = 39 */
144 attr_www_authenticate
, /* WINHTTP_QUERY_WWW_AUTHENTICATE = 40 */
145 attr_proxy_authenticate
, /* WINHTTP_QUERY_PROXY_AUTHENTICATE = 41 */
146 attr_accept_ranges
, /* WINHTTP_QUERY_ACCEPT_RANGES = 42 */
147 attr_set_cookie
, /* WINHTTP_QUERY_SET_COOKIE = 43 */
148 attr_cookie
, /* WINHTTP_QUERY_COOKIE = 44 */
149 NULL
, /* WINHTTP_QUERY_REQUEST_METHOD = 45 */
150 NULL
, /* WINHTTP_QUERY_REFRESH = 46 */
151 NULL
, /* WINHTTP_QUERY_CONTENT_DISPOSITION = 47 */
152 attr_age
, /* WINHTTP_QUERY_AGE = 48 */
153 attr_cache_control
, /* WINHTTP_QUERY_CACHE_CONTROL = 49 */
154 attr_content_base
, /* WINHTTP_QUERY_CONTENT_BASE = 50 */
155 attr_content_location
, /* WINHTTP_QUERY_CONTENT_LOCATION = 51 */
156 attr_content_md5
, /* WINHTTP_QUERY_CONTENT_MD5 = 52 */
157 attr_content_range
, /* WINHTTP_QUERY_CONTENT_RANGE = 53 */
158 attr_etag
, /* WINHTTP_QUERY_ETAG = 54 */
159 attr_host
, /* WINHTTP_QUERY_HOST = 55 */
160 attr_if_match
, /* WINHTTP_QUERY_IF_MATCH = 56 */
161 attr_if_none_match
, /* WINHTTP_QUERY_IF_NONE_MATCH = 57 */
162 attr_if_range
, /* WINHTTP_QUERY_IF_RANGE = 58 */
163 attr_if_unmodified_since
, /* WINHTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
164 attr_max_forwards
, /* WINHTTP_QUERY_MAX_FORWARDS = 60 */
165 attr_proxy_authorization
, /* WINHTTP_QUERY_PROXY_AUTHORIZATION = 61 */
166 attr_range
, /* WINHTTP_QUERY_RANGE = 62 */
167 attr_transfer_encoding
, /* WINHTTP_QUERY_TRANSFER_ENCODING = 63 */
168 attr_upgrade
, /* WINHTTP_QUERY_UPGRADE = 64 */
169 attr_vary
, /* WINHTTP_QUERY_VARY = 65 */
170 attr_via
, /* WINHTTP_QUERY_VIA = 66 */
171 attr_warning
, /* WINHTTP_QUERY_WARNING = 67 */
172 attr_expect
, /* WINHTTP_QUERY_EXPECT = 68 */
173 attr_proxy_connection
, /* WINHTTP_QUERY_PROXY_CONNECTION = 69 */
174 attr_unless_modified_since
, /* WINHTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
175 NULL
, /* WINHTTP_QUERY_PROXY_SUPPORT = 75 */
176 NULL
, /* WINHTTP_QUERY_AUTHENTICATION_INFO = 76 */
177 NULL
, /* WINHTTP_QUERY_PASSPORT_URLS = 77 */
178 NULL
/* WINHTTP_QUERY_PASSPORT_CONFIG = 78 */
181 static DWORD CALLBACK
task_thread( LPVOID param
)
183 task_header_t
*task
= param
;
187 release_object( &task
->request
->hdr
);
189 return ERROR_SUCCESS
;
192 static BOOL
queue_task( task_header_t
*task
)
194 return QueueUserWorkItem( task_thread
, task
, WT_EXECUTELONGFUNCTION
);
197 static void free_header( header_t
*header
)
199 heap_free( header
->field
);
200 heap_free( header
->value
);
204 static BOOL
valid_token_char( WCHAR c
)
206 if (c
< 32 || c
== 127) return FALSE
;
213 case '\\': case '\"':
225 static header_t
*parse_header( LPCWSTR string
)
232 if (!(q
= strchrW( p
, ':' )))
234 WARN("no ':' in line %s\n", debugstr_w(string
));
239 WARN("empty field name in line %s\n", debugstr_w(string
));
244 if (!valid_token_char( *p
))
246 WARN("invalid character in field name %s\n", debugstr_w(string
));
252 if (!(header
= heap_alloc_zero( sizeof(header_t
) ))) return NULL
;
253 if (!(header
->field
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) )))
258 memcpy( header
->field
, string
, len
* sizeof(WCHAR
) );
259 header
->field
[len
] = 0;
261 q
++; /* skip past colon */
262 while (*q
== ' ') q
++;
265 WARN("no value in line %s\n", debugstr_w(string
));
269 if (!(header
->value
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) )))
271 free_header( header
);
274 memcpy( header
->value
, q
, len
* sizeof(WCHAR
) );
275 header
->value
[len
] = 0;
280 static int get_header_index( request_t
*request
, LPCWSTR field
, int requested_index
, BOOL request_only
)
284 TRACE("%s\n", debugstr_w(field
));
286 for (index
= 0; index
< request
->num_headers
; index
++)
288 if (strcmpiW( request
->headers
[index
].field
, field
)) continue;
289 if (request_only
&& !request
->headers
[index
].is_request
) continue;
290 if (!request_only
&& request
->headers
[index
].is_request
) continue;
292 if (!requested_index
) break;
295 if (index
>= request
->num_headers
) index
= -1;
296 TRACE("returning %d\n", index
);
300 static BOOL
insert_header( request_t
*request
, header_t
*header
)
305 count
= request
->num_headers
+ 1;
307 hdrs
= heap_realloc_zero( request
->headers
, sizeof(header_t
) * count
);
309 hdrs
= heap_alloc_zero( sizeof(header_t
) * count
);
313 request
->headers
= hdrs
;
314 request
->headers
[count
- 1].field
= strdupW( header
->field
);
315 request
->headers
[count
- 1].value
= strdupW( header
->value
);
316 request
->headers
[count
- 1].is_request
= header
->is_request
;
317 request
->num_headers
++;
323 static BOOL
delete_header( request_t
*request
, DWORD index
)
325 if (!request
->num_headers
) return FALSE
;
326 if (index
>= request
->num_headers
) return FALSE
;
327 request
->num_headers
--;
329 heap_free( request
->headers
[index
].field
);
330 heap_free( request
->headers
[index
].value
);
332 memmove( &request
->headers
[index
], &request
->headers
[index
+ 1], (request
->num_headers
- index
) * sizeof(header_t
) );
333 memset( &request
->headers
[request
->num_headers
], 0, sizeof(header_t
) );
337 static BOOL
process_header( request_t
*request
, LPCWSTR field
, LPCWSTR value
, DWORD flags
, BOOL request_only
)
342 TRACE("%s: %s 0x%08x\n", debugstr_w(field
), debugstr_w(value
), flags
);
344 /* replace wins out over add */
345 if (flags
& WINHTTP_ADDREQ_FLAG_REPLACE
) flags
&= ~WINHTTP_ADDREQ_FLAG_ADD
;
347 if (flags
& WINHTTP_ADDREQ_FLAG_ADD
) index
= -1;
349 index
= get_header_index( request
, field
, 0, request_only
);
353 if (flags
& WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
) return FALSE
;
354 header
= &request
->headers
[index
];
360 hdr
.field
= (LPWSTR
)field
;
361 hdr
.value
= (LPWSTR
)value
;
362 hdr
.is_request
= request_only
;
364 return insert_header( request
, &hdr
);
366 /* no value to delete */
369 if (flags
& WINHTTP_ADDREQ_FLAG_REPLACE
)
371 delete_header( request
, index
);
376 hdr
.field
= (LPWSTR
)field
;
377 hdr
.value
= (LPWSTR
)value
;
378 hdr
.is_request
= request_only
;
380 return insert_header( request
, &hdr
);
384 else if (flags
& (WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA
| WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON
))
387 int len
, orig_len
, value_len
;
389 orig_len
= strlenW( header
->value
);
390 value_len
= strlenW( value
);
392 if (flags
& WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA
) sep
= ',';
395 len
= orig_len
+ value_len
+ 2;
396 if ((tmp
= heap_realloc( header
->value
, (len
+ 1) * sizeof(WCHAR
) )))
400 header
->value
[orig_len
] = sep
;
402 header
->value
[orig_len
] = ' ';
405 memcpy( &header
->value
[orig_len
], value
, value_len
* sizeof(WCHAR
) );
406 header
->value
[len
] = 0;
413 BOOL
add_request_headers( request_t
*request
, LPCWSTR headers
, DWORD len
, DWORD flags
)
416 WCHAR
*buffer
, *p
, *q
;
419 if (len
== ~0u) len
= strlenW( headers
);
420 if (!len
) return TRUE
;
421 if (!(buffer
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) ))) return FALSE
;
422 strcpyW( buffer
, headers
);
430 if (q
[0] == '\n' && q
[1] == '\r')
435 if (q
[0] == '\r' && q
[1] == '\n') break;
442 q
+= 2; /* jump over \r\n */
444 if ((header
= parse_header( p
)))
446 ret
= process_header( request
, header
->field
, header
->value
, flags
, TRUE
);
447 free_header( header
);
456 /***********************************************************************
457 * WinHttpAddRequestHeaders (winhttp.@)
459 BOOL WINAPI
WinHttpAddRequestHeaders( HINTERNET hrequest
, LPCWSTR headers
, DWORD len
, DWORD flags
)
464 TRACE("%p, %s, 0x%x, 0x%08x\n", hrequest
, debugstr_w(headers
), len
, flags
);
468 set_last_error( ERROR_INVALID_PARAMETER
);
471 if (!(request
= (request_t
*)grab_object( hrequest
)))
473 set_last_error( ERROR_INVALID_HANDLE
);
476 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
478 release_object( &request
->hdr
);
479 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
483 ret
= add_request_headers( request
, headers
, len
, flags
);
485 release_object( &request
->hdr
);
489 static WCHAR
*build_request_path( request_t
*request
)
493 if (strcmpiW( request
->connect
->hostname
, request
->connect
->servername
))
495 static const WCHAR http
[] = { 'h','t','t','p',0 };
496 static const WCHAR https
[] = { 'h','t','t','p','s',0 };
497 static const WCHAR fmt
[] = { '%','s',':','/','/','%','s',0 };
498 LPCWSTR scheme
= request
->netconn
.secure
? https
: http
;
501 len
= strlenW( scheme
) + strlenW( request
->connect
->hostname
);
502 /* 3 characters for '://', 1 for NUL. */
504 if (request
->connect
->hostport
)
506 /* 1 for ':' between host and port, up to 5 for port */
510 len
+= strlenW( request
->path
);
511 if ((ret
= heap_alloc( len
* sizeof(WCHAR
) )))
513 sprintfW( ret
, fmt
, scheme
, request
->connect
->hostname
);
514 if (request
->connect
->hostport
)
516 static const WCHAR colonFmt
[] = { ':','%','u',0 };
518 sprintfW( ret
+ strlenW( ret
), colonFmt
,
519 request
->connect
->hostport
);
522 strcatW( ret
, request
->path
);
530 static WCHAR
*build_request_string( request_t
*request
)
532 static const WCHAR space
[] = {' ',0};
533 static const WCHAR crlf
[] = {'\r','\n',0};
534 static const WCHAR colon
[] = {':',' ',0};
535 static const WCHAR twocrlf
[] = {'\r','\n','\r','\n',0};
538 const WCHAR
**headers
, **p
;
539 unsigned int len
, i
= 0, j
;
541 /* allocate space for an array of all the string pointers to be added */
542 len
= request
->num_headers
* 4 + 7;
543 if (!(headers
= heap_alloc( len
* sizeof(LPCWSTR
) ))) return NULL
;
545 path
= build_request_path( request
);
546 headers
[i
++] = request
->verb
;
547 headers
[i
++] = space
;
549 headers
[i
++] = space
;
550 headers
[i
++] = request
->version
;
552 for (j
= 0; j
< request
->num_headers
; j
++)
554 if (request
->headers
[j
].is_request
)
557 headers
[i
++] = request
->headers
[j
].field
;
558 headers
[i
++] = colon
;
559 headers
[i
++] = request
->headers
[j
].value
;
561 TRACE("adding header %s (%s)\n", debugstr_w(request
->headers
[j
].field
),
562 debugstr_w(request
->headers
[j
].value
));
565 headers
[i
++] = twocrlf
;
569 for (p
= headers
; *p
; p
++) len
+= strlenW( *p
);
572 if (!(ret
= heap_alloc( len
* sizeof(WCHAR
) )))
575 for (p
= headers
; *p
; p
++) strcatW( ret
, *p
);
578 if (path
!= request
->path
)
580 heap_free( headers
);
584 #define QUERY_MODIFIER_MASK (WINHTTP_QUERY_FLAG_REQUEST_HEADERS | WINHTTP_QUERY_FLAG_SYSTEMTIME | WINHTTP_QUERY_FLAG_NUMBER)
586 static BOOL
query_headers( request_t
*request
, DWORD level
, LPCWSTR name
, LPVOID buffer
, LPDWORD buflen
, LPDWORD index
)
588 header_t
*header
= NULL
;
589 BOOL request_only
, ret
= FALSE
;
590 int requested_index
, header_index
= -1;
593 request_only
= level
& WINHTTP_QUERY_FLAG_REQUEST_HEADERS
;
594 requested_index
= index
? *index
: 0;
596 attr
= level
& ~QUERY_MODIFIER_MASK
;
599 case WINHTTP_QUERY_CUSTOM
:
601 header_index
= get_header_index( request
, name
, requested_index
, request_only
);
604 case WINHTTP_QUERY_RAW_HEADERS
:
606 WCHAR
*headers
, *p
, *q
;
609 headers
= build_request_string( request
);
611 headers
= request
->raw_headers
;
613 if (!(p
= headers
)) return FALSE
;
614 for (len
= 0; *p
; p
++) if (*p
!= '\r') len
++;
616 if (!buffer
|| (len
+ 1) * sizeof(WCHAR
) > *buflen
)
619 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
623 for (p
= headers
, q
= buffer
; *p
; p
++, q
++)
625 if (*p
!= '\r') *q
= *p
;
633 TRACE("returning data: %s\n", debugstr_wn(buffer
, len
));
636 *buflen
= len
* sizeof(WCHAR
);
637 if (request_only
) heap_free( headers
);
640 case WINHTTP_QUERY_RAW_HEADERS_CRLF
:
645 headers
= build_request_string( request
);
647 headers
= request
->raw_headers
;
649 if (!headers
) return FALSE
;
650 len
= strlenW( headers
) * sizeof(WCHAR
);
651 if (!buffer
|| len
+ sizeof(WCHAR
) > *buflen
)
653 len
+= sizeof(WCHAR
);
654 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
658 memcpy( buffer
, headers
, len
+ sizeof(WCHAR
) );
659 TRACE("returning data: %s\n", debugstr_wn(buffer
, len
/ sizeof(WCHAR
)));
663 if (request_only
) heap_free( headers
);
666 case WINHTTP_QUERY_VERSION
:
667 len
= strlenW( request
->version
) * sizeof(WCHAR
);
668 if (!buffer
|| len
+ sizeof(WCHAR
) > *buflen
)
670 len
+= sizeof(WCHAR
);
671 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
675 strcpyW( buffer
, request
->version
);
676 TRACE("returning string: %s\n", debugstr_w(buffer
));
682 case WINHTTP_QUERY_STATUS_TEXT
:
683 len
= strlenW( request
->status_text
) * sizeof(WCHAR
);
684 if (!buffer
|| len
+ sizeof(WCHAR
) > *buflen
)
686 len
+= sizeof(WCHAR
);
687 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
691 strcpyW( buffer
, request
->status_text
);
692 TRACE("returning string: %s\n", debugstr_w(buffer
));
699 if (attr
>= sizeof(attribute_table
)/sizeof(attribute_table
[0]) || !attribute_table
[attr
])
701 FIXME("attribute %u not implemented\n", attr
);
704 TRACE("attribute %s\n", debugstr_w(attribute_table
[attr
]));
705 header_index
= get_header_index( request
, attribute_table
[attr
], requested_index
, request_only
);
709 if (header_index
>= 0)
711 header
= &request
->headers
[header_index
];
713 if (!header
|| (request_only
&& !header
->is_request
))
715 set_last_error( ERROR_WINHTTP_HEADER_NOT_FOUND
);
718 if (index
) *index
+= 1;
719 if (level
& WINHTTP_QUERY_FLAG_NUMBER
)
721 if (!buffer
|| sizeof(int) > *buflen
)
723 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
727 int *number
= buffer
;
728 *number
= atoiW( header
->value
);
729 TRACE("returning number: %d\n", *number
);
732 *buflen
= sizeof(int);
734 else if (level
& WINHTTP_QUERY_FLAG_SYSTEMTIME
)
736 SYSTEMTIME
*st
= buffer
;
737 if (!buffer
|| sizeof(SYSTEMTIME
) > *buflen
)
739 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
741 else if ((ret
= WinHttpTimeToSystemTime( header
->value
, st
)))
743 TRACE("returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
744 st
->wYear
, st
->wMonth
, st
->wDay
, st
->wDayOfWeek
,
745 st
->wHour
, st
->wMinute
, st
->wSecond
, st
->wMilliseconds
);
747 *buflen
= sizeof(SYSTEMTIME
);
749 else if (header
->value
)
751 len
= strlenW( header
->value
) * sizeof(WCHAR
);
752 if (!buffer
|| len
+ sizeof(WCHAR
) > *buflen
)
754 len
+= sizeof(WCHAR
);
755 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
759 strcpyW( buffer
, header
->value
);
760 TRACE("returning string: %s\n", debugstr_w(buffer
));
768 /***********************************************************************
769 * WinHttpQueryHeaders (winhttp.@)
771 BOOL WINAPI
WinHttpQueryHeaders( HINTERNET hrequest
, DWORD level
, LPCWSTR name
, LPVOID buffer
, LPDWORD buflen
, LPDWORD index
)
776 TRACE("%p, 0x%08x, %s, %p, %p, %p\n", hrequest
, level
, debugstr_w(name
), buffer
, buflen
, index
);
778 if (!(request
= (request_t
*)grab_object( hrequest
)))
780 set_last_error( ERROR_INVALID_HANDLE
);
783 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
785 release_object( &request
->hdr
);
786 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
790 ret
= query_headers( request
, level
, name
, buffer
, buflen
, index
);
792 release_object( &request
->hdr
);
796 static LPWSTR
concatenate_string_list( LPCWSTR
*list
, int len
)
801 for( t
= list
; *t
; t
++ )
802 len
+= strlenW( *t
);
805 str
= heap_alloc( len
* sizeof(WCHAR
) );
806 if (!str
) return NULL
;
809 for( t
= list
; *t
; t
++ )
815 static LPWSTR
build_header_request_string( request_t
*request
, LPCWSTR verb
,
816 LPCWSTR path
, LPCWSTR version
)
818 static const WCHAR crlf
[] = {'\r','\n',0};
819 static const WCHAR space
[] = { ' ',0 };
820 static const WCHAR colon
[] = { ':',' ',0 };
821 static const WCHAR twocrlf
[] = {'\r','\n','\r','\n', 0};
822 LPWSTR requestString
;
828 /* allocate space for an array of all the string pointers to be added */
829 len
= (request
->num_headers
) * 4 + 10;
830 req
= heap_alloc( len
* sizeof(LPCWSTR
) );
831 if (!req
) return NULL
;
833 /* add the verb, path and HTTP version string */
841 /* Append custom request headers */
842 for (i
= 0; i
< request
->num_headers
; i
++)
844 if (request
->headers
[i
].is_request
)
847 req
[n
++] = request
->headers
[i
].field
;
849 req
[n
++] = request
->headers
[i
].value
;
851 TRACE("Adding custom header %s (%s)\n",
852 debugstr_w(request
->headers
[i
].field
),
853 debugstr_w(request
->headers
[i
].value
));
858 ERR("oops. buffer overrun\n");
861 requestString
= concatenate_string_list( req
, 4 );
863 if (!requestString
) return NULL
;
866 * Set (header) termination string for request
867 * Make sure there's exactly two new lines at the end of the request
869 p
= &requestString
[strlenW(requestString
)-1];
870 while ( (*p
== '\n') || (*p
== '\r') )
872 strcpyW( p
+1, twocrlf
);
874 return requestString
;
877 static BOOL
read_reply( request_t
*request
);
879 static BOOL
secure_proxy_connect( request_t
*request
)
881 static const WCHAR verbConnect
[] = {'C','O','N','N','E','C','T',0};
882 static const WCHAR fmt
[] = {'%','s',':','%','u',0};
885 connect_t
*connect
= request
->connect
;
887 path
= heap_alloc( (strlenW( connect
->hostname
) + 13) * sizeof(WCHAR
) );
890 LPWSTR requestString
;
892 sprintfW( path
, fmt
, connect
->hostname
, connect
->hostport
);
893 requestString
= build_header_request_string( request
, verbConnect
,
898 LPSTR req_ascii
= strdupWA( requestString
);
900 heap_free( requestString
);
903 int len
= strlen( req_ascii
), bytes_sent
;
905 ret
= netconn_send( &request
->netconn
, req_ascii
, len
, 0, &bytes_sent
);
906 heap_free( req_ascii
);
908 ret
= read_reply( request
);
915 #ifndef INET6_ADDRSTRLEN
916 #define INET6_ADDRSTRLEN 46
919 static WCHAR
*addr_to_str( const struct sockaddr
*addr
)
921 char buf
[INET6_ADDRSTRLEN
];
924 switch (addr
->sa_family
)
927 src
= &((struct sockaddr_in
*)addr
)->sin_addr
;
930 src
= &((struct sockaddr_in6
*)addr
)->sin6_addr
;
933 WARN("unsupported address family %d\n", addr
->sa_family
);
936 if (!inet_ntop( addr
->sa_family
, src
, buf
, sizeof(buf
) )) return NULL
;
937 return strdupAW( buf
);
940 static BOOL
open_connection( request_t
*request
)
943 WCHAR
*addressW
= NULL
;
946 struct sockaddr
*saddr
;
949 if (netconn_connected( &request
->netconn
)) return TRUE
;
951 connect
= request
->connect
;
952 port
= connect
->serverport
? connect
->serverport
: (request
->hdr
.flags
& WINHTTP_FLAG_SECURE
? 443 : 80);
953 saddr
= (struct sockaddr
*)&connect
->sockaddr
;
954 slen
= sizeof(struct sockaddr
);
956 if (!connect
->resolved
)
958 len
= strlenW( connect
->servername
) + 1;
959 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME
, connect
->servername
, len
);
961 if (!netconn_resolve( connect
->servername
, port
, saddr
, &slen
, request
->resolve_timeout
)) return FALSE
;
962 connect
->resolved
= TRUE
;
964 if (!(addressW
= addr_to_str( saddr
))) return FALSE
;
965 len
= strlenW( addressW
) + 1;
966 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED
, addressW
, len
);
968 if (!addressW
&& !(addressW
= addr_to_str( saddr
))) return FALSE
;
969 TRACE("connecting to %s:%u\n", debugstr_w(addressW
), port
);
971 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER
, addressW
, 0 );
973 if (!netconn_create( &request
->netconn
, saddr
->sa_family
, SOCK_STREAM
, 0 ))
975 heap_free( addressW
);
978 netconn_set_timeout( &request
->netconn
, TRUE
, request
->send_timeout
);
979 netconn_set_timeout( &request
->netconn
, FALSE
, request
->recv_timeout
);
980 if (!netconn_connect( &request
->netconn
, saddr
, slen
, request
->connect_timeout
))
982 netconn_close( &request
->netconn
);
983 heap_free( addressW
);
986 if (request
->hdr
.flags
& WINHTTP_FLAG_SECURE
)
988 if (connect
->session
->proxy_server
&&
989 strcmpiW( connect
->hostname
, connect
->servername
))
991 if (!secure_proxy_connect( request
))
993 heap_free( addressW
);
997 if (!netconn_secure_connect( &request
->netconn
, connect
->servername
))
999 netconn_close( &request
->netconn
);
1000 heap_free( addressW
);
1005 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER
, addressW
, strlenW(addressW
) + 1 );
1007 heap_free( addressW
);
1011 void close_connection( request_t
*request
)
1013 if (!netconn_connected( &request
->netconn
)) return;
1015 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION
, 0, 0 );
1016 netconn_close( &request
->netconn
);
1017 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED
, 0, 0 );
1020 static BOOL
add_host_header( request_t
*request
, DWORD modifier
)
1025 static const WCHAR fmt
[] = {'%','s',':','%','u',0};
1026 connect_t
*connect
= request
->connect
;
1029 port
= connect
->hostport
? connect
->hostport
: (request
->hdr
.flags
& WINHTTP_FLAG_SECURE
? 443 : 80);
1031 if (port
== INTERNET_DEFAULT_HTTP_PORT
|| port
== INTERNET_DEFAULT_HTTPS_PORT
)
1033 return process_header( request
, attr_host
, connect
->hostname
, modifier
, TRUE
);
1035 len
= strlenW( connect
->hostname
) + 7; /* sizeof(":65335") */
1036 if (!(host
= heap_alloc( len
* sizeof(WCHAR
) ))) return FALSE
;
1037 sprintfW( host
, fmt
, connect
->hostname
, port
);
1038 ret
= process_header( request
, attr_host
, host
, modifier
, TRUE
);
1043 static BOOL
send_request( request_t
*request
, LPCWSTR headers
, DWORD headers_len
, LPVOID optional
,
1044 DWORD optional_len
, DWORD total_len
, DWORD_PTR context
, BOOL async
)
1046 static const WCHAR keep_alive
[] = {'K','e','e','p','-','A','l','i','v','e',0};
1047 static const WCHAR no_cache
[] = {'n','o','-','c','a','c','h','e',0};
1048 static const WCHAR length_fmt
[] = {'%','l','d',0};
1051 connect_t
*connect
= request
->connect
;
1052 session_t
*session
= connect
->session
;
1056 DWORD len
, i
, flags
;
1058 flags
= WINHTTP_ADDREQ_FLAG_ADD
|WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA
;
1059 for (i
= 0; i
< request
->num_accept_types
; i
++)
1061 process_header( request
, attr_accept
, request
->accept_types
[i
], flags
, TRUE
);
1064 process_header( request
, attr_user_agent
, session
->agent
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
, TRUE
);
1066 if (connect
->hostname
)
1067 add_host_header( request
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
);
1069 if (total_len
|| (request
->verb
&& !strcmpW( request
->verb
, postW
)))
1071 WCHAR length
[21]; /* decimal long int + null */
1072 sprintfW( length
, length_fmt
, total_len
);
1073 process_header( request
, attr_content_length
, length
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
, TRUE
);
1075 if (!(request
->hdr
.disable_flags
& WINHTTP_DISABLE_KEEP_ALIVE
))
1077 process_header( request
, attr_connection
, keep_alive
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
, TRUE
);
1079 if (request
->hdr
.flags
& WINHTTP_FLAG_REFRESH
)
1081 process_header( request
, attr_pragma
, no_cache
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
, TRUE
);
1082 process_header( request
, attr_cache_control
, no_cache
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
, TRUE
);
1084 if (headers
&& !add_request_headers( request
, headers
, headers_len
, WINHTTP_ADDREQ_FLAG_ADD
| WINHTTP_ADDREQ_FLAG_REPLACE
))
1086 TRACE("failed to add request headers\n");
1089 if (!(request
->hdr
.disable_flags
& WINHTTP_DISABLE_COOKIES
) && !add_cookie_headers( request
))
1091 WARN("failed to add cookie headers\n");
1095 if (context
) request
->hdr
.context
= context
;
1097 if (!(ret
= open_connection( request
))) goto end
;
1098 if (!(req
= build_request_string( request
))) goto end
;
1100 if (!(req_ascii
= strdupWA( req
))) goto end
;
1101 TRACE("full request: %s\n", debugstr_a(req_ascii
));
1102 len
= strlen(req_ascii
);
1104 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST
, NULL
, 0 );
1106 ret
= netconn_send( &request
->netconn
, req_ascii
, len
, 0, &bytes_sent
);
1107 heap_free( req_ascii
);
1110 if (optional_len
&& !netconn_send( &request
->netconn
, optional
, optional_len
, 0, &bytes_sent
)) goto end
;
1111 len
+= optional_len
;
1113 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_SENT
, &len
, sizeof(DWORD
) );
1118 if (ret
) send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE
, NULL
, 0 );
1121 WINHTTP_ASYNC_RESULT result
;
1122 result
.dwResult
= API_SEND_REQUEST
;
1123 result
.dwError
= get_last_error();
1124 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
, &result
, sizeof(result
) );
1131 static void task_send_request( task_header_t
*task
)
1133 send_request_t
*s
= (send_request_t
*)task
;
1134 send_request( s
->hdr
.request
, s
->headers
, s
->headers_len
, s
->optional
, s
->optional_len
, s
->total_len
, s
->context
, TRUE
);
1135 heap_free( s
->headers
);
1138 /***********************************************************************
1139 * WinHttpSendRequest (winhttp.@)
1141 BOOL WINAPI
WinHttpSendRequest( HINTERNET hrequest
, LPCWSTR headers
, DWORD headers_len
,
1142 LPVOID optional
, DWORD optional_len
, DWORD total_len
, DWORD_PTR context
)
1147 TRACE("%p, %s, 0x%x, %u, %u, %lx\n",
1148 hrequest
, debugstr_w(headers
), headers_len
, optional_len
, total_len
, context
);
1150 if (!(request
= (request_t
*)grab_object( hrequest
)))
1152 set_last_error( ERROR_INVALID_HANDLE
);
1155 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
1157 release_object( &request
->hdr
);
1158 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
1162 if (request
->connect
->hdr
.flags
& WINHTTP_FLAG_ASYNC
)
1166 if (!(s
= heap_alloc( sizeof(send_request_t
) ))) return FALSE
;
1167 s
->hdr
.request
= request
;
1168 s
->hdr
.proc
= task_send_request
;
1169 s
->headers
= strdupW( headers
);
1170 s
->headers_len
= headers_len
;
1171 s
->optional
= optional
;
1172 s
->optional_len
= optional_len
;
1173 s
->total_len
= total_len
;
1174 s
->context
= context
;
1176 addref_object( &request
->hdr
);
1177 ret
= queue_task( (task_header_t
*)s
);
1180 ret
= send_request( request
, headers
, headers_len
, optional
, optional_len
, total_len
, context
, FALSE
);
1182 release_object( &request
->hdr
);
1186 #define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0]))
1188 static DWORD
auth_scheme_from_header( WCHAR
*header
)
1190 static const WCHAR basic
[] = {'B','a','s','i','c'};
1191 static const WCHAR ntlm
[] = {'N','T','L','M'};
1192 static const WCHAR passport
[] = {'P','a','s','s','p','o','r','t'};
1193 static const WCHAR digest
[] = {'D','i','g','e','s','t'};
1194 static const WCHAR negotiate
[] = {'N','e','g','o','t','i','a','t','e'};
1196 if (!strncmpiW( header
, basic
, ARRAYSIZE(basic
) ) &&
1197 (header
[ARRAYSIZE(basic
)] == ' ' || !header
[ARRAYSIZE(basic
)])) return WINHTTP_AUTH_SCHEME_BASIC
;
1199 if (!strncmpiW( header
, ntlm
, ARRAYSIZE(ntlm
) ) &&
1200 (header
[ARRAYSIZE(ntlm
)] == ' ' || !header
[ARRAYSIZE(ntlm
)])) return WINHTTP_AUTH_SCHEME_NTLM
;
1202 if (!strncmpiW( header
, passport
, ARRAYSIZE(passport
) ) &&
1203 (header
[ARRAYSIZE(passport
)] == ' ' || !header
[ARRAYSIZE(passport
)])) return WINHTTP_AUTH_SCHEME_PASSPORT
;
1205 if (!strncmpiW( header
, digest
, ARRAYSIZE(digest
) ) &&
1206 (header
[ARRAYSIZE(digest
)] == ' ' || !header
[ARRAYSIZE(digest
)])) return WINHTTP_AUTH_SCHEME_DIGEST
;
1208 if (!strncmpiW( header
, negotiate
, ARRAYSIZE(negotiate
) ) &&
1209 (header
[ARRAYSIZE(negotiate
)] == ' ' || !header
[ARRAYSIZE(negotiate
)])) return WINHTTP_AUTH_SCHEME_NEGOTIATE
;
1214 static BOOL
query_auth_schemes( request_t
*request
, DWORD level
, LPDWORD supported
, LPDWORD first
)
1225 query_headers( request
, level
, NULL
, NULL
, &size
, &index
);
1226 if (get_last_error() != ERROR_INSUFFICIENT_BUFFER
) break;
1229 if (!(buffer
= heap_alloc( size
))) return FALSE
;
1230 if (!query_headers( request
, level
, NULL
, buffer
, &size
, &index
))
1232 heap_free( buffer
);
1235 scheme
= auth_scheme_from_header( buffer
);
1236 if (first
&& index
== 1) *first
= scheme
;
1237 *supported
|= scheme
;
1239 heap_free( buffer
);
1245 /***********************************************************************
1246 * WinHttpQueryAuthSchemes (winhttp.@)
1248 BOOL WINAPI
WinHttpQueryAuthSchemes( HINTERNET hrequest
, LPDWORD supported
, LPDWORD first
, LPDWORD target
)
1253 TRACE("%p, %p, %p, %p\n", hrequest
, supported
, first
, target
);
1255 if (!(request
= (request_t
*)grab_object( hrequest
)))
1257 set_last_error( ERROR_INVALID_HANDLE
);
1260 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
1262 release_object( &request
->hdr
);
1263 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
1267 if (query_auth_schemes( request
, WINHTTP_QUERY_WWW_AUTHENTICATE
, supported
, first
))
1269 *target
= WINHTTP_AUTH_TARGET_SERVER
;
1272 else if (query_auth_schemes( request
, WINHTTP_QUERY_PROXY_AUTHENTICATE
, supported
, first
))
1274 *target
= WINHTTP_AUTH_TARGET_PROXY
;
1278 release_object( &request
->hdr
);
1282 static UINT
encode_base64( const char *bin
, unsigned int len
, WCHAR
*base64
)
1285 static const char base64enc
[] =
1286 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1290 /* first 6 bits, all from bin[0] */
1291 base64
[n
++] = base64enc
[(bin
[0] & 0xfc) >> 2];
1292 x
= (bin
[0] & 3) << 4;
1294 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
1297 base64
[n
++] = base64enc
[x
];
1302 base64
[n
++] = base64enc
[x
| ((bin
[1] & 0xf0) >> 4)];
1303 x
= (bin
[1] & 0x0f) << 2;
1305 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
1308 base64
[n
++] = base64enc
[x
];
1312 base64
[n
++] = base64enc
[x
| ((bin
[2] & 0xc0) >> 6)];
1314 /* last 6 bits, all from bin [2] */
1315 base64
[n
++] = base64enc
[bin
[2] & 0x3f];
1323 static BOOL
set_credentials( request_t
*request
, DWORD target
, DWORD scheme
, LPCWSTR username
, LPCWSTR password
)
1325 static const WCHAR basic
[] = {'B','a','s','i','c',' ',0};
1326 const WCHAR
*auth_scheme
, *auth_target
;
1328 DWORD len
, auth_data_len
;
1332 if (!username
|| !password
)
1334 set_last_error( ERROR_INVALID_PARAMETER
);
1340 case WINHTTP_AUTH_TARGET_SERVER
: auth_target
= attr_authorization
; break;
1341 case WINHTTP_AUTH_TARGET_PROXY
: auth_target
= attr_proxy_authorization
; break;
1343 WARN("unknown target %x\n", target
);
1348 case WINHTTP_AUTH_SCHEME_BASIC
:
1350 int userlen
= WideCharToMultiByte( CP_UTF8
, 0, username
, strlenW( username
), NULL
, 0, NULL
, NULL
);
1351 int passlen
= WideCharToMultiByte( CP_UTF8
, 0, password
, strlenW( password
), NULL
, 0, NULL
, NULL
);
1353 TRACE("basic authentication\n");
1355 auth_scheme
= basic
;
1356 auth_data_len
= userlen
+ 1 + passlen
;
1357 if (!(auth_data
= heap_alloc( auth_data_len
))) return FALSE
;
1359 WideCharToMultiByte( CP_UTF8
, 0, username
, -1, auth_data
, userlen
, NULL
, NULL
);
1360 auth_data
[userlen
] = ':';
1361 WideCharToMultiByte( CP_UTF8
, 0, password
, -1, auth_data
+ userlen
+ 1, passlen
, NULL
, NULL
);
1364 case WINHTTP_AUTH_SCHEME_NTLM
:
1365 case WINHTTP_AUTH_SCHEME_PASSPORT
:
1366 case WINHTTP_AUTH_SCHEME_DIGEST
:
1367 case WINHTTP_AUTH_SCHEME_NEGOTIATE
:
1368 FIXME("unimplemented authentication scheme %x\n", scheme
);
1371 WARN("unknown authentication scheme %x\n", scheme
);
1375 len
= strlenW( auth_scheme
) + ((auth_data_len
+ 2) * 4) / 3;
1376 if (!(auth_header
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) )))
1378 heap_free( auth_data
);
1381 strcpyW( auth_header
, auth_scheme
);
1382 encode_base64( auth_data
, auth_data_len
, auth_header
+ strlenW( auth_header
) );
1384 ret
= process_header( request
, auth_target
, auth_header
, WINHTTP_ADDREQ_FLAG_ADD
| WINHTTP_ADDREQ_FLAG_REPLACE
, TRUE
);
1386 heap_free( auth_data
);
1387 heap_free( auth_header
);
1391 /***********************************************************************
1392 * WinHttpSetCredentials (winhttp.@)
1394 BOOL WINAPI
WinHttpSetCredentials( HINTERNET hrequest
, DWORD target
, DWORD scheme
, LPCWSTR username
,
1395 LPCWSTR password
, LPVOID params
)
1400 TRACE("%p, %x, 0x%08x, %s, %p, %p\n", hrequest
, target
, scheme
, debugstr_w(username
), password
, params
);
1402 if (!(request
= (request_t
*)grab_object( hrequest
)))
1404 set_last_error( ERROR_INVALID_HANDLE
);
1407 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
1409 release_object( &request
->hdr
);
1410 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
1414 ret
= set_credentials( request
, target
, scheme
, username
, password
);
1416 release_object( &request
->hdr
);
1420 static BOOL
handle_authorization( request_t
*request
, DWORD status
)
1422 DWORD schemes
, level
, target
;
1423 const WCHAR
*username
, *password
;
1428 target
= WINHTTP_AUTH_TARGET_SERVER
;
1429 level
= WINHTTP_QUERY_WWW_AUTHENTICATE
;
1433 target
= WINHTTP_AUTH_TARGET_PROXY
;
1434 level
= WINHTTP_QUERY_PROXY_AUTHENTICATE
;
1438 WARN("unhandled status %u\n", status
);
1442 if (!query_auth_schemes( request
, level
, &schemes
, NULL
)) return FALSE
;
1444 if (target
== WINHTTP_AUTH_TARGET_SERVER
)
1446 username
= request
->connect
->username
;
1447 password
= request
->connect
->password
;
1451 username
= request
->connect
->session
->proxy_username
;
1452 password
= request
->connect
->session
->proxy_password
;
1455 if (schemes
& WINHTTP_AUTH_SCHEME_BASIC
)
1456 return set_credentials( request
, target
, WINHTTP_AUTH_SCHEME_BASIC
, username
, password
);
1458 FIXME("unsupported authentication scheme\n");
1462 static void clear_response_headers( request_t
*request
)
1466 for (i
= 0; i
< request
->num_headers
; i
++)
1468 if (!request
->headers
[i
].field
) continue;
1469 if (!request
->headers
[i
].value
) continue;
1470 if (request
->headers
[i
].is_request
) continue;
1471 delete_header( request
, i
);
1476 #define MAX_REPLY_LEN 1460
1477 #define INITIAL_HEADER_BUFFER_LEN 512
1479 static BOOL
read_reply( request_t
*request
)
1481 static const WCHAR crlf
[] = {'\r','\n',0};
1483 char buffer
[MAX_REPLY_LEN
];
1484 DWORD buflen
, len
, offset
, received_len
, crlf_len
= 2; /* strlenW(crlf) */
1485 char *status_code
, *status_text
;
1486 WCHAR
*versionW
, *status_textW
, *raw_headers
;
1487 WCHAR status_codeW
[4]; /* sizeof("nnn") */
1489 if (!netconn_connected( &request
->netconn
)) return FALSE
;
1491 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE
, NULL
, 0 );
1496 buflen
= MAX_REPLY_LEN
;
1497 if (!netconn_get_next_line( &request
->netconn
, buffer
, &buflen
)) return FALSE
;
1498 received_len
+= buflen
;
1500 /* first line should look like 'HTTP/1.x nnn OK' where nnn is the status code */
1501 if (!(status_code
= strchr( buffer
, ' ' ))) return FALSE
;
1503 if (!(status_text
= strchr( status_code
, ' ' ))) return FALSE
;
1504 if ((len
= status_text
- status_code
) != sizeof("nnn") - 1) return FALSE
;
1507 TRACE("version [%s] status code [%s] status text [%s]\n",
1508 debugstr_an(buffer
, status_code
- buffer
- 1),
1509 debugstr_an(status_code
, len
),
1510 debugstr_a(status_text
));
1512 } while (!memcmp( status_code
, "100", len
)); /* ignore "100 Continue" responses */
1514 /* we rely on the fact that the protocol is ascii */
1515 MultiByteToWideChar( CP_ACP
, 0, status_code
, len
, status_codeW
, len
);
1516 status_codeW
[len
] = 0;
1517 if (!(process_header( request
, attr_status
, status_codeW
, WINHTTP_ADDREQ_FLAG_REPLACE
, FALSE
))) return FALSE
;
1519 len
= status_code
- buffer
;
1520 if (!(versionW
= heap_alloc( len
* sizeof(WCHAR
) ))) return FALSE
;
1521 MultiByteToWideChar( CP_ACP
, 0, buffer
, len
- 1, versionW
, len
-1 );
1522 versionW
[len
- 1] = 0;
1524 heap_free( request
->version
);
1525 request
->version
= versionW
;
1527 len
= buflen
- (status_text
- buffer
);
1528 if (!(status_textW
= heap_alloc( len
* sizeof(WCHAR
) ))) return FALSE
;
1529 MultiByteToWideChar( CP_ACP
, 0, status_text
, len
, status_textW
, len
);
1531 heap_free( request
->status_text
);
1532 request
->status_text
= status_textW
;
1534 len
= max( buflen
+ crlf_len
, INITIAL_HEADER_BUFFER_LEN
);
1535 if (!(raw_headers
= heap_alloc( len
* sizeof(WCHAR
) ))) return FALSE
;
1536 MultiByteToWideChar( CP_ACP
, 0, buffer
, buflen
, raw_headers
, buflen
);
1537 memcpy( raw_headers
+ buflen
- 1, crlf
, sizeof(crlf
) );
1539 heap_free( request
->raw_headers
);
1540 request
->raw_headers
= raw_headers
;
1542 offset
= buflen
+ crlf_len
- 1;
1547 buflen
= MAX_REPLY_LEN
;
1548 if (!netconn_get_next_line( &request
->netconn
, buffer
, &buflen
)) goto end
;
1549 received_len
+= buflen
;
1550 if (!*buffer
) break;
1552 while (len
- offset
< buflen
+ crlf_len
)
1556 if (!(tmp
= heap_realloc( raw_headers
, len
* sizeof(WCHAR
) ))) return FALSE
;
1557 request
->raw_headers
= raw_headers
= tmp
;
1559 MultiByteToWideChar( CP_ACP
, 0, buffer
, buflen
, raw_headers
+ offset
, buflen
);
1561 if (!(header
= parse_header( raw_headers
+ offset
))) break;
1562 if (!(process_header( request
, header
->field
, header
->value
, WINHTTP_ADDREQ_FLAG_ADD
, FALSE
)))
1564 free_header( header
);
1567 free_header( header
);
1568 memcpy( raw_headers
+ offset
+ buflen
- 1, crlf
, sizeof(crlf
) );
1569 offset
+= buflen
+ crlf_len
- 1;
1572 TRACE("raw headers: %s\n", debugstr_w(raw_headers
));
1575 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED
, &received_len
, sizeof(DWORD
) );
1579 static BOOL
handle_redirect( request_t
*request
, DWORD status
)
1584 connect_t
*connect
= request
->connect
;
1586 WCHAR
*hostname
= NULL
, *location
= NULL
;
1590 query_headers( request
, WINHTTP_QUERY_LOCATION
, NULL
, NULL
, &size
, NULL
);
1591 if (!(location
= heap_alloc( size
))) return FALSE
;
1592 if (!query_headers( request
, WINHTTP_QUERY_LOCATION
, NULL
, location
, &size
, NULL
)) goto end
;
1594 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REDIRECT
, location
, size
/ sizeof(WCHAR
) + 1 );
1596 memset( &uc
, 0, sizeof(uc
) );
1597 uc
.dwStructSize
= sizeof(uc
);
1598 uc
.dwSchemeLength
= uc
.dwHostNameLength
= uc
.dwUrlPathLength
= uc
.dwExtraInfoLength
= ~0u;
1600 if (!WinHttpCrackUrl( location
, size
/ sizeof(WCHAR
), 0, &uc
)) /* assume relative redirect */
1604 len
= strlenW( location
) + 1;
1605 if (location
[0] != '/') len
++;
1606 if (!(p
= path
= heap_alloc( len
* sizeof(WCHAR
) ))) goto end
;
1608 if (location
[0] != '/') *p
++ = '/';
1609 strcpyW( p
, location
);
1611 heap_free( request
->path
);
1612 request
->path
= path
;
1616 if (uc
.nScheme
== INTERNET_SCHEME_HTTP
&& request
->hdr
.flags
& WINHTTP_FLAG_SECURE
)
1618 TRACE("redirect from secure page to non-secure page\n");
1619 request
->hdr
.flags
&= ~WINHTTP_FLAG_SECURE
;
1621 else if (uc
.nScheme
== INTERNET_SCHEME_HTTPS
&& !(request
->hdr
.flags
& WINHTTP_FLAG_SECURE
))
1623 TRACE("redirect from non-secure page to secure page\n");
1624 request
->hdr
.flags
|= WINHTTP_FLAG_SECURE
;
1627 len
= uc
.dwHostNameLength
;
1628 if (!(hostname
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) ))) goto end
;
1629 memcpy( hostname
, uc
.lpszHostName
, len
* sizeof(WCHAR
) );
1632 port
= uc
.nPort
? uc
.nPort
: (uc
.nScheme
== INTERNET_SCHEME_HTTPS
? 443 : 80);
1633 if (strcmpiW( connect
->hostname
, hostname
) || connect
->serverport
!= port
)
1635 heap_free( connect
->hostname
);
1636 connect
->hostname
= hostname
;
1637 connect
->hostport
= port
;
1638 if (!(ret
= set_server_for_hostname( connect
, hostname
, port
))) goto end
;
1640 netconn_close( &request
->netconn
);
1641 if (!(ret
= netconn_init( &request
->netconn
, request
->hdr
.flags
& WINHTTP_FLAG_SECURE
))) goto end
;
1643 if (!(ret
= add_host_header( request
, WINHTTP_ADDREQ_FLAG_REPLACE
))) goto end
;
1644 if (!(ret
= open_connection( request
))) goto end
;
1646 heap_free( request
->path
);
1647 request
->path
= NULL
;
1648 if (uc
.dwUrlPathLength
)
1650 len
= uc
.dwUrlPathLength
+ uc
.dwExtraInfoLength
;
1651 if (!(request
->path
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) ))) goto end
;
1652 strcpyW( request
->path
, uc
.lpszUrlPath
);
1654 else request
->path
= strdupW( slashW
);
1657 /* remove content-type/length headers */
1658 if ((index
= get_header_index( request
, attr_content_type
, 0, TRUE
)) >= 0) delete_header( request
, index
);
1659 if ((index
= get_header_index( request
, attr_content_length
, 0, TRUE
)) >= 0 ) delete_header( request
, index
);
1661 if (status
!= HTTP_STATUS_REDIRECT_KEEP_VERB
&& !strcmpW( request
->verb
, postW
))
1663 heap_free( request
->verb
);
1664 request
->verb
= strdupW( getW
);
1669 if (!ret
) heap_free( hostname
);
1670 heap_free( location
);
1674 static BOOL
receive_data( request_t
*request
, void *buffer
, DWORD size
, DWORD
*read
, BOOL async
)
1679 to_read
= min( size
, request
->content_length
- request
->content_read
);
1680 if (!netconn_recv( &request
->netconn
, buffer
, to_read
, async
? 0 : MSG_WAITALL
, &bytes_read
))
1682 if (bytes_read
!= to_read
)
1684 ERR("not all data received %d/%d\n", bytes_read
, to_read
);
1686 /* always return success, even if the network layer returns an error */
1690 request
->content_read
+= bytes_read
;
1695 static DWORD
get_chunk_size( const char *buffer
)
1700 for (p
= buffer
; *p
; p
++)
1702 if (*p
>= '0' && *p
<= '9') size
= size
* 16 + *p
- '0';
1703 else if (*p
>= 'a' && *p
<= 'f') size
= size
* 16 + *p
- 'a' + 10;
1704 else if (*p
>= 'A' && *p
<= 'F') size
= size
* 16 + *p
- 'A' + 10;
1705 else if (*p
== ';') break;
1710 static BOOL
receive_data_chunked( request_t
*request
, void *buffer
, DWORD size
, DWORD
*read
, BOOL async
)
1712 char reply
[MAX_REPLY_LEN
], *p
= buffer
;
1713 DWORD buflen
, to_read
, to_write
= size
;
1719 if (*read
== size
) break;
1721 if (request
->content_length
== ~0u) /* new chunk */
1723 buflen
= sizeof(reply
);
1724 if (!netconn_get_next_line( &request
->netconn
, reply
, &buflen
)) break;
1726 if (!(request
->content_length
= get_chunk_size( reply
)))
1728 /* zero sized chunk marks end of transfer; read any trailing headers and return */
1729 read_reply( request
);
1733 to_read
= min( to_write
, request
->content_length
- request
->content_read
);
1735 if (!netconn_recv( &request
->netconn
, p
, to_read
, async
? 0 : MSG_WAITALL
, &bytes_read
))
1737 if (bytes_read
!= to_read
)
1739 ERR("Not all data received %d/%d\n", bytes_read
, to_read
);
1741 /* always return success, even if the network layer returns an error */
1745 if (!bytes_read
) break;
1747 request
->content_read
+= bytes_read
;
1748 to_write
-= bytes_read
;
1749 *read
+= bytes_read
;
1752 if (request
->content_read
== request
->content_length
) /* chunk complete */
1754 request
->content_read
= 0;
1755 request
->content_length
= ~0u;
1757 buflen
= sizeof(reply
);
1758 if (!netconn_get_next_line( &request
->netconn
, reply
, &buflen
))
1760 ERR("Malformed chunk\n");
1769 static void finished_reading( request_t
*request
)
1771 static const WCHAR closeW
[] = {'c','l','o','s','e',0};
1774 WCHAR connection
[20];
1775 DWORD size
= sizeof(connection
);
1777 if (request
->hdr
.disable_flags
& WINHTTP_DISABLE_KEEP_ALIVE
) close
= TRUE
;
1778 else if (query_headers( request
, WINHTTP_QUERY_CONNECTION
, NULL
, connection
, &size
, NULL
) ||
1779 query_headers( request
, WINHTTP_QUERY_PROXY_CONNECTION
, NULL
, connection
, &size
, NULL
))
1781 if (!strcmpiW( connection
, closeW
)) close
= TRUE
;
1783 else if (!strcmpW( request
->version
, http1_0
)) close
= TRUE
;
1785 if (close
) close_connection( request
);
1786 request
->content_length
= ~0u;
1787 request
->content_read
= 0;
1790 static BOOL
read_data( request_t
*request
, void *buffer
, DWORD to_read
, DWORD
*read
, BOOL async
)
1792 static const WCHAR chunked
[] = {'c','h','u','n','k','e','d',0};
1796 DWORD num_bytes
, buflen
= sizeof(encoding
);
1798 if (query_headers( request
, WINHTTP_QUERY_TRANSFER_ENCODING
, NULL
, encoding
, &buflen
, NULL
) &&
1799 !strcmpiW( encoding
, chunked
))
1801 ret
= receive_data_chunked( request
, buffer
, to_read
, &num_bytes
, async
);
1804 ret
= receive_data( request
, buffer
, to_read
, &num_bytes
, async
);
1808 if (ret
) send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_READ_COMPLETE
, buffer
, num_bytes
);
1811 WINHTTP_ASYNC_RESULT result
;
1812 result
.dwResult
= API_READ_DATA
;
1813 result
.dwError
= get_last_error();
1814 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
, &result
, sizeof(result
) );
1819 if (read
) *read
= num_bytes
;
1820 if (!num_bytes
) finished_reading( request
);
1825 /* read any content returned by the server so that the connection can be reused */
1826 static void drain_content( request_t
*request
)
1831 if (!request
->content_length
)
1833 finished_reading( request
);
1838 if (!read_data( request
, buffer
, sizeof(buffer
), &bytes_read
, FALSE
) || !bytes_read
) return;
1842 static void record_cookies( request_t
*request
)
1846 for (i
= 0; i
< request
->num_headers
; i
++)
1848 header_t
*set_cookie
= &request
->headers
[i
];
1849 if (!strcmpiW( set_cookie
->field
, attr_set_cookie
) && !set_cookie
->is_request
)
1851 set_cookies( request
, set_cookie
->value
);
1856 static BOOL
receive_response( request_t
*request
, BOOL async
)
1859 DWORD size
, query
, status
;
1863 if (!(ret
= read_reply( request
)))
1865 set_last_error( ERROR_WINHTTP_INVALID_SERVER_RESPONSE
);
1868 size
= sizeof(DWORD
);
1869 query
= WINHTTP_QUERY_STATUS_CODE
| WINHTTP_QUERY_FLAG_NUMBER
;
1870 if (!(ret
= query_headers( request
, query
, NULL
, &status
, &size
, NULL
))) break;
1872 size
= sizeof(DWORD
);
1873 query
= WINHTTP_QUERY_CONTENT_LENGTH
| WINHTTP_QUERY_FLAG_NUMBER
;
1874 if (!query_headers( request
, query
, NULL
, &request
->content_length
, &size
, NULL
))
1875 request
->content_length
= ~0u;
1877 if (!(request
->hdr
.disable_flags
& WINHTTP_DISABLE_COOKIES
)) record_cookies( request
);
1879 if (status
== HTTP_STATUS_MOVED
|| status
== HTTP_STATUS_REDIRECT
|| status
== HTTP_STATUS_REDIRECT_KEEP_VERB
)
1881 if (request
->hdr
.disable_flags
& WINHTTP_DISABLE_REDIRECTS
) break;
1883 drain_content( request
);
1884 if (!(ret
= handle_redirect( request
, status
))) break;
1886 clear_response_headers( request
);
1887 send_request( request
, NULL
, 0, NULL
, 0, 0, 0, FALSE
); /* recurse synchronously */
1890 else if (status
== 401 || status
== 407)
1892 if (request
->hdr
.disable_flags
& WINHTTP_DISABLE_AUTHENTICATION
) break;
1894 drain_content( request
);
1895 if (!handle_authorization( request
, status
))
1900 clear_response_headers( request
);
1901 send_request( request
, NULL
, 0, NULL
, 0, 0, 0, FALSE
);
1909 if (ret
) send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE
, NULL
, 0 );
1912 WINHTTP_ASYNC_RESULT result
;
1913 result
.dwResult
= API_RECEIVE_RESPONSE
;
1914 result
.dwError
= get_last_error();
1915 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
, &result
, sizeof(result
) );
1921 static void task_receive_response( task_header_t
*task
)
1923 receive_response_t
*r
= (receive_response_t
*)task
;
1924 receive_response( r
->hdr
.request
, TRUE
);
1927 /***********************************************************************
1928 * WinHttpReceiveResponse (winhttp.@)
1930 BOOL WINAPI
WinHttpReceiveResponse( HINTERNET hrequest
, LPVOID reserved
)
1935 TRACE("%p, %p\n", hrequest
, reserved
);
1937 if (!(request
= (request_t
*)grab_object( hrequest
)))
1939 set_last_error( ERROR_INVALID_HANDLE
);
1942 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
1944 release_object( &request
->hdr
);
1945 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
1949 if (request
->connect
->hdr
.flags
& WINHTTP_FLAG_ASYNC
)
1951 receive_response_t
*r
;
1953 if (!(r
= heap_alloc( sizeof(receive_response_t
) ))) return FALSE
;
1954 r
->hdr
.request
= request
;
1955 r
->hdr
.proc
= task_receive_response
;
1957 addref_object( &request
->hdr
);
1958 ret
= queue_task( (task_header_t
*)r
);
1961 ret
= receive_response( request
, FALSE
);
1963 release_object( &request
->hdr
);
1967 static BOOL
query_data( request_t
*request
, LPDWORD available
, BOOL async
)
1972 if ((ret
= netconn_query_data_available( &request
->netconn
, &num_bytes
)))
1974 if (request
->content_read
< request
->content_length
)
1979 size_t to_read
= min( sizeof(buffer
), request
->content_length
- request
->content_read
);
1981 ret
= netconn_recv( &request
->netconn
, buffer
, to_read
, MSG_PEEK
, (int *)&num_bytes
);
1982 if (ret
&& !num_bytes
) WARN("expected more data to be available\n");
1987 WARN("extra data available %u\n", num_bytes
);
1991 TRACE("%u bytes available\n", num_bytes
);
1995 if (ret
) send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE
, &num_bytes
, sizeof(DWORD
) );
1998 WINHTTP_ASYNC_RESULT result
;
1999 result
.dwResult
= API_QUERY_DATA_AVAILABLE
;
2000 result
.dwError
= get_last_error();
2001 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
, &result
, sizeof(result
) );
2004 if (ret
&& available
) *available
= num_bytes
;
2008 static void task_query_data( task_header_t
*task
)
2010 query_data_t
*q
= (query_data_t
*)task
;
2011 query_data( q
->hdr
.request
, q
->available
, TRUE
);
2014 /***********************************************************************
2015 * WinHttpQueryDataAvailable (winhttp.@)
2017 BOOL WINAPI
WinHttpQueryDataAvailable( HINTERNET hrequest
, LPDWORD available
)
2022 TRACE("%p, %p\n", hrequest
, available
);
2024 if (!(request
= (request_t
*)grab_object( hrequest
)))
2026 set_last_error( ERROR_INVALID_HANDLE
);
2029 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
2031 release_object( &request
->hdr
);
2032 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
2036 if (request
->connect
->hdr
.flags
& WINHTTP_FLAG_ASYNC
)
2040 if (!(q
= heap_alloc( sizeof(query_data_t
) ))) return FALSE
;
2041 q
->hdr
.request
= request
;
2042 q
->hdr
.proc
= task_query_data
;
2043 q
->available
= available
;
2045 addref_object( &request
->hdr
);
2046 ret
= queue_task( (task_header_t
*)q
);
2049 ret
= query_data( request
, available
, FALSE
);
2051 release_object( &request
->hdr
);
2055 static void task_read_data( task_header_t
*task
)
2057 read_data_t
*r
= (read_data_t
*)task
;
2058 read_data( r
->hdr
.request
, r
->buffer
, r
->to_read
, r
->read
, TRUE
);
2061 /***********************************************************************
2062 * WinHttpReadData (winhttp.@)
2064 BOOL WINAPI
WinHttpReadData( HINTERNET hrequest
, LPVOID buffer
, DWORD to_read
, LPDWORD read
)
2069 TRACE("%p, %p, %d, %p\n", hrequest
, buffer
, to_read
, read
);
2071 if (!(request
= (request_t
*)grab_object( hrequest
)))
2073 set_last_error( ERROR_INVALID_HANDLE
);
2076 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
2078 release_object( &request
->hdr
);
2079 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
2083 if (request
->connect
->hdr
.flags
& WINHTTP_FLAG_ASYNC
)
2087 if (!(r
= heap_alloc( sizeof(read_data_t
) ))) return FALSE
;
2088 r
->hdr
.request
= request
;
2089 r
->hdr
.proc
= task_read_data
;
2091 r
->to_read
= to_read
;
2094 addref_object( &request
->hdr
);
2095 ret
= queue_task( (task_header_t
*)r
);
2098 ret
= read_data( request
, buffer
, to_read
, read
, FALSE
);
2100 release_object( &request
->hdr
);
2104 static BOOL
write_data( request_t
*request
, LPCVOID buffer
, DWORD to_write
, LPDWORD written
, BOOL async
)
2109 ret
= netconn_send( &request
->netconn
, buffer
, to_write
, 0, &num_bytes
);
2113 if (ret
) send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE
, &num_bytes
, sizeof(DWORD
) );
2116 WINHTTP_ASYNC_RESULT result
;
2117 result
.dwResult
= API_WRITE_DATA
;
2118 result
.dwError
= get_last_error();
2119 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
, &result
, sizeof(result
) );
2122 if (ret
&& written
) *written
= num_bytes
;
2126 static void task_write_data( task_header_t
*task
)
2128 write_data_t
*w
= (write_data_t
*)task
;
2129 write_data( w
->hdr
.request
, w
->buffer
, w
->to_write
, w
->written
, TRUE
);
2132 /***********************************************************************
2133 * WinHttpWriteData (winhttp.@)
2135 BOOL WINAPI
WinHttpWriteData( HINTERNET hrequest
, LPCVOID buffer
, DWORD to_write
, LPDWORD written
)
2140 TRACE("%p, %p, %d, %p\n", hrequest
, buffer
, to_write
, written
);
2142 if (!(request
= (request_t
*)grab_object( hrequest
)))
2144 set_last_error( ERROR_INVALID_HANDLE
);
2147 if (request
->hdr
.type
!= WINHTTP_HANDLE_TYPE_REQUEST
)
2149 release_object( &request
->hdr
);
2150 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
2154 if (request
->connect
->hdr
.flags
& WINHTTP_FLAG_ASYNC
)
2158 if (!(w
= heap_alloc( sizeof(write_data_t
) ))) return FALSE
;
2159 w
->hdr
.request
= request
;
2160 w
->hdr
.proc
= task_write_data
;
2162 w
->to_write
= to_write
;
2163 w
->written
= written
;
2165 addref_object( &request
->hdr
);
2166 ret
= queue_task( (task_header_t
*)w
);
2169 ret
= write_data( request
, buffer
, to_write
, written
, FALSE
);
2171 release_object( &request
->hdr
);
2177 REQUEST_STATE_UNINITIALIZED
,
2178 REQUEST_STATE_INITIALIZED
,
2179 REQUEST_STATE_CANCELLED
,
2182 REQUEST_STATE_RESPONSE_RECEIVED
2185 struct winhttp_request
2187 IWinHttpRequest IWinHttpRequest_iface
;
2189 CRITICAL_SECTION cs
;
2190 enum request_state state
;
2201 DWORD bytes_available
;
2205 DWORD disable_feature
;
2206 LONG resolve_timeout
;
2207 LONG connect_timeout
;
2209 LONG receive_timeout
;
2210 WINHTTP_PROXY_INFO proxy
;
2213 static inline struct winhttp_request
*impl_from_IWinHttpRequest( IWinHttpRequest
*iface
)
2215 return CONTAINING_RECORD( iface
, struct winhttp_request
, IWinHttpRequest_iface
);
2218 static ULONG WINAPI
winhttp_request_AddRef(
2219 IWinHttpRequest
*iface
)
2221 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2222 return InterlockedIncrement( &request
->refs
);
2225 /* critical section must be held */
2226 static void cancel_request( struct winhttp_request
*request
)
2228 if (request
->state
<= REQUEST_STATE_CANCELLED
) return;
2229 if (request
->thread
) SetEvent( request
->cancel
);
2230 request
->state
= REQUEST_STATE_CANCELLED
;
2233 /* critical section must be held */
2234 static void free_request( struct winhttp_request
*request
)
2236 if (request
->state
< REQUEST_STATE_INITIALIZED
) return;
2237 WinHttpCloseHandle( request
->hrequest
);
2238 WinHttpCloseHandle( request
->hconnect
);
2239 WinHttpCloseHandle( request
->hsession
);
2240 CloseHandle( request
->thread
);
2241 CloseHandle( request
->wait
);
2242 CloseHandle( request
->cancel
);
2243 heap_free( (WCHAR
*)request
->proxy
.lpszProxy
);
2244 heap_free( (WCHAR
*)request
->proxy
.lpszProxyBypass
);
2245 heap_free( request
->buffer
);
2246 heap_free( request
->verb
);
2247 VariantClear( &request
->data
);
2250 static ULONG WINAPI
winhttp_request_Release(
2251 IWinHttpRequest
*iface
)
2253 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2254 LONG refs
= InterlockedDecrement( &request
->refs
);
2257 TRACE("destroying %p\n", request
);
2259 EnterCriticalSection( &request
->cs
);
2260 cancel_request( request
);
2261 free_request( request
);
2262 LeaveCriticalSection( &request
->cs
);
2263 request
->cs
.DebugInfo
->Spare
[0] = 0;
2264 DeleteCriticalSection( &request
->cs
);
2265 heap_free( request
);
2270 static HRESULT WINAPI
winhttp_request_QueryInterface(
2271 IWinHttpRequest
*iface
,
2275 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2277 TRACE("%p, %s, %p\n", request
, debugstr_guid(riid
), obj
);
2279 if (IsEqualGUID( riid
, &IID_IWinHttpRequest
) ||
2280 IsEqualGUID( riid
, &IID_IDispatch
) ||
2281 IsEqualGUID( riid
, &IID_IUnknown
))
2287 FIXME("interface %s not implemented\n", debugstr_guid(riid
));
2288 return E_NOINTERFACE
;
2290 IWinHttpRequest_AddRef( iface
);
2294 static HRESULT WINAPI
winhttp_request_GetTypeInfoCount(
2295 IWinHttpRequest
*iface
,
2298 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2300 TRACE("%p, %p\n", request
, count
);
2307 IWinHttpRequest_tid
,
2311 static ITypeLib
*winhttp_typelib
;
2312 static ITypeInfo
*winhttp_typeinfo
[last_tid
];
2314 static REFIID winhttp_tid_id
[] =
2316 &IID_IWinHttpRequest
2319 static HRESULT
get_typeinfo( enum type_id tid
, ITypeInfo
**ret
)
2323 if (!winhttp_typelib
)
2327 hr
= LoadRegTypeLib( &LIBID_WinHttp
, 5, 1, LOCALE_SYSTEM_DEFAULT
, &typelib
);
2330 ERR("LoadRegTypeLib failed: %08x\n", hr
);
2333 if (InterlockedCompareExchangePointer( (void **)&winhttp_typelib
, typelib
, NULL
))
2334 ITypeLib_Release( typelib
);
2336 if (!winhttp_typeinfo
[tid
])
2338 ITypeInfo
*typeinfo
;
2340 hr
= ITypeLib_GetTypeInfoOfGuid( winhttp_typelib
, winhttp_tid_id
[tid
], &typeinfo
);
2343 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(winhttp_tid_id
[tid
]), hr
);
2346 if (InterlockedCompareExchangePointer( (void **)(winhttp_typeinfo
+ tid
), typeinfo
, NULL
))
2347 ITypeInfo_Release( typeinfo
);
2349 *ret
= winhttp_typeinfo
[tid
];
2353 static HRESULT WINAPI
winhttp_request_GetTypeInfo(
2354 IWinHttpRequest
*iface
,
2359 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2360 TRACE("%p, %u, %u, %p\n", request
, index
, lcid
, info
);
2362 return get_typeinfo( IWinHttpRequest_tid
, info
);
2365 static HRESULT WINAPI
winhttp_request_GetIDsOfNames(
2366 IWinHttpRequest
*iface
,
2373 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2374 ITypeInfo
*typeinfo
;
2377 TRACE("%p, %s, %p, %u, %u, %p\n", request
, debugstr_guid(riid
), names
, count
, lcid
, dispid
);
2379 if (!names
|| !count
|| !dispid
) return E_INVALIDARG
;
2381 hr
= get_typeinfo( IWinHttpRequest_tid
, &typeinfo
);
2384 hr
= ITypeInfo_GetIDsOfNames( typeinfo
, names
, count
, dispid
);
2385 ITypeInfo_Release( typeinfo
);
2390 static HRESULT WINAPI
winhttp_request_Invoke(
2391 IWinHttpRequest
*iface
,
2398 EXCEPINFO
*excep_info
,
2401 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2402 ITypeInfo
*typeinfo
;
2405 TRACE("%p, %d, %s, %d, %d, %p, %p, %p, %p\n", request
, member
, debugstr_guid(riid
),
2406 lcid
, flags
, params
, result
, excep_info
, arg_err
);
2408 hr
= get_typeinfo( IWinHttpRequest_tid
, &typeinfo
);
2411 hr
= ITypeInfo_Invoke( typeinfo
, &request
->IWinHttpRequest_iface
, member
, flags
,
2412 params
, result
, excep_info
, arg_err
);
2413 ITypeInfo_Release( typeinfo
);
2418 static HRESULT WINAPI
winhttp_request_SetProxy(
2419 IWinHttpRequest
*iface
,
2420 HTTPREQUEST_PROXY_SETTING proxy_setting
,
2421 VARIANT proxy_server
,
2422 VARIANT bypass_list
)
2424 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2425 DWORD err
= ERROR_SUCCESS
;
2427 TRACE("%p, %u, %s, %s\n", request
, proxy_setting
, debugstr_variant(&proxy_server
),
2428 debugstr_variant(&bypass_list
));
2430 EnterCriticalSection( &request
->cs
);
2431 switch (proxy_setting
)
2433 case HTTPREQUEST_PROXYSETTING_DEFAULT
:
2434 request
->proxy
.dwAccessType
= WINHTTP_ACCESS_TYPE_DEFAULT_PROXY
;
2435 heap_free( (WCHAR
*)request
->proxy
.lpszProxy
);
2436 heap_free( (WCHAR
*)request
->proxy
.lpszProxyBypass
);
2437 request
->proxy
.lpszProxy
= NULL
;
2438 request
->proxy
.lpszProxyBypass
= NULL
;
2441 case HTTPREQUEST_PROXYSETTING_DIRECT
:
2442 request
->proxy
.dwAccessType
= WINHTTP_ACCESS_TYPE_NO_PROXY
;
2443 heap_free( (WCHAR
*)request
->proxy
.lpszProxy
);
2444 heap_free( (WCHAR
*)request
->proxy
.lpszProxyBypass
);
2445 request
->proxy
.lpszProxy
= NULL
;
2446 request
->proxy
.lpszProxyBypass
= NULL
;
2449 case HTTPREQUEST_PROXYSETTING_PROXY
:
2450 request
->proxy
.dwAccessType
= WINHTTP_ACCESS_TYPE_NAMED_PROXY
;
2451 if (V_VT( &proxy_server
) == VT_BSTR
)
2453 heap_free( (WCHAR
*)request
->proxy
.lpszProxy
);
2454 request
->proxy
.lpszProxy
= strdupW( V_BSTR( &proxy_server
) );
2456 if (V_VT( &bypass_list
) == VT_BSTR
)
2458 heap_free( (WCHAR
*)request
->proxy
.lpszProxyBypass
);
2459 request
->proxy
.lpszProxyBypass
= strdupW( V_BSTR( &bypass_list
) );
2464 err
= ERROR_INVALID_PARAMETER
;
2467 LeaveCriticalSection( &request
->cs
);
2468 return HRESULT_FROM_WIN32( err
);
2471 static HRESULT WINAPI
winhttp_request_SetCredentials(
2472 IWinHttpRequest
*iface
,
2475 HTTPREQUEST_SETCREDENTIALS_FLAGS flags
)
2477 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2478 DWORD target
, scheme
= WINHTTP_AUTH_SCHEME_BASIC
; /* FIXME: query supported schemes */
2479 DWORD err
= ERROR_SUCCESS
;
2481 TRACE("%p, %s, %p\n", request
, debugstr_w(username
), password
);
2483 EnterCriticalSection( &request
->cs
);
2484 if (request
->state
< REQUEST_STATE_OPEN
)
2486 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN
;
2491 case HTTPREQUEST_SETCREDENTIALS_FOR_SERVER
:
2492 target
= WINHTTP_AUTH_TARGET_SERVER
;
2494 case HTTPREQUEST_SETCREDENTIALS_FOR_PROXY
:
2495 target
= WINHTTP_AUTH_TARGET_PROXY
;
2498 err
= ERROR_INVALID_PARAMETER
;
2501 if (!WinHttpSetCredentials( request
->hrequest
, target
, scheme
, username
, password
, NULL
))
2503 err
= get_last_error();
2506 LeaveCriticalSection( &request
->cs
);
2507 return HRESULT_FROM_WIN32( err
);
2510 static void initialize_request( struct winhttp_request
*request
)
2512 request
->hrequest
= NULL
;
2513 request
->hconnect
= NULL
;
2514 request
->hsession
= NULL
;
2515 request
->thread
= NULL
;
2516 request
->wait
= NULL
;
2517 request
->cancel
= NULL
;
2518 request
->buffer
= NULL
;
2519 request
->verb
= NULL
;
2520 request
->offset
= 0;
2521 request
->bytes_available
= 0;
2522 request
->bytes_read
= 0;
2523 request
->error
= ERROR_SUCCESS
;
2524 request
->logon_policy
= WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM
;
2525 request
->disable_feature
= WINHTTP_DISABLE_AUTHENTICATION
;
2526 request
->proxy
.dwAccessType
= WINHTTP_ACCESS_TYPE_DEFAULT_PROXY
;
2527 request
->proxy
.lpszProxy
= NULL
;
2528 request
->proxy
.lpszProxyBypass
= NULL
;
2529 request
->resolve_timeout
= 0;
2530 request
->connect_timeout
= 60000;
2531 request
->send_timeout
= 30000;
2532 request
->receive_timeout
= 30000;
2533 VariantInit( &request
->data
);
2534 request
->state
= REQUEST_STATE_INITIALIZED
;
2537 static HRESULT WINAPI
winhttp_request_Open(
2538 IWinHttpRequest
*iface
,
2543 static const WCHAR typeW
[] = {'*','/','*',0};
2544 static const WCHAR
*acceptW
[] = {typeW
, NULL
};
2545 static const WCHAR httpsW
[] = {'h','t','t','p','s'};
2546 static const WCHAR user_agentW
[] = {
2547 'M','o','z','i','l','l','a','/','4','.','0',' ','(','c','o','m','p','a','t','i','b','l','e',';',' ',
2548 'W','i','n','3','2',';',' ','W','i','n','H','t','t','p','.','W','i','n','H','t','t','p',
2549 'R','e','q','u','e','s','t','.','5',')',0};
2550 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2551 HINTERNET hsession
= NULL
, hconnect
= NULL
, hrequest
;
2553 WCHAR
*hostname
, *path
= NULL
, *verb
= NULL
;
2554 DWORD err
= ERROR_OUTOFMEMORY
, len
, flags
= 0, request_flags
= 0;
2556 TRACE("%p, %s, %s, %s\n", request
, debugstr_w(method
), debugstr_w(url
),
2557 debugstr_variant(&async
));
2559 if (!method
|| !url
) return E_INVALIDARG
;
2561 memset( &uc
, 0, sizeof(uc
) );
2562 uc
.dwStructSize
= sizeof(uc
);
2563 uc
.dwSchemeLength
= ~0u;
2564 uc
.dwHostNameLength
= ~0u;
2565 uc
.dwUrlPathLength
= ~0u;
2566 uc
.dwExtraInfoLength
= ~0u;
2567 if (!WinHttpCrackUrl( url
, 0, 0, &uc
)) return HRESULT_FROM_WIN32( get_last_error() );
2569 EnterCriticalSection( &request
->cs
);
2570 if (request
->state
!= REQUEST_STATE_INITIALIZED
)
2572 cancel_request( request
);
2573 free_request( request
);
2574 initialize_request( request
);
2576 if (!(hostname
= heap_alloc( (uc
.dwHostNameLength
+ 1) * sizeof(WCHAR
) ))) goto error
;
2577 memcpy( hostname
, uc
.lpszHostName
, uc
.dwHostNameLength
* sizeof(WCHAR
) );
2578 hostname
[uc
.dwHostNameLength
] = 0;
2580 if (!(path
= heap_alloc( (uc
.dwUrlPathLength
+ uc
.dwExtraInfoLength
+ 1) * sizeof(WCHAR
) ))) goto error
;
2581 memcpy( path
, uc
.lpszUrlPath
, (uc
.dwUrlPathLength
+ uc
.dwExtraInfoLength
) * sizeof(WCHAR
) );
2582 path
[uc
.dwUrlPathLength
+ uc
.dwExtraInfoLength
] = 0;
2584 if (!(verb
= strdupW( method
))) goto error
;
2585 if (V_BOOL( &async
)) flags
|= WINHTTP_FLAG_ASYNC
;
2586 if (!(hsession
= WinHttpOpen( user_agentW
, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY
, NULL
, NULL
, flags
)))
2588 err
= get_last_error();
2591 if (!(hconnect
= WinHttpConnect( hsession
, hostname
, uc
.nPort
, 0 )))
2593 err
= get_last_error();
2596 len
= sizeof(httpsW
) / sizeof(WCHAR
);
2597 if (uc
.dwSchemeLength
== len
&& !memcmp( uc
.lpszScheme
, httpsW
, len
* sizeof(WCHAR
) ))
2599 request_flags
|= WINHTTP_FLAG_SECURE
;
2601 if (!(hrequest
= WinHttpOpenRequest( hconnect
, method
, path
, NULL
, NULL
, acceptW
, request_flags
)))
2603 err
= get_last_error();
2606 if (flags
& WINHTTP_FLAG_ASYNC
)
2608 request
->wait
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
);
2609 request
->cancel
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
);
2610 WinHttpSetOption( hrequest
, WINHTTP_OPTION_CONTEXT_VALUE
, &request
, sizeof(request
) );
2612 request
->state
= REQUEST_STATE_OPEN
;
2613 request
->hsession
= hsession
;
2614 request
->hconnect
= hconnect
;
2615 request
->hrequest
= hrequest
;
2616 request
->verb
= verb
;
2617 heap_free( hostname
);
2619 LeaveCriticalSection( &request
->cs
);
2623 WinHttpCloseHandle( hconnect
);
2624 WinHttpCloseHandle( hsession
);
2625 heap_free( hostname
);
2628 LeaveCriticalSection( &request
->cs
);
2629 return HRESULT_FROM_WIN32( err
);
2632 static HRESULT WINAPI
winhttp_request_SetRequestHeader(
2633 IWinHttpRequest
*iface
,
2637 static const WCHAR fmtW
[] = {'%','s',':',' ','%','s','\r','\n',0};
2638 static const WCHAR emptyW
[] = {0};
2639 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2640 DWORD len
, err
= ERROR_SUCCESS
;
2643 TRACE("%p, %s, %s\n", request
, debugstr_w(header
), debugstr_w(value
));
2645 if (!header
) return E_INVALIDARG
;
2647 EnterCriticalSection( &request
->cs
);
2648 if (request
->state
< REQUEST_STATE_OPEN
)
2650 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN
;
2653 if (request
->state
>= REQUEST_STATE_SENT
)
2655 err
= ERROR_WINHTTP_CANNOT_CALL_AFTER_SEND
;
2658 len
= strlenW( header
) + 4;
2659 if (value
) len
+= strlenW( value
);
2660 if (!(str
= heap_alloc( (len
+ 1) * sizeof(WCHAR
) )))
2662 err
= ERROR_OUTOFMEMORY
;
2665 sprintfW( str
, fmtW
, header
, value
? value
: emptyW
);
2666 if (!WinHttpAddRequestHeaders( request
->hrequest
, str
, len
, WINHTTP_ADDREQ_FLAG_REPLACE
))
2668 err
= get_last_error();
2673 LeaveCriticalSection( &request
->cs
);
2674 return HRESULT_FROM_WIN32( err
);
2677 static HRESULT WINAPI
winhttp_request_GetResponseHeader(
2678 IWinHttpRequest
*iface
,
2682 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2683 DWORD size
, err
= ERROR_SUCCESS
;
2685 TRACE("%p, %p\n", request
, header
);
2687 EnterCriticalSection( &request
->cs
);
2688 if (request
->state
< REQUEST_STATE_SENT
)
2690 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
;
2693 if (!header
|| !value
)
2695 err
= ERROR_INVALID_PARAMETER
;
2699 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_CUSTOM
, header
, NULL
, &size
, NULL
))
2701 err
= get_last_error();
2702 if (err
!= ERROR_INSUFFICIENT_BUFFER
) goto done
;
2704 if (!(*value
= SysAllocStringLen( NULL
, size
/ sizeof(WCHAR
) )))
2706 err
= ERROR_OUTOFMEMORY
;
2709 err
= ERROR_SUCCESS
;
2710 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_CUSTOM
, header
, *value
, &size
, NULL
))
2712 err
= get_last_error();
2713 SysFreeString( *value
);
2716 LeaveCriticalSection( &request
->cs
);
2717 return HRESULT_FROM_WIN32( err
);
2720 static HRESULT WINAPI
winhttp_request_GetAllResponseHeaders(
2721 IWinHttpRequest
*iface
,
2724 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2725 DWORD size
, err
= ERROR_SUCCESS
;
2727 TRACE("%p, %p\n", request
, headers
);
2729 if (!headers
) return E_INVALIDARG
;
2731 EnterCriticalSection( &request
->cs
);
2732 if (request
->state
< REQUEST_STATE_SENT
)
2734 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
;
2738 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_RAW_HEADERS_CRLF
, NULL
, NULL
, &size
, NULL
))
2740 err
= get_last_error();
2741 if (err
!= ERROR_INSUFFICIENT_BUFFER
) goto done
;
2743 if (!(*headers
= SysAllocStringLen( NULL
, size
/ sizeof(WCHAR
) )))
2745 err
= ERROR_OUTOFMEMORY
;
2748 err
= ERROR_SUCCESS
;
2749 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_RAW_HEADERS_CRLF
, NULL
, *headers
, &size
, NULL
))
2751 err
= get_last_error();
2752 SysFreeString( *headers
);
2755 LeaveCriticalSection( &request
->cs
);
2756 return HRESULT_FROM_WIN32( err
);
2759 static void CALLBACK
wait_status_callback( HINTERNET handle
, DWORD_PTR context
, DWORD status
, LPVOID buffer
, DWORD size
)
2761 struct winhttp_request
*request
= (struct winhttp_request
*)context
;
2765 case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE
:
2766 request
->bytes_available
= *(DWORD
*)buffer
;
2767 request
->error
= ERROR_SUCCESS
;
2769 case WINHTTP_CALLBACK_STATUS_READ_COMPLETE
:
2770 request
->bytes_read
= size
;
2771 request
->error
= ERROR_SUCCESS
;
2773 case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
:
2775 WINHTTP_ASYNC_RESULT
*result
= (WINHTTP_ASYNC_RESULT
*)buffer
;
2776 request
->error
= result
->dwError
;
2781 SetEvent( request
->wait
);
2784 static void wait_set_status_callback( struct winhttp_request
*request
, DWORD status
)
2786 if (!request
->wait
) return;
2787 status
|= WINHTTP_CALLBACK_STATUS_REQUEST_ERROR
;
2788 WinHttpSetStatusCallback( request
->hrequest
, wait_status_callback
, status
, 0 );
2791 static DWORD
wait_for_completion( struct winhttp_request
*request
)
2797 request
->error
= ERROR_SUCCESS
;
2798 return ERROR_SUCCESS
;
2800 handles
[0] = request
->wait
;
2801 handles
[1] = request
->cancel
;
2802 switch (WaitForMultipleObjects( 2, handles
, FALSE
, INFINITE
))
2806 case WAIT_OBJECT_0
+ 1:
2807 request
->error
= ERROR_CANCELLED
;
2810 request
->error
= get_last_error();
2813 return request
->error
;
2816 static HRESULT
request_receive( struct winhttp_request
*request
)
2818 DWORD err
, size
, total_bytes_read
, buflen
= 4096;
2820 wait_set_status_callback( request
, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE
);
2821 if (!WinHttpReceiveResponse( request
->hrequest
, NULL
))
2823 return HRESULT_FROM_WIN32( get_last_error() );
2825 if ((err
= wait_for_completion( request
))) return HRESULT_FROM_WIN32( err
);
2826 if (!strcmpW( request
->verb
, headW
))
2828 request
->state
= REQUEST_STATE_RESPONSE_RECEIVED
;
2831 if (!(request
->buffer
= heap_alloc( buflen
))) return E_OUTOFMEMORY
;
2832 request
->buffer
[0] = 0;
2833 size
= total_bytes_read
= 0;
2836 wait_set_status_callback( request
, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE
);
2837 if (!WinHttpQueryDataAvailable( request
->hrequest
, &request
->bytes_available
))
2839 err
= get_last_error();
2842 if ((err
= wait_for_completion( request
))) goto error
;
2843 if (!request
->bytes_available
) break;
2844 size
+= request
->bytes_available
;
2848 while (buflen
< size
) buflen
*= 2;
2849 if (!(tmp
= heap_realloc( request
->buffer
, buflen
)))
2851 err
= ERROR_OUTOFMEMORY
;
2854 request
->buffer
= tmp
;
2856 wait_set_status_callback( request
, WINHTTP_CALLBACK_STATUS_READ_COMPLETE
);
2857 if (!WinHttpReadData( request
->hrequest
, request
->buffer
+ request
->offset
,
2858 request
->bytes_available
, &request
->bytes_read
))
2860 err
= get_last_error();
2863 if ((err
= wait_for_completion( request
))) goto error
;
2864 total_bytes_read
+= request
->bytes_read
;
2865 request
->offset
+= request
->bytes_read
;
2866 } while (request
->bytes_read
);
2868 request
->state
= REQUEST_STATE_RESPONSE_RECEIVED
;
2872 heap_free( request
->buffer
);
2873 request
->buffer
= NULL
;
2874 return HRESULT_FROM_WIN32( err
);
2877 static DWORD
request_set_parameters( struct winhttp_request
*request
)
2879 if (!WinHttpSetOption( request
->hrequest
, WINHTTP_OPTION_PROXY
, &request
->proxy
,
2880 sizeof(request
->proxy
) )) return get_last_error();
2882 if (!WinHttpSetOption( request
->hrequest
, WINHTTP_OPTION_AUTOLOGON_POLICY
, &request
->logon_policy
,
2883 sizeof(request
->logon_policy
) )) return get_last_error();
2885 if (!WinHttpSetOption( request
->hrequest
, WINHTTP_OPTION_DISABLE_FEATURE
, &request
->disable_feature
,
2886 sizeof(request
->disable_feature
) )) return get_last_error();
2888 if (!WinHttpSetTimeouts( request
->hrequest
,
2889 request
->resolve_timeout
,
2890 request
->connect_timeout
,
2891 request
->send_timeout
,
2892 request
->receive_timeout
)) return get_last_error();
2893 return ERROR_SUCCESS
;
2896 static void request_set_utf8_content_type( struct winhttp_request
*request
)
2898 static const WCHAR fmtW
[] = {'%','s',':',' ','%','s',0};
2899 static const WCHAR text_plainW
[] = {'t','e','x','t','/','p','l','a','i','n',0};
2900 static const WCHAR charset_utf8W
[] = {'c','h','a','r','s','e','t','=','u','t','f','-','8',0};
2904 len
= sprintfW( headerW
, fmtW
, attr_content_type
, text_plainW
);
2905 WinHttpAddRequestHeaders( request
->hrequest
, headerW
, len
, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW
);
2906 len
= sprintfW( headerW
, fmtW
, attr_content_type
, charset_utf8W
);
2907 WinHttpAddRequestHeaders( request
->hrequest
, headerW
, len
, WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON
);
2910 static HRESULT
request_send( struct winhttp_request
*request
)
2912 SAFEARRAY
*sa
= NULL
;
2920 if ((err
= request_set_parameters( request
))) return HRESULT_FROM_WIN32( err
);
2921 if (strcmpW( request
->verb
, getW
))
2923 VariantInit( &data
);
2924 if (V_VT( &request
->data
) == VT_BSTR
)
2926 UINT i
, cp
= CP_ACP
;
2927 const WCHAR
*str
= V_BSTR( &request
->data
);
2928 int len
= strlenW( str
);
2930 for (i
= 0; i
< len
; i
++)
2938 size
= WideCharToMultiByte( cp
, 0, str
, len
, NULL
, 0, NULL
, NULL
);
2939 if (!(ptr
= heap_alloc( size
))) return E_OUTOFMEMORY
;
2940 WideCharToMultiByte( cp
, 0, str
, len
, ptr
, size
, NULL
, NULL
);
2941 if (cp
== CP_UTF8
) request_set_utf8_content_type( request
);
2943 else if (VariantChangeType( &data
, &request
->data
, 0, VT_ARRAY
|VT_UI1
) == S_OK
)
2945 sa
= V_ARRAY( &data
);
2946 if ((hr
= SafeArrayAccessData( sa
, (void **)&ptr
)) != S_OK
) return hr
;
2947 if ((hr
= SafeArrayGetUBound( sa
, 1, &size
) != S_OK
))
2949 SafeArrayUnaccessData( sa
);
2955 wait_set_status_callback( request
, WINHTTP_CALLBACK_STATUS_REQUEST_SENT
);
2956 if (!(ret
= WinHttpSendRequest( request
->hrequest
, NULL
, 0, ptr
, size
, size
, 0 )))
2958 err
= get_last_error();
2961 if ((err
= wait_for_completion( request
))) goto error
;
2962 if (sa
) SafeArrayUnaccessData( sa
);
2963 else heap_free( ptr
);
2964 request
->state
= REQUEST_STATE_SENT
;
2968 if (sa
) SafeArrayUnaccessData( sa
);
2969 else heap_free( ptr
);
2970 return HRESULT_FROM_WIN32( err
);
2973 static HRESULT
request_send_and_receive( struct winhttp_request
*request
)
2975 HRESULT hr
= request_send( request
);
2976 if (hr
== S_OK
) hr
= request_receive( request
);
2980 static DWORD CALLBACK
send_and_receive_proc( void *arg
)
2982 struct winhttp_request
*request
= (struct winhttp_request
*)arg
;
2983 return request_send_and_receive( request
);
2986 static HRESULT WINAPI
winhttp_request_Send(
2987 IWinHttpRequest
*iface
,
2990 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
2993 TRACE("%p, %s\n", request
, debugstr_variant(&body
));
2995 EnterCriticalSection( &request
->cs
);
2996 if (request
->state
< REQUEST_STATE_OPEN
)
2998 LeaveCriticalSection( &request
->cs
);
2999 return HRESULT_FROM_WIN32( ERROR_WINHTTP_CANNOT_CALL_BEFORE_OPEN
);
3001 if (request
->state
>= REQUEST_STATE_SENT
)
3003 LeaveCriticalSection( &request
->cs
);
3006 VariantClear( &request
->data
);
3007 if ((hr
= VariantCopyInd( &request
->data
, &body
)) != S_OK
) {
3008 LeaveCriticalSection( &request
->cs
);
3012 if (request
->wait
) /* async request */
3014 if (!(request
->thread
= CreateThread( NULL
, 0, send_and_receive_proc
, request
, 0, NULL
)))
3016 LeaveCriticalSection( &request
->cs
);
3017 return HRESULT_FROM_WIN32( get_last_error() );
3020 else hr
= request_send_and_receive( request
);
3021 LeaveCriticalSection( &request
->cs
);
3025 static HRESULT WINAPI
winhttp_request_get_Status(
3026 IWinHttpRequest
*iface
,
3029 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3030 DWORD err
= ERROR_SUCCESS
, flags
, status_code
, len
= sizeof(status_code
), index
= 0;
3032 TRACE("%p, %p\n", request
, status
);
3034 if (!status
) return E_INVALIDARG
;
3036 EnterCriticalSection( &request
->cs
);
3037 if (request
->state
< REQUEST_STATE_SENT
)
3039 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
;
3042 flags
= WINHTTP_QUERY_STATUS_CODE
| WINHTTP_QUERY_FLAG_NUMBER
;
3043 if (!WinHttpQueryHeaders( request
->hrequest
, flags
, NULL
, &status_code
, &len
, &index
))
3045 err
= get_last_error();
3047 *status
= status_code
;
3050 LeaveCriticalSection( &request
->cs
);
3051 return HRESULT_FROM_WIN32( err
);
3054 static HRESULT WINAPI
winhttp_request_get_StatusText(
3055 IWinHttpRequest
*iface
,
3058 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3059 DWORD err
= ERROR_SUCCESS
, len
= 0, index
= 0;
3061 TRACE("%p, %p\n", request
, status
);
3063 if (!status
) return E_INVALIDARG
;
3065 EnterCriticalSection( &request
->cs
);
3066 if (request
->state
< REQUEST_STATE_SENT
)
3068 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
;
3071 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_STATUS_TEXT
, NULL
, NULL
, &len
, &index
))
3073 err
= get_last_error();
3074 if (err
!= ERROR_INSUFFICIENT_BUFFER
) goto done
;
3076 if (!(*status
= SysAllocStringLen( NULL
, len
/ sizeof(WCHAR
) )))
3078 err
= ERROR_OUTOFMEMORY
;
3082 err
= ERROR_SUCCESS
;
3083 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_STATUS_TEXT
, NULL
, *status
, &len
, &index
))
3085 err
= get_last_error();
3086 SysFreeString( *status
);
3089 LeaveCriticalSection( &request
->cs
);
3090 return HRESULT_FROM_WIN32( err
);
3093 static DWORD
request_get_codepage( struct winhttp_request
*request
, UINT
*codepage
)
3095 static const WCHAR utf8W
[] = {'u','t','f','-','8',0};
3096 static const WCHAR charsetW
[] = {'c','h','a','r','s','e','t',0};
3101 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_CONTENT_TYPE
, NULL
, NULL
, &size
, NULL
) &&
3102 get_last_error() == ERROR_INSUFFICIENT_BUFFER
)
3104 if (!(buffer
= heap_alloc( size
))) return ERROR_OUTOFMEMORY
;
3105 if (!WinHttpQueryHeaders( request
->hrequest
, WINHTTP_QUERY_CONTENT_TYPE
, NULL
, buffer
, &size
, NULL
))
3107 return get_last_error();
3109 if ((p
= strstrW( buffer
, charsetW
)))
3111 p
+= strlenW( charsetW
);
3112 while (*p
== ' ') p
++;
3115 while (*p
== ' ') p
++;
3116 if (!strcmpiW( p
, utf8W
)) *codepage
= CP_UTF8
;
3119 heap_free( buffer
);
3121 return ERROR_SUCCESS
;
3124 static HRESULT WINAPI
winhttp_request_get_ResponseText(
3125 IWinHttpRequest
*iface
,
3128 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3130 DWORD err
= ERROR_SUCCESS
;
3133 TRACE("%p, %p\n", request
, body
);
3135 if (!body
) return E_INVALIDARG
;
3137 EnterCriticalSection( &request
->cs
);
3138 if (request
->state
< REQUEST_STATE_SENT
)
3140 err
= ERROR_WINHTTP_CANNOT_CALL_BEFORE_SEND
;
3143 if ((err
= request_get_codepage( request
, &codepage
))) goto done
;
3144 len
= MultiByteToWideChar( codepage
, 0, request
->buffer
, request
->offset
, NULL
, 0 );
3145 if (!(*body
= SysAllocStringLen( NULL
, len
)))
3147 err
= ERROR_OUTOFMEMORY
;
3150 MultiByteToWideChar( codepage
, 0, request
->buffer
, request
->offset
, *body
, len
);
3154 LeaveCriticalSection( &request
->cs
);
3155 return HRESULT_FROM_WIN32( err
);
3158 static HRESULT WINAPI
winhttp_request_get_ResponseBody(
3159 IWinHttpRequest
*iface
,
3162 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3165 DWORD err
= ERROR_SUCCESS
;
3168 TRACE("%p, %p\n", request
, body
);
3170 if (!body
) return E_INVALIDARG
;
3172 EnterCriticalSection( &request
->cs
);
3173 if (!(sa
= SafeArrayCreateVector( VT_UI1
, 0, request
->offset
)))
3175 err
= ERROR_OUTOFMEMORY
;
3178 if ((hr
= SafeArrayAccessData( sa
, (void **)&ptr
)) != S_OK
)
3180 SafeArrayDestroy( sa
);
3181 LeaveCriticalSection( &request
->cs
);
3184 memcpy( ptr
, request
->buffer
, request
->offset
);
3185 if ((hr
= SafeArrayUnaccessData( sa
)) != S_OK
)
3187 SafeArrayDestroy( sa
);
3188 LeaveCriticalSection( &request
->cs
);
3191 V_VT( body
) = VT_ARRAY
|VT_UI1
;
3192 V_ARRAY( body
) = sa
;
3195 LeaveCriticalSection( &request
->cs
);
3196 return HRESULT_FROM_WIN32( err
);
3199 static HRESULT WINAPI
winhttp_request_get_ResponseStream(
3200 IWinHttpRequest
*iface
,
3207 static HRESULT WINAPI
winhttp_request_get_Option(
3208 IWinHttpRequest
*iface
,
3209 WinHttpRequestOption option
,
3216 static HRESULT WINAPI
winhttp_request_put_Option(
3217 IWinHttpRequest
*iface
,
3218 WinHttpRequestOption option
,
3221 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3224 TRACE("%p, %u, %s\n", request
, option
, debugstr_variant(&value
));
3226 EnterCriticalSection( &request
->cs
);
3229 case WinHttpRequestOption_EnableRedirects
:
3231 if (V_BOOL( &value
))
3232 request
->disable_feature
&= ~WINHTTP_DISABLE_REDIRECTS
;
3234 request
->disable_feature
|= WINHTTP_DISABLE_REDIRECTS
;
3238 FIXME("unimplemented option %u\n", option
);
3242 LeaveCriticalSection( &request
->cs
);
3246 /* critical section must be held */
3247 static DWORD
wait_for_response( struct winhttp_request
*request
, DWORD timeout
)
3249 HANDLE thread
= request
->thread
;
3252 LeaveCriticalSection( &request
->cs
);
3253 while ((err
= MsgWaitForMultipleObjects( 1, &thread
, FALSE
, timeout
, QS_ALLINPUT
)) == WAIT_OBJECT_0
+ 1)
3256 while (PeekMessageW( &msg
, NULL
, 0, 0, PM_REMOVE
))
3258 TranslateMessage( &msg
);
3259 DispatchMessageW( &msg
);
3265 ret
= ERROR_SUCCESS
;
3268 ret
= ERROR_TIMEOUT
;
3272 ret
= get_last_error();
3275 EnterCriticalSection( &request
->cs
);
3279 static HRESULT WINAPI
winhttp_request_WaitForResponse(
3280 IWinHttpRequest
*iface
,
3282 VARIANT_BOOL
*succeeded
)
3284 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3285 DWORD err
, msecs
= (V_I4(&timeout
) == -1) ? INFINITE
: V_I4(&timeout
) * 1000;
3287 TRACE("%p, %s, %p\n", request
, debugstr_variant(&timeout
), succeeded
);
3289 EnterCriticalSection( &request
->cs
);
3290 if (!request
->thread
)
3292 LeaveCriticalSection( &request
->cs
);
3295 if (request
->state
>= REQUEST_STATE_RESPONSE_RECEIVED
)
3297 LeaveCriticalSection( &request
->cs
);
3300 switch ((err
= wait_for_response( request
, msecs
)))
3303 if (succeeded
) *succeeded
= VARIANT_FALSE
;
3304 err
= ERROR_SUCCESS
;
3308 if (succeeded
) *succeeded
= VARIANT_TRUE
;
3313 LeaveCriticalSection( &request
->cs
);
3314 return HRESULT_FROM_WIN32( err
);
3317 static HRESULT WINAPI
winhttp_request_Abort(
3318 IWinHttpRequest
*iface
)
3320 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3322 TRACE("%p\n", request
);
3324 EnterCriticalSection( &request
->cs
);
3325 cancel_request( request
);
3326 LeaveCriticalSection( &request
->cs
);
3330 static HRESULT WINAPI
winhttp_request_SetTimeouts(
3331 IWinHttpRequest
*iface
,
3332 LONG resolve_timeout
,
3333 LONG connect_timeout
,
3335 LONG receive_timeout
)
3337 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3339 TRACE("%p, %d, %d, %d, %d\n", request
, resolve_timeout
, connect_timeout
, send_timeout
, receive_timeout
);
3341 EnterCriticalSection( &request
->cs
);
3342 request
->resolve_timeout
= resolve_timeout
;
3343 request
->connect_timeout
= connect_timeout
;
3344 request
->send_timeout
= send_timeout
;
3345 request
->receive_timeout
= receive_timeout
;
3346 LeaveCriticalSection( &request
->cs
);
3350 static HRESULT WINAPI
winhttp_request_SetClientCertificate(
3351 IWinHttpRequest
*iface
,
3358 static HRESULT WINAPI
winhttp_request_SetAutoLogonPolicy(
3359 IWinHttpRequest
*iface
,
3360 WinHttpRequestAutoLogonPolicy policy
)
3362 struct winhttp_request
*request
= impl_from_IWinHttpRequest( iface
);
3365 TRACE("%p, %u\n", request
, policy
);
3367 EnterCriticalSection( &request
->cs
);
3370 case AutoLogonPolicy_Always
:
3371 request
->logon_policy
= WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW
;
3373 case AutoLogonPolicy_OnlyIfBypassProxy
:
3374 request
->logon_policy
= WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM
;
3376 case AutoLogonPolicy_Never
:
3377 request
->logon_policy
= WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH
;
3379 default: hr
= E_INVALIDARG
;
3382 LeaveCriticalSection( &request
->cs
);
3386 static const struct IWinHttpRequestVtbl winhttp_request_vtbl
=
3388 winhttp_request_QueryInterface
,
3389 winhttp_request_AddRef
,
3390 winhttp_request_Release
,
3391 winhttp_request_GetTypeInfoCount
,
3392 winhttp_request_GetTypeInfo
,
3393 winhttp_request_GetIDsOfNames
,
3394 winhttp_request_Invoke
,
3395 winhttp_request_SetProxy
,
3396 winhttp_request_SetCredentials
,
3397 winhttp_request_Open
,
3398 winhttp_request_SetRequestHeader
,
3399 winhttp_request_GetResponseHeader
,
3400 winhttp_request_GetAllResponseHeaders
,
3401 winhttp_request_Send
,
3402 winhttp_request_get_Status
,
3403 winhttp_request_get_StatusText
,
3404 winhttp_request_get_ResponseText
,
3405 winhttp_request_get_ResponseBody
,
3406 winhttp_request_get_ResponseStream
,
3407 winhttp_request_get_Option
,
3408 winhttp_request_put_Option
,
3409 winhttp_request_WaitForResponse
,
3410 winhttp_request_Abort
,
3411 winhttp_request_SetTimeouts
,
3412 winhttp_request_SetClientCertificate
,
3413 winhttp_request_SetAutoLogonPolicy
3416 HRESULT
WinHttpRequest_create( IUnknown
*unknown
, void **obj
)
3418 struct winhttp_request
*request
;
3420 TRACE("%p, %p\n", unknown
, obj
);
3422 if (!(request
= heap_alloc( sizeof(*request
) ))) return E_OUTOFMEMORY
;
3423 request
->IWinHttpRequest_iface
.lpVtbl
= &winhttp_request_vtbl
;
3425 request
->state
= REQUEST_STATE_UNINITIALIZED
;
3426 request
->proxy
.lpszProxy
= NULL
;
3427 request
->proxy
.lpszProxyBypass
= NULL
;
3428 InitializeCriticalSection( &request
->cs
);
3429 request
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": winhttp_request.cs");
3431 *obj
= &request
->IWinHttpRequest_iface
;
3432 TRACE("returning iface %p\n", *obj
);