dlls/wininet/http.c

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