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         if(!len)
2350             netconn_stream->content_length = netconn_stream->content_read;
2351     }
2352
2353     netconn_stream->content_read += *read = len;
2354     TRACE("read %u bytes\n", len);
2355     return ERROR_SUCCESS;
2356 }
2357
2358 static BOOL netconn_drain_content(data_stream_t *stream, http_request_t *req)
2359 {
2360     netconn_stream_t *netconn_stream = (netconn_stream_t*)stream;
2361     BYTE buf[1024];
2362     DWORD avail;
2363     int len;
2364
2365     if(netconn_end_of_data(stream, req))
2366         return TRUE;
2367
2368     do {
2369         avail = netconn_get_avail_data(stream, req);
2370         if(!avail)
2371             return FALSE;
2372
2373         if(NETCON_recv(req->netconn, buf, min(avail, sizeof(buf)), 0, &len) != ERROR_SUCCESS)
2374             return FALSE;
2375
2376         netconn_stream->content_read += len;
2377     }while(netconn_stream->content_read < netconn_stream->content_length);
2378
2379     return TRUE;
2380 }
2381
2382 static void netconn_destroy(data_stream_t *stream)
2383 {
2384 }
2385
2386 static const data_stream_vtbl_t netconn_stream_vtbl = {
2387     netconn_get_avail_data,
2388     netconn_end_of_data,
2389     netconn_read,
2390     netconn_drain_content,
2391     netconn_destroy
2392 };
2393
2394 /* read some more data into the read buffer (the read section must be held) */
2395 static DWORD read_more_chunked_data(chunked_stream_t *stream, http_request_t *req, int maxlen)
2396 {
2397     DWORD res;
2398     int len;
2399
2400     if (stream->buf_pos)
2401     {
2402         /* move existing data to the start of the buffer */
2403         if(stream->buf_size)
2404             memmove(stream->buf, stream->buf + stream->buf_pos, stream->buf_size);
2405         stream->buf_pos = 0;
2406     }
2407
2408     if (maxlen == -1) maxlen = sizeof(stream->buf);
2409
2410     res = NETCON_recv( req->netconn, stream->buf + stream->buf_size,
2411                        maxlen - stream->buf_size, 0, &len );
2412     if(res == ERROR_SUCCESS)
2413         stream->buf_size += len;
2414
2415     return res;
2416 }
2417
2418 /* remove some amount of data from the read buffer (the read section must be held) */
2419 static void remove_chunked_data(chunked_stream_t *stream, int count)
2420 {
2421     if (!(stream->buf_size -= count)) stream->buf_pos = 0;
2422     else stream->buf_pos += count;
2423 }
2424
2425 /* discard data contents until we reach end of line (the read section must be held) */
2426 static DWORD discard_chunked_eol(chunked_stream_t *stream, http_request_t *req)
2427 {
2428     DWORD res;
2429
2430     do
2431     {
2432         BYTE *eol = memchr(stream->buf + stream->buf_pos, '\n', stream->buf_size);
2433         if (eol)
2434         {
2435             remove_chunked_data(stream, (eol + 1) - (stream->buf + stream->buf_pos));
2436             break;
2437         }
2438         stream->buf_pos = stream->buf_size = 0;  /* discard everything */
2439         if ((res = read_more_chunked_data(stream, req, -1)) != ERROR_SUCCESS) return res;
2440     } while (stream->buf_size);
2441     return ERROR_SUCCESS;
2442 }
2443
2444 /* read the size of the next chunk (the read section must be held) */
2445 static DWORD start_next_chunk(chunked_stream_t *stream, http_request_t *req)
2446 {
2447     /* TODOO */
2448     DWORD chunk_size = 0, res;
2449
2450     if(stream->chunk_size != ~0u && (res = discard_chunked_eol(stream, req)) != ERROR_SUCCESS)
2451         return res;
2452
2453     for (;;)
2454     {
2455         while (stream->buf_size)
2456         {
2457             char ch = stream->buf[stream->buf_pos];
2458             if (ch >= '0' && ch <= '9') chunk_size = chunk_size * 16 + ch - '0';
2459             else if (ch >= 'a' && ch <= 'f') chunk_size = chunk_size * 16 + ch - 'a' + 10;
2460             else if (ch >= 'A' && ch <= 'F') chunk_size = chunk_size * 16 + ch - 'A' + 10;
2461             else if (ch == ';' || ch == '\r' || ch == '\n')
2462             {
2463                 TRACE( "reading %u byte chunk\n", chunk_size );
2464                 stream->chunk_size = chunk_size;
2465                 req->contentLength += chunk_size;
2466                 return discard_chunked_eol(stream, req);
2467             }
2468             remove_chunked_data(stream, 1);
2469         }
2470         if ((res = read_more_chunked_data(stream, req, -1)) != ERROR_SUCCESS) return res;
2471         if (!stream->buf_size)
2472         {
2473             stream->chunk_size = 0;
2474             return ERROR_SUCCESS;
2475         }
2476     }
2477 }
2478
2479 static DWORD chunked_get_avail_data(data_stream_t *stream, http_request_t *req)
2480 {
2481     /* Allow reading only from read buffer */
2482     return 0;
2483 }
2484
2485 static BOOL chunked_end_of_data(data_stream_t *stream, http_request_t *req)
2486 {
2487     chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2488     return !chunked_stream->chunk_size;
2489 }
2490
2491 static DWORD chunked_read(data_stream_t *stream, http_request_t *req, BYTE *buf, DWORD size,
2492         DWORD *read, read_mode_t read_mode)
2493 {
2494     chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2495     DWORD read_bytes = 0, ret_read = 0, res = ERROR_SUCCESS;
2496
2497     if(chunked_stream->chunk_size == ~0u) {
2498         res = start_next_chunk(chunked_stream, req);
2499         if(res != ERROR_SUCCESS)
2500             return res;
2501     }
2502
2503     while(size && chunked_stream->chunk_size) {
2504         if(chunked_stream->buf_size) {
2505             read_bytes = min(size, min(chunked_stream->buf_size, chunked_stream->chunk_size));
2506
2507             /* this could block */
2508             if(read_mode == READMODE_NOBLOCK && read_bytes == chunked_stream->chunk_size)
2509                 break;
2510
2511             memcpy(buf+ret_read, chunked_stream->buf+chunked_stream->buf_pos, read_bytes);
2512             remove_chunked_data(chunked_stream, read_bytes);
2513         }else {
2514             read_bytes = min(size, chunked_stream->chunk_size);
2515
2516             if(read_mode == READMODE_NOBLOCK) {
2517                 DWORD avail;
2518
2519                 if(!NETCON_query_data_available(req->netconn, &avail) || !avail)
2520                     break;
2521                 if(read_bytes > avail)
2522                     read_bytes = avail;
2523
2524                 /* this could block */
2525                 if(read_bytes == chunked_stream->chunk_size)
2526                     break;
2527             }
2528
2529             res = NETCON_recv(req->netconn, (char *)buf+ret_read, read_bytes, 0, (int*)&read_bytes);
2530             if(res != ERROR_SUCCESS)
2531                 break;
2532         }
2533
2534         chunked_stream->chunk_size -= read_bytes;
2535         size -= read_bytes;
2536         ret_read += read_bytes;
2537         if(!chunked_stream->chunk_size) {
2538             assert(read_mode != READMODE_NOBLOCK);
2539             res = start_next_chunk(chunked_stream, req);
2540             if(res != ERROR_SUCCESS)
2541                 break;
2542         }
2543
2544         if(read_mode == READMODE_ASYNC)
2545             read_mode = READMODE_NOBLOCK;
2546     }
2547
2548     TRACE("read %u bytes\n", ret_read);
2549     *read = ret_read;
2550     return res;
2551 }
2552
2553 static BOOL chunked_drain_content(data_stream_t *stream, http_request_t *req)
2554 {
2555     chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2556
2557     /* FIXME: we can do better */
2558     return !chunked_stream->chunk_size;
2559 }
2560
2561 static void chunked_destroy(data_stream_t *stream)
2562 {
2563     chunked_stream_t *chunked_stream = (chunked_stream_t*)stream;
2564     heap_free(chunked_stream);
2565 }
2566
2567 static const data_stream_vtbl_t chunked_stream_vtbl = {
2568     chunked_get_avail_data,
2569     chunked_end_of_data,
2570     chunked_read,
2571     chunked_drain_content,
2572     chunked_destroy
2573 };
2574
2575 /* set the request content length based on the headers */
2576 static DWORD set_content_length(http_request_t *request, DWORD status_code)
2577 {
2578     static const WCHAR szChunked[] = {'c','h','u','n','k','e','d',0};
2579     WCHAR encoding[20];
2580     DWORD size;
2581
2582     if(status_code == HTTP_STATUS_NO_CONTENT) {
2583         request->contentLength = request->netconn_stream.content_length = 0;
2584         return ERROR_SUCCESS;
2585     }
2586
2587     size = sizeof(request->contentLength);
2588     if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH,
2589                             &request->contentLength, &size, NULL) != ERROR_SUCCESS)
2590         request->contentLength = ~0u;
2591     request->netconn_stream.content_length = request->contentLength;
2592     request->netconn_stream.content_read = request->read_size;
2593
2594     size = sizeof(encoding);
2595     if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_TRANSFER_ENCODING, encoding, &size, NULL) == ERROR_SUCCESS &&
2596         !strcmpiW(encoding, szChunked))
2597     {
2598         chunked_stream_t *chunked_stream;
2599
2600         chunked_stream = heap_alloc(sizeof(*chunked_stream));
2601         if(!chunked_stream)
2602             return ERROR_OUTOFMEMORY;
2603
2604         chunked_stream->data_stream.vtbl = &chunked_stream_vtbl;
2605         chunked_stream->buf_size = chunked_stream->buf_pos = 0;
2606         chunked_stream->chunk_size = ~0u;
2607
2608         if(request->read_size) {
2609             memcpy(chunked_stream->buf, request->read_buf+request->read_pos, request->read_size);
2610             chunked_stream->buf_size = request->read_size;
2611             request->read_size = request->read_pos = 0;
2612         }
2613
2614         request->data_stream = &chunked_stream->data_stream;
2615         request->contentLength = ~0u;
2616         request->read_chunked = TRUE;
2617     }
2618
2619     if(request->decoding) {
2620         int encoding_idx;
2621
2622         static const WCHAR gzipW[] = {'g','z','i','p',0};
2623
2624         encoding_idx = HTTP_GetCustomHeaderIndex(request, szContent_Encoding, 0, FALSE);
2625         if(encoding_idx != -1 && !strcmpiW(request->custHeaders[encoding_idx].lpszValue, gzipW))
2626             return init_gzip_stream(request);
2627     }
2628
2629     return ERROR_SUCCESS;
2630 }
2631
2632 static void send_request_complete(http_request_t *req, DWORD_PTR result, DWORD error)
2633 {
2634     INTERNET_ASYNC_RESULT iar;
2635
2636     iar.dwResult = result;
2637     iar.dwError = error;
2638
2639     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE, &iar,
2640             sizeof(INTERNET_ASYNC_RESULT));
2641 }
2642
2643 static void HTTP_ReceiveRequestData(http_request_t *req, BOOL first_notif)
2644 {
2645     DWORD res, read = 0, avail = 0;
2646     read_mode_t mode;
2647
2648     TRACE("%p\n", req);
2649
2650     EnterCriticalSection( &req->read_section );
2651
2652     mode = first_notif && req->read_size ? READMODE_NOBLOCK : READMODE_ASYNC;
2653     res = refill_read_buffer(req, mode, &read);
2654     if(res == ERROR_SUCCESS && !first_notif)
2655         avail = get_avail_data(req);
2656
2657     LeaveCriticalSection( &req->read_section );
2658
2659     if(res != ERROR_SUCCESS || (mode != READMODE_NOBLOCK && !read)) {
2660         WARN("res %u read %u, closing connection\n", res, read);
2661         http_release_netconn(req, FALSE);
2662     }
2663
2664     if(res == ERROR_SUCCESS)
2665         send_request_complete(req, req->session->hdr.dwInternalFlags & INET_OPENURL ? (DWORD_PTR)req->hdr.hInternet : 1, avail);
2666     else
2667         send_request_complete(req, 0, res);
2668 }
2669
2670 /* read data from the http connection (the read section must be held) */
2671 static DWORD HTTPREQ_Read(http_request_t *req, void *buffer, DWORD size, DWORD *read, BOOL sync)
2672 {
2673     DWORD current_read = 0, ret_read = 0;
2674     read_mode_t read_mode;
2675     DWORD res = ERROR_SUCCESS;
2676
2677     read_mode = req->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC ? READMODE_ASYNC : READMODE_SYNC;
2678
2679     EnterCriticalSection( &req->read_section );
2680
2681     if(req->read_size) {
2682         ret_read = min(size, req->read_size);
2683         memcpy(buffer, req->read_buf+req->read_pos, ret_read);
2684         req->read_size -= ret_read;
2685         req->read_pos += ret_read;
2686         if(read_mode == READMODE_ASYNC)
2687             read_mode = READMODE_NOBLOCK;
2688     }
2689
2690     if(ret_read < size) {
2691         res = req->data_stream->vtbl->read(req->data_stream, req, (BYTE*)buffer+ret_read, size-ret_read, &current_read, read_mode);
2692         ret_read += current_read;
2693     }
2694
2695     LeaveCriticalSection( &req->read_section );
2696
2697     *read = ret_read;
2698     TRACE( "retrieved %u bytes (%u)\n", ret_read, req->contentLength );
2699
2700     if(req->hCacheFile && res == ERROR_SUCCESS && ret_read) {
2701         BOOL res;
2702         DWORD written;
2703
2704         res = WriteFile(req->hCacheFile, buffer, ret_read, &written, NULL);
2705         if(!res)
2706             WARN("WriteFile failed: %u\n", GetLastError());
2707     }
2708
2709     if(size && !ret_read)
2710         http_release_netconn(req, res == ERROR_SUCCESS);
2711
2712     return res;
2713 }
2714
2715
2716 static DWORD HTTPREQ_ReadFile(object_header_t *hdr, void *buffer, DWORD size, DWORD *read)
2717 {
2718     http_request_t *req = (http_request_t*)hdr;
2719     DWORD res;
2720
2721     EnterCriticalSection( &req->read_section );
2722     if(hdr->dwError == INTERNET_HANDLE_IN_USE)
2723         hdr->dwError = ERROR_INTERNET_INTERNAL_ERROR;
2724
2725     res = HTTPREQ_Read(req, buffer, size, read, TRUE);
2726     if(res == ERROR_SUCCESS)
2727         res = hdr->dwError;
2728     LeaveCriticalSection( &req->read_section );
2729
2730     return res;
2731 }
2732
2733 static void HTTPREQ_AsyncReadFileExAProc(WORKREQUEST *workRequest)
2734 {
2735     struct WORKREQ_INTERNETREADFILEEXA const *data = &workRequest->u.InternetReadFileExA;
2736     http_request_t *req = (http_request_t*)workRequest->hdr;
2737     DWORD res;
2738
2739     TRACE("INTERNETREADFILEEXA %p\n", workRequest->hdr);
2740
2741     res = HTTPREQ_Read(req, data->lpBuffersOut->lpvBuffer,
2742             data->lpBuffersOut->dwBufferLength, &data->lpBuffersOut->dwBufferLength, TRUE);
2743
2744     send_request_complete(req, res == ERROR_SUCCESS, res);
2745 }
2746
2747 static DWORD HTTPREQ_ReadFileExA(object_header_t *hdr, INTERNET_BUFFERSA *buffers,
2748         DWORD flags, DWORD_PTR context)
2749 {
2750     http_request_t *req = (http_request_t*)hdr;
2751     DWORD res, size, read, error = ERROR_SUCCESS;
2752
2753     if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
2754         FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
2755
2756     if (buffers->dwStructSize != sizeof(*buffers))
2757         return ERROR_INVALID_PARAMETER;
2758
2759     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2760
2761     if (hdr->dwFlags & INTERNET_FLAG_ASYNC)
2762     {
2763         WORKREQUEST workRequest;
2764
2765         if (TryEnterCriticalSection( &req->read_section ))
2766         {
2767             if (get_avail_data(req))
2768             {
2769                 res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength,
2770                                    &buffers->dwBufferLength, FALSE);
2771                 size = buffers->dwBufferLength;
2772                 LeaveCriticalSection( &req->read_section );
2773                 goto done;
2774             }
2775             LeaveCriticalSection( &req->read_section );
2776         }
2777
2778         workRequest.asyncproc = HTTPREQ_AsyncReadFileExAProc;
2779         workRequest.hdr = WININET_AddRef(&req->hdr);
2780         workRequest.u.InternetReadFileExA.lpBuffersOut = buffers;
2781
2782         INTERNET_AsyncCall(&workRequest);
2783
2784         return ERROR_IO_PENDING;
2785     }
2786
2787     read = 0;
2788     size = buffers->dwBufferLength;
2789
2790     EnterCriticalSection( &req->read_section );
2791     if(hdr->dwError == ERROR_SUCCESS)
2792         hdr->dwError = INTERNET_HANDLE_IN_USE;
2793     else if(hdr->dwError == INTERNET_HANDLE_IN_USE)
2794         hdr->dwError = ERROR_INTERNET_INTERNAL_ERROR;
2795
2796     while(1) {
2797         res = HTTPREQ_Read(req, (char*)buffers->lpvBuffer+read, size-read,
2798                 &buffers->dwBufferLength, !(flags & IRF_NO_WAIT));
2799         if(res != ERROR_SUCCESS)
2800             break;
2801
2802         read += buffers->dwBufferLength;
2803         if(read == size || end_of_read_data(req))
2804             break;
2805
2806         LeaveCriticalSection( &req->read_section );
2807
2808         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2809                 &buffers->dwBufferLength, sizeof(buffers->dwBufferLength));
2810         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
2811                 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2812
2813         EnterCriticalSection( &req->read_section );
2814     }
2815
2816     if(hdr->dwError == INTERNET_HANDLE_IN_USE)
2817         hdr->dwError = ERROR_SUCCESS;
2818     else
2819         error = hdr->dwError;
2820
2821     LeaveCriticalSection( &req->read_section );
2822     size = buffers->dwBufferLength;
2823     buffers->dwBufferLength = read;
2824
2825 done:
2826     if (res == ERROR_SUCCESS) {
2827         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2828                 &size, sizeof(size));
2829     }
2830
2831     return res==ERROR_SUCCESS ? error : res;
2832 }
2833
2834 static void HTTPREQ_AsyncReadFileExWProc(WORKREQUEST *workRequest)
2835 {
2836     struct WORKREQ_INTERNETREADFILEEXW const *data = &workRequest->u.InternetReadFileExW;
2837     http_request_t *req = (http_request_t*)workRequest->hdr;
2838     DWORD res;
2839
2840     TRACE("INTERNETREADFILEEXW %p\n", workRequest->hdr);
2841
2842     res = HTTPREQ_Read(req, data->lpBuffersOut->lpvBuffer,
2843             data->lpBuffersOut->dwBufferLength, &data->lpBuffersOut->dwBufferLength, TRUE);
2844
2845     send_request_complete(req, res == ERROR_SUCCESS, res);
2846 }
2847
2848 static DWORD HTTPREQ_ReadFileExW(object_header_t *hdr, INTERNET_BUFFERSW *buffers,
2849         DWORD flags, DWORD_PTR context)
2850 {
2851
2852     http_request_t *req = (http_request_t*)hdr;
2853     DWORD res, size, read, error = ERROR_SUCCESS;
2854
2855     if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
2856         FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
2857
2858     if (buffers->dwStructSize != sizeof(*buffers))
2859         return ERROR_INVALID_PARAMETER;
2860
2861     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2862
2863     if (hdr->dwFlags & INTERNET_FLAG_ASYNC)
2864     {
2865         WORKREQUEST workRequest;
2866
2867         if (TryEnterCriticalSection( &req->read_section ))
2868         {
2869             if (get_avail_data(req))
2870             {
2871                 res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength,
2872                                    &buffers->dwBufferLength, FALSE);
2873                 size = buffers->dwBufferLength;
2874                 LeaveCriticalSection( &req->read_section );
2875                 goto done;
2876             }
2877             LeaveCriticalSection( &req->read_section );
2878         }
2879
2880         workRequest.asyncproc = HTTPREQ_AsyncReadFileExWProc;
2881         workRequest.hdr = WININET_AddRef(&req->hdr);
2882         workRequest.u.InternetReadFileExW.lpBuffersOut = buffers;
2883
2884         INTERNET_AsyncCall(&workRequest);
2885
2886         return ERROR_IO_PENDING;
2887     }
2888
2889     read = 0;
2890     size = buffers->dwBufferLength;
2891
2892     EnterCriticalSection( &req->read_section );
2893     if(hdr->dwError == ERROR_SUCCESS)
2894         hdr->dwError = INTERNET_HANDLE_IN_USE;
2895     else if(hdr->dwError == INTERNET_HANDLE_IN_USE)
2896         hdr->dwError = ERROR_INTERNET_INTERNAL_ERROR;
2897
2898     while(1) {
2899         res = HTTPREQ_Read(req, (char*)buffers->lpvBuffer+read, size-read,
2900                 &buffers->dwBufferLength, !(flags & IRF_NO_WAIT));
2901         if(res != ERROR_SUCCESS)
2902             break;
2903
2904         read += buffers->dwBufferLength;
2905         if(read == size || end_of_read_data(req))
2906             break;
2907
2908         LeaveCriticalSection( &req->read_section );
2909
2910         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2911                 &buffers->dwBufferLength, sizeof(buffers->dwBufferLength));
2912         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
2913                 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2914
2915         EnterCriticalSection( &req->read_section );
2916     }
2917
2918     if(hdr->dwError == INTERNET_HANDLE_IN_USE)
2919         hdr->dwError = ERROR_SUCCESS;
2920     else
2921         error = hdr->dwError;
2922
2923     LeaveCriticalSection( &req->read_section );
2924     size = buffers->dwBufferLength;
2925     buffers->dwBufferLength = read;
2926
2927 done:
2928     if (res == ERROR_SUCCESS) {
2929         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2930                 &size, sizeof(size));
2931     }
2932
2933     return res==ERROR_SUCCESS ? error : res;
2934 }
2935
2936 static DWORD HTTPREQ_WriteFile(object_header_t *hdr, const void *buffer, DWORD size, DWORD *written)
2937 {
2938     DWORD res;
2939     http_request_t *request = (http_request_t*)hdr;
2940
2941     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
2942
2943     *written = 0;
2944     res = NETCON_send(request->netconn, buffer, size, 0, (LPINT)written);
2945     if (res == ERROR_SUCCESS)
2946         request->bytesWritten += *written;
2947
2948     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REQUEST_SENT, written, sizeof(DWORD));
2949     return res;
2950 }
2951
2952 static void HTTPREQ_AsyncQueryDataAvailableProc(WORKREQUEST *workRequest)
2953 {
2954     http_request_t *req = (http_request_t*)workRequest->hdr;
2955
2956     HTTP_ReceiveRequestData(req, FALSE);
2957 }
2958
2959 static DWORD HTTPREQ_QueryDataAvailable(object_header_t *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
2960 {
2961     http_request_t *req = (http_request_t*)hdr;
2962
2963     TRACE("(%p %p %x %lx)\n", req, available, flags, ctx);
2964
2965     if (req->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2966     {
2967         WORKREQUEST workRequest;
2968
2969         /* never wait, if we can't enter the section we queue an async request right away */
2970         if (TryEnterCriticalSection( &req->read_section ))
2971         {
2972             refill_read_buffer(req, READMODE_NOBLOCK, NULL);
2973             if ((*available = get_avail_data( req ))) goto done;
2974             if (end_of_read_data( req )) goto done;
2975             LeaveCriticalSection( &req->read_section );
2976         }
2977
2978         workRequest.asyncproc = HTTPREQ_AsyncQueryDataAvailableProc;
2979         workRequest.hdr = WININET_AddRef( &req->hdr );
2980
2981         INTERNET_AsyncCall(&workRequest);
2982
2983         return ERROR_IO_PENDING;
2984     }
2985
2986     EnterCriticalSection( &req->read_section );
2987
2988     if (!(*available = get_avail_data( req )) && !end_of_read_data( req ))
2989     {
2990         refill_read_buffer( req, READMODE_ASYNC, NULL );
2991         *available = get_avail_data( req );
2992     }
2993
2994 done:
2995     LeaveCriticalSection( &req->read_section );
2996
2997     TRACE( "returning %u\n", *available );
2998     return ERROR_SUCCESS;
2999 }
3000
3001 static const object_vtbl_t HTTPREQVtbl = {
3002     HTTPREQ_Destroy,
3003     HTTPREQ_CloseConnection,
3004     HTTPREQ_QueryOption,
3005     HTTPREQ_SetOption,
3006     HTTPREQ_ReadFile,
3007     HTTPREQ_ReadFileExA,
3008     HTTPREQ_ReadFileExW,
3009     HTTPREQ_WriteFile,
3010     HTTPREQ_QueryDataAvailable,
3011     NULL
3012 };
3013
3014 /***********************************************************************
3015  *           HTTP_HttpOpenRequestW (internal)
3016  *
3017  * Open a HTTP request handle
3018  *
3019  * RETURNS
3020  *    HINTERNET  a HTTP request handle on success
3021  *    NULL       on failure
3022  *
3023  */
3024 static DWORD HTTP_HttpOpenRequestW(http_session_t *session,
3025         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
3026         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
3027         DWORD dwFlags, DWORD_PTR dwContext, HINTERNET *ret)
3028 {
3029     appinfo_t *hIC = session->appInfo;
3030     http_request_t *request;
3031     DWORD len, res = ERROR_SUCCESS;
3032
3033     TRACE("-->\n");
3034
3035     request = alloc_object(&session->hdr, &HTTPREQVtbl, sizeof(http_request_t));
3036     if(!request)
3037         return ERROR_OUTOFMEMORY;
3038
3039     request->hdr.htype = WH_HHTTPREQ;
3040     request->hdr.dwFlags = dwFlags;
3041     request->hdr.dwContext = dwContext;
3042     request->contentLength = ~0u;
3043
3044     request->netconn_stream.data_stream.vtbl = &netconn_stream_vtbl;
3045     request->data_stream = &request->netconn_stream.data_stream;
3046
3047     InitializeCriticalSection( &request->read_section );
3048
3049     WININET_AddRef( &session->hdr );
3050     request->session = session;
3051     list_add_head( &session->hdr.children, &request->hdr.entry );
3052
3053     if (dwFlags & INTERNET_FLAG_IGNORE_CERT_CN_INVALID)
3054         request->security_flags |= SECURITY_FLAG_IGNORE_CERT_CN_INVALID;
3055     if (dwFlags & INTERNET_FLAG_IGNORE_CERT_DATE_INVALID)
3056         request->security_flags |= SECURITY_FLAG_IGNORE_CERT_DATE_INVALID;
3057
3058     if (lpszObjectName && *lpszObjectName) {
3059         HRESULT rc;
3060
3061         len = 0;
3062         rc = UrlEscapeW(lpszObjectName, NULL, &len, URL_ESCAPE_SPACES_ONLY);
3063         if (rc != E_POINTER)
3064             len = strlenW(lpszObjectName)+1;
3065         request->path = heap_alloc(len*sizeof(WCHAR));
3066         rc = UrlEscapeW(lpszObjectName, request->path, &len,
3067                    URL_ESCAPE_SPACES_ONLY);
3068         if (rc != S_OK)
3069         {
3070             ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(lpszObjectName),rc);
3071             strcpyW(request->path,lpszObjectName);
3072         }
3073     }else {
3074         static const WCHAR slashW[] = {'/',0};
3075
3076         request->path = heap_strdupW(slashW);
3077     }
3078
3079     if (lpszReferrer && *lpszReferrer)
3080         HTTP_ProcessHeader(request, HTTP_REFERER, lpszReferrer, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
3081
3082     if (lpszAcceptTypes)
3083     {
3084         int i;
3085         for (i = 0; lpszAcceptTypes[i]; i++)
3086         {
3087             if (!*lpszAcceptTypes[i]) continue;
3088             HTTP_ProcessHeader(request, HTTP_ACCEPT, lpszAcceptTypes[i],
3089                                HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA |
3090                                HTTP_ADDHDR_FLAG_REQ |
3091                                (i == 0 ? HTTP_ADDHDR_FLAG_REPLACE : 0));
3092         }
3093     }
3094
3095     request->verb = heap_strdupW(lpszVerb && *lpszVerb ? lpszVerb : szGET);
3096     request->version = heap_strdupW(lpszVersion ? lpszVersion : g_szHttp1_1);
3097
3098     if (session->hostPort != INTERNET_INVALID_PORT_NUMBER &&
3099         session->hostPort != INTERNET_DEFAULT_HTTP_PORT &&
3100         session->hostPort != INTERNET_DEFAULT_HTTPS_PORT)
3101     {
3102         WCHAR *host_name;
3103
3104         static const WCHAR host_formatW[] = {'%','s',':','%','u',0};
3105
3106         host_name = heap_alloc((strlenW(session->hostName) + 7 /* length of ":65535" + 1 */) * sizeof(WCHAR));
3107         if (!host_name) {
3108             res = ERROR_OUTOFMEMORY;
3109             goto lend;
3110         }
3111
3112         sprintfW(host_name, host_formatW, session->hostName, session->hostPort);
3113         HTTP_ProcessHeader(request, hostW, host_name, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
3114         heap_free(host_name);
3115     }
3116     else
3117         HTTP_ProcessHeader(request, hostW, session->hostName,
3118                 HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
3119
3120     if (session->serverPort == INTERNET_INVALID_PORT_NUMBER)
3121         session->serverPort = (dwFlags & INTERNET_FLAG_SECURE ?
3122                         INTERNET_DEFAULT_HTTPS_PORT :
3123                         INTERNET_DEFAULT_HTTP_PORT);
3124
3125     if (session->hostPort == INTERNET_INVALID_PORT_NUMBER)
3126         session->hostPort = (dwFlags & INTERNET_FLAG_SECURE ?
3127                         INTERNET_DEFAULT_HTTPS_PORT :
3128                         INTERNET_DEFAULT_HTTP_PORT);
3129
3130     if (hIC->proxy && hIC->proxy[0])
3131         HTTP_DealWithProxy( hIC, session, request );
3132
3133     INTERNET_SendCallback(&session->hdr, dwContext,
3134                           INTERNET_STATUS_HANDLE_CREATED, &request->hdr.hInternet,
3135                           sizeof(HINTERNET));
3136
3137 lend:
3138     TRACE("<-- %u (%p)\n", res, request);
3139
3140     if(res != ERROR_SUCCESS) {
3141         WININET_Release( &request->hdr );
3142         *ret = NULL;
3143         return res;
3144     }
3145
3146     *ret = request->hdr.hInternet;
3147     return ERROR_SUCCESS;
3148 }
3149
3150 /***********************************************************************
3151  *           HttpOpenRequestW (WININET.@)
3152  *
3153  * Open a HTTP request handle
3154  *
3155  * RETURNS
3156  *    HINTERNET  a HTTP request handle on success
3157  *    NULL       on failure
3158  *
3159  */
3160 HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession,
3161         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
3162         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
3163         DWORD dwFlags, DWORD_PTR dwContext)
3164 {
3165     http_session_t *session;
3166     HINTERNET handle = NULL;
3167     DWORD res;
3168
3169     TRACE("(%p, %s, %s, %s, %s, %p, %08x, %08lx)\n", hHttpSession,
3170           debugstr_w(lpszVerb), debugstr_w(lpszObjectName),
3171           debugstr_w(lpszVersion), debugstr_w(lpszReferrer), lpszAcceptTypes,
3172           dwFlags, dwContext);
3173     if(lpszAcceptTypes!=NULL)
3174     {
3175         int i;
3176         for(i=0;lpszAcceptTypes[i]!=NULL;i++)
3177             TRACE("\taccept type: %s\n",debugstr_w(lpszAcceptTypes[i]));
3178     }
3179
3180     session = (http_session_t*) get_handle_object( hHttpSession );
3181     if (NULL == session ||  session->hdr.htype != WH_HHTTPSESSION)
3182     {
3183         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
3184         goto lend;
3185     }
3186
3187     /*
3188      * My tests seem to show that the windows version does not
3189      * become asynchronous until after this point. And anyhow
3190      * if this call was asynchronous then how would you get the
3191      * necessary HINTERNET pointer returned by this function.
3192      *
3193      */
3194     res = HTTP_HttpOpenRequestW(session, lpszVerb, lpszObjectName,
3195                                 lpszVersion, lpszReferrer, lpszAcceptTypes,
3196                                 dwFlags, dwContext, &handle);
3197 lend:
3198     if( session )
3199         WININET_Release( &session->hdr );
3200     TRACE("returning %p\n", handle);
3201     if(res != ERROR_SUCCESS)
3202         SetLastError(res);
3203     return handle;
3204 }
3205
3206 static const LPCWSTR header_lookup[] = {
3207     szMime_Version,             /* HTTP_QUERY_MIME_VERSION = 0 */
3208     szContent_Type,             /* HTTP_QUERY_CONTENT_TYPE = 1 */
3209     szContent_Transfer_Encoding,/* HTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
3210     szContent_ID,               /* HTTP_QUERY_CONTENT_ID = 3 */
3211     NULL,                       /* HTTP_QUERY_CONTENT_DESCRIPTION = 4 */
3212     szContent_Length,           /* HTTP_QUERY_CONTENT_LENGTH =  5 */
3213     szContent_Language,         /* HTTP_QUERY_CONTENT_LANGUAGE =  6 */
3214     szAllow,                    /* HTTP_QUERY_ALLOW = 7 */
3215     szPublic,                   /* HTTP_QUERY_PUBLIC = 8 */
3216     szDate,                     /* HTTP_QUERY_DATE = 9 */
3217     szExpires,                  /* HTTP_QUERY_EXPIRES = 10 */
3218     szLast_Modified,            /* HTTP_QUERY_LAST_MODIFIED = 11 */
3219     NULL,                       /* HTTP_QUERY_MESSAGE_ID = 12 */
3220     szURI,                      /* HTTP_QUERY_URI = 13 */
3221     szFrom,                     /* HTTP_QUERY_DERIVED_FROM = 14 */
3222     NULL,                       /* HTTP_QUERY_COST = 15 */
3223     NULL,                       /* HTTP_QUERY_LINK = 16 */
3224     szPragma,                   /* HTTP_QUERY_PRAGMA = 17 */
3225     NULL,                       /* HTTP_QUERY_VERSION = 18 */
3226     szStatus,                   /* HTTP_QUERY_STATUS_CODE = 19 */
3227     NULL,                       /* HTTP_QUERY_STATUS_TEXT = 20 */
3228     NULL,                       /* HTTP_QUERY_RAW_HEADERS = 21 */
3229     NULL,                       /* HTTP_QUERY_RAW_HEADERS_CRLF = 22 */
3230     szConnection,               /* HTTP_QUERY_CONNECTION = 23 */
3231     szAccept,                   /* HTTP_QUERY_ACCEPT = 24 */
3232     szAccept_Charset,           /* HTTP_QUERY_ACCEPT_CHARSET = 25 */
3233     szAccept_Encoding,          /* HTTP_QUERY_ACCEPT_ENCODING = 26 */
3234     szAccept_Language,          /* HTTP_QUERY_ACCEPT_LANGUAGE = 27 */
3235     szAuthorization,            /* HTTP_QUERY_AUTHORIZATION = 28 */
3236     szContent_Encoding,         /* HTTP_QUERY_CONTENT_ENCODING = 29 */
3237     NULL,                       /* HTTP_QUERY_FORWARDED = 30 */
3238     NULL,                       /* HTTP_QUERY_FROM = 31 */
3239     szIf_Modified_Since,        /* HTTP_QUERY_IF_MODIFIED_SINCE = 32 */
3240     szLocation,                 /* HTTP_QUERY_LOCATION = 33 */
3241     NULL,                       /* HTTP_QUERY_ORIG_URI = 34 */
3242     szReferer,                  /* HTTP_QUERY_REFERER = 35 */
3243     szRetry_After,              /* HTTP_QUERY_RETRY_AFTER = 36 */
3244     szServer,                   /* HTTP_QUERY_SERVER = 37 */
3245     NULL,                       /* HTTP_TITLE = 38 */
3246     szUser_Agent,               /* HTTP_QUERY_USER_AGENT = 39 */
3247     szWWW_Authenticate,         /* HTTP_QUERY_WWW_AUTHENTICATE = 40 */
3248     szProxy_Authenticate,       /* HTTP_QUERY_PROXY_AUTHENTICATE = 41 */
3249     szAccept_Ranges,            /* HTTP_QUERY_ACCEPT_RANGES = 42 */
3250     szSet_Cookie,               /* HTTP_QUERY_SET_COOKIE = 43 */
3251     szCookie,                   /* HTTP_QUERY_COOKIE = 44 */
3252     NULL,                       /* HTTP_QUERY_REQUEST_METHOD = 45 */
3253     NULL,                       /* HTTP_QUERY_REFRESH = 46 */
3254     NULL,                       /* HTTP_QUERY_CONTENT_DISPOSITION = 47 */
3255     szAge,                      /* HTTP_QUERY_AGE = 48 */
3256     szCache_Control,            /* HTTP_QUERY_CACHE_CONTROL = 49 */
3257     szContent_Base,             /* HTTP_QUERY_CONTENT_BASE = 50 */
3258     szContent_Location,         /* HTTP_QUERY_CONTENT_LOCATION = 51 */
3259     szContent_MD5,              /* HTTP_QUERY_CONTENT_MD5 = 52 */
3260     szContent_Range,            /* HTTP_QUERY_CONTENT_RANGE = 53 */
3261     szETag,                     /* HTTP_QUERY_ETAG = 54 */
3262     hostW,                      /* HTTP_QUERY_HOST = 55 */
3263     szIf_Match,                 /* HTTP_QUERY_IF_MATCH = 56 */
3264     szIf_None_Match,            /* HTTP_QUERY_IF_NONE_MATCH = 57 */
3265     szIf_Range,                 /* HTTP_QUERY_IF_RANGE = 58 */
3266     szIf_Unmodified_Since,      /* HTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
3267     szMax_Forwards,             /* HTTP_QUERY_MAX_FORWARDS = 60 */
3268     szProxy_Authorization,      /* HTTP_QUERY_PROXY_AUTHORIZATION = 61 */
3269     szRange,                    /* HTTP_QUERY_RANGE = 62 */
3270     szTransfer_Encoding,        /* HTTP_QUERY_TRANSFER_ENCODING = 63 */
3271     szUpgrade,                  /* HTTP_QUERY_UPGRADE = 64 */
3272     szVary,                     /* HTTP_QUERY_VARY = 65 */
3273     szVia,                      /* HTTP_QUERY_VIA = 66 */
3274     szWarning,                  /* HTTP_QUERY_WARNING = 67 */
3275     szExpect,                   /* HTTP_QUERY_EXPECT = 68 */
3276     szProxy_Connection,         /* HTTP_QUERY_PROXY_CONNECTION = 69 */
3277     szUnless_Modified_Since,    /* HTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
3278 };
3279
3280 #define LAST_TABLE_HEADER (sizeof(header_lookup)/sizeof(header_lookup[0]))
3281
3282 /***********************************************************************
3283  *           HTTP_HttpQueryInfoW (internal)
3284  */
3285 static DWORD HTTP_HttpQueryInfoW(http_request_t *request, DWORD dwInfoLevel,
3286         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3287 {
3288     LPHTTPHEADERW lphttpHdr = NULL;
3289     BOOL request_only = dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS;
3290     INT requested_index = lpdwIndex ? *lpdwIndex : 0;
3291     DWORD level = (dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK);
3292     INT index = -1;
3293
3294     /* Find requested header structure */
3295     switch (level)
3296     {
3297     case HTTP_QUERY_CUSTOM:
3298         if (!lpBuffer) return ERROR_INVALID_PARAMETER;
3299         index = HTTP_GetCustomHeaderIndex(request, lpBuffer, requested_index, request_only);
3300         break;
3301     case HTTP_QUERY_RAW_HEADERS_CRLF:
3302         {
3303             LPWSTR headers;
3304             DWORD len = 0;
3305             DWORD res = ERROR_INVALID_PARAMETER;
3306
3307             if (request_only)
3308                 headers = HTTP_BuildHeaderRequestString(request, request->verb, request->path, request->version);
3309             else
3310                 headers = request->rawHeaders;
3311
3312             if (headers)
3313                 len = strlenW(headers) * sizeof(WCHAR);
3314
3315             if (len + sizeof(WCHAR) > *lpdwBufferLength)
3316             {
3317                 len += sizeof(WCHAR);
3318                 res = ERROR_INSUFFICIENT_BUFFER;
3319             }
3320             else if (lpBuffer)
3321             {
3322                 if (headers)
3323                     memcpy(lpBuffer, headers, len + sizeof(WCHAR));
3324                 else
3325                 {
3326                     len = strlenW(szCrLf) * sizeof(WCHAR);
3327                     memcpy(lpBuffer, szCrLf, sizeof(szCrLf));
3328                 }
3329                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len / sizeof(WCHAR)));
3330                 res = ERROR_SUCCESS;
3331             }
3332             *lpdwBufferLength = len;
3333
3334             if (request_only) heap_free(headers);
3335             return res;
3336         }
3337     case HTTP_QUERY_RAW_HEADERS:
3338         {
3339             LPWSTR * ppszRawHeaderLines = HTTP_Tokenize(request->rawHeaders, szCrLf);
3340             DWORD i, size = 0;
3341             LPWSTR pszString = lpBuffer;
3342
3343             for (i = 0; ppszRawHeaderLines[i]; i++)
3344                 size += strlenW(ppszRawHeaderLines[i]) + 1;
3345
3346             if (size + 1 > *lpdwBufferLength/sizeof(WCHAR))
3347             {
3348                 HTTP_FreeTokens(ppszRawHeaderLines);
3349                 *lpdwBufferLength = (size + 1) * sizeof(WCHAR);
3350                 return ERROR_INSUFFICIENT_BUFFER;
3351             }
3352             if (pszString)
3353             {
3354                 for (i = 0; ppszRawHeaderLines[i]; i++)
3355                 {
3356                     DWORD len = strlenW(ppszRawHeaderLines[i]);
3357                     memcpy(pszString, ppszRawHeaderLines[i], (len+1)*sizeof(WCHAR));
3358                     pszString += len+1;
3359                 }
3360                 *pszString = '\0';
3361                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, size));
3362             }
3363             *lpdwBufferLength = size * sizeof(WCHAR);
3364             HTTP_FreeTokens(ppszRawHeaderLines);
3365
3366             return ERROR_SUCCESS;
3367         }
3368     case HTTP_QUERY_STATUS_TEXT:
3369         if (request->statusText)
3370         {
3371             DWORD len = strlenW(request->statusText);
3372             if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
3373             {
3374                 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
3375                 return ERROR_INSUFFICIENT_BUFFER;
3376             }
3377             if (lpBuffer)
3378             {
3379                 memcpy(lpBuffer, request->statusText, (len + 1) * sizeof(WCHAR));
3380                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
3381             }
3382             *lpdwBufferLength = len * sizeof(WCHAR);
3383             return ERROR_SUCCESS;
3384         }
3385         break;
3386     case HTTP_QUERY_VERSION:
3387         if (request->version)
3388         {
3389             DWORD len = strlenW(request->version);
3390             if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
3391             {
3392                 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
3393                 return ERROR_INSUFFICIENT_BUFFER;
3394             }
3395             if (lpBuffer)
3396             {
3397                 memcpy(lpBuffer, request->version, (len + 1) * sizeof(WCHAR));
3398                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
3399             }
3400             *lpdwBufferLength = len * sizeof(WCHAR);
3401             return ERROR_SUCCESS;
3402         }
3403         break;
3404     case HTTP_QUERY_CONTENT_ENCODING:
3405         index = HTTP_GetCustomHeaderIndex(request, header_lookup[request->read_gzip ? HTTP_QUERY_CONTENT_TYPE : level],
3406                 requested_index,request_only);
3407         break;
3408     default:
3409         assert (LAST_TABLE_HEADER == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1));
3410
3411         if (level < LAST_TABLE_HEADER && header_lookup[level])
3412             index = HTTP_GetCustomHeaderIndex(request, header_lookup[level],
3413                                               requested_index,request_only);
3414     }
3415
3416     if (index >= 0)
3417         lphttpHdr = &request->custHeaders[index];
3418
3419     /* Ensure header satisfies requested attributes */
3420     if (!lphttpHdr ||
3421         ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
3422          (~lphttpHdr->wFlags & HDR_ISREQUEST)))
3423     {
3424         return ERROR_HTTP_HEADER_NOT_FOUND;
3425     }
3426
3427     if (lpdwIndex && level != HTTP_QUERY_STATUS_CODE) (*lpdwIndex)++;
3428
3429     /* coalesce value to requested type */
3430     if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER && lpBuffer)
3431     {
3432         *(int *)lpBuffer = atoiW(lphttpHdr->lpszValue);
3433         TRACE(" returning number: %d\n", *(int *)lpBuffer);
3434      }
3435     else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME && lpBuffer)
3436     {
3437         time_t tmpTime;
3438         struct tm tmpTM;
3439         SYSTEMTIME *STHook;
3440
3441         tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
3442
3443         tmpTM = *gmtime(&tmpTime);
3444         STHook = (SYSTEMTIME *)lpBuffer;
3445         STHook->wDay = tmpTM.tm_mday;
3446         STHook->wHour = tmpTM.tm_hour;
3447         STHook->wMilliseconds = 0;
3448         STHook->wMinute = tmpTM.tm_min;
3449         STHook->wDayOfWeek = tmpTM.tm_wday;
3450         STHook->wMonth = tmpTM.tm_mon + 1;
3451         STHook->wSecond = tmpTM.tm_sec;
3452         STHook->wYear = tmpTM.tm_year;
3453
3454         TRACE(" returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
3455               STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
3456               STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
3457     }
3458     else if (lphttpHdr->lpszValue)
3459     {
3460         DWORD len = (strlenW(lphttpHdr->lpszValue) + 1) * sizeof(WCHAR);
3461
3462         if (len > *lpdwBufferLength)
3463         {
3464             *lpdwBufferLength = len;
3465             return ERROR_INSUFFICIENT_BUFFER;
3466         }
3467         if (lpBuffer)
3468         {
3469             memcpy(lpBuffer, lphttpHdr->lpszValue, len);
3470             TRACE("! returning string: %s\n", debugstr_w(lpBuffer));
3471         }
3472         *lpdwBufferLength = len - sizeof(WCHAR);
3473     }
3474     return ERROR_SUCCESS;
3475 }
3476
3477 /***********************************************************************
3478  *           HttpQueryInfoW (WININET.@)
3479  *
3480  * Queries for information about an HTTP request
3481  *
3482  * RETURNS
3483  *    TRUE  on success
3484  *    FALSE on failure
3485  *
3486  */
3487 BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel,
3488         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3489 {
3490     http_request_t *request;
3491     DWORD res;
3492
3493     if (TRACE_ON(wininet)) {
3494 #define FE(x) { x, #x }
3495         static const wininet_flag_info query_flags[] = {
3496             FE(HTTP_QUERY_MIME_VERSION),
3497             FE(HTTP_QUERY_CONTENT_TYPE),
3498             FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
3499             FE(HTTP_QUERY_CONTENT_ID),
3500             FE(HTTP_QUERY_CONTENT_DESCRIPTION),
3501             FE(HTTP_QUERY_CONTENT_LENGTH),
3502             FE(HTTP_QUERY_CONTENT_LANGUAGE),
3503             FE(HTTP_QUERY_ALLOW),
3504             FE(HTTP_QUERY_PUBLIC),
3505             FE(HTTP_QUERY_DATE),
3506             FE(HTTP_QUERY_EXPIRES),
3507             FE(HTTP_QUERY_LAST_MODIFIED),
3508             FE(HTTP_QUERY_MESSAGE_ID),
3509             FE(HTTP_QUERY_URI),
3510             FE(HTTP_QUERY_DERIVED_FROM),
3511             FE(HTTP_QUERY_COST),
3512             FE(HTTP_QUERY_LINK),
3513             FE(HTTP_QUERY_PRAGMA),
3514             FE(HTTP_QUERY_VERSION),
3515             FE(HTTP_QUERY_STATUS_CODE),
3516             FE(HTTP_QUERY_STATUS_TEXT),
3517             FE(HTTP_QUERY_RAW_HEADERS),
3518             FE(HTTP_QUERY_RAW_HEADERS_CRLF),
3519             FE(HTTP_QUERY_CONNECTION),
3520             FE(HTTP_QUERY_ACCEPT),
3521             FE(HTTP_QUERY_ACCEPT_CHARSET),
3522             FE(HTTP_QUERY_ACCEPT_ENCODING),
3523             FE(HTTP_QUERY_ACCEPT_LANGUAGE),
3524             FE(HTTP_QUERY_AUTHORIZATION),
3525             FE(HTTP_QUERY_CONTENT_ENCODING),
3526             FE(HTTP_QUERY_FORWARDED),
3527             FE(HTTP_QUERY_FROM),
3528             FE(HTTP_QUERY_IF_MODIFIED_SINCE),
3529             FE(HTTP_QUERY_LOCATION),
3530             FE(HTTP_QUERY_ORIG_URI),
3531             FE(HTTP_QUERY_REFERER),
3532             FE(HTTP_QUERY_RETRY_AFTER),
3533             FE(HTTP_QUERY_SERVER),
3534             FE(HTTP_QUERY_TITLE),
3535             FE(HTTP_QUERY_USER_AGENT),
3536             FE(HTTP_QUERY_WWW_AUTHENTICATE),
3537             FE(HTTP_QUERY_PROXY_AUTHENTICATE),
3538             FE(HTTP_QUERY_ACCEPT_RANGES),
3539         FE(HTTP_QUERY_SET_COOKIE),
3540         FE(HTTP_QUERY_COOKIE),
3541             FE(HTTP_QUERY_REQUEST_METHOD),
3542             FE(HTTP_QUERY_REFRESH),
3543             FE(HTTP_QUERY_CONTENT_DISPOSITION),
3544             FE(HTTP_QUERY_AGE),
3545             FE(HTTP_QUERY_CACHE_CONTROL),
3546             FE(HTTP_QUERY_CONTENT_BASE),
3547             FE(HTTP_QUERY_CONTENT_LOCATION),
3548             FE(HTTP_QUERY_CONTENT_MD5),
3549             FE(HTTP_QUERY_CONTENT_RANGE),
3550             FE(HTTP_QUERY_ETAG),
3551             FE(HTTP_QUERY_HOST),
3552             FE(HTTP_QUERY_IF_MATCH),
3553             FE(HTTP_QUERY_IF_NONE_MATCH),
3554             FE(HTTP_QUERY_IF_RANGE),
3555             FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
3556             FE(HTTP_QUERY_MAX_FORWARDS),
3557             FE(HTTP_QUERY_PROXY_AUTHORIZATION),
3558             FE(HTTP_QUERY_RANGE),
3559             FE(HTTP_QUERY_TRANSFER_ENCODING),
3560             FE(HTTP_QUERY_UPGRADE),
3561             FE(HTTP_QUERY_VARY),
3562             FE(HTTP_QUERY_VIA),
3563             FE(HTTP_QUERY_WARNING),
3564             FE(HTTP_QUERY_CUSTOM)
3565         };
3566         static const wininet_flag_info modifier_flags[] = {
3567             FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
3568             FE(HTTP_QUERY_FLAG_SYSTEMTIME),
3569             FE(HTTP_QUERY_FLAG_NUMBER),
3570             FE(HTTP_QUERY_FLAG_COALESCE)
3571         };
3572 #undef FE
3573         DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
3574         DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
3575         DWORD i;
3576
3577         TRACE("(%p, 0x%08x)--> %d\n", hHttpRequest, dwInfoLevel, info);
3578         TRACE("  Attribute:");
3579         for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
3580             if (query_flags[i].val == info) {
3581                 TRACE(" %s", query_flags[i].name);
3582                 break;
3583             }
3584         }
3585         if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
3586             TRACE(" Unknown (%08x)", info);
3587         }
3588
3589         TRACE(" Modifier:");
3590         for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
3591             if (modifier_flags[i].val & info_mod) {
3592                 TRACE(" %s", modifier_flags[i].name);
3593                 info_mod &= ~ modifier_flags[i].val;
3594             }
3595         }
3596
3597         if (info_mod) {
3598             TRACE(" Unknown (%08x)", info_mod);
3599         }
3600         TRACE("\n");
3601     }
3602
3603     request = (http_request_t*) get_handle_object( hHttpRequest );
3604     if (NULL == request ||  request->hdr.htype != WH_HHTTPREQ)
3605     {
3606         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
3607         goto lend;
3608     }
3609
3610     if (lpBuffer == NULL)
3611         *lpdwBufferLength = 0;
3612     res = HTTP_HttpQueryInfoW( request, dwInfoLevel,
3613                                lpBuffer, lpdwBufferLength, lpdwIndex);
3614
3615 lend:
3616     if( request )
3617          WININET_Release( &request->hdr );
3618
3619     TRACE("%u <--\n", res);
3620     if(res != ERROR_SUCCESS)
3621         SetLastError(res);
3622     return res == ERROR_SUCCESS;
3623 }
3624
3625 /***********************************************************************
3626  *           HttpQueryInfoA (WININET.@)
3627  *
3628  * Queries for information about an HTTP request
3629  *
3630  * RETURNS
3631  *    TRUE  on success
3632  *    FALSE on failure
3633  *
3634  */
3635 BOOL WINAPI HttpQueryInfoA(HINTERNET hHttpRequest, DWORD dwInfoLevel,
3636         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
3637 {
3638     BOOL result;
3639     DWORD len;
3640     WCHAR* bufferW;
3641
3642     if((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
3643        (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME))
3644     {
3645         return HttpQueryInfoW( hHttpRequest, dwInfoLevel, lpBuffer,
3646                                lpdwBufferLength, lpdwIndex );
3647     }
3648
3649     if (lpBuffer)
3650     {
3651         DWORD alloclen;
3652         len = (*lpdwBufferLength)*sizeof(WCHAR);
3653         if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
3654         {
3655             alloclen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, NULL, 0 ) * sizeof(WCHAR);
3656             if (alloclen < len)
3657                 alloclen = len;
3658         }
3659         else
3660             alloclen = len;
3661         bufferW = heap_alloc(alloclen);
3662         /* buffer is in/out because of HTTP_QUERY_CUSTOM */
3663         if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
3664             MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, bufferW, alloclen / sizeof(WCHAR) );
3665     } else
3666     {
3667         bufferW = NULL;
3668         len = 0;
3669     }
3670
3671     result = HttpQueryInfoW( hHttpRequest, dwInfoLevel, bufferW,
3672                            &len, lpdwIndex );
3673     if( result )
3674     {
3675         len = WideCharToMultiByte( CP_ACP,0, bufferW, len / sizeof(WCHAR) + 1,
3676                                      lpBuffer, *lpdwBufferLength, NULL, NULL );
3677         *lpdwBufferLength = len - 1;
3678
3679         TRACE("lpBuffer: %s\n", debugstr_a(lpBuffer));
3680     }
3681     else
3682         /* since the strings being returned from HttpQueryInfoW should be
3683          * only ASCII characters, it is reasonable to assume that all of
3684          * the Unicode characters can be reduced to a single byte */
3685         *lpdwBufferLength = len / sizeof(WCHAR);
3686
3687     heap_free( bufferW );
3688     return result;
3689 }
3690
3691 /***********************************************************************
3692  *           HTTP_GetRedirectURL (internal)
3693  */
3694 static LPWSTR HTTP_GetRedirectURL(http_request_t *request, LPCWSTR lpszUrl)
3695 {
3696     static WCHAR szHttp[] = {'h','t','t','p',0};
3697     static WCHAR szHttps[] = {'h','t','t','p','s',0};
3698     http_session_t *session = request->session;
3699     URL_COMPONENTSW urlComponents;
3700     DWORD url_length = 0;
3701     LPWSTR orig_url;
3702     LPWSTR combined_url;
3703
3704     urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
3705     urlComponents.lpszScheme = (request->hdr.dwFlags & INTERNET_FLAG_SECURE) ? szHttps : szHttp;
3706     urlComponents.dwSchemeLength = 0;
3707     urlComponents.lpszHostName = session->hostName;
3708     urlComponents.dwHostNameLength = 0;
3709     urlComponents.nPort = session->hostPort;
3710     urlComponents.lpszUserName = session->userName;
3711     urlComponents.dwUserNameLength = 0;
3712     urlComponents.lpszPassword = NULL;
3713     urlComponents.dwPasswordLength = 0;
3714     urlComponents.lpszUrlPath = request->path;
3715     urlComponents.dwUrlPathLength = 0;
3716     urlComponents.lpszExtraInfo = NULL;
3717     urlComponents.dwExtraInfoLength = 0;
3718
3719     if (!InternetCreateUrlW(&urlComponents, 0, NULL, &url_length) &&
3720         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
3721         return NULL;
3722
3723     orig_url = heap_alloc(url_length);
3724
3725     /* convert from bytes to characters */
3726     url_length = url_length / sizeof(WCHAR) - 1;
3727     if (!InternetCreateUrlW(&urlComponents, 0, orig_url, &url_length))
3728     {
3729         heap_free(orig_url);
3730         return NULL;
3731     }
3732
3733     url_length = 0;
3734     if (!InternetCombineUrlW(orig_url, lpszUrl, NULL, &url_length, ICU_ENCODE_SPACES_ONLY) &&
3735         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
3736     {
3737         heap_free(orig_url);
3738         return NULL;
3739     }
3740     combined_url = heap_alloc(url_length * sizeof(WCHAR));
3741
3742     if (!InternetCombineUrlW(orig_url, lpszUrl, combined_url, &url_length, ICU_ENCODE_SPACES_ONLY))
3743     {
3744         heap_free(orig_url);
3745         heap_free(combined_url);
3746         return NULL;
3747     }
3748     heap_free(orig_url);
3749     return combined_url;
3750 }
3751
3752
3753 /***********************************************************************
3754  *           HTTP_HandleRedirect (internal)
3755  */
3756 static DWORD HTTP_HandleRedirect(http_request_t *request, LPCWSTR lpszUrl)
3757 {
3758     http_session_t *session = request->session;
3759     appinfo_t *hIC = session->appInfo;
3760     BOOL using_proxy = hIC->proxy && hIC->proxy[0];
3761     WCHAR path[INTERNET_MAX_URL_LENGTH];
3762     int index;
3763
3764     if(lpszUrl[0]=='/')
3765     {
3766         /* if it's an absolute path, keep the same session info */
3767         lstrcpynW(path, lpszUrl, INTERNET_MAX_URL_LENGTH);
3768     }
3769     else
3770     {
3771         URL_COMPONENTSW urlComponents;
3772         WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
3773         static WCHAR szHttp[] = {'h','t','t','p',0};
3774         static WCHAR szHttps[] = {'h','t','t','p','s',0};
3775
3776         userName[0] = 0;
3777         hostName[0] = 0;
3778         protocol[0] = 0;
3779
3780         urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
3781         urlComponents.lpszScheme = protocol;
3782         urlComponents.dwSchemeLength = 32;
3783         urlComponents.lpszHostName = hostName;
3784         urlComponents.dwHostNameLength = MAXHOSTNAME;
3785         urlComponents.lpszUserName = userName;
3786         urlComponents.dwUserNameLength = 1024;
3787         urlComponents.lpszPassword = NULL;
3788         urlComponents.dwPasswordLength = 0;
3789         urlComponents.lpszUrlPath = path;
3790         urlComponents.dwUrlPathLength = 2048;
3791         urlComponents.lpszExtraInfo = NULL;
3792         urlComponents.dwExtraInfoLength = 0;
3793         if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
3794             return INTERNET_GetLastError();
3795
3796         if (!strncmpW(szHttp, urlComponents.lpszScheme, strlenW(szHttp)) &&
3797             (request->hdr.dwFlags & INTERNET_FLAG_SECURE))
3798         {
3799             TRACE("redirect from secure page to non-secure page\n");
3800             /* FIXME: warn about from secure redirect to non-secure page */
3801             request->hdr.dwFlags &= ~INTERNET_FLAG_SECURE;
3802         }
3803         if (!strncmpW(szHttps, urlComponents.lpszScheme, strlenW(szHttps)) &&
3804             !(request->hdr.dwFlags & INTERNET_FLAG_SECURE))
3805         {
3806             TRACE("redirect from non-secure page to secure page\n");
3807             /* FIXME: notify about redirect to secure page */
3808             request->hdr.dwFlags |= INTERNET_FLAG_SECURE;
3809         }
3810
3811         if (urlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
3812         {
3813             if (lstrlenW(protocol)>4) /*https*/
3814                 urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
3815             else /*http*/
3816                 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
3817         }
3818
3819 #if 0
3820         /*
3821          * This upsets redirects to binary files on sourceforge.net
3822          * and gives an html page instead of the target file
3823          * Examination of the HTTP request sent by native wininet.dll
3824          * reveals that it doesn't send a referrer in that case.
3825          * Maybe there's a flag that enables this, or maybe a referrer
3826          * shouldn't be added in case of a redirect.
3827          */
3828
3829         /* consider the current host as the referrer */
3830         if (session->lpszServerName && *session->lpszServerName)
3831             HTTP_ProcessHeader(request, HTTP_REFERER, session->lpszServerName,
3832                            HTTP_ADDHDR_FLAG_REQ|HTTP_ADDREQ_FLAG_REPLACE|
3833                            HTTP_ADDHDR_FLAG_ADD_IF_NEW);
3834 #endif
3835
3836         heap_free(session->hostName);
3837         if (urlComponents.nPort != INTERNET_DEFAULT_HTTP_PORT &&
3838             urlComponents.nPort != INTERNET_DEFAULT_HTTPS_PORT)
3839         {
3840             int len;
3841             static const WCHAR fmt[] = {'%','s',':','%','u',0};
3842             len = lstrlenW(hostName);
3843             len += 7; /* 5 for strlen("65535") + 1 for ":" + 1 for '\0' */
3844             session->hostName = heap_alloc(len*sizeof(WCHAR));
3845             sprintfW(session->hostName, fmt, hostName, urlComponents.nPort);
3846         }
3847         else
3848             session->hostName = heap_strdupW(hostName);
3849
3850         HTTP_ProcessHeader(request, hostW, session->hostName, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
3851
3852         heap_free(session->userName);
3853         session->userName = NULL;
3854         if (userName[0])
3855             session->userName = heap_strdupW(userName);
3856
3857         reset_data_stream(request);
3858
3859         if(!using_proxy) {
3860             if(strcmpiW(session->serverName, hostName)) {
3861                 heap_free(session->serverName);
3862                 session->serverName = heap_strdupW(hostName);
3863             }
3864             session->serverPort = urlComponents.nPort;
3865         }
3866     }
3867     heap_free(request->path);
3868     request->path=NULL;
3869     if (*path)
3870     {
3871         DWORD needed = 0;
3872         HRESULT rc;
3873
3874         rc = UrlEscapeW(path, NULL, &needed, URL_ESCAPE_SPACES_ONLY);
3875         if (rc != E_POINTER)
3876             needed = strlenW(path)+1;
3877         request->path = heap_alloc(needed*sizeof(WCHAR));
3878         rc = UrlEscapeW(path, request->path, &needed,
3879                         URL_ESCAPE_SPACES_ONLY);
3880         if (rc != S_OK)
3881         {
3882             ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
3883             strcpyW(request->path,path);
3884         }
3885     }
3886
3887     /* Remove custom content-type/length headers on redirects.  */
3888     index = HTTP_GetCustomHeaderIndex(request, szContent_Type, 0, TRUE);
3889     if (0 <= index)
3890         HTTP_DeleteCustomHeader(request, index);
3891     index = HTTP_GetCustomHeaderIndex(request, szContent_Length, 0, TRUE);
3892     if (0 <= index)
3893         HTTP_DeleteCustomHeader(request, index);
3894
3895     return ERROR_SUCCESS;
3896 }
3897
3898 /***********************************************************************
3899  *           HTTP_build_req (internal)
3900  *
3901  *  concatenate all the strings in the request together
3902  */
3903 static LPWSTR HTTP_build_req( LPCWSTR *list, int len )
3904 {
3905     LPCWSTR *t;
3906     LPWSTR str;
3907
3908     for( t = list; *t ; t++  )
3909         len += strlenW( *t );
3910     len++;
3911
3912     str = heap_alloc(len*sizeof(WCHAR));
3913     *str = 0;
3914
3915     for( t = list; *t ; t++ )
3916         strcatW( str, *t );
3917
3918     return str;
3919 }
3920
3921 static DWORD HTTP_SecureProxyConnect(http_request_t *request)
3922 {
3923     LPWSTR lpszPath;
3924     LPWSTR requestString;
3925     INT len;
3926     INT cnt;
3927     INT responseLen;
3928     char *ascii_req;
3929     DWORD res;
3930     static const WCHAR szConnect[] = {'C','O','N','N','E','C','T',0};
3931     static const WCHAR szFormat[] = {'%','s',':','%','u',0};
3932     http_session_t *session = request->session;
3933
3934     TRACE("\n");
3935
3936     lpszPath = heap_alloc((lstrlenW( session->hostName ) + 13)*sizeof(WCHAR));
3937     sprintfW( lpszPath, szFormat, session->hostName, session->hostPort );
3938     requestString = HTTP_BuildHeaderRequestString( request, szConnect, lpszPath, g_szHttp1_1 );
3939     heap_free( lpszPath );
3940
3941     len = WideCharToMultiByte( CP_ACP, 0, requestString, -1,
3942                                 NULL, 0, NULL, NULL );
3943     len--; /* the nul terminator isn't needed */
3944     ascii_req = heap_alloc(len);
3945     WideCharToMultiByte( CP_ACP, 0, requestString, -1, ascii_req, len, NULL, NULL );
3946     heap_free( requestString );
3947
3948     TRACE("full request -> %s\n", debugstr_an( ascii_req, len ) );
3949
3950     res = NETCON_send( request->netconn, ascii_req, len, 0, &cnt );
3951     heap_free( ascii_req );
3952     if (res != ERROR_SUCCESS)
3953         return res;
3954
3955     responseLen = HTTP_GetResponseHeaders( request, TRUE );
3956     if (!responseLen)
3957         return ERROR_HTTP_INVALID_HEADER;
3958
3959     return ERROR_SUCCESS;
3960 }
3961
3962 static void HTTP_InsertCookies(http_request_t *request)
3963 {
3964     DWORD cookie_size, size, cnt = 0;
3965     HTTPHEADERW *host;
3966     WCHAR *cookies;
3967
3968     static const WCHAR cookieW[] = {'C','o','o','k','i','e',':',' ',0};
3969
3970     host = HTTP_GetHeader(request, hostW);
3971     if(!host)
3972         return;
3973
3974     if(!get_cookie(host->lpszValue, request->path, NULL, &cookie_size))
3975         return;
3976
3977     size = sizeof(cookieW) + cookie_size * sizeof(WCHAR) + sizeof(szCrLf);
3978     if(!(cookies = heap_alloc(size)))
3979         return;
3980
3981     cnt += sprintfW(cookies, cookieW);
3982     get_cookie(host->lpszValue, request->path, cookies+cnt, &cookie_size);
3983     strcatW(cookies, szCrLf);
3984
3985     HTTP_HttpAddRequestHeadersW(request, cookies, strlenW(cookies), HTTP_ADDREQ_FLAG_REPLACE);
3986
3987     heap_free(cookies);
3988 }
3989
3990 static WORD HTTP_ParseDay(LPCWSTR day)
3991 {
3992     static const WCHAR days[7][4] = {{ 's','u','n',0 },
3993                                      { 'm','o','n',0 },
3994                                      { 't','u','e',0 },
3995                                      { 'w','e','d',0 },
3996                                      { 't','h','u',0 },
3997                                      { 'f','r','i',0 },
3998                                      { 's','a','t',0 }};
3999     int i;
4000     for (i = 0; i < sizeof(days)/sizeof(*days); i++)
4001         if (!strcmpiW(day, days[i]))
4002             return i;
4003
4004     /* Invalid */
4005     return 7;
4006 }
4007
4008 static WORD HTTP_ParseMonth(LPCWSTR month)
4009 {
4010     static const WCHAR jan[] = { 'j','a','n',0 };
4011     static const WCHAR feb[] = { 'f','e','b',0 };
4012     static const WCHAR mar[] = { 'm','a','r',0 };
4013     static const WCHAR apr[] = { 'a','p','r',0 };
4014     static const WCHAR may[] = { 'm','a','y',0 };
4015     static const WCHAR jun[] = { 'j','u','n',0 };
4016     static const WCHAR jul[] = { 'j','u','l',0 };
4017     static const WCHAR aug[] = { 'a','u','g',0 };
4018     static const WCHAR sep[] = { 's','e','p',0 };
4019     static const WCHAR oct[] = { 'o','c','t',0 };
4020     static const WCHAR nov[] = { 'n','o','v',0 };
4021     static const WCHAR dec[] = { 'd','e','c',0 };
4022
4023     if (!strcmpiW(month, jan)) return 1;
4024     if (!strcmpiW(month, feb)) return 2;
4025     if (!strcmpiW(month, mar)) return 3;
4026     if (!strcmpiW(month, apr)) return 4;
4027     if (!strcmpiW(month, may)) return 5;
4028     if (!strcmpiW(month, jun)) return 6;
4029     if (!strcmpiW(month, jul)) return 7;
4030     if (!strcmpiW(month, aug)) return 8;
4031     if (!strcmpiW(month, sep)) return 9;
4032     if (!strcmpiW(month, oct)) return 10;
4033     if (!strcmpiW(month, nov)) return 11;
4034     if (!strcmpiW(month, dec)) return 12;
4035     /* Invalid */
4036     return 0;
4037 }
4038
4039 /* Parses the string pointed to by *str, assumed to be a 24-hour time HH:MM:SS,
4040  * optionally preceded by whitespace.
4041  * Upon success, returns TRUE, sets the wHour, wMinute, and wSecond fields of
4042  * st, and sets *str to the first character after the time format.
4043  */
4044 static BOOL HTTP_ParseTime(SYSTEMTIME *st, LPCWSTR *str)
4045 {
4046     LPCWSTR ptr = *str;
4047     WCHAR *nextPtr;
4048     unsigned long num;
4049
4050     while (isspaceW(*ptr))
4051         ptr++;
4052
4053     num = strtoulW(ptr, &nextPtr, 10);
4054     if (!nextPtr || nextPtr <= ptr || *nextPtr != ':')
4055     {
4056         ERR("unexpected time format %s\n", debugstr_w(ptr));
4057         return FALSE;
4058     }
4059     if (num > 23)
4060     {
4061         ERR("unexpected hour in time format %s\n", debugstr_w(ptr));
4062         return FALSE;
4063     }
4064     ptr = nextPtr + 1;
4065     st->wHour = (WORD)num;
4066     num = strtoulW(ptr, &nextPtr, 10);
4067     if (!nextPtr || nextPtr <= ptr || *nextPtr != ':')
4068     {
4069         ERR("unexpected time format %s\n", debugstr_w(ptr));
4070         return FALSE;
4071     }
4072     if (num > 59)
4073     {
4074         ERR("unexpected minute in time format %s\n", debugstr_w(ptr));
4075         return FALSE;
4076     }
4077     ptr = nextPtr + 1;
4078     st->wMinute = (WORD)num;
4079     num = strtoulW(ptr, &nextPtr, 10);
4080     if (!nextPtr || nextPtr <= ptr)
4081     {
4082         ERR("unexpected time format %s\n", debugstr_w(ptr));
4083         return FALSE;
4084     }
4085     if (num > 59)
4086     {
4087         ERR("unexpected second in time format %s\n", debugstr_w(ptr));
4088         return FALSE;
4089     }
4090     ptr = nextPtr + 1;
4091     *str = ptr;
4092     st->wSecond = (WORD)num;
4093     return TRUE;
4094 }
4095
4096 static BOOL HTTP_ParseDateAsAsctime(LPCWSTR value, FILETIME *ft)
4097 {
4098     static const WCHAR gmt[]= { 'G','M','T',0 };
4099     WCHAR day[4], *dayPtr, month[4], *monthPtr, *nextPtr;
4100     LPCWSTR ptr;
4101     SYSTEMTIME st = { 0 };
4102     unsigned long num;
4103
4104     for (ptr = value, dayPtr = day; *ptr && !isspaceW(*ptr) &&
4105          dayPtr - day < sizeof(day) / sizeof(day[0]) - 1; ptr++, dayPtr++)
4106         *dayPtr = *ptr;
4107     *dayPtr = 0;
4108     st.wDayOfWeek = HTTP_ParseDay(day);
4109     if (st.wDayOfWeek >= 7)
4110     {
4111         ERR("unexpected weekday %s\n", debugstr_w(day));
4112         return FALSE;
4113     }
4114
4115     while (isspaceW(*ptr))
4116         ptr++;
4117
4118     for (monthPtr = month; !isspace(*ptr) &&
4119          monthPtr - month < sizeof(month) / sizeof(month[0]) - 1;
4120          monthPtr++, ptr++)
4121         *monthPtr = *ptr;
4122     *monthPtr = 0;
4123     st.wMonth = HTTP_ParseMonth(month);
4124     if (!st.wMonth || st.wMonth > 12)
4125     {
4126         ERR("unexpected month %s\n", debugstr_w(month));
4127         return FALSE;
4128     }
4129
4130     while (isspaceW(*ptr))
4131         ptr++;
4132
4133     num = strtoulW(ptr, &nextPtr, 10);
4134     if (!nextPtr || nextPtr <= ptr || !num || num > 31)
4135     {
4136         ERR("unexpected day %s\n", debugstr_w(ptr));
4137         return FALSE;
4138     }
4139     ptr = nextPtr;
4140     st.wDay = (WORD)num;
4141
4142     while (isspaceW(*ptr))
4143         ptr++;
4144
4145     if (!HTTP_ParseTime(&st, &ptr))
4146         return FALSE;
4147
4148     while (isspaceW(*ptr))
4149         ptr++;
4150
4151     num = strtoulW(ptr, &nextPtr, 10);
4152     if (!nextPtr || nextPtr <= ptr || num < 1601 || num > 30827)
4153     {
4154         ERR("unexpected year %s\n", debugstr_w(ptr));
4155         return FALSE;
4156     }
4157     ptr = nextPtr;
4158     st.wYear = (WORD)num;
4159
4160     while (isspaceW(*ptr))
4161         ptr++;
4162
4163     /* asctime() doesn't report a timezone, but some web servers do, so accept
4164      * with or without GMT.
4165      */
4166     if (*ptr && strcmpW(ptr, gmt))
4167     {
4168         ERR("unexpected timezone %s\n", debugstr_w(ptr));
4169         return FALSE;
4170     }
4171     return SystemTimeToFileTime(&st, ft);
4172 }
4173
4174 static BOOL HTTP_ParseRfc1123Date(LPCWSTR value, FILETIME *ft)
4175 {
4176     static const WCHAR gmt[]= { 'G','M','T',0 };
4177     WCHAR *nextPtr, day[4], month[4], *monthPtr;
4178     LPCWSTR ptr;
4179     unsigned long num;
4180     SYSTEMTIME st = { 0 };
4181
4182     ptr = strchrW(value, ',');
4183     if (!ptr)
4184         return FALSE;
4185     if (ptr - value != 3)
4186     {
4187         ERR("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4188         return FALSE;
4189     }
4190     memcpy(day, value, (ptr - value) * sizeof(WCHAR));
4191     day[3] = 0;
4192     st.wDayOfWeek = HTTP_ParseDay(day);
4193     if (st.wDayOfWeek > 6)
4194     {
4195         ERR("unexpected weekday %s\n", debugstr_wn(value, ptr - value));
4196         return FALSE;
4197     }
4198     ptr++;
4199
4200     while (isspaceW(*ptr))
4201         ptr++;
4202
4203     num = strtoulW(ptr, &nextPtr, 10);
4204     if (!nextPtr || nextPtr <= ptr || !num || num > 31)
4205     {
4206         ERR("unexpected day %s\n", debugstr_w(value));
4207         return FALSE;
4208     }
4209     ptr = nextPtr;
4210     st.wDay = (WORD)num;
4211
4212     while (isspaceW(*ptr))
4213         ptr++;
4214
4215     for (monthPtr = month; !isspace(*ptr) &&
4216          monthPtr - month < sizeof(month) / sizeof(month[0]) - 1;
4217          monthPtr++, ptr++)
4218         *monthPtr = *ptr;
4219     *monthPtr = 0;
4220     st.wMonth = HTTP_ParseMonth(month);
4221     if (!st.wMonth || st.wMonth > 12)
4222     {
4223         ERR("unexpected month %s\n", debugstr_w(month));
4224         return FALSE;
4225     }
4226
4227     while (isspaceW(*ptr))
4228         ptr++;
4229
4230     num = strtoulW(ptr, &nextPtr, 10);
4231     if (!nextPtr || nextPtr <= ptr || num < 1601 || num > 30827)
4232     {
4233         ERR("unexpected year %s\n", debugstr_w(value));
4234         return FALSE;
4235     }
4236     ptr = nextPtr;
4237     st.wYear = (WORD)num;
4238
4239     if (!HTTP_ParseTime(&st, &ptr))
4240         return FALSE;
4241
4242     while (isspaceW(*ptr))
4243         ptr++;
4244
4245     if (strcmpW(ptr, gmt))
4246     {
4247         ERR("unexpected time zone %s\n", debugstr_w(ptr));
4248         return FALSE;
4249     }
4250     return SystemTimeToFileTime(&st, ft);
4251 }
4252
4253 /* FIXME: only accepts dates in RFC 1123 format and asctime() format,
4254  * which may not be the only formats actually seen in the wild.
4255  * http://www.hackcraft.net/web/datetime/ suggests at least RFC 850 dates
4256  * should be accepted as well.
4257  */
4258 static BOOL HTTP_ParseDate(LPCWSTR value, FILETIME *ft)
4259 {
4260     static const WCHAR zero[] = { '0',0 };
4261     BOOL ret;
4262
4263     if (!strcmpW(value, zero))
4264     {
4265         ft->dwLowDateTime = ft->dwHighDateTime = 0;
4266         ret = TRUE;
4267     }
4268     else if (strchrW(value, ','))
4269         ret = HTTP_ParseRfc1123Date(value, ft);
4270     else
4271     {
4272         ret = HTTP_ParseDateAsAsctime(value, ft);
4273         if (!ret)
4274             ERR("unexpected date format %s\n", debugstr_w(value));
4275     }
4276     return ret;
4277 }
4278
4279 static void HTTP_ProcessExpires(http_request_t *request)
4280 {
4281     BOOL expirationFound = FALSE;
4282     int headerIndex;
4283
4284     /* Look for a Cache-Control header with a max-age directive, as it takes
4285      * precedence over the Expires header.
4286      */
4287     headerIndex = HTTP_GetCustomHeaderIndex(request, szCache_Control, 0, FALSE);
4288     if (headerIndex != -1)
4289     {
4290         LPHTTPHEADERW ccHeader = &request->custHeaders[headerIndex];
4291         LPWSTR ptr;
4292
4293         for (ptr = ccHeader->lpszValue; ptr && *ptr; )
4294         {
4295             LPWSTR comma = strchrW(ptr, ','), end, equal;
4296
4297             if (comma)
4298                 end = comma;
4299             else
4300                 end = ptr + strlenW(ptr);
4301             for (equal = end - 1; equal > ptr && *equal != '='; equal--)
4302                 ;
4303             if (*equal == '=')
4304             {
4305                 static const WCHAR max_age[] = {
4306                     'm','a','x','-','a','g','e',0 };
4307
4308                 if (!strncmpiW(ptr, max_age, equal - ptr - 1))
4309                 {
4310                     LPWSTR nextPtr;
4311                     unsigned long age;
4312
4313                     age = strtoulW(equal + 1, &nextPtr, 10);
4314                     if (nextPtr > equal + 1)
4315                     {
4316                         LARGE_INTEGER ft;
4317
4318                         NtQuerySystemTime( &ft );
4319                         /* Age is in seconds, FILETIME resolution is in
4320                          * 100 nanosecond intervals.
4321                          */
4322                         ft.QuadPart += age * (ULONGLONG)1000000;
4323                         request->expires.dwLowDateTime = ft.u.LowPart;
4324                         request->expires.dwHighDateTime = ft.u.HighPart;
4325                         expirationFound = TRUE;
4326                     }
4327                 }
4328             }
4329             if (comma)
4330             {
4331                 ptr = comma + 1;
4332                 while (isspaceW(*ptr))
4333                     ptr++;
4334             }
4335             else
4336                 ptr = NULL;
4337         }
4338     }
4339     if (!expirationFound)
4340     {
4341         headerIndex = HTTP_GetCustomHeaderIndex(request, szExpires, 0, FALSE);
4342         if (headerIndex != -1)
4343         {
4344             LPHTTPHEADERW expiresHeader = &request->custHeaders[headerIndex];
4345             FILETIME ft;
4346
4347             if (HTTP_ParseDate(expiresHeader->lpszValue, &ft))
4348             {
4349                 expirationFound = TRUE;
4350                 request->expires = ft;
4351             }
4352         }
4353     }
4354     if (!expirationFound)
4355     {
4356         LARGE_INTEGER t;
4357
4358         /* With no known age, default to 10 minutes until expiration. */
4359         NtQuerySystemTime( &t );
4360         t.QuadPart += 10 * 60 * (ULONGLONG)10000000;
4361         request->expires.dwLowDateTime = t.u.LowPart;
4362         request->expires.dwHighDateTime = t.u.HighPart;
4363     }
4364 }
4365
4366 static void HTTP_ProcessLastModified(http_request_t *request)
4367 {
4368     int headerIndex;
4369
4370     headerIndex = HTTP_GetCustomHeaderIndex(request, szLast_Modified, 0, FALSE);
4371     if (headerIndex != -1)
4372     {
4373         LPHTTPHEADERW expiresHeader = &request->custHeaders[headerIndex];
4374         FILETIME ft;
4375
4376         if (HTTP_ParseDate(expiresHeader->lpszValue, &ft))
4377             request->last_modified = ft;
4378     }
4379 }
4380
4381 static void http_process_keep_alive(http_request_t *req)
4382 {
4383     int index;
4384
4385     index = HTTP_GetCustomHeaderIndex(req, szConnection, 0, FALSE);
4386     if(index != -1)
4387         req->netconn->keep_alive = !strcmpiW(req->custHeaders[index].lpszValue, szKeepAlive);
4388     else
4389         req->netconn->keep_alive = !strcmpiW(req->version, g_szHttp1_1);
4390 }
4391
4392 static void HTTP_CacheRequest(http_request_t *request)
4393 {
4394     WCHAR url[INTERNET_MAX_URL_LENGTH];
4395     WCHAR cacheFileName[MAX_PATH+1];
4396     BOOL b;
4397
4398     b = HTTP_GetRequestURL(request, url);
4399     if(!b) {
4400         WARN("Could not get URL\n");
4401         return;
4402     }
4403
4404     b = CreateUrlCacheEntryW(url, request->contentLength, NULL, cacheFileName, 0);
4405     if(b) {
4406         heap_free(request->cacheFile);
4407         CloseHandle(request->hCacheFile);
4408
4409         request->cacheFile = heap_strdupW(cacheFileName);
4410         request->hCacheFile = CreateFileW(request->cacheFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
4411                   NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
4412         if(request->hCacheFile == INVALID_HANDLE_VALUE) {
4413             WARN("Could not create file: %u\n", GetLastError());
4414             request->hCacheFile = NULL;
4415         }
4416     }else {
4417         WARN("Could not create cache entry: %08x\n", GetLastError());
4418     }
4419 }
4420
4421 static DWORD open_http_connection(http_request_t *request, BOOL *reusing)
4422 {
4423     const BOOL is_https = (request->hdr.dwFlags & INTERNET_FLAG_SECURE) != 0;
4424     http_session_t *session = request->session;
4425     netconn_t *netconn = NULL;
4426     server_t *server;
4427     DWORD res;
4428
4429     assert(!request->netconn);
4430     reset_data_stream(request);
4431
4432     server = get_server(session->serverName, session->serverPort);
4433     if(!server)
4434         return ERROR_OUTOFMEMORY;
4435
4436     res = HTTP_ResolveName(request, server);
4437     if(res != ERROR_SUCCESS) {
4438         server_release(server);
4439         return res;
4440     }
4441
4442     EnterCriticalSection(&connection_pool_cs);
4443
4444     while(!list_empty(&server->conn_pool)) {
4445         netconn = LIST_ENTRY(list_head(&server->conn_pool), netconn_t, pool_entry);
4446         list_remove(&netconn->pool_entry);
4447
4448         if(NETCON_is_alive(netconn))
4449             break;
4450
4451         TRACE("connection %p closed during idle\n", netconn);
4452         free_netconn(netconn);
4453         netconn = NULL;
4454     }
4455
4456     LeaveCriticalSection(&connection_pool_cs);
4457
4458     if(netconn) {
4459         TRACE("<-- reusing %p netconn\n", netconn);
4460         request->netconn = netconn;
4461         *reusing = TRUE;
4462         return ERROR_SUCCESS;
4463     }
4464
4465     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4466                           INTERNET_STATUS_CONNECTING_TO_SERVER,
4467                           server->addr_str,
4468                           strlen(server->addr_str)+1);
4469
4470     res = create_netconn(is_https, server, request->security_flags, &netconn);
4471     server_release(server);
4472     if(res != ERROR_SUCCESS) {
4473         ERR("create_netconn failed: %u\n", res);
4474         return res;
4475     }
4476
4477     request->netconn = netconn;
4478
4479     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4480             INTERNET_STATUS_CONNECTED_TO_SERVER,
4481             server->addr_str, strlen(server->addr_str)+1);
4482
4483     if(is_https) {
4484         /* Note: we differ from Microsoft's WinINet here. they seem to have
4485          * a bug that causes no status callbacks to be sent when starting
4486          * a tunnel to a proxy server using the CONNECT verb. i believe our
4487          * behaviour to be more correct and to not cause any incompatibilities
4488          * because using a secure connection through a proxy server is a rare
4489          * case that would be hard for anyone to depend on */
4490         if(session->appInfo->proxy)
4491             res = HTTP_SecureProxyConnect(request);
4492         if(res == ERROR_SUCCESS)
4493             res = NETCON_secure_connect(request->netconn, session->hostName);
4494         if(res != ERROR_SUCCESS)
4495         {
4496             WARN("Couldn't connect securely to host\n");
4497
4498             if((request->hdr.ErrorMask&INTERNET_ERROR_MASK_COMBINED_SEC_CERT) && (
4499                     res == ERROR_INTERNET_SEC_CERT_DATE_INVALID
4500                     || res == ERROR_INTERNET_INVALID_CA
4501                     || res == ERROR_INTERNET_SEC_CERT_NO_REV
4502                     || res == ERROR_INTERNET_SEC_CERT_REV_FAILED
4503                     || res == ERROR_INTERNET_SEC_CERT_REVOKED
4504                     || res == ERROR_INTERNET_SEC_INVALID_CERT
4505                     || res == ERROR_INTERNET_SEC_CERT_CN_INVALID))
4506                 res = ERROR_INTERNET_SEC_CERT_ERRORS;
4507         }
4508     }
4509
4510     if(res != ERROR_SUCCESS) {
4511         http_release_netconn(request, FALSE);
4512         return res;
4513     }
4514
4515     *reusing = FALSE;
4516     TRACE("Created connection to %s: %p\n", debugstr_w(server->name), netconn);
4517     return ERROR_SUCCESS;
4518 }
4519
4520 /***********************************************************************
4521  *           HTTP_HttpSendRequestW (internal)
4522  *
4523  * Sends the specified request to the HTTP server
4524  *
4525  * RETURNS
4526  *    ERROR_SUCCESS on success
4527  *    win32 error code on failure
4528  *
4529  */
4530 static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders,
4531         DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength,
4532         DWORD dwContentLength, BOOL bEndRequest)
4533 {
4534     INT cnt;
4535     BOOL redirected = FALSE;
4536     LPWSTR requestString = NULL;
4537     INT responseLen;
4538     BOOL loop_next;
4539     static const WCHAR szPost[] = { 'P','O','S','T',0 };
4540     static const WCHAR szContentLength[] =
4541         { 'C','o','n','t','e','n','t','-','L','e','n','g','t','h',':',' ','%','l','i','\r','\n',0 };
4542     WCHAR contentLengthStr[sizeof szContentLength/2 /* includes \r\n */ + 20 /* int */ ];
4543     DWORD res;
4544
4545     TRACE("--> %p\n", request);
4546
4547     assert(request->hdr.htype == WH_HHTTPREQ);
4548
4549     /* if the verb is NULL default to GET */
4550     if (!request->verb)
4551         request->verb = heap_strdupW(szGET);
4552
4553     if (dwContentLength || strcmpW(request->verb, szGET))
4554     {
4555         sprintfW(contentLengthStr, szContentLength, dwContentLength);
4556         HTTP_HttpAddRequestHeadersW(request, contentLengthStr, -1L, HTTP_ADDREQ_FLAG_REPLACE);
4557         request->bytesToWrite = dwContentLength;
4558     }
4559     if (request->session->appInfo->agent)
4560     {
4561         WCHAR *agent_header;
4562         static const WCHAR user_agent[] = {'U','s','e','r','-','A','g','e','n','t',':',' ','%','s','\r','\n',0};
4563         int len;
4564
4565         len = strlenW(request->session->appInfo->agent) + strlenW(user_agent);
4566         agent_header = heap_alloc(len * sizeof(WCHAR));
4567         sprintfW(agent_header, user_agent, request->session->appInfo->agent);
4568
4569         HTTP_HttpAddRequestHeadersW(request, agent_header, strlenW(agent_header), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4570         heap_free(agent_header);
4571     }
4572     if (request->hdr.dwFlags & INTERNET_FLAG_PRAGMA_NOCACHE)
4573     {
4574         static const WCHAR pragma_nocache[] = {'P','r','a','g','m','a',':',' ','n','o','-','c','a','c','h','e','\r','\n',0};
4575         HTTP_HttpAddRequestHeadersW(request, pragma_nocache, strlenW(pragma_nocache), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4576     }
4577     if ((request->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && !strcmpW(request->verb, szPost))
4578     {
4579         static const WCHAR cache_control[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',':',
4580                                               ' ','n','o','-','c','a','c','h','e','\r','\n',0};
4581         HTTP_HttpAddRequestHeadersW(request, cache_control, strlenW(cache_control), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
4582     }
4583
4584     do
4585     {
4586         DWORD len;
4587         BOOL reusing_connection;
4588         char *ascii_req;
4589
4590         loop_next = FALSE;
4591
4592         /* like native, just in case the caller forgot to call InternetReadFile
4593          * for all the data */
4594         drain_content(request);
4595         if(redirected) {
4596             request->contentLength = ~0u;
4597             request->bytesToWrite = 0;
4598         }
4599
4600         if (TRACE_ON(wininet))
4601         {
4602             LPHTTPHEADERW Host = HTTP_GetHeader(request, hostW);
4603             TRACE("Going to url %s %s\n", debugstr_w(Host->lpszValue), debugstr_w(request->path));
4604         }
4605
4606         HTTP_FixURL(request);
4607         if (request->hdr.dwFlags & INTERNET_FLAG_KEEP_CONNECTION)
4608         {
4609             HTTP_ProcessHeader(request, szConnection, szKeepAlive, HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE);
4610         }
4611         HTTP_InsertAuthorization(request, request->authInfo, szAuthorization);
4612         HTTP_InsertAuthorization(request, request->proxyAuthInfo, szProxy_Authorization);
4613
4614         if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES))
4615             HTTP_InsertCookies(request);
4616
4617         /* add the headers the caller supplied */
4618         if( lpszHeaders && dwHeaderLength )
4619         {
4620             HTTP_HttpAddRequestHeadersW(request, lpszHeaders, dwHeaderLength,
4621                         HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE);
4622         }
4623
4624         if (request->session->appInfo->proxy && request->session->appInfo->proxy[0])
4625         {
4626             WCHAR *url = HTTP_BuildProxyRequestUrl(request);
4627             requestString = HTTP_BuildHeaderRequestString(request, request->verb, url, request->version);
4628             heap_free(url);
4629         }
4630         else
4631             requestString = HTTP_BuildHeaderRequestString(request, request->verb, request->path, request->version);
4632
4633
4634         TRACE("Request header -> %s\n", debugstr_w(requestString) );
4635
4636         if ((res = open_http_connection(request, &reusing_connection)) != ERROR_SUCCESS)
4637             break;
4638
4639         /* send the request as ASCII, tack on the optional data */
4640         if (!lpOptional || redirected)
4641             dwOptionalLength = 0;
4642         len = WideCharToMultiByte( CP_ACP, 0, requestString, -1,
4643                                    NULL, 0, NULL, NULL );
4644         ascii_req = heap_alloc(len + dwOptionalLength);
4645         WideCharToMultiByte( CP_ACP, 0, requestString, -1,
4646                              ascii_req, len, NULL, NULL );
4647         if( lpOptional )
4648             memcpy( &ascii_req[len-1], lpOptional, dwOptionalLength );
4649         len = (len + dwOptionalLength - 1);
4650         ascii_req[len] = 0;
4651         TRACE("full request -> %s\n", debugstr_a(ascii_req) );
4652
4653         INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4654                               INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
4655
4656         res = NETCON_send(request->netconn, ascii_req, len, 0, &cnt);
4657         heap_free( ascii_req );
4658         if(res != ERROR_SUCCESS) {
4659             TRACE("send failed: %u\n", res);
4660             if(!reusing_connection)
4661                 break;
4662             http_release_netconn(request, FALSE);
4663             loop_next = TRUE;
4664             continue;
4665         }
4666
4667         request->bytesWritten = dwOptionalLength;
4668
4669         INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4670                               INTERNET_STATUS_REQUEST_SENT,
4671                               &len, sizeof(DWORD));
4672
4673         if (bEndRequest)
4674         {
4675             DWORD dwBufferSize;
4676             DWORD dwStatusCode;
4677
4678             INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4679                                 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
4680
4681             responseLen = HTTP_GetResponseHeaders(request, TRUE);
4682             /* FIXME: We should know that connection is closed before sending
4683              * headers. Otherwise wrong callbacks are executed */
4684             if(!responseLen && reusing_connection) {
4685                 TRACE("Connection closed by server, reconnecting\n");
4686                 http_release_netconn(request, FALSE);
4687                 loop_next = TRUE;
4688                 continue;
4689             }
4690
4691             INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4692                                 INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen,
4693                                 sizeof(DWORD));
4694
4695             http_process_keep_alive(request);
4696             HTTP_ProcessCookies(request);
4697             HTTP_ProcessExpires(request);
4698             HTTP_ProcessLastModified(request);
4699
4700             dwBufferSize = sizeof(dwStatusCode);
4701             if (HTTP_HttpQueryInfoW(request,HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,
4702                                     &dwStatusCode,&dwBufferSize,NULL) != ERROR_SUCCESS)
4703                 dwStatusCode = 0;
4704
4705             res = set_content_length(request, dwStatusCode);
4706             if(res != ERROR_SUCCESS)
4707                 goto lend;
4708             if(!request->contentLength)
4709                 http_release_netconn(request, TRUE);
4710
4711             if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT) && responseLen)
4712             {
4713                 WCHAR *new_url, szNewLocation[INTERNET_MAX_URL_LENGTH];
4714                 dwBufferSize=sizeof(szNewLocation);
4715                 if ((dwStatusCode == HTTP_STATUS_REDIRECT ||
4716                      dwStatusCode == HTTP_STATUS_MOVED ||
4717                      dwStatusCode == HTTP_STATUS_REDIRECT_KEEP_VERB ||
4718                      dwStatusCode == HTTP_STATUS_REDIRECT_METHOD) &&
4719                     HTTP_HttpQueryInfoW(request,HTTP_QUERY_LOCATION,szNewLocation,&dwBufferSize,NULL) == ERROR_SUCCESS)
4720                 {
4721                     if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD) &&
4722                         dwStatusCode != HTTP_STATUS_REDIRECT_KEEP_VERB)
4723                     {
4724                         heap_free(request->verb);
4725                         request->verb = heap_strdupW(szGET);
4726                     }
4727                     drain_content(request);
4728                     if ((new_url = HTTP_GetRedirectURL( request, szNewLocation )))
4729                     {
4730                         INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REDIRECT,
4731                                               new_url, (strlenW(new_url) + 1) * sizeof(WCHAR));
4732                         res = HTTP_HandleRedirect(request, new_url);
4733                         if (res == ERROR_SUCCESS)
4734                         {
4735                             heap_free(requestString);
4736                             loop_next = TRUE;
4737                         }
4738                         heap_free( new_url );
4739                     }
4740                     redirected = TRUE;
4741                 }
4742             }
4743             if (!(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTH) && res == ERROR_SUCCESS)
4744             {
4745                 WCHAR szAuthValue[2048];
4746                 dwBufferSize=2048;
4747                 if (dwStatusCode == HTTP_STATUS_DENIED)
4748                 {
4749                     LPHTTPHEADERW Host = HTTP_GetHeader(request, hostW);
4750                     DWORD dwIndex = 0;
4751                     while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_WWW_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS)
4752                     {
4753                         if (HTTP_DoAuthorization(request, szAuthValue,
4754                                                  &request->authInfo,
4755                                                  request->session->userName,
4756                                                  request->session->password,
4757                                                  Host->lpszValue))
4758                         {
4759                             heap_free(requestString);
4760                             loop_next = TRUE;
4761                             break;
4762                         }
4763                     }
4764
4765                     if(!loop_next) {
4766                         TRACE("Cleaning wrong authorization data\n");
4767                         destroy_authinfo(request->authInfo);
4768                         request->authInfo = NULL;
4769                     }
4770                 }
4771                 if (dwStatusCode == HTTP_STATUS_PROXY_AUTH_REQ)
4772                 {
4773                     DWORD dwIndex = 0;
4774                     while (HTTP_HttpQueryInfoW(request,HTTP_QUERY_PROXY_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex) == ERROR_SUCCESS)
4775                     {
4776                         if (HTTP_DoAuthorization(request, szAuthValue,
4777                                                  &request->proxyAuthInfo,
4778                                                  request->session->appInfo->proxyUsername,
4779                                                  request->session->appInfo->proxyPassword,
4780                                                  NULL))
4781                         {
4782                             loop_next = TRUE;
4783                             break;
4784                         }
4785                     }
4786
4787                     if(!loop_next) {
4788                         TRACE("Cleaning wrong proxy authorization data\n");
4789                         destroy_authinfo(request->proxyAuthInfo);
4790                         request->proxyAuthInfo = NULL;
4791                     }
4792                 }
4793             }
4794         }
4795         else
4796             res = ERROR_SUCCESS;
4797     }
4798     while (loop_next);
4799
4800     if(res == ERROR_SUCCESS)
4801         HTTP_CacheRequest(request);
4802
4803 lend:
4804     heap_free(requestString);
4805
4806     /* TODO: send notification for P3P header */
4807
4808     if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
4809     {
4810         if (res == ERROR_SUCCESS) {
4811             if(request->contentLength && request->bytesWritten == request->bytesToWrite)
4812                 HTTP_ReceiveRequestData(request, TRUE);
4813             else
4814                 send_request_complete(request,
4815                         request->session->hdr.dwInternalFlags & INET_OPENURL ? (DWORD_PTR)request->hdr.hInternet : 1, 0);
4816         }else {
4817                 send_request_complete(request, 0, res);
4818         }
4819     }
4820
4821     TRACE("<--\n");
4822     return res;
4823 }
4824
4825 /***********************************************************************
4826  *
4827  * Helper functions for the HttpSendRequest(Ex) functions
4828  *
4829  */
4830 static void AsyncHttpSendRequestProc(WORKREQUEST *workRequest)
4831 {
4832     struct WORKREQ_HTTPSENDREQUESTW const *req = &workRequest->u.HttpSendRequestW;
4833     http_request_t *request = (http_request_t*) workRequest->hdr;
4834
4835     TRACE("%p\n", request);
4836
4837     HTTP_HttpSendRequestW(request, req->lpszHeader,
4838             req->dwHeaderLength, req->lpOptional, req->dwOptionalLength,
4839             req->dwContentLength, req->bEndRequest);
4840
4841     heap_free(req->lpszHeader);
4842 }
4843
4844
4845 static DWORD HTTP_HttpEndRequestW(http_request_t *request, DWORD dwFlags, DWORD_PTR dwContext)
4846 {
4847     INT responseLen;
4848     DWORD dwCode, dwCodeLength;
4849     DWORD dwBufferSize;
4850     DWORD res = ERROR_SUCCESS;
4851
4852     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4853                   INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
4854
4855     responseLen = HTTP_GetResponseHeaders(request, TRUE);
4856     if (!responseLen)
4857         res = ERROR_HTTP_HEADER_NOT_FOUND;
4858
4859     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
4860                   INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen, sizeof(DWORD));
4861
4862     /* process cookies here. Is this right? */
4863     http_process_keep_alive(request);
4864     HTTP_ProcessCookies(request);
4865     HTTP_ProcessExpires(request);
4866     HTTP_ProcessLastModified(request);
4867
4868     dwCodeLength = sizeof(dwCode);
4869     if (HTTP_HttpQueryInfoW(request,HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,
4870                             &dwCode,&dwCodeLength,NULL) != ERROR_SUCCESS)
4871         dwCode = 0;
4872
4873     if ((res = set_content_length( request, dwCode )) == ERROR_SUCCESS) {
4874         if(!request->contentLength)
4875             http_release_netconn(request, TRUE);
4876     }
4877
4878     if (res == ERROR_SUCCESS && !(request->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT))
4879     {
4880         if (dwCode == HTTP_STATUS_REDIRECT ||
4881                 dwCode == HTTP_STATUS_MOVED ||
4882                 dwCode == HTTP_STATUS_REDIRECT_METHOD ||
4883                 dwCode == HTTP_STATUS_REDIRECT_KEEP_VERB)
4884         {
4885             WCHAR *new_url, szNewLocation[INTERNET_MAX_URL_LENGTH];
4886             dwBufferSize=sizeof(szNewLocation);
4887             if (HTTP_HttpQueryInfoW(request, HTTP_QUERY_LOCATION, szNewLocation, &dwBufferSize, NULL) == ERROR_SUCCESS)
4888             {
4889                 if (strcmpW(request->verb, szGET) && strcmpW(request->verb, szHEAD) &&
4890                     dwCode != HTTP_STATUS_REDIRECT_KEEP_VERB)
4891                 {
4892                     heap_free(request->verb);
4893                     request->verb = heap_strdupW(szGET);
4894                 }
4895                 drain_content(request);
4896                 if ((new_url = HTTP_GetRedirectURL( request, szNewLocation )))
4897                 {
4898                     INTERNET_SendCallback(&request->hdr, request->hdr.dwContext, INTERNET_STATUS_REDIRECT,
4899                                           new_url, (strlenW(new_url) + 1) * sizeof(WCHAR));
4900                     res = HTTP_HandleRedirect(request, new_url);
4901                     if (res == ERROR_SUCCESS)
4902                         res = HTTP_HttpSendRequestW(request, NULL, 0, NULL, 0, 0, TRUE);
4903                     heap_free( new_url );
4904                 }
4905             }
4906         }
4907     }
4908
4909     if (res == ERROR_SUCCESS && request->contentLength)
4910         HTTP_ReceiveRequestData(request, TRUE);
4911     else
4912         send_request_complete(request, res == ERROR_SUCCESS, res);
4913
4914     return res;
4915 }
4916
4917 /***********************************************************************
4918  *           HttpEndRequestA (WININET.@)
4919  *
4920  * Ends an HTTP request that was started by HttpSendRequestEx
4921  *
4922  * RETURNS
4923  *    TRUE      if successful
4924  *    FALSE     on failure
4925  *
4926  */
4927 BOOL WINAPI HttpEndRequestA(HINTERNET hRequest,
4928         LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
4929 {
4930     TRACE("(%p, %p, %08x, %08lx)\n", hRequest, lpBuffersOut, dwFlags, dwContext);
4931
4932     if (lpBuffersOut)
4933     {
4934         SetLastError(ERROR_INVALID_PARAMETER);
4935         return FALSE;
4936     }
4937
4938     return HttpEndRequestW(hRequest, NULL, dwFlags, dwContext);
4939 }
4940
4941 static void AsyncHttpEndRequestProc(WORKREQUEST *work)
4942 {
4943     struct WORKREQ_HTTPENDREQUESTW const *req = &work->u.HttpEndRequestW;
4944     http_request_t *request = (http_request_t*)work->hdr;
4945
4946     TRACE("%p\n", request);
4947
4948     HTTP_HttpEndRequestW(request, req->dwFlags, req->dwContext);
4949 }
4950
4951 /***********************************************************************
4952  *           HttpEndRequestW (WININET.@)
4953  *
4954  * Ends an HTTP request that was started by HttpSendRequestEx
4955  *
4956  * RETURNS
4957  *    TRUE      if successful
4958  *    FALSE     on failure
4959  *
4960  */
4961 BOOL WINAPI HttpEndRequestW(HINTERNET hRequest,
4962         LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
4963 {
4964     http_request_t *request;
4965     DWORD res;
4966
4967     TRACE("%p %p %x %lx -->\n", hRequest, lpBuffersOut, dwFlags, dwContext);
4968
4969     if (lpBuffersOut)
4970     {
4971         SetLastError(ERROR_INVALID_PARAMETER);
4972         return FALSE;
4973     }
4974
4975     request = (http_request_t*) get_handle_object( hRequest );
4976
4977     if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
4978     {
4979         SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
4980         if (request)
4981             WININET_Release( &request->hdr );
4982         return FALSE;
4983     }
4984     request->hdr.dwFlags |= dwFlags;
4985
4986     if (request->session->appInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
4987     {
4988         WORKREQUEST work;
4989         struct WORKREQ_HTTPENDREQUESTW *work_endrequest;
4990
4991         work.asyncproc = AsyncHttpEndRequestProc;
4992         work.hdr = WININET_AddRef( &request->hdr );
4993
4994         work_endrequest = &work.u.HttpEndRequestW;
4995         work_endrequest->dwFlags = dwFlags;
4996         work_endrequest->dwContext = dwContext;
4997
4998         INTERNET_AsyncCall(&work);
4999         res = ERROR_IO_PENDING;
5000     }
5001     else
5002         res = HTTP_HttpEndRequestW(request, dwFlags, dwContext);
5003
5004     WININET_Release( &request->hdr );
5005     TRACE("%u <--\n", res);
5006     if(res != ERROR_SUCCESS)
5007         SetLastError(res);
5008     return res == ERROR_SUCCESS;
5009 }
5010
5011 /***********************************************************************
5012  *           HttpSendRequestExA (WININET.@)
5013  *
5014  * Sends the specified request to the HTTP server and allows chunked
5015  * transfers.
5016  *
5017  * RETURNS
5018  *  Success: TRUE
5019  *  Failure: FALSE, call GetLastError() for more information.
5020  */
5021 BOOL WINAPI HttpSendRequestExA(HINTERNET hRequest,
5022                                LPINTERNET_BUFFERSA lpBuffersIn,
5023                                LPINTERNET_BUFFERSA lpBuffersOut,
5024                                DWORD dwFlags, DWORD_PTR dwContext)
5025 {
5026     INTERNET_BUFFERSW BuffersInW;
5027     BOOL rc = FALSE;
5028     DWORD headerlen;
5029     LPWSTR header = NULL;
5030
5031     TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
5032             lpBuffersOut, dwFlags, dwContext);
5033
5034     if (lpBuffersIn)
5035     {
5036         BuffersInW.dwStructSize = sizeof(LPINTERNET_BUFFERSW);
5037         if (lpBuffersIn->lpcszHeader)
5038         {
5039             headerlen = MultiByteToWideChar(CP_ACP,0,lpBuffersIn->lpcszHeader,
5040                     lpBuffersIn->dwHeadersLength,0,0);
5041             header = heap_alloc(headerlen*sizeof(WCHAR));
5042             if (!(BuffersInW.lpcszHeader = header))
5043             {
5044                 SetLastError(ERROR_OUTOFMEMORY);
5045                 return FALSE;
5046             }
5047             BuffersInW.dwHeadersLength = MultiByteToWideChar(CP_ACP, 0,
5048                     lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
5049                     header, headerlen);
5050         }
5051         else
5052             BuffersInW.lpcszHeader = NULL;
5053         BuffersInW.dwHeadersTotal = lpBuffersIn->dwHeadersTotal;
5054         BuffersInW.lpvBuffer = lpBuffersIn->lpvBuffer;
5055         BuffersInW.dwBufferLength = lpBuffersIn->dwBufferLength;
5056         BuffersInW.dwBufferTotal = lpBuffersIn->dwBufferTotal;
5057         BuffersInW.Next = NULL;
5058     }
5059
5060     rc = HttpSendRequestExW(hRequest, lpBuffersIn ? &BuffersInW : NULL, NULL, dwFlags, dwContext);
5061
5062     heap_free(header);
5063     return rc;
5064 }
5065
5066 /***********************************************************************
5067  *           HttpSendRequestExW (WININET.@)
5068  *
5069  * Sends the specified request to the HTTP server and allows chunked
5070  * transfers
5071  *
5072  * RETURNS
5073  *  Success: TRUE
5074  *  Failure: FALSE, call GetLastError() for more information.
5075  */
5076 BOOL WINAPI HttpSendRequestExW(HINTERNET hRequest,
5077                    LPINTERNET_BUFFERSW lpBuffersIn,
5078                    LPINTERNET_BUFFERSW lpBuffersOut,
5079                    DWORD dwFlags, DWORD_PTR dwContext)
5080 {
5081     http_request_t *request;
5082     http_session_t *session;
5083     appinfo_t *hIC;
5084     DWORD res;
5085
5086     TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
5087             lpBuffersOut, dwFlags, dwContext);
5088
5089     request = (http_request_t*) get_handle_object( hRequest );
5090
5091     if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
5092     {
5093         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5094         goto lend;
5095     }
5096
5097     session = request->session;
5098     assert(session->hdr.htype == WH_HHTTPSESSION);
5099     hIC = session->appInfo;
5100     assert(hIC->hdr.htype == WH_HINIT);
5101
5102     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5103     {
5104         WORKREQUEST workRequest;
5105         struct WORKREQ_HTTPSENDREQUESTW *req;
5106
5107         workRequest.asyncproc = AsyncHttpSendRequestProc;
5108         workRequest.hdr = WININET_AddRef( &request->hdr );
5109         req = &workRequest.u.HttpSendRequestW;
5110         if (lpBuffersIn)
5111         {
5112             DWORD size = 0;
5113
5114             if (lpBuffersIn->lpcszHeader)
5115             {
5116                 if (lpBuffersIn->dwHeadersLength == ~0u)
5117                     size = (strlenW( lpBuffersIn->lpcszHeader ) + 1) * sizeof(WCHAR);
5118                 else
5119                     size = lpBuffersIn->dwHeadersLength * sizeof(WCHAR);
5120
5121                 req->lpszHeader = heap_alloc(size);
5122                 memcpy( req->lpszHeader, lpBuffersIn->lpcszHeader, size );
5123             }
5124             else req->lpszHeader = NULL;
5125
5126             req->dwHeaderLength = size / sizeof(WCHAR);
5127             req->lpOptional = lpBuffersIn->lpvBuffer;
5128             req->dwOptionalLength = lpBuffersIn->dwBufferLength;
5129             req->dwContentLength = lpBuffersIn->dwBufferTotal;
5130         }
5131         else
5132         {
5133             req->lpszHeader = NULL;
5134             req->dwHeaderLength = 0;
5135             req->lpOptional = NULL;
5136             req->dwOptionalLength = 0;
5137             req->dwContentLength = 0;
5138         }
5139
5140         req->bEndRequest = FALSE;
5141
5142         INTERNET_AsyncCall(&workRequest);
5143         /*
5144          * This is from windows.
5145          */
5146         res = ERROR_IO_PENDING;
5147     }
5148     else
5149     {
5150         if (lpBuffersIn)
5151             res = HTTP_HttpSendRequestW(request, lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
5152                                         lpBuffersIn->lpvBuffer, lpBuffersIn->dwBufferLength,
5153                                         lpBuffersIn->dwBufferTotal, FALSE);
5154         else
5155             res = HTTP_HttpSendRequestW(request, NULL, 0, NULL, 0, 0, FALSE);
5156     }
5157
5158 lend:
5159     if ( request )
5160         WININET_Release( &request->hdr );
5161
5162     TRACE("<---\n");
5163     SetLastError(res);
5164     return res == ERROR_SUCCESS;
5165 }
5166
5167 /***********************************************************************
5168  *           HttpSendRequestW (WININET.@)
5169  *
5170  * Sends the specified request to the HTTP server
5171  *
5172  * RETURNS
5173  *    TRUE  on success
5174  *    FALSE on failure
5175  *
5176  */
5177 BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
5178         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
5179 {
5180     http_request_t *request;
5181     http_session_t *session = NULL;
5182     appinfo_t *hIC = NULL;
5183     DWORD res = ERROR_SUCCESS;
5184
5185     TRACE("%p, %s, %i, %p, %i)\n", hHttpRequest,
5186             debugstr_wn(lpszHeaders, dwHeaderLength), dwHeaderLength, lpOptional, dwOptionalLength);
5187
5188     request = (http_request_t*) get_handle_object( hHttpRequest );
5189     if (NULL == request || request->hdr.htype != WH_HHTTPREQ)
5190     {
5191         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5192         goto lend;
5193     }
5194
5195     session = request->session;
5196     if (NULL == session ||  session->hdr.htype != WH_HHTTPSESSION)
5197     {
5198         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5199         goto lend;
5200     }
5201
5202     hIC = session->appInfo;
5203     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT)
5204     {
5205         res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
5206         goto lend;
5207     }
5208
5209     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
5210     {
5211         WORKREQUEST workRequest;
5212         struct WORKREQ_HTTPSENDREQUESTW *req;
5213
5214         workRequest.asyncproc = AsyncHttpSendRequestProc;
5215         workRequest.hdr = WININET_AddRef( &request->hdr );
5216         req = &workRequest.u.HttpSendRequestW;
5217         if (lpszHeaders)
5218         {
5219             DWORD size;
5220
5221             if (dwHeaderLength == ~0u) size = (strlenW(lpszHeaders) + 1) * sizeof(WCHAR);
5222             else size = dwHeaderLength * sizeof(WCHAR);
5223
5224             req->lpszHeader = heap_alloc(size);
5225             memcpy(req->lpszHeader, lpszHeaders, size);
5226         }
5227         else
5228             req->lpszHeader = 0;
5229         req->dwHeaderLength = dwHeaderLength;
5230         req->lpOptional = lpOptional;
5231         req->dwOptionalLength = dwOptionalLength;
5232         req->dwContentLength = dwOptionalLength;
5233         req->bEndRequest = TRUE;
5234
5235         INTERNET_AsyncCall(&workRequest);
5236         /*
5237          * This is from windows.
5238          */
5239         res = ERROR_IO_PENDING;
5240     }
5241     else
5242     {
5243         res = HTTP_HttpSendRequestW(request, lpszHeaders,
5244                 dwHeaderLength, lpOptional, dwOptionalLength,
5245                 dwOptionalLength, TRUE);
5246     }
5247 lend:
5248     if( request )
5249         WININET_Release( &request->hdr );
5250
5251     SetLastError(res);
5252     return res == ERROR_SUCCESS;
5253 }
5254
5255 /***********************************************************************
5256  *           HttpSendRequestA (WININET.@)
5257  *
5258  * Sends the specified request to the HTTP server
5259  *
5260  * RETURNS
5261  *    TRUE  on success
5262  *    FALSE on failure
5263  *
5264  */
5265 BOOL WINAPI HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
5266         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
5267 {
5268     BOOL result;
5269     LPWSTR szHeaders=NULL;
5270     DWORD nLen=dwHeaderLength;
5271     if(lpszHeaders!=NULL)
5272     {
5273         nLen=MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,NULL,0);
5274         szHeaders = heap_alloc(nLen*sizeof(WCHAR));
5275         MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,szHeaders,nLen);
5276     }
5277     result = HttpSendRequestW(hHttpRequest, szHeaders, nLen, lpOptional, dwOptionalLength);
5278     heap_free(szHeaders);
5279     return result;
5280 }
5281
5282 /***********************************************************************
5283  *           HTTPSESSION_Destroy (internal)
5284  *
5285  * Deallocate session handle
5286  *
5287  */
5288 static void HTTPSESSION_Destroy(object_header_t *hdr)
5289 {
5290     http_session_t *session = (http_session_t*) hdr;
5291
5292     TRACE("%p\n", session);
5293
5294     WININET_Release(&session->appInfo->hdr);
5295
5296     heap_free(session->hostName);
5297     heap_free(session->serverName);
5298     heap_free(session->password);
5299     heap_free(session->userName);
5300 }
5301
5302 static DWORD HTTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
5303 {
5304     switch(option) {
5305     case INTERNET_OPTION_HANDLE_TYPE:
5306         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
5307
5308         if (*size < sizeof(ULONG))
5309             return ERROR_INSUFFICIENT_BUFFER;
5310
5311         *size = sizeof(DWORD);
5312         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_HTTP;
5313         return ERROR_SUCCESS;
5314     }
5315
5316     return INET_QueryOption(hdr, option, buffer, size, unicode);
5317 }
5318
5319 static DWORD HTTPSESSION_SetOption(object_header_t *hdr, DWORD option, void *buffer, DWORD size)
5320 {
5321     http_session_t *ses = (http_session_t*)hdr;
5322
5323     switch(option) {
5324     case INTERNET_OPTION_USERNAME:
5325     {
5326         heap_free(ses->userName);
5327         if (!(ses->userName = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5328         return ERROR_SUCCESS;
5329     }
5330     case INTERNET_OPTION_PASSWORD:
5331     {
5332         heap_free(ses->password);
5333         if (!(ses->password = heap_strdupW(buffer))) return ERROR_OUTOFMEMORY;
5334         return ERROR_SUCCESS;
5335     }
5336     default: break;
5337     }
5338
5339     return ERROR_INTERNET_INVALID_OPTION;
5340 }
5341
5342 static const object_vtbl_t HTTPSESSIONVtbl = {
5343     HTTPSESSION_Destroy,
5344     NULL,
5345     HTTPSESSION_QueryOption,
5346     HTTPSESSION_SetOption,
5347     NULL,
5348     NULL,
5349     NULL,
5350     NULL,
5351     NULL
5352 };
5353
5354
5355 /***********************************************************************
5356  *           HTTP_Connect  (internal)
5357  *
5358  * Create http session handle
5359  *
5360  * RETURNS
5361  *   HINTERNET a session handle on success
5362  *   NULL on failure
5363  *
5364  */
5365 DWORD HTTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
5366         INTERNET_PORT serverPort, LPCWSTR lpszUserName,
5367         LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
5368         DWORD dwInternalFlags, HINTERNET *ret)
5369 {
5370     http_session_t *session = NULL;
5371
5372     TRACE("-->\n");
5373
5374     if (!lpszServerName || !lpszServerName[0])
5375         return ERROR_INVALID_PARAMETER;
5376
5377     assert( hIC->hdr.htype == WH_HINIT );
5378
5379     session = alloc_object(&hIC->hdr, &HTTPSESSIONVtbl, sizeof(http_session_t));
5380     if (!session)
5381         return ERROR_OUTOFMEMORY;
5382
5383    /*
5384     * According to my tests. The name is not resolved until a request is sent
5385     */
5386
5387     session->hdr.htype = WH_HHTTPSESSION;
5388     session->hdr.dwFlags = dwFlags;
5389     session->hdr.dwContext = dwContext;
5390     session->hdr.dwInternalFlags |= dwInternalFlags;
5391
5392     WININET_AddRef( &hIC->hdr );
5393     session->appInfo = hIC;
5394     list_add_head( &hIC->hdr.children, &session->hdr.entry );
5395
5396     if(hIC->proxy && hIC->accessType == INTERNET_OPEN_TYPE_PROXY) {
5397         if(hIC->proxyBypass)
5398             FIXME("Proxy bypass is ignored.\n");
5399     }
5400     session->serverName = heap_strdupW(lpszServerName);
5401     session->hostName = heap_strdupW(lpszServerName);
5402     if (lpszUserName && lpszUserName[0])
5403         session->userName = heap_strdupW(lpszUserName);
5404     if (lpszPassword && lpszPassword[0])
5405         session->password = heap_strdupW(lpszPassword);
5406     session->serverPort = serverPort;
5407     session->hostPort = serverPort;
5408
5409     /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
5410     if (!(session->hdr.dwInternalFlags & INET_OPENURL))
5411     {
5412         INTERNET_SendCallback(&hIC->hdr, dwContext,
5413                               INTERNET_STATUS_HANDLE_CREATED, &session->hdr.hInternet,
5414                               sizeof(HINTERNET));
5415     }
5416
5417 /*
5418  * an INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
5419  * windows
5420  */
5421
5422     TRACE("%p --> %p\n", hIC, session);
5423
5424     *ret = session->hdr.hInternet;
5425     return ERROR_SUCCESS;
5426 }
5427
5428 /***********************************************************************
5429  *           HTTP_clear_response_headers (internal)
5430  *
5431  * clear out any old response headers
5432  */
5433 static void HTTP_clear_response_headers( http_request_t *request )
5434 {
5435     DWORD i;
5436
5437     for( i=0; i<request->nCustHeaders; i++)
5438     {
5439         if( !request->custHeaders[i].lpszField )
5440             continue;
5441         if( !request->custHeaders[i].lpszValue )
5442             continue;
5443         if ( request->custHeaders[i].wFlags & HDR_ISREQUEST )
5444             continue;
5445         HTTP_DeleteCustomHeader( request, i );
5446         i--;
5447     }
5448 }
5449
5450 /***********************************************************************
5451  *           HTTP_GetResponseHeaders (internal)
5452  *
5453  * Read server response
5454  *
5455  * RETURNS
5456  *
5457  *   TRUE  on success
5458  *   FALSE on error
5459  */
5460 static INT HTTP_GetResponseHeaders(http_request_t *request, BOOL clear)
5461 {
5462     INT cbreaks = 0;
5463     WCHAR buffer[MAX_REPLY_LEN];
5464     DWORD buflen = MAX_REPLY_LEN;
5465     BOOL bSuccess = FALSE;
5466     INT  rc = 0;
5467     char bufferA[MAX_REPLY_LEN];
5468     LPWSTR status_code = NULL, status_text = NULL;
5469     DWORD cchMaxRawHeaders = 1024;
5470     LPWSTR lpszRawHeaders = NULL;
5471     LPWSTR temp;
5472     DWORD cchRawHeaders = 0;
5473     BOOL codeHundred = FALSE;
5474
5475     TRACE("-->\n");
5476
5477     if(!request->netconn)
5478         goto lend;
5479
5480     do {
5481         static const WCHAR szHundred[] = {'1','0','0',0};
5482         /*
5483          * We should first receive 'HTTP/1.x nnn OK' where nnn is the status code.
5484          */
5485         buflen = MAX_REPLY_LEN;
5486         if (!read_line(request, bufferA, &buflen))
5487             goto lend;
5488
5489         /* clear old response headers (eg. from a redirect response) */
5490         if (clear) {
5491             HTTP_clear_response_headers( request );
5492             clear = FALSE;
5493         }
5494
5495         rc += buflen;
5496         MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
5497         /* check is this a status code line? */
5498         if (!strncmpW(buffer, g_szHttp1_0, 4))
5499         {
5500             /* split the version from the status code */
5501             status_code = strchrW( buffer, ' ' );
5502             if( !status_code )
5503                 goto lend;
5504             *status_code++=0;
5505
5506             /* split the status code from the status text */
5507             status_text = strchrW( status_code, ' ' );
5508             if( !status_text )
5509                 goto lend;
5510             *status_text++=0;
5511
5512             TRACE("version [%s] status code [%s] status text [%s]\n",
5513                debugstr_w(buffer), debugstr_w(status_code), debugstr_w(status_text) );
5514
5515             codeHundred = (!strcmpW(status_code, szHundred));
5516         }
5517         else if (!codeHundred)
5518         {
5519             WARN("No status line at head of response (%s)\n", debugstr_w(buffer));
5520
5521             heap_free(request->version);
5522             heap_free(request->statusText);
5523
5524             request->version = heap_strdupW(g_szHttp1_0);
5525             request->statusText = heap_strdupW(szOK);
5526
5527             heap_free(request->rawHeaders);
5528             request->rawHeaders = heap_strdupW(szDefaultHeader);
5529
5530             bSuccess = TRUE;
5531             goto lend;
5532         }
5533     } while (codeHundred);
5534
5535     /* Add status code */
5536     HTTP_ProcessHeader(request, szStatus, status_code,
5537             HTTP_ADDHDR_FLAG_REPLACE);
5538
5539     heap_free(request->version);
5540     heap_free(request->statusText);
5541
5542     request->version = heap_strdupW(buffer);
5543     request->statusText = heap_strdupW(status_text);
5544
5545     /* Restore the spaces */
5546     *(status_code-1) = ' ';
5547     *(status_text-1) = ' ';
5548
5549     /* regenerate raw headers */
5550     lpszRawHeaders = heap_alloc((cchMaxRawHeaders + 1) * sizeof(WCHAR));
5551     if (!lpszRawHeaders) goto lend;
5552
5553     while (cchRawHeaders + buflen + strlenW(szCrLf) > cchMaxRawHeaders)
5554         cchMaxRawHeaders *= 2;
5555     temp = heap_realloc(lpszRawHeaders, (cchMaxRawHeaders+1)*sizeof(WCHAR));
5556     if (temp == NULL) goto lend;
5557     lpszRawHeaders = temp;
5558     memcpy(lpszRawHeaders+cchRawHeaders, buffer, (buflen-1)*sizeof(WCHAR));
5559     cchRawHeaders += (buflen-1);
5560     memcpy(lpszRawHeaders+cchRawHeaders, szCrLf, sizeof(szCrLf));
5561     cchRawHeaders += sizeof(szCrLf)/sizeof(szCrLf[0])-1;
5562     lpszRawHeaders[cchRawHeaders] = '\0';
5563
5564     /* Parse each response line */
5565     do
5566     {
5567         buflen = MAX_REPLY_LEN;
5568         if (read_line(request, bufferA, &buflen))
5569         {
5570             LPWSTR * pFieldAndValue;
5571
5572             TRACE("got line %s, now interpreting\n", debugstr_a(bufferA));
5573
5574             if (!bufferA[0]) break;
5575             MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
5576
5577             pFieldAndValue = HTTP_InterpretHttpHeader(buffer);
5578             if (pFieldAndValue)
5579             {
5580                 while (cchRawHeaders + buflen + strlenW(szCrLf) > cchMaxRawHeaders)
5581                     cchMaxRawHeaders *= 2;
5582                 temp = heap_realloc(lpszRawHeaders, (cchMaxRawHeaders+1)*sizeof(WCHAR));
5583                 if (temp == NULL) goto lend;
5584                 lpszRawHeaders = temp;
5585                 memcpy(lpszRawHeaders+cchRawHeaders, buffer, (buflen-1)*sizeof(WCHAR));
5586                 cchRawHeaders += (buflen-1);
5587                 memcpy(lpszRawHeaders+cchRawHeaders, szCrLf, sizeof(szCrLf));
5588                 cchRawHeaders += sizeof(szCrLf)/sizeof(szCrLf[0])-1;
5589                 lpszRawHeaders[cchRawHeaders] = '\0';
5590
5591                 HTTP_ProcessHeader(request, pFieldAndValue[0], pFieldAndValue[1],
5592                                    HTTP_ADDREQ_FLAG_ADD );
5593
5594                 HTTP_FreeTokens(pFieldAndValue);
5595             }
5596         }
5597         else
5598         {
5599             cbreaks++;
5600             if (cbreaks >= 2)
5601                break;
5602         }
5603     }while(1);
5604
5605     /* make sure the response header is terminated with an empty line.  Some apps really
5606        truly care about that empty line being there for some reason.  Just add it to the
5607        header. */
5608     if (cchRawHeaders + strlenW(szCrLf) > cchMaxRawHeaders)
5609     {
5610         cchMaxRawHeaders = cchRawHeaders + strlenW(szCrLf);
5611         temp = heap_realloc(lpszRawHeaders, (cchMaxRawHeaders + 1) * sizeof(WCHAR));
5612         if (temp == NULL) goto lend;
5613         lpszRawHeaders = temp;
5614     }
5615
5616     memcpy(&lpszRawHeaders[cchRawHeaders], szCrLf, sizeof(szCrLf));
5617
5618     heap_free(request->rawHeaders);
5619     request->rawHeaders = lpszRawHeaders;
5620     TRACE("raw headers: %s\n", debugstr_w(lpszRawHeaders));
5621     bSuccess = TRUE;
5622
5623 lend:
5624
5625     TRACE("<--\n");
5626     if (bSuccess)
5627         return rc;
5628     else
5629     {
5630         heap_free(lpszRawHeaders);
5631         return 0;
5632     }
5633 }
5634
5635 /***********************************************************************
5636  *           HTTP_InterpretHttpHeader (internal)
5637  *
5638  * Parse server response
5639  *
5640  * RETURNS
5641  *
5642  *   Pointer to array of field, value, NULL on success.
5643  *   NULL on error.
5644  */
5645 static LPWSTR * HTTP_InterpretHttpHeader(LPCWSTR buffer)
5646 {
5647     LPWSTR * pTokenPair;
5648     LPWSTR pszColon;
5649     INT len;
5650
5651     pTokenPair = heap_alloc_zero(sizeof(*pTokenPair)*3);
5652
5653     pszColon = strchrW(buffer, ':');
5654     /* must have two tokens */
5655     if (!pszColon)
5656     {
5657         HTTP_FreeTokens(pTokenPair);
5658         if (buffer[0])
5659             TRACE("No ':' in line: %s\n", debugstr_w(buffer));
5660         return NULL;
5661     }
5662
5663     pTokenPair[0] = heap_alloc((pszColon - buffer + 1) * sizeof(WCHAR));
5664     if (!pTokenPair[0])
5665     {
5666         HTTP_FreeTokens(pTokenPair);
5667         return NULL;
5668     }
5669     memcpy(pTokenPair[0], buffer, (pszColon - buffer) * sizeof(WCHAR));
5670     pTokenPair[0][pszColon - buffer] = '\0';
5671
5672     /* skip colon */
5673     pszColon++;
5674     len = strlenW(pszColon);
5675     pTokenPair[1] = heap_alloc((len + 1) * sizeof(WCHAR));
5676     if (!pTokenPair[1])
5677     {
5678         HTTP_FreeTokens(pTokenPair);
5679         return NULL;
5680     }
5681     memcpy(pTokenPair[1], pszColon, (len + 1) * sizeof(WCHAR));
5682
5683     strip_spaces(pTokenPair[0]);
5684     strip_spaces(pTokenPair[1]);
5685
5686     TRACE("field(%s) Value(%s)\n", debugstr_w(pTokenPair[0]), debugstr_w(pTokenPair[1]));
5687     return pTokenPair;
5688 }
5689
5690 /***********************************************************************
5691  *           HTTP_ProcessHeader (internal)
5692  *
5693  * Stuff header into header tables according to <dwModifier>
5694  *
5695  */
5696
5697 #define COALESCEFLAGS (HTTP_ADDHDR_FLAG_COALESCE|HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
5698
5699 static DWORD HTTP_ProcessHeader(http_request_t *request, LPCWSTR field, LPCWSTR value, DWORD dwModifier)
5700 {
5701     LPHTTPHEADERW lphttpHdr = NULL;
5702     INT index = -1;
5703     BOOL request_only = dwModifier & HTTP_ADDHDR_FLAG_REQ;
5704     DWORD res = ERROR_HTTP_INVALID_HEADER;
5705
5706     TRACE("--> %s: %s - 0x%08x\n", debugstr_w(field), debugstr_w(value), dwModifier);
5707
5708     /* REPLACE wins out over ADD */
5709     if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
5710         dwModifier &= ~HTTP_ADDHDR_FLAG_ADD;
5711
5712     if (dwModifier & HTTP_ADDHDR_FLAG_ADD)
5713         index = -1;
5714     else
5715         index = HTTP_GetCustomHeaderIndex(request, field, 0, request_only);
5716
5717     if (index >= 0)
5718     {
5719         if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW)
5720             return ERROR_HTTP_INVALID_HEADER;
5721         lphttpHdr = &request->custHeaders[index];
5722     }
5723     else if (value)
5724     {
5725         HTTPHEADERW hdr;
5726
5727         hdr.lpszField = (LPWSTR)field;
5728         hdr.lpszValue = (LPWSTR)value;
5729         hdr.wFlags = hdr.wCount = 0;
5730
5731         if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
5732             hdr.wFlags |= HDR_ISREQUEST;
5733
5734         return HTTP_InsertCustomHeader(request, &hdr);
5735     }
5736     /* no value to delete */
5737     else return ERROR_SUCCESS;
5738
5739     if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
5740             lphttpHdr->wFlags |= HDR_ISREQUEST;
5741     else
5742         lphttpHdr->wFlags &= ~HDR_ISREQUEST;
5743
5744     if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
5745     {
5746         HTTP_DeleteCustomHeader( request, index );
5747
5748         if (value)
5749         {
5750             HTTPHEADERW hdr;
5751
5752             hdr.lpszField = (LPWSTR)field;
5753             hdr.lpszValue = (LPWSTR)value;
5754             hdr.wFlags = hdr.wCount = 0;
5755
5756             if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
5757                 hdr.wFlags |= HDR_ISREQUEST;
5758
5759             return HTTP_InsertCustomHeader(request, &hdr);
5760         }
5761
5762         return ERROR_SUCCESS;
5763     }
5764     else if (dwModifier & COALESCEFLAGS)
5765     {
5766         LPWSTR lpsztmp;
5767         WCHAR ch = 0;
5768         INT len = 0;
5769         INT origlen = strlenW(lphttpHdr->lpszValue);
5770         INT valuelen = strlenW(value);
5771
5772         if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA)
5773         {
5774             ch = ',';
5775             lphttpHdr->wFlags |= HDR_COMMADELIMITED;
5776         }
5777         else if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
5778         {
5779             ch = ';';
5780             lphttpHdr->wFlags |= HDR_COMMADELIMITED;
5781         }
5782
5783         len = origlen + valuelen + ((ch > 0) ? 2 : 0);
5784
5785         lpsztmp = heap_realloc(lphttpHdr->lpszValue, (len+1)*sizeof(WCHAR));
5786         if (lpsztmp)
5787         {
5788             lphttpHdr->lpszValue = lpsztmp;
5789     /* FIXME: Increment lphttpHdr->wCount. Perhaps lpszValue should be an array */
5790             if (ch > 0)
5791             {
5792                 lphttpHdr->lpszValue[origlen] = ch;
5793                 origlen++;
5794                 lphttpHdr->lpszValue[origlen] = ' ';
5795                 origlen++;
5796             }
5797
5798             memcpy(&lphttpHdr->lpszValue[origlen], value, valuelen*sizeof(WCHAR));
5799             lphttpHdr->lpszValue[len] = '\0';
5800             res = ERROR_SUCCESS;
5801         }
5802         else
5803         {
5804             WARN("heap_realloc (%d bytes) failed\n",len+1);
5805             res = ERROR_OUTOFMEMORY;
5806         }
5807     }
5808     TRACE("<-- %d\n", res);
5809     return res;
5810 }
5811
5812 /***********************************************************************
5813  *           HTTP_GetCustomHeaderIndex (internal)
5814  *
5815  * Return index of custom header from header array
5816  *
5817  */
5818 static INT HTTP_GetCustomHeaderIndex(http_request_t *request, LPCWSTR lpszField,
5819                                      int requested_index, BOOL request_only)
5820 {
5821     DWORD index;
5822
5823     TRACE("%s, %d, %d\n", debugstr_w(lpszField), requested_index, request_only);
5824
5825     for (index = 0; index < request->nCustHeaders; index++)
5826     {
5827         if (strcmpiW(request->custHeaders[index].lpszField, lpszField))
5828             continue;
5829
5830         if (request_only && !(request->custHeaders[index].wFlags & HDR_ISREQUEST))
5831             continue;
5832
5833         if (!request_only && (request->custHeaders[index].wFlags & HDR_ISREQUEST))
5834             continue;
5835
5836         if (requested_index == 0)
5837             break;
5838         requested_index --;
5839     }
5840
5841     if (index >= request->nCustHeaders)
5842         index = -1;
5843
5844     TRACE("Return: %d\n", index);
5845     return index;
5846 }
5847
5848
5849 /***********************************************************************
5850  *           HTTP_InsertCustomHeader (internal)
5851  *
5852  * Insert header into array
5853  *
5854  */
5855 static DWORD HTTP_InsertCustomHeader(http_request_t *request, LPHTTPHEADERW lpHdr)
5856 {
5857     INT count;
5858     LPHTTPHEADERW lph = NULL;
5859
5860     TRACE("--> %s: %s\n", debugstr_w(lpHdr->lpszField), debugstr_w(lpHdr->lpszValue));
5861     count = request->nCustHeaders + 1;
5862     if (count > 1)
5863         lph = heap_realloc_zero(request->custHeaders, sizeof(HTTPHEADERW) * count);
5864     else
5865         lph = heap_alloc_zero(sizeof(HTTPHEADERW) * count);
5866
5867     if (!lph)
5868         return ERROR_OUTOFMEMORY;
5869
5870     request->custHeaders = lph;
5871     request->custHeaders[count-1].lpszField = heap_strdupW(lpHdr->lpszField);
5872     request->custHeaders[count-1].lpszValue = heap_strdupW(lpHdr->lpszValue);
5873     request->custHeaders[count-1].wFlags = lpHdr->wFlags;
5874     request->custHeaders[count-1].wCount= lpHdr->wCount;
5875     request->nCustHeaders++;
5876
5877     return ERROR_SUCCESS;
5878 }
5879
5880
5881 /***********************************************************************
5882  *           HTTP_DeleteCustomHeader (internal)
5883  *
5884  * Delete header from array
5885  *  If this function is called, the indexs may change.
5886  */
5887 static BOOL HTTP_DeleteCustomHeader(http_request_t *request, DWORD index)
5888 {
5889     if( request->nCustHeaders <= 0 )
5890         return FALSE;
5891     if( index >= request->nCustHeaders )
5892         return FALSE;
5893     request->nCustHeaders--;
5894
5895     heap_free(request->custHeaders[index].lpszField);
5896     heap_free(request->custHeaders[index].lpszValue);
5897
5898     memmove( &request->custHeaders[index], &request->custHeaders[index+1],
5899              (request->nCustHeaders - index)* sizeof(HTTPHEADERW) );
5900     memset( &request->custHeaders[request->nCustHeaders], 0, sizeof(HTTPHEADERW) );
5901
5902     return TRUE;
5903 }
5904
5905
5906 /***********************************************************************
5907  *           HTTP_VerifyValidHeader (internal)
5908  *
5909  * Verify the given header is not invalid for the given http request
5910  *
5911  */
5912 static BOOL HTTP_VerifyValidHeader(http_request_t *request, LPCWSTR field)
5913 {
5914     /* Accept-Encoding is stripped from HTTP/1.0 requests. It is invalid */
5915     if (!strcmpW(request->version, g_szHttp1_0) && !strcmpiW(field, szAccept_Encoding))
5916         return ERROR_HTTP_INVALID_HEADER;
5917
5918     return ERROR_SUCCESS;
5919 }
5920
5921 /***********************************************************************
5922  *          IsHostInProxyBypassList (@)
5923  *
5924  * Undocumented
5925  *
5926  */
5927 BOOL WINAPI IsHostInProxyBypassList(DWORD flags, LPCSTR szHost, DWORD length)
5928 {
5929    FIXME("STUB: flags=%d host=%s length=%d\n",flags,szHost,length);
5930    return FALSE;
5931 }
5932
5933 /***********************************************************************
5934  *           InternetShowSecurityInfoByURLA (@)
5935  */
5936 BOOL WINAPI InternetShowSecurityInfoByURLA(LPCSTR url, HWND window)
5937 {
5938    FIXME("stub: %s %p\n", url, window);
5939    return FALSE;
5940 }
5941
5942 /***********************************************************************
5943  *           InternetShowSecurityInfoByURLW (@)
5944  */
5945 BOOL WINAPI InternetShowSecurityInfoByURLW(LPCWSTR url, HWND window)
5946 {
5947    FIXME("stub: %s %p\n", debugstr_w(url), window);
5948    return FALSE;
5949 }