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