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