?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 3.0.2.
[wine.git] / dlls / wininet / http.c
blob79f7df1b1e36536af27316a16b8cf5baec10c163
1 /*
2 * Wininet - HTTP Implementation
3 *
4 * Copyright 1999 Corel Corporation
5 * Copyright 2002 CodeWeavers Inc.
6 * Copyright 2002 TransGaming Technologies Inc.
7 * Copyright 2004 Mike McCormack for CodeWeavers
8 * Copyright 2005 Aric Stewart for CodeWeavers
9 * Copyright 2006 Robert Shearman for CodeWeavers
10 * Copyright 2011 Jacek Caban for CodeWeavers
11 *
12 * Ulrich Czekalla
13 * David Hammerton
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 */
29
30 #include "config.h"
31
32 #include <stdlib.h>
33
34 #ifdef HAVE_ZLIB
35 # include <zlib.h>
36 #endif
37
38 #include "winsock2.h"
39 #include "ws2ipdef.h"
40
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include <time.h>
44 #include <assert.h>
45
46 #include "windef.h"
47 #include "winbase.h"
48 #include "wininet.h"
49 #include "winerror.h"
50 #include "winternl.h"
51 #define NO_SHLWAPI_STREAM
52 #define NO_SHLWAPI_REG
53 #define NO_SHLWAPI_STRFCNS
54 #define NO_SHLWAPI_GDI
55 #include "shlwapi.h"
56 #include "sspi.h"
57 #include "wincrypt.h"
58 #include "winuser.h"
59
60 #include "internet.h"
61 #include "wine/debug.h"
62 #include "wine/exception.h"
63 #include "wine/unicode.h"
64
65 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
66
67 static const WCHAR g_szHttp1_0[] = {'H','T','T','P','/','1','.','0',0};
68 static const WCHAR g_szHttp1_1[] = {'H','T','T','P','/','1','.','1',0};
69 static const WCHAR szOK[] = {'O','K',0};
70 static const WCHAR hostW[] = { 'H','o','s','t',0 };
71 static const WCHAR szAuthorization[] = { 'A','u','t','h','o','r','i','z','a','t','i','o','n',0 };
72 static const WCHAR szProxy_Authorization[] = { 'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',0 };
73 static const WCHAR szStatus[] = { 'S','t','a','t','u','s',0 };
74 static const WCHAR szKeepAlive[] = {'K','e','e','p','-','A','l','i','v','e',0};
75 static const WCHAR szGET[] = { 'G','E','T', 0 };
76 static const WCHAR szHEAD[] = { 'H','E','A','D', 0 };
77
78 static const WCHAR szAccept[] = { 'A','c','c','e','p','t',0 };
79 static const WCHAR szAccept_Charset[] = { 'A','c','c','e','p','t','-','C','h','a','r','s','e','t', 0 };
80 static const WCHAR szAccept_Encoding[] = { 'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',0 };
81 static const WCHAR szAccept_Language[] = { 'A','c','c','e','p','t','-','L','a','n','g','u','a','g','e',0 };
82 static const WCHAR szAccept_Ranges[] = { 'A','c','c','e','p','t','-','R','a','n','g','e','s',0 };
83 static const WCHAR szAge[] = { 'A','g','e',0 };
84 static const WCHAR szAllow[] = { 'A','l','l','o','w',0 };
85 static const WCHAR szCache_Control[] = { 'C','a','c','h','e','-','C','o','n','t','r','o','l',0 };
86 static const WCHAR szConnection[] = { 'C','o','n','n','e','c','t','i','o','n',0 };
87 static const WCHAR szContent_Base[] = { 'C','o','n','t','e','n','t','-','B','a','s','e',0 };
88 static const WCHAR szContent_Disposition[] = { 'C','o','n','t','e','n','t','-','D','i','s','p','o','s','i','t','i','o','n',0 };
89 static const WCHAR szContent_Encoding[] = { 'C','o','n','t','e','n','t','-','E','n','c','o','d','i','n','g',0 };
90 static const WCHAR szContent_ID[] = { 'C','o','n','t','e','n','t','-','I','D',0 };
91 static const WCHAR szContent_Language[] = { 'C','o','n','t','e','n','t','-','L','a','n','g','u','a','g','e',0 };
92 static const WCHAR szContent_Length[] = { 'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0 };
93 static const WCHAR szContent_Location[] = { 'C','o','n','t','e','n','t','-','L','o','c','a','t','i','o','n',0 };
94 static const WCHAR szContent_MD5[] = { 'C','o','n','t','e','n','t','-','M','D','5',0 };
95 static const WCHAR szContent_Range[] = { 'C','o','n','t','e','n','t','-','R','a','n','g','e',0 };
96 static const WCHAR szContent_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 };
97 static const WCHAR szContent_Type[] = { 'C','o','n','t','e','n','t','-','T','y','p','e',0 };
98 static const WCHAR szCookie[] = { 'C','o','o','k','i','e',0 };
99 static const WCHAR szDate[] = { 'D','a','t','e',0 };
100 static const WCHAR szFrom[] = { 'F','r','o','m',0 };
101 static const WCHAR szETag[] = { 'E','T','a','g',0 };
102 static const WCHAR szExpect[] = { 'E','x','p','e','c','t',0 };
103 static const WCHAR szExpires[] = { 'E','x','p','i','r','e','s',0 };
104 static const WCHAR szIf_Match[] = { 'I','f','-','M','a','t','c','h',0 };
105 static const WCHAR szIf_Modified_Since[] = { 'I','f','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0 };
106 static const WCHAR szIf_None_Match[] = { 'I','f','-','N','o','n','e','-','M','a','t','c','h',0 };
107 static const WCHAR szIf_Range[] = { 'I','f','-','R','a','n','g','e',0 };
108 static const WCHAR szIf_Unmodified_Since[] = { 'I','f','-','U','n','m','o','d','i','f','i','e','d','-','S','i','n','c','e',0 };
109 static const WCHAR szLast_Modified[] = { 'L','a','s','t','-','M','o','d','i','f','i','e','d',0 };
110 static const WCHAR szLocation[] = { 'L','o','c','a','t','i','o','n',0 };
111 static const WCHAR szMax_Forwards[] = { 'M','a','x','-','F','o','r','w','a','r','d','s',0 };
112 static const WCHAR szMime_Version[] = { 'M','i','m','e','-','V','e','r','s','i','o','n',0 };
113 static const WCHAR szPragma[] = { 'P','r','a','g','m','a',0 };
114 static const WCHAR szProxy_Authenticate[] = { 'P','r','o','x','y','-','A','u','t','h','e','n','t','i','c','a','t','e',0 };
115 static const WCHAR szProxy_Connection[] = { 'P','r','o','x','y','-','C','o','n','n','e','c','t','i','o','n',0 };
116 static const WCHAR szPublic[] = { 'P','u','b','l','i','c',0 };
117 static const WCHAR szRange[] = { 'R','a','n','g','e',0 };
118 static const WCHAR szReferer[] = { 'R','e','f','e','r','e','r',0 };
119 static const WCHAR szRetry_After[] = { 'R','e','t','r','y','-','A','f','t','e','r',0 };
120 static const WCHAR szServer[] = { 'S','e','r','v','e','r',0 };
121 static const WCHAR szSet_Cookie[] = { 'S','e','t','-','C','o','o','k','i','e',0 };
122 static const WCHAR szTransfer_Encoding[] = { 'T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0 };
123 static const WCHAR szUnless_Modified_Since[] = { 'U','n','l','e','s','s','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0 };
124 static const WCHAR szUpgrade[] = { 'U','p','g','r','a','d','e',0 };
125 static const WCHAR szURI[] = { 'U','R','I',0 };
126 static const WCHAR szUser_Agent[] = { 'U','s','e','r','-','A','g','e','n','t',0 };
127 static const WCHAR szVary[] = { 'V','a','r','y',0 };
128 static const WCHAR szVia[] = { 'V','i','a',0 };
129 static const WCHAR szWarning[] = { 'W','a','r','n','i','n','g',0 };
130 static const WCHAR szWWW_Authenticate[] = { 'W','W','W','-','A','u','t','h','e','n','t','i','c','a','t','e',0 };
131
132 static const WCHAR emptyW[] = {0};
133
134 #define HTTP_REFERER szReferer
135 #define HTTP_ACCEPT szAccept
136 #define HTTP_USERAGENT szUser_Agent
137
138 #define HTTP_ADDHDR_FLAG_ADD 0x20000000
139 #define HTTP_ADDHDR_FLAG_ADD_IF_NEW 0x10000000
140 #define HTTP_ADDHDR_FLAG_COALESCE 0x40000000
141 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA 0x40000000
142 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON 0x01000000
143 #define HTTP_ADDHDR_FLAG_REPLACE 0x80000000
144 #define HTTP_ADDHDR_FLAG_REQ 0x02000000
145
146 #define COLLECT_TIME 60000
147
148 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
149
150 struct HttpAuthInfo
151 {
152 LPWSTR scheme;
153 CredHandle cred;
154 CtxtHandle ctx;
155 TimeStamp exp;
156 ULONG attr;
157 ULONG max_token;
158 void *auth_data;
159 unsigned int auth_data_len;
160 BOOL finished; /* finished authenticating */
161 };
162
163
164 typedef struct _basicAuthorizationData
165 {
166 struct list entry;
167
168 LPWSTR host;
169 LPWSTR realm;
170 LPSTR authorization;
171 UINT authorizationLen;
172 } basicAuthorizationData;
173
174 typedef struct _authorizationData
175 {
176 struct list entry;
177
178 LPWSTR host;
179 LPWSTR scheme;
180 LPWSTR domain;
181 UINT domain_len;
182 LPWSTR user;
183 UINT user_len;
184 LPWSTR password;
185 UINT password_len;
186 } authorizationData;
187
188 static struct list basicAuthorizationCache = LIST_INIT(basicAuthorizationCache);
189 static struct list authorizationCache = LIST_INIT(authorizationCache);
190
191 static CRITICAL_SECTION authcache_cs;
192 static CRITICAL_SECTION_DEBUG critsect_debug =
193 {
194 0, 0, &authcache_cs,
195 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
196 0, 0, { (DWORD_PTR)(__FILE__ ": authcache_cs") }
197 };
198 static CRITICAL_SECTION authcache_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
199
200 static DWORD HTTP_GetResponseHeaders(http_request_t *req, INT *len);
201 static DWORD HTTP_ProcessHeader(http_request_t *req, LPCWSTR field, LPCWSTR value, DWORD dwModifier);
202 static LPWSTR * HTTP_InterpretHttpHeader(LPCWSTR buffer);
203 static DWORD HTTP_InsertCustomHeader(http_request_t *req, LPHTTPHEADERW lpHdr);
204 static INT HTTP_GetCustomHeaderIndex(http_request_t *req, LPCWSTR lpszField, INT index, BOOL Request);
205 static BOOL HTTP_DeleteCustomHeader(http_request_t *req, DWORD index);
206 static LPWSTR HTTP_build_req( LPCWSTR *list, int len );
207 static DWORD HTTP_HttpQueryInfoW(http_request_t*, DWORD, LPVOID, LPDWORD, LPDWORD);
208 static UINT HTTP_DecodeBase64(LPCWSTR base64, LPSTR bin);
209 static DWORD drain_content(http_request_t*,BOOL);
210
211 static CRITICAL_SECTION connection_pool_cs;
212 static CRITICAL_SECTION_DEBUG connection_pool_debug =
213 {
214 0, 0, &connection_pool_cs,
215 { &connection_pool_debug.ProcessLocksList, &connection_pool_debug.ProcessLocksList },
216 0, 0, { (DWORD_PTR)(__FILE__ ": connection_pool_cs") }
217 };
218 static CRITICAL_SECTION connection_pool_cs = { &connection_pool_debug, -1, 0, 0, 0, 0 };
219
220 static struct list connection_pool = LIST_INIT(connection_pool);
221 static BOOL collector_running;
222
223 void server_addref(server_t *server)
224 {
225 InterlockedIncrement(&server->ref);
226 }
227
228 void server_release(server_t *server)
229 {
230 if(InterlockedDecrement(&server->ref))
231 return;
232
233 list_remove(&server->entry);
234
235 if(server->cert_chain)
236 CertFreeCertificateChain(server->cert_chain);
237 heap_free(server->name);
238 heap_free(server->scheme_host_port);
239 heap_free(server);
240 }
241
242 static BOOL process_host_port(server_t *server)
243 {
244 BOOL default_port;
245 size_t name_len;
246 WCHAR *buf;
247
248 static const WCHAR httpW[] = {'h','t','t','p',0};
249 static const WCHAR httpsW[] = {'h','t','t','p','s',0};
250 static const WCHAR formatW[] = {'%','s',':','/','/','%','s',':','%','u',0};
251
252 name_len = strlenW(server->name);
253 buf = heap_alloc((name_len + 10 /* strlen("://:<port>") */)*sizeof(WCHAR) + sizeof(httpsW));
254 if(!buf)
255 return FALSE;
256
257 sprintfW(buf, formatW, server->is_https ? httpsW : httpW, server->name, server->port);
258 server->scheme_host_port = buf;
259
260 server->host_port = server->scheme_host_port + 7 /* strlen("http://") */;
261 if(server->is_https)
262 server->host_port++;
263
264 default_port = server->port == (server->is_https ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT);
265 server->canon_host_port = default_port ? server->name : server->host_port;
266 return TRUE;
267 }
268
269 server_t *get_server(substr_t name, INTERNET_PORT port, BOOL is_https, BOOL do_create)
270 {
271 server_t *iter, *server = NULL;
272
273 EnterCriticalSection(&connection_pool_cs);
274
275 LIST_FOR_EACH_ENTRY(iter, &connection_pool, server_t, entry) {
276 if(iter->port == port && name.len == strlenW(iter->name) && !strncmpiW(iter->name, name.str, name.len)
277 && iter->is_https == is_https) {
278 server = iter;
279 server_addref(server);
280 break;
281 }
282 }
283
284 if(!server && do_create) {
285 server = heap_alloc_zero(sizeof(*server));
286 if(server) {
287 server->ref = 2; /* list reference and return */
288 server->port = port;
289 server->is_https = is_https;
290 list_init(&server->conn_pool);
291 server->name = heap_strndupW(name.str, name.len);
292 if(server->name && process_host_port(server)) {
293 list_add_head(&connection_pool, &server->entry);
294 }else {
295 heap_free(server);
296 server = NULL;
297 }
298 }
299 }
300
301 LeaveCriticalSection(&connection_pool_cs);
302
303 return server;
304 }
305
306 BOOL collect_connections(collect_type_t collect_type)
307 {
308 netconn_t *netconn, *netconn_safe;
309 server_t *server, *server_safe;
310 BOOL remaining = FALSE;
311 DWORD64 now;
312
313 now = GetTickCount64();
314
315 LIST_FOR_EACH_ENTRY_SAFE(server, server_safe, &connection_pool, server_t, entry) {
316 LIST_FOR_EACH_ENTRY_SAFE(netconn, netconn_safe, &server->conn_pool, netconn_t, pool_entry) {
317 if(collect_type > COLLECT_TIMEOUT || netconn->keep_until < now) {
318 TRACE("freeing %p\n", netconn);
319 list_remove(&netconn->pool_entry);
320 free_netconn(netconn);
321 }else {
322 remaining = TRUE;
323 }
324 }
325
326 if(collect_type == COLLECT_CLEANUP) {
327 list_remove(&server->entry);
328 list_init(&server->entry);
329 server_release(server);
330 }
331 }
332
333 return remaining;
334 }
335
336 static DWORD WINAPI collect_connections_proc(void *arg)
337 {
338 BOOL remaining_conns;
339
340 do {
341 /* FIXME: Use more sophisticated method */
342 Sleep(5000);
343
344 EnterCriticalSection(&connection_pool_cs);
345
346 remaining_conns = collect_connections(COLLECT_TIMEOUT);
347 if(!remaining_conns)
348 collector_running = FALSE;
349
350 LeaveCriticalSection(&connection_pool_cs);
351 }while(remaining_conns);
352
353 FreeLibraryAndExitThread(WININET_hModule, 0);
354 }
355
356 /***********************************************************************
357 * HTTP_GetHeader (internal)
358 *
359 * Headers section must be held
360 */
361 static LPHTTPHEADERW HTTP_GetHeader(http_request_t *req, LPCWSTR head)
362 {
363 int HeaderIndex = 0;
364 HeaderIndex = HTTP_GetCustomHeaderIndex(req, head, 0, TRUE);
365 if (HeaderIndex == -1)
366 return NULL;
367 else
368 return &req->custHeaders[HeaderIndex];
369 }
370
371 static WCHAR *get_host_header( http_request_t *req )
372 {
373 HTTPHEADERW *header;
374 WCHAR *ret = NULL;
375
376 EnterCriticalSection( &req->headers_section );
377 if ((header = HTTP_GetHeader( req, hostW ))) ret = heap_strdupW( header->lpszValue );
378 else ret = heap_strdupW( req->server->canon_host_port );
379 LeaveCriticalSection( &req->headers_section );
380 return ret;
381 }
382
383 struct data_stream_vtbl_t {
384 BOOL (*end_of_data)(data_stream_t*,http_request_t*);
385 DWORD (*read)(data_stream_t*,http_request_t*,BYTE*,DWORD,DWORD*,BOOL);
386 DWORD (*drain_content)(data_stream_t*,http_request_t*,BOOL);
387 void (*destroy)(data_stream_t*);
388 };
389
390 typedef struct {
391 data_stream_t data_stream;
392
393 BYTE buf[READ_BUFFER_SIZE];
394 DWORD buf_size;
395 DWORD buf_pos;
396 DWORD chunk_size;
397
398 enum {
399 CHUNKED_STREAM_STATE_READING_CHUNK_SIZE,
400 CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE,
401 CHUNKED_STREAM_STATE_READING_CHUNK,
402 CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA,
403 CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END,
404 CHUNKED_STREAM_STATE_END_OF_STREAM,
405 CHUNKED_STREAM_STATE_ERROR
406 } state;
407 } chunked_stream_t;
408
409 static inline void destroy_data_stream(data_stream_t *stream)
410 {
411 stream->vtbl->destroy(stream);
412 }
413
414 static void reset_data_stream(http_request_t *req)
415 {
416 destroy_data_stream(req->data_stream);
417 req->data_stream = &req->netconn_stream.data_stream;
418 req->read_pos = req->read_size = req->netconn_stream.content_read = 0;
419 req->read_gzip = FALSE;
420 }
421
422 static void remove_header( http_request_t *request, const WCHAR *str, BOOL from_request )
423 {
424 int index;
425 EnterCriticalSection( &request->headers_section );
426 index = HTTP_GetCustomHeaderIndex( request, str, 0, from_request );
427 if (index != -1) HTTP_DeleteCustomHeader( request, index );
428 LeaveCriticalSection( &request->headers_section );
429 }
430
431 #ifdef HAVE_ZLIB
432
433 typedef struct {
434 data_stream_t stream;
435 data_stream_t *parent_stream;
436 z_stream zstream;
437 BYTE buf[READ_BUFFER_SIZE];
438 DWORD buf_size;
439 DWORD buf_pos;
440 BOOL end_of_data;
441 } gzip_stream_t;
442
443 static BOOL gzip_end_of_data(data_stream_t *stream, http_request_t *req)
444 {
445 gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
446 return gzip_stream->end_of_data
447 || (!gzip_stream->buf_size && gzip_stream->parent_stream->vtbl->end_of_data(gzip_stream->parent_stream, req));
448 }
449
450 static DWORD gzip_read(data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size,
451 DWORD *read, BOOL allow_blocking)
452 {
453 gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
454 z_stream *zstream = &gzip_stream->zstream;
455 DWORD current_read, ret_read = 0;
456 int zres;
457 DWORD res = ERROR_SUCCESS;
458
459 TRACE("(%d %x)\n", size, allow_blocking);
460
461 while(size && !gzip_stream->end_of_data) {
462 if(!gzip_stream->buf_size) {
463 if(gzip_stream->buf_pos) {
464 if(gzip_stream->buf_size)
465 memmove(gzip_stream->buf, gzip_stream->buf+gzip_stream->buf_pos, gzip_stream->buf_size);
466 gzip_stream->buf_pos = 0;
467 }
468 res = gzip_stream->parent_stream->vtbl->read(gzip_stream->parent_stream, req, gzip_stream->buf+gzip_stream->buf_size,
469 sizeof(gzip_stream->buf)-gzip_stream->buf_size, &current_read, allow_blocking);
470 if(res != ERROR_SUCCESS)
471 break;
472
473 gzip_stream->buf_size += current_read;
474 if(!current_read) {
475 WARN("unexpected end of data\n");
476 gzip_stream->end_of_data = TRUE;
477 break;
478 }
479 }
480
481 zstream->next_in = gzip_stream->buf+gzip_stream->buf_pos;
482 zstream->avail_in = gzip_stream->buf_size;
483 zstream->next_out = buf+ret_read;
484 zstream->avail_out = size;
485 zres = inflate(&gzip_stream->zstream, 0);
486 current_read = size - zstream->avail_out;
487 size -= current_read;
488 ret_read += current_read;
489 gzip_stream->buf_size -= zstream->next_in - (gzip_stream->buf+gzip_stream->buf_pos);
490 gzip_stream->buf_pos = zstream->next_in-gzip_stream->buf;
491 if(zres == Z_STREAM_END) {
492 TRACE("end of data\n");
493 gzip_stream->end_of_data = TRUE;
494 inflateEnd(zstream);
495 }else if(zres != Z_OK) {
496 WARN("inflate failed %d: %s\n", zres, debugstr_a(zstream->msg));
497 if(!ret_read)
498 res = ERROR_INTERNET_DECODING_FAILED;
499 break;
500 }
501
502 if(ret_read)
503 allow_blocking = FALSE;
504 }
505
506 TRACE("read %u bytes\n", ret_read);
507 if(ret_read)
508 res = ERROR_SUCCESS;
509 *read = ret_read;
510 return res;
511 }
512
513 static DWORD gzip_drain_content(data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
514 {
515 gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
516 return gzip_stream->parent_stream->vtbl->drain_content(gzip_stream->parent_stream, req, allow_blocking);
517 }
518
519 static void gzip_destroy(data_stream_t *stream)
520 {
521 gzip_stream_t *gzip_stream = (gzip_stream_t*)stream;
522
523 destroy_data_stream(gzip_stream->parent_stream);
524
525 if(!gzip_stream->end_of_data)
526 inflateEnd(&gzip_stream->zstream);
527 heap_free(gzip_stream);
528 }
529
530 static const data_stream_vtbl_t gzip_stream_vtbl = {
531 gzip_end_of_data,
532 gzip_read,
533 gzip_drain_content,
534 gzip_destroy
535 };
536
537 static voidpf wininet_zalloc(voidpf opaque, uInt items, uInt size)
538 {
539 return heap_alloc(items*size);
540 }
541
542 static void wininet_zfree(voidpf opaque, voidpf address)
543 {
544 heap_free(address);
545 }
546
547 static DWORD init_gzip_stream(http_request_t *req, BOOL is_gzip)
548 {
549 gzip_stream_t *gzip_stream;
550 int zres;
551
552 gzip_stream = heap_alloc_zero(sizeof(gzip_stream_t));
553 if(!gzip_stream)
554 return ERROR_OUTOFMEMORY;
555
556 gzip_stream->stream.vtbl = &gzip_stream_vtbl;
557 gzip_stream->zstream.zalloc = wininet_zalloc;
558 gzip_stream->zstream.zfree = wininet_zfree;
559
560 zres = inflateInit2(&gzip_stream->zstream, is_gzip ? 0x1f : -15);
561 if(zres != Z_OK) {
562 ERR("inflateInit failed: %d\n", zres);
563 heap_free(gzip_stream);
564 return ERROR_OUTOFMEMORY;
565 }
566
567 remove_header(req, szContent_Length, FALSE);
568
569 if(req->read_size) {
570 memcpy(gzip_stream->buf, req->read_buf+req->read_pos, req->read_size);
571 gzip_stream->buf_size = req->read_size;
572 req->read_pos = req->read_size = 0;
573 }
574
575 req->read_gzip = TRUE;
576 gzip_stream->parent_stream = req->data_stream;
577 req->data_stream = &gzip_stream->stream;
578 return ERROR_SUCCESS;
579 }
580
581 #else
582
583 static DWORD init_gzip_stream(http_request_t *req, BOOL is_gzip)
584 {
585 ERR("gzip stream not supported, missing zlib.\n");
586 return ERROR_SUCCESS;
587 }
588
589 #endif
590
591 /***********************************************************************
592 * HTTP_FreeTokens (internal)
593 *
594 * Frees table of pointers.
595 */
596 static void HTTP_FreeTokens(LPWSTR * token_array)
597 {
598 int i;
599 for (i = 0; token_array[i]; i++) heap_free(token_array[i]);
600 heap_free(token_array);
601 }
602
603 static void HTTP_FixURL(http_request_t *request)
604 {
605 static const WCHAR szSlash[] = { '/',0 };
606 static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/', 0 };
607
608 /* If we don't have a path we set it to root */
609 if (NULL == request->path)
610 request->path = heap_strdupW(szSlash);
611 else /* remove \r and \n*/
612 {
613 int nLen = strlenW(request->path);
614 while ((nLen >0 ) && ((request->path[nLen-1] == '\r')||(request->path[nLen-1] == '\n')))
615 {
616 nLen--;
617 request->path[nLen]='\0';
618 }
619 /* Replace '\' with '/' */
620 while (nLen>0) {
621 nLen--;
622 if (request->path[nLen] == '\\') request->path[nLen]='/';
623 }
624 }
625
626 if(CSTR_EQUAL != CompareStringW( LOCALE_INVARIANT, NORM_IGNORECASE,
627 request->path, strlenW(request->path), szHttp, strlenW(szHttp) )
628 && request->path[0] != '/') /* not an absolute path ?? --> fix it !! */
629 {
630 WCHAR *fixurl = heap_alloc((strlenW(request->path) + 2)*sizeof(WCHAR));
631 *fixurl = '/';
632 strcpyW(fixurl + 1, request->path);
633 heap_free( request->path );
634 request->path = fixurl;
635 }
636 }
637
638 static WCHAR* build_request_header(http_request_t *request, const WCHAR *verb,
639 const WCHAR *path, const WCHAR *version, BOOL use_cr)
640 {
641 static const WCHAR szSpace[] = {' ',0};
642 static const WCHAR szColon[] = {':',' ',0};
643 static const WCHAR szCr[] = {'\r',0};
644 static const WCHAR szLf[] = {'\n',0};
645 LPWSTR requestString;
646 DWORD len, n;
647 LPCWSTR *req;
648 UINT i;
649
650 EnterCriticalSection( &request->headers_section );
651
652 /* allocate space for an array of all the string pointers to be added */
653 len = request->nCustHeaders * 5 + 10;
654 if (!(req = heap_alloc( len * sizeof(const WCHAR *) )))
655 {
656 LeaveCriticalSection( &request->headers_section );
657 return NULL;
658 }
659
660 /* add the verb, path and HTTP version string */
661 n = 0;
662 req[n++] = verb;
663 req[n++] = szSpace;
664 req[n++] = path;
665 req[n++] = szSpace;
666 req[n++] = version;
667 if (use_cr)
668 req[n++] = szCr;
669 req[n++] = szLf;
670
671 /* Append custom request headers */
672 for (i = 0; i < request->nCustHeaders; i++)
673 {
674 if (request->custHeaders[i].wFlags & HDR_ISREQUEST)
675 {
676 req[n++] = request->custHeaders[i].lpszField;
677 req[n++] = szColon;
678 req[n++] = request->custHeaders[i].lpszValue;
679 if (use_cr)
680 req[n++] = szCr;
681 req[n++] = szLf;
682
683 TRACE("Adding custom header %s (%s)\n",
684 debugstr_w(request->custHeaders[i].lpszField),
685 debugstr_w(request->custHeaders[i].lpszValue));
686 }
687 }
688 if (use_cr)
689 req[n++] = szCr;
690 req[n++] = szLf;
691 req[n] = NULL;
692
693 requestString = HTTP_build_req( req, 4 );
694 heap_free( req );
695 LeaveCriticalSection( &request->headers_section );
696 return requestString;
697 }
698
699 static WCHAR* build_response_header(http_request_t *request, BOOL use_cr)
700 {
701 static const WCHAR colonW[] = { ':',' ',0 };
702 static const WCHAR crW[] = { '\r',0 };
703 static const WCHAR lfW[] = { '\n',0 };
704 static const WCHAR status_fmt[] = { ' ','%','u',' ',0 };
705 const WCHAR **req;
706 WCHAR *ret, buf[14];
707 DWORD i, n = 0;
708
709 EnterCriticalSection( &request->headers_section );
710
711 if (!(req = heap_alloc( (request->nCustHeaders * 5 + 8) * sizeof(WCHAR *) )))
712 {
713 LeaveCriticalSection( &request->headers_section );
714 return NULL;
715 }
716
717 if (request->status_code)
718 {
719 req[n++] = request->version;
720 sprintfW(buf, status_fmt, request->status_code);
721 req[n++] = buf;
722 req[n++] = request->statusText;
723 if (use_cr)
724 req[n++] = crW;
725 req[n++] = lfW;
726 }
727
728 for(i = 0; i < request->nCustHeaders; i++)
729 {
730 if(!(request->custHeaders[i].wFlags & HDR_ISREQUEST)
731 && strcmpW(request->custHeaders[i].lpszField, szStatus))
732 {
733 req[n++] = request->custHeaders[i].lpszField;
734 req[n++] = colonW;
735 req[n++] = request->custHeaders[i].lpszValue;
736 if(use_cr)
737 req[n++] = crW;
738 req[n++] = lfW;
739
740 TRACE("Adding custom header %s (%s)\n",
741 debugstr_w(request->custHeaders[i].lpszField),
742 debugstr_w(request->custHeaders[i].lpszValue));
743 }
744 }
745 if(use_cr)
746 req[n++] = crW;
747 req[n++] = lfW;
748 req[n] = NULL;
749
750 ret = HTTP_build_req(req, 0);
751 heap_free(req);
752 LeaveCriticalSection( &request->headers_section );
753 return ret;
754 }
755
756 static void HTTP_ProcessCookies( http_request_t *request )
757 {
758 int HeaderIndex;
759 int numCookies = 0;
760 LPHTTPHEADERW setCookieHeader;
761
762 if(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES)
763 return;
764
765 EnterCriticalSection( &request->headers_section );
766
767 while((HeaderIndex = HTTP_GetCustomHeaderIndex(request, szSet_Cookie, numCookies++, FALSE)) != -1)
768 {
769 const WCHAR *data;
770 substr_t name;
771
772 setCookieHeader = &request->custHeaders[HeaderIndex];
773
774 if (!setCookieHeader->lpszValue)
775 continue;
776
777 data = strchrW(setCookieHeader->lpszValue, '=');
778 if(!data)
779 continue;
780
781 name = substr(setCookieHeader->lpszValue, data - setCookieHeader->lpszValue);
782 data++;
783 set_cookie(substrz(request->server->name), substrz(request->path), name, substrz(data), INTERNET_COOKIE_HTTPONLY);
784 }
785
786 LeaveCriticalSection( &request->headers_section );
787 }
788
789 static void strip_spaces(LPWSTR start)
790 {
791 LPWSTR str = start;
792 LPWSTR end;
793
794 while (*str == ' ')
795 str++;
796
797 if (str != start)
798 memmove(start, str, sizeof(WCHAR) * (strlenW(str) + 1));
799
800 end = start + strlenW(start) - 1;
801 while (end >= start && *end == ' ')
802 {
803 *end = '\0';
804 end--;
805 }
806 }
807
808 static inline BOOL is_basic_auth_value( LPCWSTR pszAuthValue, LPWSTR *pszRealm )
809 {
810 static const WCHAR szBasic[] = {'B','a','s','i','c'}; /* Note: not nul-terminated */
811 static const WCHAR szRealm[] = {'r','e','a','l','m'}; /* Note: not nul-terminated */
812 BOOL is_basic;
813 is_basic = !strncmpiW(pszAuthValue, szBasic, ARRAYSIZE(szBasic)) &&
814 ((pszAuthValue[ARRAYSIZE(szBasic)] == ' ') || !pszAuthValue[ARRAYSIZE(szBasic)]);
815 if (is_basic && pszRealm)
816 {
817 LPCWSTR token;
818 LPCWSTR ptr = &pszAuthValue[ARRAYSIZE(szBasic)];
819 LPCWSTR realm;
820 ptr++;
821 *pszRealm=NULL;
822 token = strchrW(ptr,'=');
823 if (!token)
824 return TRUE;
825 realm = ptr;
826 while (*realm == ' ')
827 realm++;
828 if(!strncmpiW(realm, szRealm, ARRAYSIZE(szRealm)) &&
829 (realm[ARRAYSIZE(szRealm)] == ' ' || realm[ARRAYSIZE(szRealm)] == '='))
830 {
831 token++;
832 while (*token == ' ')
833 token++;
834 if (*token == '\0')
835 return TRUE;
836 *pszRealm = heap_strdupW(token);
837 strip_spaces(*pszRealm);
838 }
839 }
840
841 return is_basic;
842 }
843
844 static void destroy_authinfo( struct HttpAuthInfo *authinfo )
845 {
846 if (!authinfo) return;
847
848 if (SecIsValidHandle(&authinfo->ctx))
849 DeleteSecurityContext(&authinfo->ctx);
850 if (SecIsValidHandle(&authinfo->cred))
851 FreeCredentialsHandle(&authinfo->cred);
852
853 heap_free(authinfo->auth_data);
854 heap_free(authinfo->scheme);
855 heap_free(authinfo);
856 }
857
858 static UINT retrieve_cached_basic_authorization(const WCHAR *host, const WCHAR *realm, char **auth_data)
859 {
860 basicAuthorizationData *ad;
861 UINT rc = 0;
862
863 TRACE("Looking for authorization for %s:%s\n",debugstr_w(host),debugstr_w(realm));
864
865 EnterCriticalSection(&authcache_cs);
866 LIST_FOR_EACH_ENTRY(ad, &basicAuthorizationCache, basicAuthorizationData, entry)
867 {
868 if (!strcmpiW(host, ad->host) && (!realm || !strcmpW(realm, ad->realm)))
869 {
870 TRACE("Authorization found in cache\n");
871 *auth_data = heap_alloc(ad->authorizationLen);
872 memcpy(*auth_data,ad->authorization,ad->authorizationLen);
873 rc = ad->authorizationLen;
874 break;
875 }
876 }
877 LeaveCriticalSection(&authcache_cs);
878 return rc;
879 }
880
881 static void cache_basic_authorization(LPWSTR host, LPWSTR realm, LPSTR auth_data, UINT auth_data_len)
882 {
883 struct list *cursor;
884 basicAuthorizationData* ad = NULL;
885
886 TRACE("caching authorization for %s:%s = %s\n",debugstr_w(host),debugstr_w(realm),debugstr_an(auth_data,auth_data_len));
887
888 EnterCriticalSection(&authcache_cs);
889 LIST_FOR_EACH(cursor, &basicAuthorizationCache)
890 {
891 basicAuthorizationData *check = LIST_ENTRY(cursor,basicAuthorizationData,entry);
892 if (!strcmpiW(host,check->host) && !strcmpW(realm,check->realm))
893 {
894 ad = check;
895 break;
896 }
897 }
898
899 if (ad)
900 {
901 TRACE("Found match in cache, replacing\n");
902 heap_free(ad->authorization);
903 ad->authorization = heap_alloc(auth_data_len);
904 memcpy(ad->authorization, auth_data, auth_data_len);
905 ad->authorizationLen = auth_data_len;
906 }
907 else
908 {
909 ad = heap_alloc(sizeof(basicAuthorizationData));
910 ad->host = heap_strdupW(host);
911 ad->realm = heap_strdupW(realm);
912 ad->authorization = heap_alloc(auth_data_len);
913 memcpy(ad->authorization, auth_data, auth_data_len);
914 ad->authorizationLen = auth_data_len;
915 list_add_head(&basicAuthorizationCache,&ad->entry);
916 TRACE("authorization cached\n");
917 }
918 LeaveCriticalSection(&authcache_cs);
919 }
920
921 static BOOL retrieve_cached_authorization(LPWSTR host, LPWSTR scheme,
922 SEC_WINNT_AUTH_IDENTITY_W *nt_auth_identity)
923 {
924 authorizationData *ad;
925
926 TRACE("Looking for authorization for %s:%s\n", debugstr_w(host), debugstr_w(scheme));
927
928 EnterCriticalSection(&authcache_cs);
929 LIST_FOR_EACH_ENTRY(ad, &authorizationCache, authorizationData, entry) {
930 if(!strcmpiW(host, ad->host) && !strcmpiW(scheme, ad->scheme)) {
931 TRACE("Authorization found in cache\n");
932
933 nt_auth_identity->User = heap_strdupW(ad->user);
934 nt_auth_identity->Password = heap_strdupW(ad->password);
935 nt_auth_identity->Domain = heap_alloc(sizeof(WCHAR)*ad->domain_len);
936 if(!nt_auth_identity->User || !nt_auth_identity->Password ||
937 (!nt_auth_identity->Domain && ad->domain_len)) {
938 heap_free(nt_auth_identity->User);
939 heap_free(nt_auth_identity->Password);
940 heap_free(nt_auth_identity->Domain);
941 break;
942 }
943
944 nt_auth_identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
945 nt_auth_identity->UserLength = ad->user_len;
946 nt_auth_identity->PasswordLength = ad->password_len;
947 memcpy(nt_auth_identity->Domain, ad->domain, sizeof(WCHAR)*ad->domain_len);
948 nt_auth_identity->DomainLength = ad->domain_len;
949 LeaveCriticalSection(&authcache_cs);
950 return TRUE;
951 }
952 }
953 LeaveCriticalSection(&authcache_cs);
954
955 return FALSE;
956 }
957
958 static void cache_authorization(LPWSTR host, LPWSTR scheme,
959 SEC_WINNT_AUTH_IDENTITY_W *nt_auth_identity)
960 {
961 authorizationData *ad;
962 BOOL found = FALSE;
963
964 TRACE("Caching authorization for %s:%s\n", debugstr_w(host), debugstr_w(scheme));
965
966 EnterCriticalSection(&authcache_cs);
967 LIST_FOR_EACH_ENTRY(ad, &authorizationCache, authorizationData, entry)
968 if(!strcmpiW(host, ad->host) && !strcmpiW(scheme, ad->scheme)) {
969 found = TRUE;
970 break;
971 }
972
973 if(found) {
974 heap_free(ad->user);
975 heap_free(ad->password);
976 heap_free(ad->domain);
977 } else {
978 ad = heap_alloc(sizeof(authorizationData));
979 if(!ad) {
980 LeaveCriticalSection(&authcache_cs);
981 return;
982 }
983
984 ad->host = heap_strdupW(host);
985 ad->scheme = heap_strdupW(scheme);
986 list_add_head(&authorizationCache, &ad->entry);
987 }
988
989 ad->user = heap_strndupW(nt_auth_identity->User, nt_auth_identity->UserLength);
990 ad->password = heap_strndupW(nt_auth_identity->Password, nt_auth_identity->PasswordLength);
991 ad->domain = heap_strndupW(nt_auth_identity->Domain, nt_auth_identity->DomainLength);
992 ad->user_len = nt_auth_identity->UserLength;
993 ad->password_len = nt_auth_identity->PasswordLength;
994 ad->domain_len = nt_auth_identity->DomainLength;
995
996 if(!ad->host || !ad->scheme || !ad->user || !ad->password
997 || (nt_auth_identity->Domain && !ad->domain)) {
998 heap_free(ad->host);
999 heap_free(ad->scheme);
1000 heap_free(ad->user);
1001 heap_free(ad->password);
1002 heap_free(ad->domain);
1003 list_remove(&ad->entry);
1004 heap_free(ad);
1005 }
1006
1007 LeaveCriticalSection(&authcache_cs);
1008 }
1009
1010 static BOOL HTTP_DoAuthorization( http_request_t *request, LPCWSTR pszAuthValue,
1011 struct HttpAuthInfo **ppAuthInfo,
1012 LPWSTR domain_and_username, LPWSTR password,
1013 LPWSTR host )
1014 {
1015 SECURITY_STATUS sec_status;
1016 struct HttpAuthInfo *pAuthInfo = *ppAuthInfo;
1017 BOOL first = FALSE;
1018 LPWSTR szRealm = NULL;
1019
1020 TRACE("%s\n", debugstr_w(pszAuthValue));
1021
1022 if (!pAuthInfo)
1023 {
1024 TimeStamp exp;
1025
1026 first = TRUE;
1027 pAuthInfo = heap_alloc(sizeof(*pAuthInfo));
1028 if (!pAuthInfo)
1029 return FALSE;
1030
1031 SecInvalidateHandle(&pAuthInfo->cred);
1032 SecInvalidateHandle(&pAuthInfo->ctx);
1033 memset(&pAuthInfo->exp, 0, sizeof(pAuthInfo->exp));
1034 pAuthInfo->attr = 0;
1035 pAuthInfo->auth_data = NULL;
1036 pAuthInfo->auth_data_len = 0;
1037 pAuthInfo->finished = FALSE;
1038
1039 if (is_basic_auth_value(pszAuthValue,NULL))
1040 {
1041 static const WCHAR szBasic[] = {'B','a','s','i','c',0};
1042 pAuthInfo->scheme = heap_strdupW(szBasic);
1043 if (!pAuthInfo->scheme)
1044 {
1045 heap_free(pAuthInfo);
1046 return FALSE;
1047 }
1048 }
1049 else
1050 {
1051 PVOID pAuthData;
1052 SEC_WINNT_AUTH_IDENTITY_W nt_auth_identity;
1053
1054 pAuthInfo->scheme = heap_strdupW(pszAuthValue);
1055 if (!pAuthInfo->scheme)
1056 {
1057 heap_free(pAuthInfo);
1058 return FALSE;
1059 }
1060
1061 if (domain_and_username)
1062 {
1063 WCHAR *user = strchrW(domain_and_username, '\\');
1064 WCHAR *domain = domain_and_username;
1065
1066 /* FIXME: make sure scheme accepts SEC_WINNT_AUTH_IDENTITY before calling AcquireCredentialsHandle */
1067
1068 pAuthData = &nt_auth_identity;
1069
1070 if (user) user++;
1071 else
1072 {
1073 user = domain_and_username;
1074 domain = NULL;
1075 }
1076
1077 nt_auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1078 nt_auth_identity.User = user;
1079 nt_auth_identity.UserLength = strlenW(nt_auth_identity.User);
1080 nt_auth_identity.Domain = domain;
1081 nt_auth_identity.DomainLength = domain ? user - domain - 1 : 0;
1082 nt_auth_identity.Password = password;
1083 nt_auth_identity.PasswordLength = strlenW(nt_auth_identity.Password);
1084
1085 cache_authorization(host, pAuthInfo->scheme, &nt_auth_identity);
1086 }
1087 else if(retrieve_cached_authorization(host, pAuthInfo->scheme, &nt_auth_identity))
1088 pAuthData = &nt_auth_identity;
1089 else
1090 /* use default credentials */
1091 pAuthData = NULL;
1092
1093 sec_status = AcquireCredentialsHandleW(NULL, pAuthInfo->scheme,
1094 SECPKG_CRED_OUTBOUND, NULL,
1095 pAuthData, NULL,
1096 NULL, &pAuthInfo->cred,
1097 &exp);
1098
1099 if(pAuthData && !domain_and_username) {
1100 heap_free(nt_auth_identity.User);
1101 heap_free(nt_auth_identity.Domain);
1102 heap_free(nt_auth_identity.Password);
1103 }
1104
1105 if (sec_status == SEC_E_OK)
1106 {
1107 PSecPkgInfoW sec_pkg_info;
1108 sec_status = QuerySecurityPackageInfoW(pAuthInfo->scheme, &sec_pkg_info);
1109 if (sec_status == SEC_E_OK)
1110 {
1111 pAuthInfo->max_token = sec_pkg_info->cbMaxToken;
1112 FreeContextBuffer(sec_pkg_info);
1113 }
1114 }
1115 if (sec_status != SEC_E_OK)
1116 {
1117 WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
1118 debugstr_w(pAuthInfo->scheme), sec_status);
1119 heap_free(pAuthInfo->scheme);
1120 heap_free(pAuthInfo);
1121 return FALSE;
1122 }
1123 }
1124 *ppAuthInfo = pAuthInfo;
1125 }
1126 else if (pAuthInfo->finished)
1127 return FALSE;
1128
1129 if ((strlenW(pszAuthValue) < strlenW(pAuthInfo->scheme)) ||
1130 strncmpiW(pszAuthValue, pAuthInfo->scheme, strlenW(pAuthInfo->scheme)))
1131 {
1132 ERR("authentication scheme changed from %s to %s\n",
1133 debugstr_w(pAuthInfo->scheme), debugstr_w(pszAuthValue));
1134 return FALSE;
1135 }
1136
1137 if (is_basic_auth_value(pszAuthValue,&szRealm))
1138 {
1139 int userlen;
1140 int passlen;
1141 char *auth_data = NULL;
1142 UINT auth_data_len = 0;
1143
1144 TRACE("basic authentication realm %s\n",debugstr_w(szRealm));
1145
1146 if (!domain_and_username)
1147 {
1148 if (host && szRealm)
1149 auth_data_len = retrieve_cached_basic_authorization(host, szRealm,&auth_data);
1150 if (auth_data_len == 0)
1151 {
1152 heap_free(szRealm);
1153 return FALSE;
1154 }
1155 }
1156 else
1157 {
1158 userlen = WideCharToMultiByte(CP_UTF8, 0, domain_and_username, lstrlenW(domain_and_username), NULL, 0, NULL, NULL);
1159 passlen = WideCharToMultiByte(CP_UTF8, 0, password, lstrlenW(password), NULL, 0, NULL, NULL);
1160
1161 /* length includes a nul terminator, which will be re-used for the ':' */
1162 auth_data = heap_alloc(userlen + 1 + passlen);
1163 if (!auth_data)
1164 {
1165 heap_free(szRealm);
1166 return FALSE;
1167 }
1168
1169 WideCharToMultiByte(CP_UTF8, 0, domain_and_username, -1, auth_data, userlen, NULL, NULL);
1170 auth_data[userlen] = ':';
1171 WideCharToMultiByte(CP_UTF8, 0, password, -1, &auth_data[userlen+1], passlen, NULL, NULL);
1172 auth_data_len = userlen + 1 + passlen;
1173 if (host && szRealm)
1174 cache_basic_authorization(host, szRealm, auth_data, auth_data_len);
1175 }
1176
1177 pAuthInfo->auth_data = auth_data;
1178 pAuthInfo->auth_data_len = auth_data_len;
1179 pAuthInfo->finished = TRUE;
1180 heap_free(szRealm);
1181 return TRUE;
1182 }
1183 else
1184 {
1185 LPCWSTR pszAuthData;
1186 SecBufferDesc out_desc, in_desc;
1187 SecBuffer out, in;
1188 unsigned char *buffer;
1189 ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
1190 ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
1191
1192 in.BufferType = SECBUFFER_TOKEN;
1193 in.cbBuffer = 0;
1194 in.pvBuffer = NULL;
1195
1196 in_desc.ulVersion = 0;
1197 in_desc.cBuffers = 1;
1198 in_desc.pBuffers = &in;
1199
1200 pszAuthData = pszAuthValue + strlenW(pAuthInfo->scheme);
1201 if (*pszAuthData == ' ')
1202 {
1203 pszAuthData++;
1204 in.cbBuffer = HTTP_DecodeBase64(pszAuthData, NULL);
1205 in.pvBuffer = heap_alloc(in.cbBuffer);
1206 HTTP_DecodeBase64(pszAuthData, in.pvBuffer);
1207 }
1208
1209 buffer = heap_alloc(pAuthInfo->max_token);
1210
1211 out.BufferType = SECBUFFER_TOKEN;
1212 out.cbBuffer = pAuthInfo->max_token;
1213 out.pvBuffer = buffer;
1214
1215 out_desc.ulVersion = 0;
1216 out_desc.cBuffers = 1;
1217 out_desc.pBuffers = &out;
1218
1219 sec_status = InitializeSecurityContextW(first ? &pAuthInfo->cred : NULL,
1220 first ? NULL : &pAuthInfo->ctx,
1221 first ? request->server->name : NULL,
1222 context_req, 0, SECURITY_NETWORK_DREP,
1223 in.pvBuffer ? &in_desc : NULL,
1224 0, &pAuthInfo->ctx, &out_desc,
1225 &pAuthInfo->attr, &pAuthInfo->exp);
1226 if (sec_status == SEC_E_OK)
1227 {
1228 pAuthInfo->finished = TRUE;
1229 pAuthInfo->auth_data = out.pvBuffer;
1230 pAuthInfo->auth_data_len = out.cbBuffer;
1231 TRACE("sending last auth packet\n");
1232 }
1233 else if (sec_status == SEC_I_CONTINUE_NEEDED)
1234 {
1235 pAuthInfo->auth_data = out.pvBuffer;
1236 pAuthInfo->auth_data_len = out.cbBuffer;
1237 TRACE("sending next auth packet\n");
1238 }
1239 else
1240 {
1241 ERR("InitializeSecurityContextW returned error 0x%08x\n", sec_status);
1242 heap_free(out.pvBuffer);
1243 destroy_authinfo(pAuthInfo);
1244 *ppAuthInfo = NULL;
1245 return FALSE;
1246 }
1247 }
1248
1249 return TRUE;
1250 }
1251
1252 /***********************************************************************
1253 * HTTP_HttpAddRequestHeadersW (internal)
1254 */
1255 static DWORD HTTP_HttpAddRequestHeadersW(http_request_t *request,
1256 LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
1257 {
1258 LPWSTR lpszStart;
1259 LPWSTR lpszEnd;
1260 LPWSTR buffer;
1261 DWORD len, res = ERROR_HTTP_INVALID_HEADER;
1262
1263 TRACE("copying header: %s\n", debugstr_wn(lpszHeader, dwHeaderLength));
1264
1265 if( dwHeaderLength == ~0U )
1266 len = strlenW(lpszHeader);
1267 else
1268 len = dwHeaderLength;
1269 buffer = heap_alloc(sizeof(WCHAR)*(len+1));
1270 lstrcpynW( buffer, lpszHeader, len + 1);
1271
1272 lpszStart = buffer;
1273
1274 do
1275 {
1276 LPWSTR * pFieldAndValue;
1277
1278 lpszEnd = lpszStart;
1279
1280 while (*lpszEnd != '\0')
1281 {
1282 if (*lpszEnd == '\r' || *lpszEnd == '\n')
1283 break;
1284 lpszEnd++;
1285 }
1286
1287 if (*lpszStart == '\0')
1288 break;
1289
1290 if (*lpszEnd == '\r' || *lpszEnd == '\n')
1291 {
1292 *lpszEnd = '\0';
1293 lpszEnd++; /* Jump over newline */
1294 }
1295 TRACE("interpreting header %s\n", debugstr_w(lpszStart));
1296 if (*lpszStart == '\0')
1297 {
1298 /* Skip 0-length headers */
1299 lpszStart = lpszEnd;
1300 res = ERROR_SUCCESS;
1301 continue;
1302 }
1303 pFieldAndValue = HTTP_InterpretHttpHeader(lpszStart);
1304 if (pFieldAndValue)
1305 {
1306 res = HTTP_ProcessHeader(request, pFieldAndValue[0],
1307 pFieldAndValue[1], dwModifier | HTTP_ADDHDR_FLAG_REQ);
1308 HTTP_FreeTokens(pFieldAndValue);
1309 }
1310
1311 lpszStart = lpszEnd;
1312 } while (res == ERROR_SUCCESS);
1313
1314 heap_free(buffer);
1315 return res;
1316 }
1317
1318 /***********************************************************************
1319 * HttpAddRequestHeadersW (WININET.@)
1320 *
1321 * Adds one or more HTTP header to the request handler
1322 *
1323 * NOTE
1324 * On Windows if dwHeaderLength includes the trailing '\0', then
1325 * HttpAddRequestHeadersW() adds it too. However this results in an
1326 * invalid HTTP header which is rejected by some servers so we probably
1327 * don't need to match Windows on that point.
1328 *
1329 * RETURNS
1330 * TRUE on success
1331 * FALSE on failure
1332 *
1333 */
1334 BOOL WINAPI HttpAddRequestHeadersW(HINTERNET hHttpRequest,
1335 LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
1336 {
1337 http_request_t *request;
1338 DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
1339
1340 TRACE("%p, %s, %i, %i\n", hHttpRequest, debugstr_wn(lpszHeader, dwHeaderLength), dwHeaderLength, dwModifier);
1341
1342 if (!lpszHeader)
1343 return TRUE;
1344
1345 request = (http_request_t*) get_handle_object( hHttpRequest );
1346 if (request && request->hdr.htype == WH_HHTTPREQ)
1347 res = HTTP_HttpAddRequestHeadersW( request, lpszHeader, dwHeaderLength, dwModifier );
1348 if( request )
1349 WININET_Release( &request->hdr );
1350
1351 if(res != ERROR_SUCCESS)
1352 SetLastError(res);
1353 return res == ERROR_SUCCESS;
1354 }
1355
1356 /***********************************************************************
1357 * HttpAddRequestHeadersA (WININET.@)
1358 *
1359 * Adds one or more HTTP header to the request handler
1360 *
1361 * RETURNS
1362 * TRUE on success
1363 * FALSE on failure
1364 *
1365 */
1366 BOOL WINAPI HttpAddRequestHeadersA(HINTERNET hHttpRequest,
1367 LPCSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
1368 {
1369 WCHAR *headers = NULL;
1370 BOOL r;
1371
1372 TRACE("%p, %s, %i, %i\n", hHttpRequest, debugstr_an(lpszHeader, dwHeaderLength), dwHeaderLength, dwModifier);
1373
1374 if(lpszHeader)
1375 headers = heap_strndupAtoW(lpszHeader, dwHeaderLength, &dwHeaderLength);
1376
1377 r = HttpAddRequestHeadersW(hHttpRequest, headers, dwHeaderLength, dwModifier);
1378
1379 heap_free(headers);
1380 return r;
1381 }
1382
1383 static void free_accept_types( WCHAR **accept_types )
1384 {
1385 WCHAR *ptr, **types = accept_types;
1386
1387 if (!types) return;
1388 while ((ptr = *types))
1389 {
1390 heap_free( ptr );
1391 types++;
1392 }
1393 heap_free( accept_types );
1394 }
1395
1396 static WCHAR **convert_accept_types( const char **accept_types )
1397 {
1398 unsigned int count;
1399 const char **types = accept_types;
1400 WCHAR **typesW;
1401 BOOL invalid_pointer = FALSE;
1402
1403 if (!types) return NULL;
1404 count = 0;
1405 while (*types)
1406 {
1407 __TRY
1408 {
1409 /* find out how many there are */
1410 if (*types && **types)
1411 {
1412 TRACE("accept type: %s\n", debugstr_a(*types));
1413 count++;
1414 }
1415 }
1416 __EXCEPT_PAGE_FAULT
1417 {
1418 WARN("invalid accept type pointer\n");
1419 invalid_pointer = TRUE;
1420 }
1421 __ENDTRY;
1422 types++;
1423 }
1424 if (invalid_pointer) return NULL;
1425 if (!(typesW = heap_alloc( sizeof(WCHAR *) * (count + 1) ))) return NULL;
1426 count = 0;
1427 types = accept_types;
1428 while (*types)
1429 {
1430 if (*types && **types) typesW[count++] = heap_strdupAtoW( *types );
1431 types++;
1432 }
1433 typesW[count] = NULL;
1434 return typesW;
1435 }
1436
1437 /***********************************************************************
1438 * HttpOpenRequestA (WININET.@)
1439 *
1440 * Open a HTTP request handle
1441 *
1442 * RETURNS
1443 * HINTERNET a HTTP request handle on success
1444 * NULL on failure
1445 *
1446 */
1447 HINTERNET WINAPI HttpOpenRequestA(HINTERNET hHttpSession,
1448 LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion,
1449 LPCSTR lpszReferrer , LPCSTR *lpszAcceptTypes,
1450 DWORD dwFlags, DWORD_PTR dwContext)
1451 {
1452 LPWSTR szVerb = NULL, szObjectName = NULL;
1453 LPWSTR szVersion = NULL, szReferrer = NULL, *szAcceptTypes = NULL;
1454 HINTERNET rc = NULL;
1455
1456 TRACE("(%p, %s, %s, %s, %s, %p, %08x, %08lx)\n", hHttpSession,
1457 debugstr_a(lpszVerb), debugstr_a(lpszObjectName),
1458 debugstr_a(lpszVersion), debugstr_a(lpszReferrer), lpszAcceptTypes,
1459 dwFlags, dwContext);
1460
1461 if (lpszVerb)
1462 {
1463 szVerb = heap_strdupAtoW(lpszVerb);
1464 if ( !szVerb )
1465 goto end;
1466 }
1467
1468 if (lpszObjectName)
1469 {
1470 szObjectName = heap_strdupAtoW(lpszObjectName);
1471 if ( !szObjectName )
1472 goto end;
1473 }
1474
1475 if (lpszVersion)
1476 {
1477 szVersion = heap_strdupAtoW(lpszVersion);
1478 if ( !szVersion )
1479 goto end;
1480 }
1481
1482 if (lpszReferrer)
1483 {
1484 szReferrer = heap_strdupAtoW(lpszReferrer);
1485 if ( !szReferrer )
1486 goto end;
1487 }
1488
1489 szAcceptTypes = convert_accept_types( lpszAcceptTypes );
1490 rc = HttpOpenRequestW(hHttpSession, szVerb, szObjectName, szVersion, szReferrer,
1491 (const WCHAR **)szAcceptTypes, dwFlags, dwContext);
1492
1493 end:
1494 free_accept_types(szAcceptTypes);
1495 heap_free(szReferrer);
1496 heap_free(szVersion);
1497 heap_free(szObjectName);
1498 heap_free(szVerb);
1499 return rc;
1500 }
1501
1502 /***********************************************************************
1503 * HTTP_EncodeBase64
1504 */
1505 static UINT HTTP_EncodeBase64( LPCSTR bin, unsigned int len, LPWSTR base64 )
1506 {
1507 UINT n = 0, x;
1508 static const CHAR HTTP_Base64Enc[] =
1509 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1510
1511 while( len > 0 )
1512 {
1513 /* first 6 bits, all from bin[0] */
1514 base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2];
1515 x = (bin[0] & 3) << 4;
1516
1517 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
1518 if( len == 1 )
1519 {
1520 base64[n++] = HTTP_Base64Enc[x];
1521 base64[n++] = '=';
1522 base64[n++] = '=';
1523 break;
1524 }
1525 base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ];
1526 x = ( bin[1] & 0x0f ) << 2;
1527
1528 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
1529 if( len == 2 )
1530 {
1531 base64[n++] = HTTP_Base64Enc[x];
1532 base64[n++] = '=';
1533 break;
1534 }
1535 base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ];
1536
1537 /* last 6 bits, all from bin [2] */
1538 base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ];
1539 bin += 3;
1540 len -= 3;
1541 }
1542 base64[n] = 0;
1543 return n;
1544 }
1545
1546 static const signed char HTTP_Base64Dec[] =
1547 {
1548 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00 */
1549 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10 */
1550 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20 */
1551 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30 */
1552 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40 */
1553 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50 */
1554 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60 */
1555 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 /* 0x70 */
1556 };
1557
1558 /***********************************************************************
1559 * HTTP_DecodeBase64
1560 */
1561 static UINT HTTP_DecodeBase64( LPCWSTR base64, LPSTR bin )
1562 {
1563 unsigned int n = 0;
1564
1565 while(*base64)
1566 {
1567 signed char in[4];
1568
1569 if (base64[0] >= ARRAYSIZE(HTTP_Base64Dec) ||
1570 ((in[0] = HTTP_Base64Dec[base64[0]]) == -1) ||
1571 base64[1] >= ARRAYSIZE(HTTP_Base64Dec) ||
1572 ((in[1] = HTTP_Base64Dec[base64[1]]) == -1))
1573 {
1574 WARN("invalid base64: %s\n", debugstr_w(base64));
1575 return 0;
1576 }
1577 if (bin)
1578 bin[n] = (unsigned char) (in[0] << 2 | in[1] >> 4);
1579 n++;
1580
1581 if ((base64[2] == '=') && (base64[3] == '='))
1582 break;
1583 if (base64[2] > ARRAYSIZE(HTTP_Base64Dec) ||
1584 ((in[2] = HTTP_Base64Dec[base64[2]]) == -1))
1585 {
1586 WARN("invalid base64: %s\n", debugstr_w(&base64[2]));
1587 return 0;
1588 }
1589 if (bin)
1590 bin[n] = (unsigned char) (in[1] << 4 | in[2] >> 2);
1591 n++;
1592
1593 if (base64[3] == '=')
1594 break;
1595 if (base64[3] > ARRAYSIZE(HTTP_Base64Dec) ||
1596 ((in[3] = HTTP_Base64Dec[base64[3]]) == -1))
1597 {
1598 WARN("invalid base64: %s\n", debugstr_w(&base64[3]));
1599 return 0;
1600 }
1601 if (bin)
1602 bin[n] = (unsigned char) (((in[2] << 6) & 0xc0) | in[3]);
1603 n++;
1604
1605 base64 += 4;
1606 }
1607
1608 return n;
1609 }
1610
1611 static WCHAR *encode_auth_data( const WCHAR *scheme, const char *data, UINT data_len )
1612 {
1613 WCHAR *ret;
1614 UINT len, scheme_len = strlenW( scheme );
1615
1616 /* scheme + space + base64 encoded data (3/2/1 bytes data -> 4 bytes of characters) */
1617 len = scheme_len + 1 + ((data_len + 2) * 4) / 3;
1618 if (!(ret = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
1619 memcpy( ret, scheme, scheme_len * sizeof(WCHAR) );
1620 ret[scheme_len] = ' ';
1621 HTTP_EncodeBase64( data, data_len, ret + scheme_len + 1 );
1622 return ret;
1623 }
1624
1625
1626 /***********************************************************************
1627 * HTTP_InsertAuthorization
1628 *
1629 * Insert or delete the authorization field in the request header.
1630 */
1631 static BOOL HTTP_InsertAuthorization( http_request_t *request, struct HttpAuthInfo *pAuthInfo, LPCWSTR header )
1632 {
1633 static const WCHAR wszBasic[] = {'B','a','s','i','c',0};
1634 WCHAR *host, *authorization = NULL;
1635
1636 if (pAuthInfo)
1637 {
1638 if (pAuthInfo->auth_data_len)
1639 {
1640 if (!(authorization = encode_auth_data(pAuthInfo->scheme, pAuthInfo->auth_data, pAuthInfo->auth_data_len)))
1641 return FALSE;
1642
1643 /* clear the data as it isn't valid now that it has been sent to the
1644 * server, unless it's Basic authentication which doesn't do
1645 * connection tracking */
1646 if (strcmpiW(pAuthInfo->scheme, wszBasic))
1647 {
1648 heap_free(pAuthInfo->auth_data);
1649 pAuthInfo->auth_data = NULL;
1650 pAuthInfo->auth_data_len = 0;
1651 }
1652 }
1653
1654 TRACE("Inserting authorization: %s\n", debugstr_w(authorization));
1655
1656 HTTP_ProcessHeader(request, header, authorization,
1657 HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD);
1658 heap_free(authorization);
1659 }
1660 else if (!strcmpW(header, szAuthorization) && (host = get_host_header(request)))
1661 {
1662 UINT data_len;
1663 char *data;
1664
1665 if ((data_len = retrieve_cached_basic_authorization(host, NULL, &data)))
1666 {
1667 TRACE("Found cached basic authorization for %s\n", debugstr_w(host));
1668
1669 if (!(authorization = encode_auth_data(wszBasic, data, data_len)))
1670 {
1671 heap_free(data);
1672 heap_free(host);
1673 return FALSE;
1674 }
1675
1676 TRACE("Inserting authorization: %s\n", debugstr_w(authorization));
1677
1678 HTTP_ProcessHeader(request, header, authorization,
1679 HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD);
1680 heap_free(data);
1681 heap_free(authorization);
1682 }
1683 heap_free(host);
1684 }
1685 return TRUE;
1686 }
1687
1688 static WCHAR *build_proxy_path_url(http_request_t *req)
1689 {
1690 DWORD size, len;
1691 WCHAR *url;
1692
1693 len = strlenW(req->server->scheme_host_port);
1694 size = len + strlenW(req->path) + 1;
1695 if(*req->path != '/')
1696 size++;
1697 url = heap_alloc(size * sizeof(WCHAR));
1698 if(!url)
1699 return NULL;
1700
1701 memcpy(url, req->server->scheme_host_port, len*sizeof(WCHAR));
1702 if(*req->path != '/')
1703 url[len++] = '/';
1704
1705 strcpyW(url+len, req->path);
1706
1707 TRACE("url=%s\n", debugstr_w(url));
1708 return url;
1709 }
1710
1711 static BOOL HTTP_DomainMatches(LPCWSTR server, substr_t domain)
1712 {
1713 static const WCHAR localW[] = { '<','l','o','c','a','l','>',0 };
1714 const WCHAR *dot, *ptr;
1715 int len;
1716
1717 if(domain.len == sizeof(localW)/sizeof(WCHAR)-1 && !strncmpiW(domain.str, localW, domain.len) && !strchrW(server, '.' ))
1718 return TRUE;
1719
1720 if(domain.len && *domain.str != '*')
1721 return domain.len == strlenW(server) && !strncmpiW(server, domain.str, domain.len);
1722
1723 if(domain.len < 2 || domain.str[1] != '.')
1724 return FALSE;
1725
1726 /* For a hostname to match a wildcard, the last domain must match
1727 * the wildcard exactly. E.g. if the wildcard is *.a.b, and the
1728 * hostname is www.foo.a.b, it matches, but a.b does not.
1729 */
1730 dot = strchrW(server, '.');
1731 if(!dot)
1732 return FALSE;
1733
1734 len = strlenW(dot + 1);
1735 if(len < domain.len - 2)
1736 return FALSE;
1737
1738 /* The server's domain is longer than the wildcard, so it
1739 * could be a subdomain. Compare the last portion of the
1740 * server's domain.
1741 */
1742 ptr = dot + 1 + len - domain.len + 2;
1743 if(!strncmpiW(ptr, domain.str+2, domain.len-2))
1744 /* This is only a match if the preceding character is
1745 * a '.', i.e. that it is a matching domain. E.g.
1746 * if domain is '*.b.c' and server is 'www.ab.c' they
1747 * do not match.
1748 */
1749 return *(ptr - 1) == '.';
1750
1751 return len == domain.len-2 && !strncmpiW(dot + 1, domain.str + 2, len);
1752 }
1753
1754 static BOOL HTTP_ShouldBypassProxy(appinfo_t *lpwai, LPCWSTR server)
1755 {
1756 LPCWSTR ptr;
1757 BOOL ret = FALSE;
1758
1759 if (!lpwai->proxyBypass) return FALSE;
1760 ptr = lpwai->proxyBypass;
1761 while(1) {
1762 LPCWSTR tmp = ptr;
1763
1764 ptr = strchrW( ptr, ';' );
1765 if (!ptr)
1766 ptr = strchrW( tmp, ' ' );
1767 if (!ptr)
1768 ptr = tmp + strlenW(tmp);
1769 ret = HTTP_DomainMatches( server, substr(tmp, ptr-tmp) );
1770 if (ret || !*ptr)
1771 break;
1772 ptr++;
1773 }
1774 return ret;
1775 }
1776
1777 /***********************************************************************
1778 * HTTP_DealWithProxy
1779 */
1780 static BOOL HTTP_DealWithProxy(appinfo_t *hIC, http_session_t *session, http_request_t *request)
1781 {
1782 static const WCHAR protoHttp[] = { 'h','t','t','p',0 };
1783 static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/',0 };
1784 static WCHAR szNul[] = { 0 };
1785 URL_COMPONENTSW UrlComponents = { sizeof(UrlComponents) };
1786 server_t *new_server = NULL;
1787 WCHAR *proxy;
1788
1789 proxy = INTERNET_FindProxyForProtocol(hIC->proxy, protoHttp);
1790 if(!proxy)
1791 return FALSE;
1792 if(CSTR_EQUAL != CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1793 proxy, strlenW(szHttp), szHttp, strlenW(szHttp))) {
1794 WCHAR *proxy_url = heap_alloc(strlenW(proxy)*sizeof(WCHAR) + sizeof(szHttp));
1795 if(!proxy_url) {
1796 heap_free(proxy);
1797 return FALSE;
1798 }
1799 strcpyW(proxy_url, szHttp);
1800 strcatW(proxy_url, proxy);
1801 heap_free(proxy);
1802 proxy = proxy_url;
1803 }
1804
1805 UrlComponents.dwHostNameLength = 1;
1806 if(InternetCrackUrlW(proxy, 0, 0, &UrlComponents) && UrlComponents.dwHostNameLength) {
1807 if( !request->path )
1808 request->path = szNul;
1809
1810 new_server = get_server(substr(UrlComponents.lpszHostName, UrlComponents.dwHostNameLength),
1811 UrlComponents.nPort, UrlComponents.nScheme == INTERNET_SCHEME_HTTPS, TRUE);
1812 }
1813 heap_free(proxy);
1814 if(!new_server)
1815 return FALSE;
1816
1817 request->proxy = new_server;
1818
1819 TRACE("proxy server=%s port=%d\n", debugstr_w(new_server->name), new_server->port);
1820 return TRUE;
1821 }
1822
1823 static DWORD HTTP_ResolveName(http_request_t *request)
1824 {
1825 server_t *server = request->proxy ? request->proxy : request->server;
1826 int addr_len;
1827
1828 if(server->addr_len)
1829 return ERROR_SUCCESS;
1830
1831 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
1832 INTERNET_STATUS_RESOLVING_NAME,
1833 server->name,
1834 (strlenW(server->name)+1) * sizeof(WCHAR));
1835
1836 addr_len = sizeof(server->addr);
1837 if (!GetAddress(server->name, server->port, (SOCKADDR*)&server->addr, &addr_len, server->addr_str))
1838 return ERROR_INTERNET_NAME_NOT_RESOLVED;
1839
1840 server->addr_len = addr_len;
1841 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
1842 INTERNET_STATUS_NAME_RESOLVED,
1843 server->addr_str, strlen(server->addr_str)+1);
1844
1845 TRACE("resolved %s to %s\n", debugstr_w(server->name), server->addr_str);
1846 return ERROR_SUCCESS;
1847 }
1848
1849 static WCHAR *compose_request_url(http_request_t *req)
1850 {
1851 static const WCHAR http[] = { 'h','t','t','p',':','/','/',0 };
1852 static const WCHAR https[] = { 'h','t','t','p','s',':','/','/',0 };
1853 const WCHAR *host, *scheme;
1854 WCHAR *buf, *ptr;
1855 size_t len;
1856
1857 host = req->server->canon_host_port;
1858
1859 if (req->server->is_https)
1860 scheme = https;
1861 else
1862 scheme = http;
1863
1864 len = strlenW(scheme) + strlenW(host) + (req->path[0] != '/' ? 1 : 0) + strlenW(req->path);
1865 ptr = buf = heap_alloc((len+1) * sizeof(WCHAR));
1866 if(buf) {
1867 strcpyW(ptr, scheme);
1868 ptr += strlenW(ptr);
1869
1870 strcpyW(ptr, host);
1871 ptr += strlenW(ptr);
1872
1873 if(req->path[0] != '/')
1874 *ptr++ = '/';
1875
1876 strcpyW(ptr, req->path);
1877 ptr += strlenW(ptr);
1878 *ptr = 0;
1879 }
1880
1881 return buf;
1882 }
1883
1884
1885 /***********************************************************************
1886 * HTTPREQ_Destroy (internal)
1887 *
1888 * Deallocate request handle
1889 *
1890 */
1891 static void HTTPREQ_Destroy(object_header_t *hdr)
1892 {
1893 http_request_t *request = (http_request_t*) hdr;
1894 DWORD i;
1895
1896 TRACE("\n");
1897
1898 if(request->hCacheFile)
1899 CloseHandle(request->hCacheFile);
1900 if(request->req_file)
1901 req_file_release(request->req_file);
1902
1903 request->headers_section.DebugInfo->Spare[0] = 0;
1904 DeleteCriticalSection( &request->headers_section );
1905 request->read_section.DebugInfo->Spare[0] = 0;
1906 DeleteCriticalSection( &request->read_section );
1907 WININET_Release(&request->session->hdr);
1908
1909 destroy_authinfo(request->authInfo);
1910 destroy_authinfo(request->proxyAuthInfo);
1911
1912 if(request->server)
1913 server_release(request->server);
1914 if(request->proxy)
1915 server_release(request->proxy);
1916
1917 heap_free(request->path);
1918 heap_free(request->verb);
1919 heap_free(request->version);
1920 heap_free(request->statusText);
1921
1922 for (i = 0; i < request->nCustHeaders; i++)
1923 {
1924 heap_free(request->custHeaders[i].lpszField);
1925 heap_free(request->custHeaders[i].lpszValue);
1926 }
1927 destroy_data_stream(request->data_stream);
1928 heap_free(request->custHeaders);
1929 }
1930
1931 static void http_release_netconn(http_request_t *req, BOOL reuse)
1932 {
1933 TRACE("%p %p %x\n",req, req->netconn, reuse);
1934
1935 if(!is_valid_netconn(req->netconn))
1936 return;
1937
1938 if(reuse && req->netconn->keep_alive) {
1939 BOOL run_collector;
1940
1941 EnterCriticalSection(&connection_pool_cs);
1942
1943 list_add_head(&req->netconn->server->conn_pool, &req->netconn->pool_entry);
1944 req->netconn->keep_until = GetTickCount64() + COLLECT_TIME;
1945 req->netconn = NULL;
1946
1947 run_collector = !collector_running;
1948 collector_running = TRUE;
1949
1950 LeaveCriticalSection(&connection_pool_cs);
1951
1952 if(run_collector) {
1953 HANDLE thread = NULL;
1954 HMODULE module;
1955
1956 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const WCHAR*)WININET_hModule, &module);
1957 if(module)
1958 thread = CreateThread(NULL, 0, collect_connections_proc, NULL, 0, NULL);
1959 if(!thread) {
1960 EnterCriticalSection(&connection_pool_cs);
1961 collector_running = FALSE;
1962 LeaveCriticalSection(&connection_pool_cs);
1963
1964 if(module)
1965 FreeLibrary(module);
1966 }
1967 else
1968 CloseHandle(thread);
1969 }
1970 return;
1971 }
1972
1973 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
1974 INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
1975
1976 close_netconn(req->netconn);
1977
1978 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
1979 INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
1980 }
1981
1982 static BOOL HTTP_KeepAlive(http_request_t *request)
1983 {
1984 WCHAR szVersion[10];
1985 WCHAR szConnectionResponse[20];
1986 DWORD dwBufferSize = sizeof(szVersion);
1987 BOOL keepalive = FALSE;
1988
1989 /* as per RFC 2068, S8.1.2.1, if the client is HTTP/1.1 then assume that
1990 * the connection is keep-alive by default */
1991 if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_VERSION, szVersion, &dwBufferSize, NULL) == ERROR_SUCCESS
1992 && !strcmpiW(szVersion, g_szHttp1_1))
1993 {
1994 keepalive = TRUE;
1995 }
1996
1997 dwBufferSize = sizeof(szConnectionResponse);
1998 if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_PROXY_CONNECTION, szConnectionResponse, &dwBufferSize, NULL) == ERROR_SUCCESS
1999 || HTTP_HttpQueryInfoW(request, HTTP_QUERY_CONNECTION, szConnectionResponse, &dwBufferSize, NULL) == ERROR_SUCCESS)
2000 {
2001 keepalive = !strcmpiW(szConnectionResponse, szKeepAlive);
2002 }
2003
2004 return keepalive;
2005 }
2006
2007 static void HTTPREQ_CloseConnection(object_header_t *hdr)
2008 {
2009 http_request_t *req = (http_request_t*)hdr;
2010
2011 http_release_netconn(req, drain_content(req, FALSE) == ERROR_SUCCESS);
2012 }
2013
2014 static DWORD str_to_buffer(const WCHAR *str, void *buffer, DWORD *size, BOOL unicode)
2015 {
2016 int len;
2017 if (unicode)
2018 {
2019 WCHAR *buf = buffer;
2020
2021 if (str) len = strlenW(str);
2022 else len = 0;
2023 if (*size < (len + 1) * sizeof(WCHAR))
2024 {
2025 *size = (len + 1) * sizeof(WCHAR);
2026 return ERROR_INSUFFICIENT_BUFFER;
2027 }
2028 if (str) strcpyW(buf, str);
2029 else buf[0] = 0;
2030
2031 *size = len;
2032 return ERROR_SUCCESS;
2033 }
2034 else
2035 {
2036 char *buf = buffer;
2037
2038 if (str) len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
2039 else len = 1;
2040 if (*size < len)
2041 {
2042 *size = len;
2043 return ERROR_INSUFFICIENT_BUFFER;
2044 }
2045 if (str) WideCharToMultiByte(CP_ACP, 0, str, -1, buf, *size, NULL, NULL);
2046 else buf[0] = 0;
2047
2048 *size = len - 1;
2049 return ERROR_SUCCESS;
2050 }
2051 }
2052
2053 static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
2054 {
2055 http_request_t *req = (http_request_t*)hdr;
2056
2057 switch(option) {
2058 case INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO:
2059 {
2060 INTERNET_DIAGNOSTIC_SOCKET_INFO *info = buffer;
2061
2062 FIXME("INTERNET_DIAGNOSTIC_SOCKET_INFO stub\n");
2063
2064 if (*size < sizeof(INTERNET_DIAGNOSTIC_SOCKET_INFO))
2065 return ERROR_INSUFFICIENT_BUFFER;
2066 *size = sizeof(INTERNET_DIAGNOSTIC_SOCKET_INFO);
2067 /* FIXME: can't get a SOCKET from our connection since we don't use
2068 * winsock
2069 */
2070 info->Socket = 0;
2071 /* FIXME: get source port from req->netConnection */
2072 info->SourcePort = 0;
2073 info->DestPort = req->server->port;
2074 info->Flags = 0;
2075 if (HTTP_KeepAlive(req))
2076 info->Flags |= IDSI_FLAG_KEEP_ALIVE;
2077 if (req->proxy)
2078 info->Flags |= IDSI_FLAG_PROXY;
2079 if (is_valid_netconn(req->netconn) && req->netconn->secure)
2080 info->Flags |= IDSI_FLAG_SECURE;
2081
2082 return ERROR_SUCCESS;
2083 }
2084
2085 case 98:
2086 TRACE("Queried undocumented option 98, forwarding to INTERNET_OPTION_SECURITY_FLAGS\n");
2087 /* fall through */
2088 case INTERNET_OPTION_SECURITY_FLAGS:
2089 {
2090 DWORD flags;
2091
2092 if (*size < sizeof(ULONG))
2093 return ERROR_INSUFFICIENT_BUFFER;
2094
2095 *size = sizeof(DWORD);
2096 flags = is_valid_netconn(req->netconn) ? req->netconn->security_flags : req->security_flags | req->server->security_flags;
2097 *(DWORD *)buffer = flags;
2098
2099 TRACE("INTERNET_OPTION_SECURITY_FLAGS %x\n", flags);
2100 return ERROR_SUCCESS;
2101 }
2102
2103 case INTERNET_OPTION_HANDLE_TYPE:
2104 TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
2105
2106 if (*size < sizeof(ULONG))
2107 return ERROR_INSUFFICIENT_BUFFER;
2108
2109 *size = sizeof(DWORD);
2110 *(DWORD*)buffer = INTERNET_HANDLE_TYPE_HTTP_REQUEST;
2111 return ERROR_SUCCESS;
2112
2113 case INTERNET_OPTION_URL: {
2114 WCHAR *url;
2115 DWORD res;
2116
2117 TRACE("INTERNET_OPTION_URL\n");
2118
2119 url = compose_request_url(req);
2120 if(!url)
2121 return ERROR_OUTOFMEMORY;
2122
2123 res = str_to_buffer(url, buffer, size, unicode);
2124 heap_free(url);
2125 return res;
2126 }
2127 case INTERNET_OPTION_USER_AGENT:
2128 return str_to_buffer(req->session->appInfo->agent, buffer, size, unicode);
2129 case INTERNET_OPTION_USERNAME:
2130 return str_to_buffer(req->session->userName, buffer, size, unicode);
2131 case INTERNET_OPTION_PASSWORD:
2132 return str_to_buffer(req->session->password, buffer, size, unicode);
2133 case INTERNET_OPTION_PROXY_USERNAME:
2134 return str_to_buffer(req->session->appInfo->proxyUsername, buffer, size, unicode);
2135 case INTERNET_OPTION_PROXY_PASSWORD:
2136 return str_to_buffer(req->session->appInfo->proxyPassword, buffer, size, unicode);
2137
2138 case INTERNET_OPTION_CACHE_TIMESTAMPS: {
2139 INTERNET_CACHE_ENTRY_INFOW *info;
2140 INTERNET_CACHE_TIMESTAMPS *ts = buffer;
2141 DWORD nbytes, error;
2142 BOOL ret;
2143
2144 TRACE("INTERNET_OPTION_CACHE_TIMESTAMPS\n");
2145
2146 if(!req->req_file)
2147 return ERROR_FILE_NOT_FOUND;
2148
2149 if (*size < sizeof(*ts))
2150 {
2151 *size = sizeof(*ts);
2152 return ERROR_INSUFFICIENT_BUFFER;
2153 }
2154
2155 nbytes = 0;
2156 ret = GetUrlCacheEntryInfoW(req->req_file->url, NULL, &nbytes);
2157 error = GetLastError();
2158 if (!ret && error == ERROR_INSUFFICIENT_BUFFER)
2159 {
2160 if (!(info = heap_alloc(nbytes)))
2161 return ERROR_OUTOFMEMORY;
2162
2163 GetUrlCacheEntryInfoW(req->req_file->url, info, &nbytes);
2164
2165 ts->ftExpires = info->ExpireTime;
2166 ts->ftLastModified = info->LastModifiedTime;
2167
2168 heap_free(info);
2169 *size = sizeof(*ts);
2170 return ERROR_SUCCESS;
2171 }
2172 return error;
2173 }
2174
2175 case INTERNET_OPTION_DATAFILE_NAME: {
2176 DWORD req_size;
2177
2178 TRACE("INTERNET_OPTION_DATAFILE_NAME\n");
2179
2180 if(!req->req_file) {
2181 *size = 0;
2182 return ERROR_INTERNET_ITEM_NOT_FOUND;
2183 }
2184
2185 if(unicode) {
2186 req_size = (lstrlenW(req->req_file->file_name)+1) * sizeof(WCHAR);
2187 if(*size < req_size)
2188 return ERROR_INSUFFICIENT_BUFFER;
2189
2190 *size = req_size;
2191 memcpy(buffer, req->req_file->file_name, *size);
2192 return ERROR_SUCCESS;
2193 }else {
2194 req_size = WideCharToMultiByte(CP_ACP, 0, req->req_file->file_name, -1, NULL, 0, NULL, NULL);
2195 if (req_size > *size)
2196 return ERROR_INSUFFICIENT_BUFFER;
2197
2198 *size = WideCharToMultiByte(CP_ACP, 0, req->req_file->file_name,
2199 -1, buffer, *size, NULL, NULL);
2200 return ERROR_SUCCESS;
2201 }
2202 }
2203
2204 case INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT: {
2205 PCCERT_CONTEXT context;
2206
2207 if(!req->netconn)
2208 return ERROR_INTERNET_INVALID_OPERATION;
2209
2210 if(*size < sizeof(INTERNET_CERTIFICATE_INFOA)) {
2211 *size = sizeof(INTERNET_CERTIFICATE_INFOA);
2212 return ERROR_INSUFFICIENT_BUFFER;
2213 }
2214
2215 context = (PCCERT_CONTEXT)NETCON_GetCert(req->netconn);
2216 if(context) {
2217 INTERNET_CERTIFICATE_INFOA *info = (INTERNET_CERTIFICATE_INFOA*)buffer;
2218 DWORD len;
2219
2220 memset(info, 0, sizeof(*info));
2221 info->ftExpiry = context->pCertInfo->NotAfter;
2222 info->ftStart = context->pCertInfo->NotBefore;
2223 len = CertNameToStrA(context->dwCertEncodingType,
2224 &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG, NULL, 0);
2225 info->lpszSubjectInfo = LocalAlloc(0, len);
2226 if(info->lpszSubjectInfo)
2227 CertNameToStrA(context->dwCertEncodingType,
2228 &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG,
2229 info->lpszSubjectInfo, len);
2230 len = CertNameToStrA(context->dwCertEncodingType,
2231 &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG, NULL, 0);
2232 info->lpszIssuerInfo = LocalAlloc(0, len);
2233 if(info->lpszIssuerInfo)
2234 CertNameToStrA(context->dwCertEncodingType,
2235 &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR|CERT_NAME_STR_CRLF_FLAG,
2236 info->lpszIssuerInfo, len);
2237 info->dwKeySize = NETCON_GetCipherStrength(req->netconn);
2238 CertFreeCertificateContext(context);
2239 return ERROR_SUCCESS;
2240 }
2241 return ERROR_NOT_SUPPORTED;
2242 }
2243 case INTERNET_OPTION_CONNECT_TIMEOUT:
2244 if (*size < sizeof(DWORD))
2245 return ERROR_INSUFFICIENT_BUFFER;
2246
2247 *size = sizeof(DWORD);
2248 *(DWORD *)buffer = req->connect_timeout;
2249 return ERROR_SUCCESS;
2250 case INTERNET_OPTION_REQUEST_FLAGS: {
2251 DWORD flags = 0;
2252
2253 if (*size < sizeof(DWORD))
2254 return ERROR_INSUFFICIENT_BUFFER;
2255
2256 /* FIXME: Add support for:
2257 * INTERNET_REQFLAG_FROM_CACHE
2258 * INTERNET_REQFLAG_CACHE_WRITE_DISABLED
2259 */
2260
2261 if(req->proxy)
2262 flags |= INTERNET_REQFLAG_VIA_PROXY;
2263 if(!req->status_code)
2264 flags |= INTERNET_REQFLAG_NO_HEADERS;
2265
2266 TRACE("INTERNET_OPTION_REQUEST_FLAGS returning %x\n", flags);
2267
2268 *size = sizeof(DWORD);
2269 *(DWORD*)buffer = flags;
2270 return ERROR_SUCCESS;
2271 }
2272 }
2273
2274 return INET_QueryOption(hdr, option, buffer, size, unicode);
2275 }
2276
2277 static DWORD HTTPREQ_SetOption(object_header_t *hdr, DWORD option, void *buffer, DWORD size)
2278 {
2279 http_request_t *req = (http_request_t*)hdr;
2280
2281 switch(option) {
2282 case 99: /* Undocumented, seems to be INTERNET_OPTION_SECURITY_FLAGS with argument validation */
2283 TRACE("Undocumented option 99\n");
2284
2285 if (!buffer || size != sizeof(DWORD))
2286 return ERROR_INVALID_PARAMETER;
2287 if(*(DWORD*)buffer & ~SECURITY_SET_MASK)
2288 return ERROR_INTERNET_OPTION_NOT_SETTABLE;
2289
2290 /* fall through */
2291 case INTERNET_OPTION_SECURITY_FLAGS:
2292 {
2293 DWORD flags;
2294
2295 if (!buffer || size != sizeof(DWORD))
2296 return ERROR_INVALID_PARAMETER;
2297 flags = *(DWORD *)buffer;
2298 TRACE("INTERNET_OPTION_SECURITY_FLAGS %08x\n", flags);
2299 flags &= SECURITY_SET_MASK;
2300 req->security_flags |= flags;
2301 if(is_valid_netconn(req->netconn))
2302 req->netconn->security_flags |= flags;
2303 return ERROR_SUCCESS;
2304 }
2305 case INTERNET_OPTION_CONNECT_TIMEOUT:
2306 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
2307 req->connect_timeout = *(DWORD *)buffer;
2308 return ERROR_SUCCESS;
2309
2310 case INTERNET_OPTION_SEND_TIMEOUT:
2311 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
2312 req->send_timeout = *(DWORD *)buffer;
2313 return ERROR_SUCCESS;
2314
2315 case INTERNET_OPTION_RECEIVE_TIMEOUT:
2316 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
2317 req->receive_timeout = *(DWORD *)buffer;
2318 return ERROR_SUCCESS;
2319
2320 case INTERNET_OPTION_USERNAME:
2321 heap_free(req->session->userName);
2322 if (!(req->session->userName = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
2323 return ERROR_SUCCESS;
2324
2325 case INTERNET_OPTION_PASSWORD:
2326 heap_free(req->session->password);
2327 if (!(req->session->password = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
2328 return ERROR_SUCCESS;
2329
2330 case INTERNET_OPTION_PROXY_USERNAME:
2331 heap_free(req->session->appInfo->proxyUsername);
2332 if (!(req->session->appInfo->proxyUsername = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
2333 return ERROR_SUCCESS;
2334
2335 case INTERNET_OPTION_PROXY_PASSWORD:
2336 heap_free(req->session->appInfo->proxyPassword);
2337 if (!(req->session->appInfo->proxyPassword = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
2338 return ERROR_SUCCESS;
2339
2340 case INTERNET_OPTION_HTTP_DECODING:
2341 if(size != sizeof(BOOL))
2342 return ERROR_INVALID_PARAMETER;
2343 req->decoding = *(BOOL*)buffer;
2344 return ERROR_SUCCESS;
2345 }
2346
2347 return INET_SetOption(hdr, option, buffer, size);
2348 }
2349
2350 static void commit_cache_entry(http_request_t *req)
2351 {
2352 WCHAR *header;
2353 DWORD header_len;
2354 BOOL res;
2355
2356 TRACE("%p\n", req);
2357
2358 CloseHandle(req->hCacheFile);
2359 req->hCacheFile = NULL;
2360
2361 header = build_response_header(req, TRUE);
2362 header_len = (header ? strlenW(header) : 0);
2363 res = CommitUrlCacheEntryW(req->req_file->url, req->req_file->file_name, req->expires,
2364 req->last_modified, NORMAL_CACHE_ENTRY,
2365 header, header_len, NULL, 0);
2366 if(res)
2367 req->req_file->is_committed = TRUE;
2368 else
2369 WARN("CommitUrlCacheEntry failed: %u\n", GetLastError());
2370 heap_free(header);
2371 }
2372
2373 static void create_cache_entry(http_request_t *req)
2374 {
2375 static const WCHAR no_cacheW[] = {'n','o','-','c','a','c','h','e',0};
2376 static const WCHAR no_storeW[] = {'n','o','-','s','t','o','r','e',0};
2377
2378 WCHAR file_name[MAX_PATH+1];
2379 WCHAR *url;
2380 BOOL b = TRUE;
2381
2382 /* FIXME: We should free previous cache file earlier */
2383 if(req->req_file) {
2384 req_file_release(req->req_file);
2385 req->req_file = NULL;
2386 }
2387 if(req->hCacheFile) {
2388 CloseHandle(req->hCacheFile);
2389 req->hCacheFile = NULL;
2390 }
2391
2392 if(req->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE)
2393 b = FALSE;
2394
2395 if(b) {
2396 int header_idx;
2397
2398 EnterCriticalSection( &req->headers_section );
2399
2400 header_idx = HTTP_GetCustomHeaderIndex(req, szCache_Control, 0, FALSE);
2401 if(header_idx != -1) {
2402 WCHAR *ptr;
2403
2404 for(ptr=req->custHeaders[header_idx].lpszValue; *ptr; ) {
2405 WCHAR *end;
2406
2407 while(*ptr==' ' || *ptr=='\t')
2408 ptr++;
2409
2410 end = strchrW(ptr, ',');
2411 if(!end)
2412 end = ptr + strlenW(ptr);
2413
2414 if(!strncmpiW(ptr, no_cacheW, sizeof(no_cacheW)/sizeof(*no_cacheW)-1)
2415 || !strncmpiW(ptr, no_storeW, sizeof(no_storeW)/sizeof(*no_storeW)-1)) {
2416 b = FALSE;
2417 break;
2418 }
2419
2420 ptr = end;
2421 if(*ptr == ',')
2422 ptr++;
2423 }
2424 }
2425
2426 LeaveCriticalSection( &req->headers_section );
2427 }
2428
2429 if(!b) {
2430 if(!(req->hdr.dwFlags & INTERNET_FLAG_NEED_FILE))
2431 return;
2432
2433 FIXME("INTERNET_FLAG_NEED_FILE is not supported correctly\n");
2434 }
2435
2436 url = compose_request_url(req);
2437 if(!url) {
2438 WARN("Could not get URL\n");
2439 return;
2440 }
2441
2442 b = CreateUrlCacheEntryW(url, req->contentLength == ~0u ? 0 : req->contentLength, NULL, file_name, 0);
2443 if(!b) {
2444 WARN("Could not create cache entry: %08x\n", GetLastError());
2445 return;
2446 }
2447
2448 create_req_file(file_name, &req->req_file);
2449 req->req_file->url = url;
2450
2451 req->hCacheFile = CreateFileW(file_name, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
2452 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2453 if(req->hCacheFile == INVALID_HANDLE_VALUE) {
2454 WARN("Could not create file: %u\n", GetLastError());
2455 req->hCacheFile = NULL;
2456 return;
2457 }
2458
2459 if(req->read_size) {
2460 DWORD written;
2461
2462 b = WriteFile(req->hCacheFile, req->read_buf+req->read_pos, req->read_size, &written, NULL);
2463 if(!b)
2464 FIXME("WriteFile failed: %u\n", GetLastError());
2465
2466 if(req->data_stream->vtbl->end_of_data(req->data_stream, req))
2467 commit_cache_entry(req);
2468 }
2469 }
2470
2471 /* read some more data into the read buffer (the read section must be held) */
2472 static DWORD read_more_data( http_request_t *req, int maxlen )
2473 {
2474 DWORD res;
2475 int len;
2476
2477 if (req->read_pos)
2478 {
2479 /* move existing data to the start of the buffer */
2480 if(req->read_size)
2481 memmove( req->read_buf, req->read_buf + req->read_pos, req->read_size );
2482 req->read_pos = 0;
2483 }
2484
2485 if (maxlen == -1) maxlen = sizeof(req->read_buf);
2486
2487 res = NETCON_recv( req->netconn, req->read_buf + req->read_size,
2488 maxlen - req->read_size, TRUE, &len );
2489 if(res == ERROR_SUCCESS)
2490 req->read_size += len;
2491
2492 return res;
2493 }
2494
2495 /* remove some amount of data from the read buffer (the read section must be held) */
2496 static void remove_data( http_request_t *req, int count )
2497 {
2498 if (!(req->read_size -= count)) req->read_pos = 0;
2499 else req->read_pos += count;
2500 }
2501
2502 static DWORD read_line( http_request_t *req, LPSTR buffer, DWORD *len )
2503 {
2504 int count, bytes_read, pos = 0;
2505 DWORD res;
2506
2507 EnterCriticalSection( &req->read_section );
2508 for (;;)
2509 {
2510 BYTE *eol = memchr( req->read_buf + req->read_pos, '\n', req->read_size );
2511
2512 if (eol)
2513 {
2514 count = eol - (req->read_buf + req->read_pos);
2515 bytes_read = count + 1;
2516 }
2517 else count = bytes_read = req->read_size;
2518
2519 count = min( count, *len - pos );
2520 memcpy( buffer + pos, req->read_buf + req->read_pos, count );
2521 pos += count;
2522 remove_data( req, bytes_read );
2523 if (eol) break;
2524
2525 if ((res = read_more_data( req, -1 )))
2526 {
2527 WARN( "read failed %u\n", res );
2528 LeaveCriticalSection( &req->read_section );
2529 return res;
2530 }
2531 if (!req->read_size)
2532 {
2533 *len = 0;
2534 TRACE( "returning empty string\n" );
2535 LeaveCriticalSection( &req->read_section );
2536 return ERROR_SUCCESS;
2537 }
2538 }
2539 LeaveCriticalSection( &req->read_section );
2540
2541 if (pos < *len)
2542 {
2543 if (pos && buffer[pos - 1] == '\r') pos--;
2544 *len = pos + 1;
2545 }
2546 buffer[*len - 1] = 0;
2547 TRACE( "returning %s\n", debugstr_a(buffer));
2548 return ERROR_SUCCESS;
2549 }
2550
2551 /* check if we have reached the end of the data to read (the read section must be held) */
2552 static BOOL end_of_read_data( http_request_t *req )
2553 {
2554 return !req->read_size && req->data_stream->vtbl->end_of_data(req->data_stream, req);
2555 }
2556
2557 static DWORD read_http_stream(http_request_t *req, BYTE *buf, DWORD size, DWORD *read, BOOL allow_blocking)
2558 {
2559 DWORD res;
2560
2561 res = req->data_stream->vtbl->read(req->data_stream, req, buf, size, read, allow_blocking);
2562 if(res != ERROR_SUCCESS)
2563 *read = 0;
2564 assert(*read <= size);
2565
2566 if(req->hCacheFile) {
2567 if(*read) {
2568 BOOL bres;
2569 DWORD written;
2570
2571 bres = WriteFile(req->hCacheFile, buf, *read, &written, NULL);
2572 if(!bres)
2573 FIXME("WriteFile failed: %u\n", GetLastError());
2574 }
2575
2576 if((res == ERROR_SUCCESS && !*read) || req->data_stream->vtbl->end_of_data(req->data_stream, req))
2577 commit_cache_entry(req);
2578 }
2579
2580 return res;
2581 }
2582
2583 /* fetch some more data into the read buffer (the read section must be held) */
2584 static DWORD refill_read_buffer(http_request_t *req, BOOL allow_blocking, DWORD *read_bytes)
2585 {
2586 DWORD res, read=0;
2587
2588 if(req->read_size == sizeof(req->read_buf))
2589 return ERROR_SUCCESS;
2590
2591 if(req->read_pos) {
2592 if(req->read_size)
2593 memmove(req->read_buf, req->read_buf+req->read_pos, req->read_size);
2594 req->read_pos = 0;
2595 }
2596
2597 res = read_http_stream(req, req->read_buf+req->read_size, sizeof(req->read_buf) - req->read_size,
2598 &read, allow_blocking);
2599 if(res != ERROR_SUCCESS)
2600 return res;
2601
2602 req->read_size += read;
2603
2604 TRACE("read %u bytes, read_size %u\n", read, req->read_size);
2605 if(read_bytes)
2606 *read_bytes = read;
2607 return res;
2608 }
2609
2610 static BOOL netconn_end_of_data(data_stream_t *stream, http_request_t *req)
2611 {
2612 netconn_stream_t *netconn_stream = (netconn_stream_t*)stream;
2613 return netconn_stream->content_read == netconn_stream->content_length || !is_valid_netconn(req->netconn);
2614 }
2615
2616 static DWORD netconn_read(data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size,
2617 DWORD *read, BOOL allow_blocking)
2618 {
2619 netconn_stream_t *netconn_stream = (netconn_stream_t*)stream;
2620 DWORD res = ERROR_SUCCESS;
2621 int ret = 0;
2622
2623 size = min(size, netconn_stream->content_length-netconn_stream->content_read);
2624
2625 if(size && is_valid_netconn(req->netconn)) {
2626 res = NETCON_recv(req->netconn, buf, size, allow_blocking, &ret);
2627 if(res == ERROR_SUCCESS) {
2628 if(!ret)
2629 netconn_stream->content_length = netconn_stream->content_read;
2630 netconn_stream->content_read += ret;
2631 }
2632 }
2633
2634 TRACE("res %u read %u bytes\n", res, ret);
2635 *read = ret;
2636 return res;
2637 }
2638
2639 static DWORD netconn_drain_content(data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
2640 {
2641 netconn_stream_t *netconn_stream = (netconn_stream_t*)stream;
2642 BYTE buf[1024];
2643 int len, res;
2644 size_t size;
2645
2646 if(netconn_stream->content_length == ~0u)
2647 return WSAEISCONN;
2648
2649 while(netconn_stream->content_read < netconn_stream->content_length) {
2650 size = min(sizeof(buf), netconn_stream->content_length-netconn_stream->content_read);
2651 res = NETCON_recv(req->netconn, buf, size, allow_blocking, &len);
2652 if(res)
2653 return res;
2654 if(!len)
2655 return WSAECONNABORTED;
2656
2657 netconn_stream->content_read += len;
2658 }
2659
2660 return ERROR_SUCCESS;
2661 }
2662
2663 static void netconn_destroy(data_stream_t *stream)
2664 {
2665 }
2666
2667 static const data_stream_vtbl_t netconn_stream_vtbl = {
2668 netconn_end_of_data,
2669 netconn_read,
2670 netconn_drain_content,
2671 netconn_destroy
2672 };
2673
2674 static char next_chunked_data_char(chunked_stream_t *stream)
2675 {
2676 assert(stream->buf_size);
2677
2678 stream->buf_size--;
2679 return stream->buf[stream->buf_pos++];
2680 }
2681
2682 static BOOL chunked_end_of_data(data_stream_t *stream, http_request_t *req)
2683 {
2684 chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2685 switch(chunked_stream->state) {
2686 case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
2687 case CHUNKED_STREAM_STATE_END_OF_STREAM:
2688 case CHUNKED_STREAM_STATE_ERROR:
2689 return TRUE;
2690 default:
2691 return FALSE;
2692 }
2693 }
2694
2695 static DWORD chunked_read(data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size,
2696 DWORD *read, BOOL allow_blocking)
2697 {
2698 chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2699 DWORD ret_read = 0, res = ERROR_SUCCESS;
2700 BOOL continue_read = TRUE;
2701 int read_bytes;
2702 char ch;
2703
2704 do {
2705 TRACE("state %d\n", chunked_stream->state);
2706
2707 /* Ensure that we have data in the buffer for states that need it. */
2708 if(!chunked_stream->buf_size) {
2709 BOOL blocking_read = allow_blocking;
2710
2711 switch(chunked_stream->state) {
2712 case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
2713 case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
2714 /* never allow blocking after 0 chunk size */
2715 if(!chunked_stream->chunk_size)
2716 blocking_read = FALSE;
2717 /* fall through */
2718 case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
2719 case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
2720 chunked_stream->buf_pos = 0;
2721 res = NETCON_recv(req->netconn, chunked_stream->buf, sizeof(chunked_stream->buf), blocking_read, &read_bytes);
2722 if(res == ERROR_SUCCESS && read_bytes) {
2723 chunked_stream->buf_size += read_bytes;
2724 }else if(res == WSAEWOULDBLOCK) {
2725 if(ret_read || allow_blocking)
2726 res = ERROR_SUCCESS;
2727 continue_read = FALSE;
2728 continue;
2729 }else {
2730 chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
2731 }
2732 break;
2733 default:
2734 break;
2735 }
2736 }
2737
2738 switch(chunked_stream->state) {
2739 case CHUNKED_STREAM_STATE_READING_CHUNK_SIZE:
2740 ch = next_chunked_data_char(chunked_stream);
2741
2742 if(ch >= '0' && ch <= '9') {
2743 chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - '0';
2744 }else if(ch >= 'a' && ch <= 'f') {
2745 chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - 'a' + 10;
2746 }else if (ch >= 'A' && ch <= 'F') {
2747 chunked_stream->chunk_size = chunked_stream->chunk_size * 16 + ch - 'A' + 10;
2748 }else if (ch == ';' || ch == '\r' || ch == '\n') {
2749 TRACE("reading %u byte chunk\n", chunked_stream->chunk_size);
2750 chunked_stream->buf_size++;
2751 chunked_stream->buf_pos--;
2752 if(req->contentLength == ~0u) req->contentLength = chunked_stream->chunk_size;
2753 else req->contentLength += chunked_stream->chunk_size;
2754 chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE;
2755 }
2756 break;
2757
2758 case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_SIZE:
2759 ch = next_chunked_data_char(chunked_stream);
2760 if(ch == '\n')
2761 chunked_stream->state = chunked_stream->chunk_size
2762 ? CHUNKED_STREAM_STATE_READING_CHUNK
2763 : CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END;
2764 else if(ch != '\r')
2765 WARN("unexpected char '%c'\n", ch);
2766 break;
2767
2768 case CHUNKED_STREAM_STATE_READING_CHUNK:
2769 assert(chunked_stream->chunk_size);
2770 if(!size) {
2771 continue_read = FALSE;
2772 break;
2773 }
2774 read_bytes = min(size, chunked_stream->chunk_size);
2775
2776 if(chunked_stream->buf_size) {
2777 if(read_bytes > chunked_stream->buf_size)
2778 read_bytes = chunked_stream->buf_size;
2779
2780 memcpy(buf+ret_read, chunked_stream->buf+chunked_stream->buf_pos, read_bytes);
2781 chunked_stream->buf_pos += read_bytes;
2782 chunked_stream->buf_size -= read_bytes;
2783 }else {
2784 res = NETCON_recv(req->netconn, (char*)buf+ret_read, read_bytes,
2785 allow_blocking, (int*)&read_bytes);
2786 if(res != ERROR_SUCCESS) {
2787 continue_read = FALSE;
2788 break;
2789 }
2790
2791 if(!read_bytes) {
2792 chunked_stream->state = CHUNKED_STREAM_STATE_ERROR;
2793 continue;
2794 }
2795 }
2796
2797 chunked_stream->chunk_size -= read_bytes;
2798 size -= read_bytes;
2799 ret_read += read_bytes;
2800 if(!chunked_stream->chunk_size)
2801 chunked_stream->state = CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA;
2802 allow_blocking = FALSE;
2803 break;
2804
2805 case CHUNKED_STREAM_STATE_DISCARD_EOL_AFTER_DATA:
2806 ch = next_chunked_data_char(chunked_stream);
2807 if(ch == '\n')
2808 chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK_SIZE;
2809 else if(ch != '\r')
2810 WARN("unexpected char '%c'\n", ch);
2811 break;
2812
2813 case CHUNKED_STREAM_STATE_DISCARD_EOL_AT_END:
2814 ch = next_chunked_data_char(chunked_stream);
2815 if(ch == '\n')
2816 chunked_stream->state = CHUNKED_STREAM_STATE_END_OF_STREAM;
2817 else if(ch != '\r')
2818 WARN("unexpected char '%c'\n", ch);
2819 break;
2820
2821 case CHUNKED_STREAM_STATE_END_OF_STREAM:
2822 case CHUNKED_STREAM_STATE_ERROR:
2823 continue_read = FALSE;
2824 break;
2825 }
2826 } while(continue_read);
2827
2828 if(ret_read)
2829 res = ERROR_SUCCESS;
2830 if(res != ERROR_SUCCESS)
2831 return res;
2832
2833 TRACE("read %d bytes\n", ret_read);
2834 *read = ret_read;
2835 return ERROR_SUCCESS;
2836 }
2837
2838 static DWORD chunked_drain_content(data_stream_t *stream, http_request_t *req, BOOL allow_blocking)
2839 {
2840 chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2841 BYTE buf[1024];
2842 DWORD size, res;
2843
2844 while(chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM
2845 && chunked_stream->state != CHUNKED_STREAM_STATE_ERROR) {
2846 res = chunked_read(stream, req, buf, sizeof(buf), &size, allow_blocking);
2847 if(res != ERROR_SUCCESS)
2848 return res;
2849 }
2850
2851 if(chunked_stream->state != CHUNKED_STREAM_STATE_END_OF_STREAM)
2852 return ERROR_NO_DATA;
2853 return ERROR_SUCCESS;
2854 }
2855
2856 static void chunked_destroy(data_stream_t *stream)
2857 {
2858 chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2859 heap_free(chunked_stream);
2860 }
2861
2862 static const data_stream_vtbl_t chunked_stream_vtbl = {
2863 chunked_end_of_data,
2864 chunked_read,
2865 chunked_drain_content,
2866 chunked_destroy
2867 };
2868
2869 /* set the request content length based on the headers */
2870 static DWORD set_content_length(http_request_t *request)
2871 {
2872 static const WCHAR szChunked[] = {'c','h','u','n','k','e','d',0};
2873 static const WCHAR headW[] = {'H','E','A','D',0};
2874 WCHAR encoding[20];
2875 DWORD size;
2876
2877 if(request->status_code == HTTP_STATUS_NO_CONTENT || !strcmpW(request->verb, headW)) {
2878 request->contentLength = request->netconn_stream.content_length = 0;
2879 return ERROR_SUCCESS;
2880 }
2881
2882 size = sizeof(request->contentLength);
2883 if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH,
2884 &request->contentLength, &size, NULL) != ERROR_SUCCESS)
2885 request->contentLength = ~0u;
2886 request->netconn_stream.content_length = request->contentLength;
2887 request->netconn_stream.content_read = request->read_size;
2888
2889 size = sizeof(encoding);
2890 if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_TRANSFER_ENCODING, encoding, &size, NULL) == ERROR_SUCCESS &&
2891 !strcmpiW(encoding, szChunked))
2892 {
2893 chunked_stream_t *chunked_stream;
2894
2895 chunked_stream = heap_alloc(sizeof(*chunked_stream));
2896 if(!chunked_stream)
2897 return ERROR_OUTOFMEMORY;
2898
2899 chunked_stream->data_stream.vtbl = &chunked_stream_vtbl;
2900 chunked_stream->buf_size = chunked_stream->buf_pos = 0;
2901 chunked_stream->chunk_size = 0;
2902 chunked_stream->state = CHUNKED_STREAM_STATE_READING_CHUNK_SIZE;
2903
2904 if(request->read_size) {
2905 memcpy(chunked_stream->buf, request->read_buf+request->read_pos, request->read_size);
2906 chunked_stream->buf_size = request->read_size;
2907 request->read_size = request->read_pos = 0;
2908 }
2909
2910 request->data_stream = &chunked_stream->data_stream;
2911 request->contentLength = ~0u;
2912 }
2913
2914 if(request->decoding) {
2915 int encoding_idx;
2916
2917 static const WCHAR deflateW[] = {'d','e','f','l','a','t','e',0};
2918 static const WCHAR gzipW[] = {'g','z','i','p',0};
2919
2920 EnterCriticalSection( &request->headers_section );
2921
2922 encoding_idx = HTTP_GetCustomHeaderIndex(request, szContent_Encoding, 0, FALSE);
2923 if(encoding_idx != -1) {
2924 if(!strcmpiW(request->custHeaders[encoding_idx].lpszValue, gzipW)) {
2925 HTTP_DeleteCustomHeader(request, encoding_idx);
2926 LeaveCriticalSection( &request->headers_section );
2927 return init_gzip_stream(request, TRUE);
2928 }
2929 if(!strcmpiW(request->custHeaders[encoding_idx].lpszValue, deflateW)) {
2930 HTTP_DeleteCustomHeader(request, encoding_idx);
2931 LeaveCriticalSection( &request->headers_section );
2932 return init_gzip_stream(request, FALSE);
2933 }
2934 }
2935
2936 LeaveCriticalSection( &request->headers_section );
2937 }
2938
2939 return ERROR_SUCCESS;
2940 }
2941
2942 static void send_request_complete(http_request_t *req, DWORD_PTR result, DWORD error)
2943 {
2944 INTERNET_ASYNC_RESULT iar;
2945
2946 iar.dwResult = result;
2947 iar.dwError = error;
2948
2949 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE, &iar,
2950 sizeof(INTERNET_ASYNC_RESULT));
2951 }
2952
2953 static void HTTP_ReceiveRequestData(http_request_t *req)
2954 {
2955 DWORD res, read = 0;
2956
2957 TRACE("%p\n", req);
2958
2959 EnterCriticalSection( &req->read_section );
2960
2961 res = refill_read_buffer(req, FALSE, &read);
2962 if(res == ERROR_SUCCESS)
2963 read += req->read_size;
2964
2965 LeaveCriticalSection( &req->read_section );
2966
2967 if(res != WSAEWOULDBLOCK && (res != ERROR_SUCCESS || !read)) {
2968 WARN("res %u read %u, closing connection\n", res, read);
2969 http_release_netconn(req, FALSE);
2970 }
2971
2972 if(res != ERROR_SUCCESS && res != WSAEWOULDBLOCK) {
2973 send_request_complete(req, 0, res);
2974 return;
2975 }
2976
2977 send_request_complete(req, req->session->hdr.dwInternalFlags & INET_OPENURL ? (DWORD_PTR)req->hdr.hInternet : 1, 0);
2978 }
2979
2980 /* read data from the http connection (the read section must be held) */
2981 static DWORD HTTPREQ_Read(http_request_t *req, void *buffer, DWORD size, DWORD *read, BOOL allow_blocking)
2982 {
2983 DWORD current_read = 0, ret_read = 0;
2984 DWORD res = ERROR_SUCCESS;
2985
2986 EnterCriticalSection( &req->read_section );
2987
2988 if(req->read_size) {
2989 ret_read = min(size, req->read_size);
2990 memcpy(buffer, req->read_buf+req->read_pos, ret_read);
2991 req->read_size -= ret_read;
2992 req->read_pos += ret_read;
2993 allow_blocking = FALSE;
2994 }
2995
2996 if(ret_read < size) {
2997 res = read_http_stream(req, (BYTE*)buffer+ret_read, size-ret_read, &current_read, allow_blocking);
2998 if(res == ERROR_SUCCESS)
2999 ret_read += current_read;
3000 else if(res == WSAEWOULDBLOCK && ret_read)
3001 res = ERROR_SUCCESS;
3002 }
3003
3004 LeaveCriticalSection( &req->read_section );
3005
3006 *read = ret_read;
3007 TRACE( "retrieved %u bytes (res %u)\n", ret_read, res );
3008
3009 if(res != WSAEWOULDBLOCK) {
3010 if(res != ERROR_SUCCESS)
3011 http_release_netconn(req, FALSE);
3012 else if(!ret_read && drain_content(req, FALSE) == ERROR_SUCCESS)
3013 http_release_netconn(req, TRUE);
3014 }
3015
3016 return res;
3017 }
3018
3019 static DWORD drain_content(http_request_t *req, BOOL blocking)
3020 {
3021 DWORD res;
3022
3023 TRACE("%p\n", req->netconn);
3024
3025 if(!is_valid_netconn(req->netconn))
3026 return ERROR_NO_DATA;
3027
3028 if(!strcmpW(req->verb, szHEAD))
3029 return ERROR_SUCCESS;
3030
3031 EnterCriticalSection( &req->read_section );
3032 res = req->data_stream->vtbl->drain_content(req->data_stream, req, blocking);
3033 LeaveCriticalSection( &req->read_section );
3034 return res;
3035 }
3036
3037 typedef struct {
3038 task_header_t hdr;
3039 void *buf;
3040 DWORD size;
3041 DWORD read_pos;
3042 DWORD *ret_read;
3043 } read_file_task_t;
3044
3045 static void async_read_file_proc(task_header_t *hdr)
3046 {
3047 read_file_task_t *task = (read_file_task_t*)hdr;
3048 http_request_t *req = (http_request_t*)task->hdr.hdr;
3049 DWORD res = ERROR_SUCCESS, read = task->read_pos, complete_arg = 0;
3050
3051 TRACE("req %p buf %p size %u read_pos %u ret_read %p\n", req, task->buf, task->size, task->read_pos, task->ret_read);
3052
3053 if(task->buf) {
3054 DWORD read_bytes;
3055 while (read < task->size) {
3056 res = HTTPREQ_Read(req, (char*)task->buf + read, task->size - read, &read_bytes, TRUE);
3057 if (res != ERROR_SUCCESS || !read_bytes)
3058 break;
3059 read += read_bytes;
3060 }
3061 }else {
3062 EnterCriticalSection(&req->read_section);
3063 res = refill_read_buffer(req, TRUE, &read);
3064 LeaveCriticalSection(&req->read_section);
3065
3066 if(task->ret_read)
3067 complete_arg = read; /* QueryDataAvailable reports read bytes in request complete notification */
3068 if(res != ERROR_SUCCESS || !read)
3069 http_release_netconn(req, drain_content(req, FALSE) == ERROR_SUCCESS);
3070 }
3071
3072 TRACE("res %u read %u\n", res, read);
3073
3074 if(task->ret_read)
3075 *task->ret_read = read;
3076
3077 /* FIXME: We should report bytes transferred before decoding content. */
3078 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED, &read, sizeof(read));
3079
3080 if(res != ERROR_SUCCESS)
3081 complete_arg = res;
3082 send_request_complete(req, res == ERROR_SUCCESS, complete_arg);
3083 }
3084
3085 static DWORD async_read(http_request_t *req, void *buf, DWORD size, DWORD read_pos, DWORD *ret_read)
3086 {
3087 read_file_task_t *task;
3088
3089 task = alloc_async_task(&req->hdr, async_read_file_proc, sizeof(*task));
3090 if(!task)
3091 return ERROR_OUTOFMEMORY;
3092
3093 task->buf = buf;
3094 task->size = size;
3095 task->read_pos = read_pos;
3096 task->ret_read = ret_read;
3097
3098 INTERNET_AsyncCall(&task->hdr);
3099 return ERROR_IO_PENDING;
3100 }
3101
3102 static DWORD HTTPREQ_ReadFile(object_header_t *hdr, void *buf, DWORD size, DWORD *ret_read,
3103 DWORD flags, DWORD_PTR context)
3104 {
3105 http_request_t *req = (http_request_t*)hdr;
3106 DWORD res = ERROR_SUCCESS, read = 0, cread, error = ERROR_SUCCESS;
3107 BOOL allow_blocking, notify_received = FALSE;
3108
3109 TRACE("(%p %p %u %x)\n", req, buf, size, flags);
3110
3111 if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
3112 FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
3113
3114 allow_blocking = !(req->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC);
3115
3116 if(allow_blocking || TryEnterCriticalSection(&req->read_section)) {
3117 if(allow_blocking)
3118 EnterCriticalSection(&req->read_section);
3119 if(hdr->dwError == ERROR_SUCCESS)
3120 hdr->dwError = INTERNET_HANDLE_IN_USE;
3121 else if(hdr->dwError == INTERNET_HANDLE_IN_USE)
3122 hdr->dwError = ERROR_INTERNET_INTERNAL_ERROR;
3123
3124 if(req->read_size) {
3125 read = min(size, req->read_size);
3126 memcpy(buf, req->read_buf + req->read_pos, read);
3127 req->read_size -= read;
3128 req->read_pos += read;
3129 }
3130
3131 if(read < size && (!read || !(flags & IRF_NO_WAIT)) && !end_of_read_data(req)) {
3132 LeaveCriticalSection(&req->read_section);
3133 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
3134 EnterCriticalSection( &req->read_section );
3135 notify_received = TRUE;
3136
3137 while(read < size) {
3138 res = HTTPREQ_Read(req, (char*)buf+read, size-read, &cread, allow_blocking);
3139 read += cread;
3140 if (res != ERROR_SUCCESS || !cread)
3141 break;
3142 }
3143 }
3144
3145 if(hdr->dwError == INTERNET_HANDLE_IN_USE)
3146 hdr->dwError = ERROR_SUCCESS;
3147 else
3148 error = hdr->dwError;
3149
3150 LeaveCriticalSection( &req->read_section );
3151 }else {
3152 res = WSAEWOULDBLOCK;
3153 }
3154
3155 if(res == WSAEWOULDBLOCK) {
3156 if(!(flags & IRF_NO_WAIT))
3157 return async_read(req, buf, size, read, ret_read);
3158 if(!read)
3159 return async_read(req, NULL, 0, 0, NULL);
3160 res = ERROR_SUCCESS;
3161 }
3162
3163 *ret_read = read;
3164 if (res != ERROR_SUCCESS)
3165 return res;
3166
3167 if(notify_received)
3168 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
3169 &read, sizeof(read));
3170 return error;
3171 }
3172
3173 static DWORD HTTPREQ_WriteFile(object_header_t *hdr, const void *buffer, DWORD size, DWORD *written)
3174 {
3175 DWORD res;
3176 http_request_t *request = (http_request_t*)hdr;
3177
3178 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
3179
3180 *written = 0;
3181 res = NETCON_send(request->netconn, buffer, size, 0, (LPINT)written);
3182 if (res == ERROR_SUCCESS)
3183 request->bytesWritten += *written;
3184
3185 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REQUEST_SENT, written, sizeof(DWORD));
3186 return res;
3187 }
3188
3189 static DWORD HTTPREQ_QueryDataAvailable(object_header_t *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
3190 {
3191 http_request_t *req = (http_request_t*)hdr;
3192 DWORD res = ERROR_SUCCESS, avail = 0, error = ERROR_SUCCESS;
3193 BOOL allow_blocking, notify_received = FALSE;
3194
3195 TRACE("(%p %p %x %lx)\n", req, available, flags, ctx);
3196
3197 if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
3198 FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
3199
3200 *available = 0;
3201 allow_blocking = !(req->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC);
3202
3203 if(allow_blocking || TryEnterCriticalSection(&req->read_section)) {
3204 if(allow_blocking)
3205 EnterCriticalSection(&req->read_section);
3206 if(hdr->dwError == ERROR_SUCCESS)
3207 hdr->dwError = INTERNET_HANDLE_IN_USE;
3208 else if(hdr->dwError == INTERNET_HANDLE_IN_USE)
3209 hdr->dwError = ERROR_INTERNET_INTERNAL_ERROR;
3210
3211 avail = req->read_size;
3212
3213 if(!avail && !end_of_read_data(req)) {
3214 LeaveCriticalSection(&req->read_section);
3215 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
3216 EnterCriticalSection( &req->read_section );
3217 notify_received = TRUE;
3218
3219 res = refill_read_buffer(req, allow_blocking, &avail);
3220 }
3221
3222 if(hdr->dwError == INTERNET_HANDLE_IN_USE)
3223 hdr->dwError = ERROR_SUCCESS;
3224 else
3225 error = hdr->dwError;
3226
3227 LeaveCriticalSection( &req->read_section );
3228 }else {
3229 res = WSAEWOULDBLOCK;
3230 }
3231
3232 if(res == WSAEWOULDBLOCK)
3233 return async_read(req, NULL, 0, 0, available);
3234
3235 if (res != ERROR_SUCCESS)
3236 return res;
3237
3238 *available = avail;
3239 if(notify_received)
3240 INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
3241 &avail, sizeof(avail));
3242 return error;
3243 }
3244
3245 static DWORD HTTPREQ_LockRequestFile(object_header_t *hdr, req_file_t **ret)
3246 {
3247 http_request_t *req = (http_request_t*)hdr;
3248
3249 TRACE("(%p)\n", req);
3250
3251 if(!req->req_file) {
3252 WARN("No cache file name available\n");
3253 return ERROR_FILE_NOT_FOUND;
3254 }
3255
3256 *ret = req_file_addref(req->req_file);
3257 return ERROR_SUCCESS;
3258 }
3259
3260 static const object_vtbl_t HTTPREQVtbl = {
3261 HTTPREQ_Destroy,
3262 HTTPREQ_CloseConnection,
3263 HTTPREQ_QueryOption,
3264 HTTPREQ_SetOption,
3265 HTTPREQ_ReadFile,
3266 HTTPREQ_WriteFile,
3267 HTTPREQ_QueryDataAvailable,
3268 NULL,
3269 HTTPREQ_LockRequestFile
3270 };
3271
3272 /***********************************************************************
3273 * HTTP_HttpOpenRequestW (internal)
3274 *
3275 * Open a HTTP request handle
3276 *
3277 * RETURNS
3278 * HINTERNET a HTTP request handle on success
3279 * NULL on failure
3280 *
3281 */
3282 static DWORD HTTP_HttpOpenRequestW(http_session_t *session,
3283 LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
3284 LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
3285 DWORD dwFlags, DWORD_PTR dwContext, HINTERNET *ret)
3286 {
3287 appinfo_t *hIC = session->appInfo;
3288 http_request_t *request;
3289 DWORD port, len;
3290
3291 TRACE("-->\n");
3292
3293 request = alloc_object(&session->hdr, &HTTPREQVtbl, sizeof(http_request_t));
3294 if(!request)
3295 return ERROR_OUTOFMEMORY;
3296
3297 request->hdr.htype = WH_HHTTPREQ;
3298 request->hdr.dwFlags = dwFlags;
3299 request->hdr.dwContext = dwContext;
3300 request->contentLength = ~0u;
3301
3302 request->netconn_stream.data_stream.vtbl = &netconn_stream_vtbl;
3303 request->data_stream = &request->netconn_stream.data_stream;
3304 request->connect_timeout = session->connect_timeout;
3305 request->send_timeout = session->send_timeout;
3306 request->receive_timeout = session->receive_timeout;
3307
3308 InitializeCriticalSection( &request->headers_section );
3309 request->headers_section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": http_request_t.headers_section");
3310
3311 InitializeCriticalSection( &request->read_section );
3312 request->read_section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": http_request_t.read_section");
3313
3314 WININET_AddRef( &session->hdr );
3315 request->session = session;
3316 list_add_head( &session->hdr.children, &request->hdr.entry );
3317
3318 port = session->hostPort;
3319 if (port == INTERNET_INVALID_PORT_NUMBER)
3320 port = (session->hdr.dwFlags & INTERNET_FLAG_SECURE) ?
3321 INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT;
3322
3323 request->server = get_server(substrz(session->hostName), port, (dwFlags & INTERNET_FLAG_SECURE) != 0, TRUE);
3324 if(!request->server) {
3325 WININET_Release(&request->hdr);
3326 return ERROR_OUTOFMEMORY;
3327 }
3328
3329 if (dwFlags & INTERNET_FLAG_IGNORE_CERT_CN_INVALID)
3330 request->security_flags |= SECURITY_FLAG_IGNORE_CERT_CN_INVALID;
3331 if (dwFlags & INTERNET_FLAG_IGNORE_CERT_DATE_INVALID)
3332 request->security_flags |= SECURITY_FLAG_IGNORE_CERT_DATE_INVALID;
3333
3334 if (lpszObjectName && *lpszObjectName) {
3335 HRESULT rc;
3336 WCHAR dummy;
3337
3338 len = 1;
3339 rc = UrlCanonicalizeW(lpszObjectName, &dummy, &len, URL_ESCAPE_SPACES_ONLY);
3340 if (rc != E_POINTER)
3341 len = strlenW(lpszObjectName)+1;
3342 request->path = heap_alloc(len*sizeof(WCHAR));
3343 rc = UrlCanonicalizeW(lpszObjectName, request->path, &len,
3344 URL_ESCAPE_SPACES_ONLY);
3345 if (rc != S_OK)
3346 {
3347 ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(lpszObjectName),rc);
3348 strcpyW(request->path,lpszObjectName);
3349 }
3350 }else {
3351 static const WCHAR slashW[] = {'/',0};
3352
3353 request->path = heap_strdupW(slashW);
3354 }
3355
3356 if (lpszReferrer && *lpszReferrer)
3357 HTTP_ProcessHeader(request, HTTP_REFERER, lpszReferrer, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
3358
3359 if (lpszAcceptTypes)
3360 {
3361 int i;
3362 for (i = 0; lpszAcceptTypes[i]; i++)
3363 {
3364 if (!*lpszAcceptTypes[i]) continue;
3365 HTTP_ProcessHeader(request, HTTP_ACCEPT, lpszAcceptTypes[i],
3366 HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA |
3367 HTTP_ADDHDR_FLAG_REQ |
3368 (i == 0 ? (HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD) : 0));
3369 }
3370 }
3371
3372 request->verb = heap_strdupW(lpszVerb && *lpszVerb ? lpszVerb : szGET);
3373 request->version = heap_strdupW(lpszVersion && *lpszVersion ? lpszVersion : g_szHttp1_1);
3374
3375 if (hIC->proxy && hIC->proxy[0] && !HTTP_ShouldBypassProxy(hIC, session->hostName))
3376 HTTP_DealWithProxy( hIC, session, request );
3377
3378 INTERNET_SendCallback(&session->hdr, dwContext,
3379 INTERNET_STATUS_HANDLE_CREATED, &request->hdr.hInternet,
3380 sizeof(HINTERNET));
3381
3382 TRACE("<-- (%p)\n", request);
3383
3384 *ret = request->hdr.hInternet;
3385 return ERROR_SUCCESS;
3386 }
3387
3388 /***********************************************************************
3389 * HttpOpenRequestW (WININET.@)
3390 *
3391 * Open a HTTP request handle
3392 *
3393 * RETURNS
3394 * HINTERNET a HTTP request handle on success
3395 * NULL on failure
3396 *
3397 */
3398 HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession,
3399 LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
3400 LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
3401 DWORD dwFlags, DWORD_PTR dwContext)
3402 {
3403 http_session_t *session;
3404 HINTERNET handle = NULL;
3405 DWORD res;
3406
3407 TRACE("(%p, %s, %s, %s, %s, %p, %08x, %08lx)\n", hHttpSession,
3408 debugstr_w(lpszVerb), debugstr_w(lpszObjectName),
3409 debugstr_w(lpszVersion), debugstr_w(lpszReferrer), lpszAcceptTypes,
3410 dwFlags, dwContext);
3411 if(lpszAcceptTypes!=NULL)
3412 {
3413 int i;
3414 for(i=0;lpszAcceptTypes[i]!=NULL;i++)
3415 TRACE("\taccept type: %s\n",debugstr_w(lpszAcceptTypes[i]));
3416 }
3417
3418 session = (http_session_t*) get_handle_object( hHttpSession );
3419 if (NULL == session || session->hdr.htype != WH_HHTTPSESSION)
3420 {
3421 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
3422 goto lend;
3423 }
3424
3425 /*
3426 * My tests seem to show that the windows version does not
3427 * become asynchronous until after this point. And anyhow
3428 * if this call was asynchronous then how would you get the
3429 * necessary HINTERNET pointer returned by this function.
3430 *
3431 */
3432 res = HTTP_HttpOpenRequestW(session, lpszVerb, lpszObjectName,
3433 lpszVersion, lpszReferrer, lpszAcceptTypes,
3434 dwFlags, dwContext, &handle);
3435 lend:
3436 if( session )
3437 WININET_Release( &session->hdr );
3438 TRACE("returning %p\n", handle);
3439 if(res != ERROR_SUCCESS)
3440 SetLastError(res);
3441 return handle;
3442 }
3443
3444 static const LPCWSTR header_lookup[] = {
3445 szMime_Version, /* HTTP_QUERY_MIME_VERSION = 0 */
3446 szContent_Type, /* HTTP_QUERY_CONTENT_TYPE = 1 */
3447 szContent_Transfer_Encoding,/* HTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
3448 szContent_ID, /* HTTP_QUERY_CONTENT_ID = 3 */
3449 NULL, /* HTTP_QUERY_CONTENT_DESCRIPTION = 4 */
3450 szContent_Length, /* HTTP_QUERY_CONTENT_LENGTH = 5 */
3451 szContent_Language, /* HTTP_QUERY_CONTENT_LANGUAGE = 6 */
3452 szAllow, /* HTTP_QUERY_ALLOW = 7 */
3453 szPublic, /* HTTP_QUERY_PUBLIC = 8 */
3454 szDate, /* HTTP_QUERY_DATE = 9 */
3455 szExpires, /* HTTP_QUERY_EXPIRES = 10 */
3456 szLast_Modified, /* HTTP_QUERY_LAST_MODIFIED = 11 */
3457 NULL, /* HTTP_QUERY_MESSAGE_ID = 12 */
3458 szURI, /* HTTP_QUERY_URI = 13 */
3459 szFrom, /* HTTP_QUERY_DERIVED_FROM = 14 */
3460 NULL, /* HTTP_QUERY_COST = 15 */
3461 NULL, /* HTTP_QUERY_LINK = 16 */
3462 szPragma, /* HTTP_QUERY_PRAGMA = 17 */
3463 NULL, /* HTTP_QUERY_VERSION = 18 */
3464 szStatus, /* HTTP_QUERY_STATUS_CODE = 19 */
3465 NULL, /* HTTP_QUERY_STATUS_TEXT = 20 */
3466 NULL, /* HTTP_QUERY_RAW_HEADERS = 21 */
3467 NULL, /* HTTP_QUERY_RAW_HEADERS_CRLF = 22 */
3468 szConnection, /* HTTP_QUERY_CONNECTION = 23 */
3469 szAccept, /* HTTP_QUERY_ACCEPT = 24 */
3470 szAccept_Charset, /* HTTP_QUERY_ACCEPT_CHARSET = 25 */
3471 szAccept_Encoding, /* HTTP_QUERY_ACCEPT_ENCODING = 26 */
3472 szAccept_Language, /* HTTP_QUERY_ACCEPT_LANGUAGE = 27 */
3473 szAuthorization, /* HTTP_QUERY_AUTHORIZATION = 28 */
3474 szContent_Encoding, /* HTTP_QUERY_CONTENT_ENCODING = 29 */
3475 NULL, /* HTTP_QUERY_FORWARDED = 30 */
3476 NULL, /* HTTP_QUERY_FROM = 31 */
3477 szIf_Modified_Since, /* HTTP_QUERY_IF_MODIFIED_SINCE = 32 */
3478 szLocation, /* HTTP_QUERY_LOCATION = 33 */
3479 NULL, /* HTTP_QUERY_ORIG_URI = 34 */
3480 szReferer, /* HTTP_QUERY_REFERER = 35 */
3481 szRetry_After, /* HTTP_QUERY_RETRY_AFTER = 36 */
3482 szServer, /* HTTP_QUERY_SERVER = 37 */
3483 NULL, /* HTTP_TITLE = 38 */
3484 szUser_Agent, /* HTTP_QUERY_USER_AGENT = 39 */
3485 szWWW_Authenticate, /* HTTP_QUERY_WWW_AUTHENTICATE = 40 */
3486 szProxy_Authenticate, /* HTTP_QUERY_PROXY_AUTHENTICATE = 41 */
3487 szAccept_Ranges, /* HTTP_QUERY_ACCEPT_RANGES = 42 */
3488 szSet_Cookie, /* HTTP_QUERY_SET_COOKIE = 43 */
3489 szCookie, /* HTTP_QUERY_COOKIE = 44 */
3490 NULL, /* HTTP_QUERY_REQUEST_METHOD = 45 */
3491 NULL, /* HTTP_QUERY_REFRESH = 46 */
3492 szContent_Disposition, /* HTTP_QUERY_CONTENT_DISPOSITION = 47 */
3493 szAge, /* HTTP_QUERY_AGE = 48 */
3494 szCache_Control, /* HTTP_QUERY_CACHE_CONTROL = 49 */
3495 szContent_Base, /* HTTP_QUERY_CONTENT_BASE = 50 */
3496 szContent_Location, /* HTTP_QUERY_CONTENT_LOCATION = 51 */
3497 szContent_MD5, /* HTTP_QUERY_CONTENT_MD5 = 52 */
3498 szContent_Range, /* HTTP_QUERY_CONTENT_RANGE = 53 */
3499 szETag, /* HTTP_QUERY_ETAG = 54 */
3500 hostW, /* HTTP_QUERY_HOST = 55 */
3501 szIf_Match, /* HTTP_QUERY_IF_MATCH = 56 */
3502 szIf_None_Match, /* HTTP_QUERY_IF_NONE_MATCH = 57 */
3503 szIf_Range, /* HTTP_QUERY_IF_RANGE = 58 */
3504 szIf_Unmodified_Since, /* HTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
3505 szMax_Forwards, /* HTTP_QUERY_MAX_FORWARDS = 60 */
3506 szProxy_Authorization, /* HTTP_QUERY_PROXY_AUTHORIZATION = 61 */
3507 szRange, /* HTTP_QUERY_RANGE = 62 */
3508 szTransfer_Encoding, /* HTTP_QUERY_TRANSFER_ENCODING = 63 */
3509 szUpgrade, /* HTTP_QUERY_UPGRADE = 64 */
3510 szVary, /* HTTP_QUERY_VARY = 65 */
3511 szVia, /* HTTP_QUERY_VIA = 66 */
3512 szWarning, /* HTTP_QUERY_WARNING = 67 */
3513 szExpect, /* HTTP_QUERY_EXPECT = 68 */
3514 szProxy_Connection, /* HTTP_QUERY_PROXY_CONNECTION = 69 */
3515 szUnless_Modified_Since, /* HTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
3516 };
3517
3518 #define LAST_TABLE_HEADER (sizeof(header_lookup)/sizeof(header_lookup[0]))
3519
3520 /***********************************************************************
3521 * HTTP_HttpQueryInfoW (internal)
3522 */
3523 static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel,
3524 LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3525 {
3526 LPHTTPHEADERW lphttpHdr = NULL;
3527 BOOL request_only = !!(dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS);
3528 INT requested_index = lpdwIndex ? *lpdwIndex : 0;
3529 DWORD level = (dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK);
3530 INT index = -1;
3531
3532 EnterCriticalSection( &request->headers_section );
3533
3534 /* Find requested header structure */
3535 switch (level)
3536 {
3537 case HTTP_QUERY_CUSTOM:
3538 if (!lpBuffer)
3539 {
3540 LeaveCriticalSection( &request->headers_section );
3541 return ERROR_INVALID_PARAMETER;
3542 }
3543 index = HTTP_GetCustomHeaderIndex(request, lpBuffer, requested_index, request_only);
3544 break;
3545 case HTTP_QUERY_RAW_HEADERS_CRLF:
3546 {
3547 LPWSTR headers;
3548 DWORD len = 0;
3549 DWORD res = ERROR_INVALID_PARAMETER;
3550
3551 if (request_only)
3552 headers = build_request_header(request, request->verb, request->path, request->version, TRUE);
3553 else
3554 headers = build_response_header(request, TRUE);
3555 if (!headers)
3556 {
3557 LeaveCriticalSection( &request->headers_section );
3558 return ERROR_OUTOFMEMORY;
3559 }
3560
3561 len = strlenW(headers) * sizeof(WCHAR);
3562 if (len + sizeof(WCHAR) > *lpdwBufferLength)
3563 {
3564 len += sizeof(WCHAR);
3565 res = ERROR_INSUFFICIENT_BUFFER;
3566 }
3567 else if (lpBuffer)
3568 {
3569 memcpy(lpBuffer, headers, len + sizeof(WCHAR));
3570 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len / sizeof(WCHAR)));
3571 res = ERROR_SUCCESS;
3572 }
3573 *lpdwBufferLength = len;
3574
3575 heap_free(headers);
3576 LeaveCriticalSection( &request->headers_section );
3577 return res;
3578 }
3579 case HTTP_QUERY_RAW_HEADERS:
3580 {
3581 LPWSTR headers;
3582 DWORD len;
3583
3584 if (request_only)
3585 headers = build_request_header(request, request->verb, request->path, request->version, FALSE);
3586 else
3587 headers = build_response_header(request, FALSE);
3588
3589 if (!headers)
3590 {
3591 LeaveCriticalSection( &request->headers_section );
3592 return ERROR_OUTOFMEMORY;
3593 }
3594
3595 len = strlenW(headers) * sizeof(WCHAR);
3596 if (len > *lpdwBufferLength)
3597 {
3598 *lpdwBufferLength = len;
3599 heap_free(headers);
3600 LeaveCriticalSection( &request->headers_section );
3601 return ERROR_INSUFFICIENT_BUFFER;
3602 }
3603
3604 if (lpBuffer)
3605 {
3606 DWORD i;
3607
3608 TRACE("returning data: %s\n", debugstr_wn(headers, len / sizeof(WCHAR)));
3609
3610 for (i = 0; i < len / sizeof(WCHAR); i++)
3611 {
3612 if (headers[i] == '\n')
3613 headers[i] = 0;
3614 }
3615 memcpy(lpBuffer, headers, len);
3616 }
3617 *lpdwBufferLength = len - sizeof(WCHAR);
3618
3619 heap_free(headers);
3620 LeaveCriticalSection( &request->headers_section );
3621 return ERROR_SUCCESS;
3622 }
3623 case HTTP_QUERY_STATUS_TEXT:
3624 if (request->statusText)
3625 {
3626 DWORD len = strlenW(request->statusText);
3627 if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
3628 {
3629 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
3630 LeaveCriticalSection( &request->headers_section );
3631 return ERROR_INSUFFICIENT_BUFFER;
3632 }
3633 if (lpBuffer)
3634 {
3635 memcpy(lpBuffer, request->statusText, (len + 1) * sizeof(WCHAR));
3636 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
3637 }
3638 *lpdwBufferLength = len * sizeof(WCHAR);
3639 LeaveCriticalSection( &request->headers_section );
3640 return ERROR_SUCCESS;
3641 }
3642 break;
3643 case HTTP_QUERY_VERSION:
3644 if (request->version)
3645 {
3646 DWORD len = strlenW(request->version);
3647 if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
3648 {
3649 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
3650 LeaveCriticalSection( &request->headers_section );
3651 return ERROR_INSUFFICIENT_BUFFER;
3652 }
3653 if (lpBuffer)
3654 {
3655 memcpy(lpBuffer, request->version, (len + 1) * sizeof(WCHAR));
3656 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
3657 }
3658 *lpdwBufferLength = len * sizeof(WCHAR);
3659 LeaveCriticalSection( &request->headers_section );
3660 return ERROR_SUCCESS;
3661 }
3662 break;
3663 case HTTP_QUERY_CONTENT_ENCODING:
3664 index = HTTP_GetCustomHeaderIndex(request, header_lookup[request->read_gzip ? HTTP_QUERY_CONTENT_TYPE : level],
3665 requested_index,request_only);
3666 break;
3667 case HTTP_QUERY_STATUS_CODE: {
3668 DWORD res = ERROR_SUCCESS;
3669
3670 if(request_only)
3671 {
3672 LeaveCriticalSection( &request->headers_section );
3673 return ERROR_HTTP_INVALID_QUERY_REQUEST;
3674 }
3675
3676 if(requested_index)
3677 break;
3678
3679 if(dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) {
3680 if(*lpdwBufferLength >= sizeof(DWORD))
3681 *(DWORD*)lpBuffer = request->status_code;
3682 else
3683 res = ERROR_INSUFFICIENT_BUFFER;
3684 *lpdwBufferLength = sizeof(DWORD);
3685 }else {
3686 WCHAR buf[12];
3687 DWORD size;
3688 static const WCHAR formatW[] = {'%','u',0};
3689
3690 size = sprintfW(buf, formatW, request->status_code) * sizeof(WCHAR);
3691
3692 if(size <= *lpdwBufferLength) {
3693 memcpy(lpBuffer, buf, size+sizeof(WCHAR));
3694 }else {
3695 size += sizeof(WCHAR);
3696 res = ERROR_INSUFFICIENT_BUFFER;
3697 }
3698
3699 *lpdwBufferLength = size;
3700 }
3701 LeaveCriticalSection( &request->headers_section );
3702 return res;
3703 }
3704 default:
3705 assert (LAST_TABLE_HEADER == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1));
3706
3707 if (level < LAST_TABLE_HEADER && header_lookup[level])
3708 index = HTTP_GetCustomHeaderIndex(request, header_lookup[level],
3709 requested_index,request_only);
3710 }
3711
3712 if (index >= 0)
3713 lphttpHdr = &request->custHeaders[index];
3714
3715 /* Ensure header satisfies requested attributes */
3716 if (!lphttpHdr ||
3717 ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
3718 (~lphttpHdr->wFlags & HDR_ISREQUEST)))
3719 {
3720 LeaveCriticalSection( &request->headers_section );
3721 return ERROR_HTTP_HEADER_NOT_FOUND;
3722 }
3723
3724 /* coalesce value to requested type */
3725 if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER && lpBuffer)
3726 {
3727 *(int *)lpBuffer = atoiW(lphttpHdr->lpszValue);
3728 TRACE(" returning number: %d\n", *(int *)lpBuffer);
3729 }
3730 else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME && lpBuffer)
3731 {
3732 time_t tmpTime;
3733 struct tm tmpTM;
3734 SYSTEMTIME *STHook;
3735
3736 tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
3737
3738 tmpTM = *gmtime(&tmpTime);
3739 STHook = (SYSTEMTIME *)lpBuffer;
3740 STHook->wDay = tmpTM.tm_mday;
3741 STHook->wHour = tmpTM.tm_hour;
3742 STHook->wMilliseconds = 0;
3743 STHook->wMinute = tmpTM.tm_min;
3744 STHook->wDayOfWeek = tmpTM.tm_wday;
3745 STHook->wMonth = tmpTM.tm_mon + 1;
3746 STHook->wSecond = tmpTM.tm_sec;
3747 STHook->wYear = 1900+tmpTM.tm_year;
3748
3749 TRACE(" returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
3750 STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
3751 STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
3752 }
3753 else if (lphttpHdr->lpszValue)
3754 {
3755 DWORD len = (strlenW(lphttpHdr->lpszValue) + 1) * sizeof(WCHAR);
3756
3757 if (len > *lpdwBufferLength)
3758 {
3759 *lpdwBufferLength = len;
3760 LeaveCriticalSection( &request->headers_section );
3761 return ERROR_INSUFFICIENT_BUFFER;
3762 }
3763 if (lpBuffer)
3764 {
3765 memcpy(lpBuffer, lphttpHdr->lpszValue, len);
3766 TRACE("! returning string: %s\n", debugstr_w(lpBuffer));
3767 }
3768 *lpdwBufferLength = len - sizeof(WCHAR);
3769 }
3770 if (lpdwIndex) (*lpdwIndex)++;
3771
3772 LeaveCriticalSection( &request->headers_section );
3773 return ERROR_SUCCESS;
3774 }
3775
3776 /***********************************************************************
3777 * HttpQueryInfoW (WININET.@)
3778 *
3779 * Queries for information about an HTTP request
3780 *
3781 * RETURNS
3782 * TRUE on success
3783 * FALSE on failure
3784 *
3785 */
3786 BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel,
3787 LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3788 {
3789 http_request_t *request;
3790 DWORD res;
3791
3792 if (TRACE_ON(wininet)) {
3793 #define FE(x) { x, #x }
3794 static const wininet_flag_info query_flags[] = {
3795 FE(HTTP_QUERY_MIME_VERSION),
3796 FE(HTTP_QUERY_CONTENT_TYPE),
3797 FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
3798 FE(HTTP_QUERY_CONTENT_ID),
3799 FE(HTTP_QUERY_CONTENT_DESCRIPTION),
3800 FE(HTTP_QUERY_CONTENT_LENGTH),
3801 FE(HTTP_QUERY_CONTENT_LANGUAGE),
3802 FE(HTTP_QUERY_ALLOW),
3803 FE(HTTP_QUERY_PUBLIC),
3804 FE(HTTP_QUERY_DATE),
3805 FE(HTTP_QUERY_EXPIRES),
3806 FE(HTTP_QUERY_LAST_MODIFIED),
3807 FE(HTTP_QUERY_MESSAGE_ID),
3808 FE(HTTP_QUERY_URI),
3809 FE(HTTP_QUERY_DERIVED_FROM),
3810 FE(HTTP_QUERY_COST),
3811 FE(HTTP_QUERY_LINK),
3812 FE(HTTP_QUERY_PRAGMA),
3813 FE(HTTP_QUERY_VERSION),
3814 FE(HTTP_QUERY_STATUS_CODE),
3815 FE(HTTP_QUERY_STATUS_TEXT),
3816 FE(HTTP_QUERY_RAW_HEADERS),
3817 FE(HTTP_QUERY_RAW_HEADERS_CRLF),
3818 FE(HTTP_QUERY_CONNECTION),
3819 FE(HTTP_QUERY_ACCEPT),
3820 FE(HTTP_QUERY_ACCEPT_CHARSET),
3821 FE(HTTP_QUERY_ACCEPT_ENCODING),
3822 FE(HTTP_QUERY_ACCEPT_LANGUAGE),
3823 FE(HTTP_QUERY_AUTHORIZATION),
3824 FE(HTTP_QUERY_CONTENT_ENCODING),
3825 FE(HTTP_QUERY_FORWARDED),
3826 FE(HTTP_QUERY_FROM),
3827 FE(HTTP_QUERY_IF_MODIFIED_SINCE),
3828 FE(HTTP_QUERY_LOCATION),
3829 FE(HTTP_QUERY_ORIG_URI),
3830 FE(HTTP_QUERY_REFERER),
3831 FE(HTTP_QUERY_RETRY_AFTER),
3832 FE(HTTP_QUERY_SERVER),
3833 FE(HTTP_QUERY_TITLE),
3834 FE(HTTP_QUERY_USER_AGENT),
3835 FE(HTTP_QUERY_WWW_AUTHENTICATE),
3836 FE(HTTP_QUERY_PROXY_AUTHENTICATE),
3837 FE(HTTP_QUERY_ACCEPT_RANGES),
3838 FE(HTTP_QUERY_SET_COOKIE),
3839 FE(HTTP_QUERY_COOKIE),
3840 FE(HTTP_QUERY_REQUEST_METHOD),
3841 FE(HTTP_QUERY_REFRESH),
3842 FE(HTTP_QUERY_CONTENT_DISPOSITION),
3843 FE(HTTP_QUERY_AGE),
3844 FE(HTTP_QUERY_CACHE_CONTROL),
3845 FE(HTTP_QUERY_CONTENT_BASE),
3846 FE(HTTP_QUERY_CONTENT_LOCATION),
3847 FE(HTTP_QUERY_CONTENT_MD5),
3848 FE(HTTP_QUERY_CONTENT_RANGE),
3849 FE(HTTP_QUERY_ETAG),
3850 FE(HTTP_QUERY_HOST),
3851 FE(HTTP_QUERY_IF_MATCH),
3852 FE(HTTP_QUERY_IF_NONE_MATCH),
3853 FE(HTTP_QUERY_IF_RANGE),
3854 FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
3855 FE(HTTP_QUERY_MAX_FORWARDS),
3856 FE(HTTP_QUERY_PROXY_AUTHORIZATION),
3857 FE(HTTP_QUERY_RANGE),
3858 FE(HTTP_QUERY_TRANSFER_ENCODING),
3859 FE(HTTP_QUERY_UPGRADE),
3860 FE(HTTP_QUERY_VARY),
3861 FE(HTTP_QUERY_VIA),
3862 FE(HTTP_QUERY_WARNING),
3863 FE(HTTP_QUERY_CUSTOM)
3864 };
3865 static const wininet_flag_info modifier_flags[] = {
3866 FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
3867 FE(HTTP_QUERY_FLAG_SYSTEMTIME),
3868 FE(HTTP_QUERY_FLAG_NUMBER),
3869 FE(HTTP_QUERY_FLAG_COALESCE)
3870 };
3871 #undef FE
3872 DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
3873 DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
3874 DWORD i;
3875
3876 TRACE("(%p, 0x%08x)--> %d\n", hHttpRequest, dwInfoLevel, info);
3877 TRACE(" Attribute:");
3878 for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
3879 if (query_flags[i].val == info) {
3880 TRACE(" %s", query_flags[i].name);
3881 break;
3882 }
3883 }
3884 if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
3885 TRACE(" Unknown (%08x)", info);
3886 }
3887
3888 TRACE(" Modifier:");
3889 for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
3890 if (modifier_flags[i].val & info_mod) {
3891 TRACE(" %s", modifier_flags[i].name);
3892 info_mod &= ~ modifier_flags[i].val;
3893 }
3894 }
3895
3896 if (info_mod) {
3897 TRACE(" Unknown (%08x)", info_mod);
3898 }
3899 TRACE("\n");
3900 }
3901
3902 request = (http_request_t*) get_handle_object( hHttpRequest );
3903 if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
3904 {
3905 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
3906 goto lend;
3907 }
3908
3909 if (lpBuffer == NULL)
3910 *lpdwBufferLength = 0;
3911 res = HTTP_HttpQueryInfoW( request, dwInfoLevel,
3912 lpBuffer, lpdwBufferLength, lpdwIndex);
3913
3914 lend:
3915 if( request )
3916 WININET_Release( &request->hdr );
3917
3918 TRACE("%u <--\n", res);
3919 if(res != ERROR_SUCCESS)
3920 SetLastError(res);
3921 return res == ERROR_SUCCESS;
3922 }
3923
3924 /***********************************************************************
3925 * HttpQueryInfoA (WININET.@)
3926 *
3927 * Queries for information about an HTTP request
3928 *
3929 * RETURNS
3930 * TRUE on success
3931 * FALSE on failure
3932 *
3933 */
3934 BOOL WINAPI HttpQueryInfoA(HINTERNET hHttpRequest, DWORD dwInfoLevel,
3935 LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3936 {
3937 BOOL result;
3938 DWORD len;
3939 WCHAR* bufferW;
3940
3941 TRACE("%p %x\n", hHttpRequest, dwInfoLevel);
3942
3943 if((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
3944 (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME))
3945 {
3946 return HttpQueryInfoW( hHttpRequest, dwInfoLevel, lpBuffer,
3947 lpdwBufferLength, lpdwIndex );
3948 }
3949
3950 if (lpBuffer)
3951 {
3952 DWORD alloclen;
3953 len = (*lpdwBufferLength)*sizeof(WCHAR);
3954 if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
3955 {
3956 alloclen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, NULL, 0 ) * sizeof(WCHAR);
3957 if (alloclen < len)
3958 alloclen = len;
3959 }
3960 else
3961 alloclen = len;
3962 bufferW = heap_alloc(alloclen);
3963 /* buffer is in/out because of HTTP_QUERY_CUSTOM */
3964 if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
3965 MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, bufferW, alloclen / sizeof(WCHAR) );
3966 } else
3967 {
3968 bufferW = NULL;
3969 len = 0;
3970 }
3971
3972 result = HttpQueryInfoW( hHttpRequest, dwInfoLevel, bufferW,
3973 &len, lpdwIndex );
3974 if( result )
3975 {
3976 len = WideCharToMultiByte( CP_ACP,0, bufferW, len / sizeof(WCHAR) + 1,
3977 lpBuffer, *lpdwBufferLength, NULL, NULL );
3978 *lpdwBufferLength = len - 1;
3979
3980 TRACE("lpBuffer: %s\n", debugstr_a(lpBuffer));
3981 }
3982 else
3983 /* since the strings being returned from HttpQueryInfoW should be
3984 * only ASCII characters, it is reasonable to assume that all of
3985 * the Unicode characters can be reduced to a single byte */
3986 *lpdwBufferLength = len / sizeof(WCHAR);
3987
3988 heap_free( bufferW );
3989 return result;
3990 }
3991
3992 static WCHAR *get_redirect_url(http_request_t *request)
3993 {
3994 static WCHAR szHttp[] = {'h','t','t','p',0};
3995 static WCHAR szHttps[] = {'h','t','t','p','s',0};
3996 http_session_t *session = request->session;
3997 URL_COMPONENTSW urlComponents = { sizeof(urlComponents) };
3998 WCHAR *orig_url = NULL, *redirect_url = NULL, *combined_url = NULL;
3999 DWORD url_length = 0, res;
4000 BOOL b;
4001
4002 url_length = 0;
4003 res = HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, redirect_url, &url_length, NULL);
4004 if(res == ERROR_INSUFFICIENT_BUFFER) {
4005 redirect_url = heap_alloc(url_length);
4006 res = HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, redirect_url, &url_length, NULL);
4007 }
4008 if(res != ERROR_SUCCESS) {
4009 heap_free(redirect_url);
4010 return NULL;
4011 }
4012
4013 urlComponents.dwSchemeLength = 1;
4014 b = InternetCrackUrlW(redirect_url, url_length / sizeof(WCHAR), 0, &urlComponents);
4015 if(b && urlComponents.dwSchemeLength &&
4016 urlComponents.nScheme != INTERNET_SCHEME_HTTP && urlComponents.nScheme != INTERNET_SCHEME_HTTPS) {
4017 TRACE("redirect to non-http URL\n");
4018 return NULL;
4019 }
4020
4021 urlComponents.lpszScheme = (request->hdr.dwFlags & INTERNET_FLAG_SECURE) ? szHttps : szHttp;
4022 urlComponents.dwSchemeLength = 0;
4023 urlComponents.lpszHostName = request->server->name;
4024 urlComponents.nPort = request->server->port;
4025 urlComponents.lpszUserName = session->userName;
4026 urlComponents.lpszUrlPath = request->path;
4027
4028 b = InternetCreateUrlW(&urlComponents, 0, NULL, &url_length);
4029 if(!b && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
4030 orig_url = heap_alloc(url_length);
4031
4032 /* convert from bytes to characters */
4033 url_length = url_length / sizeof(WCHAR) - 1;
4034 b = InternetCreateUrlW(&urlComponents, 0, orig_url, &url_length);
4035 }
4036
4037 if(b) {
4038 url_length = 0;
4039 b = InternetCombineUrlW(orig_url, redirect_url, NULL, &url_length, ICU_ENCODE_SPACES_ONLY);
4040 if(!b && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
4041 combined_url = heap_alloc(url_length * sizeof(WCHAR));
4042 b = InternetCombineUrlW(orig_url, redirect_url, combined_url, &url_length, ICU_ENCODE_SPACES_ONLY);
4043 if(!b) {
4044 heap_free(combined_url);
4045 combined_url = NULL;
4046 }
4047 }
4048 }
4049
4050 heap_free(orig_url);
4051 heap_free(redirect_url);
4052 return combined_url;
4053 }
4054
4055
4056 /***********************************************************************
4057 * HTTP_HandleRedirect (internal)
4058 */
4059 static DWORD HTTP_HandleRedirect(http_request_t *request, WCHAR *url)
4060 {
4061 URL_COMPONENTSW urlComponents = { sizeof(urlComponents) };
4062 http_session_t *session = request->session;
4063 size_t url_len = strlenW(url);
4064
4065 if(url[0] == '/')
4066 {
4067 /* if it's an absolute path, keep the same session info */
4068 urlComponents.lpszUrlPath = url;
4069 urlComponents.dwUrlPathLength = url_len;
4070 }
4071 else
4072 {
4073 urlComponents.dwHostNameLength = 1;
4074 urlComponents.dwUserNameLength = 1;
4075 urlComponents.dwUrlPathLength = 1;
4076 if(!InternetCrackUrlW(url, url_len, 0, &urlComponents))
4077 return INTERNET_GetLastError();
4078
4079 if(!urlComponents.dwHostNameLength)
4080 return ERROR_INTERNET_INVALID_URL;
4081 }
4082
4083 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REDIRECT,
4084 url, (url_len + 1) * sizeof(WCHAR));
4085
4086 if(urlComponents.dwHostNameLength) {
4087 BOOL custom_port = FALSE;
4088 substr_t host;
4089
4090 if(urlComponents.nScheme == INTERNET_SCHEME_HTTP) {
4091 if(request->hdr.dwFlags & INTERNET_FLAG_SECURE) {
4092 TRACE("redirect from secure page to non-secure page\n");
4093 /* FIXME: warn about from secure redirect to non-secure page */
4094 request->hdr.dwFlags &= ~INTERNET_FLAG_SECURE;
4095 }
4096
4097 custom_port = urlComponents.nPort != INTERNET_DEFAULT_HTTP_PORT;
4098 }else if(urlComponents.nScheme == INTERNET_SCHEME_HTTPS) {
4099 if(!(request->hdr.dwFlags & INTERNET_FLAG_SECURE)) {
4100 TRACE("redirect from non-secure page to secure page\n");
4101 /* FIXME: notify about redirect to secure page */
4102 request->hdr.dwFlags |= INTERNET_FLAG_SECURE;
4103 }
4104
4105 custom_port = urlComponents.nPort != INTERNET_DEFAULT_HTTPS_PORT;
4106 }
4107
4108 heap_free(session->hostName);
4109
4110 session->hostName = heap_strndupW(urlComponents.lpszHostName, urlComponents.dwHostNameLength);
4111 session->hostPort = urlComponents.nPort;
4112
4113 heap_free(session->userName);
4114 session->userName = NULL;
4115 if (urlComponents.dwUserNameLength)
4116 session->userName = heap_strndupW(urlComponents.lpszUserName, urlComponents.dwUserNameLength);
4117
4118 reset_data_stream(request);
4119
4120 host = substr(urlComponents.lpszHostName, urlComponents.dwHostNameLength);
4121
4122 if(host.len != strlenW(request->server->name) || strncmpiW(request->server->name, host.str, host.len)
4123 || request->server->port != urlComponents.nPort) {
4124 server_t *new_server;
4125
4126 new_server = get_server(host, urlComponents.nPort, urlComponents.nScheme == INTERNET_SCHEME_HTTPS, TRUE);
4127 server_release(request->server);
4128 request->server = new_server;
4129 }
4130
4131 if (custom_port)
4132 HTTP_ProcessHeader(request, hostW, request->server->host_port, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
4133 else
4134 HTTP_ProcessHeader(request, hostW, request->server->name, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
4135 }
4136
4137 heap_free(request->path);
4138 request->path = NULL;
4139 if(urlComponents.dwUrlPathLength)
4140 {
4141 DWORD needed = 1;
4142 HRESULT rc;
4143 WCHAR dummy = 0;
4144 WCHAR *path;
4145
4146 path = heap_strndupW(urlComponents.lpszUrlPath, urlComponents.dwUrlPathLength);
4147 rc = UrlEscapeW(path, &dummy, &needed, URL_ESCAPE_SPACES_ONLY);
4148 if (rc != E_POINTER)
4149 ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
4150 request->path = heap_alloc(needed*sizeof(WCHAR));
4151 rc = UrlEscapeW(path, request->path, &needed,
4152 URL_ESCAPE_SPACES_ONLY);
4153 if (rc != S_OK)
4154 {
4155 ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
4156 strcpyW(request->path, path);
4157 }
4158 heap_free(path);
4159 }
4160
4161 /* Remove custom content-type/length headers on redirects. */
4162 remove_header(request, szContent_Type, TRUE);
4163 remove_header(request, szContent_Length, TRUE);
4164
4165 return ERROR_SUCCESS;
4166 }
4167
4168 /***********************************************************************
4169 * HTTP_build_req (internal)
4170 *
4171 * concatenate all the strings in the request together
4172 */
4173 static LPWSTR HTTP_build_req( LPCWSTR *list, int len )
4174 {
4175 LPCWSTR *t;
4176 LPWSTR str;
4177
4178 for( t = list; *t ; t++ )
4179 len += strlenW( *t );
4180 len++;
4181
4182 str = heap_alloc(len*sizeof(WCHAR));
4183 *str = 0;
4184
4185 for( t = list; *t ; t++ )
4186 strcatW( str, *t );
4187
4188 return str;
4189 }
4190
4191 static void HTTP_InsertCookies(http_request_t *request)
4192 {
4193 WCHAR *cookies;
4194 DWORD res;
4195
4196 res = get_cookie_header(request->server->name, request->path, &cookies);
4197 if(res != ERROR_SUCCESS || !cookies)
4198 return;
4199
4200 HTTP_HttpAddRequestHeadersW(request, cookies, strlenW(cookies),
4201 HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD);
4202 heap_free(cookies);
4203 }
4204
4205 static WORD HTTP_ParseWkday(LPCWSTR day)
4206 {
4207 static const WCHAR days[7][4] = {{ 's','u','n',0 },
4208 { 'm','o','n',0 },
4209 { 't','u','e',0 },
4210 { 'w','e','d',0 },
4211 { 't','h','u',0 },
4212 { 'f','r','i',0 },
4213 { 's','a','t',0 }};
4214 unsigned int i;
4215 for (i = 0; i < sizeof(days)/sizeof(*days); i++)
4216 if (!strcmpiW(day, days[i]))
4217 return i;
4218
4219 /* Invalid */
4220 return 7;
4221 }
4222
4223 static WORD HTTP_ParseMonth(LPCWSTR month)
4224 {
4225 static const WCHAR jan[] = { 'j','a','n',0 };
4226 static const WCHAR feb[] = { 'f','e','b',0 };
4227 static const WCHAR mar[] = { 'm','a','r',0 };
4228 static const WCHAR apr[] = { 'a','p','r',0 };
4229 static const WCHAR may[] = { 'm','a','y',0 };
4230 static const WCHAR jun[] = { 'j','u','n',0 };
4231 static const WCHAR jul[] = { 'j','u','l',0 };
4232 static const WCHAR aug[] = { 'a','u','g',0 };
4233 static const WCHAR sep[] = { 's','e','p',0 };
4234 static const WCHAR oct[] = { 'o','c','t',0 };
4235 static const WCHAR nov[] = { 'n','o','v',0 };
4236 static const WCHAR dec[] = { 'd','e','c',0 };
4237
4238 if (!strcmpiW(month, jan)) return 1;
4239 if (!strcmpiW(month, feb)) return 2;
4240 if (!strcmpiW(month, mar)) return 3;
4241 if (!strcmpiW(month, apr)) return 4;
4242 if (!strcmpiW(month, may)) return 5;
4243 if (!strcmpiW(month, jun)) return 6;
4244 if (!strcmpiW(month, jul)) return 7;
4245 if (!strcmpiW(month, aug)) return 8;
4246 if (!strcmpiW(month, sep)) return 9;
4247 if (!strcmpiW(month, oct)) return 10;
4248 if (!strcmpiW(month, nov)) return 11;
4249 if (!strcmpiW(month, dec)) return 12;
4250 /* Invalid */
4251 return 0;
4252 }
4253
4254 /* Parses the string pointed to by *str, assumed to be a 24-hour time HH:MM:SS,
4255 * optionally preceded by whitespace.
4256 * Upon success, returns TRUE, sets the wHour, wMinute, and wSecond fields of
4257 * st, and sets *str to the first character after the time format.
4258 */
4259 static BOOL HTTP_ParseTime(SYSTEMTIME *st, LPCWSTR *str)
4260 {
4261 LPCWSTR ptr = *str;
4262 WCHAR *nextPtr;
4263 unsigned long num;
4264
4265 while (isspaceW(*ptr))
4266 ptr++;
4267
4268 num = strtoulW(ptr, &nextPtr, 10);
4269 if (!nextPtr || nextPtr <= ptr || *nextPtr != ':')
4270 {
4271 ERR("unexpected time format %s\n", debugstr_w(ptr));
4272 return FALSE;
4273 }
4274 if (num > 23)
4275 {
4276 ERR("unexpected hour in time format %s\n", debugstr_w(ptr));
4277 return FALSE;
4278 }
4279 ptr = nextPtr + 1;
4280 st->wHour = (WORD)num;
4281 num = strtoulW(ptr, &nextPtr, 10);
4282 if (!nextPtr || nextPtr <= ptr || *nextPtr != ':')
4283 {
4284 ERR("unexpected time format %s\n", debugstr_w(ptr));
4285 return FALSE;
4286 }
4287 if (num > 59)
4288 {
4289 ERR("unexpected minute in time format %s\n", debugstr_w(ptr));
4290 return FALSE;
4291 }
4292 ptr = nextPtr + 1;
4293 st->wMinute = (WORD)num;
4294 num = strtoulW(ptr, &nextPtr, 10);
4295 if (!nextPtr || nextPtr <= ptr)
4296 {
4297 ERR("unexpected time format %s\n", debugstr_w(ptr));
4298 return FALSE;
4299 }
4300 if (num > 59)
4301 {
4302 ERR("unexpected second in time format %s\n", debugstr_w(ptr));
4303 return FALSE;
4304 }
4305 ptr = nextPtr + 1;
4306 *str = ptr;
4307 st->wSecond = (WORD)num;
4308 return TRUE;
4309 }
4310
4311 static BOOL HTTP_ParseDateAsAsctime(LPCWSTR value, FILETIME *ft)
4312 {
4313 static const WCHAR gmt[]= { 'G','M','T',0 };
4314 WCHAR day[4], *dayPtr, month[4], *monthPtr, *nextPtr;
4315 LPCWSTR ptr;
4316 SYSTEMTIME st = { 0 };
4317 unsigned long num;
4318
4319 for (ptr = value, dayPtr = day; *ptr && !isspaceW(*ptr) &&
4320 dayPtr - day < sizeof(day) / sizeof(day[0]) - 1; ptr++, dayPtr++)
4321 *dayPtr = *ptr;
4322 *dayPtr = 0;
4323 st.wDayOfWeek = HTTP_ParseWkday(day);
4324 if (st.wDayOfWeek >= 7)
4325 {
4326 ERR("unexpected weekday %s\n", debugstr_w(day));
4327 return FALSE;
4328 }
4329
4330 while (isspaceW(*ptr))
4331 ptr++;
4332
4333 for (monthPtr = month; !isspaceW(*ptr) &&
4334 monthPtr - month < sizeof(month) / sizeof(month[0]) - 1;
4335 monthPtr++, ptr++)
4336 *monthPtr = *ptr;
4337 *monthPtr = 0;
4338 st.wMonth = HTTP_ParseMonth(month);
4339 if (!st.wMonth || st.wMonth > 12)
4340 {
4341 ERR("unexpected month %s\n", debugstr_w(month));
4342 return FALSE;
4343 }
4344
4345 while (isspaceW(*ptr))
4346 ptr++;
4347
4348 num = strtoulW(ptr, &nextPtr, 10);
4349 if (!nextPtr || nextPtr <= ptr || !num || num > 31)
4350 {
4351 ERR("unexpected day %s\n", debugstr_w(ptr));
4352 return FALSE;
4353 }
4354 ptr = nextPtr;
4355 st.wDay = (WORD)num;
4356
4357 while (isspaceW(*ptr))
4358 ptr++;
4359
4360 if (!HTTP_ParseTime(&st, &ptr))
4361 return FALSE;
4362
4363 while (isspaceW(*ptr))
4364 ptr++;
4365
4366 num = strtoulW(ptr, &nextPtr, 10);
4367 if (!nextPtr || nextPtr <= ptr || num < 1601 || num > 30827)
4368 {
4369 ERR("unexpected year %s\n", debugstr_w(ptr));
4370 return FALSE;
4371 }
4372 ptr = nextPtr;
4373 st.wYear = (WORD)num;
4374
4375 while (isspaceW(*ptr))
4376 ptr++;
4377
4378 /* asctime() doesn't report a timezone, but some web servers do, so accept
4379 * with or without GMT.
4380 */
4381 if (*ptr && strcmpW(ptr, gmt))
4382 {
4383 ERR("unexpected timezone %s\n", debugstr_w(ptr));
4384 return FALSE;
4385 }
4386 return SystemTimeToFileTime(&st, ft);
4387 }
4388
4389 static BOOL HTTP_ParseRfc1123Date(LPCWSTR value, FILETIME *ft)
4390 {
4391 static const WCHAR gmt[]= { 'G','M','T',0 };
4392 WCHAR *nextPtr, day[4], month[4], *monthPtr;
4393 LPCWSTR ptr;
4394 unsigned long num;
4395 SYSTEMTIME st = { 0 };
4396
4397 ptr = strchrW(value, ',');
4398 if (!ptr)
4399 return FALSE;
4400 if (ptr - value != 3)
4401 {
4402 WARN("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4403 return FALSE;
4404 }
4405 memcpy(day, value, (ptr - value) * sizeof(WCHAR));
4406 day[3] = 0;
4407 st.wDayOfWeek = HTTP_ParseWkday(day);
4408 if (st.wDayOfWeek > 6)
4409 {
4410 WARN("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4411 return FALSE;
4412 }
4413 ptr++;
4414
4415 while (isspaceW(*ptr))
4416 ptr++;
4417
4418 num = strtoulW(ptr, &nextPtr, 10);
4419 if (!nextPtr || nextPtr <= ptr || !num || num > 31)
4420 {
4421 WARN("unexpected day %s\n", debugstr_w(value));
4422 return FALSE;
4423 }
4424 ptr = nextPtr;
4425 st.wDay = (WORD)num;
4426
4427 while (isspaceW(*ptr))
4428 ptr++;
4429
4430 for (monthPtr = month; !isspaceW(*ptr) &&
4431 monthPtr - month < sizeof(month) / sizeof(month[0]) - 1;
4432 monthPtr++, ptr++)
4433 *monthPtr = *ptr;
4434 *monthPtr = 0;
4435 st.wMonth = HTTP_ParseMonth(month);
4436 if (!st.wMonth || st.wMonth > 12)
4437 {
4438 WARN("unexpected month %s\n", debugstr_w(month));
4439 return FALSE;
4440 }
4441
4442 while (isspaceW(*ptr))
4443 ptr++;
4444
4445 num = strtoulW(ptr, &nextPtr, 10);
4446 if (!nextPtr || nextPtr <= ptr || num < 1601 || num > 30827)
4447 {
4448 ERR("unexpected year %s\n", debugstr_w(value));
4449 return FALSE;
4450 }
4451 ptr = nextPtr;
4452 st.wYear = (WORD)num;
4453
4454 if (!HTTP_ParseTime(&st, &ptr))
4455 return FALSE;
4456
4457 while (isspaceW(*ptr))
4458 ptr++;
4459
4460 if (strcmpW(ptr, gmt))
4461 {
4462 ERR("unexpected time zone %s\n", debugstr_w(ptr));
4463 return FALSE;
4464 }
4465 return SystemTimeToFileTime(&st, ft);
4466 }
4467
4468 static WORD HTTP_ParseWeekday(LPCWSTR day)
4469 {
4470 static const WCHAR days[7][10] = {{ 's','u','n','d','a','y',0 },
4471 { 'm','o','n','d','a','y',0 },
4472 { 't','u','e','s','d','a','y',0 },
4473 { 'w','e','d','n','e','s','d','a','y',0 },
4474 { 't','h','u','r','s','d','a','y',0 },
4475 { 'f','r','i','d','a','y',0 },
4476 { 's','a','t','u','r','d','a','y',0 }};
4477 unsigned int i;
4478 for (i = 0; i < sizeof(days)/sizeof(*days); i++)
4479 if (!strcmpiW(day, days[i]))
4480 return i;
4481
4482 /* Invalid */
4483 return 7;
4484 }
4485
4486 static BOOL HTTP_ParseRfc850Date(LPCWSTR value, FILETIME *ft)
4487 {
4488 static const WCHAR gmt[]= { 'G','M','T',0 };
4489 WCHAR *nextPtr, day[10], month[4], *monthPtr;
4490 LPCWSTR ptr;
4491 unsigned long num;
4492 SYSTEMTIME st = { 0 };
4493
4494 ptr = strchrW(value, ',');
4495 if (!ptr)
4496 return FALSE;
4497 if (ptr - value == 3)
4498 {
4499 memcpy(day, value, (ptr - value) * sizeof(WCHAR));
4500 day[3] = 0;
4501 st.wDayOfWeek = HTTP_ParseWkday(day);
4502 if (st.wDayOfWeek > 6)
4503 {
4504 ERR("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4505 return FALSE;
4506 }
4507 }
4508 else if (ptr - value < sizeof(day) / sizeof(day[0]))
4509 {
4510 memcpy(day, value, (ptr - value) * sizeof(WCHAR));
4511 day[ptr - value + 1] = 0;
4512 st.wDayOfWeek = HTTP_ParseWeekday(day);
4513 if (st.wDayOfWeek > 6)
4514 {
4515 ERR("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4516 return FALSE;
4517 }
4518 }
4519 else
4520 {
4521 ERR("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4522 return FALSE;
4523 }
4524 ptr++;
4525
4526 while (isspaceW(*ptr))
4527 ptr++;
4528
4529 num = strtoulW(ptr, &nextPtr, 10);
4530 if (!nextPtr || nextPtr <= ptr || !num || num > 31)
4531 {
4532 ERR("unexpected day %s\n", debugstr_w(value));
4533 return FALSE;
4534 }
4535 ptr = nextPtr;
4536 st.wDay = (WORD)num;
4537
4538 if (*ptr != '-')
4539 {
4540 ERR("unexpected month format %s\n", debugstr_w(ptr));
4541 return FALSE;
4542 }
4543 ptr++;
4544
4545 for (monthPtr = month; *ptr != '-' &&
4546 monthPtr - month < sizeof(month) / sizeof(month[0]) - 1;
4547 monthPtr++, ptr++)
4548 *monthPtr = *ptr;
4549 *monthPtr = 0;
4550 st.wMonth = HTTP_ParseMonth(month);
4551 if (!st.wMonth || st.wMonth > 12)
4552 {
4553 ERR("unexpected month %s\n", debugstr_w(month));
4554 return FALSE;
4555 }
4556
4557 if (*ptr != '-')
4558 {
4559 ERR("unexpected year format %s\n", debugstr_w(ptr));
4560 return FALSE;
4561 }
4562 ptr++;
4563
4564 num = strtoulW(ptr, &nextPtr, 10);
4565 if (!nextPtr || nextPtr <= ptr || num < 1601 || num > 30827)
4566 {
4567 ERR("unexpected year %s\n", debugstr_w(value));
4568 return FALSE;
4569 }
4570 ptr = nextPtr;
4571 st.wYear = (WORD)num;
4572
4573 if (!HTTP_ParseTime(&st, &ptr))
4574 return FALSE;
4575
4576 while (isspaceW(*ptr))
4577 ptr++;
4578
4579 if (strcmpW(ptr, gmt))
4580 {
4581 ERR("unexpected time zone %s\n", debugstr_w(ptr));
4582 return FALSE;
4583 }
4584 return SystemTimeToFileTime(&st, ft);
4585 }
4586
4587 static BOOL HTTP_ParseDate(LPCWSTR value, FILETIME *ft)
4588 {
4589 static const WCHAR zero[] = { '0',0 };
4590 BOOL ret;
4591
4592 if (!strcmpW(value, zero))
4593 {
4594 ft->dwLowDateTime = ft->dwHighDateTime = 0;
4595 ret = TRUE;
4596 }
4597 else if (strchrW(value, ','))
4598 {
4599 ret = HTTP_ParseRfc1123Date(value, ft);
4600 if (!ret)
4601 {
4602 ret = HTTP_ParseRfc850Date(value, ft);
4603 if (!ret)
4604 ERR("unexpected date format %s\n", debugstr_w(value));
4605 }
4606 }
4607 else
4608 {
4609 ret = HTTP_ParseDateAsAsctime(value, ft);
4610 if (!ret)
4611 ERR("unexpected date format %s\n", debugstr_w(value));
4612 }
4613 return ret;
4614 }
4615
4616 static void HTTP_ProcessExpires(http_request_t *request)
4617 {
4618 BOOL expirationFound = FALSE;
4619 int headerIndex;
4620
4621 EnterCriticalSection( &request->headers_section );
4622
4623 /* Look for a Cache-Control header with a max-age directive, as it takes
4624 * precedence over the Expires header.
4625 */
4626 headerIndex = HTTP_GetCustomHeaderIndex(request, szCache_Control, 0, FALSE);
4627 if (headerIndex != -1)
4628 {
4629 LPHTTPHEADERW ccHeader = &request->custHeaders[headerIndex];
4630 LPWSTR ptr;
4631
4632 for (ptr = ccHeader->lpszValue; ptr && *ptr; )
4633 {
4634 LPWSTR comma = strchrW(ptr, ','), end, equal;
4635
4636 if (comma)
4637 end = comma;
4638 else
4639 end = ptr + strlenW(ptr);
4640 for (equal = end - 1; equal > ptr && *equal != '='; equal--)
4641 ;
4642 if (*equal == '=')
4643 {
4644 static const WCHAR max_age[] = {
4645 'm','a','x','-','a','g','e',0 };
4646
4647 if (!strncmpiW(ptr, max_age, equal - ptr - 1))
4648 {
4649 LPWSTR nextPtr;
4650 unsigned long age;
4651
4652 age = strtoulW(equal + 1, &nextPtr, 10);
4653 if (nextPtr > equal + 1)
4654 {
4655 LARGE_INTEGER ft;
4656
4657 NtQuerySystemTime( &ft );
4658 /* Age is in seconds, FILETIME resolution is in
4659 * 100 nanosecond intervals.
4660 */
4661 ft.QuadPart += age * (ULONGLONG)1000000;
4662 request->expires.dwLowDateTime = ft.u.LowPart;
4663 request->expires.dwHighDateTime = ft.u.HighPart;
4664 expirationFound = TRUE;
4665 }
4666 }
4667 }
4668 if (comma)
4669 {
4670 ptr = comma + 1;
4671 while (isspaceW(*ptr))
4672 ptr++;
4673 }
4674 else
4675 ptr = NULL;
4676 }
4677 }
4678 if (!expirationFound)
4679 {
4680 headerIndex = HTTP_GetCustomHeaderIndex(request, szExpires, 0, FALSE);
4681 if (headerIndex != -1)
4682 {
4683 LPHTTPHEADERW expiresHeader = &request->custHeaders[headerIndex];
4684 FILETIME ft;
4685
4686 if (HTTP_ParseDate(expiresHeader->lpszValue, &ft))
4687 {
4688 expirationFound = TRUE;
4689 request->expires = ft;
4690 }
4691 }
4692 }
4693 if (!expirationFound)
4694 {
4695 LARGE_INTEGER t;
4696
4697 /* With no known age, default to 10 minutes until expiration. */
4698 NtQuerySystemTime( &t );
4699 t.QuadPart += 10 * 60 * (ULONGLONG)10000000;
4700 request->expires.dwLowDateTime = t.u.LowPart;
4701 request->expires.dwHighDateTime = t.u.HighPart;
4702 }
4703
4704 LeaveCriticalSection( &request->headers_section );
4705 }
4706
4707 static void HTTP_ProcessLastModified(http_request_t *request)
4708 {
4709 int headerIndex;
4710
4711 EnterCriticalSection( &request->headers_section );
4712
4713 headerIndex = HTTP_GetCustomHeaderIndex(request, szLast_Modified, 0, FALSE);
4714 if (headerIndex != -1)
4715 {
4716 LPHTTPHEADERW expiresHeader = &request->custHeaders[headerIndex];
4717 FILETIME ft;
4718
4719 if (HTTP_ParseDate(expiresHeader->lpszValue, &ft))
4720 request->last_modified = ft;
4721 }
4722
4723 LeaveCriticalSection( &request->headers_section );
4724 }
4725
4726 static void http_process_keep_alive(http_request_t *req)
4727 {
4728 int index;
4729
4730 EnterCriticalSection( &req->headers_section );
4731
4732 if ((index = HTTP_GetCustomHeaderIndex(req, szConnection, 0, FALSE)) != -1)
4733 req->netconn->keep_alive = !strcmpiW(req->custHeaders[index].lpszValue, szKeepAlive);
4734 else if ((index = HTTP_GetCustomHeaderIndex(req, szProxy_Connection, 0, FALSE)) != -1)
4735 req->netconn->keep_alive = !strcmpiW(req->custHeaders[index].lpszValue, szKeepAlive);
4736 else
4737 req->netconn->keep_alive = !strcmpiW(req->version, g_szHttp1_1);
4738
4739 LeaveCriticalSection( &req->headers_section );
4740 }
4741
4742 static DWORD open_http_connection(http_request_t *request, BOOL *reusing)
4743 {
4744 const BOOL is_https = (request->hdr.dwFlags & INTERNET_FLAG_SECURE) != 0;
4745 netconn_t *netconn = NULL;
4746 DWORD res;
4747
4748 if (request->netconn)
4749 {
4750 if (NETCON_is_alive(request->netconn) && drain_content(request, TRUE) == ERROR_SUCCESS)
4751 {
4752 reset_data_stream(request);
4753 *reusing = TRUE;
4754 return ERROR_SUCCESS;
4755 }
4756
4757 TRACE("freeing netconn\n");
4758 free_netconn(request->netconn);
4759 request->netconn = NULL;
4760 }
4761
4762 reset_data_stream(request);
4763
4764 res = HTTP_ResolveName(request);
4765 if(res != ERROR_SUCCESS)
4766 return res;
4767
4768 EnterCriticalSection(&connection_pool_cs);
4769
4770 while(!list_empty(&request->server->conn_pool)) {
4771 netconn = LIST_ENTRY(list_head(&request->server->conn_pool), netconn_t, pool_entry);
4772 list_remove(&netconn->pool_entry);
4773
4774 if(is_valid_netconn(netconn) && NETCON_is_alive(netconn))
4775 break;
4776
4777 TRACE("connection %p closed during idle\n", netconn);
4778 free_netconn(netconn);
4779 netconn = NULL;
4780 }
4781
4782 LeaveCriticalSection(&connection_pool_cs);
4783
4784 if(netconn) {
4785 TRACE("<-- reusing %p netconn\n", netconn);
4786 request->netconn = netconn;
4787 *reusing = TRUE;
4788 return ERROR_SUCCESS;
4789 }
4790
4791 TRACE("connecting to %s, proxy %s\n", debugstr_w(request->server->name),
4792 request->proxy ? debugstr_w(request->proxy->name) : "(null)");
4793
4794 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4795 INTERNET_STATUS_CONNECTING_TO_SERVER,
4796 request->server->addr_str,
4797 strlen(request->server->addr_str)+1);
4798
4799 res = create_netconn(is_https, request->proxy ? request->proxy : request->server, request->security_flags,
4800 (request->hdr.ErrorMask & INTERNET_ERROR_MASK_COMBINED_SEC_CERT) != 0,
4801 request->connect_timeout, &netconn);
4802 if(res != ERROR_SUCCESS) {
4803 ERR("create_netconn failed: %u\n", res);
4804 return res;
4805 }
4806
4807 request->netconn = netconn;
4808
4809 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4810 INTERNET_STATUS_CONNECTED_TO_SERVER,
4811 request->server->addr_str, strlen(request->server->addr_str)+1);
4812
4813 *reusing = FALSE;
4814 TRACE("Created connection to %s: %p\n", debugstr_w(request->server->name), netconn);
4815 return ERROR_SUCCESS;
4816 }
4817
4818 static char *build_ascii_request( const WCHAR *str, void *data, DWORD data_len, DWORD *out_len )
4819 {
4820 int len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
4821 char *ret;
4822
4823 if (!(ret = heap_alloc( len + data_len ))) return NULL;
4824 WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
4825 if (data_len) memcpy( ret + len - 1, data, data_len );
4826 *out_len = len + data_len - 1;
4827 ret[*out_len] = 0;
4828 return ret;
4829 }
4830
4831 static void set_content_length_header( http_request_t *request, DWORD len, DWORD flags )
4832 {
4833 static const WCHAR fmtW[] =
4834 {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',':',' ','%','u','\r','\n',0};
4835 WCHAR buf[sizeof(fmtW)/sizeof(fmtW[0]) + 10];
4836
4837 sprintfW( buf, fmtW, len );
4838 HTTP_HttpAddRequestHeadersW( request, buf, ~0u, flags );
4839 }
4840
4841 /***********************************************************************
4842 * HTTP_HttpSendRequestW (internal)
4843 *
4844 * Sends the specified request to the HTTP server
4845 *
4846 * RETURNS
4847 * ERROR_SUCCESS on success
4848 * win32 error code on failure
4849 *
4850 */
4851 static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders,
4852 DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength,
4853 DWORD dwContentLength, BOOL bEndRequest)
4854 {
4855 BOOL redirected = FALSE, secure_proxy_connect = FALSE, loop_next;
4856 LPWSTR requestString = NULL;
4857 INT responseLen, cnt;
4858 DWORD res;
4859
4860 TRACE("--> %p\n", request);
4861
4862 assert(request->hdr.htype == WH_HHTTPREQ);
4863
4864 /* if the verb is NULL default to GET */
4865 if (!request->verb)
4866 request->verb = heap_strdupW(szGET);
4867
4868 HTTP_ProcessHeader(request, hostW, request->server->canon_host_port,
4869 HTTP_ADDREQ_FLAG_ADD_IF_NEW | HTTP_ADDHDR_FLAG_REQ);
4870
4871 if (dwContentLength || strcmpW(request->verb, szGET))
4872 {
4873 set_content_length_header(request, dwContentLength, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4874 request->bytesToWrite = dwContentLength;
4875 }
4876 if (request->session->appInfo->agent)
4877 {
4878 WCHAR *agent_header;
4879 static const WCHAR user_agent[] = {'U','s','e','r','-','A','g','e','n','t',':',' ','%','s','\r','\n',0};
4880 int len;
4881
4882 len = strlenW(request->session->appInfo->agent) + strlenW(user_agent);
4883 agent_header = heap_alloc(len * sizeof(WCHAR));
4884 sprintfW(agent_header, user_agent, request->session->appInfo->agent);
4885
4886 HTTP_HttpAddRequestHeadersW(request, agent_header, strlenW(agent_header), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4887 heap_free(agent_header);
4888 }
4889 if (request->hdr.dwFlags & INTERNET_FLAG_PRAGMA_NOCACHE)
4890 {
4891 static const WCHAR pragma_nocache[] = {'P','r','a','g','m','a',':',' ','n','o','-','c','a','c','h','e','\r','\n',0};
4892 HTTP_HttpAddRequestHeadersW(request, pragma_nocache, strlenW(pragma_nocache), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4893 }
4894 if ((request->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && strcmpW(request->verb, szGET))
4895 {
4896 static const WCHAR cache_control[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',':',
4897 ' ','n','o','-','c','a','c','h','e','\r','\n',0};
4898 HTTP_HttpAddRequestHeadersW(request, cache_control, strlenW(cache_control), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4899 }
4900
4901 /* add the headers the caller supplied */
4902 if( lpszHeaders && dwHeaderLength )
4903 HTTP_HttpAddRequestHeadersW(request, lpszHeaders, dwHeaderLength, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE);
4904
4905 do
4906 {
4907 DWORD len, data_len = dwOptionalLength;
4908 BOOL reusing_connection;
4909 char *ascii_req;
4910
4911 loop_next = FALSE;
4912
4913 if(redirected) {
4914 request->contentLength = ~0u;
4915 request->bytesToWrite = 0;
4916 }
4917
4918 if (TRACE_ON(wininet))
4919 {
4920 HTTPHEADERW *host;
4921
4922 EnterCriticalSection( &request->headers_section );
4923 host = HTTP_GetHeader( request, hostW );
4924 TRACE("Going to url %s %s\n", debugstr_w(host->lpszValue), debugstr_w(request->path));
4925 LeaveCriticalSection( &request->headers_section );
4926 }
4927
4928 HTTP_FixURL(request);
4929 if (request->hdr.dwFlags & INTERNET_FLAG_KEEP_CONNECTION)
4930 {
4931 HTTP_ProcessHeader(request, szConnection, szKeepAlive,
4932 HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD);
4933 }
4934 HTTP_InsertAuthorization(request, request->authInfo, szAuthorization);
4935 HTTP_InsertAuthorization(request, request->proxyAuthInfo, szProxy_Authorization);
4936
4937 if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES))
4938 HTTP_InsertCookies(request);
4939
4940 res = open_http_connection(request, &reusing_connection);
4941 if (res != ERROR_SUCCESS)
4942 break;
4943
4944 if (!reusing_connection && (request->hdr.dwFlags & INTERNET_FLAG_SECURE))
4945 {
4946 if (request->proxy) secure_proxy_connect = TRUE;
4947 else
4948 {
4949 res = NETCON_secure_connect(request->netconn, request->server);
4950 if (res != ERROR_SUCCESS)
4951 {
4952 WARN("failed to upgrade to secure connection\n");
4953 http_release_netconn(request, FALSE);
4954 break;
4955 }
4956 }
4957 }
4958 if (secure_proxy_connect)
4959 {
4960 static const WCHAR connectW[] = {'C','O','N','N','E','C','T',0};
4961 const WCHAR *target = request->server->host_port;
4962
4963 if (HTTP_GetCustomHeaderIndex(request, szContent_Length, 0, TRUE) >= 0)
4964 set_content_length_header(request, 0, HTTP_ADDREQ_FLAG_REPLACE);
4965
4966 requestString = build_request_header(request, connectW, target, g_szHttp1_1, TRUE);
4967 }
4968 else if (request->proxy && !(request->hdr.dwFlags & INTERNET_FLAG_SECURE))
4969 {
4970 WCHAR *url = build_proxy_path_url(request);
4971 requestString = build_request_header(request, request->verb, url, request->version, TRUE);
4972 heap_free(url);
4973 }
4974 else
4975 {
4976 if (request->proxy && HTTP_GetCustomHeaderIndex(request, szContent_Length, 0, TRUE) >= 0)
4977 set_content_length_header(request, dwContentLength, HTTP_ADDREQ_FLAG_REPLACE);
4978
4979 requestString = build_request_header(request, request->verb, request->path, request->version, TRUE);
4980 }
4981
4982 TRACE("Request header -> %s\n", debugstr_w(requestString) );
4983
4984 /* send the request as ASCII, tack on the optional data */
4985 if (!lpOptional || redirected || secure_proxy_connect)
4986 data_len = 0;
4987
4988 ascii_req = build_ascii_request( requestString, lpOptional, data_len, &len );
4989 TRACE("full request -> %s\n", debugstr_a(ascii_req) );
4990
4991 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4992 INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
4993
4994 NETCON_set_timeout( request->netconn, TRUE, request->send_timeout );
4995 res = NETCON_send(request->netconn, ascii_req, len, 0, &cnt);
4996 heap_free( ascii_req );
4997 if(res != ERROR_SUCCESS) {
4998 TRACE("send failed: %u\n", res);
4999 if(!reusing_connection)
5000 break;
5001 http_release_netconn(request, FALSE);
5002 loop_next = TRUE;
5003 continue;
5004 }
5005
5006 request->bytesWritten = data_len;
5007
5008 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
5009 INTERNET_STATUS_REQUEST_SENT,
5010 &len, sizeof(DWORD));
5011
5012 if (bEndRequest)
5013 {
5014 DWORD dwBufferSize;
5015
5016 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
5017 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
5018
5019 if (HTTP_GetResponseHeaders(request, &responseLen))
5020 {
5021 http_release_netconn(request, FALSE);
5022 res = ERROR_INTERNET_CONNECTION_ABORTED;
5023 goto lend;
5024 }
5025 /* FIXME: We should know that connection is closed before sending
5026 * headers. Otherwise wrong callbacks are executed */
5027 if(!responseLen && reusing_connection) {
5028 TRACE("Connection closed by server, reconnecting\n");
5029 http_release_netconn(request, FALSE);
5030 loop_next = TRUE;
5031 continue;
5032 }
5033
5034 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
5035 INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen,
5036 sizeof(DWORD));
5037
5038 http_process_keep_alive(request);
5039 HTTP_ProcessCookies(request);
5040 HTTP_ProcessExpires(request);
5041 HTTP_ProcessLastModified(request);
5042
5043 res = set_content_length(request);
5044 if(res != ERROR_SUCCESS)
5045 goto lend;
5046 if(!request->contentLength)
5047 http_release_netconn(request, TRUE);
5048
5049 if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT) && responseLen)
5050 {
5051 WCHAR *new_url;
5052
5053 switch(request->status_code) {
5054 case HTTP_STATUS_REDIRECT:
5055 case HTTP_STATUS_MOVED:
5056 case HTTP_STATUS_REDIRECT_KEEP_VERB:
5057 case HTTP_STATUS_REDIRECT_METHOD:
5058 new_url = get_redirect_url(request);
5059 if(!new_url)
5060 break;
5061
5062 if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD) &&
5063 request->status_code != HTTP_STATUS_REDIRECT_KEEP_VERB)
5064 {
5065 heap_free(request->verb);
5066 request->verb = heap_strdupW(szGET);
5067 }
5068 http_release_netconn(request, drain_content(request, FALSE) == ERROR_SUCCESS);
5069 res = HTTP_HandleRedirect(request, new_url);
5070 heap_free(new_url);
5071 if (res == ERROR_SUCCESS) {
5072 heap_free(requestString);
5073 loop_next = TRUE;
5074 }
5075 redirected = TRUE;
5076 }
5077 }
5078 if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTH) && res == ERROR_SUCCESS)
5079 {
5080 WCHAR szAuthValue[2048];
5081 dwBufferSize=2048;
5082 if (request->status_code == HTTP_STATUS_DENIED)
5083 {
5084 WCHAR *host = heap_strdupW( request->server->canon_host_port );
5085 DWORD dwIndex = 0;
5086 while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_WWW_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS)
5087 {
5088 if (HTTP_DoAuthorization(request, szAuthValue,
5089 &request->authInfo,
5090 request->session->userName,
5091 request->session->password, host))
5092 {
5093 heap_free(requestString);
5094 if (drain_content(request, TRUE) != ERROR_SUCCESS)
5095 {
5096 FIXME("Could not drain content\n");
5097 http_release_netconn(request, FALSE);
5098 }
5099 loop_next = TRUE;
5100 break;
5101 }
5102 }
5103 heap_free( host );
5104
5105 if(!loop_next) {
5106 TRACE("Cleaning wrong authorization data\n");
5107 destroy_authinfo(request->authInfo);
5108 request->authInfo = NULL;
5109 }
5110 }
5111 if (request->status_code == HTTP_STATUS_PROXY_AUTH_REQ)
5112 {
5113 DWORD dwIndex = 0;
5114 while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_PROXY_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS)
5115 {
5116 if (HTTP_DoAuthorization(request, szAuthValue,
5117 &request->proxyAuthInfo,
5118 request->session->appInfo->proxyUsername,
5119 request->session->appInfo->proxyPassword,
5120 NULL))
5121 {
5122 heap_free(requestString);
5123 if (drain_content(request, TRUE) != ERROR_SUCCESS)
5124 {
5125 FIXME("Could not drain content\n");
5126 http_release_netconn(request, FALSE);
5127 }
5128 loop_next = TRUE;
5129 break;
5130 }
5131 }
5132
5133 if(!loop_next) {
5134 TRACE("Cleaning wrong proxy authorization data\n");
5135 destroy_authinfo(request->proxyAuthInfo);
5136 request->proxyAuthInfo = NULL;
5137 }
5138 }
5139 }
5140 if (secure_proxy_connect && request->status_code == HTTP_STATUS_OK)
5141 {
5142 res = NETCON_secure_connect(request->netconn, request->server);
5143 if (res != ERROR_SUCCESS)
5144 {
5145 WARN("failed to upgrade to secure proxy connection\n");
5146 http_release_netconn( request, FALSE );
5147 break;
5148 }
5149 remove_header(request, szProxy_Authorization, TRUE);
5150 destroy_authinfo(request->proxyAuthInfo);
5151 request->proxyAuthInfo = NULL;
5152
5153 secure_proxy_connect = FALSE;
5154 loop_next = TRUE;
5155 }
5156 }
5157 else
5158 res = ERROR_SUCCESS;
5159 }
5160 while (loop_next);
5161
5162 lend:
5163 heap_free(requestString);
5164
5165 /* TODO: send notification for P3P header */
5166
5167 if(res == ERROR_SUCCESS)
5168 create_cache_entry(request);
5169
5170 if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5171 {
5172 if (res == ERROR_SUCCESS) {
5173 if(bEndRequest && request->contentLength && request->bytesWritten == request->bytesToWrite)
5174 HTTP_ReceiveRequestData(request);
5175 else
5176 send_request_complete(request,
5177 request->session->hdr.dwInternalFlags & INET_OPENURL ? (DWORD_PTR)request->hdr.hInternet : 1, 0);
5178 }else {
5179 send_request_complete(request, 0, res);
5180 }
5181 }
5182
5183 TRACE("<--\n");
5184 return res;
5185 }
5186
5187 typedef struct {
5188 task_header_t hdr;
5189 WCHAR *headers;
5190 DWORD headers_len;
5191 void *optional;
5192 DWORD optional_len;
5193 DWORD content_len;
5194 BOOL end_request;
5195 } send_request_task_t;
5196
5197 /***********************************************************************
5198 *
5199 * Helper functions for the HttpSendRequest(Ex) functions
5200 *
5201 */
5202 static void AsyncHttpSendRequestProc(task_header_t *hdr)
5203 {
5204 send_request_task_t *task = (send_request_task_t*)hdr;
5205 http_request_t *request = (http_request_t*)task->hdr.hdr;
5206
5207 TRACE("%p\n", request);
5208
5209 HTTP_HttpSendRequestW(request, task->headers, task->headers_len, task->optional,
5210 task->optional_len, task->content_len, task->end_request);
5211
5212 heap_free(task->headers);
5213 }
5214
5215
5216 static DWORD HTTP_HttpEndRequestW(http_request_t *request, DWORD dwFlags, DWORD_PTR dwContext)
5217 {
5218 INT responseLen;
5219 DWORD res = ERROR_SUCCESS;
5220
5221 if(!is_valid_netconn(request->netconn)) {
5222 WARN("Not connected\n");
5223 send_request_complete(request, 0, ERROR_INTERNET_OPERATION_CANCELLED);
5224 return ERROR_INTERNET_OPERATION_CANCELLED;
5225 }
5226
5227 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
5228 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
5229
5230 if (HTTP_GetResponseHeaders(request, &responseLen) || !responseLen)
5231 res = ERROR_HTTP_HEADER_NOT_FOUND;
5232
5233 INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
5234 INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen, sizeof(DWORD));
5235
5236 /* process cookies here. Is this right? */
5237 http_process_keep_alive(request);
5238 HTTP_ProcessCookies(request);
5239 HTTP_ProcessExpires(request);
5240 HTTP_ProcessLastModified(request);
5241
5242 if ((res = set_content_length(request)) == ERROR_SUCCESS) {
5243 if(!request->contentLength)
5244 http_release_netconn(request, TRUE);
5245 }
5246
5247 if (res == ERROR_SUCCESS && !(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT))
5248 {
5249 switch(request->status_code) {
5250 case HTTP_STATUS_REDIRECT:
5251 case HTTP_STATUS_MOVED:
5252 case HTTP_STATUS_REDIRECT_METHOD:
5253 case HTTP_STATUS_REDIRECT_KEEP_VERB: {
5254 WCHAR *new_url;
5255
5256 new_url = get_redirect_url(request);
5257 if(!new_url)
5258 break;
5259
5260 if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD) &&
5261 request->status_code != HTTP_STATUS_REDIRECT_KEEP_VERB)
5262 {
5263 heap_free(request->verb);
5264 request->verb = heap_strdupW(szGET);
5265 }
5266 http_release_netconn(request, drain_content(request, FALSE) == ERROR_SUCCESS);
5267 res = HTTP_HandleRedirect(request, new_url);
5268 heap_free(new_url);
5269 if (res == ERROR_SUCCESS)
5270 res = HTTP_HttpSendRequestW(request, NULL, 0, NULL, 0, 0, TRUE);
5271 }
5272 }
5273 }
5274
5275 if(res == ERROR_SUCCESS)
5276 create_cache_entry(request);
5277
5278 if (res == ERROR_SUCCESS && request->contentLength)
5279 HTTP_ReceiveRequestData(request);
5280 else
5281 send_request_complete(request, res == ERROR_SUCCESS, res);
5282
5283 return res;
5284 }
5285
5286 /***********************************************************************
5287 * HttpEndRequestA (WININET.@)
5288 *
5289 * Ends an HTTP request that was started by HttpSendRequestEx
5290 *
5291 * RETURNS
5292 * TRUE if successful
5293 * FALSE on failure
5294 *
5295 */
5296 BOOL WINAPI HttpEndRequestA(HINTERNET hRequest,
5297 LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
5298 {
5299 TRACE("(%p, %p, %08x, %08lx)\n", hRequest, lpBuffersOut, dwFlags, dwContext);
5300
5301 if (lpBuffersOut)
5302 {
5303 SetLastError(ERROR_INVALID_PARAMETER);
5304 return FALSE;
5305 }
5306
5307 return HttpEndRequestW(hRequest, NULL, dwFlags, dwContext);
5308 }
5309
5310 typedef struct {
5311 task_header_t hdr;
5312 DWORD flags;
5313 DWORD context;
5314 } end_request_task_t;
5315
5316 static void AsyncHttpEndRequestProc(task_header_t *hdr)
5317 {
5318 end_request_task_t *task = (end_request_task_t*)hdr;
5319 http_request_t *req = (http_request_t*)task->hdr.hdr;
5320
5321 TRACE("%p\n", req);
5322
5323 HTTP_HttpEndRequestW(req, task->flags, task->context);
5324 }
5325
5326 /***********************************************************************
5327 * HttpEndRequestW (WININET.@)
5328 *
5329 * Ends an HTTP request that was started by HttpSendRequestEx
5330 *
5331 * RETURNS
5332 * TRUE if successful
5333 * FALSE on failure
5334 *
5335 */
5336 BOOL WINAPI HttpEndRequestW(HINTERNET hRequest,
5337 LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
5338 {
5339 http_request_t *request;
5340 DWORD res;
5341
5342 TRACE("%p %p %x %lx -->\n", hRequest, lpBuffersOut, dwFlags, dwContext);
5343
5344 if (lpBuffersOut)
5345 {
5346 SetLastError(ERROR_INVALID_PARAMETER);
5347 return FALSE;
5348 }
5349
5350 request = (http_request_t*) get_handle_object( hRequest );
5351
5352 if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
5353 {
5354 SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
5355 if (request)
5356 WININET_Release( &request->hdr );
5357 return FALSE;
5358 }
5359 request->hdr.dwFlags |= dwFlags;
5360
5361 if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5362 {
5363 end_request_task_t *task;
5364
5365 task = alloc_async_task(&request->hdr, AsyncHttpEndRequestProc, sizeof(*task));
5366 task->flags = dwFlags;
5367 task->context = dwContext;
5368
5369 INTERNET_AsyncCall(&task->hdr);
5370 res = ERROR_IO_PENDING;
5371 }
5372 else
5373 res = HTTP_HttpEndRequestW(request, dwFlags, dwContext);
5374
5375 WININET_Release( &request->hdr );
5376 TRACE("%u <--\n", res);
5377 if(res != ERROR_SUCCESS)
5378 SetLastError(res);
5379 return res == ERROR_SUCCESS;
5380 }
5381
5382 /***********************************************************************
5383 * HttpSendRequestExA (WININET.@)
5384 *
5385 * Sends the specified request to the HTTP server and allows chunked
5386 * transfers.
5387 *
5388 * RETURNS
5389 * Success: TRUE
5390 * Failure: FALSE, call GetLastError() for more information.
5391 */
5392 BOOL WINAPI HttpSendRequestExA(HINTERNET hRequest,
5393 LPINTERNET_BUFFERSA lpBuffersIn,
5394 LPINTERNET_BUFFERSA lpBuffersOut,
5395 DWORD dwFlags, DWORD_PTR dwContext)
5396 {
5397 INTERNET_BUFFERSW BuffersInW;
5398 BOOL rc = FALSE;
5399 DWORD headerlen;
5400 LPWSTR header = NULL;
5401
5402 TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
5403 lpBuffersOut, dwFlags, dwContext);
5404
5405 if (lpBuffersIn)
5406 {
5407 BuffersInW.dwStructSize = sizeof(LPINTERNET_BUFFERSW);
5408 if (lpBuffersIn->lpcszHeader)
5409 {
5410 headerlen = MultiByteToWideChar(CP_ACP,0,lpBuffersIn->lpcszHeader,
5411 lpBuffersIn->dwHeadersLength,0,0);
5412 header = heap_alloc(headerlen*sizeof(WCHAR));
5413 if (!(BuffersInW.lpcszHeader = header))
5414 {
5415 SetLastError(ERROR_OUTOFMEMORY);
5416 return FALSE;
5417 }
5418 BuffersInW.dwHeadersLength = MultiByteToWideChar(CP_ACP, 0,
5419 lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
5420 header, headerlen);
5421 }
5422 else
5423 BuffersInW.lpcszHeader = NULL;
5424 BuffersInW.dwHeadersTotal = lpBuffersIn->dwHeadersTotal;
5425 BuffersInW.lpvBuffer = lpBuffersIn->lpvBuffer;
5426 BuffersInW.dwBufferLength = lpBuffersIn->dwBufferLength;
5427 BuffersInW.dwBufferTotal = lpBuffersIn->dwBufferTotal;
5428 BuffersInW.Next = NULL;
5429 }
5430
5431 rc = HttpSendRequestExW(hRequest, lpBuffersIn ? &BuffersInW : NULL, NULL, dwFlags, dwContext);
5432
5433 heap_free(header);
5434 return rc;
5435 }
5436
5437 /***********************************************************************
5438 * HttpSendRequestExW (WININET.@)
5439 *
5440 * Sends the specified request to the HTTP server and allows chunked
5441 * transfers
5442 *
5443 * RETURNS
5444 * Success: TRUE
5445 * Failure: FALSE, call GetLastError() for more information.
5446 */
5447 BOOL WINAPI HttpSendRequestExW(HINTERNET hRequest,
5448 LPINTERNET_BUFFERSW lpBuffersIn,
5449 LPINTERNET_BUFFERSW lpBuffersOut,
5450 DWORD dwFlags, DWORD_PTR dwContext)
5451 {
5452 http_request_t *request;
5453 http_session_t *session;
5454 appinfo_t *hIC;
5455 DWORD res;
5456
5457 TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
5458 lpBuffersOut, dwFlags, dwContext);
5459
5460 request = (http_request_t*) get_handle_object( hRequest );
5461
5462 if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
5463 {
5464 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5465 goto lend;
5466 }
5467
5468 session = request->session;
5469 assert(session->hdr.htype == WH_HHTTPSESSION);
5470 hIC = session->appInfo;
5471 assert(hIC->hdr.htype == WH_HINIT);
5472
5473 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5474 {
5475 send_request_task_t *task;
5476
5477 task = alloc_async_task(&request->hdr, AsyncHttpSendRequestProc, sizeof(*task));
5478 if (lpBuffersIn)
5479 {
5480 DWORD size = 0;
5481
5482 if (lpBuffersIn->lpcszHeader)
5483 {
5484 if (lpBuffersIn->dwHeadersLength == ~0u)
5485 size = (strlenW( lpBuffersIn->lpcszHeader ) + 1) * sizeof(WCHAR);
5486 else
5487 size = lpBuffersIn->dwHeadersLength * sizeof(WCHAR);
5488
5489 task->headers = heap_alloc(size);
5490 memcpy(task->headers, lpBuffersIn->lpcszHeader, size);
5491 }
5492 else task->headers = NULL;
5493
5494 task->headers_len = size / sizeof(WCHAR);
5495 task->optional = lpBuffersIn->lpvBuffer;
5496 task->optional_len = lpBuffersIn->dwBufferLength;
5497 task->content_len = lpBuffersIn->dwBufferTotal;
5498 }
5499 else
5500 {
5501 task->headers = NULL;
5502 task->headers_len = 0;
5503 task->optional = NULL;
5504 task->optional_len = 0;
5505 task->content_len = 0;
5506 }
5507
5508 task->end_request = FALSE;
5509
5510 INTERNET_AsyncCall(&task->hdr);
5511 res = ERROR_IO_PENDING;
5512 }
5513 else
5514 {
5515 if (lpBuffersIn)
5516 res = HTTP_HttpSendRequestW(request, lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
5517 lpBuffersIn->lpvBuffer, lpBuffersIn->dwBufferLength,
5518 lpBuffersIn->dwBufferTotal, FALSE);
5519 else
5520 res = HTTP_HttpSendRequestW(request, NULL, 0, NULL, 0, 0, FALSE);
5521 }
5522
5523 lend:
5524 if ( request )
5525 WININET_Release( &request->hdr );
5526
5527 TRACE("<---\n");
5528 SetLastError(res);
5529 return res == ERROR_SUCCESS;
5530 }
5531
5532 /***********************************************************************
5533 * HttpSendRequestW (WININET.@)
5534 *
5535 * Sends the specified request to the HTTP server
5536 *
5537 * RETURNS
5538 * TRUE on success
5539 * FALSE on failure
5540 *
5541 */
5542 BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
5543 DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
5544 {
5545 http_request_t *request;
5546 http_session_t *session = NULL;
5547 appinfo_t *hIC = NULL;
5548 DWORD res = ERROR_SUCCESS;
5549
5550 TRACE("%p, %s, %i, %p, %i)\n", hHttpRequest,
5551 debugstr_wn(lpszHeaders, dwHeaderLength), dwHeaderLength, lpOptional, dwOptionalLength);
5552
5553 request = (http_request_t*) get_handle_object( hHttpRequest );
5554 if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
5555 {
5556 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5557 goto lend;
5558 }
5559
5560 session = request->session;
5561 if (NULL == session || session->hdr.htype != WH_HHTTPSESSION)
5562 {
5563 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5564 goto lend;
5565 }
5566
5567 hIC = session->appInfo;
5568 if (NULL == hIC || hIC->hdr.htype != WH_HINIT)
5569 {
5570 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5571 goto lend;
5572 }
5573
5574 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5575 {
5576 send_request_task_t *task;
5577
5578 task = alloc_async_task(&request->hdr, AsyncHttpSendRequestProc, sizeof(*task));
5579 if (lpszHeaders)
5580 {
5581 DWORD size;
5582
5583 if (dwHeaderLength == ~0u) size = (strlenW(lpszHeaders) + 1) * sizeof(WCHAR);
5584 else size = dwHeaderLength * sizeof(WCHAR);
5585
5586 task->headers = heap_alloc(size);
5587 memcpy(task->headers, lpszHeaders, size);
5588 }
5589 else
5590 task->headers = NULL;
5591 task->headers_len = dwHeaderLength;
5592 task->optional = lpOptional;
5593 task->optional_len = dwOptionalLength;
5594 task->content_len = dwOptionalLength;
5595 task->end_request = TRUE;
5596
5597 INTERNET_AsyncCall(&task->hdr);
5598 res = ERROR_IO_PENDING;
5599 }
5600 else
5601 {
5602 res = HTTP_HttpSendRequestW(request, lpszHeaders,
5603 dwHeaderLength, lpOptional, dwOptionalLength,
5604 dwOptionalLength, TRUE);
5605 }
5606 lend:
5607 if( request )
5608 WININET_Release( &request->hdr );
5609
5610 SetLastError(res);
5611 return res == ERROR_SUCCESS;
5612 }
5613
5614 /***********************************************************************
5615 * HttpSendRequestA (WININET.@)
5616 *
5617 * Sends the specified request to the HTTP server
5618 *
5619 * RETURNS
5620 * TRUE on success
5621 * FALSE on failure
5622 *
5623 */
5624 BOOL WINAPI HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
5625 DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
5626 {
5627 BOOL result;
5628 LPWSTR szHeaders=NULL;
5629 DWORD nLen=dwHeaderLength;
5630 if(lpszHeaders!=NULL)
5631 {
5632 nLen=MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,NULL,0);
5633 szHeaders = heap_alloc(nLen*sizeof(WCHAR));
5634 MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,szHeaders,nLen);
5635 }
5636 result = HttpSendRequestW(hHttpRequest, szHeaders, nLen, lpOptional, dwOptionalLength);
5637 heap_free(szHeaders);
5638 return result;
5639 }
5640
5641 /***********************************************************************
5642 * HTTPSESSION_Destroy (internal)
5643 *
5644 * Deallocate session handle
5645 *
5646 */
5647 static void HTTPSESSION_Destroy(object_header_t *hdr)
5648 {
5649 http_session_t *session = (http_session_t*) hdr;
5650
5651 TRACE("%p\n", session);
5652
5653 WININET_Release(&session->appInfo->hdr);
5654
5655 heap_free(session->hostName);
5656 heap_free(session->password);
5657 heap_free(session->userName);
5658 }
5659
5660 static DWORD HTTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
5661 {
5662 http_session_t *ses = (http_session_t *)hdr;
5663
5664 switch(option) {
5665 case INTERNET_OPTION_HANDLE_TYPE:
5666 TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
5667
5668 if (*size < sizeof(ULONG))
5669 return ERROR_INSUFFICIENT_BUFFER;
5670
5671 *size = sizeof(DWORD);
5672 *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_HTTP;
5673 return ERROR_SUCCESS;
5674 case INTERNET_OPTION_CONNECT_TIMEOUT:
5675 TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
5676
5677 if (*size < sizeof(DWORD))
5678 return ERROR_INSUFFICIENT_BUFFER;
5679
5680 *size = sizeof(DWORD);
5681 *(DWORD *)buffer = ses->connect_timeout;
5682 return ERROR_SUCCESS;
5683
5684 case INTERNET_OPTION_SEND_TIMEOUT:
5685 TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
5686
5687 if (*size < sizeof(DWORD))
5688 return ERROR_INSUFFICIENT_BUFFER;
5689
5690 *size = sizeof(DWORD);
5691 *(DWORD *)buffer = ses->send_timeout;
5692 return ERROR_SUCCESS;
5693
5694 case INTERNET_OPTION_RECEIVE_TIMEOUT:
5695 TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
5696
5697 if (*size < sizeof(DWORD))
5698 return ERROR_INSUFFICIENT_BUFFER;
5699
5700 *size = sizeof(DWORD);
5701 *(DWORD *)buffer = ses->receive_timeout;
5702 return ERROR_SUCCESS;
5703 }
5704
5705 return INET_QueryOption(hdr, option, buffer, size, unicode);
5706 }
5707
5708 static DWORD HTTPSESSION_SetOption(object_header_t *hdr, DWORD option, void *buffer, DWORD size)
5709 {
5710 http_session_t *ses = (http_session_t*)hdr;
5711
5712 switch(option) {
5713 case INTERNET_OPTION_USERNAME:
5714 {
5715 heap_free(ses->userName);
5716 if (!(ses->userName = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5717 return ERROR_SUCCESS;
5718 }
5719 case INTERNET_OPTION_PASSWORD:
5720 {
5721 heap_free(ses->password);
5722 if (!(ses->password = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5723 return ERROR_SUCCESS;
5724 }
5725 case INTERNET_OPTION_PROXY_USERNAME:
5726 {
5727 heap_free(ses->appInfo->proxyUsername);
5728 if (!(ses->appInfo->proxyUsername = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5729 return ERROR_SUCCESS;
5730 }
5731 case INTERNET_OPTION_PROXY_PASSWORD:
5732 {
5733 heap_free(ses->appInfo->proxyPassword);
5734 if (!(ses->appInfo->proxyPassword = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5735 return ERROR_SUCCESS;
5736 }
5737 case INTERNET_OPTION_CONNECT_TIMEOUT:
5738 {
5739 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
5740 ses->connect_timeout = *(DWORD *)buffer;
5741 return ERROR_SUCCESS;
5742 }
5743 case INTERNET_OPTION_SEND_TIMEOUT:
5744 {
5745 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
5746 ses->send_timeout = *(DWORD *)buffer;
5747 return ERROR_SUCCESS;
5748 }
5749 case INTERNET_OPTION_RECEIVE_TIMEOUT:
5750 {
5751 if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
5752 ses->receive_timeout = *(DWORD *)buffer;
5753 return ERROR_SUCCESS;
5754 }
5755 default: break;
5756 }
5757
5758 return INET_SetOption(hdr, option, buffer, size);
5759 }
5760
5761 static const object_vtbl_t HTTPSESSIONVtbl = {
5762 HTTPSESSION_Destroy,
5763 NULL,
5764 HTTPSESSION_QueryOption,
5765 HTTPSESSION_SetOption,
5766 NULL,
5767 NULL,
5768 NULL,
5769 NULL
5770 };
5771
5772
5773 /***********************************************************************
5774 * HTTP_Connect (internal)
5775 *
5776 * Create http session handle
5777 *
5778 * RETURNS
5779 * HINTERNET a session handle on success
5780 * NULL on failure
5781 *
5782 */
5783 DWORD HTTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
5784 INTERNET_PORT serverPort, LPCWSTR lpszUserName,
5785 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
5786 DWORD dwInternalFlags, HINTERNET *ret)
5787 {
5788 http_session_t *session = NULL;
5789
5790 TRACE("-->\n");
5791
5792 if (!lpszServerName || !lpszServerName[0])
5793 return ERROR_INVALID_PARAMETER;
5794
5795 assert( hIC->hdr.htype == WH_HINIT );
5796
5797 session = alloc_object(&hIC->hdr, &HTTPSESSIONVtbl, sizeof(http_session_t));
5798 if (!session)
5799 return ERROR_OUTOFMEMORY;
5800
5801 /*
5802 * According to my tests. The name is not resolved until a request is sent
5803 */
5804
5805 session->hdr.htype = WH_HHTTPSESSION;
5806 session->hdr.dwFlags = dwFlags;
5807 session->hdr.dwContext = dwContext;
5808 session->hdr.dwInternalFlags |= dwInternalFlags;
5809
5810 WININET_AddRef( &hIC->hdr );
5811 session->appInfo = hIC;
5812 list_add_head( &hIC->hdr.children, &session->hdr.entry );
5813
5814 session->hostName = heap_strdupW(lpszServerName);
5815 if (lpszUserName && lpszUserName[0])
5816 session->userName = heap_strdupW(lpszUserName);
5817 if (lpszPassword && lpszPassword[0])
5818 session->password = heap_strdupW(lpszPassword);
5819 session->hostPort = serverPort;
5820 session->connect_timeout = hIC->connect_timeout;
5821 session->send_timeout = 0;
5822 session->receive_timeout = 0;
5823
5824 /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
5825 if (!(session->hdr.dwInternalFlags & INET_OPENURL))
5826 {
5827 INTERNET_SendCallback(&hIC->hdr, dwContext,
5828 INTERNET_STATUS_HANDLE_CREATED, &session->hdr.hInternet,
5829 sizeof(HINTERNET));
5830 }
5831
5832 /*
5833 * an INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
5834 * windows
5835 */
5836
5837 TRACE("%p --> %p\n", hIC, session);
5838
5839 *ret = session->hdr.hInternet;
5840 return ERROR_SUCCESS;
5841 }
5842
5843 /***********************************************************************
5844 * HTTP_clear_response_headers (internal)
5845 *
5846 * clear out any old response headers
5847 */
5848 static void HTTP_clear_response_headers( http_request_t *request )
5849 {
5850 DWORD i;
5851
5852 EnterCriticalSection( &request->headers_section );
5853
5854 for( i=0; i<request->nCustHeaders; i++)
5855 {
5856 if( !request->custHeaders[i].lpszField )
5857 continue;
5858 if( !request->custHeaders[i].lpszValue )
5859 continue;
5860 if ( request->custHeaders[i].wFlags & HDR_ISREQUEST )
5861 continue;
5862 HTTP_DeleteCustomHeader( request, i );
5863 i--;
5864 }
5865
5866 LeaveCriticalSection( &request->headers_section );
5867 }
5868
5869 /***********************************************************************
5870 * HTTP_GetResponseHeaders (internal)
5871 *
5872 * Read server response
5873 *
5874 * RETURNS
5875 *
5876 * TRUE on success
5877 * FALSE on error
5878 */
5879 static DWORD HTTP_GetResponseHeaders(http_request_t *request, INT *len)
5880 {
5881 INT cbreaks = 0;
5882 WCHAR buffer[MAX_REPLY_LEN];
5883 DWORD buflen = MAX_REPLY_LEN;
5884 INT rc = 0;
5885 char bufferA[MAX_REPLY_LEN];
5886 LPWSTR status_code = NULL, status_text = NULL;
5887 DWORD res = ERROR_HTTP_INVALID_SERVER_RESPONSE;
5888 BOOL codeHundred = FALSE;
5889
5890 TRACE("-->\n");
5891
5892 if(!is_valid_netconn(request->netconn))
5893 goto lend;
5894
5895 /* clear old response headers (eg. from a redirect response) */
5896 HTTP_clear_response_headers( request );
5897
5898 NETCON_set_timeout( request->netconn, FALSE, request->receive_timeout );
5899 do {
5900 /*
5901 * We should first receive 'HTTP/1.x nnn OK' where nnn is the status code.
5902 */
5903 buflen = MAX_REPLY_LEN;
5904 if ((res = read_line(request, bufferA, &buflen)))
5905 goto lend;
5906
5907 if (!buflen) goto lend;
5908
5909 rc += buflen;
5910 MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
5911 /* check is this a status code line? */
5912 if (!strncmpW(buffer, g_szHttp1_0, 4))
5913 {
5914 /* split the version from the status code */
5915 status_code = strchrW( buffer, ' ' );
5916 if( !status_code )
5917 goto lend;
5918 *status_code++=0;
5919
5920 /* split the status code from the status text */
5921 status_text = strchrW( status_code, ' ' );
5922 if( status_text )
5923 *status_text++=0;
5924
5925 request->status_code = atoiW(status_code);
5926
5927 TRACE("version [%s] status code [%s] status text [%s]\n",
5928 debugstr_w(buffer), debugstr_w(status_code), debugstr_w(status_text) );
5929
5930 codeHundred = request->status_code == HTTP_STATUS_CONTINUE;
5931 }
5932 else if (!codeHundred)
5933 {
5934 WARN("No status line at head of response (%s)\n", debugstr_w(buffer));
5935
5936 heap_free(request->version);
5937 heap_free(request->statusText);
5938
5939 request->status_code = HTTP_STATUS_OK;
5940 request->version = heap_strdupW(g_szHttp1_0);
5941 request->statusText = heap_strdupW(szOK);
5942
5943 goto lend;
5944 }
5945 } while (codeHundred);
5946
5947 /* Add status code */
5948 HTTP_ProcessHeader(request, szStatus, status_code,
5949 HTTP_ADDHDR_FLAG_REPLACE | HTTP_ADDHDR_FLAG_ADD);
5950
5951 heap_free(request->version);
5952 heap_free(request->statusText);
5953
5954 request->version = heap_strdupW(buffer);
5955 request->statusText = heap_strdupW(status_text ? status_text : emptyW);
5956
5957 /* Restore the spaces */
5958 *(status_code-1) = ' ';
5959 if (status_text)
5960 *(status_text-1) = ' ';
5961
5962 /* Parse each response line */
5963 do
5964 {
5965 buflen = MAX_REPLY_LEN;
5966 if (!read_line(request, bufferA, &buflen) && buflen)
5967 {
5968 LPWSTR * pFieldAndValue;
5969
5970 TRACE("got line %s, now interpreting\n", debugstr_a(bufferA));
5971
5972 if (!bufferA[0]) break;
5973 MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
5974
5975 pFieldAndValue = HTTP_InterpretHttpHeader(buffer);
5976 if (pFieldAndValue)
5977 {
5978 HTTP_ProcessHeader(request, pFieldAndValue[0], pFieldAndValue[1],
5979 HTTP_ADDREQ_FLAG_ADD );
5980 HTTP_FreeTokens(pFieldAndValue);
5981 }
5982 }
5983 else
5984 {
5985 cbreaks++;
5986 if (cbreaks >= 2)
5987 break;
5988 }
5989 }while(1);
5990
5991 res = ERROR_SUCCESS;
5992
5993 lend:
5994
5995 *len = rc;
5996 TRACE("<--\n");
5997 return res;
5998 }
5999
6000 /***********************************************************************
6001 * HTTP_InterpretHttpHeader (internal)
6002 *
6003 * Parse server response
6004 *
6005 * RETURNS
6006 *
6007 * Pointer to array of field, value, NULL on success.
6008 * NULL on error.
6009 */
6010 static LPWSTR * HTTP_InterpretHttpHeader(LPCWSTR buffer)
6011 {
6012 LPWSTR * pTokenPair;
6013 LPWSTR pszColon;
6014 INT len;
6015
6016 pTokenPair = heap_alloc_zero(sizeof(*pTokenPair)*3);
6017
6018 pszColon = strchrW(buffer, ':');
6019 /* must have two tokens */
6020 if (!pszColon)
6021 {
6022 HTTP_FreeTokens(pTokenPair);
6023 if (buffer[0])
6024 TRACE("No ':' in line: %s\n", debugstr_w(buffer));
6025 return NULL;
6026 }
6027
6028 pTokenPair[0] = heap_alloc((pszColon - buffer + 1) * sizeof(WCHAR));
6029 if (!pTokenPair[0])
6030 {
6031 HTTP_FreeTokens(pTokenPair);
6032 return NULL;
6033 }
6034 memcpy(pTokenPair[0], buffer, (pszColon - buffer) * sizeof(WCHAR));
6035 pTokenPair[0][pszColon - buffer] = '\0';
6036
6037 /* skip colon */
6038 pszColon++;
6039 len = strlenW(pszColon);
6040 pTokenPair[1] = heap_alloc((len + 1) * sizeof(WCHAR));
6041 if (!pTokenPair[1])
6042 {
6043 HTTP_FreeTokens(pTokenPair);
6044 return NULL;
6045 }
6046 memcpy(pTokenPair[1], pszColon, (len + 1) * sizeof(WCHAR));
6047
6048 strip_spaces(pTokenPair[0]);
6049 strip_spaces(pTokenPair[1]);
6050
6051 TRACE("field(%s) Value(%s)\n", debugstr_w(pTokenPair[0]), debugstr_w(pTokenPair[1]));
6052 return pTokenPair;
6053 }
6054
6055 /***********************************************************************
6056 * HTTP_ProcessHeader (internal)
6057 *
6058 * Stuff header into header tables according to <dwModifier>
6059 *
6060 */
6061
6062 #define COALESCEFLAGS (HTTP_ADDHDR_FLAG_COALESCE|HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
6063
6064 static DWORD HTTP_ProcessHeader(http_request_t *request, LPCWSTR field, LPCWSTR value, DWORD dwModifier)
6065 {
6066 LPHTTPHEADERW lphttpHdr = NULL;
6067 INT index;
6068 BOOL request_only = !!(dwModifier & HTTP_ADDHDR_FLAG_REQ);
6069 DWORD res = ERROR_HTTP_INVALID_HEADER;
6070
6071 TRACE("--> %s: %s - 0x%08x\n", debugstr_w(field), debugstr_w(value), dwModifier);
6072
6073 EnterCriticalSection( &request->headers_section );
6074
6075 /* REPLACE wins out over ADD */
6076 if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
6077 dwModifier &= ~HTTP_ADDHDR_FLAG_ADD;
6078
6079 if (dwModifier & HTTP_ADDHDR_FLAG_ADD)
6080 index = -1;
6081 else
6082 index = HTTP_GetCustomHeaderIndex(request, field, 0, request_only);
6083
6084 if (index >= 0)
6085 {
6086 if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW)
6087 {
6088 LeaveCriticalSection( &request->headers_section );
6089 return ERROR_HTTP_INVALID_HEADER;
6090 }
6091 lphttpHdr = &request->custHeaders[index];
6092 }
6093 else if (value)
6094 {
6095 HTTPHEADERW hdr;
6096
6097 hdr.lpszField = (LPWSTR)field;
6098 hdr.lpszValue = (LPWSTR)value;
6099 hdr.wFlags = hdr.wCount = 0;
6100
6101 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
6102 hdr.wFlags |= HDR_ISREQUEST;
6103
6104 res = HTTP_InsertCustomHeader(request, &hdr);
6105 LeaveCriticalSection( &request->headers_section );
6106 return res;
6107 }
6108 /* no value to delete */
6109 else
6110 {
6111 LeaveCriticalSection( &request->headers_section );
6112 return ERROR_SUCCESS;
6113 }
6114
6115 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
6116 lphttpHdr->wFlags |= HDR_ISREQUEST;
6117 else
6118 lphttpHdr->wFlags &= ~HDR_ISREQUEST;
6119
6120 if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
6121 {
6122 HTTP_DeleteCustomHeader( request, index );
6123
6124 if (value && value[0])
6125 {
6126 HTTPHEADERW hdr;
6127
6128 hdr.lpszField = (LPWSTR)field;
6129 hdr.lpszValue = (LPWSTR)value;
6130 hdr.wFlags = hdr.wCount = 0;
6131
6132 if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
6133 hdr.wFlags |= HDR_ISREQUEST;
6134
6135 res = HTTP_InsertCustomHeader(request, &hdr);
6136 LeaveCriticalSection( &request->headers_section );
6137 return res;
6138 }
6139
6140 LeaveCriticalSection( &request->headers_section );
6141 return ERROR_SUCCESS;
6142 }
6143 else if (dwModifier & COALESCEFLAGS)
6144 {
6145 LPWSTR lpsztmp;
6146 WCHAR ch = 0;
6147 INT len = 0;
6148 INT origlen = strlenW(lphttpHdr->lpszValue);
6149 INT valuelen = strlenW(value);
6150
6151 if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA)
6152 {
6153 ch = ',';
6154 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
6155 }
6156 else if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
6157 {
6158 ch = ';';
6159 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
6160 }
6161
6162 len = origlen + valuelen + ((ch > 0) ? 2 : 0);
6163
6164 lpsztmp = heap_realloc(lphttpHdr->lpszValue, (len+1)*sizeof(WCHAR));
6165 if (lpsztmp)
6166 {
6167 lphttpHdr->lpszValue = lpsztmp;
6168 /* FIXME: Increment lphttpHdr->wCount. Perhaps lpszValue should be an array */
6169 if (ch > 0)
6170 {
6171 lphttpHdr->lpszValue[origlen] = ch;
6172 origlen++;
6173 lphttpHdr->lpszValue[origlen] = ' ';
6174 origlen++;
6175 }
6176
6177 memcpy(&lphttpHdr->lpszValue[origlen], value, valuelen*sizeof(WCHAR));
6178 lphttpHdr->lpszValue[len] = '\0';
6179 res = ERROR_SUCCESS;
6180 }
6181 else
6182 {
6183 WARN("heap_realloc (%d bytes) failed\n",len+1);
6184 res = ERROR_OUTOFMEMORY;
6185 }
6186 }
6187 TRACE("<-- %d\n", res);
6188 LeaveCriticalSection( &request->headers_section );
6189 return res;
6190 }
6191
6192 /***********************************************************************
6193 * HTTP_GetCustomHeaderIndex (internal)
6194 *
6195 * Return index of custom header from header array
6196 * Headers section must be held
6197 */
6198 static INT HTTP_GetCustomHeaderIndex(http_request_t *request, LPCWSTR lpszField,
6199 int requested_index, BOOL request_only)
6200 {
6201 DWORD index;
6202
6203 TRACE("%s, %d, %d\n", debugstr_w(lpszField), requested_index, request_only);
6204
6205 for (index = 0; index < request->nCustHeaders; index++)
6206 {
6207 if (strcmpiW(request->custHeaders[index].lpszField, lpszField))
6208 continue;
6209
6210 if (request_only && !(request->custHeaders[index].wFlags & HDR_ISREQUEST))
6211 continue;
6212
6213 if (!request_only && (request->custHeaders[index].wFlags & HDR_ISREQUEST))
6214 continue;
6215
6216 if (requested_index == 0)
6217 break;
6218 requested_index --;
6219 }
6220
6221 if (index >= request->nCustHeaders)
6222 index = -1;
6223
6224 TRACE("Return: %d\n", index);
6225 return index;
6226 }
6227
6228
6229 /***********************************************************************
6230 * HTTP_InsertCustomHeader (internal)
6231 *
6232 * Insert header into array
6233 * Headers section must be held
6234 */
6235 static DWORD HTTP_InsertCustomHeader(http_request_t *request, LPHTTPHEADERW lpHdr)
6236 {
6237 INT count;
6238 LPHTTPHEADERW lph = NULL;
6239
6240 TRACE("--> %s: %s\n", debugstr_w(lpHdr->lpszField), debugstr_w(lpHdr->lpszValue));
6241 count = request->nCustHeaders + 1;
6242 if (count > 1)
6243 lph = heap_realloc_zero(request->custHeaders, sizeof(HTTPHEADERW) * count);
6244 else
6245 lph = heap_alloc_zero(sizeof(HTTPHEADERW) * count);
6246
6247 if (!lph)
6248 return ERROR_OUTOFMEMORY;
6249
6250 request->custHeaders = lph;
6251 request->custHeaders[count-1].lpszField = heap_strdupW(lpHdr->lpszField);
6252 request->custHeaders[count-1].lpszValue = heap_strdupW(lpHdr->lpszValue);
6253 request->custHeaders[count-1].wFlags = lpHdr->wFlags;
6254 request->custHeaders[count-1].wCount= lpHdr->wCount;
6255 request->nCustHeaders++;
6256
6257 return ERROR_SUCCESS;
6258 }
6259
6260
6261 /***********************************************************************
6262 * HTTP_DeleteCustomHeader (internal)
6263 *
6264 * Delete header from array
6265 * If this function is called, the index may change.
6266 * Headers section must be held
6267 */
6268 static BOOL HTTP_DeleteCustomHeader(http_request_t *request, DWORD index)
6269 {
6270 if( request->nCustHeaders <= 0 )
6271 return FALSE;
6272 if( index >= request->nCustHeaders )
6273 return FALSE;
6274 request->nCustHeaders--;
6275
6276 heap_free(request->custHeaders[index].lpszField);
6277 heap_free(request->custHeaders[index].lpszValue);
6278
6279 memmove( &request->custHeaders[index], &request->custHeaders[index+1],
6280 (request->nCustHeaders - index)* sizeof(HTTPHEADERW) );
6281 memset( &request->custHeaders[request->nCustHeaders], 0, sizeof(HTTPHEADERW) );
6282
6283 return TRUE;
6284 }
6285
6286
6287 /***********************************************************************
6288 * IsHostInProxyBypassList (@)
6289 *
6290 * Undocumented
6291 *
6292 */
6293 BOOL WINAPI IsHostInProxyBypassList(DWORD flags, LPCSTR szHost, DWORD length)
6294 {
6295 FIXME("STUB: flags=%d host=%s length=%d\n",flags,szHost,length);
6296 return FALSE;
6297 }
Windows API implementation