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