git.oblomov.eu Git - wine/blob - dlls/wininet/internet.c

   1 /*
   2  * Wininet
   3  *
   4  * Copyright 1999 Corel Corporation
   5  * Copyright 2002 CodeWeavers Inc.
   6  * Copyright 2002 Jaco Greeff
   7  * Copyright 2002 TransGaming Technologies Inc.
   8  * Copyright 2004 Mike McCormack for CodeWeavers
   9  *
  10  * Ulrich Czekalla
  11  * Aric Stewart
  12  * David Hammerton
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this library; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31
  32 #define MAXHOSTNAME 100 /* from http.c */
  33
  34 #include <string.h>
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <sys/types.h>
  38 #ifdef HAVE_SYS_SOCKET_H
  39 # include <sys/socket.h>
  40 #endif
  41 #ifdef HAVE_SYS_TIME_H
  42 # include <sys/time.h>
  43 #endif
  44 #include <stdlib.h>
  45 #include <ctype.h>
  46 #ifdef HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #endif
  49 #include <assert.h>
  50
  51 #include "windef.h"
  52 #include "winbase.h"
  53 #include "winreg.h"
  54 #include "winuser.h"
  55 #include "wininet.h"
  56 #include "winnls.h"
  57 #include "wine/debug.h"
  58 #include "winerror.h"
  59 #define NO_SHLWAPI_STREAM
  60 #include "shlwapi.h"
  61
  62 #include "wine/exception.h"
  63 #include "excpt.h"
  64
  65 #include "internet.h"
  66 #include "resource.h"
  67
  68 #include "wine/unicode.h"
  69 #include "wincrypt.h"
  70
  71 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
  72
  73 #define MAX_IDLE_WORKER 1000*60*1
  74 #define MAX_WORKER_THREADS 10
  75 #define RESPONSE_TIMEOUT        30
  76
  77 #define GET_HWININET_FROM_LPWININETFINDNEXT(lpwh) \
  78 (LPWININETAPPINFOW)(((LPWININETFTPSESSIONW)(lpwh->hdr.lpwhparent))->hdr.lpwhparent)
  79
  80
  81 typedef struct
  82 {
  83     DWORD  dwError;
  84     CHAR   response[MAX_REPLY_LEN];
  85 } WITHREADERROR, *LPWITHREADERROR;
  86
  87 static VOID INTERNET_CloseHandle(LPWININETHANDLEHEADER hdr);
  88 BOOL WINAPI INTERNET_FindNextFileW(LPWININETFINDNEXTW lpwh, LPVOID lpvFindData);
  89 HINTERNET WINAPI INTERNET_InternetOpenUrlW(LPWININETAPPINFOW hIC, LPCWSTR lpszUrl,
  90               LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext);
  91 static VOID INTERNET_ExecuteWork(void);
  92
  93 static DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES;
  94 static LONG dwNumThreads;
  95 static LONG dwNumIdleThreads;
  96 static LONG dwNumJobs;
  97 static HANDLE hEventArray[2];
  98 #define hQuitEvent hEventArray[0]
  99 #define hWorkEvent hEventArray[1]
 100 static CRITICAL_SECTION csQueue;
 101 static LPWORKREQUEST lpHeadWorkQueue;
 102 static LPWORKREQUEST lpWorkQueueTail;
 103 static HMODULE WININET_hModule;
 104
 105 #define HANDLE_CHUNK_SIZE 0x10
 106
 107 static CRITICAL_SECTION WININET_cs;
 108 static CRITICAL_SECTION_DEBUG WININET_cs_debug =
 109 {
 110     0, 0, &WININET_cs,
 111     { &WININET_cs_debug.ProcessLocksList, &WININET_cs_debug.ProcessLocksList },
 112       0, 0, { (DWORD_PTR)(__FILE__ ": WININET_cs") }
 113 };
 114 static CRITICAL_SECTION WININET_cs = { &WININET_cs_debug, -1, 0, 0, 0, 0 };
 115
 116 static LPWININETHANDLEHEADER *WININET_Handles;
 117 static UINT WININET_dwNextHandle;
 118 static UINT WININET_dwMaxHandles;
 119
 120 HINTERNET WININET_AllocHandle( LPWININETHANDLEHEADER info )
 121 {
 122     LPWININETHANDLEHEADER *p;
 123     UINT handle = 0, num;
 124
 125     EnterCriticalSection( &WININET_cs );
 126     if( !WININET_dwMaxHandles )
 127     {
 128         num = HANDLE_CHUNK_SIZE;
 129         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 130                    sizeof (UINT)* num);
 131         if( !p )
 132             goto end;
 133         WININET_Handles = p;
 134         WININET_dwMaxHandles = num;
 135     }
 136     if( WININET_dwMaxHandles == WININET_dwNextHandle )
 137     {
 138         num = WININET_dwMaxHandles + HANDLE_CHUNK_SIZE;
 139         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 140                    WININET_Handles, sizeof (UINT)* num);
 141         if( !p )
 142             goto end;
 143         WININET_Handles = p;
 144         WININET_dwMaxHandles = num;
 145     }
 146
 147     handle = WININET_dwNextHandle;
 148     if( WININET_Handles[handle] )
 149         ERR("handle isn't free but should be\n");
 150     WININET_Handles[handle] = WININET_AddRef( info );
 151
 152     while( WININET_Handles[WININET_dwNextHandle] &&
 153            (WININET_dwNextHandle < WININET_dwMaxHandles ) )
 154         WININET_dwNextHandle++;
 155
 156 end:
 157     LeaveCriticalSection( &WININET_cs );
 158
 159     return (HINTERNET) (handle+1);
 160 }
 161
 162 HINTERNET WININET_FindHandle( LPWININETHANDLEHEADER info )
 163 {
 164     UINT i, handle = 0;
 165
 166     EnterCriticalSection( &WININET_cs );
 167     for( i=0; i<WININET_dwMaxHandles; i++ )
 168     {
 169         if( info == WININET_Handles[i] )
 170         {
 171             WININET_AddRef( info );
 172             handle = i+1;
 173             break;
 174         }
 175     }
 176     LeaveCriticalSection( &WININET_cs );
 177
 178     return (HINTERNET) handle;
 179 }
 180
 181 LPWININETHANDLEHEADER WININET_AddRef( LPWININETHANDLEHEADER info )
 182 {
 183     info->dwRefCount++;
 184     TRACE("%p -> refcount = %ld\n", info, info->dwRefCount );
 185     return info;
 186 }
 187
 188 LPWININETHANDLEHEADER WININET_GetObject( HINTERNET hinternet )
 189 {
 190     LPWININETHANDLEHEADER info = NULL;
 191     UINT handle = (UINT) hinternet;
 192
 193     EnterCriticalSection( &WININET_cs );
 194
 195     if( (handle > 0) && ( handle <= WININET_dwMaxHandles ) &&
 196         WININET_Handles[handle-1] )
 197         info = WININET_AddRef( WININET_Handles[handle-1] );
 198
 199     LeaveCriticalSection( &WININET_cs );
 200
 201     TRACE("handle %d -> %p\n", handle, info);
 202
 203     return info;
 204 }
 205
 206 BOOL WININET_Release( LPWININETHANDLEHEADER info )
 207 {
 208     info->dwRefCount--;
 209     TRACE( "object %p refcount = %ld\n", info, info->dwRefCount );
 210     if( !info->dwRefCount )
 211     {
 212         TRACE( "destroying object %p\n", info);
 213         info->destroy( info );
 214     }
 215     return TRUE;
 216 }
 217
 218 BOOL WININET_FreeHandle( HINTERNET hinternet )
 219 {
 220     BOOL ret = FALSE;
 221     UINT handle = (UINT) hinternet;
 222     LPWININETHANDLEHEADER info = NULL;
 223
 224     EnterCriticalSection( &WININET_cs );
 225
 226     if( (handle > 0) && ( handle <= WININET_dwMaxHandles ) )
 227     {
 228         handle--;
 229         if( WININET_Handles[handle] )
 230         {
 231             info = WININET_Handles[handle];
 232             TRACE( "destroying handle %d for object %p\n", handle+1, info);
 233             WININET_Handles[handle] = NULL;
 234             ret = TRUE;
 235             if( WININET_dwNextHandle > handle )
 236                 WININET_dwNextHandle = handle;
 237         }
 238     }
 239
 240     LeaveCriticalSection( &WININET_cs );
 241
 242     if( info )
 243         WININET_Release( info );
 244
 245     return ret;
 246 }
 247
 248 /***********************************************************************
 249  * DllMain [Internal] Initializes the internal 'WININET.DLL'.
 250  *
 251  * PARAMS
 252  *     hinstDLL    [I] handle to the DLL's instance
 253  *     fdwReason   [I]
 254  *     lpvReserved [I] reserved, must be NULL
 255  *
 256  * RETURNS
 257  *     Success: TRUE
 258  *     Failure: FALSE
 259  */
 260
 261 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 262 {
 263     TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
 264
 265     switch (fdwReason) {
 266         case DLL_PROCESS_ATTACH:
 267
 268             g_dwTlsErrIndex = TlsAlloc();
 269
 270             if (g_dwTlsErrIndex == TLS_OUT_OF_INDEXES)
 271                 return FALSE;
 272
 273             hQuitEvent = CreateEventW(0, TRUE, FALSE, NULL);
 274             hWorkEvent = CreateEventW(0, FALSE, FALSE, NULL);
 275             InitializeCriticalSection(&csQueue);
 276
 277             URLCacheContainers_CreateDefaults();
 278
 279             dwNumThreads = 0;
 280             dwNumIdleThreads = 0;
 281             dwNumJobs = 0;
 282
 283             WININET_hModule = (HMODULE)hinstDLL;
 284
 285         case DLL_THREAD_ATTACH:
 286             {
 287                 LPWITHREADERROR lpwite = HeapAlloc(GetProcessHeap(), 0, sizeof(WITHREADERROR));
 288                 if (NULL == lpwite)
 289                     return FALSE;
 290
 291                 TlsSetValue(g_dwTlsErrIndex, (LPVOID)lpwite);
 292             }
 293             break;
 294
 295         case DLL_THREAD_DETACH:
 296             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 297                         {
 298                                 LPVOID lpwite = TlsGetValue(g_dwTlsErrIndex);
 299                                 HeapFree(GetProcessHeap(), 0, lpwite);
 300                         }
 301             break;
 302
 303         case DLL_PROCESS_DETACH:
 304
 305             URLCacheContainers_DeleteAll();
 306
 307             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 308             {
 309                 HeapFree(GetProcessHeap(), 0, TlsGetValue(g_dwTlsErrIndex));
 310                 TlsFree(g_dwTlsErrIndex);
 311             }
 312
 313             SetEvent(hQuitEvent);
 314
 315             CloseHandle(hQuitEvent);
 316             CloseHandle(hWorkEvent);
 317             DeleteCriticalSection(&csQueue);
 318             break;
 319     }
 320
 321     return TRUE;
 322 }
 323
 324
 325 /***********************************************************************
 326  *           InternetInitializeAutoProxyDll   (WININET.@)
 327  *
 328  * Setup the internal proxy
 329  *
 330  * PARAMETERS
 331  *     dwReserved
 332  *
 333  * RETURNS
 334  *     FALSE on failure
 335  *
 336  */
 337 BOOL WINAPI InternetInitializeAutoProxyDll(DWORD dwReserved)
 338 {
 339     FIXME("STUB\n");
 340     INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 341     return FALSE;
 342 }
 343
 344 /***********************************************************************
 345  *           DetectAutoProxyUrl   (WININET.@)
 346  *
 347  * Auto detect the proxy url
 348  *
 349  * RETURNS
 350  *     FALSE on failure
 351  *
 352  */
 353 BOOL WINAPI DetectAutoProxyUrl(LPSTR lpszAutoProxyUrl,
 354         DWORD dwAutoProxyUrlLength, DWORD dwDetectFlags)
 355 {
 356     FIXME("STUB\n");
 357     INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 358     return FALSE;
 359 }
 360
 361
 362 /***********************************************************************
 363  *           INTERNET_ConfigureProxyFromReg
 364  *
 365  * FIXME:
 366  * The proxy may be specified in the form 'http=proxy.my.org'
 367  * Presumably that means there can be ftp=ftpproxy.my.org too.
 368  */
 369 static BOOL INTERNET_ConfigureProxyFromReg( LPWININETAPPINFOW lpwai )
 370 {
 371     HKEY key;
 372     DWORD r, keytype, len, enabled;
 373     LPCSTR lpszInternetSettings =
 374         "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
 375     static const WCHAR szProxyServer[] = { 'P','r','o','x','y','S','e','r','v','e','r', 0 };
 376
 377     r = RegOpenKeyA(HKEY_CURRENT_USER, lpszInternetSettings, &key);
 378     if ( r != ERROR_SUCCESS )
 379         return FALSE;
 380
 381     len = sizeof enabled;
 382     r = RegQueryValueExA( key, "ProxyEnable", NULL, &keytype,
 383                           (BYTE*)&enabled, &len);
 384     if( (r == ERROR_SUCCESS) && enabled )
 385     {
 386         TRACE("Proxy is enabled.\n");
 387
 388         /* figure out how much memory the proxy setting takes */
 389         r = RegQueryValueExW( key, szProxyServer, NULL, &keytype,
 390                               NULL, &len);
 391         if( (r == ERROR_SUCCESS) && len && (keytype == REG_SZ) )
 392         {
 393             LPWSTR szProxy, p;
 394             static const WCHAR szHttp[] = {'h','t','t','p','=',0};
 395
 396             szProxy=HeapAlloc( GetProcessHeap(), 0, len );
 397             RegQueryValueExW( key, szProxyServer, NULL, &keytype,
 398                               (BYTE*)szProxy, &len);
 399
 400             /* find the http proxy, and strip away everything else */
 401             p = strstrW( szProxy, szHttp );
 402             if( p )
 403             {
 404                  p += lstrlenW(szHttp);
 405                  lstrcpyW( szProxy, p );
 406             }
 407             p = strchrW( szProxy, ' ' );
 408             if( p )
 409                 *p = 0;
 410
 411             lpwai->dwAccessType = INTERNET_OPEN_TYPE_PROXY;
 412             lpwai->lpszProxy = szProxy;
 413
 414             TRACE("http proxy = %s\n", debugstr_w(lpwai->lpszProxy));
 415         }
 416         else
 417             ERR("Couldn't read proxy server settings.\n");
 418     }
 419     else
 420         TRACE("Proxy is not enabled.\n");
 421     RegCloseKey(key);
 422
 423     return enabled;
 424 }
 425
 426 /***********************************************************************
 427  *           dump_INTERNET_FLAGS
 428  *
 429  * Helper function to TRACE the internet flags.
 430  *
 431  * RETURNS
 432  *    None
 433  *
 434  */
 435 static void dump_INTERNET_FLAGS(DWORD dwFlags)
 436 {
 437 #define FE(x) { x, #x }
 438     static const wininet_flag_info flag[] = {
 439         FE(INTERNET_FLAG_RELOAD),
 440         FE(INTERNET_FLAG_RAW_DATA),
 441         FE(INTERNET_FLAG_EXISTING_CONNECT),
 442         FE(INTERNET_FLAG_ASYNC),
 443         FE(INTERNET_FLAG_PASSIVE),
 444         FE(INTERNET_FLAG_NO_CACHE_WRITE),
 445         FE(INTERNET_FLAG_MAKE_PERSISTENT),
 446         FE(INTERNET_FLAG_FROM_CACHE),
 447         FE(INTERNET_FLAG_SECURE),
 448         FE(INTERNET_FLAG_KEEP_CONNECTION),
 449         FE(INTERNET_FLAG_NO_AUTO_REDIRECT),
 450         FE(INTERNET_FLAG_READ_PREFETCH),
 451         FE(INTERNET_FLAG_NO_COOKIES),
 452         FE(INTERNET_FLAG_NO_AUTH),
 453         FE(INTERNET_FLAG_CACHE_IF_NET_FAIL),
 454         FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP),
 455         FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS),
 456         FE(INTERNET_FLAG_IGNORE_CERT_DATE_INVALID),
 457         FE(INTERNET_FLAG_IGNORE_CERT_CN_INVALID),
 458         FE(INTERNET_FLAG_RESYNCHRONIZE),
 459         FE(INTERNET_FLAG_HYPERLINK),
 460         FE(INTERNET_FLAG_NO_UI),
 461         FE(INTERNET_FLAG_PRAGMA_NOCACHE),
 462         FE(INTERNET_FLAG_CACHE_ASYNC),
 463         FE(INTERNET_FLAG_FORMS_SUBMIT),
 464         FE(INTERNET_FLAG_NEED_FILE),
 465         FE(INTERNET_FLAG_TRANSFER_ASCII),
 466         FE(INTERNET_FLAG_TRANSFER_BINARY)
 467     };
 468 #undef FE
 469     int i;
 470
 471     for (i = 0; i < (sizeof(flag) / sizeof(flag[0])); i++) {
 472         if (flag[i].val & dwFlags) {
 473             TRACE(" %s", flag[i].name);
 474             dwFlags &= ~flag[i].val;
 475         }
 476     }
 477     if (dwFlags)
 478         TRACE(" Unknown flags (%08lx)\n", dwFlags);
 479     else
 480         TRACE("\n");
 481 }
 482
 483 /***********************************************************************
 484  *           InternetOpenW   (WININET.@)
 485  *
 486  * Per-application initialization of wininet
 487  *
 488  * RETURNS
 489  *    HINTERNET on success
 490  *    NULL on failure
 491  *
 492  */
 493 HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType,
 494     LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
 495 {
 496     LPWININETAPPINFOW lpwai = NULL;
 497     HINTERNET handle = NULL;
 498
 499     if (TRACE_ON(wininet)) {
 500 #define FE(x) { x, #x }
 501         static const wininet_flag_info access_type[] = {
 502             FE(INTERNET_OPEN_TYPE_PRECONFIG),
 503             FE(INTERNET_OPEN_TYPE_DIRECT),
 504             FE(INTERNET_OPEN_TYPE_PROXY),
 505             FE(INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY)
 506         };
 507 #undef FE
 508         DWORD i;
 509         const char *access_type_str = "Unknown";
 510
 511         TRACE("(%s, %li, %s, %s, %li)\n", debugstr_w(lpszAgent), dwAccessType,
 512               debugstr_w(lpszProxy), debugstr_w(lpszProxyBypass), dwFlags);
 513         for (i = 0; i < (sizeof(access_type) / sizeof(access_type[0])); i++) {
 514             if (access_type[i].val == dwAccessType) {
 515                 access_type_str = access_type[i].name;
 516                 break;
 517             }
 518         }
 519         TRACE("  access type : %s\n", access_type_str);
 520         TRACE("  flags       :");
 521         dump_INTERNET_FLAGS(dwFlags);
 522     }
 523
 524     /* Clear any error information */
 525     INTERNET_SetLastError(0);
 526
 527     lpwai = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETAPPINFOW));
 528     if (NULL == lpwai)
 529     {
 530         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 531         goto lend;
 532     }
 533
 534     memset(lpwai, 0, sizeof(WININETAPPINFOW));
 535     lpwai->hdr.htype = WH_HINIT;
 536     lpwai->hdr.lpwhparent = NULL;
 537     lpwai->hdr.dwFlags = dwFlags;
 538     lpwai->hdr.dwRefCount = 1;
 539     lpwai->hdr.destroy = INTERNET_CloseHandle;
 540     lpwai->dwAccessType = dwAccessType;
 541     lpwai->lpszProxyUsername = NULL;
 542     lpwai->lpszProxyPassword = NULL;
 543
 544     handle = WININET_AllocHandle( &lpwai->hdr );
 545     if( !handle )
 546     {
 547         HeapFree( GetProcessHeap(), 0, lpwai );
 548         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 549         goto lend;
 550     }
 551
 552     if (NULL != lpszAgent)
 553     {
 554         lpwai->lpszAgent = HeapAlloc( GetProcessHeap(),0,
 555                                       (strlenW(lpszAgent)+1)*sizeof(WCHAR));
 556         if (lpwai->lpszAgent)
 557             lstrcpyW( lpwai->lpszAgent, lpszAgent );
 558     }
 559     if(dwAccessType == INTERNET_OPEN_TYPE_PRECONFIG)
 560         INTERNET_ConfigureProxyFromReg( lpwai );
 561     else if (NULL != lpszProxy)
 562     {
 563         lpwai->lpszProxy = HeapAlloc( GetProcessHeap(), 0,
 564                                       (strlenW(lpszProxy)+1)*sizeof(WCHAR));
 565         if (lpwai->lpszProxy)
 566             lstrcpyW( lpwai->lpszProxy, lpszProxy );
 567     }
 568
 569     if (NULL != lpszProxyBypass)
 570     {
 571         lpwai->lpszProxyBypass = HeapAlloc( GetProcessHeap(), 0,
 572                                      (strlenW(lpszProxyBypass)+1)*sizeof(WCHAR));
 573         if (lpwai->lpszProxyBypass)
 574             lstrcpyW( lpwai->lpszProxyBypass, lpszProxyBypass );
 575     }
 576
 577 lend:
 578     if( lpwai )
 579         WININET_Release( &lpwai->hdr );
 580
 581     TRACE("returning %p\n", lpwai);
 582
 583     return handle;
 584 }
 585
 586
 587 /***********************************************************************
 588  *           InternetOpenA   (WININET.@)
 589  *
 590  * Per-application initialization of wininet
 591  *
 592  * RETURNS
 593  *    HINTERNET on success
 594  *    NULL on failure
 595  *
 596  */
 597 HINTERNET WINAPI InternetOpenA(LPCSTR lpszAgent, DWORD dwAccessType,
 598     LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
 599 {
 600     HINTERNET rc = (HINTERNET)NULL;
 601     INT len;
 602     WCHAR *szAgent = NULL, *szProxy = NULL, *szBypass = NULL;
 603
 604     TRACE("(%s, 0x%08lx, %s, %s, 0x%08lx)\n", debugstr_a(lpszAgent),
 605        dwAccessType, debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
 606
 607     if( lpszAgent )
 608     {
 609         len = MultiByteToWideChar(CP_ACP, 0, lpszAgent, -1, NULL, 0);
 610         szAgent = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 611         MultiByteToWideChar(CP_ACP, 0, lpszAgent, -1, szAgent, len);
 612     }
 613
 614     if( lpszProxy )
 615     {
 616         len = MultiByteToWideChar(CP_ACP, 0, lpszProxy, -1, NULL, 0);
 617         szProxy = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 618         MultiByteToWideChar(CP_ACP, 0, lpszProxy, -1, szProxy, len);
 619     }
 620
 621     if( lpszProxyBypass )
 622     {
 623         len = MultiByteToWideChar(CP_ACP, 0, lpszProxyBypass, -1, NULL, 0);
 624         szBypass = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 625         MultiByteToWideChar(CP_ACP, 0, lpszProxyBypass, -1, szBypass, len);
 626     }
 627
 628     rc = InternetOpenW(szAgent, dwAccessType, szProxy, szBypass, dwFlags);
 629
 630     HeapFree(GetProcessHeap(), 0, szAgent);
 631     HeapFree(GetProcessHeap(), 0, szProxy);
 632     HeapFree(GetProcessHeap(), 0, szBypass);
 633
 634     return rc;
 635 }
 636
 637 /***********************************************************************
 638  *           InternetGetLastResponseInfoA (WININET.@)
 639  *
 640  * Return last wininet error description on the calling thread
 641  *
 642  * RETURNS
 643  *    TRUE on success of writing to buffer
 644  *    FALSE on failure
 645  *
 646  */
 647 BOOL WINAPI InternetGetLastResponseInfoA(LPDWORD lpdwError,
 648     LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
 649 {
 650     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
 651
 652     TRACE("\n");
 653
 654     *lpdwError = lpwite->dwError;
 655     if (lpwite->dwError)
 656     {
 657         memcpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
 658         *lpdwBufferLength = strlen(lpszBuffer);
 659     }
 660     else
 661         *lpdwBufferLength = 0;
 662
 663     return TRUE;
 664 }
 665
 666 /***********************************************************************
 667  *           InternetGetLastResponseInfoW (WININET.@)
 668  *
 669  * Return last wininet error description on the calling thread
 670  *
 671  * RETURNS
 672  *    TRUE on success of writing to buffer
 673  *    FALSE on failure
 674  *
 675  */
 676 BOOL WINAPI InternetGetLastResponseInfoW(LPDWORD lpdwError,
 677     LPWSTR lpszBuffer, LPDWORD lpdwBufferLength)
 678 {
 679     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
 680
 681     TRACE("\n");
 682
 683     *lpdwError = lpwite->dwError;
 684     if (lpwite->dwError)
 685     {
 686         memcpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
 687         *lpdwBufferLength = lstrlenW(lpszBuffer);
 688     }
 689     else
 690         *lpdwBufferLength = 0;
 691
 692     return TRUE;
 693 }
 694
 695 /***********************************************************************
 696  *           InternetGetConnectedState (WININET.@)
 697  *
 698  * Return connected state
 699  *
 700  * RETURNS
 701  *    TRUE if connected
 702  *    if lpdwStatus is not null, return the status (off line,
 703  *    modem, lan...) in it.
 704  *    FALSE if not connected
 705  */
 706 BOOL WINAPI InternetGetConnectedState(LPDWORD lpdwStatus, DWORD dwReserved)
 707 {
 708     TRACE("(%p, 0x%08lx)\n", lpdwStatus, dwReserved);
 709
 710     if (lpdwStatus) {
 711         FIXME("always returning LAN connection.\n");
 712         *lpdwStatus = INTERNET_CONNECTION_LAN;
 713     }
 714     return TRUE;
 715 }
 716
 717
 718 /***********************************************************************
 719  *           InternetGetConnectedStateExW (WININET.@)
 720  *
 721  * Return connected state
 722  *
 723  * PARAMS
 724  *
 725  * lpdwStatus         [O] Flags specifying the status of the internet connection.
 726  * lpszConnectionName [O] Pointer to buffer to receive the friendly name of the internet connection.
 727  * dwNameLen          [I] Size of the buffer, in characters.
 728  * dwReserved         [I] Reserved. Must be set to 0.
 729  *
 730  * RETURNS
 731  *    TRUE if connected
 732  *    if lpdwStatus is not null, return the status (off line,
 733  *    modem, lan...) in it.
 734  *    FALSE if not connected
 735  *
 736  * NOTES
 737  *   If the system has no available network connections, an empty string is
 738  *   stored in lpszConnectionName. If there is a LAN connection, a localized
 739  *   "LAN Connection" string is stored. Presumably, if only a dial-up
 740  *   connection is available then the name of the dial-up connection is
 741  *   returned. Why any application, other than the "Internet Settings" CPL,
 742  *   would want to use this function instead of the simpler InternetGetConnectedStateW
 743  *   function is beyond me.
 744  */
 745 BOOL WINAPI InternetGetConnectedStateExW(LPDWORD lpdwStatus, LPWSTR lpszConnectionName,
 746                                          DWORD dwNameLen, DWORD dwReserved)
 747 {
 748     TRACE("(%p, %p, %ld, 0x%08lx)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
 749
 750     /* Must be zero */
 751     if(dwReserved)
 752         return FALSE;
 753
 754     if (lpdwStatus) {
 755         FIXME("always returning LAN connection.\n");
 756         *lpdwStatus = INTERNET_CONNECTION_LAN;
 757     }
 758     return LoadStringW(WININET_hModule, IDS_LANCONNECTION, lpszConnectionName, dwNameLen);
 759 }
 760
 761
 762 /***********************************************************************
 763  *           InternetGetConnectedStateExA (WININET.@)
 764  */
 765 BOOL WINAPI InternetGetConnectedStateExA(LPDWORD lpdwStatus, LPSTR lpszConnectionName,
 766                                          DWORD dwNameLen, DWORD dwReserved)
 767 {
 768     LPWSTR lpwszConnectionName = NULL;
 769     BOOL rc;
 770
 771     TRACE("(%p, %p, %ld, 0x%08lx)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
 772
 773     if (lpszConnectionName && dwNameLen > 0)
 774         lpwszConnectionName= HeapAlloc(GetProcessHeap(), 0, dwNameLen * sizeof(WCHAR));
 775
 776     rc = InternetGetConnectedStateExW(lpdwStatus,lpwszConnectionName, dwNameLen,
 777                                       dwReserved);
 778     if (rc && lpwszConnectionName)
 779     {
 780         WideCharToMultiByte(CP_ACP,0,lpwszConnectionName,-1,lpszConnectionName,
 781                             dwNameLen, NULL, NULL);
 782
 783         HeapFree(GetProcessHeap(),0,lpwszConnectionName);
 784     }
 785
 786     return rc;
 787 }
 788
 789
 790 /***********************************************************************
 791  *           InternetConnectW (WININET.@)
 792  *
 793  * Open a ftp, gopher or http session
 794  *
 795  * RETURNS
 796  *    HINTERNET a session handle on success
 797  *    NULL on failure
 798  *
 799  */
 800 HINTERNET WINAPI InternetConnectW(HINTERNET hInternet,
 801     LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
 802     LPCWSTR lpszUserName, LPCWSTR lpszPassword,
 803     DWORD dwService, DWORD dwFlags, DWORD dwContext)
 804 {
 805     LPWININETAPPINFOW hIC;
 806     HINTERNET rc = (HINTERNET) NULL;
 807
 808     TRACE("(%p, %s, %i, %s, %s, %li, %li, %li)\n", hInternet, debugstr_w(lpszServerName),
 809           nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword),
 810           dwService, dwFlags, dwContext);
 811
 812     /* Clear any error information */
 813     INTERNET_SetLastError(0);
 814     hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
 815     if ( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
 816         goto lend;
 817
 818     switch (dwService)
 819     {
 820         case INTERNET_SERVICE_FTP:
 821             rc = FTP_Connect(hIC, lpszServerName, nServerPort,
 822             lpszUserName, lpszPassword, dwFlags, dwContext, 0);
 823             break;
 824
 825         case INTERNET_SERVICE_HTTP:
 826             rc = HTTP_Connect(hIC, lpszServerName, nServerPort,
 827             lpszUserName, lpszPassword, dwFlags, dwContext, 0);
 828             break;
 829
 830         case INTERNET_SERVICE_GOPHER:
 831         default:
 832             break;
 833     }
 834 lend:
 835     if( hIC )
 836         WININET_Release( &hIC->hdr );
 837
 838     TRACE("returning %p\n", rc);
 839     return rc;
 840 }
 841
 842
 843 /***********************************************************************
 844  *           InternetConnectA (WININET.@)
 845  *
 846  * Open a ftp, gopher or http session
 847  *
 848  * RETURNS
 849  *    HINTERNET a session handle on success
 850  *    NULL on failure
 851  *
 852  */
 853 HINTERNET WINAPI InternetConnectA(HINTERNET hInternet,
 854     LPCSTR lpszServerName, INTERNET_PORT nServerPort,
 855     LPCSTR lpszUserName, LPCSTR lpszPassword,
 856     DWORD dwService, DWORD dwFlags, DWORD dwContext)
 857 {
 858     HINTERNET rc = (HINTERNET)NULL;
 859     INT len = 0;
 860     LPWSTR szServerName = NULL;
 861     LPWSTR szUserName = NULL;
 862     LPWSTR szPassword = NULL;
 863
 864     if (lpszServerName)
 865     {
 866         len = MultiByteToWideChar(CP_ACP, 0, lpszServerName, -1, NULL, 0);
 867         szServerName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 868         MultiByteToWideChar(CP_ACP, 0, lpszServerName, -1, szServerName, len);
 869     }
 870     if (lpszUserName)
 871     {
 872         len = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
 873         szUserName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 874         MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, szUserName, len);
 875     }
 876     if (lpszPassword)
 877     {
 878         len = MultiByteToWideChar(CP_ACP, 0, lpszPassword, -1, NULL, 0);
 879         szPassword = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 880         MultiByteToWideChar(CP_ACP, 0, lpszPassword, -1, szPassword, len);
 881     }
 882
 883
 884     rc = InternetConnectW(hInternet, szServerName, nServerPort,
 885         szUserName, szPassword, dwService, dwFlags, dwContext);
 886
 887     HeapFree(GetProcessHeap(), 0, szServerName);
 888     HeapFree(GetProcessHeap(), 0, szUserName);
 889     HeapFree(GetProcessHeap(), 0, szPassword);
 890     return rc;
 891 }
 892
 893
 894 /***********************************************************************
 895  *           InternetFindNextFileA (WININET.@)
 896  *
 897  * Continues a file search from a previous call to FindFirstFile
 898  *
 899  * RETURNS
 900  *    TRUE on success
 901  *    FALSE on failure
 902  *
 903  */
 904 BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
 905 {
 906     BOOL ret;
 907     WIN32_FIND_DATAW fd;
 908
 909     ret = InternetFindNextFileW(hFind, lpvFindData?&fd:NULL);
 910     if(lpvFindData)
 911         WININET_find_data_WtoA(&fd, (LPWIN32_FIND_DATAA)lpvFindData);
 912     return ret;
 913 }
 914
 915 /***********************************************************************
 916  *           InternetFindNextFileW (WININET.@)
 917  *
 918  * Continues a file search from a previous call to FindFirstFile
 919  *
 920  * RETURNS
 921  *    TRUE on success
 922  *    FALSE on failure
 923  *
 924  */
 925 BOOL WINAPI InternetFindNextFileW(HINTERNET hFind, LPVOID lpvFindData)
 926 {
 927     LPWININETAPPINFOW hIC = NULL;
 928     LPWININETFINDNEXTW lpwh;
 929     BOOL bSuccess = FALSE;
 930
 931     TRACE("\n");
 932
 933     lpwh = (LPWININETFINDNEXTW) WININET_GetObject( hFind );
 934     if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
 935     {
 936         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 937         goto lend;
 938     }
 939
 940     hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
 941     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 942     {
 943         WORKREQUEST workRequest;
 944         struct WORKREQ_INTERNETFINDNEXTW *req;
 945
 946         workRequest.asyncall = INTERNETFINDNEXTW;
 947         workRequest.hdr = WININET_AddRef( &lpwh->hdr );
 948         req = &workRequest.u.InternetFindNextW;
 949         req->lpFindFileData = lpvFindData;
 950
 951         bSuccess = INTERNET_AsyncCall(&workRequest);
 952     }
 953     else
 954     {
 955         bSuccess = INTERNET_FindNextFileW(lpwh, lpvFindData);
 956     }
 957 lend:
 958     if( lpwh )
 959         WININET_Release( &lpwh->hdr );
 960     return bSuccess;
 961 }
 962
 963 /***********************************************************************
 964  *           INTERNET_FindNextFileW (Internal)
 965  *
 966  * Continues a file search from a previous call to FindFirstFile
 967  *
 968  * RETURNS
 969  *    TRUE on success
 970  *    FALSE on failure
 971  *
 972  */
 973 BOOL WINAPI INTERNET_FindNextFileW(LPWININETFINDNEXTW lpwh, LPVOID lpvFindData)
 974 {
 975     BOOL bSuccess = TRUE;
 976     LPWIN32_FIND_DATAW lpFindFileData;
 977
 978     TRACE("\n");
 979
 980     assert (lpwh->hdr.htype == WH_HFINDNEXT);
 981
 982     /* Clear any error information */
 983     INTERNET_SetLastError(0);
 984
 985     if (lpwh->hdr.lpwhparent->htype != WH_HFTPSESSION)
 986     {
 987         FIXME("Only FTP find next supported\n");
 988         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 989         return FALSE;
 990     }
 991
 992     TRACE("index(%ld) size(%ld)\n", lpwh->index, lpwh->size);
 993
 994     lpFindFileData = (LPWIN32_FIND_DATAW) lpvFindData;
 995     ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
 996
 997     if (lpwh->index >= lpwh->size)
 998     {
 999         INTERNET_SetLastError(ERROR_NO_MORE_FILES);
1000         bSuccess = FALSE;
1001         goto lend;
1002     }
1003
1004     FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData);
1005     lpwh->index++;
1006
1007     TRACE("\nName: %s\nSize: %ld\n", debugstr_w(lpFindFileData->cFileName), lpFindFileData->nFileSizeLow);
1008
1009 lend:
1010
1011     if (lpwh->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1012     {
1013         INTERNET_ASYNC_RESULT iar;
1014
1015         iar.dwResult = (DWORD)bSuccess;
1016         iar.dwError = iar.dwError = bSuccess ? ERROR_SUCCESS :
1017                                                INTERNET_GetLastError();
1018
1019         INTERNET_SendCallback(&lpwh->hdr, lpwh->hdr.dwContext,
1020                               INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1021                               sizeof(INTERNET_ASYNC_RESULT));
1022     }
1023
1024     return bSuccess;
1025 }
1026
1027
1028 /***********************************************************************
1029  *           INTERNET_CloseHandle (internal)
1030  *
1031  * Close internet handle
1032  *
1033  * RETURNS
1034  *    Void
1035  *
1036  */
1037 static VOID INTERNET_CloseHandle(LPWININETHANDLEHEADER hdr)
1038 {
1039     LPWININETAPPINFOW lpwai = (LPWININETAPPINFOW) hdr;
1040
1041     TRACE("%p\n",lpwai);
1042
1043     HeapFree(GetProcessHeap(), 0, lpwai->lpszAgent);
1044     HeapFree(GetProcessHeap(), 0, lpwai->lpszProxy);
1045     HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyBypass);
1046     HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyUsername);
1047     HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyPassword);
1048     HeapFree(GetProcessHeap(), 0, lpwai);
1049 }
1050
1051
1052 /***********************************************************************
1053  *           InternetCloseHandle (WININET.@)
1054  *
1055  * Generic close handle function
1056  *
1057  * RETURNS
1058  *    TRUE on success
1059  *    FALSE on failure
1060  *
1061  */
1062 BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
1063 {
1064     LPWININETHANDLEHEADER lpwh;
1065
1066     TRACE("%p\n",hInternet);
1067
1068     lpwh = WININET_GetObject( hInternet );
1069     if (NULL == lpwh)
1070     {
1071         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1072         return FALSE;
1073     }
1074
1075     /* FIXME: native appears to send this from the equivalent of
1076      * WININET_Release */
1077     INTERNET_SendCallback(lpwh, lpwh->dwContext,
1078                           INTERNET_STATUS_HANDLE_CLOSING, &hInternet,
1079                           sizeof(HINTERNET));
1080
1081     if( lpwh->lpwhparent )
1082         WININET_Release( lpwh->lpwhparent );
1083     WININET_FreeHandle( hInternet );
1084     WININET_Release( lpwh );
1085
1086     return TRUE;
1087 }
1088
1089
1090 /***********************************************************************
1091  *           ConvertUrlComponentValue (Internal)
1092  *
1093  * Helper function for InternetCrackUrlW
1094  *
1095  */
1096 static void ConvertUrlComponentValue(LPSTR* lppszComponent, LPDWORD dwComponentLen,
1097                                      LPWSTR lpwszComponent, DWORD dwwComponentLen,
1098                                      LPCSTR lpszStart, LPCWSTR lpwszStart)
1099 {
1100     TRACE("%p %ld %p %ld %p %p\n", lppszComponent, *dwComponentLen, lpwszComponent, dwwComponentLen, lpszStart, lpwszStart);
1101     if (*dwComponentLen != 0)
1102     {
1103         DWORD nASCIILength=WideCharToMultiByte(CP_ACP,0,lpwszComponent,dwwComponentLen,NULL,0,NULL,NULL);
1104         if (*lppszComponent == NULL)
1105         {
1106             int nASCIIOffset=WideCharToMultiByte(CP_ACP,0,lpwszStart,lpwszComponent-lpwszStart,NULL,0,NULL,NULL);
1107             if (lpwszComponent)
1108                 *lppszComponent = (LPSTR)lpszStart+nASCIIOffset;
1109             else
1110                 *lppszComponent = NULL;
1111             *dwComponentLen = nASCIILength;
1112         }
1113         else
1114         {
1115             DWORD ncpylen = min((*dwComponentLen)-1, nASCIILength);
1116             WideCharToMultiByte(CP_ACP,0,lpwszComponent,dwwComponentLen,*lppszComponent,ncpylen+1,NULL,NULL);
1117             (*lppszComponent)[ncpylen]=0;
1118             *dwComponentLen = ncpylen;
1119         }
1120     }
1121 }
1122
1123
1124 /***********************************************************************
1125  *           InternetCrackUrlA (WININET.@)
1126  *
1127  * See InternetCrackUrlW.
1128  */
1129 BOOL WINAPI InternetCrackUrlA(LPCSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags,
1130     LPURL_COMPONENTSA lpUrlComponents)
1131 {
1132   DWORD nLength;
1133   URL_COMPONENTSW UCW;
1134   WCHAR* lpwszUrl;
1135
1136   TRACE("(%s %lu %lx %p)\n", debugstr_a(lpszUrl), dwUrlLength, dwFlags, lpUrlComponents);
1137   if(dwUrlLength<=0)
1138       dwUrlLength=-1;
1139   nLength=MultiByteToWideChar(CP_ACP,0,lpszUrl,dwUrlLength,NULL,0);
1140
1141   /* if dwUrlLength=-1 then nLength includes null but length to
1142        InternetCrackUrlW should not include it                  */
1143   if (dwUrlLength == -1) nLength--;
1144
1145   lpwszUrl=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR)*nLength);
1146   MultiByteToWideChar(CP_ACP,0,lpszUrl,dwUrlLength,lpwszUrl,nLength);
1147
1148   memset(&UCW,0,sizeof(UCW));
1149   if(lpUrlComponents->dwHostNameLength!=0)
1150       UCW.dwHostNameLength= lpUrlComponents->dwHostNameLength;
1151   if(lpUrlComponents->dwUserNameLength!=0)
1152       UCW.dwUserNameLength=lpUrlComponents->dwUserNameLength;
1153   if(lpUrlComponents->dwPasswordLength!=0)
1154       UCW.dwPasswordLength=lpUrlComponents->dwPasswordLength;
1155   if(lpUrlComponents->dwUrlPathLength!=0)
1156       UCW.dwUrlPathLength=lpUrlComponents->dwUrlPathLength;
1157   if(lpUrlComponents->dwSchemeLength!=0)
1158       UCW.dwSchemeLength=lpUrlComponents->dwSchemeLength;
1159   if(lpUrlComponents->dwExtraInfoLength!=0)
1160       UCW.dwExtraInfoLength=lpUrlComponents->dwExtraInfoLength;
1161   if(!InternetCrackUrlW(lpwszUrl,nLength,dwFlags,&UCW))
1162   {
1163       HeapFree(GetProcessHeap(), 0, lpwszUrl);
1164       return FALSE;
1165   }
1166
1167   ConvertUrlComponentValue(&lpUrlComponents->lpszHostName, &lpUrlComponents->dwHostNameLength,
1168                            UCW.lpszHostName, UCW.dwHostNameLength,
1169                            lpszUrl, lpwszUrl);
1170   ConvertUrlComponentValue(&lpUrlComponents->lpszUserName, &lpUrlComponents->dwUserNameLength,
1171                            UCW.lpszUserName, UCW.dwUserNameLength,
1172                            lpszUrl, lpwszUrl);
1173   ConvertUrlComponentValue(&lpUrlComponents->lpszPassword, &lpUrlComponents->dwPasswordLength,
1174                            UCW.lpszPassword, UCW.dwPasswordLength,
1175                            lpszUrl, lpwszUrl);
1176   ConvertUrlComponentValue(&lpUrlComponents->lpszUrlPath, &lpUrlComponents->dwUrlPathLength,
1177                            UCW.lpszUrlPath, UCW.dwUrlPathLength,
1178                            lpszUrl, lpwszUrl);
1179   ConvertUrlComponentValue(&lpUrlComponents->lpszScheme, &lpUrlComponents->dwSchemeLength,
1180                            UCW.lpszScheme, UCW.dwSchemeLength,
1181                            lpszUrl, lpwszUrl);
1182   ConvertUrlComponentValue(&lpUrlComponents->lpszExtraInfo, &lpUrlComponents->dwExtraInfoLength,
1183                            UCW.lpszExtraInfo, UCW.dwExtraInfoLength,
1184                            lpszUrl, lpwszUrl);
1185   lpUrlComponents->nScheme=UCW.nScheme;
1186   lpUrlComponents->nPort=UCW.nPort;
1187   HeapFree(GetProcessHeap(), 0, lpwszUrl);
1188
1189   TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", lpszUrl,
1190           debugstr_an(lpUrlComponents->lpszScheme,lpUrlComponents->dwSchemeLength),
1191           debugstr_an(lpUrlComponents->lpszHostName,lpUrlComponents->dwHostNameLength),
1192           debugstr_an(lpUrlComponents->lpszUrlPath,lpUrlComponents->dwUrlPathLength),
1193           debugstr_an(lpUrlComponents->lpszExtraInfo,lpUrlComponents->dwExtraInfoLength));
1194
1195   return TRUE;
1196 }
1197
1198 static const WCHAR url_schemes[][7] =
1199 {
1200     {'f','t','p',0},
1201     {'g','o','p','h','e','r',0},
1202     {'h','t','t','p',0},
1203     {'h','t','t','p','s',0},
1204     {'f','i','l','e',0},
1205     {'n','e','w','s',0},
1206     {'m','a','i','l','t','o',0},
1207     {'r','e','s',0},
1208 };
1209
1210 /***********************************************************************
1211  *           GetInternetSchemeW (internal)
1212  *
1213  * Get scheme of url
1214  *
1215  * RETURNS
1216  *    scheme on success
1217  *    INTERNET_SCHEME_UNKNOWN on failure
1218  *
1219  */
1220 static INTERNET_SCHEME GetInternetSchemeW(LPCWSTR lpszScheme, DWORD nMaxCmp)
1221 {
1222     int i;
1223
1224     TRACE("%s %ld\n",debugstr_wn(lpszScheme, nMaxCmp), nMaxCmp);
1225
1226     if(lpszScheme==NULL)
1227         return INTERNET_SCHEME_UNKNOWN;
1228
1229     for (i = 0; i < sizeof(url_schemes)/sizeof(url_schemes[0]); i++)
1230         if (!strncmpW(lpszScheme, url_schemes[i], nMaxCmp))
1231             return INTERNET_SCHEME_FIRST + i;
1232
1233     return INTERNET_SCHEME_UNKNOWN;
1234 }
1235
1236 /***********************************************************************
1237  *           SetUrlComponentValueW (Internal)
1238  *
1239  * Helper function for InternetCrackUrlW
1240  *
1241  * PARAMS
1242  *     lppszComponent [O] Holds the returned string
1243  *     dwComponentLen [I] Holds the size of lppszComponent
1244  *                    [O] Holds the length of the string in lppszComponent without '\0'
1245  *     lpszStart      [I] Holds the string to copy from
1246  *     len            [I] Holds the length of lpszStart without '\0'
1247  *
1248  * RETURNS
1249  *    TRUE on success
1250  *    FALSE on failure
1251  *
1252  */
1253 static BOOL SetUrlComponentValueW(LPWSTR* lppszComponent, LPDWORD dwComponentLen, LPCWSTR lpszStart, DWORD len)
1254 {
1255     TRACE("%s (%ld)\n", debugstr_wn(lpszStart,len), len);
1256
1257     if ( (*dwComponentLen == 0) && (*lppszComponent == NULL) )
1258         return FALSE;
1259
1260     if (*dwComponentLen != 0 || *lppszComponent == NULL)
1261     {
1262         if (*lppszComponent == NULL)
1263         {
1264             *lppszComponent = (LPWSTR)lpszStart;
1265             *dwComponentLen = len;
1266         }
1267         else
1268         {
1269             DWORD ncpylen = min((*dwComponentLen)-1, len);
1270             memcpy(*lppszComponent, lpszStart, ncpylen*sizeof(WCHAR));
1271             (*lppszComponent)[ncpylen] = '\0';
1272             *dwComponentLen = ncpylen;
1273         }
1274     }
1275
1276     return TRUE;
1277 }
1278
1279 /***********************************************************************
1280  *           InternetCrackUrlW   (WININET.@)
1281  *
1282  * Break up URL into its components
1283  *
1284  * RETURNS
1285  *    TRUE on success
1286  *    FALSE on failure
1287  */
1288 BOOL WINAPI InternetCrackUrlW(LPCWSTR lpszUrl_orig, DWORD dwUrlLength_orig, DWORD dwFlags,
1289                               LPURL_COMPONENTSW lpUC)
1290 {
1291   /*
1292    * RFC 1808
1293    * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
1294    *
1295    */
1296     LPCWSTR lpszParam    = NULL;
1297     BOOL  bIsAbsolute = FALSE;
1298     LPCWSTR lpszap, lpszUrl = lpszUrl_orig;
1299     LPCWSTR lpszcp = NULL;
1300     LPWSTR  lpszUrl_decode = NULL;
1301     DWORD dwUrlLength = dwUrlLength_orig;
1302     const WCHAR lpszSeparators[3]={';','?',0};
1303     const WCHAR lpszSlash[2]={'/',0};
1304     if(dwUrlLength==0)
1305         dwUrlLength=strlenW(lpszUrl);
1306
1307     TRACE("(%s %lu %lx %p)\n", debugstr_w(lpszUrl), dwUrlLength, dwFlags, lpUC);
1308     if (dwFlags & ICU_DECODE)
1309     {
1310         lpszUrl_decode=HeapAlloc( GetProcessHeap(), 0,  dwUrlLength * sizeof (WCHAR) );
1311         if( InternetCanonicalizeUrlW(lpszUrl_orig, lpszUrl_decode, &dwUrlLength, dwFlags))
1312         {
1313             lpszUrl =  lpszUrl_decode;
1314         }
1315     }
1316     lpszap = lpszUrl;
1317
1318     /* Determine if the URI is absolute. */
1319     while (*lpszap != '\0')
1320     {
1321         if (isalnumW(*lpszap))
1322         {
1323             lpszap++;
1324             continue;
1325         }
1326         if ((*lpszap == ':') && (lpszap - lpszUrl >= 2))
1327         {
1328             bIsAbsolute = TRUE;
1329             lpszcp = lpszap;
1330         }
1331         else
1332         {
1333             lpszcp = lpszUrl; /* Relative url */
1334         }
1335
1336         break;
1337     }
1338
1339     lpUC->nScheme = INTERNET_SCHEME_UNKNOWN;
1340     lpUC->nPort = INTERNET_INVALID_PORT_NUMBER;
1341
1342     /* Parse <params> */
1343     lpszParam = strpbrkW(lpszap, lpszSeparators);
1344     SetUrlComponentValueW(&lpUC->lpszExtraInfo, &lpUC->dwExtraInfoLength,
1345                           lpszParam, lpszParam ? dwUrlLength-(lpszParam-lpszUrl) : 0);
1346
1347     if (bIsAbsolute) /* Parse <protocol>:[//<net_loc>] */
1348     {
1349         LPCWSTR lpszNetLoc;
1350
1351         /* Get scheme first. */
1352         lpUC->nScheme = GetInternetSchemeW(lpszUrl, lpszcp - lpszUrl);
1353         SetUrlComponentValueW(&lpUC->lpszScheme, &lpUC->dwSchemeLength,
1354                                    lpszUrl, lpszcp - lpszUrl);
1355
1356         /* Eat ':' in protocol. */
1357         lpszcp++;
1358
1359         /* double slash indicates the net_loc portion is present */
1360         if ((lpszcp[0] == '/') && (lpszcp[1] == '/'))
1361         {
1362             lpszcp += 2;
1363
1364             lpszNetLoc = strpbrkW(lpszcp, lpszSlash);
1365             if (lpszParam)
1366             {
1367                 if (lpszNetLoc)
1368                     lpszNetLoc = min(lpszNetLoc, lpszParam);
1369                 else
1370                     lpszNetLoc = lpszParam;
1371             }
1372             else if (!lpszNetLoc)
1373                 lpszNetLoc = lpszcp + dwUrlLength-(lpszcp-lpszUrl);
1374
1375             /* Parse net-loc */
1376             if (lpszNetLoc)
1377             {
1378                 LPCWSTR lpszHost;
1379                 LPCWSTR lpszPort;
1380
1381                 /* [<user>[<:password>]@]<host>[:<port>] */
1382                 /* First find the user and password if they exist */
1383
1384                 lpszHost = strchrW(lpszcp, '@');
1385                 if (lpszHost == NULL || lpszHost > lpszNetLoc)
1386                 {
1387                     /* username and password not specified. */
1388                     SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
1389                     SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
1390                 }
1391                 else /* Parse out username and password */
1392                 {
1393                     LPCWSTR lpszUser = lpszcp;
1394                     LPCWSTR lpszPasswd = lpszHost;
1395
1396                     while (lpszcp < lpszHost)
1397                     {
1398                         if (*lpszcp == ':')
1399                             lpszPasswd = lpszcp;
1400
1401                         lpszcp++;
1402                     }
1403
1404                     SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength,
1405                                           lpszUser, lpszPasswd - lpszUser);
1406
1407                     if (lpszPasswd != lpszHost)
1408                         lpszPasswd++;
1409                     SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength,
1410                                           lpszPasswd == lpszHost ? NULL : lpszPasswd,
1411                                           lpszHost - lpszPasswd);
1412
1413                     lpszcp++; /* Advance to beginning of host */
1414                 }
1415
1416                 /* Parse <host><:port> */
1417
1418                 lpszHost = lpszcp;
1419                 lpszPort = lpszNetLoc;
1420
1421                 /* special case for res:// URLs: there is no port here, so the host is the
1422                    entire string up to the first '/' */
1423                 if(lpUC->nScheme==INTERNET_SCHEME_RES)
1424                 {
1425                     SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1426                                           lpszHost, lpszPort - lpszHost);
1427                     lpszcp=lpszNetLoc;
1428                 }
1429                 else
1430                 {
1431                     while (lpszcp < lpszNetLoc)
1432                     {
1433                         if (*lpszcp == ':')
1434                             lpszPort = lpszcp;
1435
1436                         lpszcp++;
1437                     }
1438
1439                     /* If the scheme is "file" and the host is just one letter, it's not a host */
1440                     if(lpUC->nScheme==INTERNET_SCHEME_FILE && (lpszPort-lpszHost)==1)
1441                     {
1442                         lpszcp=lpszHost;
1443                         SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1444                                               NULL, 0);
1445                     }
1446                     else
1447                     {
1448                         SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1449                                               lpszHost, lpszPort - lpszHost);
1450                         if (lpszPort != lpszNetLoc)
1451                             lpUC->nPort = atoiW(++lpszPort);
1452                         else switch (lpUC->nScheme)
1453                         {
1454                         case INTERNET_SCHEME_HTTP:
1455                             lpUC->nPort = INTERNET_DEFAULT_HTTP_PORT;
1456                             break;
1457                         case INTERNET_SCHEME_HTTPS:
1458                             lpUC->nPort = INTERNET_DEFAULT_HTTPS_PORT;
1459                             break;
1460                         case INTERNET_SCHEME_FTP:
1461                             lpUC->nPort = INTERNET_DEFAULT_FTP_PORT;
1462                             break;
1463                         case INTERNET_SCHEME_GOPHER:
1464                             lpUC->nPort = INTERNET_DEFAULT_GOPHER_PORT;
1465                             break;
1466                         default:
1467                             break;
1468                         }
1469                     }
1470                 }
1471             }
1472         }
1473         else
1474         {
1475             SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
1476             SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
1477             SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength, NULL, 0);
1478         }
1479     }
1480     else
1481     {
1482         SetUrlComponentValueW(&lpUC->lpszScheme, &lpUC->dwSchemeLength, NULL, 0);
1483         SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
1484         SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
1485         SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength, NULL, 0);
1486     }
1487
1488     /* Here lpszcp points to:
1489      *
1490      * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
1491      *                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1492      */
1493     if (lpszcp != 0 && *lpszcp != '\0' && (!lpszParam || lpszcp < lpszParam))
1494     {
1495         INT len;
1496
1497         /* Only truncate the parameter list if it's already been saved
1498          * in lpUC->lpszExtraInfo.
1499          */
1500         if (lpszParam && lpUC->dwExtraInfoLength && lpUC->lpszExtraInfo)
1501             len = lpszParam - lpszcp;
1502         else
1503         {
1504             /* Leave the parameter list in lpszUrlPath.  Strip off any trailing
1505              * newlines if necessary.
1506              */
1507             LPWSTR lpsznewline = strchrW(lpszcp, '\n');
1508             if (lpsznewline != NULL)
1509                 len = lpsznewline - lpszcp;
1510             else
1511                 len = dwUrlLength-(lpszcp-lpszUrl);
1512         }
1513         SetUrlComponentValueW(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength,
1514                                    lpszcp, len);
1515     }
1516     else
1517     {
1518         lpUC->dwUrlPathLength = 0;
1519     }
1520
1521     TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", debugstr_wn(lpszUrl,dwUrlLength),
1522              debugstr_wn(lpUC->lpszScheme,lpUC->dwSchemeLength),
1523              debugstr_wn(lpUC->lpszHostName,lpUC->dwHostNameLength),
1524              debugstr_wn(lpUC->lpszUrlPath,lpUC->dwUrlPathLength),
1525              debugstr_wn(lpUC->lpszExtraInfo,lpUC->dwExtraInfoLength));
1526
1527     if (lpszUrl_decode)
1528          HeapFree(GetProcessHeap(), 0, lpszUrl_decode );
1529     return TRUE;
1530 }
1531
1532 /***********************************************************************
1533  *           InternetAttemptConnect (WININET.@)
1534  *
1535  * Attempt to make a connection to the internet
1536  *
1537  * RETURNS
1538  *    ERROR_SUCCESS on success
1539  *    Error value   on failure
1540  *
1541  */
1542 DWORD WINAPI InternetAttemptConnect(DWORD dwReserved)
1543 {
1544     FIXME("Stub\n");
1545     return ERROR_SUCCESS;
1546 }
1547
1548
1549 /***********************************************************************
1550  *           InternetCanonicalizeUrlA (WININET.@)
1551  *
1552  * Escape unsafe characters and spaces
1553  *
1554  * RETURNS
1555  *    TRUE on success
1556  *    FALSE on failure
1557  *
1558  */
1559 BOOL WINAPI InternetCanonicalizeUrlA(LPCSTR lpszUrl, LPSTR lpszBuffer,
1560         LPDWORD lpdwBufferLength, DWORD dwFlags)
1561 {
1562     HRESULT hr;
1563     DWORD dwURLFlags= 0x80000000; /* Don't know what this means */
1564     if(dwFlags & ICU_DECODE)
1565     {
1566         dwURLFlags |= URL_UNESCAPE;
1567         dwFlags &= ~ICU_DECODE;
1568     }
1569
1570     if(dwFlags & ICU_ESCAPE)
1571     {
1572         dwURLFlags |= URL_UNESCAPE;
1573         dwFlags &= ~ICU_ESCAPE;
1574     }
1575     if(dwFlags & ICU_BROWSER_MODE)
1576     {
1577         dwURLFlags |= URL_BROWSER_MODE;
1578         dwFlags &= ~ICU_BROWSER_MODE;
1579     }
1580     if(dwFlags)
1581         FIXME("Unhandled flags 0x%08lx\n", dwFlags);
1582     TRACE("%s %p %p %08lx\n", debugstr_a(lpszUrl), lpszBuffer,
1583         lpdwBufferLength, dwURLFlags);
1584
1585     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
1586     dwFlags ^= ICU_NO_ENCODE;
1587
1588     hr = UrlCanonicalizeA(lpszUrl, lpszBuffer, lpdwBufferLength, dwURLFlags);
1589
1590     return (hr == S_OK) ? TRUE : FALSE;
1591 }
1592
1593 /***********************************************************************
1594  *           InternetCanonicalizeUrlW (WININET.@)
1595  *
1596  * Escape unsafe characters and spaces
1597  *
1598  * RETURNS
1599  *    TRUE on success
1600  *    FALSE on failure
1601  *
1602  */
1603 BOOL WINAPI InternetCanonicalizeUrlW(LPCWSTR lpszUrl, LPWSTR lpszBuffer,
1604     LPDWORD lpdwBufferLength, DWORD dwFlags)
1605 {
1606     HRESULT hr;
1607     DWORD dwURLFlags= 0x80000000; /* Don't know what this means */
1608     if(dwFlags & ICU_DECODE)
1609     {
1610         dwURLFlags |= URL_UNESCAPE;
1611         dwFlags &= ~ICU_DECODE;
1612     }
1613
1614     if(dwFlags & ICU_ESCAPE)
1615     {
1616         dwURLFlags |= URL_UNESCAPE;
1617         dwFlags &= ~ICU_ESCAPE;
1618     }
1619     if(dwFlags & ICU_BROWSER_MODE)
1620     {
1621         dwURLFlags |= URL_BROWSER_MODE;
1622         dwFlags &= ~ICU_BROWSER_MODE;
1623     }
1624     if(dwFlags)
1625         FIXME("Unhandled flags 0x%08lx\n", dwFlags);
1626     TRACE("%s %p %p %08lx\n", debugstr_w(lpszUrl), lpszBuffer,
1627         lpdwBufferLength, dwURLFlags);
1628
1629     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
1630     dwFlags ^= ICU_NO_ENCODE;
1631
1632     hr = UrlCanonicalizeW(lpszUrl, lpszBuffer, lpdwBufferLength, dwURLFlags);
1633
1634     return (hr == S_OK) ? TRUE : FALSE;
1635 }
1636
1637
1638 /***********************************************************************
1639  *           InternetSetStatusCallbackA (WININET.@)
1640  *
1641  * Sets up a callback function which is called as progress is made
1642  * during an operation.
1643  *
1644  * RETURNS
1645  *    Previous callback or NULL         on success
1646  *    INTERNET_INVALID_STATUS_CALLBACK  on failure
1647  *
1648  */
1649 INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackA(
1650         HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
1651 {
1652     INTERNET_STATUS_CALLBACK retVal;
1653     LPWININETHANDLEHEADER lpwh;
1654
1655     TRACE("0x%08lx\n", (ULONG)hInternet);
1656
1657     lpwh = WININET_GetObject(hInternet);
1658     if (!lpwh)
1659         return INTERNET_INVALID_STATUS_CALLBACK;
1660
1661     lpwh->dwInternalFlags &= ~INET_CALLBACKW;
1662     retVal = lpwh->lpfnStatusCB;
1663     lpwh->lpfnStatusCB = lpfnIntCB;
1664
1665     WININET_Release( lpwh );
1666
1667     return retVal;
1668 }
1669
1670 /***********************************************************************
1671  *           InternetSetStatusCallbackW (WININET.@)
1672  *
1673  * Sets up a callback function which is called as progress is made
1674  * during an operation.
1675  *
1676  * RETURNS
1677  *    Previous callback or NULL         on success
1678  *    INTERNET_INVALID_STATUS_CALLBACK  on failure
1679  *
1680  */
1681 INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackW(
1682         HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
1683 {
1684     INTERNET_STATUS_CALLBACK retVal;
1685     LPWININETHANDLEHEADER lpwh;
1686
1687     TRACE("0x%08lx\n", (ULONG)hInternet);
1688
1689     lpwh = WININET_GetObject(hInternet);
1690     if (!lpwh)
1691         return INTERNET_INVALID_STATUS_CALLBACK;
1692
1693     lpwh->dwInternalFlags |= INET_CALLBACKW;
1694     retVal = lpwh->lpfnStatusCB;
1695     lpwh->lpfnStatusCB = lpfnIntCB;
1696
1697     WININET_Release( lpwh );
1698
1699     return retVal;
1700 }
1701
1702 /***********************************************************************
1703  *           InternetSetFilePointer (WININET.@)
1704  */
1705 DWORD WINAPI InternetSetFilePointer(HINTERNET hFile, LONG lDistanceToMove,
1706     PVOID pReserved, DWORD dwMoveContext, DWORD dwContext)
1707 {
1708     FIXME("stub\n");
1709     return FALSE;
1710 }
1711
1712 /***********************************************************************
1713  *           InternetWriteFile (WININET.@)
1714  *
1715  * Write data to an open internet file
1716  *
1717  * RETURNS
1718  *    TRUE  on success
1719  *    FALSE on failure
1720  *
1721  */
1722 BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer ,
1723         DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
1724 {
1725     BOOL retval = FALSE;
1726     int nSocket = -1;
1727     LPWININETHANDLEHEADER lpwh;
1728
1729     TRACE("\n");
1730     lpwh = (LPWININETHANDLEHEADER) WININET_GetObject( hFile );
1731     if (NULL == lpwh)
1732         return FALSE;
1733
1734     switch (lpwh->htype)
1735     {
1736         case WH_HHTTPREQ:
1737             {
1738                 LPWININETHTTPREQW lpwhr;
1739                 lpwhr = (LPWININETHTTPREQW)lpwh;
1740
1741                 TRACE("HTTPREQ %li\n",dwNumOfBytesToWrite);
1742                 retval = NETCON_send(&lpwhr->netConnection, lpBuffer,
1743                         dwNumOfBytesToWrite, 0, (LPINT)lpdwNumOfBytesWritten);
1744
1745                 WININET_Release( lpwh );
1746                 return retval;
1747             }
1748             break;
1749
1750         case WH_HFILE:
1751             nSocket = ((LPWININETFILE)lpwh)->nDataSocket;
1752             break;
1753
1754         default:
1755             break;
1756     }
1757
1758     if (nSocket != -1)
1759     {
1760         int res = send(nSocket, lpBuffer, dwNumOfBytesToWrite, 0);
1761         retval = (res >= 0);
1762         *lpdwNumOfBytesWritten = retval ? res : 0;
1763     }
1764     WININET_Release( lpwh );
1765
1766     return retval;
1767 }
1768
1769
1770 static BOOL INTERNET_ReadFile(LPWININETHANDLEHEADER lpwh, LPVOID lpBuffer,
1771                               DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead,
1772                               BOOL bWait, BOOL bSendCompletionStatus)
1773 {
1774     BOOL retval = FALSE;
1775     int nSocket = -1;
1776
1777     /* FIXME: this should use NETCON functions! */
1778     switch (lpwh->htype)
1779     {
1780         case WH_HHTTPREQ:
1781             if (!NETCON_recv(&((LPWININETHTTPREQW)lpwh)->netConnection, lpBuffer,
1782                              dwNumOfBytesToRead, bWait ? MSG_WAITALL : 0, (int *)pdwNumOfBytesRead))
1783             {
1784                 *pdwNumOfBytesRead = 0;
1785                 retval = TRUE; /* Under windows, it seems to return 0 even if nothing was read... */
1786             }
1787             else
1788                 retval = TRUE;
1789             break;
1790
1791         case WH_HFILE:
1792             /* FIXME: FTP should use NETCON_ stuff */
1793             nSocket = ((LPWININETFILE)lpwh)->nDataSocket;
1794             if (nSocket != -1)
1795             {
1796                 int res = recv(nSocket, lpBuffer, dwNumOfBytesToRead, bWait ? MSG_WAITALL : 0);
1797                 retval = (res >= 0);
1798                 *pdwNumOfBytesRead = retval ? res : 0;
1799             }
1800             break;
1801
1802         default:
1803             break;
1804     }
1805
1806     if (bSendCompletionStatus)
1807     {
1808         INTERNET_ASYNC_RESULT iar;
1809
1810         iar.dwResult = retval;
1811         iar.dwError = iar.dwError = retval ? ERROR_SUCCESS :
1812                                              INTERNET_GetLastError();
1813
1814         INTERNET_SendCallback(lpwh, lpwh->dwContext,
1815                               INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1816                               sizeof(INTERNET_ASYNC_RESULT));
1817     }
1818     return retval;
1819 }
1820
1821 /***********************************************************************
1822  *           InternetReadFile (WININET.@)
1823  *
1824  * Read data from an open internet file
1825  *
1826  * RETURNS
1827  *    TRUE  on success
1828  *    FALSE on failure
1829  *
1830  */
1831 BOOL WINAPI InternetReadFile(HINTERNET hFile, LPVOID lpBuffer,
1832         DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead)
1833 {
1834     LPWININETHANDLEHEADER lpwh;
1835     BOOL retval;
1836
1837     TRACE("%p %p %ld %p\n", hFile, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
1838
1839     lpwh = WININET_GetObject( hFile );
1840     if (!lpwh)
1841     {
1842         SetLastError(ERROR_INVALID_HANDLE);
1843         return FALSE;
1844     }
1845
1846     retval = INTERNET_ReadFile(lpwh, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead, TRUE, FALSE);
1847     WININET_Release( lpwh );
1848
1849     TRACE("-- %s (bytes read: %ld)\n", retval ? "TRUE": "FALSE", pdwNumOfBytesRead ? *pdwNumOfBytesRead : -1);
1850     return retval;
1851 }
1852
1853 /***********************************************************************
1854  *           InternetReadFileExA (WININET.@)
1855  *
1856  * Read data from an open internet file
1857  *
1858  * PARAMS
1859  *  hFile         [I] Handle returned by InternetOpenUrl or HttpOpenRequest.
1860  *  lpBuffersOut  [I/O] Buffer.
1861  *  dwFlags       [I] Flags. See notes.
1862  *  dwContext     [I] Context for callbacks.
1863  *
1864  * RETURNS
1865  *    TRUE  on success
1866  *    FALSE on failure
1867  *
1868  * NOTES
1869  *  The parameter dwFlags include zero or more of the following flags:
1870  *|IRF_ASYNC - Makes the call asynchronous.
1871  *|IRF_SYNC - Makes the call synchronous.
1872  *|IRF_USE_CONTEXT - Forces dwContext to be used.
1873  *|IRF_NO_WAIT - Don't block if the data is not available, just return what is available.
1874  *
1875  * However, in testing IRF_USE_CONTEXT seems to have no effect - dwContext isn't used.
1876  *
1877  * SEE
1878  *  InternetOpenUrlA(), HttpOpenRequestA()
1879  */
1880 BOOL WINAPI InternetReadFileExA(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut,
1881         DWORD dwFlags, DWORD dwContext)
1882 {
1883     BOOL retval = FALSE;
1884     LPWININETHANDLEHEADER lpwh;
1885
1886     TRACE("(%p %p 0x%lx 0x%lx)\n", hFile, lpBuffersOut, dwFlags, dwContext);
1887
1888     if (dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT))
1889         FIXME("these dwFlags aren't implemented: 0x%lx\n", dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT));
1890
1891     if (lpBuffersOut->dwStructSize != sizeof(*lpBuffersOut))
1892     {
1893         SetLastError(ERROR_INVALID_PARAMETER);
1894         return FALSE;
1895     }
1896
1897     lpwh = (LPWININETHANDLEHEADER) WININET_GetObject( hFile );
1898     if (!lpwh)
1899     {
1900         SetLastError(ERROR_INVALID_HANDLE);
1901         return FALSE;
1902     }
1903
1904     /* FIXME: native only does it asynchronously if the amount of data
1905      * requested isn't available. See NtReadFile. */
1906     /* FIXME: IRF_ASYNC may not be the right thing to test here;
1907      * hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC is probably better, but
1908      * we should implement the above first */
1909     if (dwFlags & IRF_ASYNC)
1910     {
1911         WORKREQUEST workRequest;
1912         struct WORKREQ_INTERNETREADFILEEXA *req;
1913
1914         workRequest.asyncall = INTERNETREADFILEEXA;
1915         workRequest.hdr = WININET_AddRef( lpwh );
1916         req = &workRequest.u.InternetReadFileExA;
1917         req->lpBuffersOut = lpBuffersOut;
1918
1919         retval = INTERNET_AsyncCall(&workRequest);
1920         if (!retval) return FALSE;
1921
1922         SetLastError(ERROR_IO_PENDING);
1923         return FALSE;
1924     }
1925
1926     retval = INTERNET_ReadFile(lpwh, lpBuffersOut->lpvBuffer,
1927         lpBuffersOut->dwBufferLength, &lpBuffersOut->dwBufferLength,
1928         !(dwFlags & IRF_NO_WAIT), FALSE);
1929
1930     WININET_Release( lpwh );
1931
1932     TRACE("-- %s (bytes read: %ld)\n", retval ? "TRUE": "FALSE", lpBuffersOut->dwBufferLength);
1933     return retval;
1934 }
1935
1936 /***********************************************************************
1937  *           InternetReadFileExW (WININET.@)
1938  *
1939  * Read data from an open internet file.
1940  *
1941  * PARAMS
1942  *  hFile         [I] Handle returned by InternetOpenUrl() or HttpOpenRequest().
1943  *  lpBuffersOut  [I/O] Buffer.
1944  *  dwFlags       [I] Flags.
1945  *  dwContext     [I] Context for callbacks.
1946  *
1947  * RETURNS
1948  *    FALSE, last error is set to ERROR_CALL_NOT_IMPLEMENTED
1949  *
1950  * NOTES
1951  *  Not implemented in Wine or native either (as of IE6 SP2).
1952  *
1953  */
1954 BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
1955         DWORD dwFlags, DWORD dwContext)
1956 {
1957   ERR("(%p, %p, 0x%lx, 0x%lx): not implemented in native\n", hFile, lpBuffer, dwFlags, dwContext);
1958
1959   INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1960   return FALSE;
1961 }
1962
1963 /***********************************************************************
1964  *           INET_QueryOptionHelper (internal)
1965  */
1966 static BOOL INET_QueryOptionHelper(BOOL bIsUnicode, HINTERNET hInternet, DWORD dwOption,
1967                                    LPVOID lpBuffer, LPDWORD lpdwBufferLength)
1968 {
1969     LPWININETHANDLEHEADER lpwhh;
1970     BOOL bSuccess = FALSE;
1971
1972     TRACE("(%p, 0x%08lx, %p, %p)\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
1973
1974     lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
1975
1976     switch (dwOption)
1977     {
1978         case INTERNET_OPTION_HANDLE_TYPE:
1979         {
1980             ULONG type;
1981
1982             if (!lpwhh)
1983             {
1984                 WARN("Invalid hInternet handle\n");
1985                 SetLastError(ERROR_INVALID_HANDLE);
1986                 return FALSE;
1987             }
1988
1989             type = lpwhh->htype;
1990
1991             TRACE("INTERNET_OPTION_HANDLE_TYPE: %ld\n", type);
1992
1993             if (*lpdwBufferLength < sizeof(ULONG))
1994                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1995             else
1996             {
1997                 memcpy(lpBuffer, &type, sizeof(ULONG));
1998                 bSuccess = TRUE;
1999             }
2000             *lpdwBufferLength = sizeof(ULONG);
2001             break;
2002         }
2003
2004         case INTERNET_OPTION_REQUEST_FLAGS:
2005         {
2006             ULONG flags = 4;
2007             TRACE("INTERNET_OPTION_REQUEST_FLAGS: %ld\n", flags);
2008             if (*lpdwBufferLength < sizeof(ULONG))
2009                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2010             else
2011             {
2012                 memcpy(lpBuffer, &flags, sizeof(ULONG));
2013                 bSuccess = TRUE;
2014             }
2015             *lpdwBufferLength = sizeof(ULONG);
2016             break;
2017         }
2018
2019         case INTERNET_OPTION_URL:
2020         case INTERNET_OPTION_DATAFILE_NAME:
2021         {
2022             if (!lpwhh)
2023             {
2024                 WARN("Invalid hInternet handle\n");
2025                 SetLastError(ERROR_INVALID_HANDLE);
2026                 return FALSE;
2027             }
2028             if (lpwhh->htype == WH_HHTTPREQ)
2029             {
2030                 LPWININETHTTPREQW lpreq = (LPWININETHTTPREQW) lpwhh;
2031                 WCHAR url[1023];
2032                 static const WCHAR szFmt[] = {'h','t','t','p',':','/','/','%','s','%','s',0};
2033                 static const WCHAR szHost[] = {'H','o','s','t',0};
2034                 DWORD sizeRequired;
2035                 LPHTTPHEADERW Host;
2036
2037                 Host = HTTP_GetHeader(lpreq,szHost);
2038                 sprintfW(url,szFmt,Host->lpszValue,lpreq->lpszPath);
2039                 TRACE("INTERNET_OPTION_URL: %s\n",debugstr_w(url));
2040                 if(!bIsUnicode)
2041                 {
2042                     sizeRequired = WideCharToMultiByte(CP_ACP,0,url,-1,
2043                      lpBuffer,*lpdwBufferLength,NULL,NULL);
2044                     if (sizeRequired > *lpdwBufferLength)
2045                         INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2046                     else
2047                         bSuccess = TRUE;
2048                     *lpdwBufferLength = sizeRequired;
2049                 }
2050                 else
2051                 {
2052                     sizeRequired = (lstrlenW(url)+1) * sizeof(WCHAR);
2053                     if (*lpdwBufferLength < sizeRequired)
2054                         INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2055                     else
2056                     {
2057                         strcpyW(lpBuffer, url);
2058                         bSuccess = TRUE;
2059                     }
2060                     *lpdwBufferLength = sizeRequired;
2061                 }
2062             }
2063             break;
2064         }
2065         case INTERNET_OPTION_HTTP_VERSION:
2066         {
2067             if (*lpdwBufferLength < sizeof(HTTP_VERSION_INFO))
2068                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2069             else
2070             {
2071                 /*
2072                  * Presently hardcoded to 1.1
2073                  */
2074                 ((HTTP_VERSION_INFO*)lpBuffer)->dwMajorVersion = 1;
2075                 ((HTTP_VERSION_INFO*)lpBuffer)->dwMinorVersion = 1;
2076                 bSuccess = TRUE;
2077             }
2078             *lpdwBufferLength = sizeof(HTTP_VERSION_INFO);
2079             break;
2080         }
2081        case INTERNET_OPTION_CONNECTED_STATE:
2082        {
2083             DWORD *pdwConnectedState = (DWORD *)lpBuffer;
2084             FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
2085
2086             if (*lpdwBufferLength < sizeof(*pdwConnectedState))
2087                  INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2088             else
2089             {
2090                 *pdwConnectedState = INTERNET_STATE_CONNECTED;
2091                 bSuccess = TRUE;
2092             }
2093             *lpdwBufferLength = sizeof(*pdwConnectedState);
2094             break;
2095         }
2096         case INTERNET_OPTION_PROXY:
2097         {
2098             LPWININETAPPINFOW lpwai = (LPWININETAPPINFOW)lpwhh;
2099             WININETAPPINFOW wai;
2100
2101             if (lpwai == NULL)
2102             {
2103                 TRACE("Getting global proxy info\n");
2104                 memset(&wai, 0, sizeof(WININETAPPINFOW));
2105                 INTERNET_ConfigureProxyFromReg( &wai );
2106                 lpwai = &wai;
2107             }
2108
2109             if (bIsUnicode)
2110             {
2111                 INTERNET_PROXY_INFOW *pPI = (INTERNET_PROXY_INFOW *)lpBuffer;
2112                 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
2113
2114                 if (lpwai->lpszProxy)
2115                     proxyBytesRequired = (lstrlenW(lpwai->lpszProxy) + 1) *
2116                      sizeof(WCHAR);
2117                 if (lpwai->lpszProxyBypass)
2118                     proxyBypassBytesRequired =
2119                      (lstrlenW(lpwai->lpszProxyBypass) + 1) * sizeof(WCHAR);
2120                 if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOW) +
2121                  proxyBytesRequired + proxyBypassBytesRequired)
2122                     INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2123                 else
2124                 {
2125                     pPI->dwAccessType = lpwai->dwAccessType;
2126                     if (lpwai->lpszProxy)
2127                     {
2128                         pPI->lpszProxy = (LPWSTR)((LPBYTE)lpBuffer +
2129                                                   sizeof(INTERNET_PROXY_INFOW));
2130                         lstrcpyW((LPWSTR)pPI->lpszProxy, lpwai->lpszProxy);
2131                     }
2132                     else
2133                     {
2134                         pPI->lpszProxy = (LPWSTR)((LPBYTE)lpBuffer +
2135                                                   sizeof(INTERNET_PROXY_INFOW));
2136                         *((LPWSTR)(pPI->lpszProxy)) = 0;
2137                     }
2138
2139                     if (lpwai->lpszProxyBypass)
2140                     {
2141                         pPI->lpszProxyBypass = (LPWSTR)((LPBYTE)lpBuffer +
2142                                                         sizeof(INTERNET_PROXY_INFOW) +
2143                                                         proxyBytesRequired);
2144                         lstrcpyW((LPWSTR)pPI->lpszProxyBypass,
2145                          lpwai->lpszProxyBypass);
2146                     }
2147                     else
2148                     {
2149                         pPI->lpszProxyBypass = (LPWSTR)((LPBYTE)lpBuffer +
2150                                                         sizeof(INTERNET_PROXY_INFOW) +
2151                                                         proxyBytesRequired);
2152                         *((LPWSTR)(pPI->lpszProxyBypass)) = 0;
2153                     }
2154                     bSuccess = TRUE;
2155                 }
2156                 *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOW) +
2157                  proxyBytesRequired + proxyBypassBytesRequired;
2158             }
2159             else
2160             {
2161                 INTERNET_PROXY_INFOA *pPI = (INTERNET_PROXY_INFOA *)lpBuffer;
2162                 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
2163
2164                 if (lpwai->lpszProxy)
2165                     proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0,
2166                      lpwai->lpszProxy, -1, NULL, 0, NULL, NULL);
2167                 if (lpwai->lpszProxyBypass)
2168                     proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0,
2169                      lpwai->lpszProxyBypass, -1, NULL, 0, NULL, NULL);
2170                 if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOA) +
2171                  proxyBytesRequired + proxyBypassBytesRequired)
2172                     INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2173                 else
2174                 {
2175                     pPI->dwAccessType = lpwai->dwAccessType;
2176                     if (lpwai->lpszProxy)
2177                     {
2178                         pPI->lpszProxy = (LPSTR)((LPBYTE)lpBuffer +
2179                                                  sizeof(INTERNET_PROXY_INFOA));
2180                         WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxy, -1,
2181                          (LPSTR)pPI->lpszProxy, proxyBytesRequired, NULL, NULL);
2182                     }
2183                     else
2184                     {
2185                         pPI->lpszProxy = (LPSTR)((LPBYTE)lpBuffer +
2186                                                  sizeof(INTERNET_PROXY_INFOA));
2187                         *((LPSTR)(pPI->lpszProxy)) = '\0';
2188                     }
2189
2190                     if (lpwai->lpszProxyBypass)
2191                     {
2192                         pPI->lpszProxyBypass = (LPSTR)((LPBYTE)lpBuffer +
2193                          sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired);
2194                         WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxyBypass,
2195                          -1, (LPSTR)pPI->lpszProxyBypass,
2196                          proxyBypassBytesRequired,
2197                          NULL, NULL);
2198                     }
2199                     else
2200                     {
2201                         pPI->lpszProxyBypass = (LPSTR)((LPBYTE)lpBuffer +
2202                                                        sizeof(INTERNET_PROXY_INFOA) +
2203                                                        proxyBytesRequired);
2204                         *((LPSTR)(pPI->lpszProxyBypass)) = '\0';
2205                     }
2206                     bSuccess = TRUE;
2207                 }
2208                 *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOA) +
2209                  proxyBytesRequired + proxyBypassBytesRequired;
2210             }
2211             break;
2212         }
2213         case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2214         {
2215             ULONG conn = 2;
2216             TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER: %ld\n", conn);
2217             if (*lpdwBufferLength < sizeof(ULONG))
2218                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2219             else
2220             {
2221                 memcpy(lpBuffer, &conn, sizeof(ULONG));
2222                 bSuccess = TRUE;
2223             }
2224             *lpdwBufferLength = sizeof(ULONG);
2225             break;
2226         }
2227         case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2228         {
2229             ULONG conn = 4;
2230             TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER: %ld\n", conn);
2231             if (*lpdwBufferLength < sizeof(ULONG))
2232                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2233             else
2234             {
2235                 memcpy(lpBuffer, &conn, sizeof(ULONG));
2236                 bSuccess = TRUE;
2237             }
2238             *lpdwBufferLength = sizeof(ULONG);
2239             break;
2240         }
2241         case INTERNET_OPTION_SECURITY_FLAGS:
2242             FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
2243             break;
2244
2245         case INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT:
2246             if (*lpdwBufferLength < sizeof(INTERNET_CERTIFICATE_INFOW))
2247             {
2248                 *lpdwBufferLength = sizeof(INTERNET_CERTIFICATE_INFOW);
2249                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2250             }
2251             else if (lpwhh->htype == WH_HHTTPREQ)
2252             {
2253                 LPWININETHTTPREQW lpwhr;
2254                 PCCERT_CONTEXT context;
2255
2256                 lpwhr = (LPWININETHTTPREQW)lpwhh;
2257                 context = (PCCERT_CONTEXT)NETCON_GetCert(&(lpwhr->netConnection));
2258                 if (context)
2259                 {
2260                     LPINTERNET_CERTIFICATE_INFOW info = (LPINTERNET_CERTIFICATE_INFOW)lpBuffer;
2261                     DWORD strLen;
2262
2263                     memset(info,0,sizeof(INTERNET_CERTIFICATE_INFOW));
2264                     info->ftExpiry = context->pCertInfo->NotAfter;
2265                     info->ftStart = context->pCertInfo->NotBefore;
2266                     if (bIsUnicode)
2267                     {
2268                         strLen = CertNameToStrW(context->dwCertEncodingType,
2269                          &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2270                          NULL, 0);
2271                         info->lpszSubjectInfo = LocalAlloc(0,
2272                          strLen * sizeof(WCHAR));
2273                         if (info->lpszSubjectInfo)
2274                             CertNameToStrW(context->dwCertEncodingType,
2275                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2276                              info->lpszSubjectInfo, strLen);
2277                         strLen = CertNameToStrW(context->dwCertEncodingType,
2278                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2279                          NULL, 0);
2280                         info->lpszIssuerInfo = LocalAlloc(0,
2281                          strLen * sizeof(WCHAR));
2282                         if (info->lpszIssuerInfo)
2283                             CertNameToStrW(context->dwCertEncodingType,
2284                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2285                              info->lpszIssuerInfo, strLen);
2286                     }
2287                     else
2288                     {
2289                         LPINTERNET_CERTIFICATE_INFOA infoA =
2290                          (LPINTERNET_CERTIFICATE_INFOA)info;
2291
2292                         strLen = CertNameToStrA(context->dwCertEncodingType,
2293                          &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2294                          NULL, 0);
2295                         infoA->lpszSubjectInfo = LocalAlloc(0, strLen);
2296                         if (infoA->lpszSubjectInfo)
2297                             CertNameToStrA(context->dwCertEncodingType,
2298                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2299                              infoA->lpszSubjectInfo, strLen);
2300                         strLen = CertNameToStrA(context->dwCertEncodingType,
2301                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2302                          NULL, 0);
2303                         infoA->lpszIssuerInfo = LocalAlloc(0, strLen);
2304                         if (infoA->lpszIssuerInfo)
2305                             CertNameToStrA(context->dwCertEncodingType,
2306                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2307                              infoA->lpszIssuerInfo, strLen);
2308                     }
2309                     /*
2310                      * Contrary to MSDN, these do not appear to be set.
2311                      * lpszProtocolName
2312                      * lpszSignatureAlgName
2313                      * lpszEncryptionAlgName
2314                      * dwKeySize
2315                      */
2316                     CertFreeCertificateContext(context);
2317                     bSuccess = TRUE;
2318                 }
2319             }
2320             break;
2321         default:
2322             FIXME("Stub! %ld\n", dwOption);
2323             break;
2324     }
2325     if (lpwhh)
2326         WININET_Release( lpwhh );
2327
2328     return bSuccess;
2329 }
2330
2331 /***********************************************************************
2332  *           InternetQueryOptionW (WININET.@)
2333  *
2334  * Queries an options on the specified handle
2335  *
2336  * RETURNS
2337  *    TRUE  on success
2338  *    FALSE on failure
2339  *
2340  */
2341 BOOL WINAPI InternetQueryOptionW(HINTERNET hInternet, DWORD dwOption,
2342                                  LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2343 {
2344     return INET_QueryOptionHelper(TRUE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
2345 }
2346
2347 /***********************************************************************
2348  *           InternetQueryOptionA (WININET.@)
2349  *
2350  * Queries an options on the specified handle
2351  *
2352  * RETURNS
2353  *    TRUE  on success
2354  *    FALSE on failure
2355  *
2356  */
2357 BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
2358                                  LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2359 {
2360     return INET_QueryOptionHelper(FALSE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
2361 }
2362
2363
2364 /***********************************************************************
2365  *           InternetSetOptionW (WININET.@)
2366  *
2367  * Sets an options on the specified handle
2368  *
2369  * RETURNS
2370  *    TRUE  on success
2371  *    FALSE on failure
2372  *
2373  */
2374 BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
2375                            LPVOID lpBuffer, DWORD dwBufferLength)
2376 {
2377     LPWININETHANDLEHEADER lpwhh;
2378     BOOL ret = TRUE;
2379
2380     TRACE("0x%08lx\n", dwOption);
2381
2382     lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
2383     if( !lpwhh )
2384         return FALSE;
2385
2386     switch (dwOption)
2387     {
2388     case INTERNET_OPTION_HTTP_VERSION:
2389       {
2390         HTTP_VERSION_INFO* pVersion=(HTTP_VERSION_INFO*)lpBuffer;
2391         FIXME("Option INTERNET_OPTION_HTTP_VERSION(%ld,%ld): STUB\n",pVersion->dwMajorVersion,pVersion->dwMinorVersion);
2392       }
2393       break;
2394     case INTERNET_OPTION_ERROR_MASK:
2395       {
2396         unsigned long flags=*(unsigned long*)lpBuffer;
2397         FIXME("Option INTERNET_OPTION_ERROR_MASK(%ld): STUB\n",flags);
2398       }
2399       break;
2400     case INTERNET_OPTION_CODEPAGE:
2401       {
2402         unsigned long codepage=*(unsigned long*)lpBuffer;
2403         FIXME("Option INTERNET_OPTION_CODEPAGE (%ld): STUB\n",codepage);
2404       }
2405       break;
2406     case INTERNET_OPTION_REQUEST_PRIORITY:
2407       {
2408         unsigned long priority=*(unsigned long*)lpBuffer;
2409         FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%ld): STUB\n",priority);
2410       }
2411       break;
2412     case INTERNET_OPTION_CONNECT_TIMEOUT:
2413       {
2414         unsigned long connecttimeout=*(unsigned long*)lpBuffer;
2415         FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%ld): STUB\n",connecttimeout);
2416       }
2417       break;
2418     case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
2419       {
2420         unsigned long receivetimeout=*(unsigned long*)lpBuffer;
2421         FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%ld): STUB\n",receivetimeout);
2422       }
2423       break;
2424     case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2425       {
2426         unsigned long conns=*(unsigned long*)lpBuffer;
2427         FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_SERVER (%ld): STUB\n",conns);
2428       }
2429       break;
2430     case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2431       {
2432         unsigned long conns=*(unsigned long*)lpBuffer;
2433         FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER (%ld): STUB\n",conns);
2434       }
2435       break;
2436     case INTERNET_OPTION_RESET_URLCACHE_SESSION:
2437         FIXME("Option INTERNET_OPTION_RESET_URLCACHE_SESSION: STUB\n");
2438         break;
2439     case INTERNET_OPTION_END_BROWSER_SESSION:
2440         FIXME("Option INTERNET_OPTION_END_BROWSER_SESSION: STUB\n");
2441         break;
2442     case INTERNET_OPTION_CONNECTED_STATE:
2443         FIXME("Option INTERNET_OPTION_CONNECTED_STATE: STUB\n");
2444         break;
2445     case INTERNET_OPTION_DISABLE_PASSPORT_AUTH:
2446         TRACE("Option INTERNET_OPTION_DISABLE_PASSPORT_AUTH: harmless stub, since not enabled\n");
2447         break;
2448     case INTERNET_OPTION_SEND_TIMEOUT:
2449     case INTERNET_OPTION_RECEIVE_TIMEOUT:
2450         TRACE("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT\n");
2451         if (dwBufferLength == sizeof(DWORD))
2452         {
2453             if (lpwhh->htype == WH_HHTTPREQ)
2454                 ret = NETCON_set_timeout(
2455                     &((LPWININETHTTPREQW)lpwhh)->netConnection,
2456                     dwOption == INTERNET_OPTION_SEND_TIMEOUT,
2457                     *(DWORD *)lpBuffer);
2458             else
2459             {
2460                 FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT not supported on protocol %d\n",
2461                       lpwhh->htype);
2462                 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2463                 ret = FALSE;
2464             }
2465         }
2466         else
2467         {
2468             INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2469             ret = FALSE;
2470         }
2471         break;
2472     case INTERNET_OPTION_CONNECT_RETRIES:
2473         FIXME("Option INTERNET_OPTION_CONNECT_RETRIES: STUB\n");
2474         break;
2475     case INTERNET_OPTION_CONTEXT_VALUE:
2476          FIXME("Option INTERNET_OPTION_CONTEXT_VALUE; STUB\n");
2477          break;
2478     default:
2479         FIXME("Option %ld STUB\n",dwOption);
2480         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2481         ret = FALSE;
2482         break;
2483     }
2484     WININET_Release( lpwhh );
2485
2486     return ret;
2487 }
2488
2489
2490 /***********************************************************************
2491  *           InternetSetOptionA (WININET.@)
2492  *
2493  * Sets an options on the specified handle.
2494  *
2495  * RETURNS
2496  *    TRUE  on success
2497  *    FALSE on failure
2498  *
2499  */
2500 BOOL WINAPI InternetSetOptionA(HINTERNET hInternet, DWORD dwOption,
2501                            LPVOID lpBuffer, DWORD dwBufferLength)
2502 {
2503     LPVOID wbuffer;
2504     DWORD wlen;
2505     BOOL r;
2506
2507     switch( dwOption )
2508     {
2509     case INTERNET_OPTION_PROXY:
2510         {
2511         LPINTERNET_PROXY_INFOA pi = (LPINTERNET_PROXY_INFOA) lpBuffer;
2512         LPINTERNET_PROXY_INFOW piw;
2513         DWORD proxlen, prbylen;
2514         LPWSTR prox, prby;
2515
2516         proxlen = MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, NULL, 0);
2517         prbylen= MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, NULL, 0);
2518         wlen = sizeof(*piw) + proxlen + prbylen;
2519         wbuffer = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
2520         piw = (LPINTERNET_PROXY_INFOW) wbuffer;
2521         piw->dwAccessType = pi->dwAccessType;
2522         prox = (LPWSTR) &piw[1];
2523         prby = &prox[proxlen+1];
2524         MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, prox, proxlen);
2525         MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, prby, prbylen);
2526         piw->lpszProxy = prox;
2527         piw->lpszProxyBypass = prby;
2528         }
2529         break;
2530     case INTERNET_OPTION_USER_AGENT:
2531     case INTERNET_OPTION_USERNAME:
2532     case INTERNET_OPTION_PASSWORD:
2533         wlen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, dwBufferLength,
2534                                    NULL, 0 );
2535         wbuffer = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
2536         MultiByteToWideChar( CP_ACP, 0, lpBuffer, dwBufferLength,
2537                                    wbuffer, wlen );
2538         break;
2539     default:
2540         wbuffer = lpBuffer;
2541         wlen = dwBufferLength;
2542     }
2543
2544     r = InternetSetOptionW(hInternet,dwOption, wbuffer, wlen);
2545
2546     if( lpBuffer != wbuffer )
2547         HeapFree( GetProcessHeap(), 0, wbuffer );
2548
2549     return r;
2550 }
2551
2552
2553 /***********************************************************************
2554  *           InternetSetOptionExA (WININET.@)
2555  */
2556 BOOL WINAPI InternetSetOptionExA(HINTERNET hInternet, DWORD dwOption,
2557                            LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
2558 {
2559     FIXME("Flags %08lx ignored\n", dwFlags);
2560     return InternetSetOptionA( hInternet, dwOption, lpBuffer, dwBufferLength );
2561 }
2562
2563 /***********************************************************************
2564  *           InternetSetOptionExW (WININET.@)
2565  */
2566 BOOL WINAPI InternetSetOptionExW(HINTERNET hInternet, DWORD dwOption,
2567                            LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
2568 {
2569     FIXME("Flags %08lx ignored\n", dwFlags);
2570     if( dwFlags & ~ISO_VALID_FLAGS )
2571     {
2572         SetLastError( ERROR_INVALID_PARAMETER );
2573         return FALSE;
2574     }
2575     return InternetSetOptionW( hInternet, dwOption, lpBuffer, dwBufferLength );
2576 }
2577
2578 static const WCHAR WININET_wkday[7][4] =
2579     { { 'S','u','n', 0 }, { 'M','o','n', 0 }, { 'T','u','e', 0 }, { 'W','e','d', 0 },
2580       { 'T','h','u', 0 }, { 'F','r','i', 0 }, { 'S','a','t', 0 } };
2581 static const WCHAR WININET_month[12][4] =
2582     { { 'J','a','n', 0 }, { 'F','e','b', 0 }, { 'M','a','r', 0 }, { 'A','p','r', 0 },
2583       { 'M','a','y', 0 }, { 'J','u','n', 0 }, { 'J','u','l', 0 }, { 'A','u','g', 0 },
2584       { 'S','e','p', 0 }, { 'O','c','t', 0 }, { 'N','o','v', 0 }, { 'D','e','c', 0 } };
2585
2586 /***********************************************************************
2587  *           InternetTimeFromSystemTimeA (WININET.@)
2588  */
2589 BOOL WINAPI InternetTimeFromSystemTimeA( const SYSTEMTIME* time, DWORD format, LPSTR string, DWORD size )
2590 {
2591     BOOL ret;
2592     WCHAR stringW[INTERNET_RFC1123_BUFSIZE];
2593
2594     TRACE( "%p 0x%08lx %p 0x%08lx\n", time, format, string, size );
2595
2596     ret = InternetTimeFromSystemTimeW( time, format, stringW, sizeof(stringW) );
2597     if (ret) WideCharToMultiByte( CP_ACP, 0, stringW, -1, string, size, NULL, NULL );
2598
2599     return ret;
2600 }
2601
2602 /***********************************************************************
2603  *           InternetTimeFromSystemTimeW (WININET.@)
2604  */
2605 BOOL WINAPI InternetTimeFromSystemTimeW( const SYSTEMTIME* time, DWORD format, LPWSTR string, DWORD size )
2606 {
2607     static const WCHAR date[] =
2608         { '%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
2609           '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0 };
2610
2611     TRACE( "%p 0x%08lx %p 0x%08lx\n", time, format, string, size );
2612
2613     if (!time || !string) return FALSE;
2614
2615     if (format != INTERNET_RFC1123_FORMAT || size < INTERNET_RFC1123_BUFSIZE * sizeof(WCHAR))
2616         return FALSE;
2617
2618     sprintfW( string, date,
2619               WININET_wkday[time->wDayOfWeek],
2620               time->wDay,
2621               WININET_month[time->wMonth - 1],
2622               time->wYear,
2623               time->wHour,
2624               time->wMinute,
2625               time->wSecond );
2626
2627     return TRUE;
2628 }
2629
2630 /***********************************************************************
2631  *           InternetTimeToSystemTimeA (WININET.@)
2632  */
2633 BOOL WINAPI InternetTimeToSystemTimeA( LPCSTR string, SYSTEMTIME* time, DWORD reserved )
2634 {
2635     BOOL ret = FALSE;
2636     WCHAR *stringW;
2637     int len;
2638
2639     TRACE( "%s %p 0x%08lx\n", debugstr_a(string), time, reserved );
2640
2641     len = MultiByteToWideChar( CP_ACP, 0, string, -1, NULL, 0 );
2642     stringW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2643
2644     if (stringW)
2645     {
2646         MultiByteToWideChar( CP_ACP, 0, string, -1, stringW, len );
2647         ret = InternetTimeToSystemTimeW( stringW, time, reserved );
2648         HeapFree( GetProcessHeap(), 0, stringW );
2649     }
2650     return ret;
2651 }
2652
2653 /***********************************************************************
2654  *           InternetTimeToSystemTimeW (WININET.@)
2655  */
2656 BOOL WINAPI InternetTimeToSystemTimeW( LPCWSTR string, SYSTEMTIME* time, DWORD reserved )
2657 {
2658     unsigned int i;
2659     WCHAR *s = (LPWSTR)string;
2660
2661     TRACE( "%s %p 0x%08lx\n", debugstr_w(string), time, reserved );
2662
2663     if (!string || !time) return FALSE;
2664
2665     /* Windows does this too */
2666     GetSystemTime( time );
2667
2668     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
2669      *  a SYSTEMTIME structure.
2670      */
2671
2672     while (*s && !isalphaW( *s )) s++;
2673     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2674     time->wDayOfWeek = 7;
2675
2676     for (i = 0; i < 7; i++)
2677     {
2678         if (toupperW( WININET_wkday[i][0] ) == toupperW( s[0] ) &&
2679             toupperW( WININET_wkday[i][1] ) == toupperW( s[1] ) &&
2680             toupperW( WININET_wkday[i][2] ) == toupperW( s[2] ) )
2681         {
2682             time->wDayOfWeek = i;
2683             break;
2684         }
2685     }
2686
2687     if (time->wDayOfWeek > 6) return TRUE;
2688     while (*s && !isdigitW( *s )) s++;
2689     time->wDay = strtolW( s, &s, 10 );
2690
2691     while (*s && !isalphaW( *s )) s++;
2692     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2693     time->wMonth = 0;
2694
2695     for (i = 0; i < 12; i++)
2696     {
2697         if (toupperW( WININET_month[i][0]) == toupperW( s[0] ) &&
2698             toupperW( WININET_month[i][1]) == toupperW( s[1] ) &&
2699             toupperW( WININET_month[i][2]) == toupperW( s[2] ) )
2700         {
2701             time->wMonth = i + 1;
2702             break;
2703         }
2704     }
2705     if (time->wMonth == 0) return TRUE;
2706
2707     while (*s && !isdigitW( *s )) s++;
2708     if (*s == '\0') return TRUE;
2709     time->wYear = strtolW( s, &s, 10 );
2710
2711     while (*s && !isdigitW( *s )) s++;
2712     if (*s == '\0') return TRUE;
2713     time->wHour = strtolW( s, &s, 10 );
2714
2715     while (*s && !isdigitW( *s )) s++;
2716     if (*s == '\0') return TRUE;
2717     time->wMinute = strtolW( s, &s, 10 );
2718
2719     while (*s && !isdigitW( *s )) s++;
2720     if (*s == '\0') return TRUE;
2721     time->wSecond = strtolW( s, &s, 10 );
2722
2723     time->wMilliseconds = 0;
2724     return TRUE;
2725 }
2726
2727 /***********************************************************************
2728  *      InternetCheckConnectionW (WININET.@)
2729  *
2730  * Pings a requested host to check internet connection
2731  *
2732  * RETURNS
2733  *   TRUE on success and FALSE on failure. If a failure then
2734  *   ERROR_NOT_CONNECTED is placed into GetLastError
2735  *
2736  */
2737 BOOL WINAPI InternetCheckConnectionW( LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved )
2738 {
2739 /*
2740  * this is a kludge which runs the resident ping program and reads the output.
2741  *
2742  * Anyone have a better idea?
2743  */
2744
2745   BOOL   rc = FALSE;
2746   static const CHAR ping[] = "ping -w 1 ";
2747   static const CHAR redirect[] = " >/dev/null 2>/dev/null";
2748   CHAR *command = NULL;
2749   WCHAR hostW[1024];
2750   DWORD len;
2751   int status = -1;
2752
2753   FIXME("\n");
2754
2755   /*
2756    * Crack or set the Address
2757    */
2758   if (lpszUrl == NULL)
2759   {
2760      /*
2761       * According to the doc we are supost to use the ip for the next
2762       * server in the WnInet internal server database. I have
2763       * no idea what that is or how to get it.
2764       *
2765       * So someone needs to implement this.
2766       */
2767      FIXME("Unimplemented with URL of NULL\n");
2768      return TRUE;
2769   }
2770   else
2771   {
2772      URL_COMPONENTSW components;
2773
2774      ZeroMemory(&components,sizeof(URL_COMPONENTSW));
2775      components.lpszHostName = (LPWSTR)&hostW;
2776      components.dwHostNameLength = 1024;
2777
2778      if (!InternetCrackUrlW(lpszUrl,0,0,&components))
2779        goto End;
2780
2781      TRACE("host name : %s\n",debugstr_w(components.lpszHostName));
2782   }
2783
2784   /*
2785    * Build our ping command
2786    */
2787   len = WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, NULL, 0, NULL, NULL);
2788   command = HeapAlloc( GetProcessHeap(), 0, strlen(ping)+len+strlen(redirect) );
2789   strcpy(command,ping);
2790   WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, command+strlen(ping), len, NULL, NULL);
2791   strcat(command,redirect);
2792
2793   TRACE("Ping command is : %s\n",command);
2794
2795   status = system(command);
2796
2797   TRACE("Ping returned a code of %i\n",status);
2798
2799   /* Ping return code of 0 indicates success */
2800   if (status == 0)
2801      rc = TRUE;
2802
2803 End:
2804
2805   HeapFree( GetProcessHeap(), 0, command );
2806   if (rc == FALSE)
2807     SetLastError(ERROR_NOT_CONNECTED);
2808
2809   return rc;
2810 }
2811
2812
2813 /***********************************************************************
2814  *      InternetCheckConnectionA (WININET.@)
2815  *
2816  * Pings a requested host to check internet connection
2817  *
2818  * RETURNS
2819  *   TRUE on success and FALSE on failure. If a failure then
2820  *   ERROR_NOT_CONNECTED is placed into GetLastError
2821  *
2822  */
2823 BOOL WINAPI InternetCheckConnectionA(LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
2824 {
2825     WCHAR *szUrl;
2826     INT len;
2827     BOOL rc;
2828
2829     len = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0);
2830     if (!(szUrl = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
2831         return FALSE;
2832     MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, len);
2833     rc = InternetCheckConnectionW(szUrl, dwFlags, dwReserved);
2834     HeapFree(GetProcessHeap(), 0, szUrl);
2835
2836     return rc;
2837 }
2838
2839
2840 /**********************************************************
2841  *      INTERNET_InternetOpenUrlW (internal)
2842  *
2843  * Opens an URL
2844  *
2845  * RETURNS
2846  *   handle of connection or NULL on failure
2847  */
2848 HINTERNET WINAPI INTERNET_InternetOpenUrlW(LPWININETAPPINFOW hIC, LPCWSTR lpszUrl,
2849     LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
2850 {
2851     URL_COMPONENTSW urlComponents;
2852     WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
2853     WCHAR password[1024], path[2048], extra[1024];
2854     HINTERNET client = NULL, client1 = NULL;
2855
2856     TRACE("(%p, %s, %s, %08lx, %08lx, %08lx)\n", hIC, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
2857           dwHeadersLength, dwFlags, dwContext);
2858
2859     urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
2860     urlComponents.lpszScheme = protocol;
2861     urlComponents.dwSchemeLength = 32;
2862     urlComponents.lpszHostName = hostName;
2863     urlComponents.dwHostNameLength = MAXHOSTNAME;
2864     urlComponents.lpszUserName = userName;
2865     urlComponents.dwUserNameLength = 1024;
2866     urlComponents.lpszPassword = password;
2867     urlComponents.dwPasswordLength = 1024;
2868     urlComponents.lpszUrlPath = path;
2869     urlComponents.dwUrlPathLength = 2048;
2870     urlComponents.lpszExtraInfo = extra;
2871     urlComponents.dwExtraInfoLength = 1024;
2872     if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
2873         return NULL;
2874     switch(urlComponents.nScheme) {
2875     case INTERNET_SCHEME_FTP:
2876         if(urlComponents.nPort == 0)
2877             urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT;
2878         client = FTP_Connect(hIC, hostName, urlComponents.nPort,
2879                              userName, password, dwFlags, dwContext, INET_OPENURL);
2880         if(client == NULL)
2881             break;
2882         client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext);
2883         if(client1 == NULL) {
2884             InternetCloseHandle(client);
2885             break;
2886         }
2887         break;
2888
2889     case INTERNET_SCHEME_HTTP:
2890     case INTERNET_SCHEME_HTTPS: {
2891         static const WCHAR szStars[] = { '*','/','*', 0 };
2892         LPCWSTR accept[2] = { szStars, NULL };
2893         if(urlComponents.nPort == 0) {
2894             if(urlComponents.nScheme == INTERNET_SCHEME_HTTP)
2895                 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
2896             else
2897                 urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
2898         }
2899         /* FIXME: should use pointers, not handles, as handles are not thread-safe */
2900         client = HTTP_Connect(hIC, hostName, urlComponents.nPort,
2901                               userName, password, dwFlags, dwContext, INET_OPENURL);
2902         if(client == NULL)
2903             break;
2904         client1 = HttpOpenRequestW(client, NULL, path, NULL, NULL, accept, dwFlags, dwContext);
2905         if(client1 == NULL) {
2906             InternetCloseHandle(client);
2907             break;
2908         }
2909         HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
2910         if (!HttpSendRequestW(client1, NULL, 0, NULL, 0)) {
2911             InternetCloseHandle(client1);
2912             client1 = NULL;
2913             break;
2914         }
2915     }
2916     case INTERNET_SCHEME_GOPHER:
2917         /* gopher doesn't seem to be implemented in wine, but it's supposed
2918          * to be supported by InternetOpenUrlA. */
2919     default:
2920         break;
2921     }
2922
2923     TRACE(" %p <--\n", client1);
2924
2925     return client1;
2926 }
2927
2928 /**********************************************************
2929  *      InternetOpenUrlW (WININET.@)
2930  *
2931  * Opens an URL
2932  *
2933  * RETURNS
2934  *   handle of connection or NULL on failure
2935  */
2936 HINTERNET WINAPI InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
2937     LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
2938 {
2939     HINTERNET ret = NULL;
2940     LPWININETAPPINFOW hIC = NULL;
2941
2942     if (TRACE_ON(wininet)) {
2943         TRACE("(%p, %s, %s, %08lx, %08lx, %08lx)\n", hInternet, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
2944               dwHeadersLength, dwFlags, dwContext);
2945         TRACE("  flags :");
2946         dump_INTERNET_FLAGS(dwFlags);
2947     }
2948
2949     hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
2950     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT) {
2951         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2952         goto lend;
2953     }
2954
2955     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC) {
2956         WORKREQUEST workRequest;
2957         struct WORKREQ_INTERNETOPENURLW *req;
2958
2959         workRequest.asyncall = INTERNETOPENURLW;
2960         workRequest.hdr = WININET_AddRef( &hIC->hdr );
2961         req = &workRequest.u.InternetOpenUrlW;
2962         if (lpszUrl)
2963             req->lpszUrl = WININET_strdupW(lpszUrl);
2964         else
2965             req->lpszUrl = 0;
2966         if (lpszHeaders)
2967             req->lpszHeaders = WININET_strdupW(lpszHeaders);
2968         else
2969             req->lpszHeaders = 0;
2970         req->dwHeadersLength = dwHeadersLength;
2971         req->dwFlags = dwFlags;
2972         req->dwContext = dwContext;
2973
2974         INTERNET_AsyncCall(&workRequest);
2975         /*
2976          * This is from windows.
2977          */
2978         SetLastError(ERROR_IO_PENDING);
2979     } else {
2980         ret = INTERNET_InternetOpenUrlW(hIC, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
2981     }
2982
2983   lend:
2984     if( hIC )
2985         WININET_Release( &hIC->hdr );
2986     TRACE(" %p <--\n", ret);
2987
2988     return ret;
2989 }
2990
2991 /**********************************************************
2992  *      InternetOpenUrlA (WININET.@)
2993  *
2994  * Opens an URL
2995  *
2996  * RETURNS
2997  *   handle of connection or NULL on failure
2998  */
2999 HINTERNET WINAPI InternetOpenUrlA(HINTERNET hInternet, LPCSTR lpszUrl,
3000     LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
3001 {
3002     HINTERNET rc = (HINTERNET)NULL;
3003
3004     INT lenUrl;
3005     INT lenHeaders = 0;
3006     LPWSTR szUrl = NULL;
3007     LPWSTR szHeaders = NULL;
3008
3009     TRACE("\n");
3010
3011     if(lpszUrl) {
3012         lenUrl = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0 );
3013         szUrl = HeapAlloc(GetProcessHeap(), 0, lenUrl*sizeof(WCHAR));
3014         if(!szUrl)
3015             return (HINTERNET)NULL;
3016         MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, lenUrl);
3017     }
3018
3019     if(lpszHeaders) {
3020         lenHeaders = MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, NULL, 0 );
3021         szHeaders = HeapAlloc(GetProcessHeap(), 0, lenHeaders*sizeof(WCHAR));
3022         if(!szHeaders) {
3023             HeapFree(GetProcessHeap(), 0, szUrl);
3024             return (HINTERNET)NULL;
3025         }
3026         MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, szHeaders, lenHeaders);
3027     }
3028
3029     rc = InternetOpenUrlW(hInternet, szUrl, szHeaders,
3030         lenHeaders, dwFlags, dwContext);
3031
3032     HeapFree(GetProcessHeap(), 0, szUrl);
3033     HeapFree(GetProcessHeap(), 0, szHeaders);
3034
3035     return rc;
3036 }
3037
3038
3039 /***********************************************************************
3040  *           INTERNET_SetLastError (internal)
3041  *
3042  * Set last thread specific error
3043  *
3044  * RETURNS
3045  *
3046  */
3047 void INTERNET_SetLastError(DWORD dwError)
3048 {
3049     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3050
3051     SetLastError(dwError);
3052     if(lpwite)
3053         lpwite->dwError = dwError;
3054 }
3055
3056
3057 /***********************************************************************
3058  *           INTERNET_GetLastError (internal)
3059  *
3060  * Get last thread specific error
3061  *
3062  * RETURNS
3063  *
3064  */
3065 DWORD INTERNET_GetLastError(void)
3066 {
3067     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3068     /* TlsGetValue clears last error, so set it again here */
3069     SetLastError(lpwite->dwError);
3070     return lpwite->dwError;
3071 }
3072
3073
3074 /***********************************************************************
3075  *           INTERNET_WorkerThreadFunc (internal)
3076  *
3077  * Worker thread execution function
3078  *
3079  * RETURNS
3080  *
3081  */
3082 static DWORD CALLBACK INTERNET_WorkerThreadFunc(LPVOID lpvParam)
3083 {
3084     DWORD dwWaitRes;
3085
3086     while (1)
3087     {
3088         if(dwNumJobs > 0) {
3089             INTERNET_ExecuteWork();
3090             continue;
3091         }
3092         dwWaitRes = WaitForMultipleObjects(2, hEventArray, FALSE, MAX_IDLE_WORKER);
3093
3094         if (dwWaitRes == WAIT_OBJECT_0 + 1)
3095             INTERNET_ExecuteWork();
3096         else
3097             break;
3098
3099         InterlockedIncrement(&dwNumIdleThreads);
3100     }
3101
3102     InterlockedDecrement(&dwNumIdleThreads);
3103     InterlockedDecrement(&dwNumThreads);
3104     TRACE("Worker thread exiting\n");
3105     return TRUE;
3106 }
3107
3108
3109 /***********************************************************************
3110  *           INTERNET_InsertWorkRequest (internal)
3111  *
3112  * Insert work request into queue
3113  *
3114  * RETURNS
3115  *
3116  */
3117 static BOOL INTERNET_InsertWorkRequest(LPWORKREQUEST lpWorkRequest)
3118 {
3119     BOOL bSuccess = FALSE;
3120     LPWORKREQUEST lpNewRequest;
3121
3122     TRACE("\n");
3123
3124     lpNewRequest = HeapAlloc(GetProcessHeap(), 0, sizeof(WORKREQUEST));
3125     if (lpNewRequest)
3126     {
3127         memcpy(lpNewRequest, lpWorkRequest, sizeof(WORKREQUEST));
3128         lpNewRequest->prev = NULL;
3129
3130         EnterCriticalSection(&csQueue);
3131
3132         lpNewRequest->next = lpWorkQueueTail;
3133         if (lpWorkQueueTail)
3134             lpWorkQueueTail->prev = lpNewRequest;
3135         lpWorkQueueTail = lpNewRequest;
3136         if (!lpHeadWorkQueue)
3137             lpHeadWorkQueue = lpWorkQueueTail;
3138
3139         LeaveCriticalSection(&csQueue);
3140
3141         bSuccess = TRUE;
3142         InterlockedIncrement(&dwNumJobs);
3143     }
3144
3145     return bSuccess;
3146 }
3147
3148
3149 /***********************************************************************
3150  *           INTERNET_GetWorkRequest (internal)
3151  *
3152  * Retrieves work request from queue
3153  *
3154  * RETURNS
3155  *
3156  */
3157 static BOOL INTERNET_GetWorkRequest(LPWORKREQUEST lpWorkRequest)
3158 {
3159     BOOL bSuccess = FALSE;
3160     LPWORKREQUEST lpRequest = NULL;
3161
3162     TRACE("\n");
3163
3164     EnterCriticalSection(&csQueue);
3165
3166     if (lpHeadWorkQueue)
3167     {
3168         lpRequest = lpHeadWorkQueue;
3169         lpHeadWorkQueue = lpHeadWorkQueue->prev;
3170         if (lpRequest == lpWorkQueueTail)
3171             lpWorkQueueTail = lpHeadWorkQueue;
3172     }
3173
3174     LeaveCriticalSection(&csQueue);
3175
3176     if (lpRequest)
3177     {
3178         memcpy(lpWorkRequest, lpRequest, sizeof(WORKREQUEST));
3179         HeapFree(GetProcessHeap(), 0, lpRequest);
3180         bSuccess = TRUE;
3181         InterlockedDecrement(&dwNumJobs);
3182     }
3183
3184     return bSuccess;
3185 }
3186
3187
3188 /***********************************************************************
3189  *           INTERNET_AsyncCall (internal)
3190  *
3191  * Retrieves work request from queue
3192  *
3193  * RETURNS
3194  *
3195  */
3196 BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
3197 {
3198     HANDLE hThread;
3199     DWORD dwTID;
3200     BOOL bSuccess = FALSE;
3201
3202     TRACE("\n");
3203
3204     if (InterlockedDecrement(&dwNumIdleThreads) < 0)
3205     {
3206         InterlockedIncrement(&dwNumIdleThreads);
3207
3208         if (InterlockedIncrement(&dwNumThreads) > MAX_WORKER_THREADS ||
3209             !(hThread = CreateThread(NULL, 0,
3210             INTERNET_WorkerThreadFunc, NULL, 0, &dwTID)))
3211         {
3212             InterlockedDecrement(&dwNumThreads);
3213             INTERNET_SetLastError(ERROR_INTERNET_ASYNC_THREAD_FAILED);
3214             goto lerror;
3215         }
3216
3217         TRACE("Created new thread\n");
3218     }
3219
3220     bSuccess = TRUE;
3221     INTERNET_InsertWorkRequest(lpWorkRequest);
3222     SetEvent(hWorkEvent);
3223
3224 lerror:
3225
3226     return bSuccess;
3227 }
3228
3229
3230 /***********************************************************************
3231  *           INTERNET_ExecuteWork (internal)
3232  *
3233  * RETURNS
3234  *
3235  */
3236 static VOID INTERNET_ExecuteWork(void)
3237 {
3238     WORKREQUEST workRequest;
3239
3240     TRACE("\n");
3241
3242     if (!INTERNET_GetWorkRequest(&workRequest))
3243         return;
3244
3245     switch (workRequest.asyncall)
3246     {
3247     case FTPPUTFILEW:
3248         {
3249         struct WORKREQ_FTPPUTFILEW *req = &workRequest.u.FtpPutFileW;
3250         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3251
3252         TRACE("FTPPUTFILEW %p\n", lpwfs);
3253
3254         FTP_FtpPutFileW(lpwfs, req->lpszLocalFile,
3255                    req->lpszNewRemoteFile, req->dwFlags, req->dwContext);
3256
3257         HeapFree(GetProcessHeap(), 0, req->lpszLocalFile);
3258         HeapFree(GetProcessHeap(), 0, req->lpszNewRemoteFile);
3259         }
3260         break;
3261
3262     case FTPSETCURRENTDIRECTORYW:
3263         {
3264         struct WORKREQ_FTPSETCURRENTDIRECTORYW *req;
3265         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3266
3267         TRACE("FTPSETCURRENTDIRECTORYW %p\n", lpwfs);
3268
3269         req = &workRequest.u.FtpSetCurrentDirectoryW;
3270         FTP_FtpSetCurrentDirectoryW(lpwfs, req->lpszDirectory);
3271         HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
3272         }
3273         break;
3274
3275     case FTPCREATEDIRECTORYW:
3276         {
3277         struct WORKREQ_FTPCREATEDIRECTORYW *req;
3278         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3279
3280         TRACE("FTPCREATEDIRECTORYW %p\n", lpwfs);
3281
3282         req = &workRequest.u.FtpCreateDirectoryW;
3283         FTP_FtpCreateDirectoryW(lpwfs, req->lpszDirectory);
3284         HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
3285         }
3286         break;
3287
3288     case FTPFINDFIRSTFILEW:
3289         {
3290         struct WORKREQ_FTPFINDFIRSTFILEW *req;
3291         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3292
3293         TRACE("FTPFINDFIRSTFILEW %p\n", lpwfs);
3294
3295         req = &workRequest.u.FtpFindFirstFileW;
3296         FTP_FtpFindFirstFileW(lpwfs, req->lpszSearchFile,
3297            req->lpFindFileData, req->dwFlags, req->dwContext);
3298         HeapFree(GetProcessHeap(), 0, req->lpszSearchFile);
3299         }
3300         break;
3301
3302     case FTPGETCURRENTDIRECTORYW:
3303         {
3304         struct WORKREQ_FTPGETCURRENTDIRECTORYW *req;
3305         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3306
3307         TRACE("FTPGETCURRENTDIRECTORYW %p\n", lpwfs);
3308
3309         req = &workRequest.u.FtpGetCurrentDirectoryW;
3310         FTP_FtpGetCurrentDirectoryW(lpwfs,
3311                 req->lpszDirectory, req->lpdwDirectory);
3312         }
3313         break;
3314
3315     case FTPOPENFILEW:
3316         {
3317         struct WORKREQ_FTPOPENFILEW *req = &workRequest.u.FtpOpenFileW;
3318         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3319
3320         TRACE("FTPOPENFILEW %p\n", lpwfs);
3321
3322         FTP_FtpOpenFileW(lpwfs, req->lpszFilename,
3323             req->dwAccess, req->dwFlags, req->dwContext);
3324         HeapFree(GetProcessHeap(), 0, req->lpszFilename);
3325         }
3326         break;
3327
3328     case FTPGETFILEW:
3329         {
3330         struct WORKREQ_FTPGETFILEW *req = &workRequest.u.FtpGetFileW;
3331         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3332
3333         TRACE("FTPGETFILEW %p\n", lpwfs);
3334
3335         FTP_FtpGetFileW(lpwfs, req->lpszRemoteFile,
3336                  req->lpszNewFile, req->fFailIfExists,
3337                  req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext);
3338         HeapFree(GetProcessHeap(), 0, req->lpszRemoteFile);
3339         HeapFree(GetProcessHeap(), 0, req->lpszNewFile);
3340         }
3341         break;
3342
3343     case FTPDELETEFILEW:
3344         {
3345         struct WORKREQ_FTPDELETEFILEW *req = &workRequest.u.FtpDeleteFileW;
3346         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3347
3348         TRACE("FTPDELETEFILEW %p\n", lpwfs);
3349
3350         FTP_FtpDeleteFileW(lpwfs, req->lpszFilename);
3351         HeapFree(GetProcessHeap(), 0, req->lpszFilename);
3352         }
3353         break;
3354
3355     case FTPREMOVEDIRECTORYW:
3356         {
3357         struct WORKREQ_FTPREMOVEDIRECTORYW *req;
3358         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3359
3360         TRACE("FTPREMOVEDIRECTORYW %p\n", lpwfs);
3361
3362         req = &workRequest.u.FtpRemoveDirectoryW;
3363         FTP_FtpRemoveDirectoryW(lpwfs, req->lpszDirectory);
3364         HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
3365         }
3366         break;
3367
3368     case FTPRENAMEFILEW:
3369         {
3370         struct WORKREQ_FTPRENAMEFILEW *req = &workRequest.u.FtpRenameFileW;
3371         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3372
3373         TRACE("FTPRENAMEFILEW %p\n", lpwfs);
3374
3375         FTP_FtpRenameFileW(lpwfs, req->lpszSrcFile, req->lpszDestFile);
3376         HeapFree(GetProcessHeap(), 0, req->lpszSrcFile);
3377         HeapFree(GetProcessHeap(), 0, req->lpszDestFile);
3378         }
3379         break;
3380
3381     case INTERNETFINDNEXTW:
3382         {
3383         struct WORKREQ_INTERNETFINDNEXTW *req;
3384         LPWININETFINDNEXTW lpwh = (LPWININETFINDNEXTW) workRequest.hdr;
3385
3386         TRACE("INTERNETFINDNEXTW %p\n", lpwh);
3387
3388         req = &workRequest.u.InternetFindNextW;
3389         INTERNET_FindNextFileW(lpwh, req->lpFindFileData);
3390         }
3391         break;
3392
3393     case HTTPSENDREQUESTW:
3394         {
3395         struct WORKREQ_HTTPSENDREQUESTW *req = &workRequest.u.HttpSendRequestW;
3396         LPWININETHTTPREQW lpwhr = (LPWININETHTTPREQW) workRequest.hdr;
3397
3398         TRACE("HTTPSENDREQUESTW %p\n", lpwhr);
3399
3400         HTTP_HttpSendRequestW(lpwhr, req->lpszHeader,
3401                 req->dwHeaderLength, req->lpOptional, req->dwOptionalLength,
3402                 req->dwContentLength, req->bEndRequest);
3403
3404         HeapFree(GetProcessHeap(), 0, req->lpszHeader);
3405         }
3406         break;
3407
3408     case HTTPOPENREQUESTW:
3409         {
3410         struct WORKREQ_HTTPOPENREQUESTW *req = &workRequest.u.HttpOpenRequestW;
3411         LPWININETHTTPSESSIONW lpwhs = (LPWININETHTTPSESSIONW) workRequest.hdr;
3412
3413         TRACE("HTTPOPENREQUESTW %p\n", lpwhs);
3414
3415         HTTP_HttpOpenRequestW(lpwhs, req->lpszVerb,
3416             req->lpszObjectName, req->lpszVersion, req->lpszReferrer,
3417             req->lpszAcceptTypes, req->dwFlags, req->dwContext);
3418
3419         HeapFree(GetProcessHeap(), 0, req->lpszVerb);
3420         HeapFree(GetProcessHeap(), 0, req->lpszObjectName);
3421         HeapFree(GetProcessHeap(), 0, req->lpszVersion);
3422         HeapFree(GetProcessHeap(), 0, req->lpszReferrer);
3423         }
3424         break;
3425
3426     case SENDCALLBACK:
3427         {
3428         struct WORKREQ_SENDCALLBACK *req = &workRequest.u.SendCallback;
3429
3430         TRACE("SENDCALLBACK %p\n", workRequest.hdr);
3431
3432         INTERNET_SendCallback(workRequest.hdr,
3433                          req->dwContext, req->dwInternetStatus, req->lpvStatusInfo,
3434                          req->dwStatusInfoLength);
3435
3436         /* And frees the copy of the status info */
3437         HeapFree(GetProcessHeap(), 0, req->lpvStatusInfo);
3438         }
3439         break;
3440
3441     case INTERNETOPENURLW:
3442         {
3443         struct WORKREQ_INTERNETOPENURLW *req = &workRequest.u.InternetOpenUrlW;
3444         LPWININETAPPINFOW hIC = (LPWININETAPPINFOW) workRequest.hdr;
3445
3446         TRACE("INTERNETOPENURLW %p\n", hIC);
3447
3448         INTERNET_InternetOpenUrlW(hIC, req->lpszUrl,
3449                                   req->lpszHeaders, req->dwHeadersLength, req->dwFlags, req->dwContext);
3450         HeapFree(GetProcessHeap(), 0, req->lpszUrl);
3451         HeapFree(GetProcessHeap(), 0, req->lpszHeaders);
3452         }
3453         break;
3454     case INTERNETREADFILEEXA:
3455         {
3456         struct WORKREQ_INTERNETREADFILEEXA *req = &workRequest.u.InternetReadFileExA;
3457
3458         TRACE("INTERNETREADFILEEXA %p\n", workRequest.hdr);
3459
3460         INTERNET_ReadFile(workRequest.hdr, req->lpBuffersOut->lpvBuffer,
3461             req->lpBuffersOut->dwBufferLength,
3462             &req->lpBuffersOut->dwBufferLength, TRUE, TRUE);
3463         }
3464         break;
3465     }
3466     WININET_Release( workRequest.hdr );
3467 }
3468
3469
3470 /***********************************************************************
3471  *          INTERNET_GetResponseBuffer  (internal)
3472  *
3473  * RETURNS
3474  *
3475  */
3476 LPSTR INTERNET_GetResponseBuffer(void)
3477 {
3478     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3479     TRACE("\n");
3480     return lpwite->response;
3481 }
3482
3483 /***********************************************************************
3484  *           INTERNET_GetNextLine  (internal)
3485  *
3486  * Parse next line in directory string listing
3487  *
3488  * RETURNS
3489  *   Pointer to beginning of next line
3490  *   NULL on failure
3491  *
3492  */
3493
3494 LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen)
3495 {
3496     struct timeval tv;
3497     fd_set infd;
3498     BOOL bSuccess = FALSE;
3499     INT nRecv = 0;
3500     LPSTR lpszBuffer = INTERNET_GetResponseBuffer();
3501
3502     TRACE("\n");
3503
3504     FD_ZERO(&infd);
3505     FD_SET(nSocket, &infd);
3506     tv.tv_sec=RESPONSE_TIMEOUT;
3507     tv.tv_usec=0;
3508
3509     while (nRecv < MAX_REPLY_LEN)
3510     {
3511         if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0)
3512         {
3513             if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
3514             {
3515                 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
3516                 goto lend;
3517             }
3518
3519             if (lpszBuffer[nRecv] == '\n')
3520             {
3521                 bSuccess = TRUE;
3522                 break;
3523             }
3524             if (lpszBuffer[nRecv] != '\r')
3525                 nRecv++;
3526         }
3527         else
3528         {
3529             INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
3530             goto lend;
3531         }
3532     }
3533
3534 lend:
3535     if (bSuccess)
3536     {
3537         lpszBuffer[nRecv] = '\0';
3538         *dwLen = nRecv - 1;
3539         TRACE(":%d %s\n", nRecv, lpszBuffer);
3540         return lpszBuffer;
3541     }
3542     else
3543     {
3544         return NULL;
3545     }
3546 }
3547
3548 /**********************************************************
3549  *      InternetQueryDataAvailable (WININET.@)
3550  *
3551  * Determines how much data is available to be read.
3552  *
3553  * RETURNS
3554  *   If there is data available then TRUE, otherwise if there
3555  *   is not or an error occurred then FALSE. Use GetLastError() to
3556  *   check for ERROR_NO_MORE_FILES to see if it was the former.
3557  */
3558 BOOL WINAPI InternetQueryDataAvailable( HINTERNET hFile,
3559                                 LPDWORD lpdwNumberOfBytesAvailble,
3560                                 DWORD dwFlags, DWORD dwConext)
3561 {
3562     LPWININETHTTPREQW lpwhr;
3563     BOOL retval = FALSE;
3564     char buffer[4048];
3565
3566     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hFile );
3567     if (NULL == lpwhr)
3568     {
3569         SetLastError(ERROR_NO_MORE_FILES);
3570         return FALSE;
3571     }
3572
3573     TRACE("-->  %p %i\n",lpwhr,lpwhr->hdr.htype);
3574
3575     switch (lpwhr->hdr.htype)
3576     {
3577     case WH_HHTTPREQ:
3578         if (!NETCON_recv(&lpwhr->netConnection, buffer,
3579                          4048, MSG_PEEK, (int *)lpdwNumberOfBytesAvailble))
3580         {
3581             SetLastError(ERROR_NO_MORE_FILES);
3582             retval = FALSE;
3583         }
3584         else
3585             retval = TRUE;
3586         break;
3587
3588     default:
3589         FIXME("unsupported file type\n");
3590         break;
3591     }
3592     WININET_Release( &lpwhr->hdr );
3593
3594     TRACE("<-- %i\n",retval);
3595     return retval;
3596 }
3597
3598
3599 /***********************************************************************
3600  *      InternetLockRequestFile (WININET.@)
3601  */
3602 BOOL WINAPI InternetLockRequestFile( HINTERNET hInternet, HANDLE
3603 *lphLockReqHandle)
3604 {
3605     FIXME("STUB\n");
3606     return FALSE;
3607 }
3608
3609 BOOL WINAPI InternetUnlockRequestFile( HANDLE hLockHandle)
3610 {
3611     FIXME("STUB\n");
3612     return FALSE;
3613 }
3614
3615
3616 /***********************************************************************
3617  *      InternetAutodial (WININET.@)
3618  *
3619  * On windows this function is supposed to dial the default internet
3620  * connection. We don't want to have Wine dial out to the internet so
3621  * we return TRUE by default. It might be nice to check if we are connected.
3622  *
3623  * RETURNS
3624  *   TRUE on success
3625  *   FALSE on failure
3626  *
3627  */
3628 BOOL WINAPI InternetAutodial(DWORD dwFlags, HWND hwndParent)
3629 {
3630     FIXME("STUB\n");
3631
3632     /* Tell that we are connected to the internet. */
3633     return TRUE;
3634 }
3635
3636 /***********************************************************************
3637  *      InternetAutodialHangup (WININET.@)
3638  *
3639  * Hangs up a connection made with InternetAutodial
3640  *
3641  * PARAM
3642  *    dwReserved
3643  * RETURNS
3644  *   TRUE on success
3645  *   FALSE on failure
3646  *
3647  */
3648 BOOL WINAPI InternetAutodialHangup(DWORD dwReserved)
3649 {
3650     FIXME("STUB\n");
3651
3652     /* we didn't dial, we don't disconnect */
3653     return TRUE;
3654 }
3655
3656 /***********************************************************************
3657  *      InternetCombineUrlA (WININET.@)
3658  *
3659  * Combine a base URL with a relative URL
3660  *
3661  * RETURNS
3662  *   TRUE on success
3663  *   FALSE on failure
3664  *
3665  */
3666
3667 BOOL WINAPI InternetCombineUrlA(LPCSTR lpszBaseUrl, LPCSTR lpszRelativeUrl,
3668                                 LPSTR lpszBuffer, LPDWORD lpdwBufferLength,
3669                                 DWORD dwFlags)
3670 {
3671     HRESULT hr=S_OK;
3672
3673     TRACE("(%s, %s, %p, %p, 0x%08lx)\n", debugstr_a(lpszBaseUrl), debugstr_a(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
3674
3675     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
3676     dwFlags ^= ICU_NO_ENCODE;
3677     hr=UrlCombineA(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
3678
3679     return (hr==S_OK);
3680 }
3681
3682 /***********************************************************************
3683  *      InternetCombineUrlW (WININET.@)
3684  *
3685  * Combine a base URL with a relative URL
3686  *
3687  * RETURNS
3688  *   TRUE on success
3689  *   FALSE on failure
3690  *
3691  */
3692
3693 BOOL WINAPI InternetCombineUrlW(LPCWSTR lpszBaseUrl, LPCWSTR lpszRelativeUrl,
3694                                 LPWSTR lpszBuffer, LPDWORD lpdwBufferLength,
3695                                 DWORD dwFlags)
3696 {
3697     HRESULT hr=S_OK;
3698
3699     TRACE("(%s, %s, %p, %p, 0x%08lx)\n", debugstr_w(lpszBaseUrl), debugstr_w(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
3700
3701     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
3702     dwFlags ^= ICU_NO_ENCODE;
3703     hr=UrlCombineW(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
3704
3705     return (hr==S_OK);
3706 }
3707
3708 /* max port num is 65535 => 5 digits */
3709 #define MAX_WORD_DIGITS 5
3710
3711 #define URL_GET_COMP_LENGTH(url, component) ((url)->dw##component##Length ? \
3712     (url)->dw##component##Length : strlenW((url)->lpsz##component))
3713 #define URL_GET_COMP_LENGTHA(url, component) ((url)->dw##component##Length ? \
3714     (url)->dw##component##Length : strlen((url)->lpsz##component))
3715
3716 static BOOL url_uses_default_port(INTERNET_SCHEME nScheme, INTERNET_PORT nPort)
3717 {
3718     if ((nScheme == INTERNET_SCHEME_HTTP) &&
3719         (nPort == INTERNET_DEFAULT_HTTP_PORT))
3720         return TRUE;
3721     if ((nScheme == INTERNET_SCHEME_HTTPS) &&
3722         (nPort == INTERNET_DEFAULT_HTTPS_PORT))
3723         return TRUE;
3724     if ((nScheme == INTERNET_SCHEME_FTP) &&
3725         (nPort == INTERNET_DEFAULT_FTP_PORT))
3726         return TRUE;
3727     if ((nScheme == INTERNET_SCHEME_GOPHER) &&
3728         (nPort == INTERNET_DEFAULT_GOPHER_PORT))
3729         return TRUE;
3730
3731     if (nPort == INTERNET_INVALID_PORT_NUMBER)
3732         return TRUE;
3733
3734     return FALSE;
3735 }
3736
3737 /* opaque urls do not fit into the standard url hierarchy and don't have
3738  * two following slashes */
3739 static inline BOOL scheme_is_opaque(INTERNET_SCHEME nScheme)
3740 {
3741     return (nScheme != INTERNET_SCHEME_FTP) &&
3742            (nScheme != INTERNET_SCHEME_GOPHER) &&
3743            (nScheme != INTERNET_SCHEME_HTTP) &&
3744            (nScheme != INTERNET_SCHEME_HTTPS) &&
3745            (nScheme != INTERNET_SCHEME_FILE);
3746 }
3747
3748 static LPCWSTR INTERNET_GetSchemeString(INTERNET_SCHEME scheme)
3749 {
3750     int index;
3751     if (scheme < INTERNET_SCHEME_FIRST)
3752         return NULL;
3753     index = scheme - INTERNET_SCHEME_FIRST;
3754     if (index >= sizeof(url_schemes)/sizeof(url_schemes[0]))
3755         return NULL;
3756     return (LPCWSTR)&url_schemes[index];
3757 }
3758
3759 /* we can calculate using ansi strings because we're just
3760  * calculating string length, not size
3761  */
3762 static BOOL calc_url_length(LPURL_COMPONENTSW lpUrlComponents,
3763                             LPDWORD lpdwUrlLength)
3764 {
3765     INTERNET_SCHEME nScheme;
3766
3767     *lpdwUrlLength = 0;
3768
3769     if (lpUrlComponents->lpszScheme)
3770     {
3771         DWORD dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
3772         *lpdwUrlLength += dwLen;
3773         nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
3774     }
3775     else
3776     {
3777         LPCWSTR scheme;
3778
3779         nScheme = lpUrlComponents->nScheme;
3780
3781         if (nScheme == INTERNET_SCHEME_DEFAULT)
3782             nScheme = INTERNET_SCHEME_HTTP;
3783         scheme = INTERNET_GetSchemeString(nScheme);
3784         *lpdwUrlLength += strlenW(scheme);
3785     }
3786
3787     (*lpdwUrlLength)++; /* ':' */
3788     if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
3789         *lpdwUrlLength += strlen("//");
3790
3791     if (lpUrlComponents->lpszUserName)
3792     {
3793         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
3794         *lpdwUrlLength += strlen("@");
3795     }
3796     else
3797     {
3798         if (lpUrlComponents->lpszPassword)
3799         {
3800             SetLastError(ERROR_INVALID_PARAMETER);
3801             return FALSE;
3802         }
3803     }
3804
3805     if (lpUrlComponents->lpszPassword)
3806     {
3807         *lpdwUrlLength += strlen(":");
3808         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, Password);
3809     }
3810
3811     if (lpUrlComponents->lpszHostName)
3812     {
3813         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
3814
3815         if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
3816         {
3817             char szPort[MAX_WORD_DIGITS+1];
3818
3819             sprintf(szPort, "%d", lpUrlComponents->nPort);
3820             *lpdwUrlLength += strlen(szPort);
3821             *lpdwUrlLength += strlen(":");
3822         }
3823
3824         if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
3825             (*lpdwUrlLength)++; /* '/' */
3826     }
3827
3828     if (lpUrlComponents->lpszUrlPath)
3829         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
3830
3831     return TRUE;
3832 }
3833
3834 static void convert_urlcomp_atow(LPURL_COMPONENTSA lpUrlComponents, LPURL_COMPONENTSW urlCompW)
3835 {
3836     INT len;
3837
3838     ZeroMemory(urlCompW, sizeof(URL_COMPONENTSW));
3839
3840     urlCompW->dwStructSize = sizeof(URL_COMPONENTSW);
3841     urlCompW->dwSchemeLength = lpUrlComponents->dwSchemeLength;
3842     urlCompW->nScheme = lpUrlComponents->nScheme;
3843     urlCompW->dwHostNameLength = lpUrlComponents->dwHostNameLength;
3844     urlCompW->nPort = lpUrlComponents->nPort;
3845     urlCompW->dwUserNameLength = lpUrlComponents->dwUserNameLength;
3846     urlCompW->dwPasswordLength = lpUrlComponents->dwPasswordLength;
3847     urlCompW->dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
3848     urlCompW->dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
3849
3850     if (lpUrlComponents->lpszScheme)
3851     {
3852         len = URL_GET_COMP_LENGTHA(lpUrlComponents, Scheme) + 1;
3853         urlCompW->lpszScheme = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3854         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszScheme,
3855                             -1, urlCompW->lpszScheme, len);
3856     }
3857
3858     if (lpUrlComponents->lpszHostName)
3859     {
3860         len = URL_GET_COMP_LENGTHA(lpUrlComponents, HostName) + 1;
3861         urlCompW->lpszHostName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3862         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszHostName,
3863                             -1, urlCompW->lpszHostName, len);
3864     }
3865
3866     if (lpUrlComponents->lpszUserName)
3867     {
3868         len = URL_GET_COMP_LENGTHA(lpUrlComponents, UserName) + 1;
3869         urlCompW->lpszUserName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3870         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUserName,
3871                             -1, urlCompW->lpszUserName, len);
3872     }
3873
3874     if (lpUrlComponents->lpszPassword)
3875     {
3876         len = URL_GET_COMP_LENGTHA(lpUrlComponents, Password) + 1;
3877         urlCompW->lpszPassword = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3878         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszPassword,
3879                             -1, urlCompW->lpszPassword, len);
3880     }
3881
3882     if (lpUrlComponents->lpszUrlPath)
3883     {
3884         len = URL_GET_COMP_LENGTHA(lpUrlComponents, UrlPath) + 1;
3885         urlCompW->lpszUrlPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3886         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUrlPath,
3887                             -1, urlCompW->lpszUrlPath, len);
3888     }
3889
3890     if (lpUrlComponents->lpszExtraInfo)
3891     {
3892         len = URL_GET_COMP_LENGTHA(lpUrlComponents, ExtraInfo) + 1;
3893         urlCompW->lpszExtraInfo = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3894         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszExtraInfo,
3895                             -1, urlCompW->lpszExtraInfo, len);
3896     }
3897 }
3898
3899 /***********************************************************************
3900  *      InternetCreateUrlA (WININET.@)
3901  *
3902  * See InternetCreateUrlW.
3903  */
3904 BOOL WINAPI InternetCreateUrlA(LPURL_COMPONENTSA lpUrlComponents, DWORD dwFlags,
3905                                LPSTR lpszUrl, LPDWORD lpdwUrlLength)
3906 {
3907     BOOL ret;
3908     LPWSTR urlW = NULL;
3909     URL_COMPONENTSW urlCompW;
3910
3911     TRACE("(%p,%ld,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
3912
3913     if (!lpUrlComponents)
3914         return FALSE;
3915
3916     if (lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
3917     {
3918         SetLastError(ERROR_INVALID_PARAMETER);
3919         return FALSE;
3920     }
3921
3922     convert_urlcomp_atow(lpUrlComponents, &urlCompW);
3923
3924     if (lpszUrl)
3925         urlW = HeapAlloc(GetProcessHeap(), 0, *lpdwUrlLength * sizeof(WCHAR));
3926
3927     ret = InternetCreateUrlW(&urlCompW, dwFlags, urlW, lpdwUrlLength);
3928
3929     if (!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
3930         *lpdwUrlLength /= sizeof(WCHAR);
3931
3932     /* on success, lpdwUrlLength points to the size of urlW in WCHARS
3933     * minus one, so add one to leave room for NULL terminator
3934     */
3935     if (ret)
3936         WideCharToMultiByte(CP_ACP, 0, urlW, -1, lpszUrl, *lpdwUrlLength + 1, NULL, NULL);
3937
3938     HeapFree(GetProcessHeap(), 0, urlCompW.lpszScheme);
3939     HeapFree(GetProcessHeap(), 0, urlCompW.lpszHostName);
3940     HeapFree(GetProcessHeap(), 0, urlCompW.lpszUserName);
3941     HeapFree(GetProcessHeap(), 0, urlCompW.lpszPassword);
3942     HeapFree(GetProcessHeap(), 0, urlCompW.lpszUrlPath);
3943     HeapFree(GetProcessHeap(), 0, urlCompW.lpszExtraInfo);
3944     HeapFree(GetProcessHeap(), 0, urlW);
3945
3946     return ret;
3947 }
3948
3949 /***********************************************************************
3950  *      InternetCreateUrlW (WININET.@)
3951  *
3952  * Creates a URL from its component parts.
3953  *
3954  * PARAMS
3955  *  lpUrlComponents [I] URL Components.
3956  *  dwFlags         [I] Flags. See notes.
3957  *  lpszUrl         [I] Buffer in which to store the created URL.
3958  *  lpdwUrlLength   [I/O] On input, the length of the buffer pointed to by
3959  *                        lpszUrl in characters. On output, the number of bytes
3960  *                        required to store the URL including terminator.
3961  *
3962  * NOTES
3963  *
3964  * The dwFlags parameter can be zero or more of the following:
3965  *|ICU_ESCAPE - Generates escape sequences for unsafe characters in the path and extra info of the URL.
3966  *
3967  * RETURNS
3968  *   TRUE on success
3969  *   FALSE on failure
3970  *
3971  */
3972 BOOL WINAPI InternetCreateUrlW(LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags,
3973                                LPWSTR lpszUrl, LPDWORD lpdwUrlLength)
3974 {
3975     DWORD dwLen;
3976     INTERNET_SCHEME nScheme;
3977
3978     static const WCHAR slashSlashW[] = {'/','/'};
3979     static const WCHAR percentD[] = {'%','d',0};
3980
3981     TRACE("(%p,%ld,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
3982
3983     if (!lpUrlComponents)
3984         return FALSE;
3985
3986     if (lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
3987     {
3988         SetLastError(ERROR_INVALID_PARAMETER);
3989         return FALSE;
3990     }
3991
3992     if (!calc_url_length(lpUrlComponents, &dwLen))
3993         return FALSE;
3994
3995     if (!lpszUrl || *lpdwUrlLength < dwLen)
3996     {
3997         *lpdwUrlLength = (dwLen + 1) * sizeof(WCHAR);
3998         SetLastError(ERROR_INSUFFICIENT_BUFFER);
3999         return FALSE;
4000     }
4001
4002     *lpdwUrlLength = dwLen;
4003     lpszUrl[0] = 0x00;
4004
4005     dwLen = 0;
4006
4007     if (lpUrlComponents->lpszScheme)
4008     {
4009         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
4010         memcpy(lpszUrl, lpUrlComponents->lpszScheme, dwLen * sizeof(WCHAR));
4011         lpszUrl += dwLen;
4012
4013         nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
4014     }
4015     else
4016     {
4017         LPCWSTR scheme;
4018         nScheme = lpUrlComponents->nScheme;
4019
4020         if (nScheme == INTERNET_SCHEME_DEFAULT)
4021             nScheme = INTERNET_SCHEME_HTTP;
4022
4023         scheme = INTERNET_GetSchemeString(nScheme);
4024         dwLen = strlenW(scheme);
4025         memcpy(lpszUrl, scheme, dwLen * sizeof(WCHAR));
4026         lpszUrl += dwLen;
4027     }
4028
4029     /* all schemes are followed by at least a colon */
4030     *lpszUrl = ':';
4031     lpszUrl++;
4032
4033     if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
4034     {
4035         memcpy(lpszUrl, slashSlashW, sizeof(slashSlashW));
4036         lpszUrl += sizeof(slashSlashW)/sizeof(slashSlashW[0]);
4037     }
4038
4039     if (lpUrlComponents->lpszUserName)
4040     {
4041         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
4042         memcpy(lpszUrl, lpUrlComponents->lpszUserName, dwLen * sizeof(WCHAR));
4043         lpszUrl += dwLen;
4044
4045         if (lpUrlComponents->lpszPassword)
4046         {
4047             *lpszUrl = ':';
4048             lpszUrl++;
4049
4050             dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Password);
4051             memcpy(lpszUrl, lpUrlComponents->lpszPassword, dwLen * sizeof(WCHAR));
4052             lpszUrl += dwLen;
4053         }
4054
4055         *lpszUrl = '@';
4056         lpszUrl++;
4057     }
4058
4059     if (lpUrlComponents->lpszHostName)
4060     {
4061         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
4062         memcpy(lpszUrl, lpUrlComponents->lpszHostName, dwLen * sizeof(WCHAR));
4063         lpszUrl += dwLen;
4064
4065         if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
4066         {
4067             WCHAR szPort[MAX_WORD_DIGITS+1];
4068
4069             sprintfW(szPort, percentD, lpUrlComponents->nPort);
4070             *lpszUrl = ':';
4071             lpszUrl++;
4072             dwLen = strlenW(szPort);
4073             memcpy(lpszUrl, szPort, dwLen * sizeof(WCHAR));
4074             lpszUrl += dwLen;
4075         }
4076
4077         /* add slash between hostname and path if necessary */
4078         if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
4079         {
4080             *lpszUrl = '/';
4081             lpszUrl++;
4082         }
4083     }
4084
4085
4086     if (lpUrlComponents->lpszUrlPath)
4087     {
4088         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
4089         memcpy(lpszUrl, lpUrlComponents->lpszUrlPath, dwLen * sizeof(WCHAR));
4090         lpszUrl += dwLen;
4091     }
4092
4093     *lpszUrl = '\0';
4094
4095     return TRUE;
4096 }
4097
4098 /***********************************************************************
4099  *      InternetConfirmZoneCrossingA (WININET.@)
4100  *
4101  */
4102 DWORD WINAPI InternetConfirmZoneCrossingA( HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost )
4103 {
4104     FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_a(szUrlPrev), debugstr_a(szUrlNew), bPost);
4105     return ERROR_SUCCESS;
4106 }
4107
4108 /***********************************************************************
4109  *      InternetConfirmZoneCrossingW (WININET.@)
4110  *
4111  */
4112 DWORD WINAPI InternetConfirmZoneCrossingW( HWND hWnd, LPWSTR szUrlPrev, LPWSTR szUrlNew, BOOL bPost )
4113 {
4114     FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_w(szUrlPrev), debugstr_w(szUrlNew), bPost);
4115     return ERROR_SUCCESS;
4116 }
4117
4118 DWORD WINAPI InternetDialA( HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags,
4119                             LPDWORD lpdwConnection, DWORD dwReserved )
4120 {
4121     FIXME("(%p, %p, 0x%08lx, %p, 0x%08lx) stub\n", hwndParent, lpszConnectoid, dwFlags,
4122           lpdwConnection, dwReserved);
4123     return ERROR_SUCCESS;
4124 }
4125
4126 DWORD WINAPI InternetDialW( HWND hwndParent, LPWSTR lpszConnectoid, DWORD dwFlags,
4127                             LPDWORD lpdwConnection, DWORD dwReserved )
4128 {
4129     FIXME("(%p, %p, 0x%08lx, %p, 0x%08lx) stub\n", hwndParent, lpszConnectoid, dwFlags,
4130           lpdwConnection, dwReserved);
4131     return ERROR_SUCCESS;
4132 }
4133
4134 BOOL WINAPI InternetGoOnlineA( LPSTR lpszURL, HWND hwndParent, DWORD dwReserved )
4135 {
4136     FIXME("(%s, %p, 0x%08lx) stub\n", debugstr_a(lpszURL), hwndParent, dwReserved);
4137     return TRUE;
4138 }
4139
4140 BOOL WINAPI InternetGoOnlineW( LPWSTR lpszURL, HWND hwndParent, DWORD dwReserved )
4141 {
4142     FIXME("(%s, %p, 0x%08lx) stub\n", debugstr_w(lpszURL), hwndParent, dwReserved);
4143     return TRUE;
4144 }
4145
4146 DWORD WINAPI InternetHangUp( DWORD dwConnection, DWORD dwReserved )
4147 {
4148     FIXME("(0x%08lx, 0x%08lx) stub\n", dwConnection, dwReserved);
4149     return ERROR_SUCCESS;
4150 }
4151
4152 BOOL WINAPI CreateMD5SSOHash( PWSTR pszChallengeInfo, PWSTR pwszRealm, PWSTR pwszTarget,
4153                               PBYTE pbHexHash )
4154 {
4155     FIXME("(%s, %s, %s, %p) stub\n", debugstr_w(pszChallengeInfo), debugstr_w(pwszRealm),
4156           debugstr_w(pwszTarget), pbHexHash);
4157     return FALSE;
4158 }
4159
4160 BOOL WINAPI ResumeSuspendedDownload( HINTERNET hInternet, DWORD dwError )
4161 {
4162     FIXME("(%p, 0x%08lx) stub\n", hInternet, dwError);
4163     return FALSE;
4164 }