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