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  *
   9  * Ulrich Czekalla
  10  * Aric Stewart
  11  * David Hammerton
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26  */
  27
  28 #include "config.h"
  29
  30 #include <sys/types.h>
  31 #ifdef HAVE_SYS_SOCKET_H
  32 # include <sys/socket.h>
  33 #endif
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #ifdef HAVE_UNISTD_H
  38 # include <unistd.h>
  39 #endif
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <time.h>
  43
  44 #include "windef.h"
  45 #include "winbase.h"
  46 #include "wininet.h"
  47 #include "winreg.h"
  48 #include "winerror.h"
  49 #define NO_SHLWAPI_STREAM
  50 #include "shlwapi.h"
  51
  52 #include "internet.h"
  53 #include "wine/debug.h"
  54 #include "wine/unicode.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
  57
  58 static const WCHAR g_szHttp[] = {' ','H','T','T','P','/','1','.','0',0 };
  59 static const WCHAR g_szHost[] = {'\r','\n','H','o','s','t',':',' ',0 };
  60 static const WCHAR g_szReferer[] = {'R','e','f','e','r','e','r',0};
  61 static const WCHAR g_szAccept[] = {'A','c','c','e','p','t',0};
  62 static const WCHAR g_szUserAgent[] = {'U','s','e','r','-','A','g','e','n','t',0};
  63
  64
  65 #define HTTPHEADER g_szHttp
  66 #define HTTPHOSTHEADER g_szHost
  67 #define MAXHOSTNAME 100
  68 #define MAX_FIELD_VALUE_LEN 256
  69 #define MAX_FIELD_LEN 256
  70
  71 #define HTTP_REFERER    g_szReferer
  72 #define HTTP_ACCEPT     g_szAccept
  73 #define HTTP_USERAGENT  g_szUserAgent
  74
  75 #define HTTP_ADDHDR_FLAG_ADD                            0x20000000
  76 #define HTTP_ADDHDR_FLAG_ADD_IF_NEW                     0x10000000
  77 #define HTTP_ADDHDR_FLAG_COALESCE                       0x40000000
  78 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA            0x40000000
  79 #define HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON        0x01000000
  80 #define HTTP_ADDHDR_FLAG_REPLACE                        0x80000000
  81 #define HTTP_ADDHDR_FLAG_REQ                            0x02000000
  82
  83
  84 BOOL HTTP_OpenConnection(LPWININETHTTPREQW lpwhr);
  85 int HTTP_WriteDataToStream(LPWININETHTTPREQW lpwhr,
  86         void *Buffer, int BytesToWrite);
  87 int HTTP_ReadDataFromStream(LPWININETHTTPREQW lpwhr,
  88         void *Buffer, int BytesToRead);
  89 BOOL HTTP_GetResponseHeaders(LPWININETHTTPREQW lpwhr);
  90 BOOL HTTP_ProcessHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field, LPCWSTR value, DWORD dwModifier);
  91 void HTTP_CloseConnection(LPWININETHTTPREQW lpwhr);
  92 BOOL HTTP_InterpretHttpHeader(LPWSTR buffer, LPWSTR field, INT fieldlen, LPWSTR value, INT valuelen);
  93 INT HTTP_GetStdHeaderIndex(LPCWSTR lpszField);
  94 BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQW lpwhr, LPHTTPHEADERW lpHdr);
  95 INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQW lpwhr, LPCWSTR lpszField);
  96 BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQW lpwhr, INT index);
  97
  98 /***********************************************************************
  99  *           HttpAddRequestHeadersW (WININET.@)
 100  *
 101  * Adds one or more HTTP header to the request handler
 102  *
 103  * RETURNS
 104  *    TRUE  on success
 105  *    FALSE on failure
 106  *
 107  */
 108 BOOL WINAPI HttpAddRequestHeadersW(HINTERNET hHttpRequest,
 109         LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
 110 {
 111     LPWSTR lpszStart;
 112     LPWSTR lpszEnd;
 113     LPWSTR buffer;
 114     WCHAR value[MAX_FIELD_VALUE_LEN], field[MAX_FIELD_LEN];
 115     BOOL bSuccess = FALSE;
 116     LPWININETHTTPREQW lpwhr;
 117
 118     TRACE("%p, %s, %li, %li\n", hHttpRequest, debugstr_w(lpszHeader), dwHeaderLength,
 119           dwModifier);
 120
 121     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
 122
 123     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
 124     {
 125         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 126         return FALSE;
 127     }
 128
 129     if (!lpszHeader)
 130       return TRUE;
 131
 132     TRACE("copying header: %s\n", debugstr_w(lpszHeader));
 133     buffer = WININET_strdupW(lpszHeader);
 134     lpszStart = buffer;
 135
 136     do
 137     {
 138         lpszEnd = lpszStart;
 139
 140         while (*lpszEnd != '\0')
 141         {
 142             if (*lpszEnd == '\r' && *(lpszEnd + 1) == '\n')
 143                  break;
 144             lpszEnd++;
 145         }
 146
 147         if (*lpszEnd == '\0')
 148             break;
 149
 150         *lpszEnd = '\0';
 151
 152         TRACE("interpreting header %s\n", debugstr_w(lpszStart));
 153         if (HTTP_InterpretHttpHeader(lpszStart, field, MAX_FIELD_LEN, value, MAX_FIELD_VALUE_LEN))
 154             bSuccess = HTTP_ProcessHeader(lpwhr, field, value, dwModifier | HTTP_ADDHDR_FLAG_REQ);
 155
 156         lpszStart = lpszEnd + 2; /* Jump over \0\n */
 157
 158     } while (bSuccess);
 159
 160     HeapFree(GetProcessHeap(), 0, buffer);
 161     return bSuccess;
 162 }
 163
 164 /***********************************************************************
 165  *           HttpAddRequestHeadersA (WININET.@)
 166  *
 167  * Adds one or more HTTP header to the request handler
 168  *
 169  * RETURNS
 170  *    TRUE  on success
 171  *    FALSE on failure
 172  *
 173  */
 174 BOOL WINAPI HttpAddRequestHeadersA(HINTERNET hHttpRequest,
 175         LPCSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
 176 {
 177     DWORD len;
 178     LPWSTR hdr;
 179     BOOL r;
 180
 181     TRACE("%p, %s, %li, %li\n", hHttpRequest, debugstr_a(lpszHeader), dwHeaderLength,
 182           dwModifier);
 183
 184     len = MultiByteToWideChar( CP_ACP, 0, lpszHeader, dwHeaderLength, NULL, 0 );
 185     hdr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 186     MultiByteToWideChar( CP_ACP, 0, lpszHeader, dwHeaderLength, hdr, len );
 187     if( dwHeaderLength != -1 )
 188         dwHeaderLength = len;
 189
 190     r = HttpAddRequestHeadersW( hHttpRequest, hdr, dwHeaderLength, dwModifier );
 191
 192     HeapFree( GetProcessHeap(), 0, hdr );
 193
 194     return r;
 195 }
 196
 197 /***********************************************************************
 198  *           HttpEndRequestA (WININET.@)
 199  *
 200  * Ends an HTTP request that was started by HttpSendRequestEx
 201  *
 202  * RETURNS
 203  *    TRUE      if successful
 204  *    FALSE     on failure
 205  *
 206  */
 207 BOOL WINAPI HttpEndRequestA(HINTERNET hRequest, LPINTERNET_BUFFERSA lpBuffersOut,
 208           DWORD dwFlags, DWORD dwContext)
 209 {
 210   FIXME("stub\n");
 211   return FALSE;
 212 }
 213
 214 /***********************************************************************
 215  *           HttpEndRequestW (WININET.@)
 216  *
 217  * Ends an HTTP request that was started by HttpSendRequestEx
 218  *
 219  * RETURNS
 220  *    TRUE      if successful
 221  *    FALSE     on failure
 222  *
 223  */
 224 BOOL WINAPI HttpEndRequestW(HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersOut,
 225           DWORD dwFlags, DWORD dwContext)
 226 {
 227   FIXME("stub\n");
 228   return FALSE;
 229 }
 230
 231 /***********************************************************************
 232  *           HttpOpenRequestW (WININET.@)
 233  *
 234  * Open a HTTP request handle
 235  *
 236  * RETURNS
 237  *    HINTERNET  a HTTP request handle on success
 238  *    NULL       on failure
 239  *
 240  */
 241 HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession,
 242         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
 243         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
 244         DWORD dwFlags, DWORD dwContext)
 245 {
 246     LPWININETHTTPSESSIONW lpwhs;
 247     LPWININETAPPINFOW hIC = NULL;
 248     HINTERNET handle = NULL;
 249
 250     TRACE("(%p, %s, %s, %s, %s, %p, %08lx, %08lx)\n", hHttpSession,
 251           debugstr_w(lpszVerb), debugstr_w(lpszObjectName),
 252           debugstr_w(lpszVersion), debugstr_w(lpszReferrer), lpszAcceptTypes,
 253           dwFlags, dwContext);
 254     if(lpszAcceptTypes!=NULL)
 255     {
 256         int i;
 257         for(i=0;lpszAcceptTypes[i]!=NULL;i++)
 258             TRACE("\taccept type: %s\n",debugstr_w(lpszAcceptTypes[i]));
 259     }
 260
 261     lpwhs = (LPWININETHTTPSESSIONW) WININET_GetObject( hHttpSession );
 262     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
 263     {
 264         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 265         return NULL;
 266     }
 267     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
 268
 269     /*
 270      * My tests seem to show that the windows version does not
 271      * become asynchronous until after this point. And anyhow
 272      * if this call was asynchronous then how would you get the
 273      * necessary HINTERNET pointer returned by this function.
 274      *
 275      * I am leaving this here just in case I am wrong
 276      *
 277      * if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 278      */
 279     if (0)
 280     {
 281         WORKREQUEST workRequest;
 282         struct WORKREQ_HTTPOPENREQUESTW *req;
 283
 284         workRequest.asyncall = HTTPOPENREQUESTW;
 285         workRequest.handle = hHttpSession;
 286         req = &workRequest.u.HttpOpenRequestW;
 287         req->lpszVerb = WININET_strdupW(lpszVerb);
 288         req->lpszObjectName = WININET_strdupW(lpszObjectName);
 289         if (lpszVersion)
 290             req->lpszVersion = WININET_strdupW(lpszVersion);
 291         else
 292             req->lpszVersion = 0;
 293         if (lpszReferrer)
 294             req->lpszReferrer = WININET_strdupW(lpszReferrer);
 295         else
 296             req->lpszReferrer = 0;
 297         req->lpszAcceptTypes = lpszAcceptTypes;
 298         req->dwFlags = dwFlags;
 299         req->dwContext = dwContext;
 300
 301         INTERNET_AsyncCall(&workRequest);
 302     }
 303     else
 304     {
 305         handle = HTTP_HttpOpenRequestW(hHttpSession, lpszVerb, lpszObjectName,
 306                                               lpszVersion, lpszReferrer, lpszAcceptTypes,
 307                                               dwFlags, dwContext);
 308     }
 309     TRACE("returning %p\n", handle);
 310     return handle;
 311 }
 312
 313
 314 /***********************************************************************
 315  *           HttpOpenRequestA (WININET.@)
 316  *
 317  * Open a HTTP request handle
 318  *
 319  * RETURNS
 320  *    HINTERNET  a HTTP request handle on success
 321  *    NULL       on failure
 322  *
 323  */
 324 HINTERNET WINAPI HttpOpenRequestA(HINTERNET hHttpSession,
 325         LPCSTR lpszVerb, LPCSTR lpszObjectName, LPCSTR lpszVersion,
 326         LPCSTR lpszReferrer , LPCSTR *lpszAcceptTypes,
 327         DWORD dwFlags, DWORD dwContext)
 328 {
 329     LPWSTR szVerb = NULL, szObjectName = NULL;
 330     LPWSTR szVersion = NULL, szReferrer = NULL, *szAcceptTypes = NULL;
 331     INT len;
 332     INT acceptTypesCount;
 333     HINTERNET rc = FALSE;
 334     TRACE("(%p, %s, %s, %s, %s, %p, %08lx, %08lx)\n", hHttpSession,
 335           debugstr_a(lpszVerb), debugstr_a(lpszObjectName),
 336           debugstr_a(lpszVersion), debugstr_a(lpszReferrer), lpszAcceptTypes,
 337           dwFlags, dwContext);
 338
 339     if (lpszVerb)
 340     {
 341         len = MultiByteToWideChar(CP_ACP, 0, lpszVerb, -1, NULL, 0 );
 342         szVerb = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
 343         if ( !szVerb )
 344             goto end;
 345         MultiByteToWideChar(CP_ACP, 0, lpszVerb, -1, szVerb, len);
 346     }
 347
 348     if (lpszObjectName)
 349     {
 350         len = MultiByteToWideChar(CP_ACP, 0, lpszObjectName, -1, NULL, 0 );
 351         szObjectName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
 352         if ( !szObjectName )
 353             goto end;
 354         MultiByteToWideChar(CP_ACP, 0, lpszObjectName, -1, szObjectName, len );
 355     }
 356
 357     if (lpszVersion)
 358     {
 359         len = MultiByteToWideChar(CP_ACP, 0, lpszVersion, -1, NULL, 0 );
 360         szVersion = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 361         if ( !szVersion )
 362             goto end;
 363         MultiByteToWideChar(CP_ACP, 0, lpszVersion, -1, szVersion, len );
 364     }
 365
 366     if (lpszReferrer)
 367     {
 368         len = MultiByteToWideChar(CP_ACP, 0, lpszReferrer, -1, NULL, 0 );
 369         szReferrer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 370         if ( !szReferrer )
 371             goto end;
 372         MultiByteToWideChar(CP_ACP, 0, lpszReferrer, -1, szReferrer, len );
 373     }
 374
 375     acceptTypesCount = 0;
 376     if (lpszAcceptTypes)
 377     {
 378         /* find out how many there are */
 379         while (lpszAcceptTypes[acceptTypesCount])
 380             acceptTypesCount++;
 381         szAcceptTypes = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR *) * (acceptTypesCount+1));
 382         acceptTypesCount = 0;
 383         while (lpszAcceptTypes[acceptTypesCount])
 384         {
 385             len = MultiByteToWideChar(CP_ACP, 0, lpszAcceptTypes[acceptTypesCount],
 386                                 -1, NULL, 0 );
 387             szAcceptTypes[acceptTypesCount] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 388             if (!szAcceptTypes[acceptTypesCount] )
 389                 goto end;
 390             MultiByteToWideChar(CP_ACP, 0, lpszAcceptTypes[acceptTypesCount],
 391                                 -1, szAcceptTypes[acceptTypesCount], len );
 392             acceptTypesCount++;
 393         }
 394         szAcceptTypes[acceptTypesCount] = NULL;
 395     }
 396     else szAcceptTypes = 0;
 397
 398     rc = HttpOpenRequestW(hHttpSession, szVerb, szObjectName,
 399                           szVersion, szReferrer,
 400                           (LPCWSTR*)szAcceptTypes, dwFlags, dwContext);
 401
 402 end:
 403     if (szAcceptTypes)
 404     {
 405         acceptTypesCount = 0;
 406         while (szAcceptTypes[acceptTypesCount])
 407         {
 408             HeapFree(GetProcessHeap(), 0, szAcceptTypes[acceptTypesCount]);
 409             acceptTypesCount++;
 410         }
 411         HeapFree(GetProcessHeap(), 0, szAcceptTypes);
 412     }
 413     if (szReferrer) HeapFree(GetProcessHeap(), 0, szReferrer);
 414     if (szVersion) HeapFree(GetProcessHeap(), 0, szVersion);
 415     if (szObjectName) HeapFree(GetProcessHeap(), 0, szObjectName);
 416     if (szVerb) HeapFree(GetProcessHeap(), 0, szVerb);
 417
 418     return rc;
 419 }
 420
 421 /***********************************************************************
 422  *  HTTP_Base64
 423  */
 424 static UINT HTTP_Base64( LPCWSTR bin, LPWSTR base64 )
 425 {
 426     UINT n = 0, x;
 427     static LPSTR HTTP_Base64Enc =
 428         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 429
 430     while( bin[0] )
 431     {
 432         /* first 6 bits, all from bin[0] */
 433         base64[n++] = HTTP_Base64Enc[(bin[0] & 0xfc) >> 2];
 434         x = (bin[0] & 3) << 4;
 435
 436         /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
 437         if( !bin[1] )
 438         {
 439             base64[n++] = HTTP_Base64Enc[x];
 440             base64[n++] = '=';
 441             base64[n++] = '=';
 442             break;
 443         }
 444         base64[n++] = HTTP_Base64Enc[ x | ( (bin[1]&0xf0) >> 4 ) ];
 445         x = ( bin[1] & 0x0f ) << 2;
 446
 447         /* next 6 bits 4 from bin[1] and 2 from bin[2] */
 448         if( !bin[2] )
 449         {
 450             base64[n++] = HTTP_Base64Enc[x];
 451             base64[n++] = '=';
 452             break;
 453         }
 454         base64[n++] = HTTP_Base64Enc[ x | ( (bin[2]&0xc0 ) >> 6 ) ];
 455
 456         /* last 6 bits, all from bin [2] */
 457         base64[n++] = HTTP_Base64Enc[ bin[2] & 0x3f ];
 458         bin += 3;
 459     }
 460     base64[n] = 0;
 461     return n;
 462 }
 463
 464 /***********************************************************************
 465  *  HTTP_EncodeBasicAuth
 466  *
 467  *  Encode the basic authentication string for HTTP 1.1
 468  */
 469 static LPWSTR HTTP_EncodeBasicAuth( LPCWSTR username, LPCWSTR password)
 470 {
 471     UINT len;
 472     LPWSTR in, out;
 473     static const WCHAR szBasic[] = {'B','a','s','i','c',' ',0};
 474     static const WCHAR szColon[] = {':',0};
 475
 476     len = lstrlenW( username ) + 1 + lstrlenW ( password ) + 1;
 477     in = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 478     if( !in )
 479         return NULL;
 480
 481     len = lstrlenW(szBasic) +
 482           (lstrlenW( username ) + 1 + lstrlenW ( password ))*2 + 1 + 1;
 483     out = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 484     if( out )
 485     {
 486         lstrcpyW( in, username );
 487         lstrcatW( in, szColon );
 488         lstrcatW( in, password );
 489         lstrcpyW( out, szBasic );
 490         HTTP_Base64( in, &out[strlenW(out)] );
 491     }
 492     HeapFree( GetProcessHeap(), 0, in );
 493
 494     return out;
 495 }
 496
 497 /***********************************************************************
 498  *  HTTP_InsertProxyAuthorization
 499  *
 500  *   Insert the basic authorization field in the request header
 501  */
 502 BOOL HTTP_InsertProxyAuthorization( LPWININETHTTPREQW lpwhr,
 503                        LPCWSTR username, LPCWSTR password )
 504 {
 505     HTTPHEADERW hdr;
 506     INT index;
 507     static const WCHAR szProxyAuthorization[] = {
 508         'P','r','o','x','y','-','A','u','t','h','o','r','i','z','a','t','i','o','n',0 };
 509
 510     hdr.lpszValue = HTTP_EncodeBasicAuth( username, password );
 511     hdr.lpszField = (WCHAR *)szProxyAuthorization;
 512     hdr.wFlags = HDR_ISREQUEST;
 513     hdr.wCount = 0;
 514     if( !hdr.lpszValue )
 515         return FALSE;
 516
 517     TRACE("Inserting %s = %s\n",
 518           debugstr_w( hdr.lpszField ), debugstr_w( hdr.lpszValue ) );
 519
 520     /* remove the old proxy authorization header */
 521     index = HTTP_GetCustomHeaderIndex( lpwhr, hdr.lpszField );
 522     if( index >=0 )
 523         HTTP_DeleteCustomHeader( lpwhr, index );
 524
 525     HTTP_InsertCustomHeader(lpwhr, &hdr);
 526     HeapFree( GetProcessHeap(), 0, hdr.lpszValue );
 527
 528     return TRUE;
 529 }
 530
 531 /***********************************************************************
 532  *           HTTP_DealWithProxy
 533  */
 534 static BOOL HTTP_DealWithProxy( LPWININETAPPINFOW hIC,
 535     LPWININETHTTPSESSIONW lpwhs, LPWININETHTTPREQW lpwhr)
 536 {
 537     WCHAR buf[MAXHOSTNAME];
 538     WCHAR proxy[MAXHOSTNAME + 15]; /* 15 == "http://" + sizeof(port#) + ":/\0" */
 539     WCHAR* url;
 540     static const WCHAR szNul[] = { 0 };
 541     URL_COMPONENTSW UrlComponents;
 542     static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/',0 }, szSlash[] = { '/',0 } ;
 543     static const WCHAR szFormat1[] = { 'h','t','t','p',':','/','/','%','s',':','%','d',0 };
 544     static const WCHAR szFormat2[] = { 'h','t','t','p',':','/','/','%','s',':','%','d',0 };
 545     int len;
 546
 547     memset( &UrlComponents, 0, sizeof UrlComponents );
 548     UrlComponents.dwStructSize = sizeof UrlComponents;
 549     UrlComponents.lpszHostName = buf;
 550     UrlComponents.dwHostNameLength = MAXHOSTNAME;
 551
 552     if( CSTR_EQUAL != CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
 553                                  buf,strlenW(szHttp),szHttp,strlenW(szHttp)) )
 554         sprintfW(proxy, szFormat1, hIC->lpszProxy);
 555     else
 556         strcpyW(proxy,buf);
 557     if( !InternetCrackUrlW(proxy, 0, 0, &UrlComponents) )
 558         return FALSE;
 559     if( UrlComponents.dwHostNameLength == 0 )
 560         return FALSE;
 561
 562     if( !lpwhr->lpszPath )
 563         lpwhr->lpszPath = (LPWSTR)szNul;
 564     TRACE("server='%s' path='%s'\n",
 565           debugstr_w(lpwhs->lpszServerName), debugstr_w(lpwhr->lpszPath));
 566     /* for constant 15 see above */
 567     len = strlenW(lpwhs->lpszServerName) + strlenW(lpwhr->lpszPath) + 15;
 568     url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 569
 570     if(UrlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
 571         UrlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
 572
 573     sprintfW(url, szFormat2, lpwhs->lpszServerName, lpwhs->nServerPort);
 574
 575     if( lpwhr->lpszPath[0] != '/' )
 576         strcatW( url, szSlash );
 577     strcatW(url, lpwhr->lpszPath);
 578     if(lpwhr->lpszPath != szNul)
 579         HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
 580     lpwhr->lpszPath = url;
 581     /* FIXME: Do I have to free lpwhs->lpszServerName here ? */
 582     lpwhs->lpszServerName = WININET_strdupW(UrlComponents.lpszHostName);
 583     lpwhs->nServerPort = UrlComponents.nPort;
 584
 585     return TRUE;
 586 }
 587
 588 /***********************************************************************
 589  *           HTTP_HttpOpenRequestW (internal)
 590  *
 591  * Open a HTTP request handle
 592  *
 593  * RETURNS
 594  *    HINTERNET  a HTTP request handle on success
 595  *    NULL       on failure
 596  *
 597  */
 598 HINTERNET WINAPI HTTP_HttpOpenRequestW(HINTERNET hHttpSession,
 599         LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion,
 600         LPCWSTR lpszReferrer , LPCWSTR *lpszAcceptTypes,
 601         DWORD dwFlags, DWORD dwContext)
 602 {
 603     LPWININETHTTPSESSIONW lpwhs;
 604     LPWININETAPPINFOW hIC = NULL;
 605     LPWININETHTTPREQW lpwhr;
 606     LPWSTR lpszCookies;
 607     LPWSTR lpszUrl = NULL;
 608     DWORD nCookieSize;
 609     HINTERNET handle;
 610     static const WCHAR szUrlForm[] = {'h','t','t','p',':','/','/','%','s',0};
 611     DWORD len;
 612
 613     TRACE("--> \n");
 614
 615     lpwhs = (LPWININETHTTPSESSIONW) WININET_GetObject( hHttpSession );
 616     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
 617     {
 618         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 619         return NULL;
 620     }
 621
 622     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
 623
 624     lpwhr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPREQW));
 625     if (NULL == lpwhr)
 626     {
 627         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 628         return NULL;
 629     }
 630     handle = WININET_AllocHandle( &lpwhr->hdr );
 631     if (NULL == handle)
 632     {
 633         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 634         HeapFree( GetProcessHeap(), 0, lpwhr );
 635         return NULL;
 636     }
 637
 638     lpwhr->hdr.htype = WH_HHTTPREQ;
 639     lpwhr->hdr.lpwhparent = &lpwhs->hdr;
 640     lpwhr->hdr.dwFlags = dwFlags;
 641     lpwhr->hdr.dwContext = dwContext;
 642     NETCON_init(&lpwhr->netConnection, dwFlags & INTERNET_FLAG_SECURE);
 643
 644     if (NULL != lpszObjectName && strlenW(lpszObjectName)) {
 645         HRESULT rc;
 646
 647         len = 0;
 648         rc = UrlEscapeW(lpszObjectName, NULL, &len, URL_ESCAPE_SPACES_ONLY);
 649         if (rc != E_POINTER)
 650             len = strlenW(lpszObjectName)+1;
 651         lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 652         rc = UrlEscapeW(lpszObjectName, lpwhr->lpszPath, &len,
 653                    URL_ESCAPE_SPACES_ONLY);
 654         if (rc)
 655         {
 656             ERR("Unable to escape string!(%s) (%ld)\n",debugstr_w(lpszObjectName),rc);
 657             strcpyW(lpwhr->lpszPath,lpszObjectName);
 658         }
 659     }
 660
 661     if (NULL != lpszReferrer && strlenW(lpszReferrer))
 662         HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpszReferrer, HTTP_ADDHDR_FLAG_COALESCE);
 663
 664     if(lpszAcceptTypes!=NULL)
 665     {
 666         int i;
 667         for(i=0;lpszAcceptTypes[i]!=NULL;i++)
 668             HTTP_ProcessHeader(lpwhr, HTTP_ACCEPT, lpszAcceptTypes[i], HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_REQ|HTTP_ADDHDR_FLAG_ADD_IF_NEW);
 669     }
 670
 671     if (NULL == lpszVerb)
 672     {
 673         static const WCHAR szGet[] = {'G','E','T',0};
 674         lpwhr->lpszVerb = WININET_strdupW(szGet);
 675     }
 676     else if (strlenW(lpszVerb))
 677         lpwhr->lpszVerb = WININET_strdupW(lpszVerb);
 678
 679     if (NULL != lpszReferrer && strlenW(lpszReferrer))
 680     {
 681         WCHAR buf[MAXHOSTNAME];
 682         URL_COMPONENTSW UrlComponents;
 683
 684         memset( &UrlComponents, 0, sizeof UrlComponents );
 685         UrlComponents.dwStructSize = sizeof UrlComponents;
 686         UrlComponents.lpszHostName = buf;
 687         UrlComponents.dwHostNameLength = MAXHOSTNAME;
 688
 689         InternetCrackUrlW(lpszReferrer, 0, 0, &UrlComponents);
 690         if (strlenW(UrlComponents.lpszHostName))
 691             lpwhr->lpszHostName = WININET_strdupW(UrlComponents.lpszHostName);
 692     } else {
 693         lpwhr->lpszHostName = WININET_strdupW(lpwhs->lpszServerName);
 694     }
 695     if (NULL != hIC->lpszProxy && hIC->lpszProxy[0] != 0)
 696         HTTP_DealWithProxy( hIC, lpwhs, lpwhr );
 697
 698     if (hIC->lpszAgent)
 699     {
 700         WCHAR *agent_header;
 701         static const WCHAR user_agent[] = {'U','s','e','r','-','A','g','e','n','t',':',' ','%','s','\r','\n',0 };
 702
 703         len = strlenW(hIC->lpszAgent) + strlenW(user_agent);
 704         agent_header = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 705         sprintfW(agent_header, user_agent, hIC->lpszAgent );
 706
 707         HttpAddRequestHeadersW(handle, agent_header, strlenW(agent_header),
 708                                HTTP_ADDREQ_FLAG_ADD);
 709         HeapFree(GetProcessHeap(), 0, agent_header);
 710     }
 711
 712     len = strlenW(lpwhr->lpszHostName) + strlenW(szUrlForm);
 713     lpszUrl = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 714     sprintfW( lpszUrl, szUrlForm, lpwhr->lpszHostName );
 715
 716     if (InternetGetCookieW(lpszUrl, NULL, NULL, &nCookieSize))
 717     {
 718         int cnt = 0;
 719         static const WCHAR szCookie[] = {'C','o','o','k','i','e',':',' ',0};
 720         static const WCHAR szcrlf[] = {'\r','\n',0};
 721
 722         lpszCookies = HeapAlloc(GetProcessHeap(), 0, (nCookieSize + 1 + 8)*sizeof(WCHAR));
 723
 724         cnt += sprintfW(lpszCookies, szCookie);
 725         InternetGetCookieW(lpszUrl, NULL, lpszCookies + cnt, &nCookieSize);
 726         strcatW(lpszCookies, szcrlf);
 727
 728         HttpAddRequestHeadersW(handle, lpszCookies, strlenW(lpszCookies),
 729                                HTTP_ADDREQ_FLAG_ADD);
 730         HeapFree(GetProcessHeap(), 0, lpszCookies);
 731     }
 732     HeapFree(GetProcessHeap(), 0, lpszUrl);
 733
 734
 735
 736     if (hIC->lpfnStatusCB)
 737     {
 738         INTERNET_ASYNC_RESULT iar;
 739
 740         iar.dwResult = (DWORD)handle;
 741         iar.dwError = ERROR_SUCCESS;
 742
 743         SendAsyncCallback(hIC, hHttpSession, dwContext,
 744                       INTERNET_STATUS_HANDLE_CREATED, &iar,
 745                       sizeof(INTERNET_ASYNC_RESULT));
 746     }
 747
 748     /*
 749      * A STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on windows
 750      */
 751
 752     /*
 753      * According to my tests. The name is not resolved until a request is Opened
 754      */
 755     SendAsyncCallback(hIC, hHttpSession, dwContext,
 756                       INTERNET_STATUS_RESOLVING_NAME,
 757                       lpwhs->lpszServerName,
 758                       strlenW(lpwhs->lpszServerName)+1);
 759     if (!GetAddress(lpwhs->lpszServerName, lpwhs->nServerPort,
 760                     &lpwhs->phostent, &lpwhs->socketAddress))
 761     {
 762         INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
 763         return NULL;
 764     }
 765
 766     SendAsyncCallback(hIC, hHttpSession, lpwhr->hdr.dwContext,
 767                       INTERNET_STATUS_NAME_RESOLVED,
 768                       &(lpwhs->socketAddress),
 769                       sizeof(struct sockaddr_in));
 770
 771     TRACE("<-- %p\n", handle);
 772     return handle;
 773 }
 774
 775
 776 /***********************************************************************
 777  *           HttpQueryInfoW (WININET.@)
 778  *
 779  * Queries for information about an HTTP request
 780  *
 781  * RETURNS
 782  *    TRUE  on success
 783  *    FALSE on failure
 784  *
 785  */
 786 BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel,
 787         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
 788 {
 789     LPHTTPHEADERW lphttpHdr = NULL;
 790     BOOL bSuccess = FALSE;
 791     LPWININETHTTPREQW lpwhr;
 792     static const WCHAR szFmt[] = { '%','s',':',' ','%','s','%','s',0 };
 793     static const WCHAR szcrlf[] = { '\r','\n',0 };
 794     static const WCHAR sznul[] = { 0 };
 795
 796     if (TRACE_ON(wininet)) {
 797 #define FE(x) { x, #x }
 798         static const wininet_flag_info query_flags[] = {
 799             FE(HTTP_QUERY_MIME_VERSION),
 800             FE(HTTP_QUERY_CONTENT_TYPE),
 801             FE(HTTP_QUERY_CONTENT_TRANSFER_ENCODING),
 802             FE(HTTP_QUERY_CONTENT_ID),
 803             FE(HTTP_QUERY_CONTENT_DESCRIPTION),
 804             FE(HTTP_QUERY_CONTENT_LENGTH),
 805             FE(HTTP_QUERY_CONTENT_LANGUAGE),
 806             FE(HTTP_QUERY_ALLOW),
 807             FE(HTTP_QUERY_PUBLIC),
 808             FE(HTTP_QUERY_DATE),
 809             FE(HTTP_QUERY_EXPIRES),
 810             FE(HTTP_QUERY_LAST_MODIFIED),
 811             FE(HTTP_QUERY_MESSAGE_ID),
 812             FE(HTTP_QUERY_URI),
 813             FE(HTTP_QUERY_DERIVED_FROM),
 814             FE(HTTP_QUERY_COST),
 815             FE(HTTP_QUERY_LINK),
 816             FE(HTTP_QUERY_PRAGMA),
 817             FE(HTTP_QUERY_VERSION),
 818             FE(HTTP_QUERY_STATUS_CODE),
 819             FE(HTTP_QUERY_STATUS_TEXT),
 820             FE(HTTP_QUERY_RAW_HEADERS),
 821             FE(HTTP_QUERY_RAW_HEADERS_CRLF),
 822             FE(HTTP_QUERY_CONNECTION),
 823             FE(HTTP_QUERY_ACCEPT),
 824             FE(HTTP_QUERY_ACCEPT_CHARSET),
 825             FE(HTTP_QUERY_ACCEPT_ENCODING),
 826             FE(HTTP_QUERY_ACCEPT_LANGUAGE),
 827             FE(HTTP_QUERY_AUTHORIZATION),
 828             FE(HTTP_QUERY_CONTENT_ENCODING),
 829             FE(HTTP_QUERY_FORWARDED),
 830             FE(HTTP_QUERY_FROM),
 831             FE(HTTP_QUERY_IF_MODIFIED_SINCE),
 832             FE(HTTP_QUERY_LOCATION),
 833             FE(HTTP_QUERY_ORIG_URI),
 834             FE(HTTP_QUERY_REFERER),
 835             FE(HTTP_QUERY_RETRY_AFTER),
 836             FE(HTTP_QUERY_SERVER),
 837             FE(HTTP_QUERY_TITLE),
 838             FE(HTTP_QUERY_USER_AGENT),
 839             FE(HTTP_QUERY_WWW_AUTHENTICATE),
 840             FE(HTTP_QUERY_PROXY_AUTHENTICATE),
 841             FE(HTTP_QUERY_ACCEPT_RANGES),
 842             FE(HTTP_QUERY_SET_COOKIE),
 843             FE(HTTP_QUERY_COOKIE),
 844             FE(HTTP_QUERY_REQUEST_METHOD),
 845             FE(HTTP_QUERY_REFRESH),
 846             FE(HTTP_QUERY_CONTENT_DISPOSITION),
 847             FE(HTTP_QUERY_AGE),
 848             FE(HTTP_QUERY_CACHE_CONTROL),
 849             FE(HTTP_QUERY_CONTENT_BASE),
 850             FE(HTTP_QUERY_CONTENT_LOCATION),
 851             FE(HTTP_QUERY_CONTENT_MD5),
 852             FE(HTTP_QUERY_CONTENT_RANGE),
 853             FE(HTTP_QUERY_ETAG),
 854             FE(HTTP_QUERY_HOST),
 855             FE(HTTP_QUERY_IF_MATCH),
 856             FE(HTTP_QUERY_IF_NONE_MATCH),
 857             FE(HTTP_QUERY_IF_RANGE),
 858             FE(HTTP_QUERY_IF_UNMODIFIED_SINCE),
 859             FE(HTTP_QUERY_MAX_FORWARDS),
 860             FE(HTTP_QUERY_PROXY_AUTHORIZATION),
 861             FE(HTTP_QUERY_RANGE),
 862             FE(HTTP_QUERY_TRANSFER_ENCODING),
 863             FE(HTTP_QUERY_UPGRADE),
 864             FE(HTTP_QUERY_VARY),
 865             FE(HTTP_QUERY_VIA),
 866             FE(HTTP_QUERY_WARNING),
 867             FE(HTTP_QUERY_CUSTOM)
 868         };
 869         static const wininet_flag_info modifier_flags[] = {
 870             FE(HTTP_QUERY_FLAG_REQUEST_HEADERS),
 871             FE(HTTP_QUERY_FLAG_SYSTEMTIME),
 872             FE(HTTP_QUERY_FLAG_NUMBER),
 873             FE(HTTP_QUERY_FLAG_COALESCE)
 874         };
 875 #undef FE
 876         DWORD info_mod = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
 877         DWORD info = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
 878         int i;
 879
 880         TRACE("(%p, 0x%08lx)--> %ld\n", hHttpRequest, dwInfoLevel, dwInfoLevel);
 881         TRACE("  Attribute:");
 882         for (i = 0; i < (sizeof(query_flags) / sizeof(query_flags[0])); i++) {
 883             if (query_flags[i].val == info) {
 884                 DPRINTF(" %s", query_flags[i].name);
 885                 break;
 886             }
 887         }
 888         if (i == (sizeof(query_flags) / sizeof(query_flags[0]))) {
 889             DPRINTF(" Unknown (%08lx)", info);
 890         }
 891
 892         DPRINTF(" Modifier:");
 893         for (i = 0; i < (sizeof(modifier_flags) / sizeof(modifier_flags[0])); i++) {
 894             if (modifier_flags[i].val & info_mod) {
 895                 DPRINTF(" %s", modifier_flags[i].name);
 896                 info_mod &= ~ modifier_flags[i].val;
 897             }
 898         }
 899
 900         if (info_mod) {
 901             DPRINTF(" Unknown (%08lx)", info_mod);
 902         }
 903         DPRINTF("\n");
 904     }
 905
 906     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
 907     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
 908     {
 909         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 910         goto lend;
 911     }
 912
 913     /* Find requested header structure */
 914     if ((dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK) == HTTP_QUERY_CUSTOM)
 915     {
 916         INT index = HTTP_GetCustomHeaderIndex(lpwhr, (LPWSTR)lpBuffer);
 917
 918         if (index < 0)
 919             goto lend;
 920
 921         lphttpHdr = &lpwhr->pCustHeaders[index];
 922     }
 923     else
 924     {
 925         INT index = dwInfoLevel & ~HTTP_QUERY_MODIFIER_FLAGS_MASK;
 926
 927         if (index == HTTP_QUERY_RAW_HEADERS_CRLF || index == HTTP_QUERY_RAW_HEADERS)
 928         {
 929             INT i, delim, size = 0, cnt = 0;
 930
 931             delim = index == HTTP_QUERY_RAW_HEADERS_CRLF ? 2 : 1;
 932
 933            /* Calculate length of custom reuqest headers */
 934            for (i = 0; i < lpwhr->nCustHeaders; i++)
 935            {
 936                if ((~lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST) && lpwhr->pCustHeaders[i].lpszField &&
 937                    lpwhr->pCustHeaders[i].lpszValue)
 938                {
 939                   size += strlenW(lpwhr->pCustHeaders[i].lpszField) +
 940                        strlenW(lpwhr->pCustHeaders[i].lpszValue) + delim + 2;
 941                }
 942            }
 943
 944            /* Calculate the length of stadard request headers */
 945            for (i = 0; i <= HTTP_QUERY_MAX; i++)
 946            {
 947               if ((~lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST) && lpwhr->StdHeaders[i].lpszField &&
 948                    lpwhr->StdHeaders[i].lpszValue)
 949               {
 950                  size += strlenW(lpwhr->StdHeaders[i].lpszField) +
 951                     strlenW(lpwhr->StdHeaders[i].lpszValue) + delim + 2;
 952               }
 953            }
 954            size += delim;
 955
 956            if (size + 1 > *lpdwBufferLength/sizeof(WCHAR))
 957            {
 958               *lpdwBufferLength = (size + 1) * sizeof(WCHAR);
 959               INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
 960               goto lend;
 961            }
 962
 963            /* Append standard request heades */
 964            for (i = 0; i <= HTTP_QUERY_MAX; i++)
 965            {
 966                if ((~lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST) &&
 967                                            lpwhr->StdHeaders[i].lpszField &&
 968                                            lpwhr->StdHeaders[i].lpszValue)
 969                {
 970                    cnt += sprintfW((WCHAR*)lpBuffer + cnt, szFmt,
 971                             lpwhr->StdHeaders[i].lpszField, lpwhr->StdHeaders[i].lpszValue,
 972                           index == HTTP_QUERY_RAW_HEADERS_CRLF ? szcrlf : sznul );
 973                }
 974             }
 975
 976             /* Append custom request heades */
 977             for (i = 0; i < lpwhr->nCustHeaders; i++)
 978             {
 979                 if ((~lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST) &&
 980                                                 lpwhr->pCustHeaders[i].lpszField &&
 981                                                 lpwhr->pCustHeaders[i].lpszValue)
 982                 {
 983                    cnt += sprintfW((WCHAR*)lpBuffer + cnt, szFmt,
 984                     lpwhr->pCustHeaders[i].lpszField, lpwhr->pCustHeaders[i].lpszValue,
 985                                         index == HTTP_QUERY_RAW_HEADERS_CRLF ? szcrlf : sznul);
 986                 }
 987             }
 988
 989             strcpyW((WCHAR*)lpBuffer + cnt, index == HTTP_QUERY_RAW_HEADERS_CRLF ? szcrlf : sznul);
 990
 991             *lpdwBufferLength = (cnt + delim) * sizeof(WCHAR);
 992             bSuccess = TRUE;
 993             goto lend;
 994         }
 995         else if (index >= 0 && index <= HTTP_QUERY_MAX && lpwhr->StdHeaders[index].lpszValue)
 996         {
 997             lphttpHdr = &lpwhr->StdHeaders[index];
 998         }
 999         else
1000             goto lend;
1001     }
1002
1003     /* Ensure header satisifies requested attributes */
1004     if ((dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) &&
1005             (~lphttpHdr->wFlags & HDR_ISREQUEST))
1006         goto lend;
1007
1008     /* coalesce value to reuqested type */
1009     if (dwInfoLevel & HTTP_QUERY_FLAG_NUMBER)
1010     {
1011         *(int *)lpBuffer = atoiW(lphttpHdr->lpszValue);
1012         bSuccess = TRUE;
1013
1014         TRACE(" returning number : %d\n", *(int *)lpBuffer);
1015     }
1016     else if (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME)
1017     {
1018         time_t tmpTime;
1019         struct tm tmpTM;
1020         SYSTEMTIME *STHook;
1021
1022         tmpTime = ConvertTimeString(lphttpHdr->lpszValue);
1023
1024         tmpTM = *gmtime(&tmpTime);
1025         STHook = (SYSTEMTIME *) lpBuffer;
1026         if(STHook==NULL)
1027             goto lend;
1028
1029         STHook->wDay = tmpTM.tm_mday;
1030         STHook->wHour = tmpTM.tm_hour;
1031         STHook->wMilliseconds = 0;
1032         STHook->wMinute = tmpTM.tm_min;
1033         STHook->wDayOfWeek = tmpTM.tm_wday;
1034         STHook->wMonth = tmpTM.tm_mon + 1;
1035         STHook->wSecond = tmpTM.tm_sec;
1036         STHook->wYear = tmpTM.tm_year;
1037
1038         bSuccess = TRUE;
1039
1040         TRACE(" returning time : %04d/%02d/%02d - %d - %02d:%02d:%02d.%02d\n",
1041               STHook->wYear, STHook->wMonth, STHook->wDay, STHook->wDayOfWeek,
1042               STHook->wHour, STHook->wMinute, STHook->wSecond, STHook->wMilliseconds);
1043     }
1044     else if (dwInfoLevel & HTTP_QUERY_FLAG_COALESCE)
1045     {
1046             if (*lpdwIndex >= lphttpHdr->wCount)
1047                 {
1048                 INTERNET_SetLastError(ERROR_HTTP_HEADER_NOT_FOUND);
1049                 }
1050             else
1051             {
1052             /* Copy strncpyW(lpBuffer, lphttpHdr[*lpdwIndex], len); */
1053             (*lpdwIndex)++;
1054             }
1055     }
1056     else
1057     {
1058         INT len = (strlenW(lphttpHdr->lpszValue) + 1) * sizeof(WCHAR);
1059
1060         if (len > *lpdwBufferLength)
1061         {
1062             *lpdwBufferLength = len;
1063             INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1064             goto lend;
1065         }
1066
1067         memcpy(lpBuffer, lphttpHdr->lpszValue, len);
1068         *lpdwBufferLength = len - sizeof(WCHAR);
1069         bSuccess = TRUE;
1070
1071         TRACE(" returning string : '%s'\n", debugstr_w(lpBuffer));
1072     }
1073
1074 lend:
1075     TRACE("%d <--\n", bSuccess);
1076     return bSuccess;
1077 }
1078
1079 /***********************************************************************
1080  *           HttpQueryInfoA (WININET.@)
1081  *
1082  * Queries for information about an HTTP request
1083  *
1084  * RETURNS
1085  *    TRUE  on success
1086  *    FALSE on failure
1087  *
1088  */
1089 BOOL WINAPI HttpQueryInfoA(HINTERNET hHttpRequest, DWORD dwInfoLevel,
1090         LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
1091 {
1092     BOOL result;
1093     DWORD len;
1094     WCHAR* bufferW;
1095
1096     if((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
1097        (dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME))
1098     {
1099         return HttpQueryInfoW( hHttpRequest, dwInfoLevel, lpBuffer,
1100                                lpdwBufferLength, lpdwIndex );
1101     }
1102
1103     len = (*lpdwBufferLength)*sizeof(WCHAR);
1104     bufferW = HeapAlloc( GetProcessHeap(), 0, len );
1105     result = HttpQueryInfoW( hHttpRequest, dwInfoLevel, bufferW,
1106                            &len, lpdwIndex );
1107     if( result )
1108     {
1109         len = WideCharToMultiByte( CP_ACP,0, bufferW, len / sizeof(WCHAR),
1110                                      lpBuffer, *lpdwBufferLength, NULL, NULL );
1111         *lpdwBufferLength = len * sizeof(WCHAR);
1112     }
1113     HeapFree(GetProcessHeap(), 0, bufferW );
1114
1115     return result;
1116 }
1117
1118 /***********************************************************************
1119  *           HttpSendRequestExA (WININET.@)
1120  *
1121  * Sends the specified request to the HTTP server and allows chunked
1122  * transfers
1123  */
1124 BOOL WINAPI HttpSendRequestExA(HINTERNET hRequest,
1125                                LPINTERNET_BUFFERSA lpBuffersIn,
1126                                LPINTERNET_BUFFERSA lpBuffersOut,
1127                                DWORD dwFlags, DWORD dwContext)
1128 {
1129   FIXME("(%p, %p, %p, %08lx, %08lx): stub\n", hRequest, lpBuffersIn,
1130         lpBuffersOut, dwFlags, dwContext);
1131   return FALSE;
1132 }
1133
1134 /***********************************************************************
1135  *           HttpSendRequestA (WININET.@)
1136  *
1137  * Sends the specified request to the HTTP server
1138  *
1139  * RETURNS
1140  *    TRUE  on success
1141  *    FALSE on failure
1142  *
1143  */
1144 BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
1145         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1146 {
1147     LPWININETHTTPREQW lpwhr;
1148     LPWININETHTTPSESSIONW lpwhs = NULL;
1149     LPWININETAPPINFOW hIC = NULL;
1150
1151     TRACE("%p, %p (%s), %li, %p, %li)\n", hHttpRequest,
1152             lpszHeaders, debugstr_w(lpszHeaders), dwHeaderLength, lpOptional, dwOptionalLength);
1153
1154     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
1155     if (NULL == lpwhr || lpwhr->hdr.htype != WH_HHTTPREQ)
1156     {
1157         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1158         return FALSE;
1159     }
1160
1161     lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
1162     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
1163     {
1164         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1165         return FALSE;
1166     }
1167
1168     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
1169     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT)
1170     {
1171         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1172         return FALSE;
1173     }
1174
1175     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1176     {
1177         WORKREQUEST workRequest;
1178         struct WORKREQ_HTTPSENDREQUESTW *req;
1179
1180         workRequest.asyncall = HTTPSENDREQUESTW;
1181         workRequest.handle = hHttpRequest;
1182         req = &workRequest.u.HttpSendRequestW;
1183         if (lpszHeaders)
1184             req->lpszHeader = WININET_strdupW(lpszHeaders);
1185         else
1186             req->lpszHeader = 0;
1187         req->dwHeaderLength = dwHeaderLength;
1188         req->lpOptional = lpOptional;
1189         req->dwOptionalLength = dwOptionalLength;
1190
1191         INTERNET_AsyncCall(&workRequest);
1192         /*
1193          * This is from windows.
1194          */
1195         SetLastError(ERROR_IO_PENDING);
1196         return 0;
1197     }
1198     else
1199     {
1200         return HTTP_HttpSendRequestW(hHttpRequest, lpszHeaders,
1201                 dwHeaderLength, lpOptional, dwOptionalLength);
1202     }
1203 }
1204
1205 /***********************************************************************
1206  *           HttpSendRequestW (WININET.@)
1207  *
1208  * Sends the specified request to the HTTP server
1209  *
1210  * RETURNS
1211  *    TRUE  on success
1212  *    FALSE on failure
1213  *
1214  */
1215 BOOL WINAPI HttpSendRequestA(HINTERNET hHttpRequest, LPCSTR lpszHeaders,
1216         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1217 {
1218     BOOL result;
1219     LPWSTR szHeaders=NULL;
1220     DWORD nLen=dwHeaderLength;
1221     if(lpszHeaders!=NULL)
1222     {
1223         nLen=MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,NULL,0);
1224         szHeaders=HeapAlloc(GetProcessHeap(),0,nLen*sizeof(WCHAR));
1225         MultiByteToWideChar(CP_ACP,0,lpszHeaders,dwHeaderLength,szHeaders,nLen);
1226     }
1227     result=HttpSendRequestW(hHttpRequest, szHeaders, nLen, lpOptional, dwOptionalLength);
1228     if(szHeaders!=NULL)
1229         HeapFree(GetProcessHeap(),0,szHeaders);
1230     return result;
1231 }
1232
1233 /***********************************************************************
1234  *           HTTP_HandleRedirect (internal)
1235  */
1236 static BOOL HTTP_HandleRedirect(LPWININETHTTPREQW lpwhr, LPCWSTR lpszUrl, LPCWSTR lpszHeaders,
1237                                 DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength)
1238 {
1239     LPWININETHTTPSESSIONW lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
1240     LPWININETAPPINFOW hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
1241     WCHAR path[2048];
1242     HINTERNET handle;
1243
1244     if(lpszUrl[0]=='/')
1245     {
1246         /* if it's an absolute path, keep the same session info */
1247         strcpyW(path,lpszUrl);
1248     }
1249     else if (NULL != hIC->lpszProxy && hIC->lpszProxy[0] != 0)
1250     {
1251         TRACE("Redirect through proxy\n");
1252         strcpyW(path,lpszUrl);
1253     }
1254     else
1255     {
1256         URL_COMPONENTSW urlComponents;
1257         WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
1258         WCHAR password[1024], extra[1024];
1259         urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
1260         urlComponents.lpszScheme = protocol;
1261         urlComponents.dwSchemeLength = 32;
1262         urlComponents.lpszHostName = hostName;
1263         urlComponents.dwHostNameLength = MAXHOSTNAME;
1264         urlComponents.lpszUserName = userName;
1265         urlComponents.dwUserNameLength = 1024;
1266         urlComponents.lpszPassword = password;
1267         urlComponents.dwPasswordLength = 1024;
1268         urlComponents.lpszUrlPath = path;
1269         urlComponents.dwUrlPathLength = 2048;
1270         urlComponents.lpszExtraInfo = extra;
1271         urlComponents.dwExtraInfoLength = 1024;
1272         if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
1273             return FALSE;
1274
1275         if (urlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
1276             urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
1277
1278 #if 0
1279         /*
1280          * This upsets redirects to binary files on sourceforge.net
1281          * and gives an html page instead of the target file
1282          * Examination of the HTTP request sent by native wininet.dll
1283          * reveals that it doesn't send a referrer in that case.
1284          * Maybe there's a flag that enables this, or maybe a referrer
1285          * shouldn't be added in case of a redirect.
1286          */
1287
1288         /* consider the current host as the referrer */
1289         if (NULL != lpwhs->lpszServerName && strlenW(lpwhs->lpszServerName))
1290             HTTP_ProcessHeader(lpwhr, HTTP_REFERER, lpwhs->lpszServerName,
1291                            HTTP_ADDHDR_FLAG_REQ|HTTP_ADDREQ_FLAG_REPLACE|
1292                            HTTP_ADDHDR_FLAG_ADD_IF_NEW);
1293 #endif
1294
1295         if (NULL != lpwhs->lpszServerName)
1296             HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
1297         lpwhs->lpszServerName = WININET_strdupW(hostName);
1298         if (NULL != lpwhs->lpszUserName)
1299             HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
1300         lpwhs->lpszUserName = WININET_strdupW(userName);
1301         lpwhs->nServerPort = urlComponents.nPort;
1302
1303         if (NULL != lpwhr->lpszHostName)
1304             HeapFree(GetProcessHeap(), 0, lpwhr->lpszHostName);
1305         lpwhr->lpszHostName=WININET_strdupW(hostName);
1306
1307         SendAsyncCallback(hIC, lpwhs, lpwhr->hdr.dwContext,
1308                       INTERNET_STATUS_RESOLVING_NAME,
1309                       lpwhs->lpszServerName,
1310                       strlenW(lpwhs->lpszServerName)+1);
1311
1312         if (!GetAddress(lpwhs->lpszServerName, lpwhs->nServerPort,
1313                     &lpwhs->phostent, &lpwhs->socketAddress))
1314         {
1315             INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
1316             return FALSE;
1317         }
1318
1319         SendAsyncCallback(hIC, lpwhs, lpwhr->hdr.dwContext,
1320                       INTERNET_STATUS_NAME_RESOLVED,
1321                       &(lpwhs->socketAddress),
1322                       sizeof(struct sockaddr_in));
1323
1324     }
1325
1326     if(lpwhr->lpszPath)
1327         HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
1328     lpwhr->lpszPath=NULL;
1329     if (strlenW(path))
1330     {
1331         DWORD needed = 0;
1332         HRESULT rc;
1333
1334         rc = UrlEscapeW(path, NULL, &needed, URL_ESCAPE_SPACES_ONLY);
1335         if (rc != E_POINTER)
1336             needed = strlenW(path)+1;
1337         lpwhr->lpszPath = HeapAlloc(GetProcessHeap(), 0, needed*sizeof(WCHAR));
1338         rc = UrlEscapeW(path, lpwhr->lpszPath, &needed,
1339                         URL_ESCAPE_SPACES_ONLY);
1340         if (rc)
1341         {
1342             ERR("Unable to escape string!(%s) (%ld)\n",debugstr_w(path),rc);
1343             strcpyW(lpwhr->lpszPath,path);
1344         }
1345     }
1346
1347     handle = WININET_FindHandle( &lpwhr->hdr );
1348     return HttpSendRequestW(handle, lpszHeaders, dwHeaderLength, lpOptional, dwOptionalLength);
1349 }
1350
1351 /***********************************************************************
1352  *           HTTP_HttpSendRequestW (internal)
1353  *
1354  * Sends the specified request to the HTTP server
1355  *
1356  * RETURNS
1357  *    TRUE  on success
1358  *    FALSE on failure
1359  *
1360  */
1361 BOOL WINAPI HTTP_HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders,
1362         DWORD dwHeaderLength, LPVOID lpOptional ,DWORD dwOptionalLength)
1363 {
1364     INT cnt;
1365     INT i;
1366     BOOL bSuccess = FALSE;
1367     LPWSTR requestString = NULL;
1368     LPWSTR lpszHeaders_r_n = NULL; /* lpszHeaders with atleast one pair of \r\n at the end */
1369     INT requestStringLen;
1370     INT responseLen;
1371     INT headerLength = 0;
1372     LPWININETHTTPREQW lpwhr;
1373     LPWININETHTTPSESSIONW lpwhs = NULL;
1374     LPWININETAPPINFOW hIC = NULL;
1375     BOOL loop_next = FALSE;
1376     int CustHeaderIndex;
1377
1378     TRACE("--> 0x%08lx\n", (ULONG)hHttpRequest);
1379
1380     /* Verify our tree of internet handles */
1381     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hHttpRequest );
1382     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
1383     {
1384         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1385         return FALSE;
1386     }
1387
1388     lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
1389     if (NULL == lpwhs ||  lpwhs->hdr.htype != WH_HHTTPSESSION)
1390     {
1391         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1392         return FALSE;
1393     }
1394
1395     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
1396     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT)
1397     {
1398         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1399         return FALSE;
1400     }
1401
1402     /* Clear any error information */
1403     INTERNET_SetLastError(0);
1404
1405
1406     /* We must have a verb */
1407     if (NULL == lpwhr->lpszVerb)
1408     {
1409             goto lend;
1410     }
1411
1412     /* if we are using optional stuff, we must add the fixed header of that option length */
1413     if (lpOptional && dwOptionalLength)
1414     {
1415         char contentLengthStr[sizeof("Content-Length: ") + 20 /* int */ + 2 /* \n\r */];
1416         sprintf(contentLengthStr, "Content-Length: %li\r\n", dwOptionalLength);
1417         HttpAddRequestHeadersA(hHttpRequest, contentLengthStr, -1L, HTTP_ADDREQ_FLAG_ADD);
1418     }
1419
1420     do
1421     {
1422         static const WCHAR szSlash[] = { '/',0 };
1423         static const WCHAR szSpace[] = { ' ',0 };
1424         static const WCHAR szHttp[] = { 'h','t','t','p',':','/','/', 0 };
1425         static const WCHAR szcrlf[] = {'\r','\n', 0};
1426         static const WCHAR sztwocrlf[] = {'\r','\n','\r','\n', 0};
1427         static const WCHAR szSetCookie[] = {'S','e','t','-','C','o','o','k','i','e',0 };
1428
1429         TRACE("Going to url %s %s\n", debugstr_w(lpwhr->lpszHostName), debugstr_w(lpwhr->lpszPath));
1430         loop_next = FALSE;
1431
1432         /* If we don't have a path we set it to root */
1433         if (NULL == lpwhr->lpszPath)
1434             lpwhr->lpszPath = WININET_strdupW(szSlash);
1435
1436         if(CSTR_EQUAL != CompareStringW( LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
1437                            lpwhr->lpszPath, strlenW(szHttp), szHttp, strlenW(szHttp) )
1438            && lpwhr->lpszPath[0] != '/') /* not an absolute path ?? --> fix it !! */
1439         {
1440             WCHAR *fixurl = HeapAlloc(GetProcessHeap(), 0,
1441                                  (strlenW(lpwhr->lpszPath) + 2)*sizeof(WCHAR));
1442             *fixurl = '/';
1443             strcpyW(fixurl + 1, lpwhr->lpszPath);
1444             HeapFree( GetProcessHeap(), 0, lpwhr->lpszPath );
1445             lpwhr->lpszPath = fixurl;
1446         }
1447
1448         /* Calculate length of request string */
1449         requestStringLen =
1450             strlenW(lpwhr->lpszVerb) +
1451             strlenW(lpwhr->lpszPath) +
1452             strlenW(HTTPHEADER) +
1453             5; /* " \r\n\r\n" */
1454
1455         /* add "\r\n" to end of lpszHeaders if needed */
1456         if (lpszHeaders)
1457         {
1458             int len = strlenW(lpszHeaders);
1459
1460             /* Check if the string is terminated with \r\n, but not if
1461              * the string is less that 2 characters long, because then
1462              * we would be looking at memory before the beginning of
1463              * the string. Besides, if it is less than 2 characters
1464              * long, then clearly, its not terminated with \r\n.
1465              */
1466             if ((len > 2) && (memcmp(lpszHeaders + (len - 2), szcrlf, sizeof szcrlf) == 0))
1467             {
1468                 lpszHeaders_r_n = WININET_strdupW(lpszHeaders);
1469             }
1470             else
1471             {
1472                 TRACE("Adding \r\n to lpszHeaders.\n");
1473                 lpszHeaders_r_n =  HeapAlloc( GetProcessHeap(), 0,
1474                                              (len + 3)*sizeof(WCHAR) );
1475                 strcpyW( lpszHeaders_r_n, lpszHeaders );
1476                 strcatW( lpszHeaders_r_n, szcrlf );
1477             }
1478         }
1479
1480         /* Add length of passed headers */
1481         if (lpszHeaders)
1482         {
1483             headerLength = -1 == dwHeaderLength ? strlenW(lpszHeaders_r_n) : dwHeaderLength;
1484             requestStringLen += headerLength +  2; /* \r\n */
1485         }
1486
1487
1488         /* if there isa proxy username and password, add it to the headers */
1489         if( hIC && (hIC->lpszProxyUsername || hIC->lpszProxyPassword ) )
1490         {
1491             HTTP_InsertProxyAuthorization( lpwhr, hIC->lpszProxyUsername, hIC->lpszProxyPassword );
1492         }
1493
1494         /* Calculate length of custom request headers */
1495         for (i = 0; i < lpwhr->nCustHeaders; i++)
1496         {
1497             if (lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST)
1498             {
1499                 requestStringLen += strlenW(lpwhr->pCustHeaders[i].lpszField) +
1500                     strlenW(lpwhr->pCustHeaders[i].lpszValue) + 4; /*: \r\n */
1501             }
1502         }
1503
1504         /* Calculate the length of standard request headers */
1505         for (i = 0; i <= HTTP_QUERY_MAX; i++)
1506         {
1507             if (lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST)
1508             {
1509                 requestStringLen += strlenW(lpwhr->StdHeaders[i].lpszField) +
1510                     strlenW(lpwhr->StdHeaders[i].lpszValue) + 4; /*: \r\n */
1511             }
1512         }
1513
1514         if (lpwhr->lpszHostName)
1515             requestStringLen += (strlenW(HTTPHOSTHEADER) + strlenW(lpwhr->lpszHostName));
1516
1517         /* if there is optional data to send, add the length */
1518         if (lpOptional)
1519         {
1520             requestStringLen += dwOptionalLength;
1521         }
1522
1523         /* Allocate string to hold entire request */
1524         requestString = HeapAlloc(GetProcessHeap(), 0, (requestStringLen + 1)*sizeof(WCHAR));
1525         if (NULL == requestString)
1526         {
1527             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1528             goto lend;
1529         }
1530
1531         /* Build request string */
1532         strcpyW(requestString, lpwhr->lpszVerb);
1533         strcatW(requestString, szSpace);
1534         strcatW(requestString, lpwhr->lpszPath);
1535         strcatW(requestString, HTTPHEADER );
1536         cnt = strlenW(requestString);
1537
1538         /* Append standard request headers */
1539         for (i = 0; i <= HTTP_QUERY_MAX; i++)
1540         {
1541             if (lpwhr->StdHeaders[i].wFlags & HDR_ISREQUEST)
1542             {
1543                 static const WCHAR szFmt[] = { '\r','\n','%','s',':',' ','%','s', 0};
1544                 cnt += sprintfW(requestString + cnt, szFmt,
1545                                lpwhr->StdHeaders[i].lpszField, lpwhr->StdHeaders[i].lpszValue);
1546                 TRACE("Adding header %s (%s)\n",
1547                        debugstr_w(lpwhr->StdHeaders[i].lpszField),
1548                        debugstr_w(lpwhr->StdHeaders[i].lpszValue));
1549             }
1550         }
1551
1552         /* Append custom request heades */
1553         for (i = 0; i < lpwhr->nCustHeaders; i++)
1554         {
1555             if (lpwhr->pCustHeaders[i].wFlags & HDR_ISREQUEST)
1556             {
1557                 static const WCHAR szFmt[] = { '\r','\n','%','s',':',' ','%','s', 0};
1558                 cnt += sprintfW(requestString + cnt, szFmt,
1559                                lpwhr->pCustHeaders[i].lpszField, lpwhr->pCustHeaders[i].lpszValue);
1560                 TRACE("Adding custom header %s (%s)\n",
1561                        debugstr_w(lpwhr->pCustHeaders[i].lpszField),
1562                        debugstr_w(lpwhr->pCustHeaders[i].lpszValue));
1563             }
1564         }
1565
1566         if (lpwhr->lpszHostName)
1567         {
1568             static const WCHAR szFmt[] = { '%','s','%','s',0 };
1569             cnt += sprintfW(requestString + cnt, szFmt, HTTPHOSTHEADER, lpwhr->lpszHostName);
1570         }
1571
1572         /* Append passed request headers */
1573         if (lpszHeaders_r_n)
1574         {
1575             strcpyW(requestString + cnt, szcrlf);
1576             cnt += 2;
1577             strcpyW(requestString + cnt, lpszHeaders_r_n);
1578             cnt += headerLength;
1579             /* only add \r\n if not already present */
1580             if (memcmp((requestString + cnt) - 2, szcrlf, sizeof szcrlf) != 0)
1581             {
1582                 strcpyW(requestString + cnt, szcrlf);
1583                 cnt += 2;
1584             }
1585         }
1586
1587         /* Set (header) termination string for request */
1588         if (memcmp((requestString + cnt) - 4, sztwocrlf, sizeof sztwocrlf) != 0)
1589         { /* only add it if the request string doesn't already
1590              have the thing.. (could happen if the custom header
1591              added it */
1592                 strcpyW(requestString + cnt, szcrlf);
1593                 cnt += 2;
1594         }
1595         else
1596             requestStringLen -= 2;
1597
1598         /* if optional data, append it */
1599         if (lpOptional)
1600         {
1601             memcpy(requestString + cnt, lpOptional, dwOptionalLength*sizeof(WCHAR));
1602             cnt += dwOptionalLength;
1603             /* we also have to decrease the expected string length by two,
1604              * since we won't be adding on those following \r\n's */
1605             requestStringLen -= 2;
1606         }
1607         else
1608         { /* if there is no optional data, add on another \r\n just to be safe */
1609                 /* termination for request */
1610                 strcpyW(requestString + cnt, szcrlf);
1611                 cnt += 2;
1612         }
1613
1614         TRACE("(%s) len(%d)\n", debugstr_w(requestString), requestStringLen);
1615         /* Send the request and store the results */
1616         if (!HTTP_OpenConnection(lpwhr))
1617             goto lend;
1618
1619         SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1620                           INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
1621
1622         /* send the request as ASCII */
1623         {
1624             int ascii_len;
1625             char *ascii_req;
1626
1627             ascii_len = WideCharToMultiByte( CP_ACP, 0, requestString,
1628                             requestStringLen, NULL, 0, NULL, NULL );
1629             ascii_req = HeapAlloc( GetProcessHeap(), 0, ascii_len );
1630             WideCharToMultiByte( CP_ACP, 0, requestString, requestStringLen,
1631                             ascii_req, ascii_len, NULL, NULL );
1632             NETCON_send(&lpwhr->netConnection, ascii_req, ascii_len, 0, &cnt);
1633             HeapFree( GetProcessHeap(), 0, ascii_req );
1634         }
1635
1636
1637         SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1638                           INTERNET_STATUS_REQUEST_SENT,
1639                           &requestStringLen,sizeof(DWORD));
1640
1641         SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1642                           INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
1643
1644         if (cnt < 0)
1645             goto lend;
1646
1647         responseLen = HTTP_GetResponseHeaders(lpwhr);
1648         if (responseLen)
1649             bSuccess = TRUE;
1650
1651         SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1652                           INTERNET_STATUS_RESPONSE_RECEIVED, &responseLen,
1653                           sizeof(DWORD));
1654
1655         /* process headers here. Is this right? */
1656         CustHeaderIndex = HTTP_GetCustomHeaderIndex(lpwhr, szSetCookie);
1657         if (CustHeaderIndex >= 0)
1658         {
1659             LPHTTPHEADERW setCookieHeader;
1660             int nPosStart = 0, nPosEnd = 0, len;
1661             static const WCHAR szFmt[] = { 'h','t','t','p',':','/','/','%','s','/',0};
1662
1663             setCookieHeader = &lpwhr->pCustHeaders[CustHeaderIndex];
1664
1665             while (setCookieHeader->lpszValue[nPosEnd] != '\0')
1666             {
1667                 LPWSTR buf_cookie, cookie_name, cookie_data;
1668                 LPWSTR buf_url;
1669                 LPWSTR domain = NULL;
1670                 int nEqualPos = 0;
1671                 while (setCookieHeader->lpszValue[nPosEnd] != ';' && setCookieHeader->lpszValue[nPosEnd] != ',' &&
1672                        setCookieHeader->lpszValue[nPosEnd] != '\0')
1673                 {
1674                     nPosEnd++;
1675                 }
1676                 if (setCookieHeader->lpszValue[nPosEnd] == ';')
1677                 {
1678                     /* fixme: not case sensitive, strcasestr is gnu only */
1679                     int nDomainPosEnd = 0;
1680                     int nDomainPosStart = 0, nDomainLength = 0;
1681                     static const WCHAR szDomain[] = {'d','o','m','a','i','n','=',0};
1682                     LPWSTR lpszDomain = strstrW(&setCookieHeader->lpszValue[nPosEnd], szDomain);
1683                     if (lpszDomain)
1684                     { /* they have specified their own domain, lets use it */
1685                         while (lpszDomain[nDomainPosEnd] != ';' && lpszDomain[nDomainPosEnd] != ',' &&
1686                                lpszDomain[nDomainPosEnd] != '\0')
1687                         {
1688                             nDomainPosEnd++;
1689                         }
1690                         nDomainPosStart = strlenW(szDomain);
1691                         nDomainLength = (nDomainPosEnd - nDomainPosStart) + 1;
1692                         domain = HeapAlloc(GetProcessHeap(), 0, (nDomainLength + 1)*sizeof(WCHAR));
1693                         strncpyW(domain, &lpszDomain[nDomainPosStart], nDomainLength);
1694                         domain[nDomainLength] = '\0';
1695                     }
1696                 }
1697                 if (setCookieHeader->lpszValue[nPosEnd] == '\0') break;
1698                 buf_cookie = HeapAlloc(GetProcessHeap(), 0, ((nPosEnd - nPosStart) + 1)*sizeof(WCHAR));
1699                 strncpyW(buf_cookie, &setCookieHeader->lpszValue[nPosStart], (nPosEnd - nPosStart));
1700                 buf_cookie[(nPosEnd - nPosStart)] = '\0';
1701                 TRACE("%s\n", debugstr_w(buf_cookie));
1702                 while (buf_cookie[nEqualPos] != '=' && buf_cookie[nEqualPos] != '\0')
1703                 {
1704                     nEqualPos++;
1705                 }
1706                 if (buf_cookie[nEqualPos] == '\0' || buf_cookie[nEqualPos + 1] == '\0')
1707                 {
1708                     HeapFree(GetProcessHeap(), 0, buf_cookie);
1709                     break;
1710                 }
1711
1712                 cookie_name = HeapAlloc(GetProcessHeap(), 0, (nEqualPos + 1)*sizeof(WCHAR));
1713                 strncpyW(cookie_name, buf_cookie, nEqualPos);
1714                 cookie_name[nEqualPos] = '\0';
1715                 cookie_data = &buf_cookie[nEqualPos + 1];
1716
1717
1718                 len = strlenW((domain ? domain : lpwhr->lpszHostName)) + strlenW(lpwhr->lpszPath) + 9;
1719                 buf_url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
1720                 sprintfW(buf_url, szFmt, (domain ? domain : lpwhr->lpszHostName)); /* FIXME PATH!!! */
1721                 InternetSetCookieW(buf_url, cookie_name, cookie_data);
1722
1723                 HeapFree(GetProcessHeap(), 0, buf_url);
1724                 HeapFree(GetProcessHeap(), 0, buf_cookie);
1725                 HeapFree(GetProcessHeap(), 0, cookie_name);
1726                 if (domain) HeapFree(GetProcessHeap(), 0, domain);
1727                 nPosStart = nPosEnd;
1728             }
1729         }
1730     }
1731     while (loop_next);
1732
1733 lend:
1734
1735     if (requestString)
1736         HeapFree(GetProcessHeap(), 0, requestString);
1737
1738     if (lpszHeaders)
1739         HeapFree(GetProcessHeap(), 0, lpszHeaders_r_n);
1740
1741     /* TODO: send notification for P3P header */
1742
1743     if(!(hIC->hdr.dwFlags & INTERNET_FLAG_NO_AUTO_REDIRECT) && bSuccess)
1744     {
1745         DWORD dwCode,dwCodeLength=sizeof(DWORD),dwIndex=0;
1746         if(HttpQueryInfoW(hHttpRequest,HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_STATUS_CODE,&dwCode,&dwCodeLength,&dwIndex) &&
1747             (dwCode==302 || dwCode==301))
1748         {
1749             WCHAR szNewLocation[2048];
1750             DWORD dwBufferSize=2048;
1751             dwIndex=0;
1752             if(HttpQueryInfoW(hHttpRequest,HTTP_QUERY_LOCATION,szNewLocation,&dwBufferSize,&dwIndex))
1753             {
1754                 SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1755                       INTERNET_STATUS_REDIRECT, szNewLocation,
1756                       dwBufferSize);
1757                 return HTTP_HandleRedirect(lpwhr, szNewLocation, lpszHeaders,
1758                                            dwHeaderLength, lpOptional, dwOptionalLength);
1759             }
1760         }
1761     }
1762
1763     if (hIC->lpfnStatusCB)
1764     {
1765         INTERNET_ASYNC_RESULT iar;
1766
1767         iar.dwResult = (DWORD)bSuccess;
1768         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1769
1770         SendAsyncCallback(hIC, hHttpRequest, lpwhr->hdr.dwContext,
1771                       INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1772                       sizeof(INTERNET_ASYNC_RESULT));
1773     }
1774
1775     TRACE("<--\n");
1776     return bSuccess;
1777 }
1778
1779
1780 /***********************************************************************
1781  *           HTTP_Connect  (internal)
1782  *
1783  * Create http session handle
1784  *
1785  * RETURNS
1786  *   HINTERNET a session handle on success
1787  *   NULL on failure
1788  *
1789  */
1790 HINTERNET HTTP_Connect(HINTERNET hInternet, LPCWSTR lpszServerName,
1791         INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
1792         LPCWSTR lpszPassword, DWORD dwFlags, DWORD dwContext,
1793         DWORD dwInternalFlags)
1794 {
1795     BOOL bSuccess = FALSE;
1796     LPWININETAPPINFOW hIC = NULL;
1797     LPWININETHTTPSESSIONW lpwhs = NULL;
1798     HINTERNET handle = NULL;
1799
1800     TRACE("-->\n");
1801
1802     hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
1803     if( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
1804         goto lerror;
1805
1806     hIC->hdr.dwContext = dwContext;
1807
1808     lpwhs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETHTTPSESSIONW));
1809     if (NULL == lpwhs)
1810     {
1811         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1812         goto lerror;
1813     }
1814
1815     handle = WININET_AllocHandle( &lpwhs->hdr );
1816     if (NULL == handle)
1817     {
1818         ERR("Failed to alloc handle\n");
1819         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1820         goto lerror;
1821     }
1822
1823    /*
1824     * According to my tests. The name is not resolved until a request is sent
1825     */
1826
1827     if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
1828         nServerPort = INTERNET_DEFAULT_HTTP_PORT;
1829
1830     lpwhs->hdr.htype = WH_HHTTPSESSION;
1831     lpwhs->hdr.lpwhparent = &hIC->hdr;
1832     lpwhs->hdr.dwFlags = dwFlags;
1833     lpwhs->hdr.dwContext = dwContext;
1834     lpwhs->hdr.dwInternalFlags = dwInternalFlags;
1835     if(hIC->lpszProxy && hIC->dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
1836         if(strchrW(hIC->lpszProxy, ' '))
1837             FIXME("Several proxies not implemented.\n");
1838         if(hIC->lpszProxyBypass)
1839             FIXME("Proxy bypass is ignored.\n");
1840     }
1841     if (NULL != lpszServerName)
1842         lpwhs->lpszServerName = WININET_strdupW(lpszServerName);
1843     if (NULL != lpszUserName)
1844         lpwhs->lpszUserName = WININET_strdupW(lpszUserName);
1845     lpwhs->nServerPort = nServerPort;
1846
1847     /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
1848     if (hIC->lpfnStatusCB && !(lpwhs->hdr.dwInternalFlags & INET_OPENURL))
1849     {
1850         INTERNET_ASYNC_RESULT iar;
1851
1852         iar.dwResult = (DWORD)handle;
1853         iar.dwError = ERROR_SUCCESS;
1854
1855         SendAsyncCallback(hIC, hInternet, dwContext,
1856                       INTERNET_STATUS_HANDLE_CREATED, &iar,
1857                       sizeof(INTERNET_ASYNC_RESULT));
1858     }
1859
1860     bSuccess = TRUE;
1861
1862 lerror:
1863     if (!bSuccess && lpwhs)
1864     {
1865         HeapFree(GetProcessHeap(), 0, lpwhs);
1866         WININET_FreeHandle( handle );
1867         lpwhs = NULL;
1868     }
1869
1870 /*
1871  * a INTERNET_STATUS_REQUEST_COMPLETE is NOT sent here as per my tests on
1872  * windows
1873  */
1874
1875     TRACE("%p --> %p\n", hInternet, handle);
1876     return handle;
1877 }
1878
1879
1880 /***********************************************************************
1881  *           HTTP_OpenConnection (internal)
1882  *
1883  * Connect to a web server
1884  *
1885  * RETURNS
1886  *
1887  *   TRUE  on success
1888  *   FALSE on failure
1889  */
1890 BOOL HTTP_OpenConnection(LPWININETHTTPREQW lpwhr)
1891 {
1892     BOOL bSuccess = FALSE;
1893     LPWININETHTTPSESSIONW lpwhs;
1894     LPWININETAPPINFOW hIC = NULL;
1895
1896     TRACE("-->\n");
1897
1898
1899     if (NULL == lpwhr ||  lpwhr->hdr.htype != WH_HHTTPREQ)
1900     {
1901         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1902         goto lend;
1903     }
1904
1905     lpwhs = (LPWININETHTTPSESSIONW)lpwhr->hdr.lpwhparent;
1906
1907     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
1908     SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
1909                       INTERNET_STATUS_CONNECTING_TO_SERVER,
1910                       &(lpwhs->socketAddress),
1911                        sizeof(struct sockaddr_in));
1912
1913     if (!NETCON_create(&lpwhr->netConnection, lpwhs->phostent->h_addrtype,
1914                          SOCK_STREAM, 0))
1915     {
1916         WARN("Socket creation failed\n");
1917         goto lend;
1918     }
1919
1920     if (!NETCON_connect(&lpwhr->netConnection, (struct sockaddr *)&lpwhs->socketAddress,
1921                       sizeof(lpwhs->socketAddress)))
1922     {
1923        WARN("Unable to connect to host (%s)\n", strerror(errno));
1924        goto lend;
1925     }
1926
1927     SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
1928                       INTERNET_STATUS_CONNECTED_TO_SERVER,
1929                       &(lpwhs->socketAddress),
1930                        sizeof(struct sockaddr_in));
1931
1932     bSuccess = TRUE;
1933
1934 lend:
1935     TRACE("%d <--\n", bSuccess);
1936     return bSuccess;
1937 }
1938
1939
1940 /***********************************************************************
1941  *           HTTP_GetResponseHeaders (internal)
1942  *
1943  * Read server response
1944  *
1945  * RETURNS
1946  *
1947  *   TRUE  on success
1948  *   FALSE on error
1949  */
1950 BOOL HTTP_GetResponseHeaders(LPWININETHTTPREQW lpwhr)
1951 {
1952     INT cbreaks = 0;
1953     WCHAR buffer[MAX_REPLY_LEN];
1954     DWORD buflen = MAX_REPLY_LEN;
1955     BOOL bSuccess = FALSE;
1956     INT  rc = 0;
1957     WCHAR value[MAX_FIELD_VALUE_LEN], field[MAX_FIELD_LEN];
1958     static const WCHAR szStatus[] = {'S','t','a','t','u','s',0};
1959     static const WCHAR szHttp[] = { 'H','T','T','P',0 };
1960     char bufferA[MAX_REPLY_LEN];
1961
1962     TRACE("-->\n");
1963
1964     if (!NETCON_connected(&lpwhr->netConnection))
1965         goto lend;
1966
1967     /*
1968      * HACK peek at the buffer
1969      */
1970     NETCON_recv(&lpwhr->netConnection, buffer, buflen, MSG_PEEK, &rc);
1971
1972     /*
1973      * We should first receive 'HTTP/1.x nnn' where nnn is the status code.
1974      */
1975     buflen = MAX_REPLY_LEN;
1976     memset(buffer, 0, MAX_REPLY_LEN);
1977     if (!NETCON_getNextLine(&lpwhr->netConnection, bufferA, &buflen))
1978         goto lend;
1979     MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
1980
1981     if (strncmpW(buffer, szHttp, 4) != 0)
1982         goto lend;
1983
1984     buffer[12]='\0';
1985     HTTP_ProcessHeader(lpwhr, szStatus, buffer+9, (HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE));
1986
1987     /* Parse each response line */
1988     do
1989     {
1990         buflen = MAX_REPLY_LEN;
1991         if (NETCON_getNextLine(&lpwhr->netConnection, bufferA, &buflen))
1992         {
1993             TRACE("got line %s, now interpretting\n", debugstr_a(bufferA));
1994             MultiByteToWideChar( CP_ACP, 0, bufferA, buflen, buffer, MAX_REPLY_LEN );
1995             if (!HTTP_InterpretHttpHeader(buffer, field, MAX_FIELD_LEN, value, MAX_FIELD_VALUE_LEN))
1996                 break;
1997
1998             HTTP_ProcessHeader(lpwhr, field, value, (HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE));
1999         }
2000         else
2001         {
2002             cbreaks++;
2003             if (cbreaks >= 2)
2004                break;
2005         }
2006     }while(1);
2007
2008     bSuccess = TRUE;
2009
2010 lend:
2011
2012     TRACE("<--\n");
2013     if (bSuccess)
2014         return rc;
2015     else
2016         return FALSE;
2017 }
2018
2019
2020 /***********************************************************************
2021  *           HTTP_InterpretHttpHeader (internal)
2022  *
2023  * Parse server response
2024  *
2025  * RETURNS
2026  *
2027  *   TRUE  on success
2028  *   FALSE on error
2029  */
2030 INT stripSpaces(LPCWSTR lpszSrc, LPWSTR lpszStart, INT *len)
2031 {
2032     LPCWSTR lpsztmp;
2033     INT srclen;
2034
2035     srclen = 0;
2036
2037     while (*lpszSrc == ' ' && *lpszSrc != '\0')
2038         lpszSrc++;
2039
2040     lpsztmp = lpszSrc;
2041     while(*lpsztmp != '\0')
2042     {
2043         if (*lpsztmp != ' ')
2044             srclen = lpsztmp - lpszSrc + 1;
2045
2046         lpsztmp++;
2047     }
2048
2049     *len = min(*len, srclen);
2050     strncpyW(lpszStart, lpszSrc, *len);
2051     lpszStart[*len] = '\0';
2052
2053     return *len;
2054 }
2055
2056
2057 BOOL HTTP_InterpretHttpHeader(LPWSTR buffer, LPWSTR field, INT fieldlen, LPWSTR value, INT valuelen)
2058 {
2059     WCHAR *pd;
2060     BOOL bSuccess = FALSE;
2061
2062     TRACE("\n");
2063
2064     *field = '\0';
2065     *value = '\0';
2066
2067     pd = strchrW(buffer, ':');
2068     if (pd)
2069     {
2070         *pd = '\0';
2071         if (stripSpaces(buffer, field, &fieldlen) > 0)
2072         {
2073             if (stripSpaces(pd+1, value, &valuelen) > 0)
2074                 bSuccess = TRUE;
2075         }
2076     }
2077
2078     TRACE("%d: field(%s) Value(%s)\n", bSuccess, debugstr_w(field), debugstr_w(value));
2079     return bSuccess;
2080 }
2081
2082
2083 /***********************************************************************
2084  *           HTTP_GetStdHeaderIndex (internal)
2085  *
2086  * Lookup field index in standard http header array
2087  *
2088  * FIXME: This should be stuffed into a hash table
2089  */
2090 INT HTTP_GetStdHeaderIndex(LPCWSTR lpszField)
2091 {
2092     INT index = -1;
2093     static const WCHAR szContentLength[] = {
2094        'C','o','n','t','e','n','t','-','L','e','n','g','t','h',0};
2095     static const WCHAR szStatus[] = {'S','t','a','t','u','s',0};
2096     static const WCHAR szContentType[] = {
2097        'C','o','n','t','e','n','t','-','T','y','p','e',0};
2098     static const WCHAR szLastModified[] = {
2099        'L','a','s','t','-','M','o','d','i','f','i','e','d',0};
2100     static const WCHAR szLocation[] = {'L','o','c','a','t','i','o','n',0};
2101     static const WCHAR szAccept[] = {'A','c','c','e','p','t',0};
2102     static const WCHAR szReferer[] = { 'R','e','f','e','r','e','r',0};
2103     static const WCHAR szContentTrans[] = { 'C','o','n','t','e','n','t','-',
2104        'T','r','a','n','s','f','e','r','-','E','n','c','o','d','i','n','g',0};
2105     static const WCHAR szDate[] = { 'D','a','t','e',0};
2106     static const WCHAR szServer[] = { 'S','e','r','v','e','r',0};
2107     static const WCHAR szConnection[] = { 'C','o','n','n','e','c','t','i','o','n',0};
2108     static const WCHAR szETag[] = { 'E','T','a','g',0};
2109     static const WCHAR szAcceptRanges[] = {
2110        'A','c','c','e','p','t','-','R','a','n','g','e','s',0 };
2111     static const WCHAR szExpires[] = { 'E','x','p','i','r','e','s',0 };
2112     static const WCHAR szMimeVersion[] = {
2113        'M','i','m','e','-','V','e','r','s','i','o','n', 0};
2114     static const WCHAR szPragma[] = { 'P','r','a','g','m','a', 0};
2115     static const WCHAR szCacheControl[] = {
2116        'C','a','c','h','e','-','C','o','n','t','r','o','l',0};
2117     static const WCHAR szUserAgent[] = { 'U','s','e','r','-','A','g','e','n','t',0};
2118     static const WCHAR szProxyAuth[] = {
2119        'P','r','o','x','y','-',
2120        'A','u','t','h','e','n','t','i','c','a','t','e', 0};
2121
2122     if (!strcmpiW(lpszField, szContentLength))
2123         index = HTTP_QUERY_CONTENT_LENGTH;
2124     else if (!strcmpiW(lpszField,szStatus))
2125         index = HTTP_QUERY_STATUS_CODE;
2126     else if (!strcmpiW(lpszField,szContentType))
2127         index = HTTP_QUERY_CONTENT_TYPE;
2128     else if (!strcmpiW(lpszField,szLastModified))
2129         index = HTTP_QUERY_LAST_MODIFIED;
2130     else if (!strcmpiW(lpszField,szLocation))
2131         index = HTTP_QUERY_LOCATION;
2132     else if (!strcmpiW(lpszField,szAccept))
2133         index = HTTP_QUERY_ACCEPT;
2134     else if (!strcmpiW(lpszField,szReferer))
2135         index = HTTP_QUERY_REFERER;
2136     else if (!strcmpiW(lpszField,szContentTrans))
2137         index = HTTP_QUERY_CONTENT_TRANSFER_ENCODING;
2138     else if (!strcmpiW(lpszField,szDate))
2139         index = HTTP_QUERY_DATE;
2140     else if (!strcmpiW(lpszField,szServer))
2141         index = HTTP_QUERY_SERVER;
2142     else if (!strcmpiW(lpszField,szConnection))
2143         index = HTTP_QUERY_CONNECTION;
2144     else if (!strcmpiW(lpszField,szETag))
2145         index = HTTP_QUERY_ETAG;
2146     else if (!strcmpiW(lpszField,szAcceptRanges))
2147         index = HTTP_QUERY_ACCEPT_RANGES;
2148     else if (!strcmpiW(lpszField,szExpires))
2149         index = HTTP_QUERY_EXPIRES;
2150     else if (!strcmpiW(lpszField,szMimeVersion))
2151         index = HTTP_QUERY_MIME_VERSION;
2152     else if (!strcmpiW(lpszField,szPragma))
2153         index = HTTP_QUERY_PRAGMA;
2154     else if (!strcmpiW(lpszField,szCacheControl))
2155         index = HTTP_QUERY_CACHE_CONTROL;
2156     else if (!strcmpiW(lpszField,szUserAgent))
2157         index = HTTP_QUERY_USER_AGENT;
2158     else if (!strcmpiW(lpszField,szProxyAuth))
2159         index = HTTP_QUERY_PROXY_AUTHENTICATE;
2160     else
2161     {
2162         TRACE("Couldn't find %s in standard header table\n", debugstr_w(lpszField));
2163     }
2164
2165     return index;
2166 }
2167
2168
2169 /***********************************************************************
2170  *           HTTP_ProcessHeader (internal)
2171  *
2172  * Stuff header into header tables according to <dwModifier>
2173  *
2174  */
2175
2176 #define COALESCEFLASG (HTTP_ADDHDR_FLAG_COALESCE|HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA|HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
2177
2178 BOOL HTTP_ProcessHeader(LPWININETHTTPREQW lpwhr, LPCWSTR field, LPCWSTR value, DWORD dwModifier)
2179 {
2180     LPHTTPHEADERW lphttpHdr = NULL;
2181     BOOL bSuccess = FALSE;
2182     INT index;
2183
2184     TRACE("--> %s: %s - 0x%08x\n", debugstr_w(field), debugstr_w(value), (unsigned int)dwModifier);
2185
2186     /* Adjust modifier flags */
2187     if (dwModifier & COALESCEFLASG)
2188         dwModifier |= HTTP_ADDHDR_FLAG_ADD;
2189
2190     /* Try to get index into standard header array */
2191     index = HTTP_GetStdHeaderIndex(field);
2192     if (index >= 0)
2193     {
2194         lphttpHdr = &lpwhr->StdHeaders[index];
2195     }
2196     else /* Find or create new custom header */
2197     {
2198         index = HTTP_GetCustomHeaderIndex(lpwhr, field);
2199         if (index >= 0)
2200         {
2201             if (dwModifier & HTTP_ADDHDR_FLAG_ADD_IF_NEW)
2202             {
2203                 return FALSE;
2204             }
2205             lphttpHdr = &lpwhr->pCustHeaders[index];
2206         }
2207         else
2208         {
2209             HTTPHEADERW hdr;
2210
2211             hdr.lpszField = (LPWSTR)field;
2212             hdr.lpszValue = (LPWSTR)value;
2213             hdr.wFlags = hdr.wCount = 0;
2214
2215             if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2216                 hdr.wFlags |= HDR_ISREQUEST;
2217
2218             return HTTP_InsertCustomHeader(lpwhr, &hdr);
2219         }
2220     }
2221
2222     if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2223         lphttpHdr->wFlags |= HDR_ISREQUEST;
2224     else
2225         lphttpHdr->wFlags &= ~HDR_ISREQUEST;
2226
2227     if (!lphttpHdr->lpszValue && (dwModifier & (HTTP_ADDHDR_FLAG_ADD|HTTP_ADDHDR_FLAG_ADD_IF_NEW)))
2228     {
2229         INT slen;
2230
2231         if (!lpwhr->StdHeaders[index].lpszField)
2232         {
2233             lphttpHdr->lpszField = WININET_strdupW(field);
2234
2235             if (dwModifier & HTTP_ADDHDR_FLAG_REQ)
2236                 lphttpHdr->wFlags |= HDR_ISREQUEST;
2237         }
2238
2239         slen = strlenW(value) + 1;
2240         lphttpHdr->lpszValue = HeapAlloc(GetProcessHeap(), 0, slen*sizeof(WCHAR));
2241         if (lphttpHdr->lpszValue)
2242         {
2243             strcpyW(lphttpHdr->lpszValue, value);
2244             bSuccess = TRUE;
2245         }
2246         else
2247         {
2248             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2249         }
2250     }
2251     else if (lphttpHdr->lpszValue)
2252     {
2253         if (dwModifier & HTTP_ADDHDR_FLAG_REPLACE)
2254         {
2255             LPWSTR lpsztmp;
2256             INT len;
2257
2258             len = strlenW(value);
2259
2260             if (len <= 0)
2261             {
2262                 /* if custom header delete from array */
2263                 HeapFree(GetProcessHeap(), 0, lphttpHdr->lpszValue);
2264                 lphttpHdr->lpszValue = NULL;
2265                 bSuccess = TRUE;
2266             }
2267             else
2268             {
2269                 lpsztmp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,  lphttpHdr->lpszValue, (len+1)*sizeof(WCHAR));
2270                 if (lpsztmp)
2271                 {
2272                     lphttpHdr->lpszValue = lpsztmp;
2273                     strcpyW(lpsztmp, value);
2274                     bSuccess = TRUE;
2275                 }
2276                 else
2277                 {
2278                     WARN("HeapReAlloc (%d bytes) failed\n",len+1);
2279                     INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2280                 }
2281             }
2282         }
2283         else if (dwModifier & COALESCEFLASG)
2284         {
2285             LPWSTR lpsztmp;
2286             WCHAR ch = 0;
2287             INT len = 0;
2288             INT origlen = strlenW(lphttpHdr->lpszValue);
2289             INT valuelen = strlenW(value);
2290
2291             if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_COMMA)
2292             {
2293                 ch = ',';
2294                 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
2295             }
2296             else if (dwModifier & HTTP_ADDHDR_FLAG_COALESCE_WITH_SEMICOLON)
2297             {
2298                 ch = ';';
2299                 lphttpHdr->wFlags |= HDR_COMMADELIMITED;
2300             }
2301
2302             len = origlen + valuelen + ((ch > 0) ? 1 : 0);
2303
2304             lpsztmp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,  lphttpHdr->lpszValue, (len+1)*sizeof(WCHAR));
2305             if (lpsztmp)
2306             {
2307                 /* FIXME: Increment lphttpHdr->wCount. Perhaps lpszValue should be an array */
2308                 if (ch > 0)
2309                 {
2310                     lphttpHdr->lpszValue[origlen] = ch;
2311                     origlen++;
2312                 }
2313
2314                 memcpy(&lphttpHdr->lpszValue[origlen], value, valuelen*sizeof(WCHAR));
2315                 lphttpHdr->lpszValue[len] = '\0';
2316                 bSuccess = TRUE;
2317             }
2318             else
2319             {
2320                 WARN("HeapReAlloc (%d bytes) failed\n",len+1);
2321                 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2322             }
2323         }
2324     }
2325     TRACE("<-- %d\n",bSuccess);
2326     return bSuccess;
2327 }
2328
2329
2330 /***********************************************************************
2331  *           HTTP_CloseConnection (internal)
2332  *
2333  * Close socket connection
2334  *
2335  */
2336 VOID HTTP_CloseConnection(LPWININETHTTPREQW lpwhr)
2337 {
2338
2339
2340     LPWININETHTTPSESSIONW lpwhs = NULL;
2341     LPWININETAPPINFOW hIC = NULL;
2342     HINTERNET handle;
2343
2344     TRACE("%p\n",lpwhr);
2345
2346     handle = WININET_FindHandle( &lpwhr->hdr );
2347     lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
2348     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
2349
2350     SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
2351                       INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
2352
2353     if (NETCON_connected(&lpwhr->netConnection))
2354     {
2355         NETCON_close(&lpwhr->netConnection);
2356     }
2357
2358     SendAsyncCallback(hIC, lpwhr, lpwhr->hdr.dwContext,
2359                       INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
2360 }
2361
2362
2363 /***********************************************************************
2364  *           HTTP_CloseHTTPRequestHandle (internal)
2365  *
2366  * Deallocate request handle
2367  *
2368  */
2369 void HTTP_CloseHTTPRequestHandle(LPWININETHTTPREQW lpwhr)
2370 {
2371     int i;
2372     LPWININETHTTPSESSIONW lpwhs = NULL;
2373     LPWININETAPPINFOW hIC = NULL;
2374     HINTERNET handle;
2375
2376     TRACE("\n");
2377
2378     if (NETCON_connected(&lpwhr->netConnection))
2379         HTTP_CloseConnection(lpwhr);
2380
2381     handle = WININET_FindHandle( &lpwhr->hdr );
2382     lpwhs = (LPWININETHTTPSESSIONW) lpwhr->hdr.lpwhparent;
2383     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
2384
2385     SendAsyncCallback(hIC, handle, lpwhr->hdr.dwContext,
2386                       INTERNET_STATUS_HANDLE_CLOSING, lpwhr,
2387                       sizeof(HINTERNET));
2388
2389     if (lpwhr->lpszPath)
2390         HeapFree(GetProcessHeap(), 0, lpwhr->lpszPath);
2391     if (lpwhr->lpszVerb)
2392         HeapFree(GetProcessHeap(), 0, lpwhr->lpszVerb);
2393     if (lpwhr->lpszHostName)
2394         HeapFree(GetProcessHeap(), 0, lpwhr->lpszHostName);
2395
2396     for (i = 0; i <= HTTP_QUERY_MAX; i++)
2397     {
2398            if (lpwhr->StdHeaders[i].lpszField)
2399             HeapFree(GetProcessHeap(), 0, lpwhr->StdHeaders[i].lpszField);
2400            if (lpwhr->StdHeaders[i].lpszValue)
2401             HeapFree(GetProcessHeap(), 0, lpwhr->StdHeaders[i].lpszValue);
2402     }
2403
2404     for (i = 0; i < lpwhr->nCustHeaders; i++)
2405     {
2406            if (lpwhr->pCustHeaders[i].lpszField)
2407             HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszField);
2408            if (lpwhr->pCustHeaders[i].lpszValue)
2409             HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders[i].lpszValue);
2410     }
2411
2412     HeapFree(GetProcessHeap(), 0, lpwhr->pCustHeaders);
2413     HeapFree(GetProcessHeap(), 0, lpwhr);
2414
2415     /* If this handle was opened with InternetOpenUrl, we need to close the parent to prevent
2416        a memory leek
2417      */
2418     if(lpwhs->hdr.dwInternalFlags & INET_OPENURL)
2419     {
2420         handle = WININET_FindHandle( &lpwhs->hdr );
2421         InternetCloseHandle(handle);
2422     }
2423 }
2424
2425
2426 /***********************************************************************
2427  *           HTTP_CloseHTTPSessionHandle (internal)
2428  *
2429  * Deallocate session handle
2430  *
2431  */
2432 void HTTP_CloseHTTPSessionHandle(LPWININETHTTPSESSIONW lpwhs)
2433 {
2434     LPWININETAPPINFOW hIC = NULL;
2435     HINTERNET handle;
2436
2437     TRACE("%p\n", lpwhs);
2438
2439     hIC = (LPWININETAPPINFOW) lpwhs->hdr.lpwhparent;
2440
2441     /* Don't send a handle closing callback if this handle was created with InternetOpenUrl */
2442     if(!(lpwhs->hdr.dwInternalFlags & INET_OPENURL))
2443     {
2444         handle = WININET_FindHandle( &lpwhs->hdr );
2445         SendAsyncCallback(hIC, handle, lpwhs->hdr.dwContext,
2446                           INTERNET_STATUS_HANDLE_CLOSING, lpwhs,
2447                           sizeof(HINTERNET));
2448     }
2449
2450     if (lpwhs->lpszServerName)
2451         HeapFree(GetProcessHeap(), 0, lpwhs->lpszServerName);
2452     if (lpwhs->lpszUserName)
2453         HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
2454     HeapFree(GetProcessHeap(), 0, lpwhs);
2455 }
2456
2457
2458 /***********************************************************************
2459  *           HTTP_GetCustomHeaderIndex (internal)
2460  *
2461  * Return index of custom header from header array
2462  *
2463  */
2464 INT HTTP_GetCustomHeaderIndex(LPWININETHTTPREQW lpwhr, LPCWSTR lpszField)
2465 {
2466     INT index;
2467
2468     TRACE("%s\n", debugstr_w(lpszField));
2469
2470     for (index = 0; index < lpwhr->nCustHeaders; index++)
2471     {
2472         if (!strcmpiW(lpwhr->pCustHeaders[index].lpszField, lpszField))
2473             break;
2474
2475     }
2476
2477     if (index >= lpwhr->nCustHeaders)
2478         index = -1;
2479
2480     TRACE("Return: %d\n", index);
2481     return index;
2482 }
2483
2484
2485 /***********************************************************************
2486  *           HTTP_InsertCustomHeader (internal)
2487  *
2488  * Insert header into array
2489  *
2490  */
2491 BOOL HTTP_InsertCustomHeader(LPWININETHTTPREQW lpwhr, LPHTTPHEADERW lpHdr)
2492 {
2493     INT count;
2494     LPHTTPHEADERW lph = NULL;
2495     BOOL r = FALSE;
2496
2497     TRACE("--> %s: %s\n", debugstr_w(lpHdr->lpszField), debugstr_w(lpHdr->lpszValue));
2498     count = lpwhr->nCustHeaders + 1;
2499     if (count > 1)
2500         lph = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpwhr->pCustHeaders, sizeof(HTTPHEADERW) * count);
2501     else
2502         lph = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HTTPHEADERW) * count);
2503
2504     if (NULL != lph)
2505     {
2506         lpwhr->pCustHeaders = lph;
2507         lpwhr->pCustHeaders[count-1].lpszField = WININET_strdupW(lpHdr->lpszField);
2508         lpwhr->pCustHeaders[count-1].lpszValue = WININET_strdupW(lpHdr->lpszValue);
2509         lpwhr->pCustHeaders[count-1].wFlags = lpHdr->wFlags;
2510         lpwhr->pCustHeaders[count-1].wCount= lpHdr->wCount;
2511         lpwhr->nCustHeaders++;
2512         r = TRUE;
2513     }
2514     else
2515     {
2516         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2517     }
2518
2519     return r;
2520 }
2521
2522
2523 /***********************************************************************
2524  *           HTTP_DeleteCustomHeader (internal)
2525  *
2526  * Delete header from array
2527  *  If this function is called, the indexs may change.
2528  */
2529 BOOL HTTP_DeleteCustomHeader(LPWININETHTTPREQW lpwhr, INT index)
2530 {
2531     if( lpwhr->nCustHeaders <= 0 )
2532         return FALSE;
2533     if( lpwhr->nCustHeaders >= index )
2534         return FALSE;
2535     lpwhr->nCustHeaders--;
2536
2537     memmove( &lpwhr->pCustHeaders[index], &lpwhr->pCustHeaders[index+1],
2538              (lpwhr->nCustHeaders - index)* sizeof(HTTPHEADERW) );
2539     memset( &lpwhr->pCustHeaders[lpwhr->nCustHeaders], 0, sizeof(HTTPHEADERW) );
2540
2541     return TRUE;
2542 }
2543
2544 /***********************************************************************
2545  *          IsHostInProxyBypassList (@)
2546  *
2547  * Undocumented
2548  *
2549  */
2550 BOOL WINAPI IsHostInProxyBypassList(DWORD flags, LPCSTR szHost, DWORD length)
2551 {
2552    FIXME("STUB: flags=%ld host=%s length=%ld\n",flags,szHost,length);
2553    return FALSE;
2554 }