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