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  *
  11  * Ulrich Czekalla
  12  * David Hammerton
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this library; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31
  32 #if defined(__MINGW32__) || defined (_MSC_VER)
  33 #include <ws2tcpip.h>
  34 #endif
  35
  36 #include <sys/types.h>
  37 #ifdef HAVE_SYS_SOCKET_H
  38 # include <sys/socket.h>
  39 #endif
  40 #ifdef HAVE_ARPA_INET_H
  41 # include <arpa/inet.h>
  42 #endif
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #ifdef HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #endif
  49 #include <time.h>
  50 #include <assert.h>
  51 #ifdef HAVE_ZLIB
  52 #  include <zlib.h>
  53 #endif
  54
  55 #include "windef.h"
  56 #include "winbase.h"
  57 #include "wininet.h"
  58 #include "winerror.h"
  59 #define NO_SHLWAPI_STREAM
  60 #define NO_SHLWAPI_REG
  61 #define NO_SHLWAPI_STRFCNS
  62 #define NO_SHLWAPI_GDI
  63 #include "shlwapi.h"
  64 #include "sspi.h"
  65 #include "wincrypt.h"
  66
  67 #include "internet.h"
  68 #include "wine/debug.h"
  69 #include "wine/exception.h"
  70 #include "wine/unicode.h"
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
  73
  74 static const WCHAR g_szHttp1_0[] = {'H','T','T','P','/','1','.','0',0};
  75 static const WCHAR g_szHttp1_1[] = {'H','T','T','P','/','1','.','1',0};
  76 static const WCHAR hostW[] = { 'H','o','s','t',0 };
  77 static const WCHAR szAuthorization[] = { 'A','u','t','h','o','r','i','z','a','t','i','o','n',0 };
  78 static const WCHAR szProxy_Authorization[] = { 'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',0 };
  79 static const WCHAR szStatus[] = { 'S','t','a','t','u','s',0 };
  80 static const WCHAR szKeepAlive[] = {'K','e','e','p','-','A','l','i','v','e',0};
  81 static const WCHAR szGET[] = { 'G','E','T', 0 };
  82 static const WCHAR szCrLf[] = {'\r','\n', 0};
  83
  84 static const WCHAR szAccept[] = { 'A','c','c','e','p','t',0 };
  85 static const WCHAR szAccept_Charset[] = { 'A','c','c','e','p','t','-','C','h','a','r','s','e','t', 0 };
  86 static const WCHAR szAccept_Encoding[] = { 'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',0 };
  87 static const WCHAR szAccept_Language[] = { 'A','c','c','e','p','t','-','L','a','n','g','u','a','g','e',0 };
  88 static const WCHAR szAccept_Ranges[] = { 'A','c','c','e','p','t','-','R','a','n','g','e','s',0 };
  89 static const WCHAR szAge[] = { 'A','g','e',0 };
  90 static const WCHAR szAllow[] = { 'A','l','l','o','w',0 };
  91 static const WCHAR szCache_Control[] = { 'C','a','c','h','e','-','C','o','n','t','r','o','l',0 };
  92 static const WCHAR szConnection[] = { 'C','o','n','n','e','c','t','i','o','n',0 };
  93 static const WCHAR szContent_Base[] = { 'C','o','n','t','e','n','t','-','B','a','s','e',0 };
  94 static const WCHAR szContent_Encoding[] = { 'C','o','n','t','e','n','t','-','E','n','c','o','d','i','n','g',0 };
  95 static const WCHAR szContent_ID[] = { 'C','o','n','t','e','n','t','-','I','D',0 };
  96 static const WCHAR szContent_Language[] = { 'C','o','n','t','e','n','t','-','L','a','n','g','u','a','g','e',0 };
  97 static const WCHAR szContent_Length[] = { 'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0 };
  98 static const WCHAR szContent_Location[] = { 'C','o','n','t','e','n','t','-','L','o','c','a','t','i','o','n',0 };
  99 static const WCHAR szContent_MD5[] = { 'C','o','n','t','e','n','t','-','M','D','5',0 };
 100 static const WCHAR szContent_Range[] = { 'C','o','n','t','e','n','t','-','R','a','n','g','e',0 };
 101 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 };
 102 static const WCHAR szContent_Type[] = { 'C','o','n','t','e','n','t','-','T','y','p','e',0 };
 103 static const WCHAR szCookie[] = { 'C','o','o','k','i','e',0 };
 104 static const WCHAR szDate[] = { 'D','a','t','e',0 };
 105 static const WCHAR szFrom[] = { 'F','r','o','m',0 };
 106 static const WCHAR szETag[] = { 'E','T','a','g',0 };
 107 static const WCHAR szExpect[] = { 'E','x','p','e','c','t',0 };
 108 static const WCHAR szExpires[] = { 'E','x','p','i','r','e','s',0 };
 109 static const WCHAR szIf_Match[] = { 'I','f','-','M','a','t','c','h',0 };
 110 static const WCHAR szIf_Modified_Since[] = { 'I','f','-','M','o','d','i','f','i','e','d','-','S','i','n','c','e',0 };
 111 static const WCHAR szIf_None_Match[] = { 'I','f','-','N','o','n','e','-','M','a','t','c','h',0 };
 112 static const WCHAR szIf_Range[] = { 'I','f','-','R','a','n','g','e',0 };
 113 static const WCHAR szIf_Unmodified_Since[] = { 'I','f','-','U','n','m','o','d','i','f','i','e','d','-','S','i','n','c','e',0 };
 114 static const WCHAR szLast_Modified[] = { 'L','a','s','t','-','M','o','d','i','f','i','e','d',0 };
 115 static const WCHAR szLocation[] = { 'L','o','c','a','t','i','o','n',0 };
 116 static const WCHAR szMax_Forwards[] = { 'M','a','x','-','F','o','r','w','a','r','d','s',0 };
 117 static const WCHAR szMime_Version[] = { 'M','i','m','e','-','V','e','r','s','i','o','n',0 };
 118 static const WCHAR szPragma[] = { 'P','r','a','g','m','a',0 };
 119 static const WCHAR szProxy_Authenticate[] = { 'P','r','o','x','y','-','A','u','t','h','e','n','t','i','c','a','t','e',0 };
 120 static const WCHAR szProxy_Connection[] = { 'P','r','o','x','y','-','C','o','n','n','e','c','t','i','o','n',0 };
 121 static const WCHAR szPublic[] = { 'P','u','b','l','i','c',0 };
 122 static const WCHAR szRange[] = { 'R','a','n','g','e',0 };
 123 static const WCHAR szReferer[] = { 'R','e','f','e','r','e','r',0 };
 124 static const WCHAR szRetry_After[] = { 'R','e','t','r','y','-','A','f','t','e','r',0 };
 125 static const WCHAR szServer[] = { 'S','e','r','v','e','r',0 };
 126 static const WCHAR szSet_Cookie[] = { 'S','e','t','-','C','o','o','k','i','e',0 };
 127 static const WCHAR szTransfer_Encoding[] = { 'T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0 };
 128 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 };
 129 static const WCHAR szUpgrade[] = { 'U','p','g','r','a','d','e',0 };
 130 static const WCHAR szURI[] = { 'U','R','I',0 };
 131 static const WCHAR szUser_Agent[] = { 'U','s','e','r','-','A','g','e','n','t',0 };
 132 static const WCHAR szVary[] = { 'V','a','r','y',0 };
 133 static const WCHAR szVia[] = { 'V','i','a',0 };
 134 static const WCHAR szWarning[] = { 'W','a','r','n','i','n','g',0 };
 135 static const WCHAR szWWW_Authenticate[] = { 'W','W','W','-','A','u','t','h','e','n','t','i','c','a','t','e',0 };
 136
 137 #define MAXHOSTNAME 100
 138 #define MAX_FIELD_VALUE_LEN 256
 139 #define MAX_FIELD_LEN 256
 140
 141 #define HTTP_REFERER    szReferer
 142 #define HTTP_ACCEPT     szAccept
 143 #define HTTP_USERAGENT  szUser_Agent
 144
 145 #define HTTP_ADDHDR_FLAG_ADD                            0x20000000
 146 #define HTTP_ADDHDR_FLAG_ADD_IF_NEW                     0x10000000
 147 #define HTTP_ADDHDR_FLAG_COALESCE                       0x40000000
 148 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA            0x40000000
 149 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON        0x01000000
 150 #define HTTP_ADDHDR_FLAG_REPLACE                        0x80000000
 151 #define HTTP_ADDHDR_FLAG_REQ                            0x02000000
 152
 153 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
 154
 155 struct HttpAuthInfo
 156 {
 157     LPWSTR scheme;
 158     CredHandle cred;
 159     CtxtHandle ctx;
 160     TimeStamp exp;
 161     ULONG attr;
 162     ULONG max_token;
 163     void *auth_data;
 164     unsigned int auth_data_len;
 165     BOOL finished; /* finished authenticating */
 166 };
 167
 168
 169 struct gzip_stream_t {
 170 #ifdef HAVE_ZLIB
 171     z_stream zstream;
 172 #endif
 173     BYTE buf[8192];
 174     DWORD buf_size;
 175     DWORD buf_pos;
 176     BOOL end_of_data;
 177 };
 178
 179 static BOOL HTTP_OpenConnection(LPWININETHTTPREQW lpwhr);
 180 static BOOL HTTP_GetResponseHeaders(LPWININETHTTPREQW lpwhr, BOOL clear);
 181 static BOOL HTTP_ProcessHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field, LPCWSTR value, DWORD dwModifier);
 182 static LPWSTR * HTTP_InterpretHttpHeader(LPCWSTR buffer);
 183 static BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQW lpwhr, LPHTTPHEADERW lpHdr);
 184 static INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQW lpwhr, LPCWSTR lpszField, INT index, BOOL Request);
 185 static BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQW lpwhr, DWORD index);
 186 static LPWSTR HTTP_build_req( LPCWSTR *list, int len );
 187 static BOOL HTTP_HttpQueryInfoW(LPWININETHTTPREQW, DWORD, LPVOID, LPDWORD, LPDWORD);
 188 static LPWSTR HTTP_GetRedirectURL(LPWININETHTTPREQW lpwhr, LPCWSTR lpszUrl);
 189 static BOOL HTTP_HandleRedirect(LPWININETHTTPREQW lpwhr, LPCWSTR lpszUrl);
 190 static UINT HTTP_DecodeBase64(LPCWSTR base64, LPSTR bin);
 191 static BOOL HTTP_VerifyValidHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field);
 192 static void HTTP_DrainContent(WININETHTTPREQW *req);
 193 static BOOL HTTP_FinishedReading(LPWININETHTTPREQW lpwhr);
 194
 195 static LPHTTPHEADERW HTTP_GetHeader(LPWININETHTTPREQW req, LPCWSTR head)
 196 {
 197     int HeaderIndex = 0;
 198     HeaderIndex = HTTP_GetCustomHeaderIndex(req, head, 0, TRUE);
 199     if (HeaderIndex == -1)
 200         return NULL;
 201     else
 202         return &req->pCustHeaders[HeaderIndex];
 203 }
 204
 205 #ifdef HAVE_ZLIB
 206
 207 static voidpf wininet_zalloc(voidpf opaque, uInt items, uInt size)
 208 {
 209     return HeapAlloc(GetProcessHeap(), 0, items*size);
 210 }
 211
 212 static void wininet_zfree(voidpf opaque, voidpf address)
 213 {
 214     HeapFree(GetProcessHeap(), 0, address);
 215 }
 216
 217 static void init_gzip_stream(WININETHTTPREQW *req)
 218 {
 219     gzip_stream_t *gzip_stream;
 220     int zres;
 221
 222     gzip_stream = HeapAlloc(GetProcessHeap(), 0, sizeof(gzip_stream_t));
 223     gzip_stream->zstream.zalloc = wininet_zalloc;
 224     gzip_stream->zstream.zfree = wininet_zfree;
 225     gzip_stream->zstream.opaque = NULL;
 226     gzip_stream->zstream.next_in = NULL;
 227     gzip_stream->zstream.avail_in = 0;
 228     gzip_stream->zstream.next_out = NULL;
 229     gzip_stream->zstream.avail_out = 0;
 230     gzip_stream->buf_pos = 0;
 231     gzip_stream->buf_size = 0;
 232     gzip_stream->end_of_data = FALSE;
 233
 234     zres = inflateInit2(&gzip_stream->zstream, 0x1f);
 235     if(zres != Z_OK) {
 236         ERR("inflateInit failed: %d\n", zres);
 237         HeapFree(GetProcessHeap(), 0, gzip_stream);
 238         return;
 239     }
 240
 241     req->gzip_stream = gzip_stream;
 242 }
 243
 244 #else
 245
 246 static void init_gzip_stream(WININETHTTPREQW *req)
 247 {
 248     ERR("gzip stream not supported, missing zlib.\n");
 249 }
 250
 251 #endif
 252
 253 /* set the request content length based on the headers */
 254 static DWORD set_content_length( LPWININETHTTPREQW lpwhr )
 255 {
 256     static const WCHAR szChunked[] = {'c','h','u','n','k','e','d',0};
 257     WCHAR encoding[20];
 258     DWORD size;
 259
 260     size = sizeof(lpwhr->dwContentLength);
 261     if (!HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH,
 262                              &lpwhr->dwContentLength, &size, NULL))
 263         lpwhr->dwContentLength = ~0u;
 264
 265     size = sizeof(encoding);
 266     if (HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_TRANSFER_ENCODING, encoding, &size, NULL) &&
 267         !strcmpiW(encoding, szChunked))
 268     {
 269         lpwhr->dwContentLength = ~0u;
 270         lpwhr->read_chunked = TRUE;
 271     }
 272
 273     if(lpwhr->decoding) {
 274         int encoding_idx;
 275
 276         static const WCHAR gzipW[] = {'g','z','i','p',0};
 277
 278         encoding_idx = HTTP_GetCustomHeaderIndex(lpwhr, szContent_Encoding, 0, FALSE);
 279         if(encoding_idx != -1 && !strcmpiW(lpwhr->pCustHeaders[encoding_idx].lpszValue, gzipW))
 280             init_gzip_stream(lpwhr);
 281     }
 282
 283     return lpwhr->dwContentLength;
 284 }
 285
 286 /***********************************************************************
 287  *           HTTP_Tokenize (internal)
 288  *
 289  *  Tokenize a string, allocating memory for the tokens.
 290  */
 291 static LPWSTR * HTTP_Tokenize(LPCWSTR string, LPCWSTR token_string)
 292 {
 293     LPWSTR * token_array;
 294     int tokens = 0;
 295     int i;
 296     LPCWSTR next_token;
 297
 298     if (string)
 299     {
 300         /* empty string has no tokens */
 301         if (*string)
 302             tokens++;
 303         /* count tokens */
 304         for (i = 0; string[i]; i++)
 305         {
 306             if (!strncmpW(string+i, token_string, strlenW(token_string)))
 307             {
 308                 DWORD j;
 309                 tokens++;
 310                 /* we want to skip over separators, but not the null terminator */
 311                 for (j = 0; j < strlenW(token_string) - 1; j++)
 312                     if (!string[i+j])
 313                         break;
 314                 i += j;
 315             }
 316         }
 317     }
 318
 319     /* add 1 for terminating NULL */
 320     token_array = HeapAlloc(GetProcessHeap(), 0, (tokens+1) * sizeof(*token_array));
 321     token_array[tokens] = NULL;
 322     if (!tokens)
 323         return token_array;
 324     for (i = 0; i < tokens; i++)
 325     {
 326         int len;
 327         next_token = strstrW(string, token_string);
 328         if (!next_token) next_token = string+strlenW(string);
 329         len = next_token - string;
 330         token_array[i] = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
 331         memcpy(token_array[i], string, len*sizeof(WCHAR));
 332         token_array[i][len] = '\0';
 333         string = next_token+strlenW(token_string);
 334     }
 335     return token_array;
 336 }
 337
 338 /***********************************************************************
 339  *           HTTP_FreeTokens (internal)
 340  *
 341  *  Frees memory returned from HTTP_Tokenize.
 342  */
 343 static void HTTP_FreeTokens(LPWSTR * token_array)
 344 {
 345     int i;
 346     for (i = 0; token_array[i]; i++)
 347         HeapFree(GetProcessHeap(), 0, token_array[i]);
 348     HeapFree(GetProcessHeap(), 0, token_array);
 349 }
 350
 351 /* **********************************************************************
 352  *
 353  * Helper functions for the HttpSendRequest(Ex) functions
 354  *
 355  */
 356 static void AsyncHttpSendRequestProc(WORKREQUEST *workRequest)
 357 {
 358     struct WORKREQ_HTTPSENDREQUESTW const *req = &workRequest->u.HttpSendRequestW;
 359     LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW) workRequest->hdr;
 360
 361     TRACE("%p\n", lpwhr);
 362
 363     HTTP_HttpSendRequestW(lpwhr, req->lpszHeader,
 364             req->dwHeaderLength, req->lpOptional, req->dwOptionalLength,
 365             req->dwContentLength, req->bEndRequest);
 366
 367     HeapFree(GetProcessHeap(), 0, req->lpszHeader);
 368 }
 369
 370 static void HTTP_FixURL( LPWININETHTTPREQW lpwhr)
 371 {
 372     static const WCHAR szSlash[] = { '/',0 };
 373     static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/', 0 };
 374
 375     /* If we don't have a path we set it to root */
 376     if (NULL == lpwhr->lpszPath)
 377         lpwhr->lpszPath = WININET_strdupW(szSlash);
 378     else /* remove \r and \n*/
 379     {
 380         int nLen = strlenW(lpwhr->lpszPath);
 381         while ((nLen >0 ) && ((lpwhr->lpszPath[nLen-1] == '\r')||(lpwhr->lpszPath[nLen-1] == '\n')))
 382         {
 383             nLen--;
 384             lpwhr->lpszPath[nLen]='\0';
 385         }
 386         /* Replace '\' with '/' */
 387         while (nLen>0) {
 388             nLen--;
 389             if (lpwhr->lpszPath[nLen] == '\\') lpwhr->lpszPath[nLen]='/';
 390         }
 391     }
 392
 393     if(CSTR_EQUAL != CompareStringW( LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
 394                        lpwhr->lpszPath, strlenW(lpwhr->lpszPath), szHttp, strlenW(szHttp) )
 395        && lpwhr->lpszPath[0] != '/') /* not an absolute path ?? --> fix it !! */
 396     {
 397         WCHAR *fixurl = HeapAlloc(GetProcessHeap(), 0,
 398                              (strlenW(lpwhr->lpszPath) + 2)*sizeof(WCHAR));
 399         *fixurl = '/';
 400         strcpyW(fixurl + 1, lpwhr->lpszPath);
 401         HeapFree( GetProcessHeap(), 0, lpwhr->lpszPath );
 402         lpwhr->lpszPath = fixurl;
 403     }
 404 }
 405
 406 static LPWSTR HTTP_BuildHeaderRequestString( LPWININETHTTPREQW lpwhr, LPCWSTR verb, LPCWSTR path, LPCWSTR version )
 407 {
 408     LPWSTR requestString;
 409     DWORD len, n;
 410     LPCWSTR *req;
 411     UINT i;
 412     LPWSTR p;
 413
 414     static const WCHAR szSpace[] = { ' ',0 };
 415     static const WCHAR szColon[] = { ':',' ',0 };
 416     static const WCHAR sztwocrlf[] = {'\r','\n','\r','\n', 0};
 417
 418     /* allocate space for an array of all the string pointers to be added */
 419     len = (lpwhr->nCustHeaders)*4 + 10;
 420     req = HeapAlloc( GetProcessHeap(), 0, len*sizeof(LPCWSTR) );
 421
 422     /* add the verb, path and HTTP version string */
 423     n = 0;
 424     req[n++] = verb;
 425     req[n++] = szSpace;
 426     req[n++] = path;
 427     req[n++] = szSpace;
 428     req[n++] = version;
 429
 430     /* Append custom request headers */
 431     for (i = 0; i < lpwhr->nCustHeaders; i++)
 432     {
 433         if (lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST)
 434         {
 435             req[n++] = szCrLf;
 436             req[n++] = lpwhr->pCustHeaders[i].lpszField;
 437             req[n++] = szColon;
 438             req[n++] = lpwhr->pCustHeaders[i].lpszValue;
 439
 440             TRACE("Adding custom header %s (%s)\n",
 441                    debugstr_w(lpwhr->pCustHeaders[i].lpszField),
 442                    debugstr_w(lpwhr->pCustHeaders[i].lpszValue));
 443         }
 444     }
 445
 446     if( n >= len )
 447         ERR("oops. buffer overrun\n");
 448
 449     req[n] = NULL;
 450     requestString = HTTP_build_req( req, 4 );
 451     HeapFree( GetProcessHeap(), 0, req );
 452
 453     /*
 454      * Set (header) termination string for request
 455      * Make sure there's exactly two new lines at the end of the request
 456      */
 457     p = &requestString[strlenW(requestString)-1];
 458     while ( (*p == '\n') || (*p == '\r') )
 459        p--;
 460     strcpyW( p+1, sztwocrlf );
 461
 462     return requestString;
 463 }
 464
 465 static void HTTP_ProcessCookies( LPWININETHTTPREQW lpwhr )
 466 {
 467     int HeaderIndex;
 468     int numCookies = 0;
 469     LPHTTPHEADERW setCookieHeader;
 470
 471     while((HeaderIndex = HTTP_GetCustomHeaderIndex(lpwhr, szSet_Cookie, numCookies, FALSE)) != -1)
 472     {
 473         setCookieHeader = &lpwhr->pCustHeaders[HeaderIndex];
 474
 475         if (!(lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES) && setCookieHeader->lpszValue)
 476         {
 477             int len;
 478             static const WCHAR szFmt[] = { 'h','t','t','p',':','/','/','%','s','%','s',0};
 479             LPWSTR buf_url;
 480             LPHTTPHEADERW Host;
 481
 482             Host = HTTP_GetHeader(lpwhr, hostW);
 483             len = lstrlenW(Host->lpszValue) + 9 + lstrlenW(lpwhr->lpszPath);
 484             buf_url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 485             sprintfW(buf_url, szFmt, Host->lpszValue, lpwhr->lpszPath);
 486             InternetSetCookieW(buf_url, NULL, setCookieHeader->lpszValue);
 487
 488             HeapFree(GetProcessHeap(), 0, buf_url);
 489         }
 490         numCookies++;
 491     }
 492 }
 493
 494 static inline BOOL is_basic_auth_value( LPCWSTR pszAuthValue )
 495 {
 496     static const WCHAR szBasic[] = {'B','a','s','i','c'}; /* Note: not nul-terminated */
 497     return !strncmpiW(pszAuthValue, szBasic, ARRAYSIZE(szBasic)) &&
 498         ((pszAuthValue[ARRAYSIZE(szBasic)] == ' ') || !pszAuthValue[ARRAYSIZE(szBasic)]);
 499 }
 500
 501 static BOOL HTTP_DoAuthorization( LPWININETHTTPREQW lpwhr, LPCWSTR pszAuthValue,
 502                                   struct HttpAuthInfo **ppAuthInfo,
 503                                   LPWSTR domain_and_username, LPWSTR password )
 504 {
 505     SECURITY_STATUS sec_status;
 506     struct HttpAuthInfo *pAuthInfo = *ppAuthInfo;
 507     BOOL first = FALSE;
 508
 509     TRACE("%s\n", debugstr_w(pszAuthValue));
 510
 511     if (!pAuthInfo)
 512     {
 513         TimeStamp exp;
 514
 515         first = TRUE;
 516         pAuthInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*pAuthInfo));
 517         if (!pAuthInfo)
 518             return FALSE;
 519
 520         SecInvalidateHandle(&pAuthInfo->cred);
 521         SecInvalidateHandle(&pAuthInfo->ctx);
 522         memset(&pAuthInfo->exp, 0, sizeof(pAuthInfo->exp));
 523         pAuthInfo->attr = 0;
 524         pAuthInfo->auth_data = NULL;
 525         pAuthInfo->auth_data_len = 0;
 526         pAuthInfo->finished = FALSE;
 527
 528         if (is_basic_auth_value(pszAuthValue))
 529         {
 530             static const WCHAR szBasic[] = {'B','a','s','i','c',0};
 531             pAuthInfo->scheme = WININET_strdupW(szBasic);
 532             if (!pAuthInfo->scheme)
 533             {
 534                 HeapFree(GetProcessHeap(), 0, pAuthInfo);
 535                 return FALSE;
 536             }
 537         }
 538         else
 539         {
 540             PVOID pAuthData;
 541             SEC_WINNT_AUTH_IDENTITY_W nt_auth_identity;
 542
 543             pAuthInfo->scheme = WININET_strdupW(pszAuthValue);
 544             if (!pAuthInfo->scheme)
 545             {
 546                 HeapFree(GetProcessHeap(), 0, pAuthInfo);
 547                 return FALSE;
 548             }
 549
 550             if (domain_and_username)
 551             {
 552                 WCHAR *user = strchrW(domain_and_username, '\\');
 553                 WCHAR *domain = domain_and_username;
 554
 555                 /* FIXME: make sure scheme accepts SEC_WINNT_AUTH_IDENTITY before calling AcquireCredentialsHandle */
 556
 557                 pAuthData = &nt_auth_identity;
 558
 559                 if (user) user++;
 560                 else
 561                 {
 562                     user = domain_and_username;
 563                     domain = NULL;
 564                 }
 565
 566                 nt_auth_identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
 567                 nt_auth_identity.User = user;
 568                 nt_auth_identity.UserLength = strlenW(nt_auth_identity.User);
 569                 nt_auth_identity.Domain = domain;
 570                 nt_auth_identity.DomainLength = domain ? user - domain - 1 : 0;
 571                 nt_auth_identity.Password = password;
 572                 nt_auth_identity.PasswordLength = strlenW(nt_auth_identity.Password);
 573             }
 574             else
 575                 /* use default credentials */
 576                 pAuthData = NULL;
 577
 578             sec_status = AcquireCredentialsHandleW(NULL, pAuthInfo->scheme,
 579                                                    SECPKG_CRED_OUTBOUND, NULL,
 580                                                    pAuthData, NULL,
 581                                                    NULL, &pAuthInfo->cred,
 582                                                    &exp);
 583             if (sec_status == SEC_E_OK)
 584             {
 585                 PSecPkgInfoW sec_pkg_info;
 586                 sec_status = QuerySecurityPackageInfoW(pAuthInfo->scheme, &sec_pkg_info);
 587                 if (sec_status == SEC_E_OK)
 588                 {
 589                     pAuthInfo->max_token = sec_pkg_info->cbMaxToken;
 590                     FreeContextBuffer(sec_pkg_info);
 591                 }
 592             }
 593             if (sec_status != SEC_E_OK)
 594             {
 595                 WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
 596                      debugstr_w(pAuthInfo->scheme), sec_status);
 597                 HeapFree(GetProcessHeap(), 0, pAuthInfo->scheme);
 598                 HeapFree(GetProcessHeap(), 0, pAuthInfo);
 599                 return FALSE;
 600             }
 601         }
 602         *ppAuthInfo = pAuthInfo;
 603     }
 604     else if (pAuthInfo->finished)
 605         return FALSE;
 606
 607     if ((strlenW(pszAuthValue) < strlenW(pAuthInfo->scheme)) ||
 608         strncmpiW(pszAuthValue, pAuthInfo->scheme, strlenW(pAuthInfo->scheme)))
 609     {
 610         ERR("authentication scheme changed from %s to %s\n",
 611             debugstr_w(pAuthInfo->scheme), debugstr_w(pszAuthValue));
 612         return FALSE;
 613     }
 614
 615     if (is_basic_auth_value(pszAuthValue))
 616     {
 617         int userlen;
 618         int passlen;
 619         char *auth_data;
 620
 621         TRACE("basic authentication\n");
 622
 623         /* we don't cache credentials for basic authentication, so we can't
 624          * retrieve them if the application didn't pass us any credentials */
 625         if (!domain_and_username) return FALSE;
 626
 627         userlen = WideCharToMultiByte(CP_UTF8, 0, domain_and_username, lstrlenW(domain_and_username), NULL, 0, NULL, NULL);
 628         passlen = WideCharToMultiByte(CP_UTF8, 0, password, lstrlenW(password), NULL, 0, NULL, NULL);
 629
 630         /* length includes a nul terminator, which will be re-used for the ':' */
 631         auth_data = HeapAlloc(GetProcessHeap(), 0, userlen + 1 + passlen);
 632         if (!auth_data)
 633             return FALSE;
 634
 635         WideCharToMultiByte(CP_UTF8, 0, domain_and_username, -1, auth_data, userlen, NULL, NULL);
 636         auth_data[userlen] = ':';
 637         WideCharToMultiByte(CP_UTF8, 0, password, -1, &auth_data[userlen+1], passlen, NULL, NULL);
 638
 639         pAuthInfo->auth_data = auth_data;
 640         pAuthInfo->auth_data_len = userlen + 1 + passlen;
 641         pAuthInfo->finished = TRUE;
 642
 643         return TRUE;
 644     }
 645     else
 646     {
 647         LPCWSTR pszAuthData;
 648         SecBufferDesc out_desc, in_desc;
 649         SecBuffer out, in;
 650         unsigned char *buffer;
 651         ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
 652             ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
 653
 654         in.BufferType = SECBUFFER_TOKEN;
 655         in.cbBuffer = 0;
 656         in.pvBuffer = NULL;
 657
 658         in_desc.ulVersion = 0;
 659         in_desc.cBuffers = 1;
 660         in_desc.pBuffers = &in;
 661
 662         pszAuthData = pszAuthValue + strlenW(pAuthInfo->scheme);
 663         if (*pszAuthData == ' ')
 664         {
 665             pszAuthData++;
 666             in.cbBuffer = HTTP_DecodeBase64(pszAuthData, NULL);
 667             in.pvBuffer = HeapAlloc(GetProcessHeap(), 0, in.cbBuffer);
 668             HTTP_DecodeBase64(pszAuthData, in.pvBuffer);
 669         }
 670
 671         buffer = HeapAlloc(GetProcessHeap(), 0, pAuthInfo->max_token);
 672
 673         out.BufferType = SECBUFFER_TOKEN;
 674         out.cbBuffer = pAuthInfo->max_token;
 675         out.pvBuffer = buffer;
 676
 677         out_desc.ulVersion = 0;
 678         out_desc.cBuffers = 1;
 679         out_desc.pBuffers = &out;
 680
 681         sec_status = InitializeSecurityContextW(first ? &pAuthInfo->cred : NULL,
 682                                                 first ? NULL : &pAuthInfo->ctx,
 683                                                 first ? lpwhr->lpHttpSession->lpszServerName : NULL,
 684                                                 context_req, 0, SECURITY_NETWORK_DREP,
 685                                                 in.pvBuffer ? &in_desc : NULL,
 686                                                 0, &pAuthInfo->ctx, &out_desc,
 687                                                 &pAuthInfo->attr, &pAuthInfo->exp);
 688         if (sec_status == SEC_E_OK)
 689         {
 690             pAuthInfo->finished = TRUE;
 691             pAuthInfo->auth_data = out.pvBuffer;
 692             pAuthInfo->auth_data_len = out.cbBuffer;
 693             TRACE("sending last auth packet\n");
 694         }
 695         else if (sec_status == SEC_I_CONTINUE_NEEDED)
 696         {
 697             pAuthInfo->auth_data = out.pvBuffer;
 698             pAuthInfo->auth_data_len = out.cbBuffer;
 699             TRACE("sending next auth packet\n");
 700         }
 701         else
 702         {
 703             ERR("InitializeSecurityContextW returned error 0x%08x\n", sec_status);
 704             pAuthInfo->finished = TRUE;
 705             HeapFree(GetProcessHeap(), 0, out.pvBuffer);
 706             return FALSE;
 707         }
 708     }
 709
 710     return TRUE;
 711 }
 712
 713 /***********************************************************************
 714  *           HTTP_HttpAddRequestHeadersW (internal)
 715  */
 716 static BOOL HTTP_HttpAddRequestHeadersW(LPWININETHTTPREQW lpwhr,
 717         LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
 718 {
 719     LPWSTR lpszStart;
 720     LPWSTR lpszEnd;
 721     LPWSTR buffer;
 722     BOOL bSuccess = FALSE;
 723     DWORD len;
 724
 725     TRACE("copying header: %s\n", debugstr_wn(lpszHeader, dwHeaderLength));
 726
 727     if( dwHeaderLength == ~0U )
 728         len = strlenW(lpszHeader);
 729     else
 730         len = dwHeaderLength;
 731     buffer = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1) );
 732     lstrcpynW( buffer, lpszHeader, len + 1);
 733
 734     lpszStart = buffer;
 735
 736     do
 737     {
 738         LPWSTR * pFieldAndValue;
 739
 740         lpszEnd = lpszStart;
 741
 742         while (*lpszEnd != '\0')
 743         {
 744             if (*lpszEnd == '\r' && *(lpszEnd + 1) == '\n')
 745                  break;
 746             lpszEnd++;
 747         }
 748
 749         if (*lpszStart == '\0')
 750             break;
 751
 752         if (*lpszEnd == '\r')
 753         {
 754             *lpszEnd = '\0';
 755             lpszEnd += 2; /* Jump over \r\n */
 756         }
 757         TRACE("interpreting header %s\n", debugstr_w(lpszStart));
 758         if (*lpszStart == '\0')
 759         {
 760             /* Skip 0-length headers */
 761             lpszStart = lpszEnd;
 762             bSuccess = TRUE;
 763             continue;
 764         }
 765         pFieldAndValue = HTTP_InterpretHttpHeader(lpszStart);
 766         if (pFieldAndValue)
 767         {
 768             bSuccess = HTTP_VerifyValidHeader(lpwhr, pFieldAndValue[0]);
 769             if (bSuccess)
 770                 bSuccess = HTTP_ProcessHeader(lpwhr, pFieldAndValue[0],
 771                     pFieldAndValue[1], dwModifier | HTTP_ADDHDR_FLAG_REQ);
 772             HTTP_FreeTokens(pFieldAndValue);
 773         }
 774
 775         lpszStart = lpszEnd;
 776     } while (bSuccess);
 777
 778     HeapFree(GetProcessHeap(), 0, buffer);
 779
 780     return bSuccess;
 781 }
 782
 783 /***********************************************************************
 784  *           HttpAddRequestHeadersW (WININET.@)
 785  *
 786  * Adds one or more HTTP header to the request handler
 787  *
 788  * NOTE
 789  * On Windows if dwHeaderLength includes the trailing '\0', then
 790  * HttpAddRequestHeadersW() adds it too. However this results in an
 791  * invalid Http header which is rejected by some servers so we probably
 792  * don't need to match Windows on that point.
 793  *
 794  * RETURNS
 795  *    TRUE  on success
 796  *    FALSE on failure
 797  *
 798  */
 799 BOOL WINAPI HttpAddRequestHeadersW(HINTERNET hHttpRequest,
 800         LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
 801 {
 802     BOOL bSuccess = FALSE;
 803     LPWININETHTTPREQW lpwhr;
 804
 805     TRACE("%p, %s, %i, %i\n", hHttpRequest, debugstr_wn(lpszHeader, dwHeaderLength), dwHeaderLength, dwModifier);
 806
 807     if (!lpszHeader)
 808       return TRUE;
 809
 810     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
 811     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
 812     {
 813         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 814         goto lend;
 815     }
 816     bSuccess = HTTP_HttpAddRequestHeadersW( lpwhr, lpszHeader, dwHeaderLength, dwModifier );
 817 lend:
 818     if( lpwhr )
 819         WININET_Release( &lpwhr->hdr );
 820
 821     return bSuccess;
 822 }
 823
 824 /***********************************************************************
 825  *           HttpAddRequestHeadersA (WININET.@)
 826  *
 827  * Adds one or more HTTP header to the request handler
 828  *
 829  * RETURNS
 830  *    TRUE  on success
 831  *    FALSE on failure
 832  *
 833  */
 834 BOOL WINAPI HttpAddRequestHeadersA(HINTERNET hHttpRequest,
 835         LPCSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
 836 {
 837     DWORD len;
 838     LPWSTR hdr;
 839     BOOL r;
 840
 841     TRACE("%p, %s, %i, %i\n", hHttpRequest, debugstr_an(lpszHeader, dwHeaderLength), dwHeaderLength, dwModifier);
 842
 843     len = MultiByteToWideChar( CP_ACP, 0, lpszHeader, dwHeaderLength, NULL, 0 );
 844     hdr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 845     MultiByteToWideChar( CP_ACP, 0, lpszHeader, dwHeaderLength, hdr, len );
 846     if( dwHeaderLength != ~0U )
 847         dwHeaderLength = len;
 848
 849     r = HttpAddRequestHeadersW( hHttpRequest, hdr, dwHeaderLength, dwModifier );
 850
 851     HeapFree( GetProcessHeap(), 0, hdr );
 852
 853     return r;
 854 }
 855
 856 /***********************************************************************
 857  *           HttpEndRequestA (WININET.@)
 858  *
 859  * Ends an HTTP request that was started by HttpSendRequestEx
 860  *
 861  * RETURNS
 862  *    TRUE      if successful
 863  *    FALSE     on failure
 864  *
 865  */
 866 BOOL WINAPI HttpEndRequestA(HINTERNET hRequest,
 867         LPINTERNET_BUFFERSA lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
 868 {
 869     TRACE("(%p, %p, %08x, %08lx)\n", hRequest, lpBuffersOut, dwFlags, dwContext);
 870
 871     if (lpBuffersOut)
 872     {
 873         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 874         return FALSE;
 875     }
 876
 877     return HttpEndRequestW(hRequest, NULL, dwFlags, dwContext);
 878 }
 879
 880 static BOOL HTTP_HttpEndRequestW(LPWININETHTTPREQW lpwhr, DWORD dwFlags, DWORD_PTR dwContext)
 881 {
 882     BOOL rc = FALSE;
 883     INT responseLen;
 884     DWORD dwBufferSize;
 885     INTERNET_ASYNC_RESULT iar;
 886
 887     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
 888                   INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
 889
 890     responseLen = HTTP_GetResponseHeaders(lpwhr, TRUE);
 891     if (responseLen)
 892         rc = TRUE;
 893
 894     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
 895                   INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen, sizeof(DWORD));
 896
 897     /* process cookies here. Is this right? */
 898     HTTP_ProcessCookies(lpwhr);
 899
 900     if (!set_content_length( lpwhr )) HTTP_FinishedReading(lpwhr);
 901
 902     if (!(lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT))
 903     {
 904         DWORD dwCode,dwCodeLength = sizeof(DWORD);
 905         if (HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE, &dwCode, &dwCodeLength, NULL) &&
 906             (dwCode == 302 || dwCode == 301 || dwCode == 303))
 907         {
 908             WCHAR *new_url, szNewLocation[INTERNET_MAX_URL_LENGTH];
 909             dwBufferSize=sizeof(szNewLocation);
 910             if (HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_LOCATION, szNewLocation, &dwBufferSize, NULL))
 911             {
 912                 /* redirects are always GETs */
 913                 HeapFree(GetProcessHeap(), 0, lpwhr->lpszVerb);
 914                 lpwhr->lpszVerb = WININET_strdupW(szGET);
 915                 HTTP_DrainContent(lpwhr);
 916                 if ((new_url = HTTP_GetRedirectURL( lpwhr, szNewLocation )))
 917                 {
 918                     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext, INTERNET_STATUS_REDIRECT,
 919                                           new_url, (strlenW(new_url) + 1) * sizeof(WCHAR));
 920                     rc = HTTP_HandleRedirect(lpwhr, new_url);
 921                     if (rc)
 922                         rc = HTTP_HttpSendRequestW(lpwhr, NULL, 0, NULL, 0, 0, TRUE);
 923                     HeapFree( GetProcessHeap(), 0, new_url );
 924                 }
 925             }
 926         }
 927     }
 928
 929     iar.dwResult = (DWORD_PTR)lpwhr->hdr.hInternet;
 930     iar.dwError = rc ? 0 : INTERNET_GetLastError();
 931
 932     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
 933                           INTERNET_STATUS_REQUEST_COMPLETE, &iar,
 934                           sizeof(INTERNET_ASYNC_RESULT));
 935     return rc;
 936 }
 937
 938 static void AsyncHttpEndRequestProc(WORKREQUEST *work)
 939 {
 940     struct WORKREQ_HTTPENDREQUESTW const *req = &work->u.HttpEndRequestW;
 941     LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW)work->hdr;
 942
 943     TRACE("%p\n", lpwhr);
 944
 945     HTTP_HttpEndRequestW(lpwhr, req->dwFlags, req->dwContext);
 946 }
 947
 948 /***********************************************************************
 949  *           HttpEndRequestW (WININET.@)
 950  *
 951  * Ends an HTTP request that was started by HttpSendRequestEx
 952  *
 953  * RETURNS
 954  *    TRUE      if successful
 955  *    FALSE     on failure
 956  *
 957  */
 958 BOOL WINAPI HttpEndRequestW(HINTERNET hRequest,
 959         LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
 960 {
 961     BOOL rc = FALSE;
 962     LPWININETHTTPREQW lpwhr;
 963
 964     TRACE("-->\n");
 965
 966     if (lpBuffersOut)
 967     {
 968         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 969         return FALSE;
 970     }
 971
 972     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hRequest );
 973
 974     if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
 975     {
 976         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 977         if (lpwhr)
 978             WININET_Release( &lpwhr->hdr );
 979         return FALSE;
 980     }
 981     lpwhr->hdr.dwFlags |= dwFlags;
 982
 983     if (lpwhr->lpHttpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 984     {
 985         WORKREQUEST work;
 986         struct WORKREQ_HTTPENDREQUESTW *request;
 987
 988         work.asyncproc = AsyncHttpEndRequestProc;
 989         work.hdr = WININET_AddRef( &lpwhr->hdr );
 990
 991         request = &work.u.HttpEndRequestW;
 992         request->dwFlags = dwFlags;
 993         request->dwContext = dwContext;
 994
 995         INTERNET_AsyncCall(&work);
 996         INTERNET_SetLastError(ERROR_IO_PENDING);
 997     }
 998     else
 999         rc = HTTP_HttpEndRequestW(lpwhr, dwFlags, dwContext);
1000
1001     WININET_Release( &lpwhr->hdr );
1002     TRACE("%i <--\n",rc);
1003     return rc;
1004 }
1005
1006 /***********************************************************************
1007  *           HttpOpenRequestW (WININET.@)
1008  *
1009  * Open a HTTP request handle
1010  *
1011  * RETURNS
1012  *    HINTERNET  a HTTP request handle on success
1013  *    NULL       on failure
1014  *
1015  */
1016 HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession,
1017         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
1018         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
1019         DWORD dwFlags, DWORD_PTR dwContext)
1020 {
1021     LPWININETHTTPSESSIONW lpwhs;
1022     HINTERNET handle = NULL;
1023
1024     TRACE("(%p, %s, %s, %s, %s, %p, %08x, %08lx)\n", hHttpSession,
1025           debugstr_w(lpszVerb), debugstr_w(lpszObjectName),
1026           debugstr_w(lpszVersion), debugstr_w(lpszReferrer), lpszAcceptTypes,
1027           dwFlags, dwContext);
1028     if(lpszAcceptTypes!=NULL)
1029     {
1030         int i;
1031         for(i=0;lpszAcceptTypes[i]!=NULL;i++)
1032             TRACE("\taccept type: %s\n",debugstr_w(lpszAcceptTypes[i]));
1033     }
1034
1035     lpwhs = (LPWININETHTTPSESSIONW) WININET_GetObject( hHttpSession );
1036     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
1037     {
1038         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1039         goto lend;
1040     }
1041
1042     /*
1043      * My tests seem to show that the windows version does not
1044      * become asynchronous until after this point. And anyhow
1045      * if this call was asynchronous then how would you get the
1046      * necessary HINTERNET pointer returned by this function.
1047      *
1048      */
1049     handle = HTTP_HttpOpenRequestW(lpwhs, lpszVerb, lpszObjectName,
1050                                    lpszVersion, lpszReferrer, lpszAcceptTypes,
1051                                    dwFlags, dwContext);
1052 lend:
1053     if( lpwhs )
1054         WININET_Release( &lpwhs->hdr );
1055     TRACE("returning %p\n", handle);
1056     return handle;
1057 }
1058
1059
1060 /***********************************************************************
1061  *           HttpOpenRequestA (WININET.@)
1062  *
1063  * Open a HTTP request handle
1064  *
1065  * RETURNS
1066  *    HINTERNET  a HTTP request handle on success
1067  *    NULL       on failure
1068  *
1069  */
1070 HINTERNET WINAPI HttpOpenRequestA(HINTERNET hHttpSession,
1071         LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion,
1072         LPCSTR lpszReferrer , LPCSTR *lpszAcceptTypes,
1073         DWORD dwFlags, DWORD_PTR dwContext)
1074 {
1075     LPWSTR szVerb = NULL, szObjectName = NULL;
1076     LPWSTR szVersion = NULL, szReferrer = NULL, *szAcceptTypes = NULL;
1077     INT len, acceptTypesCount;
1078     HINTERNET rc = FALSE;
1079     LPCSTR *types;
1080
1081     TRACE("(%p, %s, %s, %s, %s, %p, %08x, %08lx)\n", hHttpSession,
1082           debugstr_a(lpszVerb), debugstr_a(lpszObjectName),
1083           debugstr_a(lpszVersion), debugstr_a(lpszReferrer), lpszAcceptTypes,
1084           dwFlags, dwContext);
1085
1086     if (lpszVerb)
1087     {
1088         len = MultiByteToWideChar(CP_ACP, 0, lpszVerb, -1, NULL, 0 );
1089         szVerb = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
1090         if ( !szVerb )
1091             goto end;
1092         MultiByteToWideChar(CP_ACP, 0, lpszVerb, -1, szVerb, len);
1093     }
1094
1095     if (lpszObjectName)
1096     {
1097         len = MultiByteToWideChar(CP_ACP, 0, lpszObjectName, -1, NULL, 0 );
1098         szObjectName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
1099         if ( !szObjectName )
1100             goto end;
1101         MultiByteToWideChar(CP_ACP, 0, lpszObjectName, -1, szObjectName, len );
1102     }
1103
1104     if (lpszVersion)
1105     {
1106         len = MultiByteToWideChar(CP_ACP, 0, lpszVersion, -1, NULL, 0 );
1107         szVersion = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1108         if ( !szVersion )
1109             goto end;
1110         MultiByteToWideChar(CP_ACP, 0, lpszVersion, -1, szVersion, len );
1111     }
1112
1113     if (lpszReferrer)
1114     {
1115         len = MultiByteToWideChar(CP_ACP, 0, lpszReferrer, -1, NULL, 0 );
1116         szReferrer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1117         if ( !szReferrer )
1118             goto end;
1119         MultiByteToWideChar(CP_ACP, 0, lpszReferrer, -1, szReferrer, len );
1120     }
1121
1122     if (lpszAcceptTypes)
1123     {
1124         acceptTypesCount = 0;
1125         types = lpszAcceptTypes;
1126         while (*types)
1127         {
1128             __TRY
1129             {
1130                 /* find out how many there are */
1131                 if (*types && **types)
1132                 {
1133                     TRACE("accept type: %s\n", debugstr_a(*types));
1134                     acceptTypesCount++;
1135                 }
1136             }
1137             __EXCEPT_PAGE_FAULT
1138             {
1139                 WARN("invalid accept type pointer\n");
1140             }
1141             __ENDTRY;
1142             types++;
1143         }
1144         szAcceptTypes = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR *) * (acceptTypesCount+1));
1145         if (!szAcceptTypes) goto end;
1146
1147         acceptTypesCount = 0;
1148         types = lpszAcceptTypes;
1149         while (*types)
1150         {
1151             __TRY
1152             {
1153                 if (*types && **types)
1154                 {
1155                     len = MultiByteToWideChar(CP_ACP, 0, *types, -1, NULL, 0 );
1156                     szAcceptTypes[acceptTypesCount] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1157
1158                     MultiByteToWideChar(CP_ACP, 0, *types, -1, szAcceptTypes[acceptTypesCount], len);
1159                     acceptTypesCount++;
1160                 }
1161             }
1162             __EXCEPT_PAGE_FAULT
1163             {
1164                 /* ignore invalid pointer */
1165             }
1166             __ENDTRY;
1167             types++;
1168         }
1169         szAcceptTypes[acceptTypesCount] = NULL;
1170     }
1171
1172     rc = HttpOpenRequestW(hHttpSession, szVerb, szObjectName,
1173                           szVersion, szReferrer,
1174                           (LPCWSTR*)szAcceptTypes, dwFlags, dwContext);
1175
1176 end:
1177     if (szAcceptTypes)
1178     {
1179         acceptTypesCount = 0;
1180         while (szAcceptTypes[acceptTypesCount])
1181         {
1182             HeapFree(GetProcessHeap(), 0, szAcceptTypes[acceptTypesCount]);
1183             acceptTypesCount++;
1184         }
1185         HeapFree(GetProcessHeap(), 0, szAcceptTypes);
1186     }
1187     HeapFree(GetProcessHeap(), 0, szReferrer);
1188     HeapFree(GetProcessHeap(), 0, szVersion);
1189     HeapFree(GetProcessHeap(), 0, szObjectName);
1190     HeapFree(GetProcessHeap(), 0, szVerb);
1191
1192     return rc;
1193 }
1194
1195 /***********************************************************************
1196  *  HTTP_EncodeBase64
1197  */
1198 static UINT HTTP_EncodeBase64( LPCSTR bin, unsigned int len, LPWSTR base64 )
1199 {
1200     UINT n = 0, x;
1201     static const CHAR HTTP_Base64Enc[] =
1202         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1203
1204     while( len > 0 )
1205     {
1206         /* first 6 bits, all from bin[0] */
1207         base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2];
1208         x = (bin[0] & 3) << 4;
1209
1210         /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
1211         if( len == 1 )
1212         {
1213             base64[n++] = HTTP_Base64Enc[x];
1214             base64[n++] = '=';
1215             base64[n++] = '=';
1216             break;
1217         }
1218         base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ];
1219         x = ( bin[1] & 0x0f ) << 2;
1220
1221         /* next 6 bits 4 from bin[1] and 2 from bin[2] */
1222         if( len == 2 )
1223         {
1224             base64[n++] = HTTP_Base64Enc[x];
1225             base64[n++] = '=';
1226             break;
1227         }
1228         base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ];
1229
1230         /* last 6 bits, all from bin [2] */
1231         base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ];
1232         bin += 3;
1233         len -= 3;
1234     }
1235     base64[n] = 0;
1236     return n;
1237 }
1238
1239 #define CH(x) (((x) >= 'A' && (x) <= 'Z') ? (x) - 'A' : \
1240                ((x) >= 'a' && (x) <= 'z') ? (x) - 'a' + 26 : \
1241                ((x) >= '0' && (x) <= '9') ? (x) - '0' + 52 : \
1242                ((x) == '+') ? 62 : ((x) == '/') ? 63 : -1)
1243 static const signed char HTTP_Base64Dec[256] =
1244 {
1245     CH( 0),CH( 1),CH( 2),CH( 3),CH( 4),CH( 5),CH( 6),CH( 7),CH( 8),CH( 9),
1246     CH(10),CH(11),CH(12),CH(13),CH(14),CH(15),CH(16),CH(17),CH(18),CH(19),
1247     CH(20),CH(21),CH(22),CH(23),CH(24),CH(25),CH(26),CH(27),CH(28),CH(29),
1248     CH(30),CH(31),CH(32),CH(33),CH(34),CH(35),CH(36),CH(37),CH(38),CH(39),
1249     CH(40),CH(41),CH(42),CH(43),CH(44),CH(45),CH(46),CH(47),CH(48),CH(49),
1250     CH(50),CH(51),CH(52),CH(53),CH(54),CH(55),CH(56),CH(57),CH(58),CH(59),
1251     CH(60),CH(61),CH(62),CH(63),CH(64),CH(65),CH(66),CH(67),CH(68),CH(69),
1252     CH(70),CH(71),CH(72),CH(73),CH(74),CH(75),CH(76),CH(77),CH(78),CH(79),
1253     CH(80),CH(81),CH(82),CH(83),CH(84),CH(85),CH(86),CH(87),CH(88),CH(89),
1254     CH(90),CH(91),CH(92),CH(93),CH(94),CH(95),CH(96),CH(97),CH(98),CH(99),
1255     CH(100),CH(101),CH(102),CH(103),CH(104),CH(105),CH(106),CH(107),CH(108),CH(109),
1256     CH(110),CH(111),CH(112),CH(113),CH(114),CH(115),CH(116),CH(117),CH(118),CH(119),
1257     CH(120),CH(121),CH(122),CH(123),CH(124),CH(125),CH(126),CH(127),CH(128),CH(129),
1258     CH(130),CH(131),CH(132),CH(133),CH(134),CH(135),CH(136),CH(137),CH(138),CH(139),
1259     CH(140),CH(141),CH(142),CH(143),CH(144),CH(145),CH(146),CH(147),CH(148),CH(149),
1260     CH(150),CH(151),CH(152),CH(153),CH(154),CH(155),CH(156),CH(157),CH(158),CH(159),
1261     CH(160),CH(161),CH(162),CH(163),CH(164),CH(165),CH(166),CH(167),CH(168),CH(169),
1262     CH(170),CH(171),CH(172),CH(173),CH(174),CH(175),CH(176),CH(177),CH(178),CH(179),
1263     CH(180),CH(181),CH(182),CH(183),CH(184),CH(185),CH(186),CH(187),CH(188),CH(189),
1264     CH(190),CH(191),CH(192),CH(193),CH(194),CH(195),CH(196),CH(197),CH(198),CH(199),
1265     CH(200),CH(201),CH(202),CH(203),CH(204),CH(205),CH(206),CH(207),CH(208),CH(209),
1266     CH(210),CH(211),CH(212),CH(213),CH(214),CH(215),CH(216),CH(217),CH(218),CH(219),
1267     CH(220),CH(221),CH(222),CH(223),CH(224),CH(225),CH(226),CH(227),CH(228),CH(229),
1268     CH(230),CH(231),CH(232),CH(233),CH(234),CH(235),CH(236),CH(237),CH(238),CH(239),
1269     CH(240),CH(241),CH(242),CH(243),CH(244),CH(245),CH(246),CH(247),CH(248), CH(249),
1270     CH(250),CH(251),CH(252),CH(253),CH(254),CH(255),
1271 };
1272 #undef CH
1273
1274 /***********************************************************************
1275  *  HTTP_DecodeBase64
1276  */
1277 static UINT HTTP_DecodeBase64( LPCWSTR base64, LPSTR bin )
1278 {
1279     unsigned int n = 0;
1280
1281     while(*base64)
1282     {
1283         signed char in[4];
1284
1285         if (base64[0] >= ARRAYSIZE(HTTP_Base64Dec) ||
1286             ((in[0] = HTTP_Base64Dec[base64[0]]) == -1) ||
1287             base64[1] >= ARRAYSIZE(HTTP_Base64Dec) ||
1288             ((in[1] = HTTP_Base64Dec[base64[1]]) == -1))
1289         {
1290             WARN("invalid base64: %s\n", debugstr_w(base64));
1291             return 0;
1292         }
1293         if (bin)
1294             bin[n] = (unsigned char) (in[0] << 2 | in[1] >> 4);
1295         n++;
1296
1297         if ((base64[2] == '=') && (base64[3] == '='))
1298             break;
1299         if (base64[2] > ARRAYSIZE(HTTP_Base64Dec) ||
1300             ((in[2] = HTTP_Base64Dec[base64[2]]) == -1))
1301         {
1302             WARN("invalid base64: %s\n", debugstr_w(&base64[2]));
1303             return 0;
1304         }
1305         if (bin)
1306             bin[n] = (unsigned char) (in[1] << 4 | in[2] >> 2);
1307         n++;
1308
1309         if (base64[3] == '=')
1310             break;
1311         if (base64[3] > ARRAYSIZE(HTTP_Base64Dec) ||
1312             ((in[3] = HTTP_Base64Dec[base64[3]]) == -1))
1313         {
1314             WARN("invalid base64: %s\n", debugstr_w(&base64[3]));
1315             return 0;
1316         }
1317         if (bin)
1318             bin[n] = (unsigned char) (((in[2] << 6) & 0xc0) | in[3]);
1319         n++;
1320
1321         base64 += 4;
1322     }
1323
1324     return n;
1325 }
1326
1327 /***********************************************************************
1328  *  HTTP_InsertAuthorization
1329  *
1330  *   Insert or delete the authorization field in the request header.
1331  */
1332 static BOOL HTTP_InsertAuthorization( LPWININETHTTPREQW lpwhr, struct HttpAuthInfo *pAuthInfo, LPCWSTR header )
1333 {
1334     if (pAuthInfo)
1335     {
1336         static const WCHAR wszSpace[] = {' ',0};
1337         static const WCHAR wszBasic[] = {'B','a','s','i','c',0};
1338         unsigned int len;
1339         WCHAR *authorization = NULL;
1340
1341         if (pAuthInfo->auth_data_len)
1342         {
1343             /* scheme + space + base64 encoded data (3/2/1 bytes data -> 4 bytes of characters) */
1344             len = strlenW(pAuthInfo->scheme)+1+((pAuthInfo->auth_data_len+2)*4)/3;
1345             authorization = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
1346             if (!authorization)
1347                 return FALSE;
1348
1349             strcpyW(authorization, pAuthInfo->scheme);
1350             strcatW(authorization, wszSpace);
1351             HTTP_EncodeBase64(pAuthInfo->auth_data,
1352                               pAuthInfo->auth_data_len,
1353                               authorization+strlenW(authorization));
1354
1355             /* clear the data as it isn't valid now that it has been sent to the
1356              * server, unless it's Basic authentication which doesn't do
1357              * connection tracking */
1358             if (strcmpiW(pAuthInfo->scheme, wszBasic))
1359             {
1360                 HeapFree(GetProcessHeap(), 0, pAuthInfo->auth_data);
1361                 pAuthInfo->auth_data = NULL;
1362                 pAuthInfo->auth_data_len = 0;
1363             }
1364         }
1365
1366         TRACE("Inserting authorization: %s\n", debugstr_w(authorization));
1367
1368         HTTP_ProcessHeader(lpwhr, header, authorization, HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE);
1369
1370         HeapFree(GetProcessHeap(), 0, authorization);
1371     }
1372     return TRUE;
1373 }
1374
1375 static WCHAR *HTTP_BuildProxyRequestUrl(WININETHTTPREQW *req)
1376 {
1377     WCHAR new_location[INTERNET_MAX_URL_LENGTH], *url;
1378     DWORD size;
1379
1380     size = sizeof(new_location);
1381     if (HTTP_HttpQueryInfoW(req, HTTP_QUERY_LOCATION, new_location, &size, NULL))
1382     {
1383         if (!(url = HeapAlloc( GetProcessHeap(), 0, size + sizeof(WCHAR) ))) return NULL;
1384         strcpyW( url, new_location );
1385     }
1386     else
1387     {
1388         static const WCHAR slash[] = { '/',0 };
1389         static const WCHAR format[] = { 'h','t','t','p',':','/','/','%','s',':','%','d',0 };
1390         static const WCHAR formatSSL[] = { 'h','t','t','p','s',':','/','/','%','s',':','%','d',0 };
1391         WININETHTTPSESSIONW *session = req->lpHttpSession;
1392
1393         size = 16; /* "https://" + sizeof(port#) + ":/\0" */
1394         size += strlenW( session->lpszHostName ) + strlenW( req->lpszPath );
1395
1396         if (!(url = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL;
1397
1398         if (req->hdr.dwFlags & INTERNET_FLAG_SECURE)
1399             sprintfW( url, formatSSL, session->lpszHostName, session->nHostPort );
1400         else
1401             sprintfW( url, format, session->lpszHostName, session->nHostPort );
1402         if (req->lpszPath[0] != '/') strcatW( url, slash );
1403         strcatW( url, req->lpszPath );
1404     }
1405     TRACE("url=%s\n", debugstr_w(url));
1406     return url;
1407 }
1408
1409 /***********************************************************************
1410  *           HTTP_DealWithProxy
1411  */
1412 static BOOL HTTP_DealWithProxy( LPWININETAPPINFOW hIC,
1413     LPWININETHTTPSESSIONW lpwhs, LPWININETHTTPREQW lpwhr)
1414 {
1415     WCHAR buf[MAXHOSTNAME];
1416     WCHAR proxy[MAXHOSTNAME + 15]; /* 15 == "http://" + sizeof(port#) + ":/\0" */
1417     static WCHAR szNul[] = { 0 };
1418     URL_COMPONENTSW UrlComponents;
1419     static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/',0 };
1420     static const WCHAR szFormat[] = { 'h','t','t','p',':','/','/','%','s',0 };
1421
1422     memset( &UrlComponents, 0, sizeof UrlComponents );
1423     UrlComponents.dwStructSize = sizeof UrlComponents;
1424     UrlComponents.lpszHostName = buf;
1425     UrlComponents.dwHostNameLength = MAXHOSTNAME;
1426
1427     if( CSTR_EQUAL != CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1428                                  hIC->lpszProxy,strlenW(szHttp),szHttp,strlenW(szHttp)) )
1429         sprintfW(proxy, szFormat, hIC->lpszProxy);
1430     else
1431         strcpyW(proxy, hIC->lpszProxy);
1432     if( !InternetCrackUrlW(proxy, 0, 0, &UrlComponents) )
1433         return FALSE;
1434     if( UrlComponents.dwHostNameLength == 0 )
1435         return FALSE;
1436
1437     if( !lpwhr->lpszPath )
1438         lpwhr->lpszPath = szNul;
1439
1440     if(UrlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
1441         UrlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
1442
1443     HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
1444     lpwhs->lpszServerName = WININET_strdupW(UrlComponents.lpszHostName);
1445     lpwhs->nServerPort = UrlComponents.nPort;
1446
1447     TRACE("proxy server=%s port=%d\n", debugstr_w(lpwhs->lpszServerName), lpwhs->nServerPort);
1448     return TRUE;
1449 }
1450
1451 static BOOL HTTP_ResolveName(LPWININETHTTPREQW lpwhr)
1452 {
1453     char szaddr[32];
1454     LPWININETHTTPSESSIONW lpwhs = lpwhr->lpHttpSession;
1455
1456     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
1457                           INTERNET_STATUS_RESOLVING_NAME,
1458                           lpwhs->lpszServerName,
1459                           strlenW(lpwhs->lpszServerName)+1);
1460
1461     if (!GetAddress(lpwhs->lpszServerName, lpwhs->nServerPort,
1462                     &lpwhs->socketAddress))
1463     {
1464         INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
1465         return FALSE;
1466     }
1467
1468     inet_ntop(lpwhs->socketAddress.sin_family, &lpwhs->socketAddress.sin_addr,
1469               szaddr, sizeof(szaddr));
1470     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
1471                           INTERNET_STATUS_NAME_RESOLVED,
1472                           szaddr, strlen(szaddr)+1);
1473
1474     TRACE("resolved %s to %s\n", debugstr_w(lpwhs->lpszServerName), szaddr);
1475     return TRUE;
1476 }
1477
1478
1479 /***********************************************************************
1480  *           HTTPREQ_Destroy (internal)
1481  *
1482  * Deallocate request handle
1483  *
1484  */
1485 static void HTTPREQ_Destroy(WININETHANDLEHEADER *hdr)
1486 {
1487     LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW) hdr;
1488     DWORD i;
1489
1490     TRACE("\n");
1491
1492     if(lpwhr->hCacheFile)
1493         CloseHandle(lpwhr->hCacheFile);
1494
1495     if(lpwhr->lpszCacheFile) {
1496         DeleteFileW(lpwhr->lpszCacheFile); /* FIXME */
1497         HeapFree(GetProcessHeap(), 0, lpwhr->lpszCacheFile);
1498     }
1499
1500     DeleteCriticalSection( &lpwhr->read_section );
1501     WININET_Release(&lpwhr->lpHttpSession->hdr);
1502
1503     if (lpwhr->pAuthInfo)
1504     {
1505         if (SecIsValidHandle(&lpwhr->pAuthInfo->ctx))
1506             DeleteSecurityContext(&lpwhr->pAuthInfo->ctx);
1507         if (SecIsValidHandle(&lpwhr->pAuthInfo->cred))
1508             FreeCredentialsHandle(&lpwhr->pAuthInfo->cred);
1509
1510         HeapFree(GetProcessHeap(), 0, lpwhr->pAuthInfo->auth_data);
1511         HeapFree(GetProcessHeap(), 0, lpwhr->pAuthInfo->scheme);
1512         HeapFree(GetProcessHeap(), 0, lpwhr->pAuthInfo);
1513         lpwhr->pAuthInfo = NULL;
1514     }
1515
1516     if (lpwhr->pProxyAuthInfo)
1517     {
1518         if (SecIsValidHandle(&lpwhr->pProxyAuthInfo->ctx))
1519             DeleteSecurityContext(&lpwhr->pProxyAuthInfo->ctx);
1520         if (SecIsValidHandle(&lpwhr->pProxyAuthInfo->cred))
1521             FreeCredentialsHandle(&lpwhr->pProxyAuthInfo->cred);
1522
1523         HeapFree(GetProcessHeap(), 0, lpwhr->pProxyAuthInfo->auth_data);
1524         HeapFree(GetProcessHeap(), 0, lpwhr->pProxyAuthInfo->scheme);
1525         HeapFree(GetProcessHeap(), 0, lpwhr->pProxyAuthInfo);
1526         lpwhr->pProxyAuthInfo = NULL;
1527     }
1528
1529     HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
1530     HeapFree(GetProcessHeap(), 0, lpwhr->lpszVerb);
1531     HeapFree(GetProcessHeap(), 0, lpwhr->lpszRawHeaders);
1532     HeapFree(GetProcessHeap(), 0, lpwhr->lpszVersion);
1533     HeapFree(GetProcessHeap(), 0, lpwhr->lpszStatusText);
1534
1535     for (i = 0; i < lpwhr->nCustHeaders; i++)
1536     {
1537         HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszField);
1538         HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszValue);
1539     }
1540
1541     HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders);
1542     HeapFree(GetProcessHeap(), 0, lpwhr);
1543 }
1544
1545 static void HTTPREQ_CloseConnection(WININETHANDLEHEADER *hdr)
1546 {
1547     LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW) hdr;
1548
1549     TRACE("%p\n",lpwhr);
1550
1551 #ifdef HAVE_ZLIB
1552     if(lpwhr->gzip_stream) {
1553         inflateEnd(&lpwhr->gzip_stream->zstream);
1554         HeapFree(GetProcessHeap(), 0, lpwhr->gzip_stream);
1555         lpwhr->gzip_stream = NULL;
1556     }
1557 #endif
1558
1559     if (!NETCON_connected(&lpwhr->netConnection))
1560         return;
1561
1562     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
1563                           INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
1564
1565     NETCON_close(&lpwhr->netConnection);
1566
1567     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
1568                           INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
1569 }
1570
1571 static DWORD HTTPREQ_QueryOption(WININETHANDLEHEADER *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
1572 {
1573     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
1574
1575     switch(option) {
1576     case INTERNET_OPTION_HANDLE_TYPE:
1577         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
1578
1579         if (*size < sizeof(ULONG))
1580             return ERROR_INSUFFICIENT_BUFFER;
1581
1582         *size = sizeof(DWORD);
1583         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_HTTP_REQUEST;
1584         return ERROR_SUCCESS;
1585
1586     case INTERNET_OPTION_URL: {
1587         WCHAR url[INTERNET_MAX_URL_LENGTH];
1588         HTTPHEADERW *host;
1589         DWORD len;
1590         WCHAR *pch;
1591
1592         static const WCHAR httpW[] = {'h','t','t','p',':','/','/',0};
1593
1594         TRACE("INTERNET_OPTION_URL\n");
1595
1596         host = HTTP_GetHeader(req, hostW);
1597         strcpyW(url, httpW);
1598         strcatW(url, host->lpszValue);
1599         if (NULL != (pch = strchrW(url + strlenW(httpW), ':')))
1600             *pch = 0;
1601         strcatW(url, req->lpszPath);
1602
1603         TRACE("INTERNET_OPTION_URL: %s\n",debugstr_w(url));
1604
1605         if(unicode) {
1606             len = (strlenW(url)+1) * sizeof(WCHAR);
1607             if(*size < len)
1608                 return ERROR_INSUFFICIENT_BUFFER;
1609
1610             *size = len;
1611             strcpyW(buffer, url);
1612             return ERROR_SUCCESS;
1613         }else {
1614             len = WideCharToMultiByte(CP_ACP, 0, url, -1, buffer, *size, NULL, NULL);
1615             if(len > *size)
1616                 return ERROR_INSUFFICIENT_BUFFER;
1617
1618             *size = len;
1619             return ERROR_SUCCESS;
1620         }
1621     }
1622
1623     case INTERNET_OPTION_DATAFILE_NAME: {
1624         DWORD req_size;
1625
1626         TRACE("INTERNET_OPTION_DATAFILE_NAME\n");
1627
1628         if(!req->lpszCacheFile) {
1629             *size = 0;
1630             return ERROR_INTERNET_ITEM_NOT_FOUND;
1631         }
1632
1633         if(unicode) {
1634             req_size = (lstrlenW(req->lpszCacheFile)+1) * sizeof(WCHAR);
1635             if(*size < req_size)
1636                 return ERROR_INSUFFICIENT_BUFFER;
1637
1638             *size = req_size;
1639             memcpy(buffer, req->lpszCacheFile, *size);
1640             return ERROR_SUCCESS;
1641         }else {
1642             req_size = WideCharToMultiByte(CP_ACP, 0, req->lpszCacheFile, -1, NULL, 0, NULL, NULL);
1643             if (req_size > *size)
1644                 return ERROR_INSUFFICIENT_BUFFER;
1645
1646             *size = WideCharToMultiByte(CP_ACP, 0, req->lpszCacheFile,
1647                     -1, buffer, *size, NULL, NULL);
1648             return ERROR_SUCCESS;
1649         }
1650     }
1651
1652     case INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT: {
1653         PCCERT_CONTEXT context;
1654
1655         if(*size < sizeof(INTERNET_CERTIFICATE_INFOW)) {
1656             *size = sizeof(INTERNET_CERTIFICATE_INFOW);
1657             return ERROR_INSUFFICIENT_BUFFER;
1658         }
1659
1660         context = (PCCERT_CONTEXT)NETCON_GetCert(&(req->netConnection));
1661         if(context) {
1662             INTERNET_CERTIFICATE_INFOW *info = (INTERNET_CERTIFICATE_INFOW*)buffer;
1663             DWORD len;
1664
1665             memset(info, 0, sizeof(INTERNET_CERTIFICATE_INFOW));
1666             info->ftExpiry = context->pCertInfo->NotAfter;
1667             info->ftStart = context->pCertInfo->NotBefore;
1668             if(unicode) {
1669                 len = CertNameToStrW(context->dwCertEncodingType,
1670                         &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR, NULL, 0);
1671                 info->lpszSubjectInfo = LocalAlloc(0, len*sizeof(WCHAR));
1672                 if(info->lpszSubjectInfo)
1673                     CertNameToStrW(context->dwCertEncodingType,
1674                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
1675                              info->lpszSubjectInfo, len);
1676                 len = CertNameToStrW(context->dwCertEncodingType,
1677                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR, NULL, 0);
1678                 info->lpszIssuerInfo = LocalAlloc(0, len*sizeof(WCHAR));
1679                 if (info->lpszIssuerInfo)
1680                     CertNameToStrW(context->dwCertEncodingType,
1681                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
1682                              info->lpszIssuerInfo, len);
1683             }else {
1684                 INTERNET_CERTIFICATE_INFOA *infoA = (INTERNET_CERTIFICATE_INFOA*)info;
1685
1686                 len = CertNameToStrA(context->dwCertEncodingType,
1687                          &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR, NULL, 0);
1688                 infoA->lpszSubjectInfo = LocalAlloc(0, len);
1689                 if(infoA->lpszSubjectInfo)
1690                     CertNameToStrA(context->dwCertEncodingType,
1691                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
1692                              infoA->lpszSubjectInfo, len);
1693                 len = CertNameToStrA(context->dwCertEncodingType,
1694                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR, NULL, 0);
1695                 infoA->lpszIssuerInfo = LocalAlloc(0, len);
1696                 if(infoA->lpszIssuerInfo)
1697                     CertNameToStrA(context->dwCertEncodingType,
1698                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
1699                              infoA->lpszIssuerInfo, len);
1700             }
1701
1702             /*
1703              * Contrary to MSDN, these do not appear to be set.
1704              * lpszProtocolName
1705              * lpszSignatureAlgName
1706              * lpszEncryptionAlgName
1707              * dwKeySize
1708              */
1709             CertFreeCertificateContext(context);
1710             return ERROR_SUCCESS;
1711         }
1712     }
1713     }
1714
1715     return INET_QueryOption(option, buffer, size, unicode);
1716 }
1717
1718 static DWORD HTTPREQ_SetOption(WININETHANDLEHEADER *hdr, DWORD option, void *buffer, DWORD size)
1719 {
1720     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
1721
1722     switch(option) {
1723     case INTERNET_OPTION_SEND_TIMEOUT:
1724     case INTERNET_OPTION_RECEIVE_TIMEOUT:
1725         TRACE("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT\n");
1726
1727         if (size != sizeof(DWORD))
1728             return ERROR_INVALID_PARAMETER;
1729
1730         return NETCON_set_timeout(&req->netConnection, option == INTERNET_OPTION_SEND_TIMEOUT,
1731                     *(DWORD*)buffer);
1732
1733     case INTERNET_OPTION_USERNAME:
1734         HeapFree(GetProcessHeap(), 0, req->lpHttpSession->lpszUserName);
1735         if (!(req->lpHttpSession->lpszUserName = WININET_strdupW(buffer))) return ERROR_OUTOFMEMORY;
1736         return ERROR_SUCCESS;
1737
1738     case INTERNET_OPTION_PASSWORD:
1739         HeapFree(GetProcessHeap(), 0, req->lpHttpSession->lpszPassword);
1740         if (!(req->lpHttpSession->lpszPassword = WININET_strdupW(buffer))) return ERROR_OUTOFMEMORY;
1741         return ERROR_SUCCESS;
1742     case INTERNET_OPTION_HTTP_DECODING:
1743         if(size != sizeof(BOOL))
1744             return ERROR_INVALID_PARAMETER;
1745         req->decoding = *(BOOL*)buffer;
1746         return ERROR_SUCCESS;
1747     }
1748
1749     return ERROR_INTERNET_INVALID_OPTION;
1750 }
1751
1752 /* read some more data into the read buffer (the read section must be held) */
1753 static BOOL read_more_data( WININETHTTPREQW *req, int maxlen )
1754 {
1755     int len;
1756
1757     if (req->read_pos)
1758     {
1759         /* move existing data to the start of the buffer */
1760         if(req->read_size)
1761             memmove( req->read_buf, req->read_buf + req->read_pos, req->read_size );
1762         req->read_pos = 0;
1763     }
1764
1765     if (maxlen == -1) maxlen = sizeof(req->read_buf);
1766
1767     if(!NETCON_recv( &req->netConnection, req->read_buf + req->read_size,
1768                      maxlen - req->read_size, 0, &len ))
1769         return FALSE;
1770
1771     req->read_size += len;
1772     return TRUE;
1773 }
1774
1775 /* remove some amount of data from the read buffer (the read section must be held) */
1776 static void remove_data( WININETHTTPREQW *req, int count )
1777 {
1778     if (!(req->read_size -= count)) req->read_pos = 0;
1779     else req->read_pos += count;
1780 }
1781
1782 static BOOL read_line( WININETHTTPREQW *req, LPSTR buffer, DWORD *len )
1783 {
1784     int count, bytes_read, pos = 0;
1785
1786     EnterCriticalSection( &req->read_section );
1787     for (;;)
1788     {
1789         BYTE *eol = memchr( req->read_buf + req->read_pos, '\n', req->read_size );
1790
1791         if (eol)
1792         {
1793             count = eol - (req->read_buf + req->read_pos);
1794             bytes_read = count + 1;
1795         }
1796         else count = bytes_read = req->read_size;
1797
1798         count = min( count, *len - pos );
1799         memcpy( buffer + pos, req->read_buf + req->read_pos, count );
1800         pos += count;
1801         remove_data( req, bytes_read );
1802         if (eol) break;
1803
1804         if (!read_more_data( req, -1 ) || !req->read_size)
1805         {
1806             *len = 0;
1807             TRACE( "returning empty string\n" );
1808             LeaveCriticalSection( &req->read_section );
1809             return FALSE;
1810         }
1811     }
1812     LeaveCriticalSection( &req->read_section );
1813
1814     if (pos < *len)
1815     {
1816         if (pos && buffer[pos - 1] == '\r') pos--;
1817         *len = pos + 1;
1818     }
1819     buffer[*len - 1] = 0;
1820     TRACE( "returning %s\n", debugstr_a(buffer));
1821     return TRUE;
1822 }
1823
1824 /* discard data contents until we reach end of line (the read section must be held) */
1825 static BOOL discard_eol( WININETHTTPREQW *req )
1826 {
1827     do
1828     {
1829         BYTE *eol = memchr( req->read_buf + req->read_pos, '\n', req->read_size );
1830         if (eol)
1831         {
1832             remove_data( req, (eol + 1) - (req->read_buf + req->read_pos) );
1833             break;
1834         }
1835         req->read_pos = req->read_size = 0;  /* discard everything */
1836         if (!read_more_data( req, -1 )) return FALSE;
1837     } while (req->read_size);
1838     return TRUE;
1839 }
1840
1841 /* read the size of the next chunk (the read section must be held) */
1842 static BOOL start_next_chunk( WININETHTTPREQW *req )
1843 {
1844     DWORD chunk_size = 0;
1845
1846     if (!req->dwContentLength) return TRUE;
1847     if (req->dwContentLength == req->dwContentRead)
1848     {
1849         /* read terminator for the previous chunk */
1850         if (!discard_eol( req )) return FALSE;
1851         req->dwContentLength = ~0u;
1852         req->dwContentRead = 0;
1853     }
1854     for (;;)
1855     {
1856         while (req->read_size)
1857         {
1858             char ch = req->read_buf[req->read_pos];
1859             if (ch >= '0' && ch <= '9') chunk_size = chunk_size * 16 + ch - '0';
1860             else if (ch >= 'a' && ch <= 'f') chunk_size = chunk_size * 16 + ch - 'a' + 10;
1861             else if (ch >= 'A' && ch <= 'F') chunk_size = chunk_size * 16 + ch - 'A' + 10;
1862             else if (ch == ';' || ch == '\r' || ch == '\n')
1863             {
1864                 TRACE( "reading %u byte chunk\n", chunk_size );
1865                 req->dwContentLength = chunk_size;
1866                 req->dwContentRead = 0;
1867                 if (!discard_eol( req )) return FALSE;
1868                 return TRUE;
1869             }
1870             remove_data( req, 1 );
1871         }
1872         if (!read_more_data( req, -1 )) return FALSE;
1873         if (!req->read_size)
1874         {
1875             req->dwContentLength = req->dwContentRead = 0;
1876             return TRUE;
1877         }
1878     }
1879 }
1880
1881 /* check if we have reached the end of the data to read (the read section must be held) */
1882 static BOOL end_of_read_data( WININETHTTPREQW *req )
1883 {
1884     if (req->gzip_stream) return req->gzip_stream->end_of_data && !req->gzip_stream->buf_size;
1885     if (req->read_chunked) return (req->dwContentLength == 0);
1886     if (req->dwContentLength == ~0u) return FALSE;
1887     return (req->dwContentLength == req->dwContentRead);
1888 }
1889
1890 /* fetch some more data into the read buffer (the read section must be held) */
1891 static BOOL refill_buffer( WININETHTTPREQW *req )
1892 {
1893     int len = sizeof(req->read_buf);
1894
1895     if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead))
1896     {
1897         if (!start_next_chunk( req )) return FALSE;
1898     }
1899
1900     if (req->dwContentLength != ~0u) len = min( len, req->dwContentLength - req->dwContentRead );
1901     if (len <= req->read_size) return TRUE;
1902
1903     if (!read_more_data( req, len )) return FALSE;
1904     if (!req->read_size) req->dwContentLength = req->dwContentRead = 0;
1905     return TRUE;
1906 }
1907
1908 static DWORD read_gzip_data(WININETHTTPREQW *req, BYTE *buf, int size, BOOL sync, int *read_ret)
1909 {
1910     DWORD ret = ERROR_SUCCESS;
1911     int read = 0;
1912
1913 #ifdef HAVE_ZLIB
1914     z_stream *zstream = &req->gzip_stream->zstream;
1915     int zres;
1916
1917     while(read < size && !req->gzip_stream->end_of_data) {
1918         if(!req->read_size) {
1919             if(!sync || !refill_buffer(req))
1920                 break;
1921         }
1922
1923         zstream->next_in = req->read_buf+req->read_pos;
1924         zstream->avail_in = req->read_size;
1925         zstream->next_out = buf+read;
1926         zstream->avail_out = size-read;
1927         zres = inflate(zstream, Z_FULL_FLUSH);
1928         read = size - zstream->avail_out;
1929         remove_data(req, req->read_size-zstream->avail_in);
1930         if(zres == Z_STREAM_END) {
1931             TRACE("end of data\n");
1932             req->gzip_stream->end_of_data = TRUE;
1933         }else if(zres != Z_OK) {
1934             WARN("inflate failed %d\n", zres);
1935             if(!read)
1936                 ret = ERROR_INTERNET_DECODING_FAILED;
1937             break;
1938         }
1939     }
1940 #endif
1941
1942     *read_ret = read;
1943     return ret;
1944 }
1945
1946 static void refill_gzip_buffer(WININETHTTPREQW *req)
1947 {
1948     DWORD res;
1949     int len;
1950
1951     if(!req->gzip_stream || !req->read_size || req->gzip_stream->buf_size == sizeof(req->gzip_stream->buf))
1952         return;
1953
1954     if(req->gzip_stream->buf_pos) {
1955         if(req->gzip_stream->buf_size)
1956             memmove(req->gzip_stream->buf, req->gzip_stream->buf + req->gzip_stream->buf_pos, req->gzip_stream->buf_size);
1957         req->gzip_stream->buf_pos = 0;
1958     }
1959
1960     res = read_gzip_data(req, req->gzip_stream->buf + req->gzip_stream->buf_size,
1961             sizeof(req->gzip_stream->buf) - req->gzip_stream->buf_size, FALSE, &len);
1962     if(res == ERROR_SUCCESS)
1963         req->gzip_stream->buf_size += len;
1964 }
1965
1966 /* return the size of data available to be read immediately (the read section must be held) */
1967 static DWORD get_avail_data( WININETHTTPREQW *req )
1968 {
1969     if (req->gzip_stream) {
1970         refill_gzip_buffer(req);
1971         return req->gzip_stream->buf_size;
1972     }
1973     if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead))
1974         return 0;
1975     return min( req->read_size, req->dwContentLength - req->dwContentRead );
1976 }
1977
1978 static void HTTP_ReceiveRequestData(WININETHTTPREQW *req, BOOL first_notif)
1979 {
1980     INTERNET_ASYNC_RESULT iar;
1981
1982     TRACE("%p\n", req);
1983
1984     EnterCriticalSection( &req->read_section );
1985     if (refill_buffer( req )) {
1986         iar.dwResult = (DWORD_PTR)req->hdr.hInternet;
1987         iar.dwError = first_notif ? 0 : get_avail_data(req);
1988     }else {
1989         iar.dwResult = 0;
1990         iar.dwError = INTERNET_GetLastError();
1991     }
1992     LeaveCriticalSection( &req->read_section );
1993
1994     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1995                           sizeof(INTERNET_ASYNC_RESULT));
1996 }
1997
1998 /* read data from the http connection (the read section must be held) */
1999 static DWORD HTTPREQ_Read(WININETHTTPREQW *req, void *buffer, DWORD size, DWORD *read, BOOL sync)
2000 {
2001     BOOL finished_reading = FALSE;
2002     int len, bytes_read = 0;
2003     DWORD ret = ERROR_SUCCESS;
2004
2005     EnterCriticalSection( &req->read_section );
2006
2007     if (req->read_chunked && (req->dwContentLength == ~0u || req->dwContentLength == req->dwContentRead))
2008     {
2009         if (!start_next_chunk( req )) goto done;
2010     }
2011
2012     if(req->gzip_stream) {
2013         if(req->gzip_stream->buf_size) {
2014             bytes_read = min(req->gzip_stream->buf_size, size);
2015             memcpy(buffer, req->gzip_stream->buf + req->gzip_stream->buf_pos, bytes_read);
2016             req->gzip_stream->buf_pos += bytes_read;
2017             req->gzip_stream->buf_size -= bytes_read;
2018         }else if(!req->read_size && !req->gzip_stream->end_of_data) {
2019             refill_buffer(req);
2020         }
2021
2022         if(size > bytes_read) {
2023             ret = read_gzip_data(req, (BYTE*)buffer+bytes_read, size-bytes_read, sync, &len);
2024             if(ret == ERROR_SUCCESS)
2025                 bytes_read += len;
2026         }
2027
2028         finished_reading = req->gzip_stream->end_of_data && !req->gzip_stream->buf_size;
2029     }else {
2030         if (req->dwContentLength != ~0u) size = min( size, req->dwContentLength - req->dwContentRead );
2031
2032         if (req->read_size) {
2033             bytes_read = min( req->read_size, size );
2034             memcpy( buffer, req->read_buf + req->read_pos, bytes_read );
2035             remove_data( req, bytes_read );
2036         }
2037
2038         if (size > bytes_read && (!bytes_read || sync)) {
2039             if (NETCON_recv( &req->netConnection, (char *)buffer + bytes_read, size - bytes_read,
2040                              sync ? MSG_WAITALL : 0, &len))
2041                 bytes_read += len;
2042             /* always return success, even if the network layer returns an error */
2043         }
2044
2045         finished_reading = !bytes_read && req->dwContentRead == req->dwContentLength;
2046     }
2047 done:
2048     req->dwContentRead += bytes_read;
2049     *read = bytes_read;
2050
2051     TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, req->dwContentRead, req->dwContentLength );
2052     LeaveCriticalSection( &req->read_section );
2053
2054     if(ret == ERROR_SUCCESS && req->lpszCacheFile) {
2055         BOOL res;
2056         DWORD dwBytesWritten;
2057
2058         res = WriteFile(req->hCacheFile, buffer, bytes_read, &dwBytesWritten, NULL);
2059         if(!res)
2060             WARN("WriteFile failed: %u\n", GetLastError());
2061     }
2062
2063     if(finished_reading)
2064         HTTP_FinishedReading(req);
2065
2066     return ret;
2067 }
2068
2069
2070 static DWORD HTTPREQ_ReadFile(WININETHANDLEHEADER *hdr, void *buffer, DWORD size, DWORD *read)
2071 {
2072     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
2073     return HTTPREQ_Read(req, buffer, size, read, TRUE);
2074 }
2075
2076 static void HTTPREQ_AsyncReadFileExAProc(WORKREQUEST *workRequest)
2077 {
2078     struct WORKREQ_INTERNETREADFILEEXA const *data = &workRequest->u.InternetReadFileExA;
2079     WININETHTTPREQW *req = (WININETHTTPREQW*)workRequest->hdr;
2080     INTERNET_ASYNC_RESULT iar;
2081     DWORD res;
2082
2083     TRACE("INTERNETREADFILEEXA %p\n", workRequest->hdr);
2084
2085     res = HTTPREQ_Read(req, data->lpBuffersOut->lpvBuffer,
2086             data->lpBuffersOut->dwBufferLength, &data->lpBuffersOut->dwBufferLength, TRUE);
2087
2088     iar.dwResult = res == ERROR_SUCCESS;
2089     iar.dwError = res;
2090
2091     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
2092                           INTERNET_STATUS_REQUEST_COMPLETE, &iar,
2093                           sizeof(INTERNET_ASYNC_RESULT));
2094 }
2095
2096 static DWORD HTTPREQ_ReadFileExA(WININETHANDLEHEADER *hdr, INTERNET_BUFFERSA *buffers,
2097         DWORD flags, DWORD_PTR context)
2098 {
2099
2100     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
2101     DWORD res;
2102
2103     if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
2104         FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
2105
2106     if (buffers->dwStructSize != sizeof(*buffers))
2107         return ERROR_INVALID_PARAMETER;
2108
2109     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2110
2111     if ((hdr->dwFlags & INTERNET_FLAG_ASYNC) && !get_avail_data(req))
2112     {
2113         WORKREQUEST workRequest;
2114
2115         if (TryEnterCriticalSection( &req->read_section ))
2116         {
2117             if (get_avail_data(req))
2118             {
2119                 res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength,
2120                                    &buffers->dwBufferLength, FALSE);
2121                 LeaveCriticalSection( &req->read_section );
2122                 goto done;
2123             }
2124             LeaveCriticalSection( &req->read_section );
2125         }
2126
2127         workRequest.asyncproc = HTTPREQ_AsyncReadFileExAProc;
2128         workRequest.hdr = WININET_AddRef(&req->hdr);
2129         workRequest.u.InternetReadFileExA.lpBuffersOut = buffers;
2130
2131         INTERNET_AsyncCall(&workRequest);
2132
2133         return ERROR_IO_PENDING;
2134     }
2135
2136     res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength, &buffers->dwBufferLength,
2137             !(flags & IRF_NO_WAIT));
2138
2139 done:
2140     if (res == ERROR_SUCCESS) {
2141         DWORD size = buffers->dwBufferLength;
2142         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2143                 &size, sizeof(size));
2144     }
2145
2146     return res;
2147 }
2148
2149 static void HTTPREQ_AsyncReadFileExWProc(WORKREQUEST *workRequest)
2150 {
2151     struct WORKREQ_INTERNETREADFILEEXW const *data = &workRequest->u.InternetReadFileExW;
2152     WININETHTTPREQW *req = (WININETHTTPREQW*)workRequest->hdr;
2153     INTERNET_ASYNC_RESULT iar;
2154     DWORD res;
2155
2156     TRACE("INTERNETREADFILEEXW %p\n", workRequest->hdr);
2157
2158     res = HTTPREQ_Read(req, data->lpBuffersOut->lpvBuffer,
2159             data->lpBuffersOut->dwBufferLength, &data->lpBuffersOut->dwBufferLength, TRUE);
2160
2161     iar.dwResult = res == ERROR_SUCCESS;
2162     iar.dwError = res;
2163
2164     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext,
2165                           INTERNET_STATUS_REQUEST_COMPLETE, &iar,
2166                           sizeof(INTERNET_ASYNC_RESULT));
2167 }
2168
2169 static DWORD HTTPREQ_ReadFileExW(WININETHANDLEHEADER *hdr, INTERNET_BUFFERSW *buffers,
2170         DWORD flags, DWORD_PTR context)
2171 {
2172
2173     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
2174     DWORD res;
2175
2176     if (flags & ~(IRF_ASYNC|IRF_NO_WAIT))
2177         FIXME("these dwFlags aren't implemented: 0x%x\n", flags & ~(IRF_ASYNC|IRF_NO_WAIT));
2178
2179     if (buffers->dwStructSize != sizeof(*buffers))
2180         return ERROR_INVALID_PARAMETER;
2181
2182     INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2183
2184     if (hdr->dwFlags & INTERNET_FLAG_ASYNC)
2185     {
2186         WORKREQUEST workRequest;
2187
2188         if (TryEnterCriticalSection( &req->read_section ))
2189         {
2190             if (get_avail_data(req))
2191             {
2192                 res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength,
2193                                    &buffers->dwBufferLength, FALSE);
2194                 LeaveCriticalSection( &req->read_section );
2195                 goto done;
2196             }
2197             LeaveCriticalSection( &req->read_section );
2198         }
2199
2200         workRequest.asyncproc = HTTPREQ_AsyncReadFileExWProc;
2201         workRequest.hdr = WININET_AddRef(&req->hdr);
2202         workRequest.u.InternetReadFileExW.lpBuffersOut = buffers;
2203
2204         INTERNET_AsyncCall(&workRequest);
2205
2206         return ERROR_IO_PENDING;
2207     }
2208
2209     res = HTTPREQ_Read(req, buffers->lpvBuffer, buffers->dwBufferLength, &buffers->dwBufferLength,
2210             !(flags & IRF_NO_WAIT));
2211
2212 done:
2213     if (res == ERROR_SUCCESS) {
2214         DWORD size = buffers->dwBufferLength;
2215         INTERNET_SendCallback(&req->hdr, req->hdr.dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2216                 &size, sizeof(size));
2217     }
2218
2219     return res;
2220 }
2221
2222 static BOOL HTTPREQ_WriteFile(WININETHANDLEHEADER *hdr, const void *buffer, DWORD size, DWORD *written)
2223 {
2224     BOOL ret;
2225     LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW)hdr;
2226
2227     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
2228
2229     *written = 0;
2230     if ((ret = NETCON_send(&lpwhr->netConnection, buffer, size, 0, (LPINT)written)))
2231         lpwhr->dwBytesWritten += *written;
2232
2233     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext, INTERNET_STATUS_REQUEST_SENT, written, sizeof(DWORD));
2234     return ret;
2235 }
2236
2237 static void HTTPREQ_AsyncQueryDataAvailableProc(WORKREQUEST *workRequest)
2238 {
2239     WININETHTTPREQW *req = (WININETHTTPREQW*)workRequest->hdr;
2240
2241     HTTP_ReceiveRequestData(req, FALSE);
2242 }
2243
2244 static DWORD HTTPREQ_QueryDataAvailable(WININETHANDLEHEADER *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
2245 {
2246     WININETHTTPREQW *req = (WININETHTTPREQW*)hdr;
2247
2248     TRACE("(%p %p %x %lx)\n", req, available, flags, ctx);
2249
2250     if (req->lpHttpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2251     {
2252         WORKREQUEST workRequest;
2253
2254         /* never wait, if we can't enter the section we queue an async request right away */
2255         if (TryEnterCriticalSection( &req->read_section ))
2256         {
2257             if ((*available = get_avail_data( req ))) goto done;
2258             if (end_of_read_data( req )) goto done;
2259             LeaveCriticalSection( &req->read_section );
2260         }
2261
2262         workRequest.asyncproc = HTTPREQ_AsyncQueryDataAvailableProc;
2263         workRequest.hdr = WININET_AddRef( &req->hdr );
2264
2265         INTERNET_AsyncCall(&workRequest);
2266
2267         return ERROR_IO_PENDING;
2268     }
2269
2270     EnterCriticalSection( &req->read_section );
2271
2272     if (!(*available = get_avail_data( req )) && !end_of_read_data( req ))
2273     {
2274         refill_buffer( req );
2275         *available = get_avail_data( req );
2276     }
2277
2278 done:
2279     if (*available == sizeof(req->read_buf) && !req->gzip_stream)  /* check if we have even more pending in the socket */
2280     {
2281         DWORD extra;
2282         if (NETCON_query_data_available(&req->netConnection, &extra))
2283             *available = min( *available + extra, req->dwContentLength - req->dwContentRead );
2284     }
2285     LeaveCriticalSection( &req->read_section );
2286
2287     TRACE( "returning %u\n", *available );
2288     return ERROR_SUCCESS;
2289 }
2290
2291 static const HANDLEHEADERVtbl HTTPREQVtbl = {
2292     HTTPREQ_Destroy,
2293     HTTPREQ_CloseConnection,
2294     HTTPREQ_QueryOption,
2295     HTTPREQ_SetOption,
2296     HTTPREQ_ReadFile,
2297     HTTPREQ_ReadFileExA,
2298     HTTPREQ_ReadFileExW,
2299     HTTPREQ_WriteFile,
2300     HTTPREQ_QueryDataAvailable,
2301     NULL
2302 };
2303
2304 /***********************************************************************
2305  *           HTTP_HttpOpenRequestW (internal)
2306  *
2307  * Open a HTTP request handle
2308  *
2309  * RETURNS
2310  *    HINTERNET  a HTTP request handle on success
2311  *    NULL       on failure
2312  *
2313  */
2314 HINTERNET WINAPI HTTP_HttpOpenRequestW(LPWININETHTTPSESSIONW lpwhs,
2315         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
2316         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
2317         DWORD dwFlags, DWORD_PTR dwContext)
2318 {
2319     LPWININETAPPINFOW hIC = NULL;
2320     LPWININETHTTPREQW lpwhr;
2321     LPWSTR lpszHostName = NULL;
2322     HINTERNET handle = NULL;
2323     static const WCHAR szHostForm[] = {'%','s',':','%','u',0};
2324     DWORD len;
2325
2326     TRACE("-->\n");
2327
2328     assert( lpwhs->hdr.htype == WH_HHTTPSESSION );
2329     hIC = lpwhs->lpAppInfo;
2330
2331     lpwhr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPREQW));
2332     if (NULL == lpwhr)
2333     {
2334         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2335         goto lend;
2336     }
2337     lpwhr->hdr.htype = WH_HHTTPREQ;
2338     lpwhr->hdr.vtbl = &HTTPREQVtbl;
2339     lpwhr->hdr.dwFlags = dwFlags;
2340     lpwhr->hdr.dwContext = dwContext;
2341     lpwhr->hdr.refs = 1;
2342     lpwhr->hdr.lpfnStatusCB = lpwhs->hdr.lpfnStatusCB;
2343     lpwhr->hdr.dwInternalFlags = lpwhs->hdr.dwInternalFlags & INET_CALLBACKW;
2344     lpwhr->dwContentLength = ~0u;
2345     InitializeCriticalSection( &lpwhr->read_section );
2346
2347     WININET_AddRef( &lpwhs->hdr );
2348     lpwhr->lpHttpSession = lpwhs;
2349     list_add_head( &lpwhs->hdr.children, &lpwhr->hdr.entry );
2350
2351     lpszHostName = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) *
2352             (strlenW(lpwhs->lpszHostName) + 7 /* length of ":65535" + 1 */));
2353     if (NULL == lpszHostName)
2354     {
2355         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2356         goto lend;
2357     }
2358
2359     handle = WININET_AllocHandle( &lpwhr->hdr );
2360     if (NULL == handle)
2361     {
2362         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2363         goto lend;
2364     }
2365
2366     if (!NETCON_init(&lpwhr->netConnection, dwFlags & INTERNET_FLAG_SECURE))
2367     {
2368         InternetCloseHandle( handle );
2369         handle = NULL;
2370         goto lend;
2371     }
2372
2373     if (lpszObjectName && *lpszObjectName) {
2374         HRESULT rc;
2375
2376         len = 0;
2377         rc = UrlEscapeW(lpszObjectName, NULL, &len, URL_ESCAPE_SPACES_ONLY);
2378         if (rc != E_POINTER)
2379             len = strlenW(lpszObjectName)+1;
2380         lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
2381         rc = UrlEscapeW(lpszObjectName, lpwhr->lpszPath, &len,
2382                    URL_ESCAPE_SPACES_ONLY);
2383         if (rc != S_OK)
2384         {
2385             ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(lpszObjectName),rc);
2386             strcpyW(lpwhr->lpszPath,lpszObjectName);
2387         }
2388     }else {
2389         static const WCHAR slashW[] = {'/',0};
2390
2391         lpwhr->lpszPath = WININET_strdupW(slashW);
2392     }
2393
2394     if (lpszReferrer && *lpszReferrer)
2395         HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpszReferrer, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
2396
2397     if (lpszAcceptTypes)
2398     {
2399         int i;
2400         for (i = 0; lpszAcceptTypes[i]; i++)
2401         {
2402             if (!*lpszAcceptTypes[i]) continue;
2403             HTTP_ProcessHeader(lpwhr, HTTP_ACCEPT, lpszAcceptTypes[i],
2404                                HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA |
2405                                HTTP_ADDHDR_FLAG_REQ |
2406                                (i == 0 ? HTTP_ADDHDR_FLAG_REPLACE : 0));
2407         }
2408     }
2409
2410     lpwhr->lpszVerb = WININET_strdupW(lpszVerb && *lpszVerb ? lpszVerb : szGET);
2411
2412     if (lpszVersion)
2413         lpwhr->lpszVersion = WININET_strdupW(lpszVersion);
2414     else
2415         lpwhr->lpszVersion = WININET_strdupW(g_szHttp1_1);
2416
2417     if (lpwhs->nHostPort != INTERNET_INVALID_PORT_NUMBER &&
2418         lpwhs->nHostPort != INTERNET_DEFAULT_HTTP_PORT &&
2419         lpwhs->nHostPort != INTERNET_DEFAULT_HTTPS_PORT)
2420     {
2421         sprintfW(lpszHostName, szHostForm, lpwhs->lpszHostName, lpwhs->nHostPort);
2422         HTTP_ProcessHeader(lpwhr, hostW, lpszHostName,
2423                 HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
2424     }
2425     else
2426         HTTP_ProcessHeader(lpwhr, hostW, lpwhs->lpszHostName,
2427                 HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REQ);
2428
2429     if (lpwhs->nServerPort == INTERNET_INVALID_PORT_NUMBER)
2430         lpwhs->nServerPort = (dwFlags & INTERNET_FLAG_SECURE ?
2431                         INTERNET_DEFAULT_HTTPS_PORT :
2432                         INTERNET_DEFAULT_HTTP_PORT);
2433
2434     if (lpwhs->nHostPort == INTERNET_INVALID_PORT_NUMBER)
2435         lpwhs->nHostPort = (dwFlags & INTERNET_FLAG_SECURE ?
2436                         INTERNET_DEFAULT_HTTPS_PORT :
2437                         INTERNET_DEFAULT_HTTP_PORT);
2438
2439     if (NULL != hIC->lpszProxy && hIC->lpszProxy[0] != 0)
2440         HTTP_DealWithProxy( hIC, lpwhs, lpwhr );
2441
2442     INTERNET_SendCallback(&lpwhs->hdr, dwContext,
2443                           INTERNET_STATUS_HANDLE_CREATED, &handle,
2444                           sizeof(handle));
2445
2446 lend:
2447     HeapFree(GetProcessHeap(), 0, lpszHostName);
2448     if( lpwhr )
2449         WININET_Release( &lpwhr->hdr );
2450
2451     TRACE("<-- %p (%p)\n", handle, lpwhr);
2452     return handle;
2453 }
2454
2455 /* read any content returned by the server so that the connection can be
2456  * reused */
2457 static void HTTP_DrainContent(WININETHTTPREQW *req)
2458 {
2459     DWORD bytes_read;
2460
2461     if (!NETCON_connected(&req->netConnection)) return;
2462
2463     if (req->dwContentLength == -1)
2464     {
2465         NETCON_close(&req->netConnection);
2466         return;
2467     }
2468
2469     do
2470     {
2471         char buffer[2048];
2472         if (HTTPREQ_Read(req, buffer, sizeof(buffer), &bytes_read, TRUE) != ERROR_SUCCESS)
2473             return;
2474     } while (bytes_read);
2475 }
2476
2477 static const LPCWSTR header_lookup[] = {
2478     szMime_Version,             /* HTTP_QUERY_MIME_VERSION = 0 */
2479     szContent_Type,             /* HTTP_QUERY_CONTENT_TYPE = 1 */
2480     szContent_Transfer_Encoding,/* HTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2 */
2481     szContent_ID,               /* HTTP_QUERY_CONTENT_ID = 3 */
2482     NULL,                       /* HTTP_QUERY_CONTENT_DESCRIPTION = 4 */
2483     szContent_Length,           /* HTTP_QUERY_CONTENT_LENGTH =  5 */
2484     szContent_Language,         /* HTTP_QUERY_CONTENT_LANGUAGE =  6 */
2485     szAllow,                    /* HTTP_QUERY_ALLOW = 7 */
2486     szPublic,                   /* HTTP_QUERY_PUBLIC = 8 */
2487     szDate,                     /* HTTP_QUERY_DATE = 9 */
2488     szExpires,                  /* HTTP_QUERY_EXPIRES = 10 */
2489     szLast_Modified,            /* HTTP_QUERY_LAST_MODIFIED = 11 */
2490     NULL,                       /* HTTP_QUERY_MESSAGE_ID = 12 */
2491     szURI,                      /* HTTP_QUERY_URI = 13 */
2492     szFrom,                     /* HTTP_QUERY_DERIVED_FROM = 14 */
2493     NULL,                       /* HTTP_QUERY_COST = 15 */
2494     NULL,                       /* HTTP_QUERY_LINK = 16 */
2495     szPragma,                   /* HTTP_QUERY_PRAGMA = 17 */
2496     NULL,                       /* HTTP_QUERY_VERSION = 18 */
2497     szStatus,                   /* HTTP_QUERY_STATUS_CODE = 19 */
2498     NULL,                       /* HTTP_QUERY_STATUS_TEXT = 20 */
2499     NULL,                       /* HTTP_QUERY_RAW_HEADERS = 21 */
2500     NULL,                       /* HTTP_QUERY_RAW_HEADERS_CRLF = 22 */
2501     szConnection,               /* HTTP_QUERY_CONNECTION = 23 */
2502     szAccept,                   /* HTTP_QUERY_ACCEPT = 24 */
2503     szAccept_Charset,           /* HTTP_QUERY_ACCEPT_CHARSET = 25 */
2504     szAccept_Encoding,          /* HTTP_QUERY_ACCEPT_ENCODING = 26 */
2505     szAccept_Language,          /* HTTP_QUERY_ACCEPT_LANGUAGE = 27 */
2506     szAuthorization,            /* HTTP_QUERY_AUTHORIZATION = 28 */
2507     szContent_Encoding,         /* HTTP_QUERY_CONTENT_ENCODING = 29 */
2508     NULL,                       /* HTTP_QUERY_FORWARDED = 30 */
2509     NULL,                       /* HTTP_QUERY_FROM = 31 */
2510     szIf_Modified_Since,        /* HTTP_QUERY_IF_MODIFIED_SINCE = 32 */
2511     szLocation,                 /* HTTP_QUERY_LOCATION = 33 */
2512     NULL,                       /* HTTP_QUERY_ORIG_URI = 34 */
2513     szReferer,                  /* HTTP_QUERY_REFERER = 35 */
2514     szRetry_After,              /* HTTP_QUERY_RETRY_AFTER = 36 */
2515     szServer,                   /* HTTP_QUERY_SERVER = 37 */
2516     NULL,                       /* HTTP_TITLE = 38 */
2517     szUser_Agent,               /* HTTP_QUERY_USER_AGENT = 39 */
2518     szWWW_Authenticate,         /* HTTP_QUERY_WWW_AUTHENTICATE = 40 */
2519     szProxy_Authenticate,       /* HTTP_QUERY_PROXY_AUTHENTICATE = 41 */
2520     szAccept_Ranges,            /* HTTP_QUERY_ACCEPT_RANGES = 42 */
2521     szSet_Cookie,               /* HTTP_QUERY_SET_COOKIE = 43 */
2522     szCookie,                   /* HTTP_QUERY_COOKIE = 44 */
2523     NULL,                       /* HTTP_QUERY_REQUEST_METHOD = 45 */
2524     NULL,                       /* HTTP_QUERY_REFRESH = 46 */
2525     NULL,                       /* HTTP_QUERY_CONTENT_DISPOSITION = 47 */
2526     szAge,                      /* HTTP_QUERY_AGE = 48 */
2527     szCache_Control,            /* HTTP_QUERY_CACHE_CONTROL = 49 */
2528     szContent_Base,             /* HTTP_QUERY_CONTENT_BASE = 50 */
2529     szContent_Location,         /* HTTP_QUERY_CONTENT_LOCATION = 51 */
2530     szContent_MD5,              /* HTTP_QUERY_CONTENT_MD5 = 52 */
2531     szContent_Range,            /* HTTP_QUERY_CONTENT_RANGE = 53 */
2532     szETag,                     /* HTTP_QUERY_ETAG = 54 */
2533     hostW,                      /* HTTP_QUERY_HOST = 55 */
2534     szIf_Match,                 /* HTTP_QUERY_IF_MATCH = 56 */
2535     szIf_None_Match,            /* HTTP_QUERY_IF_NONE_MATCH = 57 */
2536     szIf_Range,                 /* HTTP_QUERY_IF_RANGE = 58 */
2537     szIf_Unmodified_Since,      /* HTTP_QUERY_IF_UNMODIFIED_SINCE = 59 */
2538     szMax_Forwards,             /* HTTP_QUERY_MAX_FORWARDS = 60 */
2539     szProxy_Authorization,      /* HTTP_QUERY_PROXY_AUTHORIZATION = 61 */
2540     szRange,                    /* HTTP_QUERY_RANGE = 62 */
2541     szTransfer_Encoding,        /* HTTP_QUERY_TRANSFER_ENCODING = 63 */
2542     szUpgrade,                  /* HTTP_QUERY_UPGRADE = 64 */
2543     szVary,                     /* HTTP_QUERY_VARY = 65 */
2544     szVia,                      /* HTTP_QUERY_VIA = 66 */
2545     szWarning,                  /* HTTP_QUERY_WARNING = 67 */
2546     szExpect,                   /* HTTP_QUERY_EXPECT = 68 */
2547     szProxy_Connection,         /* HTTP_QUERY_PROXY_CONNECTION = 69 */
2548     szUnless_Modified_Since,    /* HTTP_QUERY_UNLESS_MODIFIED_SINCE = 70 */
2549 };
2550
2551 #define LAST_TABLE_HEADER (sizeof(header_lookup)/sizeof(header_lookup[0]))
2552
2553 /***********************************************************************
2554  *           HTTP_HttpQueryInfoW (internal)
2555  */
2556 static BOOL HTTP_HttpQueryInfoW( LPWININETHTTPREQW lpwhr, DWORD dwInfoLevel,
2557         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
2558 {
2559     LPHTTPHEADERW lphttpHdr = NULL;
2560     BOOL bSuccess = FALSE;
2561     BOOL request_only = dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS;
2562     INT requested_index = lpdwIndex ? *lpdwIndex : 0;
2563     DWORD level = (dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK);
2564     INT index = -1;
2565
2566     /* Find requested header structure */
2567     switch (level)
2568     {
2569     case HTTP_QUERY_CUSTOM:
2570         if (!lpBuffer) return FALSE;
2571         index = HTTP_GetCustomHeaderIndex(lpwhr, lpBuffer, requested_index, request_only);
2572         break;
2573
2574     case HTTP_QUERY_CONTENT_LENGTH:
2575         if(lpwhr->gzip_stream) {
2576             INTERNET_SetLastError(ERROR_HTTP_HEADER_NOT_FOUND);
2577             return FALSE;
2578         }
2579
2580         index = HTTP_GetCustomHeaderIndex(lpwhr, header_lookup[level],
2581                                           requested_index,request_only);
2582         break;
2583
2584     case HTTP_QUERY_RAW_HEADERS_CRLF:
2585         {
2586             LPWSTR headers;
2587             DWORD len = 0;
2588             BOOL ret = FALSE;
2589
2590             if (request_only)
2591                 headers = HTTP_BuildHeaderRequestString(lpwhr, lpwhr->lpszVerb, lpwhr->lpszPath, lpwhr->lpszVersion);
2592             else
2593                 headers = lpwhr->lpszRawHeaders;
2594
2595             if (headers)
2596                 len = strlenW(headers) * sizeof(WCHAR);
2597
2598             if (len + sizeof(WCHAR) > *lpdwBufferLength)
2599             {
2600                 len += sizeof(WCHAR);
2601                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2602                 ret = FALSE;
2603             }
2604             else if (lpBuffer)
2605             {
2606                 if (headers)
2607                     memcpy(lpBuffer, headers, len + sizeof(WCHAR));
2608                 else
2609                 {
2610                     len = strlenW(szCrLf) * sizeof(WCHAR);
2611                     memcpy(lpBuffer, szCrLf, sizeof(szCrLf));
2612                 }
2613                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len / sizeof(WCHAR)));
2614                 ret = TRUE;
2615             }
2616             *lpdwBufferLength = len;
2617
2618             if (request_only)
2619                 HeapFree(GetProcessHeap(), 0, headers);
2620             return ret;
2621         }
2622     case HTTP_QUERY_RAW_HEADERS:
2623         {
2624             LPWSTR * ppszRawHeaderLines = HTTP_Tokenize(lpwhr->lpszRawHeaders, szCrLf);
2625             DWORD i, size = 0;
2626             LPWSTR pszString = lpBuffer;
2627
2628             for (i = 0; ppszRawHeaderLines[i]; i++)
2629                 size += strlenW(ppszRawHeaderLines[i]) + 1;
2630
2631             if (size + 1 > *lpdwBufferLength/sizeof(WCHAR))
2632             {
2633                 HTTP_FreeTokens(ppszRawHeaderLines);
2634                 *lpdwBufferLength = (size + 1) * sizeof(WCHAR);
2635                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2636                 return FALSE;
2637             }
2638             if (pszString)
2639             {
2640                 for (i = 0; ppszRawHeaderLines[i]; i++)
2641                 {
2642                     DWORD len = strlenW(ppszRawHeaderLines[i]);
2643                     memcpy(pszString, ppszRawHeaderLines[i], (len+1)*sizeof(WCHAR));
2644                     pszString += len+1;
2645                 }
2646                 *pszString = '\0';
2647                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, size));
2648             }
2649             *lpdwBufferLength = size * sizeof(WCHAR);
2650             HTTP_FreeTokens(ppszRawHeaderLines);
2651
2652             return TRUE;
2653         }
2654     case HTTP_QUERY_STATUS_TEXT:
2655         if (lpwhr->lpszStatusText)
2656         {
2657             DWORD len = strlenW(lpwhr->lpszStatusText);
2658             if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
2659             {
2660                 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
2661                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2662                 return FALSE;
2663             }
2664             if (lpBuffer)
2665             {
2666                 memcpy(lpBuffer, lpwhr->lpszStatusText, (len + 1) * sizeof(WCHAR));
2667                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
2668             }
2669             *lpdwBufferLength = len * sizeof(WCHAR);
2670             return TRUE;
2671         }
2672         break;
2673     case HTTP_QUERY_VERSION:
2674         if (lpwhr->lpszVersion)
2675         {
2676             DWORD len = strlenW(lpwhr->lpszVersion);
2677             if (len + 1 > *lpdwBufferLength/sizeof(WCHAR))
2678             {
2679                 *lpdwBufferLength = (len + 1) * sizeof(WCHAR);
2680                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2681                 return FALSE;
2682             }
2683             if (lpBuffer)
2684             {
2685                 memcpy(lpBuffer, lpwhr->lpszVersion, (len + 1) * sizeof(WCHAR));
2686                 TRACE("returning data: %s\n", debugstr_wn(lpBuffer, len));
2687             }
2688             *lpdwBufferLength = len * sizeof(WCHAR);
2689             return TRUE;
2690         }
2691         break;
2692     case HTTP_QUERY_CONTENT_ENCODING:
2693         index = HTTP_GetCustomHeaderIndex(lpwhr, header_lookup[lpwhr->gzip_stream ? HTTP_QUERY_CONTENT_TYPE : level],
2694                 requested_index,request_only);
2695         break;
2696     default:
2697         assert (LAST_TABLE_HEADER == (HTTP_QUERY_UNLESS_MODIFIED_SINCE + 1));
2698
2699         if (level < LAST_TABLE_HEADER && header_lookup[level])
2700             index = HTTP_GetCustomHeaderIndex(lpwhr, header_lookup[level],
2701                                               requested_index,request_only);
2702     }
2703
2704     if (index >= 0)
2705         lphttpHdr = &lpwhr->pCustHeaders[index];
2706
2707     /* Ensure header satisfies requested attributes */
2708     if (!lphttpHdr ||
2709         ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
2710          (~lphttpHdr->wFlags & HDR_ISREQUEST)))
2711     {
2712         INTERNET_SetLastError(ERROR_HTTP_HEADER_NOT_FOUND);
2713         return bSuccess;
2714     }
2715
2716     if (lpdwIndex && level != HTTP_QUERY_STATUS_CODE) (*lpdwIndex)++;
2717
2718     /* coalesce value to requested type */
2719     if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER && lpBuffer)
2720     {
2721         *(int *)lpBuffer = atoiW(lphttpHdr->lpszValue);
2722         TRACE(" returning number: %d\n", *(int *)lpBuffer);
2723         bSuccess = TRUE;
2724     }
2725     else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME && lpBuffer)
2726     {
2727         time_t tmpTime;
2728         struct tm tmpTM;
2729         SYSTEMTIME *STHook;
2730
2731         tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
2732
2733         tmpTM = *gmtime(&tmpTime);
2734         STHook = (SYSTEMTIME *)lpBuffer;
2735         STHook->wDay = tmpTM.tm_mday;
2736         STHook->wHour = tmpTM.tm_hour;
2737         STHook->wMilliseconds = 0;
2738         STHook->wMinute = tmpTM.tm_min;
2739         STHook->wDayOfWeek = tmpTM.tm_wday;
2740         STHook->wMonth = tmpTM.tm_mon + 1;
2741         STHook->wSecond = tmpTM.tm_sec;
2742         STHook->wYear = tmpTM.tm_year;
2743         bSuccess = TRUE;
2744
2745         TRACE(" returning time: %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
2746               STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
2747               STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
2748     }
2749     else if (lphttpHdr->lpszValue)
2750     {
2751         DWORD len = (strlenW(lphttpHdr->lpszValue) + 1) * sizeof(WCHAR);
2752
2753         if (len > *lpdwBufferLength)
2754         {
2755             *lpdwBufferLength = len;
2756             INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2757             return bSuccess;
2758         }
2759         if (lpBuffer)
2760         {
2761             memcpy(lpBuffer, lphttpHdr->lpszValue, len);
2762             TRACE(" returning string: %s\n", debugstr_w(lpBuffer));
2763         }
2764         *lpdwBufferLength = len - sizeof(WCHAR);
2765         bSuccess = TRUE;
2766     }
2767     return bSuccess;
2768 }
2769
2770 /***********************************************************************
2771  *           HttpQueryInfoW (WININET.@)
2772  *
2773  * Queries for information about an HTTP request
2774  *
2775  * RETURNS
2776  *    TRUE  on success
2777  *    FALSE on failure
2778  *
2779  */
2780 BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel,
2781         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
2782 {
2783     BOOL bSuccess = FALSE;
2784     LPWININETHTTPREQW lpwhr;
2785
2786     if (TRACE_ON(wininet)) {
2787 #define FE(x) { x, #x }
2788         static const wininet_flag_info query_flags[] = {
2789             FE(HTTP_QUERY_MIME_VERSION),
2790             FE(HTTP_QUERY_CONTENT_TYPE),
2791             FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
2792             FE(HTTP_QUERY_CONTENT_ID),
2793             FE(HTTP_QUERY_CONTENT_DESCRIPTION),
2794             FE(HTTP_QUERY_CONTENT_LENGTH),
2795             FE(HTTP_QUERY_CONTENT_LANGUAGE),
2796             FE(HTTP_QUERY_ALLOW),
2797             FE(HTTP_QUERY_PUBLIC),
2798             FE(HTTP_QUERY_DATE),
2799             FE(HTTP_QUERY_EXPIRES),
2800             FE(HTTP_QUERY_LAST_MODIFIED),
2801             FE(HTTP_QUERY_MESSAGE_ID),
2802             FE(HTTP_QUERY_URI),
2803             FE(HTTP_QUERY_DERIVED_FROM),
2804             FE(HTTP_QUERY_COST),
2805             FE(HTTP_QUERY_LINK),
2806             FE(HTTP_QUERY_PRAGMA),
2807             FE(HTTP_QUERY_VERSION),
2808             FE(HTTP_QUERY_STATUS_CODE),
2809             FE(HTTP_QUERY_STATUS_TEXT),
2810             FE(HTTP_QUERY_RAW_HEADERS),
2811             FE(HTTP_QUERY_RAW_HEADERS_CRLF),
2812             FE(HTTP_QUERY_CONNECTION),
2813             FE(HTTP_QUERY_ACCEPT),
2814             FE(HTTP_QUERY_ACCEPT_CHARSET),
2815             FE(HTTP_QUERY_ACCEPT_ENCODING),
2816             FE(HTTP_QUERY_ACCEPT_LANGUAGE),
2817             FE(HTTP_QUERY_AUTHORIZATION),
2818             FE(HTTP_QUERY_CONTENT_ENCODING),
2819             FE(HTTP_QUERY_FORWARDED),
2820             FE(HTTP_QUERY_FROM),
2821             FE(HTTP_QUERY_IF_MODIFIED_SINCE),
2822             FE(HTTP_QUERY_LOCATION),
2823             FE(HTTP_QUERY_ORIG_URI),
2824             FE(HTTP_QUERY_REFERER),
2825             FE(HTTP_QUERY_RETRY_AFTER),
2826             FE(HTTP_QUERY_SERVER),
2827             FE(HTTP_QUERY_TITLE),
2828             FE(HTTP_QUERY_USER_AGENT),
2829             FE(HTTP_QUERY_WWW_AUTHENTICATE),
2830             FE(HTTP_QUERY_PROXY_AUTHENTICATE),
2831             FE(HTTP_QUERY_ACCEPT_RANGES),
2832         FE(HTTP_QUERY_SET_COOKIE),
2833         FE(HTTP_QUERY_COOKIE),
2834             FE(HTTP_QUERY_REQUEST_METHOD),
2835             FE(HTTP_QUERY_REFRESH),
2836             FE(HTTP_QUERY_CONTENT_DISPOSITION),
2837             FE(HTTP_QUERY_AGE),
2838             FE(HTTP_QUERY_CACHE_CONTROL),
2839             FE(HTTP_QUERY_CONTENT_BASE),
2840             FE(HTTP_QUERY_CONTENT_LOCATION),
2841             FE(HTTP_QUERY_CONTENT_MD5),
2842             FE(HTTP_QUERY_CONTENT_RANGE),
2843             FE(HTTP_QUERY_ETAG),
2844             FE(HTTP_QUERY_HOST),
2845             FE(HTTP_QUERY_IF_MATCH),
2846             FE(HTTP_QUERY_IF_NONE_MATCH),
2847             FE(HTTP_QUERY_IF_RANGE),
2848             FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
2849             FE(HTTP_QUERY_MAX_FORWARDS),
2850             FE(HTTP_QUERY_PROXY_AUTHORIZATION),
2851             FE(HTTP_QUERY_RANGE),
2852             FE(HTTP_QUERY_TRANSFER_ENCODING),
2853             FE(HTTP_QUERY_UPGRADE),
2854             FE(HTTP_QUERY_VARY),
2855             FE(HTTP_QUERY_VIA),
2856             FE(HTTP_QUERY_WARNING),
2857             FE(HTTP_QUERY_CUSTOM)
2858         };
2859         static const wininet_flag_info modifier_flags[] = {
2860             FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
2861             FE(HTTP_QUERY_FLAG_SYSTEMTIME),
2862             FE(HTTP_QUERY_FLAG_NUMBER),
2863             FE(HTTP_QUERY_FLAG_COALESCE)
2864         };
2865 #undef FE
2866         DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
2867         DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
2868         DWORD i;
2869
2870         TRACE("(%p, 0x%08x)--> %d\n", hHttpRequest, dwInfoLevel, dwInfoLevel);
2871         TRACE("  Attribute:");
2872         for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
2873             if (query_flags[i].val == info) {
2874                 TRACE(" %s", query_flags[i].name);
2875                 break;
2876             }
2877         }
2878         if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
2879             TRACE(" Unknown (%08x)", info);
2880         }
2881
2882         TRACE(" Modifier:");
2883         for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
2884             if (modifier_flags[i].val & info_mod) {
2885                 TRACE(" %s", modifier_flags[i].name);
2886                 info_mod &= ~ modifier_flags[i].val;
2887             }
2888         }
2889
2890         if (info_mod) {
2891             TRACE(" Unknown (%08x)", info_mod);
2892         }
2893         TRACE("\n");
2894     }
2895
2896     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
2897     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
2898     {
2899         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2900         goto lend;
2901     }
2902
2903     if (lpBuffer == NULL)
2904         *lpdwBufferLength = 0;
2905     bSuccess = HTTP_HttpQueryInfoW( lpwhr, dwInfoLevel,
2906                                     lpBuffer, lpdwBufferLength, lpdwIndex);
2907
2908 lend:
2909     if( lpwhr )
2910          WININET_Release( &lpwhr->hdr );
2911
2912     TRACE("%d <--\n", bSuccess);
2913     return bSuccess;
2914 }
2915
2916 /***********************************************************************
2917  *           HttpQueryInfoA (WININET.@)
2918  *
2919  * Queries for information about an HTTP request
2920  *
2921  * RETURNS
2922  *    TRUE  on success
2923  *    FALSE on failure
2924  *
2925  */
2926 BOOL WINAPI HttpQueryInfoA(HINTERNET hHttpRequest, DWORD dwInfoLevel,
2927         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
2928 {
2929     BOOL result;
2930     DWORD len;
2931     WCHAR* bufferW;
2932
2933     if((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
2934        (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME))
2935     {
2936         return HttpQueryInfoW( hHttpRequest, dwInfoLevel, lpBuffer,
2937                                lpdwBufferLength, lpdwIndex );
2938     }
2939
2940     if (lpBuffer)
2941     {
2942         DWORD alloclen;
2943         len = (*lpdwBufferLength)*sizeof(WCHAR);
2944         if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
2945         {
2946             alloclen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, NULL, 0 ) * sizeof(WCHAR);
2947             if (alloclen < len)
2948                 alloclen = len;
2949         }
2950         else
2951             alloclen = len;
2952         bufferW = HeapAlloc( GetProcessHeap(), 0, alloclen );
2953         /* buffer is in/out because of HTTP_QUERY_CUSTOM */
2954         if ((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
2955             MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, bufferW, alloclen / sizeof(WCHAR) );
2956     } else
2957     {
2958         bufferW = NULL;
2959         len = 0;
2960     }
2961
2962     result = HttpQueryInfoW( hHttpRequest, dwInfoLevel, bufferW,
2963                            &len, lpdwIndex );
2964     if( result )
2965     {
2966         len = WideCharToMultiByte( CP_ACP,0, bufferW, len / sizeof(WCHAR) + 1,
2967                                      lpBuffer, *lpdwBufferLength, NULL, NULL );
2968         *lpdwBufferLength = len - 1;
2969
2970         TRACE("lpBuffer: %s\n", debugstr_a(lpBuffer));
2971     }
2972     else
2973         /* since the strings being returned from HttpQueryInfoW should be
2974          * only ASCII characters, it is reasonable to assume that all of
2975          * the Unicode characters can be reduced to a single byte */
2976         *lpdwBufferLength = len / sizeof(WCHAR);
2977
2978     HeapFree(GetProcessHeap(), 0, bufferW );
2979
2980     return result;
2981 }
2982
2983 /***********************************************************************
2984  *           HttpSendRequestExA (WININET.@)
2985  *
2986  * Sends the specified request to the HTTP server and allows chunked
2987  * transfers.
2988  *
2989  * RETURNS
2990  *  Success: TRUE
2991  *  Failure: FALSE, call GetLastError() for more information.
2992  */
2993 BOOL WINAPI HttpSendRequestExA(HINTERNET hRequest,
2994                                LPINTERNET_BUFFERSA lpBuffersIn,
2995                                LPINTERNET_BUFFERSA lpBuffersOut,
2996                                DWORD dwFlags, DWORD_PTR dwContext)
2997 {
2998     INTERNET_BUFFERSW BuffersInW;
2999     BOOL rc = FALSE;
3000     DWORD headerlen;
3001     LPWSTR header = NULL;
3002
3003     TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
3004             lpBuffersOut, dwFlags, dwContext);
3005
3006     if (lpBuffersIn)
3007     {
3008         BuffersInW.dwStructSize = sizeof(LPINTERNET_BUFFERSW);
3009         if (lpBuffersIn->lpcszHeader)
3010         {
3011             headerlen = MultiByteToWideChar(CP_ACP,0,lpBuffersIn->lpcszHeader,
3012                     lpBuffersIn->dwHeadersLength,0,0);
3013             header = HeapAlloc(GetProcessHeap(),0,headerlen*sizeof(WCHAR));
3014             if (!(BuffersInW.lpcszHeader = header))
3015             {
3016                 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
3017                 return FALSE;
3018             }
3019             BuffersInW.dwHeadersLength = MultiByteToWideChar(CP_ACP, 0,
3020                     lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
3021                     header, headerlen);
3022         }
3023         else
3024             BuffersInW.lpcszHeader = NULL;
3025         BuffersInW.dwHeadersTotal = lpBuffersIn->dwHeadersTotal;
3026         BuffersInW.lpvBuffer = lpBuffersIn->lpvBuffer;
3027         BuffersInW.dwBufferLength = lpBuffersIn->dwBufferLength;
3028         BuffersInW.dwBufferTotal = lpBuffersIn->dwBufferTotal;
3029         BuffersInW.Next = NULL;
3030     }
3031
3032     rc = HttpSendRequestExW(hRequest, lpBuffersIn ? &BuffersInW : NULL, NULL, dwFlags, dwContext);
3033
3034     HeapFree(GetProcessHeap(),0,header);
3035
3036     return rc;
3037 }
3038
3039 /***********************************************************************
3040  *           HttpSendRequestExW (WININET.@)
3041  *
3042  * Sends the specified request to the HTTP server and allows chunked
3043  * transfers
3044  *
3045  * RETURNS
3046  *  Success: TRUE
3047  *  Failure: FALSE, call GetLastError() for more information.
3048  */
3049 BOOL WINAPI HttpSendRequestExW(HINTERNET hRequest,
3050                    LPINTERNET_BUFFERSW lpBuffersIn,
3051                    LPINTERNET_BUFFERSW lpBuffersOut,
3052                    DWORD dwFlags, DWORD_PTR dwContext)
3053 {
3054     BOOL ret = FALSE;
3055     LPWININETHTTPREQW lpwhr;
3056     LPWININETHTTPSESSIONW lpwhs;
3057     LPWININETAPPINFOW hIC;
3058
3059     TRACE("(%p, %p, %p, %08x, %08lx)\n", hRequest, lpBuffersIn,
3060             lpBuffersOut, dwFlags, dwContext);
3061
3062     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hRequest );
3063
3064     if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
3065     {
3066         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
3067         goto lend;
3068     }
3069
3070     lpwhs = lpwhr->lpHttpSession;
3071     assert(lpwhs->hdr.htype == WH_HHTTPSESSION);
3072     hIC = lpwhs->lpAppInfo;
3073     assert(hIC->hdr.htype == WH_HINIT);
3074
3075     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3076     {
3077         WORKREQUEST workRequest;
3078         struct WORKREQ_HTTPSENDREQUESTW *req;
3079
3080         workRequest.asyncproc = AsyncHttpSendRequestProc;
3081         workRequest.hdr = WININET_AddRef( &lpwhr->hdr );
3082         req = &workRequest.u.HttpSendRequestW;
3083         if (lpBuffersIn)
3084         {
3085             if (lpBuffersIn->lpcszHeader)
3086                 /* FIXME: this should use dwHeadersLength or may not be necessary at all */
3087                 req->lpszHeader = WININET_strdupW(lpBuffersIn->lpcszHeader);
3088             else
3089                 req->lpszHeader = NULL;
3090             req->dwHeaderLength = lpBuffersIn->dwHeadersLength;
3091             req->lpOptional = lpBuffersIn->lpvBuffer;
3092             req->dwOptionalLength = lpBuffersIn->dwBufferLength;
3093             req->dwContentLength = lpBuffersIn->dwBufferTotal;
3094         }
3095         else
3096         {
3097             req->lpszHeader = NULL;
3098             req->dwHeaderLength = 0;
3099             req->lpOptional = NULL;
3100             req->dwOptionalLength = 0;
3101             req->dwContentLength = 0;
3102         }
3103
3104         req->bEndRequest = FALSE;
3105
3106         INTERNET_AsyncCall(&workRequest);
3107         /*
3108          * This is from windows.
3109          */
3110         INTERNET_SetLastError(ERROR_IO_PENDING);
3111     }
3112     else
3113     {
3114         if (lpBuffersIn)
3115             ret = HTTP_HttpSendRequestW(lpwhr, lpBuffersIn->lpcszHeader, lpBuffersIn->dwHeadersLength,
3116                                         lpBuffersIn->lpvBuffer, lpBuffersIn->dwBufferLength,
3117                                         lpBuffersIn->dwBufferTotal, FALSE);
3118         else
3119             ret = HTTP_HttpSendRequestW(lpwhr, NULL, 0, NULL, 0, 0, FALSE);
3120     }
3121
3122 lend:
3123     if ( lpwhr )
3124         WININET_Release( &lpwhr->hdr );
3125
3126     TRACE("<---\n");
3127     return ret;
3128 }
3129
3130 /***********************************************************************
3131  *           HttpSendRequestW (WININET.@)
3132  *
3133  * Sends the specified request to the HTTP server
3134  *
3135  * RETURNS
3136  *    TRUE  on success
3137  *    FALSE on failure
3138  *
3139  */
3140 BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
3141         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
3142 {
3143     LPWININETHTTPREQW lpwhr;
3144     LPWININETHTTPSESSIONW lpwhs = NULL;
3145     LPWININETAPPINFOW hIC = NULL;
3146     BOOL r;
3147
3148     TRACE("%p, %s, %i, %p, %i)\n", hHttpRequest,
3149             debugstr_wn(lpszHeaders, dwHeaderLength), dwHeaderLength, lpOptional, dwOptionalLength);
3150
3151     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
3152     if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
3153     {
3154         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
3155         r = FALSE;
3156         goto lend;
3157     }
3158
3159     lpwhs = lpwhr->lpHttpSession;
3160     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
3161     {
3162         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
3163         r = FALSE;
3164         goto lend;
3165     }
3166
3167     hIC = lpwhs->lpAppInfo;
3168     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT)
3169     {
3170         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
3171         r = FALSE;
3172         goto lend;
3173     }
3174
3175     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3176     {
3177         WORKREQUEST workRequest;
3178         struct WORKREQ_HTTPSENDREQUESTW *req;
3179
3180         workRequest.asyncproc = AsyncHttpSendRequestProc;
3181         workRequest.hdr = WININET_AddRef( &lpwhr->hdr );
3182         req = &workRequest.u.HttpSendRequestW;
3183         if (lpszHeaders)
3184         {
3185             DWORD size;
3186
3187             if (dwHeaderLength == ~0u) size = (strlenW(lpszHeaders) + 1) * sizeof(WCHAR);
3188             else size = dwHeaderLength * sizeof(WCHAR);
3189
3190             req->lpszHeader = HeapAlloc(GetProcessHeap(), 0, size);
3191             memcpy(req->lpszHeader, lpszHeaders, size);
3192         }
3193         else
3194             req->lpszHeader = 0;
3195         req->dwHeaderLength = dwHeaderLength;
3196         req->lpOptional = lpOptional;
3197         req->dwOptionalLength = dwOptionalLength;
3198         req->dwContentLength = dwOptionalLength;
3199         req->bEndRequest = TRUE;
3200
3201         INTERNET_AsyncCall(&workRequest);
3202         /*
3203          * This is from windows.
3204          */
3205         INTERNET_SetLastError(ERROR_IO_PENDING);
3206         r = FALSE;
3207     }
3208     else
3209     {
3210         r = HTTP_HttpSendRequestW(lpwhr, lpszHeaders,
3211                 dwHeaderLength, lpOptional, dwOptionalLength,
3212                 dwOptionalLength, TRUE);
3213     }
3214 lend:
3215     if( lpwhr )
3216         WININET_Release( &lpwhr->hdr );
3217     return r;
3218 }
3219
3220 /***********************************************************************
3221  *           HttpSendRequestA (WININET.@)
3222  *
3223  * Sends the specified request to the HTTP server
3224  *
3225  * RETURNS
3226  *    TRUE  on success
3227  *    FALSE on failure
3228  *
3229  */
3230 BOOL WINAPI HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
3231         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
3232 {
3233     BOOL result;
3234     LPWSTR szHeaders=NULL;
3235     DWORD nLen=dwHeaderLength;
3236     if(lpszHeaders!=NULL)
3237     {
3238         nLen=MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,NULL,0);
3239         szHeaders=HeapAlloc(GetProcessHeap(),0,nLen*sizeof(WCHAR));
3240         MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,szHeaders,nLen);
3241     }
3242     result=HttpSendRequestW(hHttpRequest, szHeaders, nLen, lpOptional, dwOptionalLength);
3243     HeapFree(GetProcessHeap(),0,szHeaders);
3244     return result;
3245 }
3246
3247 static BOOL HTTP_GetRequestURL(WININETHTTPREQW *req, LPWSTR buf)
3248 {
3249     LPHTTPHEADERW host_header;
3250
3251     static const WCHAR formatW[] = {'h','t','t','p',':','/','/','%','s','%','s',0};
3252
3253     host_header = HTTP_GetHeader(req, hostW);
3254     if(!host_header)
3255         return FALSE;
3256
3257     sprintfW(buf, formatW, host_header->lpszValue, req->lpszPath); /* FIXME */
3258     return TRUE;
3259 }
3260
3261 /***********************************************************************
3262  *           HTTP_GetRedirectURL (internal)
3263  */
3264 static LPWSTR HTTP_GetRedirectURL(LPWININETHTTPREQW lpwhr, LPCWSTR lpszUrl)
3265 {
3266     static WCHAR szHttp[] = {'h','t','t','p',0};
3267     static WCHAR szHttps[] = {'h','t','t','p','s',0};
3268     LPWININETHTTPSESSIONW lpwhs = lpwhr->lpHttpSession;
3269     URL_COMPONENTSW urlComponents;
3270     DWORD url_length = 0;
3271     LPWSTR orig_url;
3272     LPWSTR combined_url;
3273
3274     urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
3275     urlComponents.lpszScheme = (lpwhr->hdr.dwFlags & INTERNET_FLAG_SECURE) ? szHttps : szHttp;
3276     urlComponents.dwSchemeLength = 0;
3277     urlComponents.lpszHostName = lpwhs->lpszHostName;
3278     urlComponents.dwHostNameLength = 0;
3279     urlComponents.nPort = lpwhs->nHostPort;
3280     urlComponents.lpszUserName = lpwhs->lpszUserName;
3281     urlComponents.dwUserNameLength = 0;
3282     urlComponents.lpszPassword = NULL;
3283     urlComponents.dwPasswordLength = 0;
3284     urlComponents.lpszUrlPath = lpwhr->lpszPath;
3285     urlComponents.dwUrlPathLength = 0;
3286     urlComponents.lpszExtraInfo = NULL;
3287     urlComponents.dwExtraInfoLength = 0;
3288
3289     if (!InternetCreateUrlW(&urlComponents, 0, NULL, &url_length) &&
3290         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
3291         return NULL;
3292
3293     orig_url = HeapAlloc(GetProcessHeap(), 0, url_length);
3294
3295     /* convert from bytes to characters */
3296     url_length = url_length / sizeof(WCHAR) - 1;
3297     if (!InternetCreateUrlW(&urlComponents, 0, orig_url, &url_length))
3298     {
3299         HeapFree(GetProcessHeap(), 0, orig_url);
3300         return NULL;
3301     }
3302
3303     url_length = 0;
3304     if (!InternetCombineUrlW(orig_url, lpszUrl, NULL, &url_length, ICU_ENCODE_SPACES_ONLY) &&
3305         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
3306     {
3307         HeapFree(GetProcessHeap(), 0, orig_url);
3308         return NULL;
3309     }
3310     combined_url = HeapAlloc(GetProcessHeap(), 0, url_length * sizeof(WCHAR));
3311
3312     if (!InternetCombineUrlW(orig_url, lpszUrl, combined_url, &url_length, ICU_ENCODE_SPACES_ONLY))
3313     {
3314         HeapFree(GetProcessHeap(), 0, orig_url);
3315         HeapFree(GetProcessHeap(), 0, combined_url);
3316         return NULL;
3317     }
3318     HeapFree(GetProcessHeap(), 0, orig_url);
3319     return combined_url;
3320 }
3321
3322
3323 /***********************************************************************
3324  *           HTTP_HandleRedirect (internal)
3325  */
3326 static BOOL HTTP_HandleRedirect(LPWININETHTTPREQW lpwhr, LPCWSTR lpszUrl)
3327 {
3328     LPWININETHTTPSESSIONW lpwhs = lpwhr->lpHttpSession;
3329     LPWININETAPPINFOW hIC = lpwhs->lpAppInfo;
3330     BOOL using_proxy = hIC->lpszProxy && hIC->lpszProxy[0];
3331     WCHAR path[INTERNET_MAX_URL_LENGTH];
3332     int index;
3333
3334     if(lpszUrl[0]=='/')
3335     {
3336         /* if it's an absolute path, keep the same session info */
3337         lstrcpynW(path, lpszUrl, INTERNET_MAX_URL_LENGTH);
3338     }
3339     else
3340     {
3341         URL_COMPONENTSW urlComponents;
3342         WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
3343         static WCHAR szHttp[] = {'h','t','t','p',0};
3344         static WCHAR szHttps[] = {'h','t','t','p','s',0};
3345
3346         userName[0] = 0;
3347         hostName[0] = 0;
3348         protocol[0] = 0;
3349
3350         urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
3351         urlComponents.lpszScheme = protocol;
3352         urlComponents.dwSchemeLength = 32;
3353         urlComponents.lpszHostName = hostName;
3354         urlComponents.dwHostNameLength = MAXHOSTNAME;
3355         urlComponents.lpszUserName = userName;
3356         urlComponents.dwUserNameLength = 1024;
3357         urlComponents.lpszPassword = NULL;
3358         urlComponents.dwPasswordLength = 0;
3359         urlComponents.lpszUrlPath = path;
3360         urlComponents.dwUrlPathLength = 2048;
3361         urlComponents.lpszExtraInfo = NULL;
3362         urlComponents.dwExtraInfoLength = 0;
3363         if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
3364             return FALSE;
3365
3366         if (!strncmpW(szHttp, urlComponents.lpszScheme, strlenW(szHttp)) &&
3367             (lpwhr->hdr.dwFlags & INTERNET_FLAG_SECURE))
3368         {
3369             TRACE("redirect from secure page to non-secure page\n");
3370             /* FIXME: warn about from secure redirect to non-secure page */
3371             lpwhr->hdr.dwFlags &= ~INTERNET_FLAG_SECURE;
3372         }
3373         if (!strncmpW(szHttps, urlComponents.lpszScheme, strlenW(szHttps)) &&
3374             !(lpwhr->hdr.dwFlags & INTERNET_FLAG_SECURE))
3375         {
3376             TRACE("redirect from non-secure page to secure page\n");
3377             /* FIXME: notify about redirect to secure page */
3378             lpwhr->hdr.dwFlags |= INTERNET_FLAG_SECURE;
3379         }
3380
3381         if (urlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
3382         {
3383             if (lstrlenW(protocol)>4) /*https*/
3384                 urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
3385             else /*http*/
3386                 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
3387         }
3388
3389 #if 0
3390         /*
3391          * This upsets redirects to binary files on sourceforge.net
3392          * and gives an html page instead of the target file
3393          * Examination of the HTTP request sent by native wininet.dll
3394          * reveals that it doesn't send a referrer in that case.
3395          * Maybe there's a flag that enables this, or maybe a referrer
3396          * shouldn't be added in case of a redirect.
3397          */
3398
3399         /* consider the current host as the referrer */
3400         if (lpwhs->lpszServerName && *lpwhs->lpszServerName)
3401             HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpwhs->lpszServerName,
3402                            HTTP_ADDHDR_FLAG_REQ|HTTP_ADDREQ_FLAG_REPLACE|
3403                            HTTP_ADDHDR_FLAG_ADD_IF_NEW);
3404 #endif
3405
3406         HeapFree(GetProcessHeap(), 0, lpwhs->lpszHostName);
3407         if (urlComponents.nPort != INTERNET_DEFAULT_HTTP_PORT &&
3408             urlComponents.nPort != INTERNET_DEFAULT_HTTPS_PORT)
3409         {
3410             int len;
3411             static const WCHAR fmt[] = {'%','s',':','%','i',0};
3412             len = lstrlenW(hostName);
3413             len += 7; /* 5 for strlen("65535") + 1 for ":" + 1 for '\0' */
3414             lpwhs->lpszHostName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
3415             sprintfW(lpwhs->lpszHostName, fmt, hostName, urlComponents.nPort);
3416         }
3417         else
3418             lpwhs->lpszHostName = WININET_strdupW(hostName);
3419
3420         HTTP_ProcessHeader(lpwhr, hostW, lpwhs->lpszHostName, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDHDR_FLAG_REQ);
3421
3422         HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
3423         lpwhs->lpszUserName = NULL;
3424         if (userName[0])
3425             lpwhs->lpszUserName = WININET_strdupW(userName);
3426
3427         if (!using_proxy)
3428         {
3429             if (strcmpiW(lpwhs->lpszServerName, hostName) || lpwhs->nServerPort != urlComponents.nPort)
3430             {
3431                 HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
3432                 lpwhs->lpszServerName = WININET_strdupW(hostName);
3433                 lpwhs->nServerPort = urlComponents.nPort;
3434
3435                 NETCON_close(&lpwhr->netConnection);
3436                 if (!HTTP_ResolveName(lpwhr)) return FALSE;
3437                 if (!NETCON_init(&lpwhr->netConnection, lpwhr->hdr.dwFlags & INTERNET_FLAG_SECURE)) return FALSE;
3438                 lpwhr->read_pos = lpwhr->read_size = 0;
3439                 lpwhr->read_chunked = FALSE;
3440             }
3441         }
3442         else
3443             TRACE("Redirect through proxy\n");
3444     }
3445
3446     HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
3447     lpwhr->lpszPath=NULL;
3448     if (*path)
3449     {
3450         DWORD needed = 0;
3451         HRESULT rc;
3452
3453         rc = UrlEscapeW(path, NULL, &needed, URL_ESCAPE_SPACES_ONLY);
3454         if (rc != E_POINTER)
3455             needed = strlenW(path)+1;
3456         lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, needed*sizeof(WCHAR));
3457         rc = UrlEscapeW(path, lpwhr->lpszPath, &needed,
3458                         URL_ESCAPE_SPACES_ONLY);
3459         if (rc != S_OK)
3460         {
3461             ERR("Unable to escape string!(%s) (%d)\n",debugstr_w(path),rc);
3462             strcpyW(lpwhr->lpszPath,path);
3463         }
3464     }
3465
3466     /* Remove custom content-type/length headers on redirects.  */
3467     index = HTTP_GetCustomHeaderIndex(lpwhr, szContent_Type, 0, TRUE);
3468     if (0 <= index)
3469         HTTP_DeleteCustomHeader(lpwhr, index);
3470     index = HTTP_GetCustomHeaderIndex(lpwhr, szContent_Length, 0, TRUE);
3471     if (0 <= index)
3472         HTTP_DeleteCustomHeader(lpwhr, index);
3473
3474     return TRUE;
3475 }
3476
3477 /***********************************************************************
3478  *           HTTP_build_req (internal)
3479  *
3480  *  concatenate all the strings in the request together
3481  */
3482 static LPWSTR HTTP_build_req( LPCWSTR *list, int len )
3483 {
3484     LPCWSTR *t;
3485     LPWSTR str;
3486
3487     for( t = list; *t ; t++  )
3488         len += strlenW( *t );
3489     len++;
3490
3491     str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
3492     *str = 0;
3493
3494     for( t = list; *t ; t++ )
3495         strcatW( str, *t );
3496
3497     return str;
3498 }
3499
3500 static BOOL HTTP_SecureProxyConnect(LPWININETHTTPREQW lpwhr)
3501 {
3502     LPWSTR lpszPath;
3503     LPWSTR requestString;
3504     INT len;
3505     INT cnt;
3506     INT responseLen;
3507     char *ascii_req;
3508     BOOL ret;
3509     static const WCHAR szConnect[] = {'C','O','N','N','E','C','T',0};
3510     static const WCHAR szFormat[] = {'%','s',':','%','d',0};
3511     LPWININETHTTPSESSIONW lpwhs = lpwhr->lpHttpSession;
3512
3513     TRACE("\n");
3514
3515     lpszPath = HeapAlloc( GetProcessHeap(), 0, (lstrlenW( lpwhs->lpszHostName ) + 13)*sizeof(WCHAR) );
3516     sprintfW( lpszPath, szFormat, lpwhs->lpszHostName, lpwhs->nHostPort );
3517     requestString = HTTP_BuildHeaderRequestString( lpwhr, szConnect, lpszPath, g_szHttp1_1 );
3518     HeapFree( GetProcessHeap(), 0, lpszPath );
3519
3520     len = WideCharToMultiByte( CP_ACP, 0, requestString, -1,
3521                                 NULL, 0, NULL, NULL );
3522     len--; /* the nul terminator isn't needed */
3523     ascii_req = HeapAlloc( GetProcessHeap(), 0, len );
3524     WideCharToMultiByte( CP_ACP, 0, requestString, -1,
3525                             ascii_req, len, NULL, NULL );
3526     HeapFree( GetProcessHeap(), 0, requestString );
3527
3528     TRACE("full request -> %s\n", debugstr_an( ascii_req, len ) );
3529
3530     ret = NETCON_send( &lpwhr->netConnection, ascii_req, len, 0, &cnt );
3531     HeapFree( GetProcessHeap(), 0, ascii_req );
3532     if (!ret || cnt < 0)
3533         return FALSE;
3534
3535     responseLen = HTTP_GetResponseHeaders( lpwhr, TRUE );
3536     if (!responseLen)
3537         return FALSE;
3538
3539     return TRUE;
3540 }
3541
3542 static void HTTP_InsertCookies(LPWININETHTTPREQW lpwhr)
3543 {
3544     static const WCHAR szUrlForm[] = {'h','t','t','p',':','/','/','%','s','%','s',0};
3545     LPWSTR lpszCookies, lpszUrl = NULL;
3546     DWORD nCookieSize, size;
3547     LPHTTPHEADERW Host = HTTP_GetHeader(lpwhr, hostW);
3548
3549     size = (strlenW(Host->lpszValue) + strlenW(szUrlForm) + strlenW(lpwhr->lpszPath)) * sizeof(WCHAR);
3550     if (!(lpszUrl = HeapAlloc(GetProcessHeap(), 0, size))) return;
3551     sprintfW( lpszUrl, szUrlForm, Host->lpszValue, lpwhr->lpszPath);
3552
3553     if (InternetGetCookieW(lpszUrl, NULL, NULL, &nCookieSize))
3554     {
3555         int cnt = 0;
3556         static const WCHAR szCookie[] = {'C','o','o','k','i','e',':',' ',0};
3557
3558         size = sizeof(szCookie) + nCookieSize * sizeof(WCHAR) + sizeof(szCrLf);
3559         if ((lpszCookies = HeapAlloc(GetProcessHeap(), 0, size)))
3560         {
3561             cnt += sprintfW(lpszCookies, szCookie);
3562             InternetGetCookieW(lpszUrl, NULL, lpszCookies + cnt, &nCookieSize);
3563             strcatW(lpszCookies, szCrLf);
3564
3565             HTTP_HttpAddRequestHeadersW(lpwhr, lpszCookies, strlenW(lpszCookies), HTTP_ADDREQ_FLAG_REPLACE);
3566             HeapFree(GetProcessHeap(), 0, lpszCookies);
3567         }
3568     }
3569     HeapFree(GetProcessHeap(), 0, lpszUrl);
3570 }
3571
3572 /***********************************************************************
3573  *           HTTP_HttpSendRequestW (internal)
3574  *
3575  * Sends the specified request to the HTTP server
3576  *
3577  * RETURNS
3578  *    TRUE  on success
3579  *    FALSE on failure
3580  *
3581  */
3582 BOOL WINAPI HTTP_HttpSendRequestW(LPWININETHTTPREQW lpwhr, LPCWSTR lpszHeaders,
3583         DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength,
3584         DWORD dwContentLength, BOOL bEndRequest)
3585 {
3586     INT cnt;
3587     BOOL bSuccess = FALSE, redirected = FALSE;
3588     LPWSTR requestString = NULL;
3589     INT responseLen;
3590     BOOL loop_next;
3591     INTERNET_ASYNC_RESULT iar;
3592     static const WCHAR szPost[] = { 'P','O','S','T',0 };
3593     static const WCHAR szContentLength[] =
3594         { 'C','o','n','t','e','n','t','-','L','e','n','g','t','h',':',' ','%','l','i','\r','\n',0 };
3595     WCHAR contentLengthStr[sizeof szContentLength/2 /* includes \r\n */ + 20 /* int */ ];
3596
3597     TRACE("--> %p\n", lpwhr);
3598
3599     assert(lpwhr->hdr.htype == WH_HHTTPREQ);
3600
3601     /* if the verb is NULL default to GET */
3602     if (!lpwhr->lpszVerb)
3603         lpwhr->lpszVerb = WININET_strdupW(szGET);
3604
3605     if (dwContentLength || strcmpW(lpwhr->lpszVerb, szGET))
3606     {
3607         sprintfW(contentLengthStr, szContentLength, dwContentLength);
3608         HTTP_HttpAddRequestHeadersW(lpwhr, contentLengthStr, -1L, HTTP_ADDREQ_FLAG_REPLACE);
3609         lpwhr->dwBytesToWrite = dwContentLength;
3610     }
3611     if (lpwhr->lpHttpSession->lpAppInfo->lpszAgent)
3612     {
3613         WCHAR *agent_header;
3614         static const WCHAR user_agent[] = {'U','s','e','r','-','A','g','e','n','t',':',' ','%','s','\r','\n',0};
3615         int len;
3616
3617         len = strlenW(lpwhr->lpHttpSession->lpAppInfo->lpszAgent) + strlenW(user_agent);
3618         agent_header = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3619         sprintfW(agent_header, user_agent, lpwhr->lpHttpSession->lpAppInfo->lpszAgent);
3620
3621         HTTP_HttpAddRequestHeadersW(lpwhr, agent_header, strlenW(agent_header), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
3622         HeapFree(GetProcessHeap(), 0, agent_header);
3623     }
3624     if (lpwhr->hdr.dwFlags & INTERNET_FLAG_PRAGMA_NOCACHE)
3625     {
3626         static const WCHAR pragma_nocache[] = {'P','r','a','g','m','a',':',' ','n','o','-','c','a','c','h','e','\r','\n',0};
3627         HTTP_HttpAddRequestHeadersW(lpwhr, pragma_nocache, strlenW(pragma_nocache), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
3628     }
3629     if ((lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_CACHE_WRITE) && !strcmpW(lpwhr->lpszVerb, szPost))
3630     {
3631         static const WCHAR cache_control[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l',':',
3632                                               ' ','n','o','-','c','a','c','h','e','\r','\n',0};
3633         HTTP_HttpAddRequestHeadersW(lpwhr, cache_control, strlenW(cache_control), HTTP_ADDREQ_FLAG_ADD_IF_NEW);
3634     }
3635
3636     do
3637     {
3638         DWORD len;
3639         char *ascii_req;
3640
3641         loop_next = FALSE;
3642
3643         /* like native, just in case the caller forgot to call InternetReadFile
3644          * for all the data */
3645         HTTP_DrainContent(lpwhr);
3646         lpwhr->dwContentRead = 0;
3647
3648         if (TRACE_ON(wininet))
3649         {
3650             LPHTTPHEADERW Host = HTTP_GetHeader(lpwhr, hostW);
3651             TRACE("Going to url %s %s\n", debugstr_w(Host->lpszValue), debugstr_w(lpwhr->lpszPath));
3652         }
3653
3654         HTTP_FixURL(lpwhr);
3655         if (lpwhr->hdr.dwFlags & INTERNET_FLAG_KEEP_CONNECTION)
3656         {
3657             HTTP_ProcessHeader(lpwhr, szConnection, szKeepAlive, HTTP_ADDHDR_FLAG_REQ | HTTP_ADDHDR_FLAG_REPLACE);
3658         }
3659         HTTP_InsertAuthorization(lpwhr, lpwhr->pAuthInfo, szAuthorization);
3660         HTTP_InsertAuthorization(lpwhr, lpwhr->pProxyAuthInfo, szProxy_Authorization);
3661
3662         if (!(lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_COOKIES))
3663             HTTP_InsertCookies(lpwhr);
3664
3665         /* add the headers the caller supplied */
3666         if( lpszHeaders && dwHeaderLength )
3667         {
3668             HTTP_HttpAddRequestHeadersW(lpwhr, lpszHeaders, dwHeaderLength,
3669                         HTTP_ADDREQ_FLAG_ADD | HTTP_ADDHDR_FLAG_REPLACE);
3670         }
3671
3672         if (lpwhr->lpHttpSession->lpAppInfo->lpszProxy && lpwhr->lpHttpSession->lpAppInfo->lpszProxy[0])
3673         {
3674             WCHAR *url = HTTP_BuildProxyRequestUrl(lpwhr);
3675             requestString = HTTP_BuildHeaderRequestString(lpwhr, lpwhr->lpszVerb, url, lpwhr->lpszVersion);
3676             HeapFree(GetProcessHeap(), 0, url);
3677         }
3678         else
3679             requestString = HTTP_BuildHeaderRequestString(lpwhr, lpwhr->lpszVerb, lpwhr->lpszPath, lpwhr->lpszVersion);
3680
3681
3682         TRACE("Request header -> %s\n", debugstr_w(requestString) );
3683
3684         /* Send the request and store the results */
3685         if (!HTTP_OpenConnection(lpwhr))
3686             goto lend;
3687
3688         /* send the request as ASCII, tack on the optional data */
3689         if (!lpOptional || redirected)
3690             dwOptionalLength = 0;
3691         len = WideCharToMultiByte( CP_ACP, 0, requestString, -1,
3692                                    NULL, 0, NULL, NULL );
3693         ascii_req = HeapAlloc( GetProcessHeap(), 0, len + dwOptionalLength );
3694         WideCharToMultiByte( CP_ACP, 0, requestString, -1,
3695                              ascii_req, len, NULL, NULL );
3696         if( lpOptional )
3697             memcpy( &ascii_req[len-1], lpOptional, dwOptionalLength );
3698         len = (len + dwOptionalLength - 1);
3699         ascii_req[len] = 0;
3700         TRACE("full request -> %s\n", debugstr_a(ascii_req) );
3701
3702         INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3703                               INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
3704
3705         NETCON_send(&lpwhr->netConnection, ascii_req, len, 0, &cnt);
3706         HeapFree( GetProcessHeap(), 0, ascii_req );
3707
3708         lpwhr->dwBytesWritten = dwOptionalLength;
3709
3710         INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3711                               INTERNET_STATUS_REQUEST_SENT,
3712                               &len, sizeof(DWORD));
3713
3714         if (bEndRequest)
3715         {
3716             DWORD dwBufferSize;
3717             DWORD dwStatusCode;
3718
3719             INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3720                                 INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
3721
3722             if (cnt < 0)
3723                 goto lend;
3724
3725             responseLen = HTTP_GetResponseHeaders(lpwhr, TRUE);
3726             if (responseLen)
3727                 bSuccess = TRUE;
3728
3729             INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3730                                 INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen,
3731                                 sizeof(DWORD));
3732
3733             HTTP_ProcessCookies(lpwhr);
3734
3735             if (!set_content_length( lpwhr )) HTTP_FinishedReading(lpwhr);
3736
3737             dwBufferSize = sizeof(dwStatusCode);
3738             if (!HTTP_HttpQueryInfoW(lpwhr,HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,
3739                                      &dwStatusCode,&dwBufferSize,NULL))
3740                 dwStatusCode = 0;
3741
3742             if (!(lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT) && bSuccess)
3743             {
3744                 WCHAR *new_url, szNewLocation[INTERNET_MAX_URL_LENGTH];
3745                 dwBufferSize=sizeof(szNewLocation);
3746                 if ((dwStatusCode==HTTP_STATUS_REDIRECT || dwStatusCode==HTTP_STATUS_MOVED) &&
3747                     HTTP_HttpQueryInfoW(lpwhr,HTTP_QUERY_LOCATION,szNewLocation,&dwBufferSize,NULL))
3748                 {
3749                     /* redirects are always GETs */
3750                     HeapFree(GetProcessHeap(), 0, lpwhr->lpszVerb);
3751                     lpwhr->lpszVerb = WININET_strdupW(szGET);
3752
3753                     HTTP_DrainContent(lpwhr);
3754                     if ((new_url = HTTP_GetRedirectURL( lpwhr, szNewLocation )))
3755                     {
3756                         INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext, INTERNET_STATUS_REDIRECT,
3757                                               new_url, (strlenW(new_url) + 1) * sizeof(WCHAR));
3758                         bSuccess = HTTP_HandleRedirect(lpwhr, new_url);
3759                         if (bSuccess)
3760                         {
3761                             HeapFree(GetProcessHeap(), 0, requestString);
3762                             loop_next = TRUE;
3763                         }
3764                         HeapFree( GetProcessHeap(), 0, new_url );
3765                     }
3766                     redirected = TRUE;
3767                 }
3768             }
3769             if (!(lpwhr->hdr.dwFlags & INTERNET_FLAG_NO_AUTH) && bSuccess)
3770             {
3771                 WCHAR szAuthValue[2048];
3772                 dwBufferSize=2048;
3773                 if (dwStatusCode == HTTP_STATUS_DENIED)
3774                 {
3775                     DWORD dwIndex = 0;
3776                     while (HTTP_HttpQueryInfoW(lpwhr,HTTP_QUERY_WWW_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex))
3777                     {
3778                         if (HTTP_DoAuthorization(lpwhr, szAuthValue,
3779                                                  &lpwhr->pAuthInfo,
3780                                                  lpwhr->lpHttpSession->lpszUserName,
3781                                                  lpwhr->lpHttpSession->lpszPassword))
3782                         {
3783                             loop_next = TRUE;
3784                             break;
3785                         }
3786                     }
3787                 }
3788                 if (dwStatusCode == HTTP_STATUS_PROXY_AUTH_REQ)
3789                 {
3790                     DWORD dwIndex = 0;
3791                     while (HTTP_HttpQueryInfoW(lpwhr,HTTP_QUERY_PROXY_AUTHENTICATE,szAuthValue,&dwBufferSize,&dwIndex))
3792                     {
3793                         if (HTTP_DoAuthorization(lpwhr, szAuthValue,
3794                                                  &lpwhr->pProxyAuthInfo,
3795                                                  lpwhr->lpHttpSession->lpAppInfo->lpszProxyUsername,
3796                                                  lpwhr->lpHttpSession->lpAppInfo->lpszProxyPassword))
3797                         {
3798                             loop_next = TRUE;
3799                             break;
3800                         }
3801                     }
3802                 }
3803             }
3804         }
3805         else
3806             bSuccess = TRUE;
3807     }
3808     while (loop_next);
3809
3810     /* FIXME: Better check, when we have to create the cache file */
3811     if(bSuccess && (lpwhr->hdr.dwFlags & INTERNET_FLAG_NEED_FILE)) {
3812         WCHAR url[INTERNET_MAX_URL_LENGTH];
3813         WCHAR cacheFileName[MAX_PATH+1];
3814         BOOL b;
3815
3816         b = HTTP_GetRequestURL(lpwhr, url);
3817         if(!b) {
3818             WARN("Could not get URL\n");
3819             goto lend;
3820         }
3821
3822         b = CreateUrlCacheEntryW(url, lpwhr->dwContentLength > 0 ? lpwhr->dwContentLength : 0, NULL, cacheFileName, 0);
3823         if(b) {
3824             lpwhr->lpszCacheFile = WININET_strdupW(cacheFileName);
3825             lpwhr->hCacheFile = CreateFileW(lpwhr->lpszCacheFile, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
3826                       NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3827             if(lpwhr->hCacheFile == INVALID_HANDLE_VALUE) {
3828                 WARN("Could not create file: %u\n", GetLastError());
3829                 lpwhr->hCacheFile = NULL;
3830             }
3831         }else {
3832             WARN("Could not create cache entry: %08x\n", GetLastError());
3833         }
3834     }
3835
3836 lend:
3837
3838     HeapFree(GetProcessHeap(), 0, requestString);
3839
3840     /* TODO: send notification for P3P header */
3841
3842     if (lpwhr->lpHttpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3843     {
3844         if (bSuccess)
3845         {
3846             if (lpwhr->dwBytesWritten == lpwhr->dwBytesToWrite) HTTP_ReceiveRequestData(lpwhr, TRUE);
3847             else
3848             {
3849                 iar.dwResult = (DWORD_PTR)lpwhr->hdr.hInternet;
3850                 iar.dwError = 0;
3851
3852                 INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3853                                   INTERNET_STATUS_REQUEST_COMPLETE, &iar,
3854                                   sizeof(INTERNET_ASYNC_RESULT));
3855             }
3856         }
3857         else
3858         {
3859             iar.dwResult = (DWORD_PTR)lpwhr->hdr.hInternet;
3860             iar.dwError = INTERNET_GetLastError();
3861
3862             INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
3863                                   INTERNET_STATUS_REQUEST_COMPLETE, &iar,
3864                                   sizeof(INTERNET_ASYNC_RESULT));
3865         }
3866     }
3867
3868     TRACE("<--\n");
3869     if (bSuccess) INTERNET_SetLastError(ERROR_SUCCESS);
3870     return bSuccess;
3871 }
3872
3873 /***********************************************************************
3874  *           HTTPSESSION_Destroy (internal)
3875  *
3876  * Deallocate session handle
3877  *
3878  */
3879 static void HTTPSESSION_Destroy(WININETHANDLEHEADER *hdr)
3880 {
3881     LPWININETHTTPSESSIONW lpwhs = (LPWININETHTTPSESSIONW) hdr;
3882
3883     TRACE("%p\n", lpwhs);
3884
3885     WININET_Release(&lpwhs->lpAppInfo->hdr);
3886
3887     HeapFree(GetProcessHeap(), 0, lpwhs->lpszHostName);
3888     HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
3889     HeapFree(GetProcessHeap(), 0, lpwhs->lpszPassword);
3890     HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
3891     HeapFree(GetProcessHeap(), 0, lpwhs);
3892 }
3893
3894 static DWORD HTTPSESSION_QueryOption(WININETHANDLEHEADER *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
3895 {
3896     switch(option) {
3897     case INTERNET_OPTION_HANDLE_TYPE:
3898         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
3899
3900         if (*size < sizeof(ULONG))
3901             return ERROR_INSUFFICIENT_BUFFER;
3902
3903         *size = sizeof(DWORD);
3904         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_HTTP;
3905         return ERROR_SUCCESS;
3906     }
3907
3908     return INET_QueryOption(option, buffer, size, unicode);
3909 }
3910
3911 static DWORD HTTPSESSION_SetOption(WININETHANDLEHEADER *hdr, DWORD option, void *buffer, DWORD size)
3912 {
3913     WININETHTTPSESSIONW *ses = (WININETHTTPSESSIONW*)hdr;
3914
3915     switch(option) {
3916     case INTERNET_OPTION_USERNAME:
3917     {
3918         HeapFree(GetProcessHeap(), 0, ses->lpszUserName);
3919         if (!(ses->lpszUserName = WININET_strdupW(buffer))) return ERROR_OUTOFMEMORY;
3920         return ERROR_SUCCESS;
3921     }
3922     case INTERNET_OPTION_PASSWORD:
3923     {
3924         HeapFree(GetProcessHeap(), 0, ses->lpszPassword);
3925         if (!(ses->lpszPassword = WININET_strdupW(buffer))) return ERROR_OUTOFMEMORY;
3926         return ERROR_SUCCESS;
3927     }
3928     default: break;
3929     }
3930
3931     return ERROR_INTERNET_INVALID_OPTION;
3932 }
3933
3934 static const HANDLEHEADERVtbl HTTPSESSIONVtbl = {
3935     HTTPSESSION_Destroy,
3936     NULL,
3937     HTTPSESSION_QueryOption,
3938     HTTPSESSION_SetOption,
3939     NULL,
3940     NULL,
3941     NULL,
3942     NULL,
3943     NULL
3944 };
3945
3946
3947 /***********************************************************************
3948  *           HTTP_Connect  (internal)
3949  *
3950  * Create http session handle
3951  *
3952  * RETURNS
3953  *   HINTERNET a session handle on success
3954  *   NULL on failure
3955  *
3956  */
3957 HINTERNET HTTP_Connect(LPWININETAPPINFOW hIC, LPCWSTR lpszServerName,
3958         INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
3959         LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
3960         DWORD dwInternalFlags)
3961 {
3962     LPWININETHTTPSESSIONW lpwhs = NULL;
3963     HINTERNET handle = NULL;
3964
3965     TRACE("-->\n");
3966
3967     if (!lpszServerName || !lpszServerName[0])
3968     {
3969         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
3970         goto lerror;
3971     }
3972
3973     assert( hIC->hdr.htype == WH_HINIT );
3974
3975     lpwhs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPSESSIONW));
3976     if (NULL == lpwhs)
3977     {
3978         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
3979         goto lerror;
3980     }
3981
3982    /*
3983     * According to my tests. The name is not resolved until a request is sent
3984     */
3985
3986     lpwhs->hdr.htype = WH_HHTTPSESSION;
3987     lpwhs->hdr.vtbl = &HTTPSESSIONVtbl;
3988     lpwhs->hdr.dwFlags = dwFlags;
3989     lpwhs->hdr.dwContext = dwContext;
3990     lpwhs->hdr.dwInternalFlags = dwInternalFlags | (hIC->hdr.dwInternalFlags & INET_CALLBACKW);
3991     lpwhs->hdr.refs = 1;
3992     lpwhs->hdr.lpfnStatusCB = hIC->hdr.lpfnStatusCB;
3993
3994     WININET_AddRef( &hIC->hdr );
3995     lpwhs->lpAppInfo = hIC;
3996     list_add_head( &hIC->hdr.children, &lpwhs->hdr.entry );
3997
3998     handle = WININET_AllocHandle( &lpwhs->hdr );
3999     if (NULL == handle)
4000     {
4001         ERR("Failed to alloc handle\n");
4002         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
4003         goto lerror;
4004     }
4005
4006     if(hIC->lpszProxy && hIC->dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
4007         if(strchrW(hIC->lpszProxy, ' '))
4008             FIXME("Several proxies not implemented.\n");
4009         if(hIC->lpszProxyBypass)
4010             FIXME("Proxy bypass is ignored.\n");
4011     }
4012     if (lpszServerName && lpszServerName[0])
4013     {
4014         lpwhs->lpszServerName = WININET_strdupW(lpszServerName);
4015         lpwhs->lpszHostName = WININET_strdupW(lpszServerName);
4016     }
4017     if (lpszUserName && lpszUserName[0])
4018         lpwhs->lpszUserName = WININET_strdupW(lpszUserName);
4019     if (lpszPassword && lpszPassword[0])
4020         lpwhs->lpszPassword = WININET_strdupW(lpszPassword);
4021     lpwhs->nServerPort = nServerPort;
4022     lpwhs->nHostPort = nServerPort;
4023
4024     /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
4025     if (!(lpwhs->hdr.dwInternalFlags & INET_OPENURL))
4026     {
4027         INTERNET_SendCallback(&hIC->hdr, dwContext,
4028                               INTERNET_STATUS_HANDLE_CREATED, &handle,
4029                               sizeof(handle));
4030     }
4031
4032 lerror:
4033     if( lpwhs )
4034         WININET_Release( &lpwhs->hdr );
4035
4036 /*
4037  * an INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
4038  * windows
4039  */
4040
4041     TRACE("%p --> %p (%p)\n", hIC, handle, lpwhs);
4042     return handle;
4043 }
4044
4045
4046 /***********************************************************************
4047  *           HTTP_OpenConnection (internal)
4048  *
4049  * Connect to a web server
4050  *
4051  * RETURNS
4052  *
4053  *   TRUE  on success
4054  *   FALSE on failure
4055  */
4056 static BOOL HTTP_OpenConnection(LPWININETHTTPREQW lpwhr)
4057 {
4058     BOOL bSuccess = FALSE;
4059     LPWININETHTTPSESSIONW lpwhs;
4060     LPWININETAPPINFOW hIC = NULL;
4061     char szaddr[32];
4062
4063     TRACE("-->\n");
4064
4065
4066     if (lpwhr->hdr.htype != WH_HHTTPREQ)
4067     {
4068         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
4069         goto lend;
4070     }
4071
4072     if (NETCON_connected(&lpwhr->netConnection))
4073     {
4074         bSuccess = TRUE;
4075         goto lend;
4076     }
4077     if (!HTTP_ResolveName(lpwhr)) goto lend;
4078
4079     lpwhs = lpwhr->lpHttpSession;
4080
4081     hIC = lpwhs->lpAppInfo;
4082     inet_ntop(lpwhs->socketAddress.sin_family, &lpwhs->socketAddress.sin_addr,
4083               szaddr, sizeof(szaddr));
4084     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
4085                           INTERNET_STATUS_CONNECTING_TO_SERVER,
4086                           szaddr,
4087                           strlen(szaddr)+1);
4088
4089     if (!NETCON_create(&lpwhr->netConnection, lpwhs->socketAddress.sin_family,
4090                          SOCK_STREAM, 0))
4091     {
4092         WARN("Socket creation failed: %u\n", INTERNET_GetLastError());
4093         goto lend;
4094     }
4095
4096     if (!NETCON_connect(&lpwhr->netConnection, (struct sockaddr *)&lpwhs->socketAddress,
4097                       sizeof(lpwhs->socketAddress)))
4098        goto lend;
4099
4100     if (lpwhr->hdr.dwFlags & INTERNET_FLAG_SECURE)
4101     {
4102         /* Note: we differ from Microsoft's WinINet here. they seem to have
4103          * a bug that causes no status callbacks to be sent when starting
4104          * a tunnel to a proxy server using the CONNECT verb. i believe our
4105          * behaviour to be more correct and to not cause any incompatibilities
4106          * because using a secure connection through a proxy server is a rare
4107          * case that would be hard for anyone to depend on */
4108         if (hIC->lpszProxy && !HTTP_SecureProxyConnect(lpwhr))
4109             goto lend;
4110
4111         if (!NETCON_secure_connect(&lpwhr->netConnection, lpwhs->lpszHostName))
4112         {
4113             WARN("Couldn't connect securely to host\n");
4114             goto lend;
4115         }
4116     }
4117
4118     INTERNET_SendCallback(&lpwhr->hdr, lpwhr->hdr.dwContext,
4119                           INTERNET_STATUS_CONNECTED_TO_SERVER,
4120                           szaddr, strlen(szaddr)+1);
4121
4122     bSuccess = TRUE;
4123
4124 lend:
4125     lpwhr->read_pos = lpwhr->read_size = 0;
4126     lpwhr->read_chunked = FALSE;
4127
4128     TRACE("%d <--\n", bSuccess);
4129     return bSuccess;
4130 }
4131
4132
4133 /***********************************************************************
4134  *           HTTP_clear_response_headers (internal)
4135  *
4136  * clear out any old response headers
4137  */
4138 static void HTTP_clear_response_headers( LPWININETHTTPREQW lpwhr )
4139 {
4140     DWORD i;
4141
4142     for( i=0; i<lpwhr->nCustHeaders; i++)
4143     {
4144         if( !lpwhr->pCustHeaders[i].lpszField )
4145             continue;
4146         if( !lpwhr->pCustHeaders[i].lpszValue )
4147             continue;
4148         if ( lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST )
4149             continue;
4150         HTTP_DeleteCustomHeader( lpwhr, i );
4151         i--;
4152     }
4153 }
4154
4155 /***********************************************************************
4156  *           HTTP_GetResponseHeaders (internal)
4157  *
4158  * Read server response
4159  *
4160  * RETURNS
4161  *
4162  *   TRUE  on success
4163  *   FALSE on error
4164  */
4165 static INT HTTP_GetResponseHeaders(LPWININETHTTPREQW lpwhr, BOOL clear)
4166 {
4167     INT cbreaks = 0;
4168     WCHAR buffer[MAX_REPLY_LEN];
4169     DWORD buflen = MAX_REPLY_LEN;
4170     BOOL bSuccess = FALSE;
4171     INT  rc = 0;
4172     static const WCHAR szHundred[] = {'1','0','0',0};
4173     char bufferA[MAX_REPLY_LEN];
4174     LPWSTR status_code, status_text;
4175     DWORD cchMaxRawHeaders = 1024;
4176     LPWSTR lpszRawHeaders = HeapAlloc(GetProcessHeap(), 0, (cchMaxRawHeaders+1)*sizeof(WCHAR));
4177     LPWSTR temp;
4178     DWORD cchRawHeaders = 0;
4179
4180     TRACE("-->\n");
4181
4182     /* clear old response headers (eg. from a redirect response) */
4183     if (clear) HTTP_clear_response_headers( lpwhr );
4184
4185     if (!NETCON_connected(&lpwhr->netConnection))
4186         goto lend;
4187
4188     do {
4189         /*
4190          * We should first receive 'HTTP/1.x nnn OK' where nnn is the status code.
4191          */
4192         buflen = MAX_REPLY_LEN;
4193         if (!read_line(lpwhr, bufferA, &buflen))
4194             goto lend;
4195         rc += buflen;
4196         MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
4197
4198         /* split the version from the status code */
4199         status_code = strchrW( buffer, ' ' );
4200         if( !status_code )
4201             goto lend;
4202         *status_code++=0;
4203
4204         /* split the status code from the status text */
4205         status_text = strchrW( status_code, ' ' );
4206         if( !status_text )
4207             goto lend;
4208         *status_text++=0;
4209
4210         TRACE("version [%s] status code [%s] status text [%s]\n",
4211            debugstr_w(buffer), debugstr_w(status_code), debugstr_w(status_text) );
4212
4213     } while (!strcmpW(status_code, szHundred)); /* ignore "100 Continue" responses */
4214
4215     /* Add status code */
4216     HTTP_ProcessHeader(lpwhr, szStatus, status_code,
4217             HTTP_ADDHDR_FLAG_REPLACE);
4218
4219     HeapFree(GetProcessHeap(),0,lpwhr->lpszVersion);
4220     HeapFree(GetProcessHeap(),0,lpwhr->lpszStatusText);
4221
4222     lpwhr->lpszVersion= WININET_strdupW(buffer);
4223     lpwhr->lpszStatusText = WININET_strdupW(status_text);
4224
4225     /* Restore the spaces */
4226     *(status_code-1) = ' ';
4227     *(status_text-1) = ' ';
4228
4229     /* regenerate raw headers */
4230     while (cchRawHeaders + buflen + strlenW(szCrLf) > cchMaxRawHeaders)
4231         cchMaxRawHeaders *= 2;
4232     temp = HeapReAlloc(GetProcessHeap(), 0, lpszRawHeaders, (cchMaxRawHeaders+1)*sizeof(WCHAR));
4233     if (temp == NULL) goto lend;
4234     lpszRawHeaders = temp;
4235     memcpy(lpszRawHeaders+cchRawHeaders, buffer, (buflen-1)*sizeof(WCHAR));
4236     cchRawHeaders += (buflen-1);
4237     memcpy(lpszRawHeaders+cchRawHeaders, szCrLf, sizeof(szCrLf));
4238     cchRawHeaders += sizeof(szCrLf)/sizeof(szCrLf[0])-1;
4239     lpszRawHeaders[cchRawHeaders] = '\0';
4240
4241     /* Parse each response line */
4242     do
4243     {
4244         buflen = MAX_REPLY_LEN;
4245         if (read_line(lpwhr, bufferA, &buflen))
4246         {
4247             LPWSTR * pFieldAndValue;
4248
4249             TRACE("got line %s, now interpreting\n", debugstr_a(bufferA));
4250
4251             if (!bufferA[0]) break;
4252             MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
4253
4254             pFieldAndValue = HTTP_InterpretHttpHeader(buffer);
4255             if (pFieldAndValue)
4256             {
4257                 while (cchRawHeaders + buflen + strlenW(szCrLf) > cchMaxRawHeaders)
4258                     cchMaxRawHeaders *= 2;
4259                 temp = HeapReAlloc(GetProcessHeap(), 0, lpszRawHeaders, (cchMaxRawHeaders+1)*sizeof(WCHAR));
4260                 if (temp == NULL) goto lend;
4261                 lpszRawHeaders = temp;
4262                 memcpy(lpszRawHeaders+cchRawHeaders, buffer, (buflen-1)*sizeof(WCHAR));
4263                 cchRawHeaders += (buflen-1);
4264                 memcpy(lpszRawHeaders+cchRawHeaders, szCrLf, sizeof(szCrLf));
4265                 cchRawHeaders += sizeof(szCrLf)/sizeof(szCrLf[0])-1;
4266                 lpszRawHeaders[cchRawHeaders] = '\0';
4267
4268                 HTTP_ProcessHeader(lpwhr, pFieldAndValue[0], pFieldAndValue[1],
4269                                    HTTP_ADDREQ_FLAG_ADD );
4270
4271                 HTTP_FreeTokens(pFieldAndValue);
4272             }
4273         }
4274         else
4275         {
4276             cbreaks++;
4277             if (cbreaks >= 2)
4278                break;
4279         }
4280     }while(1);
4281
4282     HeapFree(GetProcessHeap(), 0, lpwhr->lpszRawHeaders);
4283     lpwhr->lpszRawHeaders = lpszRawHeaders;
4284     TRACE("raw headers: %s\n", debugstr_w(lpszRawHeaders));
4285     bSuccess = TRUE;
4286
4287 lend:
4288
4289     TRACE("<--\n");
4290     if (bSuccess)
4291         return rc;
4292     else
4293     {
4294         HeapFree(GetProcessHeap(), 0, lpszRawHeaders);
4295         return 0;
4296     }
4297 }
4298
4299
4300 static void strip_spaces(LPWSTR start)
4301 {
4302     LPWSTR str = start;
4303     LPWSTR end;
4304
4305     while (*str == ' ' && *str != '\0')
4306         str++;
4307
4308     if (str != start)
4309         memmove(start, str, sizeof(WCHAR) * (strlenW(str) + 1));
4310
4311     end = start + strlenW(start) - 1;
4312     while (end >= start && *end == ' ')
4313     {
4314         *end = '\0';
4315         end--;
4316     }
4317 }
4318
4319
4320 /***********************************************************************
4321  *           HTTP_InterpretHttpHeader (internal)
4322  *
4323  * Parse server response
4324  *
4325  * RETURNS
4326  *
4327  *   Pointer to array of field, value, NULL on success.
4328  *   NULL on error.
4329  */
4330 static LPWSTR * HTTP_InterpretHttpHeader(LPCWSTR buffer)
4331 {
4332     LPWSTR * pTokenPair;
4333     LPWSTR pszColon;
4334     INT len;
4335
4336     pTokenPair = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pTokenPair)*3);
4337
4338     pszColon = strchrW(buffer, ':');
4339     /* must have two tokens */
4340     if (!pszColon)
4341     {
4342         HTTP_FreeTokens(pTokenPair);
4343         if (buffer[0])
4344             TRACE("No ':' in line: %s\n", debugstr_w(buffer));
4345         return NULL;
4346     }
4347
4348     pTokenPair[0] = HeapAlloc(GetProcessHeap(), 0, (pszColon - buffer + 1) * sizeof(WCHAR));
4349     if (!pTokenPair[0])
4350     {
4351         HTTP_FreeTokens(pTokenPair);
4352         return NULL;
4353     }
4354     memcpy(pTokenPair[0], buffer, (pszColon - buffer) * sizeof(WCHAR));
4355     pTokenPair[0][pszColon - buffer] = '\0';
4356
4357     /* skip colon */
4358     pszColon++;
4359     len = strlenW(pszColon);
4360     pTokenPair[1] = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
4361     if (!pTokenPair[1])
4362     {
4363         HTTP_FreeTokens(pTokenPair);
4364         return NULL;
4365     }
4366     memcpy(pTokenPair[1], pszColon, (len + 1) * sizeof(WCHAR));
4367
4368     strip_spaces(pTokenPair[0]);
4369     strip_spaces(pTokenPair[1]);
4370
4371     TRACE("field(%s) Value(%s)\n", debugstr_w(pTokenPair[0]), debugstr_w(pTokenPair[1]));
4372     return pTokenPair;
4373 }
4374
4375 /***********************************************************************
4376  *           HTTP_ProcessHeader (internal)
4377  *
4378  * Stuff header into header tables according to <dwModifier>
4379  *
4380  */
4381
4382 #define COALESCEFLAGS (HTTP_ADDHDR_FLAG_COALESCE|HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
4383
4384 static BOOL HTTP_ProcessHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field, LPCWSTR value, DWORD dwModifier)
4385 {
4386     LPHTTPHEADERW lphttpHdr = NULL;
4387     BOOL bSuccess = FALSE;
4388     INT index = -1;
4389     BOOL request_only = dwModifier & HTTP_ADDHDR_FLAG_REQ;
4390
4391     TRACE("--> %s: %s - 0x%08x\n", debugstr_w(field), debugstr_w(value), dwModifier);
4392
4393     /* REPLACE wins out over ADD */
4394     if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
4395         dwModifier &= ~HTTP_ADDHDR_FLAG_ADD;
4396
4397     if (dwModifier & HTTP_ADDHDR_FLAG_ADD)
4398         index = -1;
4399     else
4400         index = HTTP_GetCustomHeaderIndex(lpwhr, field, 0, request_only);
4401
4402     if (index >= 0)
4403     {
4404         if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW)
4405         {
4406             return FALSE;
4407         }
4408         lphttpHdr = &lpwhr->pCustHeaders[index];
4409     }
4410     else if (value)
4411     {
4412         HTTPHEADERW hdr;
4413
4414         hdr.lpszField = (LPWSTR)field;
4415         hdr.lpszValue = (LPWSTR)value;
4416         hdr.wFlags = hdr.wCount = 0;
4417
4418         if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
4419             hdr.wFlags |= HDR_ISREQUEST;
4420
4421         return HTTP_InsertCustomHeader(lpwhr, &hdr);
4422     }
4423     /* no value to delete */
4424     else return TRUE;
4425
4426     if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
4427             lphttpHdr->wFlags |= HDR_ISREQUEST;
4428     else
4429         lphttpHdr->wFlags &= ~HDR_ISREQUEST;
4430
4431     if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
4432     {
4433         HTTP_DeleteCustomHeader( lpwhr, index );
4434
4435         if (value)
4436         {
4437             HTTPHEADERW hdr;
4438
4439             hdr.lpszField = (LPWSTR)field;
4440             hdr.lpszValue = (LPWSTR)value;
4441             hdr.wFlags = hdr.wCount = 0;
4442
4443             if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
4444                 hdr.wFlags |= HDR_ISREQUEST;
4445
4446             return HTTP_InsertCustomHeader(lpwhr, &hdr);
4447         }
4448
4449         return TRUE;
4450     }
4451     else if (dwModifier & COALESCEFLAGS)
4452     {
4453         LPWSTR lpsztmp;
4454         WCHAR ch = 0;
4455         INT len = 0;
4456         INT origlen = strlenW(lphttpHdr->lpszValue);
4457         INT valuelen = strlenW(value);
4458
4459         if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA)
4460         {
4461             ch = ',';
4462             lphttpHdr->wFlags |= HDR_COMMADELIMITED;
4463         }
4464         else if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
4465         {
4466             ch = ';';
4467             lphttpHdr->wFlags |= HDR_COMMADELIMITED;
4468         }
4469
4470         len = origlen + valuelen + ((ch > 0) ? 2 : 0);
4471
4472         lpsztmp = HeapReAlloc(GetProcessHeap(), 0, lphttpHdr->lpszValue, (len+1)*sizeof(WCHAR));
4473         if (lpsztmp)
4474         {
4475             lphttpHdr->lpszValue = lpsztmp;
4476     /* FIXME: Increment lphttpHdr->wCount. Perhaps lpszValue should be an array */
4477             if (ch > 0)
4478             {
4479                 lphttpHdr->lpszValue[origlen] = ch;
4480                 origlen++;
4481                 lphttpHdr->lpszValue[origlen] = ' ';
4482                 origlen++;
4483             }
4484
4485             memcpy(&lphttpHdr->lpszValue[origlen], value, valuelen*sizeof(WCHAR));
4486             lphttpHdr->lpszValue[len] = '\0';
4487             bSuccess = TRUE;
4488         }
4489         else
4490         {
4491             WARN("HeapReAlloc (%d bytes) failed\n",len+1);
4492             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
4493         }
4494     }
4495     TRACE("<-- %d\n",bSuccess);
4496     return bSuccess;
4497 }
4498
4499
4500 /***********************************************************************
4501  *           HTTP_FinishedReading (internal)
4502  *
4503  * Called when all content from server has been read by client.
4504  *
4505  */
4506 static BOOL HTTP_FinishedReading(LPWININETHTTPREQW lpwhr)
4507 {
4508     WCHAR szVersion[10];
4509     WCHAR szConnectionResponse[20];
4510     DWORD dwBufferSize = sizeof(szVersion);
4511     BOOL keepalive = FALSE;
4512
4513     TRACE("\n");
4514
4515     /* as per RFC 2068, S8.1.2.1, if the client is HTTP/1.1 then assume that
4516      * the connection is keep-alive by default */
4517     if (HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_VERSION, szVersion,
4518                              &dwBufferSize, NULL) &&
4519         !strcmpiW(szVersion, g_szHttp1_1))
4520     {
4521         keepalive = TRUE;
4522     }
4523
4524     dwBufferSize = sizeof(szConnectionResponse);
4525     if (HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_PROXY_CONNECTION, szConnectionResponse, &dwBufferSize, NULL) ||
4526         HTTP_HttpQueryInfoW(lpwhr, HTTP_QUERY_CONNECTION, szConnectionResponse, &dwBufferSize, NULL))
4527     {
4528         keepalive = !strcmpiW(szConnectionResponse, szKeepAlive);
4529     }
4530
4531     if (!keepalive)
4532     {
4533         HTTPREQ_CloseConnection(&lpwhr->hdr);
4534     }
4535
4536     /* FIXME: store data in the URL cache here */
4537
4538     return TRUE;
4539 }
4540
4541
4542 /***********************************************************************
4543  *           HTTP_GetCustomHeaderIndex (internal)
4544  *
4545  * Return index of custom header from header array
4546  *
4547  */
4548 static INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQW lpwhr, LPCWSTR lpszField,
4549                                      int requested_index, BOOL request_only)
4550 {
4551     DWORD index;
4552
4553     TRACE("%s\n", debugstr_w(lpszField));
4554
4555     for (index = 0; index < lpwhr->nCustHeaders; index++)
4556     {
4557         if (strcmpiW(lpwhr->pCustHeaders[index].lpszField, lpszField))
4558             continue;
4559
4560         if (request_only && !(lpwhr->pCustHeaders[index].wFlags & HDR_ISREQUEST))
4561             continue;
4562
4563         if (!request_only && (lpwhr->pCustHeaders[index].wFlags & HDR_ISREQUEST))
4564             continue;
4565
4566         if (requested_index == 0)
4567             break;
4568         requested_index --;
4569     }
4570
4571     if (index >= lpwhr->nCustHeaders)
4572         index = -1;
4573
4574     TRACE("Return: %d\n", index);
4575     return index;
4576 }
4577
4578
4579 /***********************************************************************
4580  *           HTTP_InsertCustomHeader (internal)
4581  *
4582  * Insert header into array
4583  *
4584  */
4585 static BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQW lpwhr, LPHTTPHEADERW lpHdr)
4586 {
4587     INT count;
4588     LPHTTPHEADERW lph = NULL;
4589     BOOL r = FALSE;
4590
4591     TRACE("--> %s: %s\n", debugstr_w(lpHdr->lpszField), debugstr_w(lpHdr->lpszValue));
4592     count = lpwhr->nCustHeaders + 1;
4593     if (count > 1)
4594         lph = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpwhr->pCustHeaders, sizeof(HTTPHEADERW) * count);
4595     else
4596         lph = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HTTPHEADERW) * count);
4597
4598     if (NULL != lph)
4599     {
4600         lpwhr->pCustHeaders = lph;
4601         lpwhr->pCustHeaders[count-1].lpszField = WININET_strdupW(lpHdr->lpszField);
4602         lpwhr->pCustHeaders[count-1].lpszValue = WININET_strdupW(lpHdr->lpszValue);
4603         lpwhr->pCustHeaders[count-1].wFlags = lpHdr->wFlags;
4604         lpwhr->pCustHeaders[count-1].wCount= lpHdr->wCount;
4605         lpwhr->nCustHeaders++;
4606         r = TRUE;
4607     }
4608     else
4609     {
4610         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
4611     }
4612
4613     return r;
4614 }
4615
4616
4617 /***********************************************************************
4618  *           HTTP_DeleteCustomHeader (internal)
4619  *
4620  * Delete header from array
4621  *  If this function is called, the indexs may change.
4622  */
4623 static BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQW lpwhr, DWORD index)
4624 {
4625     if( lpwhr->nCustHeaders <= 0 )
4626         return FALSE;
4627     if( index >= lpwhr->nCustHeaders )
4628         return FALSE;
4629     lpwhr->nCustHeaders--;
4630
4631     HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[index].lpszField);
4632     HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[index].lpszValue);
4633
4634     memmove( &lpwhr->pCustHeaders[index], &lpwhr->pCustHeaders[index+1],
4635              (lpwhr->nCustHeaders - index)* sizeof(HTTPHEADERW) );
4636     memset( &lpwhr->pCustHeaders[lpwhr->nCustHeaders], 0, sizeof(HTTPHEADERW) );
4637
4638     return TRUE;
4639 }
4640
4641
4642 /***********************************************************************
4643  *           HTTP_VerifyValidHeader (internal)
4644  *
4645  * Verify the given header is not invalid for the given http request
4646  *
4647  */
4648 static BOOL HTTP_VerifyValidHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field)
4649 {
4650     /* Accept-Encoding is stripped from HTTP/1.0 requests. It is invalid */
4651     if (!strcmpW(lpwhr->lpszVersion, g_szHttp1_0) && !strcmpiW(field, szAccept_Encoding))
4652         return FALSE;
4653
4654     return TRUE;
4655 }
4656
4657 /***********************************************************************
4658  *          IsHostInProxyBypassList (@)
4659  *
4660  * Undocumented
4661  *
4662  */
4663 BOOL WINAPI IsHostInProxyBypassList(DWORD flags, LPCSTR szHost, DWORD length)
4664 {
4665    FIXME("STUB: flags=%d host=%s length=%d\n",flags,szHost,length);
4666    return FALSE;
4667 }