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