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 void AsyncInternetReadFileExProc(WORKREQUEST *workRequest)
1814 {
1815     struct WORKREQ_INTERNETREADFILEEXA const *req = &workRequest->u.InternetReadFileExA;
1816
1817     TRACE("INTERNETREADFILEEXA %p\n", workRequest->hdr);
1818
1819     INTERNET_ReadFile(workRequest->hdr, req->lpBuffersOut->lpvBuffer,
1820         req->lpBuffersOut->dwBufferLength,
1821         &req->lpBuffersOut->dwBufferLength, TRUE, TRUE);
1822 }
1823
1824 BOOL WINAPI InternetReadFileExA(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut,
1825         DWORD dwFlags, DWORD dwContext)
1826 {
1827     BOOL retval = FALSE;
1828     LPWININETHANDLEHEADER lpwh;
1829
1830     TRACE("(%p %p 0x%x 0x%x)\n", hFile, lpBuffersOut, dwFlags, dwContext);
1831
1832     if (dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT))
1833         FIXME("these dwFlags aren't implemented: 0x%x\n", dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT));
1834
1835     if (lpBuffersOut->dwStructSize != sizeof(*lpBuffersOut))
1836     {
1837         SetLastError(ERROR_INVALID_PARAMETER);
1838         return FALSE;
1839     }
1840
1841     lpwh = (LPWININETHANDLEHEADER) WININET_GetObject( hFile );
1842     if (!lpwh)
1843     {
1844         SetLastError(ERROR_INVALID_HANDLE);
1845         return FALSE;
1846     }
1847
1848     /* FIXME: native only does it asynchronously if the amount of data
1849      * requested isn't available. See NtReadFile. */
1850     /* FIXME: IRF_ASYNC may not be the right thing to test here;
1851      * hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC is probably better, but
1852      * we should implement the above first */
1853     if (dwFlags & IRF_ASYNC)
1854     {
1855         WORKREQUEST workRequest;
1856         struct WORKREQ_INTERNETREADFILEEXA *req;
1857
1858         workRequest.asyncall = CALLASYNCPROC;
1859         workRequest.asyncproc = AsyncInternetReadFileExProc;
1860         workRequest.hdr = WININET_AddRef( lpwh );
1861         req = &workRequest.u.InternetReadFileExA;
1862         req->lpBuffersOut = lpBuffersOut;
1863
1864         retval = INTERNET_AsyncCall(&workRequest);
1865         if (!retval) return FALSE;
1866
1867         SetLastError(ERROR_IO_PENDING);
1868         return FALSE;
1869     }
1870
1871     retval = INTERNET_ReadFile(lpwh, lpBuffersOut->lpvBuffer,
1872         lpBuffersOut->dwBufferLength, &lpBuffersOut->dwBufferLength,
1873         !(dwFlags & IRF_NO_WAIT), FALSE);
1874
1875     WININET_Release( lpwh );
1876
1877     TRACE("-- %s (bytes read: %d)\n", retval ? "TRUE": "FALSE", lpBuffersOut->dwBufferLength);
1878     return retval;
1879 }
1880
1881 /***********************************************************************
1882  *           InternetReadFileExW (WININET.@)
1883  *
1884  * Read data from an open internet file.
1885  *
1886  * PARAMS
1887  *  hFile         [I] Handle returned by InternetOpenUrl() or HttpOpenRequest().
1888  *  lpBuffersOut  [I/O] Buffer.
1889  *  dwFlags       [I] Flags.
1890  *  dwContext     [I] Context for callbacks.
1891  *
1892  * RETURNS
1893  *    FALSE, last error is set to ERROR_CALL_NOT_IMPLEMENTED
1894  *
1895  * NOTES
1896  *  Not implemented in Wine or native either (as of IE6 SP2).
1897  *
1898  */
1899 BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
1900         DWORD dwFlags, DWORD dwContext)
1901 {
1902   ERR("(%p, %p, 0x%x, 0x%x): not implemented in native\n", hFile, lpBuffer, dwFlags, dwContext);
1903
1904   INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1905   return FALSE;
1906 }
1907
1908 /***********************************************************************
1909  *           INET_QueryOptionHelper (internal)
1910  */
1911 static BOOL INET_QueryOptionHelper(BOOL bIsUnicode, HINTERNET hInternet, DWORD dwOption,
1912                                    LPVOID lpBuffer, LPDWORD lpdwBufferLength)
1913 {
1914     LPWININETHANDLEHEADER lpwhh;
1915     BOOL bSuccess = FALSE;
1916
1917     TRACE("(%p, 0x%08x, %p, %p)\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
1918
1919     lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
1920     if (!lpwhh)
1921     {
1922         SetLastError(ERROR_INVALID_PARAMETER);
1923         return FALSE;
1924     }
1925
1926     switch (dwOption)
1927     {
1928         case INTERNET_OPTION_HANDLE_TYPE:
1929         {
1930             ULONG type;
1931
1932             if (!lpwhh)
1933             {
1934                 WARN("Invalid hInternet handle\n");
1935                 SetLastError(ERROR_INVALID_HANDLE);
1936                 return FALSE;
1937             }
1938
1939             type = lpwhh->htype;
1940
1941             TRACE("INTERNET_OPTION_HANDLE_TYPE: %d\n", type);
1942
1943             if (*lpdwBufferLength < sizeof(ULONG))
1944                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1945             else
1946             {
1947                 memcpy(lpBuffer, &type, sizeof(ULONG));
1948                 bSuccess = TRUE;
1949             }
1950             *lpdwBufferLength = sizeof(ULONG);
1951             break;
1952         }
1953
1954         case INTERNET_OPTION_REQUEST_FLAGS:
1955         {
1956             ULONG flags = 4;
1957             TRACE("INTERNET_OPTION_REQUEST_FLAGS: %d\n", flags);
1958             if (*lpdwBufferLength < sizeof(ULONG))
1959                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1960             else
1961             {
1962                 memcpy(lpBuffer, &flags, sizeof(ULONG));
1963                 bSuccess = TRUE;
1964             }
1965             *lpdwBufferLength = sizeof(ULONG);
1966             break;
1967         }
1968
1969         case INTERNET_OPTION_URL:
1970         case INTERNET_OPTION_DATAFILE_NAME:
1971         {
1972             if (!lpwhh)
1973             {
1974                 WARN("Invalid hInternet handle\n");
1975                 SetLastError(ERROR_INVALID_HANDLE);
1976                 return FALSE;
1977             }
1978             if (lpwhh->htype == WH_HHTTPREQ)
1979             {
1980                 LPWININETHTTPREQW lpreq = (LPWININETHTTPREQW) lpwhh;
1981                 WCHAR url[1023];
1982                 static const WCHAR szFmt[] = {'h','t','t','p',':','/','/','%','s','%','s',0};
1983                 static const WCHAR szHost[] = {'H','o','s','t',0};
1984                 DWORD sizeRequired;
1985                 LPHTTPHEADERW Host;
1986
1987                 Host = HTTP_GetHeader(lpreq,szHost);
1988                 sprintfW(url,szFmt,Host->lpszValue,lpreq->lpszPath);
1989                 TRACE("INTERNET_OPTION_URL: %s\n",debugstr_w(url));
1990                 if(!bIsUnicode)
1991                 {
1992                     sizeRequired = WideCharToMultiByte(CP_ACP,0,url,-1,
1993                      lpBuffer,*lpdwBufferLength,NULL,NULL);
1994                     if (sizeRequired > *lpdwBufferLength)
1995                         INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1996                     else
1997                         bSuccess = TRUE;
1998                     *lpdwBufferLength = sizeRequired;
1999                 }
2000                 else
2001                 {
2002                     sizeRequired = (lstrlenW(url)+1) * sizeof(WCHAR);
2003                     if (*lpdwBufferLength < sizeRequired)
2004                         INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2005                     else
2006                     {
2007                         strcpyW(lpBuffer, url);
2008                         bSuccess = TRUE;
2009                     }
2010                     *lpdwBufferLength = sizeRequired;
2011                 }
2012             }
2013             break;
2014         }
2015         case INTERNET_OPTION_HTTP_VERSION:
2016         {
2017             if (*lpdwBufferLength < sizeof(HTTP_VERSION_INFO))
2018                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2019             else
2020             {
2021                 /*
2022                  * Presently hardcoded to 1.1
2023                  */
2024                 ((HTTP_VERSION_INFO*)lpBuffer)->dwMajorVersion = 1;
2025                 ((HTTP_VERSION_INFO*)lpBuffer)->dwMinorVersion = 1;
2026                 bSuccess = TRUE;
2027             }
2028             *lpdwBufferLength = sizeof(HTTP_VERSION_INFO);
2029             break;
2030         }
2031        case INTERNET_OPTION_CONNECTED_STATE:
2032        {
2033             DWORD *pdwConnectedState = (DWORD *)lpBuffer;
2034             FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
2035
2036             if (*lpdwBufferLength < sizeof(*pdwConnectedState))
2037                  INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2038             else
2039             {
2040                 *pdwConnectedState = INTERNET_STATE_CONNECTED;
2041                 bSuccess = TRUE;
2042             }
2043             *lpdwBufferLength = sizeof(*pdwConnectedState);
2044             break;
2045         }
2046         case INTERNET_OPTION_PROXY:
2047         {
2048             LPWININETAPPINFOW lpwai = (LPWININETAPPINFOW)lpwhh;
2049             WININETAPPINFOW wai;
2050
2051             if (lpwai == NULL)
2052             {
2053                 TRACE("Getting global proxy info\n");
2054                 memset(&wai, 0, sizeof(WININETAPPINFOW));
2055                 INTERNET_ConfigureProxyFromReg( &wai );
2056                 lpwai = &wai;
2057             }
2058
2059             if (bIsUnicode)
2060             {
2061                 INTERNET_PROXY_INFOW *pPI = (INTERNET_PROXY_INFOW *)lpBuffer;
2062                 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
2063
2064                 if (lpwai->lpszProxy)
2065                     proxyBytesRequired = (lstrlenW(lpwai->lpszProxy) + 1) *
2066                      sizeof(WCHAR);
2067                 if (lpwai->lpszProxyBypass)
2068                     proxyBypassBytesRequired =
2069                      (lstrlenW(lpwai->lpszProxyBypass) + 1) * sizeof(WCHAR);
2070                 if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOW) +
2071                  proxyBytesRequired + proxyBypassBytesRequired)
2072                     INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2073                 else
2074                 {
2075                     LPWSTR proxy = (LPWSTR)((LPBYTE)lpBuffer +
2076                                             sizeof(INTERNET_PROXY_INFOW));
2077                     LPWSTR proxy_bypass = (LPWSTR)((LPBYTE)lpBuffer +
2078                                                    sizeof(INTERNET_PROXY_INFOW) +
2079                                                    proxyBytesRequired);
2080
2081                     pPI->dwAccessType = lpwai->dwAccessType;
2082                     if (lpwai->lpszProxy)
2083                     {
2084                         lstrcpyW(proxy, lpwai->lpszProxy);
2085                     }
2086                     else
2087                     {
2088                         *proxy = 0;
2089                     }
2090                     pPI->lpszProxy = proxy;
2091
2092                     if (lpwai->lpszProxyBypass)
2093                     {
2094                         lstrcpyW(proxy_bypass, lpwai->lpszProxyBypass);
2095                     }
2096                     else
2097                     {
2098                         *proxy_bypass = 0;
2099                     }
2100                     pPI->lpszProxyBypass = proxy_bypass;
2101                     bSuccess = TRUE;
2102                 }
2103                 *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOW) +
2104                  proxyBytesRequired + proxyBypassBytesRequired;
2105             }
2106             else
2107             {
2108                 INTERNET_PROXY_INFOA *pPI = (INTERNET_PROXY_INFOA *)lpBuffer;
2109                 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
2110
2111                 if (lpwai->lpszProxy)
2112                     proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0,
2113                      lpwai->lpszProxy, -1, NULL, 0, NULL, NULL);
2114                 if (lpwai->lpszProxyBypass)
2115                     proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0,
2116                      lpwai->lpszProxyBypass, -1, NULL, 0, NULL, NULL);
2117                 if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOA) +
2118                  proxyBytesRequired + proxyBypassBytesRequired)
2119                     INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2120                 else
2121                 {
2122                     LPSTR proxy = (LPSTR)((LPBYTE)lpBuffer +
2123                                           sizeof(INTERNET_PROXY_INFOA));
2124                     LPSTR proxy_bypass = (LPSTR)((LPBYTE)lpBuffer +
2125                                                  sizeof(INTERNET_PROXY_INFOA) +
2126                                                  proxyBytesRequired);
2127
2128                     pPI->dwAccessType = lpwai->dwAccessType;
2129                     if (lpwai->lpszProxy)
2130                     {
2131                         WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxy, -1,
2132                                             proxy, proxyBytesRequired, NULL, NULL);
2133                     }
2134                     else
2135                     {
2136                         *proxy = '\0';
2137                     }
2138                     pPI->lpszProxy = proxy;
2139
2140                     if (lpwai->lpszProxyBypass)
2141                     {
2142                         WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxyBypass,
2143                                             -1, proxy_bypass, proxyBypassBytesRequired,
2144                                             NULL, NULL);
2145                     }
2146                     else
2147                     {
2148                         *proxy_bypass = '\0';
2149                     }
2150                     pPI->lpszProxyBypass = proxy_bypass;
2151                     bSuccess = TRUE;
2152                 }
2153                 *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOA) +
2154                  proxyBytesRequired + proxyBypassBytesRequired;
2155             }
2156             break;
2157         }
2158         case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2159         {
2160             ULONG conn = 2;
2161             TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER: %d\n", conn);
2162             if (*lpdwBufferLength < sizeof(ULONG))
2163                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2164             else
2165             {
2166                 memcpy(lpBuffer, &conn, sizeof(ULONG));
2167                 bSuccess = TRUE;
2168             }
2169             *lpdwBufferLength = sizeof(ULONG);
2170             break;
2171         }
2172         case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2173         {
2174             ULONG conn = 4;
2175             TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER: %d\n", conn);
2176             if (*lpdwBufferLength < sizeof(ULONG))
2177                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2178             else
2179             {
2180                 memcpy(lpBuffer, &conn, sizeof(ULONG));
2181                 bSuccess = TRUE;
2182             }
2183             *lpdwBufferLength = sizeof(ULONG);
2184             break;
2185         }
2186         case INTERNET_OPTION_SECURITY_FLAGS:
2187             FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
2188             break;
2189
2190         case INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT:
2191             if (*lpdwBufferLength < sizeof(INTERNET_CERTIFICATE_INFOW))
2192             {
2193                 *lpdwBufferLength = sizeof(INTERNET_CERTIFICATE_INFOW);
2194                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
2195             }
2196             else if (lpwhh->htype == WH_HHTTPREQ)
2197             {
2198                 LPWININETHTTPREQW lpwhr;
2199                 PCCERT_CONTEXT context;
2200
2201                 lpwhr = (LPWININETHTTPREQW)lpwhh;
2202                 context = (PCCERT_CONTEXT)NETCON_GetCert(&(lpwhr->netConnection));
2203                 if (context)
2204                 {
2205                     LPINTERNET_CERTIFICATE_INFOW info = (LPINTERNET_CERTIFICATE_INFOW)lpBuffer;
2206                     DWORD strLen;
2207
2208                     memset(info,0,sizeof(INTERNET_CERTIFICATE_INFOW));
2209                     info->ftExpiry = context->pCertInfo->NotAfter;
2210                     info->ftStart = context->pCertInfo->NotBefore;
2211                     if (bIsUnicode)
2212                     {
2213                         strLen = CertNameToStrW(context->dwCertEncodingType,
2214                          &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2215                          NULL, 0);
2216                         info->lpszSubjectInfo = LocalAlloc(0,
2217                          strLen * sizeof(WCHAR));
2218                         if (info->lpszSubjectInfo)
2219                             CertNameToStrW(context->dwCertEncodingType,
2220                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2221                              info->lpszSubjectInfo, strLen);
2222                         strLen = CertNameToStrW(context->dwCertEncodingType,
2223                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2224                          NULL, 0);
2225                         info->lpszIssuerInfo = LocalAlloc(0,
2226                          strLen * sizeof(WCHAR));
2227                         if (info->lpszIssuerInfo)
2228                             CertNameToStrW(context->dwCertEncodingType,
2229                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2230                              info->lpszIssuerInfo, strLen);
2231                     }
2232                     else
2233                     {
2234                         LPINTERNET_CERTIFICATE_INFOA infoA =
2235                          (LPINTERNET_CERTIFICATE_INFOA)info;
2236
2237                         strLen = CertNameToStrA(context->dwCertEncodingType,
2238                          &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2239                          NULL, 0);
2240                         infoA->lpszSubjectInfo = LocalAlloc(0, strLen);
2241                         if (infoA->lpszSubjectInfo)
2242                             CertNameToStrA(context->dwCertEncodingType,
2243                              &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
2244                              infoA->lpszSubjectInfo, strLen);
2245                         strLen = CertNameToStrA(context->dwCertEncodingType,
2246                          &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2247                          NULL, 0);
2248                         infoA->lpszIssuerInfo = LocalAlloc(0, strLen);
2249                         if (infoA->lpszIssuerInfo)
2250                             CertNameToStrA(context->dwCertEncodingType,
2251                              &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
2252                              infoA->lpszIssuerInfo, strLen);
2253                     }
2254                     /*
2255                      * Contrary to MSDN, these do not appear to be set.
2256                      * lpszProtocolName
2257                      * lpszSignatureAlgName
2258                      * lpszEncryptionAlgName
2259                      * dwKeySize
2260                      */
2261                     CertFreeCertificateContext(context);
2262                     bSuccess = TRUE;
2263                 }
2264             }
2265             break;
2266         default:
2267             FIXME("Stub! %d\n", dwOption);
2268             break;
2269     }
2270     if (lpwhh)
2271         WININET_Release( lpwhh );
2272
2273     return bSuccess;
2274 }
2275
2276 /***********************************************************************
2277  *           InternetQueryOptionW (WININET.@)
2278  *
2279  * Queries an options on the specified handle
2280  *
2281  * RETURNS
2282  *    TRUE  on success
2283  *    FALSE on failure
2284  *
2285  */
2286 BOOL WINAPI InternetQueryOptionW(HINTERNET hInternet, DWORD dwOption,
2287                                  LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2288 {
2289     return INET_QueryOptionHelper(TRUE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
2290 }
2291
2292 /***********************************************************************
2293  *           InternetQueryOptionA (WININET.@)
2294  *
2295  * Queries an options on the specified handle
2296  *
2297  * RETURNS
2298  *    TRUE  on success
2299  *    FALSE on failure
2300  *
2301  */
2302 BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
2303                                  LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2304 {
2305     return INET_QueryOptionHelper(FALSE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
2306 }
2307
2308
2309 /***********************************************************************
2310  *           InternetSetOptionW (WININET.@)
2311  *
2312  * Sets an options on the specified handle
2313  *
2314  * RETURNS
2315  *    TRUE  on success
2316  *    FALSE on failure
2317  *
2318  */
2319 BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
2320                            LPVOID lpBuffer, DWORD dwBufferLength)
2321 {
2322     LPWININETHANDLEHEADER lpwhh;
2323     BOOL ret = TRUE;
2324
2325     TRACE("0x%08x\n", dwOption);
2326
2327     lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
2328     if( !lpwhh )
2329         return FALSE;
2330
2331     switch (dwOption)
2332     {
2333     case INTERNET_OPTION_HTTP_VERSION:
2334       {
2335         HTTP_VERSION_INFO* pVersion=(HTTP_VERSION_INFO*)lpBuffer;
2336         FIXME("Option INTERNET_OPTION_HTTP_VERSION(%d,%d): STUB\n",pVersion->dwMajorVersion,pVersion->dwMinorVersion);
2337       }
2338       break;
2339     case INTERNET_OPTION_ERROR_MASK:
2340       {
2341         unsigned long flags=*(unsigned long*)lpBuffer;
2342         FIXME("Option INTERNET_OPTION_ERROR_MASK(%ld): STUB\n",flags);
2343       }
2344       break;
2345     case INTERNET_OPTION_CODEPAGE:
2346       {
2347         unsigned long codepage=*(unsigned long*)lpBuffer;
2348         FIXME("Option INTERNET_OPTION_CODEPAGE (%ld): STUB\n",codepage);
2349       }
2350       break;
2351     case INTERNET_OPTION_REQUEST_PRIORITY:
2352       {
2353         unsigned long priority=*(unsigned long*)lpBuffer;
2354         FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%ld): STUB\n",priority);
2355       }
2356       break;
2357     case INTERNET_OPTION_CONNECT_TIMEOUT:
2358       {
2359         unsigned long connecttimeout=*(unsigned long*)lpBuffer;
2360         FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%ld): STUB\n",connecttimeout);
2361       }
2362       break;
2363     case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
2364       {
2365         unsigned long receivetimeout=*(unsigned long*)lpBuffer;
2366         FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%ld): STUB\n",receivetimeout);
2367       }
2368       break;
2369     case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2370       {
2371         unsigned long conns=*(unsigned long*)lpBuffer;
2372         FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_SERVER (%ld): STUB\n",conns);
2373       }
2374       break;
2375     case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2376       {
2377         unsigned long conns=*(unsigned long*)lpBuffer;
2378         FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER (%ld): STUB\n",conns);
2379       }
2380       break;
2381     case INTERNET_OPTION_RESET_URLCACHE_SESSION:
2382         FIXME("Option INTERNET_OPTION_RESET_URLCACHE_SESSION: STUB\n");
2383         break;
2384     case INTERNET_OPTION_END_BROWSER_SESSION:
2385         FIXME("Option INTERNET_OPTION_END_BROWSER_SESSION: STUB\n");
2386         break;
2387     case INTERNET_OPTION_CONNECTED_STATE:
2388         FIXME("Option INTERNET_OPTION_CONNECTED_STATE: STUB\n");
2389         break;
2390     case INTERNET_OPTION_DISABLE_PASSPORT_AUTH:
2391         TRACE("Option INTERNET_OPTION_DISABLE_PASSPORT_AUTH: harmless stub, since not enabled\n");
2392         break;
2393     case INTERNET_OPTION_SEND_TIMEOUT:
2394     case INTERNET_OPTION_RECEIVE_TIMEOUT:
2395         TRACE("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT\n");
2396         if (dwBufferLength == sizeof(DWORD))
2397         {
2398             if (lpwhh->htype == WH_HHTTPREQ)
2399                 ret = NETCON_set_timeout(
2400                     &((LPWININETHTTPREQW)lpwhh)->netConnection,
2401                     dwOption == INTERNET_OPTION_SEND_TIMEOUT,
2402                     *(DWORD *)lpBuffer);
2403             else
2404             {
2405                 FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT not supported on protocol %d\n",
2406                       lpwhh->htype);
2407             }
2408         }
2409         else
2410         {
2411             INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2412             ret = FALSE;
2413         }
2414         break;
2415     case INTERNET_OPTION_CONNECT_RETRIES:
2416         FIXME("Option INTERNET_OPTION_CONNECT_RETRIES: STUB\n");
2417         break;
2418     case INTERNET_OPTION_CONTEXT_VALUE:
2419          FIXME("Option INTERNET_OPTION_CONTEXT_VALUE; STUB\n");
2420          break;
2421     case INTERNET_OPTION_SECURITY_FLAGS:
2422          FIXME("Option INTERNET_OPTION_SECURITY_FLAGS; STUB\n");
2423          break;
2424     default:
2425         FIXME("Option %d STUB\n",dwOption);
2426         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2427         ret = FALSE;
2428         break;
2429     }
2430     WININET_Release( lpwhh );
2431
2432     return ret;
2433 }
2434
2435
2436 /***********************************************************************
2437  *           InternetSetOptionA (WININET.@)
2438  *
2439  * Sets an options on the specified handle.
2440  *
2441  * RETURNS
2442  *    TRUE  on success
2443  *    FALSE on failure
2444  *
2445  */
2446 BOOL WINAPI InternetSetOptionA(HINTERNET hInternet, DWORD dwOption,
2447                            LPVOID lpBuffer, DWORD dwBufferLength)
2448 {
2449     LPVOID wbuffer;
2450     DWORD wlen;
2451     BOOL r;
2452
2453     switch( dwOption )
2454     {
2455     case INTERNET_OPTION_PROXY:
2456         {
2457         LPINTERNET_PROXY_INFOA pi = (LPINTERNET_PROXY_INFOA) lpBuffer;
2458         LPINTERNET_PROXY_INFOW piw;
2459         DWORD proxlen, prbylen;
2460         LPWSTR prox, prby;
2461
2462         proxlen = MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, NULL, 0);
2463         prbylen= MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, NULL, 0);
2464         wlen = sizeof(*piw) + proxlen + prbylen;
2465         wbuffer = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
2466         piw = (LPINTERNET_PROXY_INFOW) wbuffer;
2467         piw->dwAccessType = pi->dwAccessType;
2468         prox = (LPWSTR) &piw[1];
2469         prby = &prox[proxlen+1];
2470         MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, prox, proxlen);
2471         MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, prby, prbylen);
2472         piw->lpszProxy = prox;
2473         piw->lpszProxyBypass = prby;
2474         }
2475         break;
2476     case INTERNET_OPTION_USER_AGENT:
2477     case INTERNET_OPTION_USERNAME:
2478     case INTERNET_OPTION_PASSWORD:
2479         wlen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, dwBufferLength,
2480                                    NULL, 0 );
2481         wbuffer = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
2482         MultiByteToWideChar( CP_ACP, 0, lpBuffer, dwBufferLength,
2483                                    wbuffer, wlen );
2484         break;
2485     default:
2486         wbuffer = lpBuffer;
2487         wlen = dwBufferLength;
2488     }
2489
2490     r = InternetSetOptionW(hInternet,dwOption, wbuffer, wlen);
2491
2492     if( lpBuffer != wbuffer )
2493         HeapFree( GetProcessHeap(), 0, wbuffer );
2494
2495     return r;
2496 }
2497
2498
2499 /***********************************************************************
2500  *           InternetSetOptionExA (WININET.@)
2501  */
2502 BOOL WINAPI InternetSetOptionExA(HINTERNET hInternet, DWORD dwOption,
2503                            LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
2504 {
2505     FIXME("Flags %08x ignored\n", dwFlags);
2506     return InternetSetOptionA( hInternet, dwOption, lpBuffer, dwBufferLength );
2507 }
2508
2509 /***********************************************************************
2510  *           InternetSetOptionExW (WININET.@)
2511  */
2512 BOOL WINAPI InternetSetOptionExW(HINTERNET hInternet, DWORD dwOption,
2513                            LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
2514 {
2515     FIXME("Flags %08x ignored\n", dwFlags);
2516     if( dwFlags & ~ISO_VALID_FLAGS )
2517     {
2518         SetLastError( ERROR_INVALID_PARAMETER );
2519         return FALSE;
2520     }
2521     return InternetSetOptionW( hInternet, dwOption, lpBuffer, dwBufferLength );
2522 }
2523
2524 static const WCHAR WININET_wkday[7][4] =
2525     { { 'S','u','n', 0 }, { 'M','o','n', 0 }, { 'T','u','e', 0 }, { 'W','e','d', 0 },
2526       { 'T','h','u', 0 }, { 'F','r','i', 0 }, { 'S','a','t', 0 } };
2527 static const WCHAR WININET_month[12][4] =
2528     { { 'J','a','n', 0 }, { 'F','e','b', 0 }, { 'M','a','r', 0 }, { 'A','p','r', 0 },
2529       { 'M','a','y', 0 }, { 'J','u','n', 0 }, { 'J','u','l', 0 }, { 'A','u','g', 0 },
2530       { 'S','e','p', 0 }, { 'O','c','t', 0 }, { 'N','o','v', 0 }, { 'D','e','c', 0 } };
2531
2532 /***********************************************************************
2533  *           InternetTimeFromSystemTimeA (WININET.@)
2534  */
2535 BOOL WINAPI InternetTimeFromSystemTimeA( const SYSTEMTIME* time, DWORD format, LPSTR string, DWORD size )
2536 {
2537     BOOL ret;
2538     WCHAR stringW[INTERNET_RFC1123_BUFSIZE];
2539
2540     TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
2541
2542     ret = InternetTimeFromSystemTimeW( time, format, stringW, sizeof(stringW) );
2543     if (ret) WideCharToMultiByte( CP_ACP, 0, stringW, -1, string, size, NULL, NULL );
2544
2545     return ret;
2546 }
2547
2548 /***********************************************************************
2549  *           InternetTimeFromSystemTimeW (WININET.@)
2550  */
2551 BOOL WINAPI InternetTimeFromSystemTimeW( const SYSTEMTIME* time, DWORD format, LPWSTR string, DWORD size )
2552 {
2553     static const WCHAR date[] =
2554         { '%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
2555           '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0 };
2556
2557     TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
2558
2559     if (!time || !string) return FALSE;
2560
2561     if (format != INTERNET_RFC1123_FORMAT || size < INTERNET_RFC1123_BUFSIZE * sizeof(WCHAR))
2562         return FALSE;
2563
2564     sprintfW( string, date,
2565               WININET_wkday[time->wDayOfWeek],
2566               time->wDay,
2567               WININET_month[time->wMonth - 1],
2568               time->wYear,
2569               time->wHour,
2570               time->wMinute,
2571               time->wSecond );
2572
2573     return TRUE;
2574 }
2575
2576 /***********************************************************************
2577  *           InternetTimeToSystemTimeA (WININET.@)
2578  */
2579 BOOL WINAPI InternetTimeToSystemTimeA( LPCSTR string, SYSTEMTIME* time, DWORD reserved )
2580 {
2581     BOOL ret = FALSE;
2582     WCHAR *stringW;
2583     int len;
2584
2585     TRACE( "%s %p 0x%08x\n", debugstr_a(string), time, reserved );
2586
2587     len = MultiByteToWideChar( CP_ACP, 0, string, -1, NULL, 0 );
2588     stringW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2589
2590     if (stringW)
2591     {
2592         MultiByteToWideChar( CP_ACP, 0, string, -1, stringW, len );
2593         ret = InternetTimeToSystemTimeW( stringW, time, reserved );
2594         HeapFree( GetProcessHeap(), 0, stringW );
2595     }
2596     return ret;
2597 }
2598
2599 /***********************************************************************
2600  *           InternetTimeToSystemTimeW (WININET.@)
2601  */
2602 BOOL WINAPI InternetTimeToSystemTimeW( LPCWSTR string, SYSTEMTIME* time, DWORD reserved )
2603 {
2604     unsigned int i;
2605     const WCHAR *s = string;
2606     WCHAR       *end;
2607
2608     TRACE( "%s %p 0x%08x\n", debugstr_w(string), time, reserved );
2609
2610     if (!string || !time) return FALSE;
2611
2612     /* Windows does this too */
2613     GetSystemTime( time );
2614
2615     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
2616      *  a SYSTEMTIME structure.
2617      */
2618
2619     while (*s && !isalphaW( *s )) s++;
2620     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2621     time->wDayOfWeek = 7;
2622
2623     for (i = 0; i < 7; i++)
2624     {
2625         if (toupperW( WININET_wkday[i][0] ) == toupperW( s[0] ) &&
2626             toupperW( WININET_wkday[i][1] ) == toupperW( s[1] ) &&
2627             toupperW( WININET_wkday[i][2] ) == toupperW( s[2] ) )
2628         {
2629             time->wDayOfWeek = i;
2630             break;
2631         }
2632     }
2633
2634     if (time->wDayOfWeek > 6) return TRUE;
2635     while (*s && !isdigitW( *s )) s++;
2636     time->wDay = strtolW( s, &end, 10 );
2637     s = end;
2638
2639     while (*s && !isalphaW( *s )) s++;
2640     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2641     time->wMonth = 0;
2642
2643     for (i = 0; i < 12; i++)
2644     {
2645         if (toupperW( WININET_month[i][0]) == toupperW( s[0] ) &&
2646             toupperW( WININET_month[i][1]) == toupperW( s[1] ) &&
2647             toupperW( WININET_month[i][2]) == toupperW( s[2] ) )
2648         {
2649             time->wMonth = i + 1;
2650             break;
2651         }
2652     }
2653     if (time->wMonth == 0) return TRUE;
2654
2655     while (*s && !isdigitW( *s )) s++;
2656     if (*s == '\0') return TRUE;
2657     time->wYear = strtolW( s, &end, 10 );
2658     s = end;
2659
2660     while (*s && !isdigitW( *s )) s++;
2661     if (*s == '\0') return TRUE;
2662     time->wHour = strtolW( s, &end, 10 );
2663     s = end;
2664
2665     while (*s && !isdigitW( *s )) s++;
2666     if (*s == '\0') return TRUE;
2667     time->wMinute = strtolW( s, &end, 10 );
2668     s = end;
2669
2670     while (*s && !isdigitW( *s )) s++;
2671     if (*s == '\0') return TRUE;
2672     time->wSecond = strtolW( s, &end, 10 );
2673     s = end;
2674
2675     time->wMilliseconds = 0;
2676     return TRUE;
2677 }
2678
2679 /***********************************************************************
2680  *      InternetCheckConnectionW (WININET.@)
2681  *
2682  * Pings a requested host to check internet connection
2683  *
2684  * RETURNS
2685  *   TRUE on success and FALSE on failure. If a failure then
2686  *   ERROR_NOT_CONNECTED is placed into GetLastError
2687  *
2688  */
2689 BOOL WINAPI InternetCheckConnectionW( LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved )
2690 {
2691 /*
2692  * this is a kludge which runs the resident ping program and reads the output.
2693  *
2694  * Anyone have a better idea?
2695  */
2696
2697   BOOL   rc = FALSE;
2698   static const CHAR ping[] = "ping -w 1 ";
2699   static const CHAR redirect[] = " >/dev/null 2>/dev/null";
2700   CHAR *command = NULL;
2701   WCHAR hostW[1024];
2702   DWORD len;
2703   int status = -1;
2704
2705   FIXME("\n");
2706
2707   /*
2708    * Crack or set the Address
2709    */
2710   if (lpszUrl == NULL)
2711   {
2712      /*
2713       * According to the doc we are supost to use the ip for the next
2714       * server in the WnInet internal server database. I have
2715       * no idea what that is or how to get it.
2716       *
2717       * So someone needs to implement this.
2718       */
2719      FIXME("Unimplemented with URL of NULL\n");
2720      return TRUE;
2721   }
2722   else
2723   {
2724      URL_COMPONENTSW components;
2725
2726      ZeroMemory(&components,sizeof(URL_COMPONENTSW));
2727      components.lpszHostName = (LPWSTR)&hostW;
2728      components.dwHostNameLength = 1024;
2729
2730      if (!InternetCrackUrlW(lpszUrl,0,0,&components))
2731        goto End;
2732
2733      TRACE("host name : %s\n",debugstr_w(components.lpszHostName));
2734   }
2735
2736   /*
2737    * Build our ping command
2738    */
2739   len = WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, NULL, 0, NULL, NULL);
2740   command = HeapAlloc( GetProcessHeap(), 0, strlen(ping)+len+strlen(redirect) );
2741   strcpy(command,ping);
2742   WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, command+strlen(ping), len, NULL, NULL);
2743   strcat(command,redirect);
2744
2745   TRACE("Ping command is : %s\n",command);
2746
2747   status = system(command);
2748
2749   TRACE("Ping returned a code of %i\n",status);
2750
2751   /* Ping return code of 0 indicates success */
2752   if (status == 0)
2753      rc = TRUE;
2754
2755 End:
2756
2757   HeapFree( GetProcessHeap(), 0, command );
2758   if (rc == FALSE)
2759     SetLastError(ERROR_NOT_CONNECTED);
2760
2761   return rc;
2762 }
2763
2764
2765 /***********************************************************************
2766  *      InternetCheckConnectionA (WININET.@)
2767  *
2768  * Pings a requested host to check internet connection
2769  *
2770  * RETURNS
2771  *   TRUE on success and FALSE on failure. If a failure then
2772  *   ERROR_NOT_CONNECTED is placed into GetLastError
2773  *
2774  */
2775 BOOL WINAPI InternetCheckConnectionA(LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
2776 {
2777     WCHAR *szUrl;
2778     INT len;
2779     BOOL rc;
2780
2781     len = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0);
2782     if (!(szUrl = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
2783         return FALSE;
2784     MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, len);
2785     rc = InternetCheckConnectionW(szUrl, dwFlags, dwReserved);
2786     HeapFree(GetProcessHeap(), 0, szUrl);
2787
2788     return rc;
2789 }
2790
2791
2792 /**********************************************************
2793  *      INTERNET_InternetOpenUrlW (internal)
2794  *
2795  * Opens an URL
2796  *
2797  * RETURNS
2798  *   handle of connection or NULL on failure
2799  */
2800 HINTERNET WINAPI INTERNET_InternetOpenUrlW(LPWININETAPPINFOW hIC, LPCWSTR lpszUrl,
2801     LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
2802 {
2803     URL_COMPONENTSW urlComponents;
2804     WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
2805     WCHAR password[1024], path[2048], extra[1024];
2806     HINTERNET client = NULL, client1 = NULL;
2807
2808     TRACE("(%p, %s, %s, %08x, %08x, %08x)\n", hIC, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
2809           dwHeadersLength, dwFlags, dwContext);
2810
2811     urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
2812     urlComponents.lpszScheme = protocol;
2813     urlComponents.dwSchemeLength = 32;
2814     urlComponents.lpszHostName = hostName;
2815     urlComponents.dwHostNameLength = MAXHOSTNAME;
2816     urlComponents.lpszUserName = userName;
2817     urlComponents.dwUserNameLength = 1024;
2818     urlComponents.lpszPassword = password;
2819     urlComponents.dwPasswordLength = 1024;
2820     urlComponents.lpszUrlPath = path;
2821     urlComponents.dwUrlPathLength = 2048;
2822     urlComponents.lpszExtraInfo = extra;
2823     urlComponents.dwExtraInfoLength = 1024;
2824     if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
2825         return NULL;
2826     switch(urlComponents.nScheme) {
2827     case INTERNET_SCHEME_FTP:
2828         if(urlComponents.nPort == 0)
2829             urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT;
2830         client = FTP_Connect(hIC, hostName, urlComponents.nPort,
2831                              userName, password, dwFlags, dwContext, INET_OPENURL);
2832         if(client == NULL)
2833             break;
2834         client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext);
2835         if(client1 == NULL) {
2836             InternetCloseHandle(client);
2837             break;
2838         }
2839         break;
2840
2841     case INTERNET_SCHEME_HTTP:
2842     case INTERNET_SCHEME_HTTPS: {
2843         static const WCHAR szStars[] = { '*','/','*', 0 };
2844         LPCWSTR accept[2] = { szStars, NULL };
2845         if(urlComponents.nPort == 0) {
2846             if(urlComponents.nScheme == INTERNET_SCHEME_HTTP)
2847                 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
2848             else
2849                 urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
2850         }
2851         /* FIXME: should use pointers, not handles, as handles are not thread-safe */
2852         client = HTTP_Connect(hIC, hostName, urlComponents.nPort,
2853                               userName, password, dwFlags, dwContext, INET_OPENURL);
2854         if(client == NULL)
2855             break;
2856         client1 = HttpOpenRequestW(client, NULL, path, NULL, NULL, accept, dwFlags, dwContext);
2857         if(client1 == NULL) {
2858             InternetCloseHandle(client);
2859             break;
2860         }
2861         HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
2862         if (!HttpSendRequestW(client1, NULL, 0, NULL, 0) &&
2863             GetLastError() != ERROR_IO_PENDING) {
2864             InternetCloseHandle(client1);
2865             client1 = NULL;
2866             break;
2867         }
2868     }
2869     case INTERNET_SCHEME_GOPHER:
2870         /* gopher doesn't seem to be implemented in wine, but it's supposed
2871          * to be supported by InternetOpenUrlA. */
2872     default:
2873         INTERNET_SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
2874         break;
2875     }
2876
2877     TRACE(" %p <--\n", client1);
2878
2879     return client1;
2880 }
2881
2882 /**********************************************************
2883  *      InternetOpenUrlW (WININET.@)
2884  *
2885  * Opens an URL
2886  *
2887  * RETURNS
2888  *   handle of connection or NULL on failure
2889  */
2890 static void AsyncInternetOpenUrlProc(WORKREQUEST *workRequest)
2891 {
2892     struct WORKREQ_INTERNETOPENURLW const *req = &workRequest->u.InternetOpenUrlW;
2893     LPWININETAPPINFOW hIC = (LPWININETAPPINFOW) workRequest->hdr;
2894
2895     TRACE("%p\n", hIC);
2896
2897     INTERNET_InternetOpenUrlW(hIC, req->lpszUrl,
2898                               req->lpszHeaders, req->dwHeadersLength, req->dwFlags, req->dwContext);
2899     HeapFree(GetProcessHeap(), 0, req->lpszUrl);
2900     HeapFree(GetProcessHeap(), 0, req->lpszHeaders);
2901 }
2902
2903 HINTERNET WINAPI InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
2904     LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
2905 {
2906     HINTERNET ret = NULL;
2907     LPWININETAPPINFOW hIC = NULL;
2908
2909     if (TRACE_ON(wininet)) {
2910         TRACE("(%p, %s, %s, %08x, %08x, %08x)\n", hInternet, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
2911               dwHeadersLength, dwFlags, dwContext);
2912         TRACE("  flags :");
2913         dump_INTERNET_FLAGS(dwFlags);
2914     }
2915
2916     if (!lpszUrl)
2917     {
2918         SetLastError(ERROR_INVALID_PARAMETER);
2919         goto lend;
2920     }
2921
2922     hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
2923     if (NULL == hIC ||  hIC->hdr.htype != WH_HINIT) {
2924         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2925         goto lend;
2926     }
2927
2928     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC) {
2929         WORKREQUEST workRequest;
2930         struct WORKREQ_INTERNETOPENURLW *req;
2931
2932         workRequest.asyncall = CALLASYNCPROC;
2933         workRequest.asyncproc = AsyncInternetOpenUrlProc;
2934         workRequest.hdr = WININET_AddRef( &hIC->hdr );
2935         req = &workRequest.u.InternetOpenUrlW;
2936         req->lpszUrl = WININET_strdupW(lpszUrl);
2937         if (lpszHeaders)
2938             req->lpszHeaders = WININET_strdupW(lpszHeaders);
2939         else
2940             req->lpszHeaders = 0;
2941         req->dwHeadersLength = dwHeadersLength;
2942         req->dwFlags = dwFlags;
2943         req->dwContext = dwContext;
2944
2945         INTERNET_AsyncCall(&workRequest);
2946         /*
2947          * This is from windows.
2948          */
2949         SetLastError(ERROR_IO_PENDING);
2950     } else {
2951         ret = INTERNET_InternetOpenUrlW(hIC, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
2952     }
2953
2954   lend:
2955     if( hIC )
2956         WININET_Release( &hIC->hdr );
2957     TRACE(" %p <--\n", ret);
2958
2959     return ret;
2960 }
2961
2962 /**********************************************************
2963  *      InternetOpenUrlA (WININET.@)
2964  *
2965  * Opens an URL
2966  *
2967  * RETURNS
2968  *   handle of connection or NULL on failure
2969  */
2970 HINTERNET WINAPI InternetOpenUrlA(HINTERNET hInternet, LPCSTR lpszUrl,
2971     LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
2972 {
2973     HINTERNET rc = (HINTERNET)NULL;
2974
2975     INT lenUrl;
2976     INT lenHeaders = 0;
2977     LPWSTR szUrl = NULL;
2978     LPWSTR szHeaders = NULL;
2979
2980     TRACE("\n");
2981
2982     if(lpszUrl) {
2983         lenUrl = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0 );
2984         szUrl = HeapAlloc(GetProcessHeap(), 0, lenUrl*sizeof(WCHAR));
2985         if(!szUrl)
2986             return (HINTERNET)NULL;
2987         MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, lenUrl);
2988     }
2989
2990     if(lpszHeaders) {
2991         lenHeaders = MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, NULL, 0 );
2992         szHeaders = HeapAlloc(GetProcessHeap(), 0, lenHeaders*sizeof(WCHAR));
2993         if(!szHeaders) {
2994             HeapFree(GetProcessHeap(), 0, szUrl);
2995             return (HINTERNET)NULL;
2996         }
2997         MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, szHeaders, lenHeaders);
2998     }
2999
3000     rc = InternetOpenUrlW(hInternet, szUrl, szHeaders,
3001         lenHeaders, dwFlags, dwContext);
3002
3003     HeapFree(GetProcessHeap(), 0, szUrl);
3004     HeapFree(GetProcessHeap(), 0, szHeaders);
3005
3006     return rc;
3007 }
3008
3009
3010 static LPWITHREADERROR INTERNET_AllocThreadError(void)
3011 {
3012     LPWITHREADERROR lpwite = HeapAlloc(GetProcessHeap(), 0, sizeof(*lpwite));
3013
3014     if (lpwite)
3015     {
3016         lpwite->dwError = 0;
3017         lpwite->response[0] = '\0';
3018     }
3019
3020     if (!TlsSetValue(g_dwTlsErrIndex, lpwite))
3021     {
3022         HeapFree(GetProcessHeap(), 0, lpwite);
3023         return NULL;
3024     }
3025
3026     return lpwite;
3027 }
3028
3029
3030 /***********************************************************************
3031  *           INTERNET_SetLastError (internal)
3032  *
3033  * Set last thread specific error
3034  *
3035  * RETURNS
3036  *
3037  */
3038 void INTERNET_SetLastError(DWORD dwError)
3039 {
3040     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3041
3042     if (!lpwite)
3043         lpwite = INTERNET_AllocThreadError();
3044
3045     SetLastError(dwError);
3046     if(lpwite)
3047         lpwite->dwError = dwError;
3048 }
3049
3050
3051 /***********************************************************************
3052  *           INTERNET_GetLastError (internal)
3053  *
3054  * Get last thread specific error
3055  *
3056  * RETURNS
3057  *
3058  */
3059 DWORD INTERNET_GetLastError(void)
3060 {
3061     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3062     if (!lpwite) return 0;
3063     /* TlsGetValue clears last error, so set it again here */
3064     SetLastError(lpwite->dwError);
3065     return lpwite->dwError;
3066 }
3067
3068
3069 /***********************************************************************
3070  *           INTERNET_WorkerThreadFunc (internal)
3071  *
3072  * Worker thread execution function
3073  *
3074  * RETURNS
3075  *
3076  */
3077 static DWORD CALLBACK INTERNET_WorkerThreadFunc(LPVOID lpvParam)
3078 {
3079     DWORD dwWaitRes;
3080
3081     while (1)
3082     {
3083         if(dwNumJobs > 0) {
3084             INTERNET_ExecuteWork();
3085             continue;
3086         }
3087         dwWaitRes = WaitForMultipleObjects(2, hEventArray, FALSE, MAX_IDLE_WORKER);
3088
3089         if (dwWaitRes == WAIT_OBJECT_0 + 1)
3090             INTERNET_ExecuteWork();
3091         else
3092             break;
3093
3094         InterlockedIncrement(&dwNumIdleThreads);
3095     }
3096
3097     InterlockedDecrement(&dwNumIdleThreads);
3098     InterlockedDecrement(&dwNumThreads);
3099     TRACE("Worker thread exiting\n");
3100     return TRUE;
3101 }
3102
3103
3104 /***********************************************************************
3105  *           INTERNET_InsertWorkRequest (internal)
3106  *
3107  * Insert work request into queue
3108  *
3109  * RETURNS
3110  *
3111  */
3112 static BOOL INTERNET_InsertWorkRequest(LPWORKREQUEST lpWorkRequest)
3113 {
3114     BOOL bSuccess = FALSE;
3115     LPWORKREQUEST lpNewRequest;
3116
3117     TRACE("\n");
3118
3119     lpNewRequest = HeapAlloc(GetProcessHeap(), 0, sizeof(WORKREQUEST));
3120     if (lpNewRequest)
3121     {
3122         memcpy(lpNewRequest, lpWorkRequest, sizeof(WORKREQUEST));
3123         lpNewRequest->prev = NULL;
3124
3125         EnterCriticalSection(&csQueue);
3126
3127         lpNewRequest->next = lpWorkQueueTail;
3128         if (lpWorkQueueTail)
3129             lpWorkQueueTail->prev = lpNewRequest;
3130         lpWorkQueueTail = lpNewRequest;
3131         if (!lpHeadWorkQueue)
3132             lpHeadWorkQueue = lpWorkQueueTail;
3133
3134         LeaveCriticalSection(&csQueue);
3135
3136         bSuccess = TRUE;
3137         InterlockedIncrement(&dwNumJobs);
3138     }
3139
3140     return bSuccess;
3141 }
3142
3143
3144 /***********************************************************************
3145  *           INTERNET_GetWorkRequest (internal)
3146  *
3147  * Retrieves work request from queue
3148  *
3149  * RETURNS
3150  *
3151  */
3152 static BOOL INTERNET_GetWorkRequest(LPWORKREQUEST lpWorkRequest)
3153 {
3154     BOOL bSuccess = FALSE;
3155     LPWORKREQUEST lpRequest = NULL;
3156
3157     TRACE("\n");
3158
3159     EnterCriticalSection(&csQueue);
3160
3161     if (lpHeadWorkQueue)
3162     {
3163         lpRequest = lpHeadWorkQueue;
3164         lpHeadWorkQueue = lpHeadWorkQueue->prev;
3165         if (lpRequest == lpWorkQueueTail)
3166             lpWorkQueueTail = lpHeadWorkQueue;
3167     }
3168
3169     LeaveCriticalSection(&csQueue);
3170
3171     if (lpRequest)
3172     {
3173         memcpy(lpWorkRequest, lpRequest, sizeof(WORKREQUEST));
3174         HeapFree(GetProcessHeap(), 0, lpRequest);
3175         bSuccess = TRUE;
3176         InterlockedDecrement(&dwNumJobs);
3177     }
3178
3179     return bSuccess;
3180 }
3181
3182
3183 /***********************************************************************
3184  *           INTERNET_AsyncCall (internal)
3185  *
3186  * Retrieves work request from queue
3187  *
3188  * RETURNS
3189  *
3190  */
3191 BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
3192 {
3193     HANDLE hThread;
3194     DWORD dwTID;
3195     BOOL bSuccess = FALSE;
3196
3197     TRACE("\n");
3198
3199     if (InterlockedDecrement(&dwNumIdleThreads) < 0)
3200     {
3201         InterlockedIncrement(&dwNumIdleThreads);
3202
3203         if (InterlockedIncrement(&dwNumThreads) > MAX_WORKER_THREADS ||
3204             !(hThread = CreateThread(NULL, 0,
3205             INTERNET_WorkerThreadFunc, NULL, 0, &dwTID)))
3206         {
3207             InterlockedDecrement(&dwNumThreads);
3208             INTERNET_SetLastError(ERROR_INTERNET_ASYNC_THREAD_FAILED);
3209             goto lerror;
3210         }
3211
3212         TRACE("Created new thread\n");
3213     }
3214
3215     bSuccess = TRUE;
3216     INTERNET_InsertWorkRequest(lpWorkRequest);
3217     SetEvent(hWorkEvent);
3218
3219 lerror:
3220
3221     return bSuccess;
3222 }
3223
3224
3225 /***********************************************************************
3226  *           INTERNET_ExecuteWork (internal)
3227  *
3228  * RETURNS
3229  *
3230  */
3231 static VOID INTERNET_ExecuteWork(void)
3232 {
3233     WORKREQUEST workRequest;
3234
3235     TRACE("\n");
3236
3237     if (!INTERNET_GetWorkRequest(&workRequest))
3238         return;
3239
3240     switch (workRequest.asyncall)
3241     {
3242     case CALLASYNCPROC:
3243         workRequest.asyncproc(&workRequest);
3244         break;
3245
3246     case FTPRENAMEFILEW:
3247         {
3248         struct WORKREQ_FTPRENAMEFILEW *req = &workRequest.u.FtpRenameFileW;
3249         LPWININETFTPSESSIONW lpwfs = (LPWININETFTPSESSIONW) workRequest.hdr;
3250
3251         TRACE("FTPRENAMEFILEW %p\n", lpwfs);
3252
3253         FTP_FtpRenameFileW(lpwfs, req->lpszSrcFile, req->lpszDestFile);
3254         HeapFree(GetProcessHeap(), 0, req->lpszSrcFile);
3255         HeapFree(GetProcessHeap(), 0, req->lpszDestFile);
3256         }
3257         break;
3258
3259     case FTPFINDNEXTW:
3260         {
3261         struct WORKREQ_FTPFINDNEXTW *req;
3262         LPWININETFTPFINDNEXTW lpwh = (LPWININETFTPFINDNEXTW) workRequest.hdr;
3263
3264         TRACE("INTERNETFINDNEXTW %p\n", lpwh);
3265
3266         req = &workRequest.u.FtpFindNextW;
3267         FTP_FindNextFileW(lpwh, req->lpFindFileData);
3268         }
3269         break;
3270     }
3271     WININET_Release( workRequest.hdr );
3272 }
3273
3274
3275 /***********************************************************************
3276  *          INTERNET_GetResponseBuffer  (internal)
3277  *
3278  * RETURNS
3279  *
3280  */
3281 LPSTR INTERNET_GetResponseBuffer(void)
3282 {
3283     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
3284     if (!lpwite)
3285         lpwite = INTERNET_AllocThreadError();
3286     TRACE("\n");
3287     return lpwite->response;
3288 }
3289
3290 /***********************************************************************
3291  *           INTERNET_GetNextLine  (internal)
3292  *
3293  * Parse next line in directory string listing
3294  *
3295  * RETURNS
3296  *   Pointer to beginning of next line
3297  *   NULL on failure
3298  *
3299  */
3300
3301 LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen)
3302 {
3303     struct timeval tv;
3304     fd_set infd;
3305     BOOL bSuccess = FALSE;
3306     INT nRecv = 0;
3307     LPSTR lpszBuffer = INTERNET_GetResponseBuffer();
3308
3309     TRACE("\n");
3310
3311     FD_ZERO(&infd);
3312     FD_SET(nSocket, &infd);
3313     tv.tv_sec=RESPONSE_TIMEOUT;
3314     tv.tv_usec=0;
3315
3316     while (nRecv < MAX_REPLY_LEN)
3317     {
3318         if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0)
3319         {
3320             if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
3321             {
3322                 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
3323                 goto lend;
3324             }
3325
3326             if (lpszBuffer[nRecv] == '\n')
3327             {
3328                 bSuccess = TRUE;
3329                 break;
3330             }
3331             if (lpszBuffer[nRecv] != '\r')
3332                 nRecv++;
3333         }
3334         else
3335         {
3336             INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
3337             goto lend;
3338         }
3339     }
3340
3341 lend:
3342     if (bSuccess)
3343     {
3344         lpszBuffer[nRecv] = '\0';
3345         *dwLen = nRecv - 1;
3346         TRACE(":%d %s\n", nRecv, lpszBuffer);
3347         return lpszBuffer;
3348     }
3349     else
3350     {
3351         return NULL;
3352     }
3353 }
3354
3355 /**********************************************************
3356  *      InternetQueryDataAvailable (WININET.@)
3357  *
3358  * Determines how much data is available to be read.
3359  *
3360  * RETURNS
3361  *   If there is data available then TRUE, otherwise if there
3362  *   is not or an error occurred then FALSE. Use GetLastError() to
3363  *   check for ERROR_NO_MORE_FILES to see if it was the former.
3364  */
3365 BOOL WINAPI InternetQueryDataAvailable( HINTERNET hFile,
3366                                 LPDWORD lpdwNumberOfBytesAvailble,
3367                                 DWORD dwFlags, DWORD dwConext)
3368 {
3369     LPWININETHTTPREQW lpwhr;
3370     BOOL retval = FALSE;
3371     char buffer[4048];
3372
3373     lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hFile );
3374     if (NULL == lpwhr)
3375     {
3376         SetLastError(ERROR_NO_MORE_FILES);
3377         return FALSE;
3378     }
3379
3380     TRACE("-->  %p %i\n",lpwhr,lpwhr->hdr.htype);
3381
3382     switch (lpwhr->hdr.htype)
3383     {
3384     case WH_HHTTPREQ:
3385         if (!NETCON_recv(&lpwhr->netConnection, buffer,
3386                          4048, MSG_PEEK, (int *)lpdwNumberOfBytesAvailble))
3387         {
3388             SetLastError(ERROR_NO_MORE_FILES);
3389             retval = FALSE;
3390         }
3391         else
3392             retval = TRUE;
3393         break;
3394
3395     default:
3396         FIXME("unsupported file type\n");
3397         break;
3398     }
3399     WININET_Release( &lpwhr->hdr );
3400
3401     TRACE("<-- %i\n",retval);
3402     return retval;
3403 }
3404
3405
3406 /***********************************************************************
3407  *      InternetLockRequestFile (WININET.@)
3408  */
3409 BOOL WINAPI InternetLockRequestFile( HINTERNET hInternet, HANDLE
3410 *lphLockReqHandle)
3411 {
3412     FIXME("STUB\n");
3413     return FALSE;
3414 }
3415
3416 BOOL WINAPI InternetUnlockRequestFile( HANDLE hLockHandle)
3417 {
3418     FIXME("STUB\n");
3419     return FALSE;
3420 }
3421
3422
3423 /***********************************************************************
3424  *      InternetAutodial (WININET.@)
3425  *
3426  * On windows this function is supposed to dial the default internet
3427  * connection. We don't want to have Wine dial out to the internet so
3428  * we return TRUE by default. It might be nice to check if we are connected.
3429  *
3430  * RETURNS
3431  *   TRUE on success
3432  *   FALSE on failure
3433  *
3434  */
3435 BOOL WINAPI InternetAutodial(DWORD dwFlags, HWND hwndParent)
3436 {
3437     FIXME("STUB\n");
3438
3439     /* Tell that we are connected to the internet. */
3440     return TRUE;
3441 }
3442
3443 /***********************************************************************
3444  *      InternetAutodialHangup (WININET.@)
3445  *
3446  * Hangs up a connection made with InternetAutodial
3447  *
3448  * PARAM
3449  *    dwReserved
3450  * RETURNS
3451  *   TRUE on success
3452  *   FALSE on failure
3453  *
3454  */
3455 BOOL WINAPI InternetAutodialHangup(DWORD dwReserved)
3456 {
3457     FIXME("STUB\n");
3458
3459     /* we didn't dial, we don't disconnect */
3460     return TRUE;
3461 }
3462
3463 /***********************************************************************
3464  *      InternetCombineUrlA (WININET.@)
3465  *
3466  * Combine a base URL with a relative URL
3467  *
3468  * RETURNS
3469  *   TRUE on success
3470  *   FALSE on failure
3471  *
3472  */
3473
3474 BOOL WINAPI InternetCombineUrlA(LPCSTR lpszBaseUrl, LPCSTR lpszRelativeUrl,
3475                                 LPSTR lpszBuffer, LPDWORD lpdwBufferLength,
3476                                 DWORD dwFlags)
3477 {
3478     HRESULT hr=S_OK;
3479
3480     TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_a(lpszBaseUrl), debugstr_a(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
3481
3482     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
3483     dwFlags ^= ICU_NO_ENCODE;
3484     hr=UrlCombineA(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
3485
3486     return (hr==S_OK);
3487 }
3488
3489 /***********************************************************************
3490  *      InternetCombineUrlW (WININET.@)
3491  *
3492  * Combine a base URL with a relative URL
3493  *
3494  * RETURNS
3495  *   TRUE on success
3496  *   FALSE on failure
3497  *
3498  */
3499
3500 BOOL WINAPI InternetCombineUrlW(LPCWSTR lpszBaseUrl, LPCWSTR lpszRelativeUrl,
3501                                 LPWSTR lpszBuffer, LPDWORD lpdwBufferLength,
3502                                 DWORD dwFlags)
3503 {
3504     HRESULT hr=S_OK;
3505
3506     TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_w(lpszBaseUrl), debugstr_w(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
3507
3508     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
3509     dwFlags ^= ICU_NO_ENCODE;
3510     hr=UrlCombineW(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
3511
3512     return (hr==S_OK);
3513 }
3514
3515 /* max port num is 65535 => 5 digits */
3516 #define MAX_WORD_DIGITS 5
3517
3518 #define URL_GET_COMP_LENGTH(url, component) ((url)->dw##component##Length ? \
3519     (url)->dw##component##Length : strlenW((url)->lpsz##component))
3520 #define URL_GET_COMP_LENGTHA(url, component) ((url)->dw##component##Length ? \
3521     (url)->dw##component##Length : strlen((url)->lpsz##component))
3522
3523 static BOOL url_uses_default_port(INTERNET_SCHEME nScheme, INTERNET_PORT nPort)
3524 {
3525     if ((nScheme == INTERNET_SCHEME_HTTP) &&
3526         (nPort == INTERNET_DEFAULT_HTTP_PORT))
3527         return TRUE;
3528     if ((nScheme == INTERNET_SCHEME_HTTPS) &&
3529         (nPort == INTERNET_DEFAULT_HTTPS_PORT))
3530         return TRUE;
3531     if ((nScheme == INTERNET_SCHEME_FTP) &&
3532         (nPort == INTERNET_DEFAULT_FTP_PORT))
3533         return TRUE;
3534     if ((nScheme == INTERNET_SCHEME_GOPHER) &&
3535         (nPort == INTERNET_DEFAULT_GOPHER_PORT))
3536         return TRUE;
3537
3538     if (nPort == INTERNET_INVALID_PORT_NUMBER)
3539         return TRUE;
3540
3541     return FALSE;
3542 }
3543
3544 /* opaque urls do not fit into the standard url hierarchy and don't have
3545  * two following slashes */
3546 static inline BOOL scheme_is_opaque(INTERNET_SCHEME nScheme)
3547 {
3548     return (nScheme != INTERNET_SCHEME_FTP) &&
3549            (nScheme != INTERNET_SCHEME_GOPHER) &&
3550            (nScheme != INTERNET_SCHEME_HTTP) &&
3551            (nScheme != INTERNET_SCHEME_HTTPS) &&
3552            (nScheme != INTERNET_SCHEME_FILE);
3553 }
3554
3555 static LPCWSTR INTERNET_GetSchemeString(INTERNET_SCHEME scheme)
3556 {
3557     int index;
3558     if (scheme < INTERNET_SCHEME_FIRST)
3559         return NULL;
3560     index = scheme - INTERNET_SCHEME_FIRST;
3561     if (index >= sizeof(url_schemes)/sizeof(url_schemes[0]))
3562         return NULL;
3563     return (LPCWSTR)&url_schemes[index];
3564 }
3565
3566 /* we can calculate using ansi strings because we're just
3567  * calculating string length, not size
3568  */
3569 static BOOL calc_url_length(LPURL_COMPONENTSW lpUrlComponents,
3570                             LPDWORD lpdwUrlLength)
3571 {
3572     INTERNET_SCHEME nScheme;
3573
3574     *lpdwUrlLength = 0;
3575
3576     if (lpUrlComponents->lpszScheme)
3577     {
3578         DWORD dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
3579         *lpdwUrlLength += dwLen;
3580         nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
3581     }
3582     else
3583     {
3584         LPCWSTR scheme;
3585
3586         nScheme = lpUrlComponents->nScheme;
3587
3588         if (nScheme == INTERNET_SCHEME_DEFAULT)
3589             nScheme = INTERNET_SCHEME_HTTP;
3590         scheme = INTERNET_GetSchemeString(nScheme);
3591         *lpdwUrlLength += strlenW(scheme);
3592     }
3593
3594     (*lpdwUrlLength)++; /* ':' */
3595     if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
3596         *lpdwUrlLength += strlen("//");
3597
3598     if (lpUrlComponents->lpszUserName)
3599     {
3600         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
3601         *lpdwUrlLength += strlen("@");
3602     }
3603     else
3604     {
3605         if (lpUrlComponents->lpszPassword)
3606         {
3607             SetLastError(ERROR_INVALID_PARAMETER);
3608             return FALSE;
3609         }
3610     }
3611
3612     if (lpUrlComponents->lpszPassword)
3613     {
3614         *lpdwUrlLength += strlen(":");
3615         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, Password);
3616     }
3617
3618     if (lpUrlComponents->lpszHostName)
3619     {
3620         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
3621
3622         if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
3623         {
3624             char szPort[MAX_WORD_DIGITS+1];
3625
3626             sprintf(szPort, "%d", lpUrlComponents->nPort);
3627             *lpdwUrlLength += strlen(szPort);
3628             *lpdwUrlLength += strlen(":");
3629         }
3630
3631         if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
3632             (*lpdwUrlLength)++; /* '/' */
3633     }
3634
3635     if (lpUrlComponents->lpszUrlPath)
3636         *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
3637
3638     return TRUE;
3639 }
3640
3641 static void convert_urlcomp_atow(LPURL_COMPONENTSA lpUrlComponents, LPURL_COMPONENTSW urlCompW)
3642 {
3643     INT len;
3644
3645     ZeroMemory(urlCompW, sizeof(URL_COMPONENTSW));
3646
3647     urlCompW->dwStructSize = sizeof(URL_COMPONENTSW);
3648     urlCompW->dwSchemeLength = lpUrlComponents->dwSchemeLength;
3649     urlCompW->nScheme = lpUrlComponents->nScheme;
3650     urlCompW->dwHostNameLength = lpUrlComponents->dwHostNameLength;
3651     urlCompW->nPort = lpUrlComponents->nPort;
3652     urlCompW->dwUserNameLength = lpUrlComponents->dwUserNameLength;
3653     urlCompW->dwPasswordLength = lpUrlComponents->dwPasswordLength;
3654     urlCompW->dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
3655     urlCompW->dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
3656
3657     if (lpUrlComponents->lpszScheme)
3658     {
3659         len = URL_GET_COMP_LENGTHA(lpUrlComponents, Scheme) + 1;
3660         urlCompW->lpszScheme = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3661         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszScheme,
3662                             -1, urlCompW->lpszScheme, len);
3663     }
3664
3665     if (lpUrlComponents->lpszHostName)
3666     {
3667         len = URL_GET_COMP_LENGTHA(lpUrlComponents, HostName) + 1;
3668         urlCompW->lpszHostName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3669         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszHostName,
3670                             -1, urlCompW->lpszHostName, len);
3671     }
3672
3673     if (lpUrlComponents->lpszUserName)
3674     {
3675         len = URL_GET_COMP_LENGTHA(lpUrlComponents, UserName) + 1;
3676         urlCompW->lpszUserName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3677         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUserName,
3678                             -1, urlCompW->lpszUserName, len);
3679     }
3680
3681     if (lpUrlComponents->lpszPassword)
3682     {
3683         len = URL_GET_COMP_LENGTHA(lpUrlComponents, Password) + 1;
3684         urlCompW->lpszPassword = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3685         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszPassword,
3686                             -1, urlCompW->lpszPassword, len);
3687     }
3688
3689     if (lpUrlComponents->lpszUrlPath)
3690     {
3691         len = URL_GET_COMP_LENGTHA(lpUrlComponents, UrlPath) + 1;
3692         urlCompW->lpszUrlPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3693         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUrlPath,
3694                             -1, urlCompW->lpszUrlPath, len);
3695     }
3696
3697     if (lpUrlComponents->lpszExtraInfo)
3698     {
3699         len = URL_GET_COMP_LENGTHA(lpUrlComponents, ExtraInfo) + 1;
3700         urlCompW->lpszExtraInfo = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3701         MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszExtraInfo,
3702                             -1, urlCompW->lpszExtraInfo, len);
3703     }
3704 }
3705
3706 /***********************************************************************
3707  *      InternetCreateUrlA (WININET.@)
3708  *
3709  * See InternetCreateUrlW.
3710  */
3711 BOOL WINAPI InternetCreateUrlA(LPURL_COMPONENTSA lpUrlComponents, DWORD dwFlags,
3712                                LPSTR lpszUrl, LPDWORD lpdwUrlLength)
3713 {
3714     BOOL ret;
3715     LPWSTR urlW = NULL;
3716     URL_COMPONENTSW urlCompW;
3717
3718     TRACE("(%p,%d,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
3719
3720     if (!lpUrlComponents)
3721         return FALSE;
3722
3723     if (lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
3724     {
3725         SetLastError(ERROR_INVALID_PARAMETER);
3726         return FALSE;
3727     }
3728
3729     convert_urlcomp_atow(lpUrlComponents, &urlCompW);
3730
3731     if (lpszUrl)
3732         urlW = HeapAlloc(GetProcessHeap(), 0, *lpdwUrlLength * sizeof(WCHAR));
3733
3734     ret = InternetCreateUrlW(&urlCompW, dwFlags, urlW, lpdwUrlLength);
3735
3736     if (!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
3737         *lpdwUrlLength /= sizeof(WCHAR);
3738
3739     /* on success, lpdwUrlLength points to the size of urlW in WCHARS
3740     * minus one, so add one to leave room for NULL terminator
3741     */
3742     if (ret)
3743         WideCharToMultiByte(CP_ACP, 0, urlW, -1, lpszUrl, *lpdwUrlLength + 1, NULL, NULL);
3744
3745     HeapFree(GetProcessHeap(), 0, urlCompW.lpszScheme);
3746     HeapFree(GetProcessHeap(), 0, urlCompW.lpszHostName);
3747     HeapFree(GetProcessHeap(), 0, urlCompW.lpszUserName);
3748     HeapFree(GetProcessHeap(), 0, urlCompW.lpszPassword);
3749     HeapFree(GetProcessHeap(), 0, urlCompW.lpszUrlPath);
3750     HeapFree(GetProcessHeap(), 0, urlCompW.lpszExtraInfo);
3751     HeapFree(GetProcessHeap(), 0, urlW);
3752
3753     return ret;
3754 }
3755
3756 /***********************************************************************
3757  *      InternetCreateUrlW (WININET.@)
3758  *
3759  * Creates a URL from its component parts.
3760  *
3761  * PARAMS
3762  *  lpUrlComponents [I] URL Components.
3763  *  dwFlags         [I] Flags. See notes.
3764  *  lpszUrl         [I] Buffer in which to store the created URL.
3765  *  lpdwUrlLength   [I/O] On input, the length of the buffer pointed to by
3766  *                        lpszUrl in characters. On output, the number of bytes
3767  *                        required to store the URL including terminator.
3768  *
3769  * NOTES
3770  *
3771  * The dwFlags parameter can be zero or more of the following:
3772  *|ICU_ESCAPE - Generates escape sequences for unsafe characters in the path and extra info of the URL.
3773  *
3774  * RETURNS
3775  *   TRUE on success
3776  *   FALSE on failure
3777  *
3778  */
3779 BOOL WINAPI InternetCreateUrlW(LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags,
3780                                LPWSTR lpszUrl, LPDWORD lpdwUrlLength)
3781 {
3782     DWORD dwLen;
3783     INTERNET_SCHEME nScheme;
3784
3785     static const WCHAR slashSlashW[] = {'/','/'};
3786     static const WCHAR percentD[] = {'%','d',0};
3787
3788     TRACE("(%p,%d,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
3789
3790     if (!lpUrlComponents)
3791         return FALSE;
3792
3793     if (lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
3794     {
3795         SetLastError(ERROR_INVALID_PARAMETER);
3796         return FALSE;
3797     }
3798
3799     if (!calc_url_length(lpUrlComponents, &dwLen))
3800         return FALSE;
3801
3802     if (!lpszUrl || *lpdwUrlLength < dwLen)
3803     {
3804         *lpdwUrlLength = (dwLen + 1) * sizeof(WCHAR);
3805         SetLastError(ERROR_INSUFFICIENT_BUFFER);
3806         return FALSE;
3807     }
3808
3809     *lpdwUrlLength = dwLen;
3810     lpszUrl[0] = 0x00;
3811
3812     dwLen = 0;
3813
3814     if (lpUrlComponents->lpszScheme)
3815     {
3816         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
3817         memcpy(lpszUrl, lpUrlComponents->lpszScheme, dwLen * sizeof(WCHAR));
3818         lpszUrl += dwLen;
3819
3820         nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
3821     }
3822     else
3823     {
3824         LPCWSTR scheme;
3825         nScheme = lpUrlComponents->nScheme;
3826
3827         if (nScheme == INTERNET_SCHEME_DEFAULT)
3828             nScheme = INTERNET_SCHEME_HTTP;
3829
3830         scheme = INTERNET_GetSchemeString(nScheme);
3831         dwLen = strlenW(scheme);
3832         memcpy(lpszUrl, scheme, dwLen * sizeof(WCHAR));
3833         lpszUrl += dwLen;
3834     }
3835
3836     /* all schemes are followed by at least a colon */
3837     *lpszUrl = ':';
3838     lpszUrl++;
3839
3840     if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
3841     {
3842         memcpy(lpszUrl, slashSlashW, sizeof(slashSlashW));
3843         lpszUrl += sizeof(slashSlashW)/sizeof(slashSlashW[0]);
3844     }
3845
3846     if (lpUrlComponents->lpszUserName)
3847     {
3848         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
3849         memcpy(lpszUrl, lpUrlComponents->lpszUserName, dwLen * sizeof(WCHAR));
3850         lpszUrl += dwLen;
3851
3852         if (lpUrlComponents->lpszPassword)
3853         {
3854             *lpszUrl = ':';
3855             lpszUrl++;
3856
3857             dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Password);
3858             memcpy(lpszUrl, lpUrlComponents->lpszPassword, dwLen * sizeof(WCHAR));
3859             lpszUrl += dwLen;
3860         }
3861
3862         *lpszUrl = '@';
3863         lpszUrl++;
3864     }
3865
3866     if (lpUrlComponents->lpszHostName)
3867     {
3868         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
3869         memcpy(lpszUrl, lpUrlComponents->lpszHostName, dwLen * sizeof(WCHAR));
3870         lpszUrl += dwLen;
3871
3872         if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
3873         {
3874             WCHAR szPort[MAX_WORD_DIGITS+1];
3875
3876             sprintfW(szPort, percentD, lpUrlComponents->nPort);
3877             *lpszUrl = ':';
3878             lpszUrl++;
3879             dwLen = strlenW(szPort);
3880             memcpy(lpszUrl, szPort, dwLen * sizeof(WCHAR));
3881             lpszUrl += dwLen;
3882         }
3883
3884         /* add slash between hostname and path if necessary */
3885         if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
3886         {
3887             *lpszUrl = '/';
3888             lpszUrl++;
3889         }
3890     }
3891
3892
3893     if (lpUrlComponents->lpszUrlPath)
3894     {
3895         dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
3896         memcpy(lpszUrl, lpUrlComponents->lpszUrlPath, dwLen * sizeof(WCHAR));
3897         lpszUrl += dwLen;
3898     }
3899
3900     *lpszUrl = '\0';
3901
3902     return TRUE;
3903 }
3904
3905 /***********************************************************************
3906  *      InternetConfirmZoneCrossingA (WININET.@)
3907  *
3908  */
3909 DWORD WINAPI InternetConfirmZoneCrossingA( HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost )
3910 {
3911     FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_a(szUrlPrev), debugstr_a(szUrlNew), bPost);
3912     return ERROR_SUCCESS;
3913 }
3914
3915 /***********************************************************************
3916  *      InternetConfirmZoneCrossingW (WININET.@)
3917  *
3918  */
3919 DWORD WINAPI InternetConfirmZoneCrossingW( HWND hWnd, LPWSTR szUrlPrev, LPWSTR szUrlNew, BOOL bPost )
3920 {
3921     FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_w(szUrlPrev), debugstr_w(szUrlNew), bPost);
3922     return ERROR_SUCCESS;
3923 }
3924
3925 DWORD WINAPI InternetDialA( HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags,
3926                             LPDWORD lpdwConnection, DWORD dwReserved )
3927 {
3928     FIXME("(%p, %p, 0x%08x, %p, 0x%08x) stub\n", hwndParent, lpszConnectoid, dwFlags,
3929           lpdwConnection, dwReserved);
3930     return ERROR_SUCCESS;
3931 }
3932
3933 DWORD WINAPI InternetDialW( HWND hwndParent, LPWSTR lpszConnectoid, DWORD dwFlags,
3934                             LPDWORD lpdwConnection, DWORD dwReserved )
3935 {
3936     FIXME("(%p, %p, 0x%08x, %p, 0x%08x) stub\n", hwndParent, lpszConnectoid, dwFlags,
3937           lpdwConnection, dwReserved);
3938     return ERROR_SUCCESS;
3939 }
3940
3941 BOOL WINAPI InternetGoOnlineA( LPSTR lpszURL, HWND hwndParent, DWORD dwReserved )
3942 {
3943     FIXME("(%s, %p, 0x%08x) stub\n", debugstr_a(lpszURL), hwndParent, dwReserved);
3944     return TRUE;
3945 }
3946
3947 BOOL WINAPI InternetGoOnlineW( LPWSTR lpszURL, HWND hwndParent, DWORD dwReserved )
3948 {
3949     FIXME("(%s, %p, 0x%08x) stub\n", debugstr_w(lpszURL), hwndParent, dwReserved);
3950     return TRUE;
3951 }
3952
3953 DWORD WINAPI InternetHangUp( DWORD dwConnection, DWORD dwReserved )
3954 {
3955     FIXME("(0x%08x, 0x%08x) stub\n", dwConnection, dwReserved);
3956     return ERROR_SUCCESS;
3957 }
3958
3959 BOOL WINAPI CreateMD5SSOHash( PWSTR pszChallengeInfo, PWSTR pwszRealm, PWSTR pwszTarget,
3960                               PBYTE pbHexHash )
3961 {
3962     FIXME("(%s, %s, %s, %p) stub\n", debugstr_w(pszChallengeInfo), debugstr_w(pwszRealm),
3963           debugstr_w(pwszTarget), pbHexHash);
3964     return FALSE;
3965 }
3966
3967 BOOL WINAPI ResumeSuspendedDownload( HINTERNET hInternet, DWORD dwError )
3968 {
3969     FIXME("(%p, 0x%08x) stub\n", hInternet, dwError);
3970     return FALSE;
3971 }