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