dlls/wininet/internet.c

   1 /*
   2  * Wininet
   3  *
   4  * Copyright 1999 Corel Corporation
   5  * Copyright 2002 CodeWeavers Inc.
   6  *
   7  * Ulrich Czekalla
   8  * Aric Stewart
   9  *
  10  * Copyright 2002 Jaco Greeff
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #include "config.h"
  28
  29 #define MAXHOSTNAME 100 /* from http.c */
  30
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <sys/types.h>
  34 #ifdef HAVE_SYS_SOCKET_H
  35 # include <sys/socket.h>
  36 #endif
  37 #ifdef HAVE_SYS_TIME_H
  38 # include <sys/time.h>
  39 #endif
  40 #include <stdlib.h>
  41 #include <ctype.h>
  42 #ifdef HAVE_UNISTD_H
  43 # include <unistd.h>
  44 #endif
  45
  46 #include "windef.h"
  47 #include "winbase.h"
  48 #include "winreg.h"
  49 #include "wininet.h"
  50 #include "winnls.h"
  51 #include "wine/debug.h"
  52 #include "winerror.h"
  53 #define NO_SHLWAPI_STREAM
  54 #include "shlwapi.h"
  55
  56 #include "wine/exception.h"
  57 #include "msvcrt/excpt.h"
  58
  59 #include "internet.h"
  60
  61 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
  62
  63 #define MAX_IDLE_WORKER 1000*60*1
  64 #define MAX_WORKER_THREADS 10
  65 #define RESPONSE_TIMEOUT        30
  66
  67 #define GET_HWININET_FROM_LPWININETFINDNEXT(lpwh) \
  68 (LPWININETAPPINFOA)(((LPWININETFTPSESSIONA)(lpwh->hdr.lpwhparent))->hdr.lpwhparent)
  69
  70 /* filter for page-fault exceptions */
  71 static WINE_EXCEPTION_FILTER(page_fault)
  72 {
  73     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ||
  74         GetExceptionCode() == EXCEPTION_PRIV_INSTRUCTION)
  75         return EXCEPTION_EXECUTE_HANDLER;
  76     return EXCEPTION_CONTINUE_SEARCH;
  77 }
  78
  79 typedef struct
  80 {
  81     DWORD  dwError;
  82     CHAR   response[MAX_REPLY_LEN];
  83 } WITHREADERROR, *LPWITHREADERROR;
  84
  85 INTERNET_SCHEME GetInternetScheme(LPCSTR lpszScheme, INT nMaxCmp);
  86 BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData);
  87 VOID INTERNET_ExecuteWork();
  88
  89 DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES;
  90 DWORD dwNumThreads;
  91 DWORD dwNumIdleThreads;
  92 DWORD dwNumJobs;
  93 HANDLE hEventArray[2];
  94 #define hQuitEvent hEventArray[0]
  95 #define hWorkEvent hEventArray[1]
  96 CRITICAL_SECTION csQueue;
  97 LPWORKREQUEST lpHeadWorkQueue;
  98 LPWORKREQUEST lpWorkQueueTail;
  99
 100 /***********************************************************************
 101  * DllMain [Internal] Initializes the internal 'WININET.DLL'.
 102  *
 103  * PARAMS
 104  *     hinstDLL    [I] handle to the DLL's instance
 105  *     fdwReason   [I]
 106  *     lpvReserved [I] reserved, must be NULL
 107  *
 108  * RETURNS
 109  *     Success: TRUE
 110  *     Failure: FALSE
 111  */
 112
 113 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 114 {
 115     TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
 116
 117     switch (fdwReason) {
 118         case DLL_PROCESS_ATTACH:
 119
 120             g_dwTlsErrIndex = TlsAlloc();
 121
 122             if (g_dwTlsErrIndex == TLS_OUT_OF_INDEXES)
 123                 return FALSE;
 124
 125             hQuitEvent = CreateEventA(0, TRUE, FALSE, NULL);
 126             hWorkEvent = CreateEventA(0, FALSE, FALSE, NULL);
 127             InitializeCriticalSection(&csQueue);
 128
 129             dwNumThreads = 0;
 130             dwNumIdleThreads = 0;
 131             dwNumJobs = 0;
 132
 133         case DLL_THREAD_ATTACH:
 134             {
 135                 LPWITHREADERROR lpwite = HeapAlloc(GetProcessHeap(), 0, sizeof(WITHREADERROR));
 136                 if (NULL == lpwite)
 137                     return FALSE;
 138
 139                 TlsSetValue(g_dwTlsErrIndex, (LPVOID)lpwite);
 140             }
 141             break;
 142
 143         case DLL_THREAD_DETACH:
 144             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 145                         {
 146                                 LPVOID lpwite = TlsGetValue(g_dwTlsErrIndex);
 147                                 if (lpwite)
 148                    HeapFree(GetProcessHeap(), 0, lpwite);
 149                         }
 150             break;
 151
 152         case DLL_PROCESS_DETACH:
 153
 154             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 155             {
 156                 HeapFree(GetProcessHeap(), 0, TlsGetValue(g_dwTlsErrIndex));
 157                 TlsFree(g_dwTlsErrIndex);
 158             }
 159
 160             SetEvent(hQuitEvent);
 161
 162             CloseHandle(hQuitEvent);
 163             CloseHandle(hWorkEvent);
 164             DeleteCriticalSection(&csQueue);
 165             break;
 166     }
 167
 168     return TRUE;
 169 }
 170
 171
 172 /***********************************************************************
 173  *           InternetInitializeAutoProxyDll   (WININET.@)
 174  *
 175  * Setup the internal proxy
 176  *
 177  * PARAMETERS
 178  *     dwReserved
 179  *
 180  * RETURNS
 181  *     FALSE on failure
 182  *
 183  */
 184 BOOL WINAPI InternetInitializeAutoProxyDll(DWORD dwReserved)
 185 {
 186     FIXME("STUB\n");
 187     INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 188     return FALSE;
 189 }
 190
 191
 192 /***********************************************************************
 193  *           InternetOpenA   (WININET.@)
 194  *
 195  * Per-application initialization of wininet
 196  *
 197  * RETURNS
 198  *    HINTERNET on success
 199  *    NULL on failure
 200  *
 201  */
 202 HINTERNET WINAPI InternetOpenA(LPCSTR lpszAgent, DWORD dwAccessType,
 203     LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
 204 {
 205     LPWININETAPPINFOA lpwai = NULL;
 206
 207     TRACE("\n");
 208
 209     /* Clear any error information */
 210     INTERNET_SetLastError(0);
 211
 212     lpwai = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETAPPINFOA));
 213     if (NULL == lpwai)
 214         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 215     else
 216     {
 217         memset(lpwai, 0, sizeof(WININETAPPINFOA));
 218         lpwai->hdr.htype = WH_HINIT;
 219         lpwai->hdr.lpwhparent = NULL;
 220         lpwai->hdr.dwFlags = dwFlags;
 221         if (NULL != lpszAgent)
 222         {
 223             if ((lpwai->lpszAgent = HeapAlloc( GetProcessHeap(),0,strlen(lpszAgent)+1)))
 224                 strcpy( lpwai->lpszAgent, lpszAgent );
 225         }
 226         if (NULL != lpszProxy)
 227         {
 228             if ((lpwai->lpszProxy = HeapAlloc( GetProcessHeap(), 0, strlen(lpszProxy)+1 )))
 229                 strcpy( lpwai->lpszProxy, lpszProxy );
 230         }
 231         if (NULL != lpszProxyBypass)
 232         {
 233             if ((lpwai->lpszProxyBypass = HeapAlloc( GetProcessHeap(), 0, strlen(lpszProxyBypass)+1)))
 234                 strcpy( lpwai->lpszProxyBypass, lpszProxyBypass );
 235         }
 236         lpwai->dwAccessType = dwAccessType;
 237     }
 238
 239     return (HINTERNET)lpwai;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           InternetOpenW   (WININET.@)
 245  *
 246  * Per-application initialization of wininet
 247  *
 248  * RETURNS
 249  *    HINTERNET on success
 250  *    NULL on failure
 251  *
 252  */
 253 HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType,
 254     LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
 255 {
 256     HINTERNET rc = (HINTERNET)NULL;
 257     INT lenAgent = lstrlenW(lpszAgent)+1;
 258     INT lenProxy = lstrlenW(lpszProxy)+1;
 259     INT lenBypass = lstrlenW(lpszProxyBypass)+1;
 260     CHAR *szAgent = (CHAR *)malloc(lenAgent*sizeof(CHAR));
 261     CHAR *szProxy = (CHAR *)malloc(lenProxy*sizeof(CHAR));
 262     CHAR *szBypass = (CHAR *)malloc(lenBypass*sizeof(CHAR));
 263
 264     if (!szAgent || !szProxy || !szBypass)
 265     {
 266         if (szAgent)
 267             free(szAgent);
 268         if (szProxy)
 269             free(szProxy);
 270         if (szBypass)
 271             free(szBypass);
 272         return (HINTERNET)NULL;
 273     }
 274
 275     WideCharToMultiByte(CP_ACP, -1, lpszAgent, -1, szAgent, lenAgent,
 276         NULL, NULL);
 277     WideCharToMultiByte(CP_ACP, -1, lpszProxy, -1, szProxy, lenProxy,
 278         NULL, NULL);
 279     WideCharToMultiByte(CP_ACP, -1, lpszProxyBypass, -1, szBypass, lenBypass,
 280         NULL, NULL);
 281
 282     rc = InternetOpenA(szAgent, dwAccessType, szProxy, szBypass, dwFlags);
 283
 284     free(szAgent);
 285     free(szProxy);
 286     free(szBypass);
 287
 288     return rc;
 289 }
 290
 291 /***********************************************************************
 292  *           InternetGetLastResponseInfoA (WININET.@)
 293  *
 294  * Return last wininet error description on the calling thread
 295  *
 296  * RETURNS
 297  *    TRUE on success of writting to buffer
 298  *    FALSE on failure
 299  *
 300  */
 301 BOOL WINAPI InternetGetLastResponseInfoA(LPDWORD lpdwError,
 302     LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
 303 {
 304     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
 305
 306     TRACE("\n");
 307
 308     *lpdwError = lpwite->dwError;
 309     if (lpwite->dwError)
 310     {
 311         strncpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
 312         *lpdwBufferLength = strlen(lpszBuffer);
 313     }
 314     else
 315         *lpdwBufferLength = 0;
 316
 317     return TRUE;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           InternetGetConnectedState (WININET.@)
 323  *
 324  * Return connected state
 325  *
 326  * RETURNS
 327  *    TRUE if connected
 328  *    if lpdwStatus is not null, return the status (off line,
 329  *    modem, lan...) in it.
 330  *    FALSE if not connected
 331  */
 332 BOOL WINAPI InternetGetConnectedState(LPDWORD lpdwStatus, DWORD dwReserved)
 333 {
 334     if (lpdwStatus) {
 335         FIXME("always returning LAN connection.\n");
 336         *lpdwStatus = INTERNET_CONNECTION_LAN;
 337     }
 338     return TRUE;
 339 }
 340
 341
 342 /***********************************************************************
 343  *           InternetConnectA (WININET.@)
 344  *
 345  * Open a ftp, gopher or http session
 346  *
 347  * RETURNS
 348  *    HINTERNET a session handle on success
 349  *    NULL on failure
 350  *
 351  */
 352 HINTERNET WINAPI InternetConnectA(HINTERNET hInternet,
 353     LPCSTR lpszServerName, INTERNET_PORT nServerPort,
 354     LPCSTR lpszUserName, LPCSTR lpszPassword,
 355     DWORD dwService, DWORD dwFlags, DWORD dwContext)
 356 {
 357     HINTERNET rc = (HINTERNET) NULL;
 358
 359     TRACE("ServerPort %i\n",nServerPort);
 360
 361     /* Clear any error information */
 362     INTERNET_SetLastError(0);
 363
 364     switch (dwService)
 365     {
 366         case INTERNET_SERVICE_FTP:
 367             rc = FTP_Connect(hInternet, lpszServerName, nServerPort,
 368             lpszUserName, lpszPassword, dwFlags, dwContext);
 369             break;
 370
 371         case INTERNET_SERVICE_HTTP:
 372             rc = HTTP_Connect(hInternet, lpszServerName, nServerPort,
 373             lpszUserName, lpszPassword, dwFlags, dwContext);
 374             break;
 375
 376         case INTERNET_SERVICE_GOPHER:
 377         default:
 378             break;
 379     }
 380
 381     return rc;
 382 }
 383
 384
 385 /***********************************************************************
 386  *           InternetConnectW (WININET.@)
 387  *
 388  * Open a ftp, gopher or http session
 389  *
 390  * RETURNS
 391  *    HINTERNET a session handle on success
 392  *    NULL on failure
 393  *
 394  */
 395 HINTERNET WINAPI InternetConnectW(HINTERNET hInternet,
 396     LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
 397     LPCWSTR lpszUserName, LPCWSTR lpszPassword,
 398     DWORD dwService, DWORD dwFlags, DWORD dwContext)
 399 {
 400     HINTERNET rc = (HINTERNET)NULL;
 401     INT lenServer = lstrlenW(lpszServerName)+1;
 402     INT lenUser = lstrlenW(lpszUserName)+1;
 403     INT lenPass = lstrlenW(lpszPassword)+1;
 404     CHAR *szServerName = (CHAR *)malloc(lenServer*sizeof(CHAR));
 405     CHAR *szUserName = (CHAR *)malloc(lenUser*sizeof(CHAR));
 406     CHAR *szPassword = (CHAR *)malloc(lenPass*sizeof(CHAR));
 407
 408     if (!szServerName || !szUserName || !szPassword)
 409     {
 410         if (szServerName)
 411             free(szServerName);
 412         if (szUserName)
 413             free(szUserName);
 414         if (szPassword)
 415             free(szPassword);
 416         return (HINTERNET)NULL;
 417     }
 418
 419     WideCharToMultiByte(CP_ACP, -1, lpszServerName, -1, szServerName, lenServer,
 420         NULL, NULL);
 421     WideCharToMultiByte(CP_ACP, -1, lpszUserName, -1, szUserName, lenUser,
 422         NULL, NULL);
 423     WideCharToMultiByte(CP_ACP, -1, lpszPassword, -1, szPassword, lenPass,
 424         NULL, NULL);
 425
 426     rc = InternetConnectA(hInternet, szServerName, nServerPort,
 427         szUserName, szPassword, dwService, dwFlags, dwContext);
 428
 429     free(szServerName);
 430     free(szUserName);
 431     free(szPassword);
 432     return rc;
 433 }
 434
 435
 436 /***********************************************************************
 437  *           InternetFindNextFileA (WININET.@)
 438  *
 439  * Continues a file search from a previous call to FindFirstFile
 440  *
 441  * RETURNS
 442  *    TRUE on success
 443  *    FALSE on failure
 444  *
 445  */
 446 BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
 447 {
 448     LPWININETAPPINFOA hIC = NULL;
 449     LPWININETFINDNEXTA lpwh = (LPWININETFINDNEXTA) hFind;
 450
 451     TRACE("\n");
 452
 453     if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
 454     {
 455         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 456         return FALSE;
 457     }
 458
 459     hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
 460     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 461     {
 462         WORKREQUEST workRequest;
 463
 464         workRequest.asyncall = INTERNETFINDNEXTA;
 465         workRequest.HFTPSESSION = (DWORD)hFind;
 466         workRequest.LPFINDFILEDATA = (DWORD)lpvFindData;
 467
 468         return INTERNET_AsyncCall(&workRequest);
 469     }
 470     else
 471     {
 472         return INTERNET_FindNextFileA(hFind, lpvFindData);
 473     }
 474 }
 475
 476 /***********************************************************************
 477  *           INTERNET_FindNextFileA (Internal)
 478  *
 479  * Continues a file search from a previous call to FindFirstFile
 480  *
 481  * RETURNS
 482  *    TRUE on success
 483  *    FALSE on failure
 484  *
 485  */
 486 BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
 487 {
 488     BOOL bSuccess = TRUE;
 489     LPWININETAPPINFOA hIC = NULL;
 490     LPWIN32_FIND_DATAA lpFindFileData;
 491     LPWININETFINDNEXTA lpwh = (LPWININETFINDNEXTA) hFind;
 492
 493     TRACE("\n");
 494
 495     if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
 496     {
 497         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 498         return FALSE;
 499     }
 500
 501     /* Clear any error information */
 502     INTERNET_SetLastError(0);
 503
 504     if (lpwh->hdr.lpwhparent->htype != WH_HFTPSESSION)
 505     {
 506         FIXME("Only FTP find next supported\n");
 507         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 508         return FALSE;
 509     }
 510
 511     TRACE("index(%d) size(%ld)\n", lpwh->index, lpwh->size);
 512
 513     lpFindFileData = (LPWIN32_FIND_DATAA) lpvFindData;
 514     ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
 515
 516     if (lpwh->index >= lpwh->size)
 517     {
 518         INTERNET_SetLastError(ERROR_NO_MORE_FILES);
 519         bSuccess = FALSE;
 520         goto lend;
 521     }
 522
 523     FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData);
 524     lpwh->index++;
 525
 526     TRACE("\nName: %s\nSize: %ld\n", lpFindFileData->cFileName, lpFindFileData->nFileSizeLow);
 527
 528 lend:
 529
 530     hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
 531     if (hIC->lpfnStatusCB)
 532     {
 533         INTERNET_ASYNC_RESULT iar;
 534
 535         iar.dwResult = (DWORD)bSuccess;
 536         iar.dwError = iar.dwError = bSuccess ? ERROR_SUCCESS :
 537                                                INTERNET_GetLastError();
 538
 539         SendAsyncCallback(hIC, hFind, lpwh->hdr.dwContext,
 540                       INTERNET_STATUS_REQUEST_COMPLETE, &iar,
 541                        sizeof(INTERNET_ASYNC_RESULT));
 542     }
 543
 544     return bSuccess;
 545 }
 546
 547
 548 /***********************************************************************
 549  *           INTERNET_CloseHandle (internal)
 550  *
 551  * Close internet handle
 552  *
 553  * RETURNS
 554  *    Void
 555  *
 556  */
 557 VOID INTERNET_CloseHandle(LPWININETAPPINFOA lpwai)
 558 {
 559     TRACE("%p\n",lpwai);
 560
 561     SendAsyncCallback(lpwai, lpwai, lpwai->hdr.dwContext,
 562                       INTERNET_STATUS_HANDLE_CLOSING, lpwai,
 563                       sizeof(HINTERNET));
 564
 565     if (lpwai->lpszAgent)
 566         HeapFree(GetProcessHeap(), 0, lpwai->lpszAgent);
 567
 568     if (lpwai->lpszProxy)
 569         HeapFree(GetProcessHeap(), 0, lpwai->lpszProxy);
 570
 571     if (lpwai->lpszProxyBypass)
 572         HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyBypass);
 573
 574     HeapFree(GetProcessHeap(), 0, lpwai);
 575 }
 576
 577
 578 /***********************************************************************
 579  *           InternetCloseHandle (WININET.@)
 580  *
 581  * Generic close handle function
 582  *
 583  * RETURNS
 584  *    TRUE on success
 585  *    FALSE on failure
 586  *
 587  */
 588 BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
 589 {
 590     BOOL retval;
 591     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hInternet;
 592
 593     TRACE("%p\n",hInternet);
 594     if (NULL == lpwh)
 595         return FALSE;
 596
 597     __TRY {
 598         /* Clear any error information */
 599         INTERNET_SetLastError(0);
 600         retval = FALSE;
 601
 602         switch (lpwh->htype)
 603         {
 604             case WH_HINIT:
 605                 INTERNET_CloseHandle((LPWININETAPPINFOA) lpwh);
 606                 retval = TRUE;
 607                 break;
 608
 609             case WH_HHTTPSESSION:
 610                 HTTP_CloseHTTPSessionHandle((LPWININETHTTPSESSIONA) lpwh);
 611                 retval = TRUE;
 612                 break;
 613
 614             case WH_HHTTPREQ:
 615                 HTTP_CloseHTTPRequestHandle((LPWININETHTTPREQA) lpwh);
 616                 retval = TRUE;
 617                 break;
 618
 619             case WH_HFTPSESSION:
 620                 retval = FTP_CloseSessionHandle((LPWININETFTPSESSIONA) lpwh);
 621                 break;
 622
 623             case WH_HFINDNEXT:
 624                 retval = FTP_CloseFindNextHandle((LPWININETFINDNEXTA) lpwh);
 625                 break;
 626
 627             default:
 628                 break;
 629         }
 630     } __EXCEPT(page_fault) {
 631         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 632         return FALSE;
 633     }
 634     __ENDTRY
 635
 636     return retval;
 637 }
 638
 639
 640 /***********************************************************************
 641  *           SetUrlComponentValue (Internal)
 642  *
 643  * Helper function for InternetCrackUrlA
 644  *
 645  * RETURNS
 646  *    TRUE on success
 647  *    FALSE on failure
 648  *
 649  */
 650 BOOL SetUrlComponentValue(LPSTR* lppszComponent, LPDWORD dwComponentLen,
 651     LPCSTR lpszStart, INT len)
 652 {
 653     TRACE("%s (%d)\n", lpszStart, len);
 654
 655     if (*dwComponentLen != 0)
 656     {
 657         if (*lppszComponent == NULL)
 658         {
 659             *lppszComponent = (LPSTR)lpszStart;
 660             *dwComponentLen = len;
 661         }
 662         else
 663         {
 664             INT ncpylen = min((*dwComponentLen)-1, len);
 665             strncpy(*lppszComponent, lpszStart, ncpylen);
 666             (*lppszComponent)[ncpylen] = '\0';
 667             *dwComponentLen = ncpylen;
 668         }
 669     }
 670
 671     return TRUE;
 672 }
 673
 674
 675 /***********************************************************************
 676  *           InternetCrackUrlA (WININET.@)
 677  *
 678  * Break up URL into its components
 679  *
 680  * TODO: Handle dwFlags
 681  *
 682  * RETURNS
 683  *    TRUE on success
 684  *    FALSE on failure
 685  *
 686  */
 687 BOOL WINAPI InternetCrackUrlA(LPCSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags,
 688     LPURL_COMPONENTSA lpUrlComponents)
 689 {
 690   /*
 691    * RFC 1808
 692    * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
 693    *
 694    */
 695     LPSTR lpszParam    = NULL;
 696     BOOL  bIsAbsolute = FALSE;
 697     LPSTR lpszap = (char*)lpszUrl;
 698     LPSTR lpszcp = NULL;
 699
 700     TRACE("\n");
 701
 702     /* Determine if the URI is absolute. */
 703     while (*lpszap != '\0')
 704     {
 705         if (isalnum(*lpszap))
 706         {
 707             lpszap++;
 708             continue;
 709         }
 710         if ((*lpszap == ':') && (lpszap - lpszUrl >= 2))
 711         {
 712             bIsAbsolute = TRUE;
 713             lpszcp = lpszap;
 714         }
 715         else
 716         {
 717             lpszcp = (LPSTR)lpszUrl; /* Relative url */
 718         }
 719
 720         break;
 721     }
 722
 723     /* Parse <params> */
 724     lpszParam = strpbrk(lpszap, ";?");
 725     if (lpszParam != NULL)
 726     {
 727         if (!SetUrlComponentValue(&lpUrlComponents->lpszExtraInfo,
 728              &lpUrlComponents->dwExtraInfoLength, lpszParam+1, strlen(lpszParam+1)))
 729         {
 730             return FALSE;
 731         }
 732         }
 733
 734     if (bIsAbsolute) /* Parse <protocol>:[//<net_loc>] */
 735         {
 736         LPSTR lpszNetLoc;
 737
 738         /* Get scheme first. */
 739         lpUrlComponents->nScheme = GetInternetScheme(lpszUrl, lpszcp - lpszUrl);
 740         if (!SetUrlComponentValue(&lpUrlComponents->lpszScheme,
 741                     &lpUrlComponents->dwSchemeLength, lpszUrl, lpszcp - lpszUrl))
 742             return FALSE;
 743
 744         /* Eat ':' in protocol. */
 745         lpszcp++;
 746
 747         /* Skip over slashes. */
 748         if (*lpszcp == '/')
 749         {
 750             lpszcp++;
 751             if (*lpszcp == '/')
 752             {
 753                 lpszcp++;
 754                 if (*lpszcp == '/')
 755                     lpszcp++;
 756             }
 757         }
 758
 759         lpszNetLoc = strpbrk(lpszcp, "/");
 760         if (lpszParam)
 761         {
 762             if (lpszNetLoc)
 763                lpszNetLoc = min(lpszNetLoc, lpszParam);
 764         else
 765                lpszNetLoc = lpszParam;
 766         }
 767         else if (!lpszNetLoc)
 768             lpszNetLoc = lpszcp + strlen(lpszcp);
 769
 770         /* Parse net-loc */
 771         if (lpszNetLoc)
 772         {
 773             LPSTR lpszHost;
 774             LPSTR lpszPort;
 775
 776                 /* [<user>[<:password>]@]<host>[:<port>] */
 777             /* First find the user and password if they exist */
 778
 779             lpszHost = strchr(lpszcp, '@');
 780             if (lpszHost == NULL || lpszHost > lpszNetLoc)
 781                 {
 782                 /* username and password not specified. */
 783                 SetUrlComponentValue(&lpUrlComponents->lpszUserName,
 784                         &lpUrlComponents->dwUserNameLength, NULL, 0);
 785                 SetUrlComponentValue(&lpUrlComponents->lpszPassword,
 786                         &lpUrlComponents->dwPasswordLength, NULL, 0);
 787                 }
 788             else /* Parse out username and password */
 789                 {
 790                 LPSTR lpszUser = lpszcp;
 791                 LPSTR lpszPasswd = lpszHost;
 792
 793                 while (lpszcp < lpszHost)
 794                         {
 795                    if (*lpszcp == ':')
 796                        lpszPasswd = lpszcp;
 797
 798                    lpszcp++;
 799                     }
 800
 801                 SetUrlComponentValue(&lpUrlComponents->lpszUserName,
 802                         &lpUrlComponents->dwUserNameLength, lpszUser, lpszPasswd - lpszUser);
 803
 804                 if (lpszPasswd != lpszHost)
 805                     lpszPasswd++;
 806                 SetUrlComponentValue(&lpUrlComponents->lpszPassword,
 807                         &lpUrlComponents->dwPasswordLength,
 808                         lpszPasswd == lpszHost ? NULL : lpszPasswd,
 809                         lpszHost - lpszPasswd);
 810
 811                 lpszcp++; /* Advance to beginning of host */
 812                 }
 813
 814             /* Parse <host><:port> */
 815
 816             lpszHost = lpszcp;
 817             lpszPort = lpszNetLoc;
 818
 819             while (lpszcp < lpszNetLoc)
 820                     {
 821                 if (*lpszcp == ':')
 822                     lpszPort = lpszcp;
 823
 824                 lpszcp++;
 825                 }
 826
 827             SetUrlComponentValue(&lpUrlComponents->lpszHostName,
 828                &lpUrlComponents->dwHostNameLength, lpszHost, lpszPort - lpszHost);
 829
 830             if (lpszPort != lpszNetLoc)
 831                 lpUrlComponents->nPort = atoi(++lpszPort);
 832             else
 833                 lpUrlComponents->nPort = 0;
 834             }
 835         }
 836
 837     /* Here lpszcp points to:
 838      *
 839      * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
 840      *                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 841      */
 842     if (lpszcp != 0 && *lpszcp != '\0' && (!lpszParam || lpszcp < lpszParam))
 843     {
 844         INT len;
 845
 846         /* Only truncate the parameter list if it's already been saved
 847          * in lpUrlComponents->lpszExtraInfo.
 848          */
 849         if (lpszParam && lpUrlComponents->dwExtraInfoLength)
 850             len = lpszParam - lpszcp;
 851         else
 852         {
 853             /* Leave the parameter list in lpszUrlPath.  Strip off any trailing
 854              * newlines if necessary.
 855              */
 856             LPSTR lpsznewline = strchr (lpszcp, '\n');
 857             if (lpsznewline != NULL)
 858                 len = lpsznewline - lpszcp;
 859             else
 860                 len = strlen(lpszcp);
 861         }
 862
 863         if (!SetUrlComponentValue(&lpUrlComponents->lpszUrlPath,
 864          &lpUrlComponents->dwUrlPathLength, lpszcp, len))
 865          return FALSE;
 866     }
 867     else
 868     {
 869         lpUrlComponents->dwUrlPathLength = 0;
 870     }
 871
 872     TRACE("%s: host(%s) path(%s) extra(%s)\n", lpszUrl, lpUrlComponents->lpszHostName,
 873           lpUrlComponents->lpszUrlPath, lpUrlComponents->lpszExtraInfo);
 874
 875     return TRUE;
 876 }
 877
 878
 879 /***********************************************************************
 880  *           GetUrlCacheEntryInfoA (WININET.@)
 881  *
 882  */
 883 BOOL WINAPI GetUrlCacheEntryInfoA(LPCSTR lpszUrl,
 884   LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntry,
 885   LPDWORD lpCacheEntrySize)
 886 {
 887     FIXME("stub\n");
 888     return FALSE;
 889 }
 890
 891 /***********************************************************************
 892  *           CommitUrlCacheEntryA (WININET.@)
 893  *
 894  */
 895 BOOL WINAPI CommitUrlCacheEntryA(LPCSTR lpszUrl, LPCSTR lpszLocalName,
 896     FILETIME ExpireTime, FILETIME lastModified, DWORD cacheEntryType,
 897     LPBYTE lpHeaderInfo, DWORD headerSize, LPCSTR fileExtension,
 898     DWORD originalUrl)
 899 {
 900     FIXME("stub\n");
 901     return FALSE;
 902 }
 903
 904 /***********************************************************************
 905  *           InternetAttemptConnect (WININET.@)
 906  *
 907  * Attempt to make a connection to the internet
 908  *
 909  * RETURNS
 910  *    ERROR_SUCCESS on success
 911  *    Error value   on failure
 912  *
 913  */
 914 DWORD WINAPI InternetAttemptConnect(DWORD dwReserved)
 915 {
 916     FIXME("Stub\n");
 917     return ERROR_SUCCESS;
 918 }
 919
 920
 921 /***********************************************************************
 922  *           InternetCanonicalizeUrlA (WININET.@)
 923  *
 924  * Escape unsafe characters and spaces
 925  *
 926  * RETURNS
 927  *    TRUE on success
 928  *    FALSE on failure
 929  *
 930  */
 931 BOOL WINAPI InternetCanonicalizeUrlA(LPCSTR lpszUrl, LPSTR lpszBuffer,
 932         LPDWORD lpdwBufferLength, DWORD dwFlags)
 933 {
 934     HRESULT hr;
 935     TRACE("%s %p %p %08lx\n",debugstr_a(lpszUrl), lpszBuffer,
 936           lpdwBufferLength, dwFlags);
 937
 938     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
 939     dwFlags ^= ICU_NO_ENCODE;
 940
 941     dwFlags |= 0x80000000; /* Don't know what this means */
 942
 943     hr = UrlCanonicalizeA(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
 944
 945     return (hr == S_OK) ? TRUE : FALSE;
 946 }
 947
 948 /***********************************************************************
 949  *           InternetCanonicalizeUrlW (WININET.@)
 950  *
 951  * Escape unsafe characters and spaces
 952  *
 953  * RETURNS
 954  *    TRUE on success
 955  *    FALSE on failure
 956  *
 957  */
 958 BOOL WINAPI InternetCanonicalizeUrlW(LPCWSTR lpszUrl, LPWSTR lpszBuffer,
 959     LPDWORD lpdwBufferLength, DWORD dwFlags)
 960 {
 961     HRESULT hr;
 962     TRACE("%s %p %p %08lx\n", debugstr_w(lpszUrl), lpszBuffer,
 963         lpdwBufferLength, dwFlags);
 964
 965     /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
 966     dwFlags ^= ICU_NO_ENCODE;
 967
 968     dwFlags |= 0x80000000; /* Don't know what this means */
 969
 970     hr = UrlCanonicalizeW(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
 971
 972     return (hr == S_OK) ? TRUE : FALSE;
 973 }
 974
 975
 976 /***********************************************************************
 977  *           InternetSetStatusCallback (WININET.@)
 978  *
 979  * Sets up a callback function which is called as progress is made
 980  * during an operation.
 981  *
 982  * RETURNS
 983  *    Previous callback or NULL         on success
 984  *    INTERNET_INVALID_STATUS_CALLBACK  on failure
 985  *
 986  */
 987 INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallback(
 988         HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
 989 {
 990     INTERNET_STATUS_CALLBACK retVal;
 991     LPWININETAPPINFOA lpwai = (LPWININETAPPINFOA)hInternet;
 992
 993     TRACE("0x%08lx\n", (ULONG)hInternet);
 994     if (lpwai->hdr.htype != WH_HINIT)
 995         return INTERNET_INVALID_STATUS_CALLBACK;
 996
 997     retVal = lpwai->lpfnStatusCB;
 998     lpwai->lpfnStatusCB = lpfnIntCB;
 999
1000     return retVal;
1001 }
1002
1003
1004 /***********************************************************************
1005  *           InternetWriteFile (WININET.@)
1006  *
1007  * Write data to an open internet file
1008  *
1009  * RETURNS
1010  *    TRUE  on success
1011  *    FALSE on failure
1012  *
1013  */
1014 BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer ,
1015         DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
1016 {
1017     BOOL retval = FALSE;
1018     int nSocket = -1;
1019     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hFile;
1020
1021     TRACE("\n");
1022     if (NULL == lpwh)
1023         return FALSE;
1024
1025     switch (lpwh->htype)
1026     {
1027         case WH_HHTTPREQ:
1028             nSocket = ((LPWININETHTTPREQA)hFile)->nSocketFD;
1029             break;
1030
1031         case WH_HFILE:
1032             nSocket = ((LPWININETFILE)hFile)->nDataSocket;
1033             break;
1034
1035         default:
1036             break;
1037     }
1038
1039     if (nSocket != -1)
1040     {
1041         int res = send(nSocket, lpBuffer, dwNumOfBytesToWrite, 0);
1042         retval = (res >= 0);
1043         *lpdwNumOfBytesWritten = retval ? res : 0;
1044     }
1045
1046     return retval;
1047 }
1048
1049
1050 /***********************************************************************
1051  *           InternetReadFile (WININET.@)
1052  *
1053  * Read data from an open internet file
1054  *
1055  * RETURNS
1056  *    TRUE  on success
1057  *    FALSE on failure
1058  *
1059  */
1060 BOOL WINAPI InternetReadFile(HINTERNET hFile, LPVOID lpBuffer,
1061         DWORD dwNumOfBytesToRead, LPDWORD dwNumOfBytesRead)
1062 {
1063     BOOL retval = FALSE;
1064     int nSocket = -1;
1065     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hFile;
1066
1067     TRACE("\n");
1068
1069     if (NULL == lpwh)
1070         return FALSE;
1071
1072     switch (lpwh->htype)
1073     {
1074         case WH_HHTTPREQ:
1075             nSocket = ((LPWININETHTTPREQA)hFile)->nSocketFD;
1076             break;
1077
1078         case WH_HFILE:
1079             nSocket = ((LPWININETFILE)hFile)->nDataSocket;
1080             break;
1081
1082         default:
1083             break;
1084     }
1085
1086     if (nSocket != -1)
1087     {
1088         int res = recv(nSocket, lpBuffer, dwNumOfBytesToRead, 0);
1089         retval = (res >= 0);
1090         *dwNumOfBytesRead = retval ? res : 0;
1091     }
1092     return retval;
1093 }
1094
1095 /***********************************************************************
1096  *           InternetReadFileExA (WININET.@)
1097  *
1098  * Read data from an open internet file
1099  *
1100  * RETURNS
1101  *    TRUE  on success
1102  *    FALSE on failure
1103  *
1104  */
1105 BOOL WINAPI InternetReadFileExA(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffer,
1106         DWORD dwFlags, DWORD dwContext)
1107 {
1108   FIXME("stub\n");
1109   return FALSE;
1110 }
1111
1112 /***********************************************************************
1113  *           InternetReadFileExW (WININET.@)
1114  *
1115  * Read data from an open internet file
1116  *
1117  * RETURNS
1118  *    TRUE  on success
1119  *    FALSE on failure
1120  *
1121  */
1122 BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
1123         DWORD dwFlags, DWORD dwContext)
1124 {
1125   FIXME("stub\n");
1126
1127   INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1128   return FALSE;
1129 }
1130
1131 /***********************************************************************
1132  *           InternetQueryOptionA (WININET.@)
1133  *
1134  * Queries an options on the specified handle
1135  *
1136  * RETURNS
1137  *    TRUE  on success
1138  *    FALSE on failure
1139  *
1140  */
1141 BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
1142         LPVOID lpBuffer, LPDWORD lpdwBufferLength)
1143 {
1144     LPWININETHANDLEHEADER lpwhh;
1145     BOOL bSuccess = FALSE;
1146
1147     TRACE("0x%08lx\n", dwOption);
1148
1149     if (NULL == hInternet)
1150     {
1151         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1152         return FALSE;
1153     }
1154
1155     lpwhh = (LPWININETHANDLEHEADER) hInternet;
1156
1157     switch (dwOption)
1158     {
1159         case INTERNET_OPTION_HANDLE_TYPE:
1160         {
1161             ULONG type = lpwhh->htype;
1162             TRACE("INTERNET_OPTION_HANDLE_TYPE: %ld\n", type);
1163
1164             if (*lpdwBufferLength < sizeof(ULONG))
1165                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1166             else
1167             {
1168                 memcpy(lpBuffer, &type, sizeof(ULONG));
1169                     *lpdwBufferLength = sizeof(ULONG);
1170                 bSuccess = TRUE;
1171             }
1172             break;
1173         }
1174
1175         case INTERNET_OPTION_REQUEST_FLAGS:
1176         {
1177             ULONG flags = 4;
1178             TRACE("INTERNET_OPTION_REQUEST_FLAGS: %ld\n", flags);
1179             if (*lpdwBufferLength < sizeof(ULONG))
1180                 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1181             else
1182             {
1183                 memcpy(lpBuffer, &flags, sizeof(ULONG));
1184                     *lpdwBufferLength = sizeof(ULONG);
1185                 bSuccess = TRUE;
1186             }
1187             break;
1188         }
1189
1190         case INTERNET_OPTION_URL:
1191         case INTERNET_OPTION_DATAFILE_NAME:
1192         {
1193             ULONG type = lpwhh->htype;
1194             if (type == WH_HHTTPREQ)
1195             {
1196                 LPWININETHTTPREQA lpreq = hInternet;
1197                 char url[1023];
1198
1199                 sprintf(url,"http://%s%s",lpreq->lpszHostName,lpreq->lpszPath);
1200                 TRACE("INTERNET_OPTION_URL: %s\n",url);
1201                 if (*lpdwBufferLength < strlen(url)+1)
1202                     INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1203                 else
1204                 {
1205                     memcpy(lpBuffer, url, strlen(url)+1);
1206                         *lpdwBufferLength = strlen(url)+1;
1207                     bSuccess = TRUE;
1208                 }
1209             }
1210             break;
1211         }
1212        case INTERNET_OPTION_HTTP_VERSION:
1213        {
1214             /*
1215              * Presently hardcoded to 1.1
1216              */
1217             ((HTTP_VERSION_INFO*)lpBuffer)->dwMajorVersion = 1;
1218             ((HTTP_VERSION_INFO*)lpBuffer)->dwMinorVersion = 1;
1219             bSuccess = TRUE;
1220         break;
1221        }
1222
1223        default:
1224          FIXME("Stub! %ld \n",dwOption);
1225          break;
1226     }
1227
1228     return bSuccess;
1229 }
1230
1231
1232 /***********************************************************************
1233  *           InternetSetOptionW (WININET.@)
1234  *
1235  * Sets an options on the specified handle
1236  *
1237  * RETURNS
1238  *    TRUE  on success
1239  *    FALSE on failure
1240  *
1241  */
1242 BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
1243                            LPVOID lpBuffer, DWORD dwBufferLength)
1244 {
1245     LPWININETHANDLEHEADER lpwhh;
1246     BOOL bSuccess = FALSE;
1247
1248     TRACE("0x%08lx\n", dwOption);
1249
1250     if (NULL == hInternet)
1251     {
1252         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1253         return FALSE;
1254     }
1255
1256     lpwhh = (LPWININETHANDLEHEADER) hInternet;
1257
1258     switch (dwOption)
1259     {
1260     default:
1261         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1262         FIXME("STUB\n");
1263         break;
1264     }
1265
1266     return bSuccess;
1267 }
1268
1269
1270 /***********************************************************************
1271  *           InternetSetOptionA (WININET.@)
1272  *
1273  * Sets an options on the specified handle.
1274  *
1275  * RETURNS
1276  *    TRUE  on success
1277  *    FALSE on failure
1278  *
1279  */
1280 BOOL WINAPI InternetSetOptionA(HINTERNET hInternet, DWORD dwOption,
1281                            LPVOID lpBuffer, DWORD dwBufferLength)
1282 {
1283     /* FIXME!!! implement if lpBuffer is a string, dwBufferLength is
1284        in TCHARs */
1285     return InternetSetOptionW(hInternet,dwOption, lpBuffer,
1286                               dwBufferLength);
1287 }
1288
1289
1290 /***********************************************************************
1291  *           InternetGetCookieA (WININET.@)
1292  *
1293  * Retrieve cookie from the specified url
1294  *
1295  * RETURNS
1296  *    TRUE  on success
1297  *    FALSE on failure
1298  *
1299  */
1300 BOOL WINAPI InternetGetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
1301     LPSTR lpCookieData, LPDWORD lpdwSize)
1302 {
1303     FIXME("STUB\n");
1304     TRACE("(%s,%s,%p)\n", debugstr_a(lpszUrl),debugstr_a(lpszCookieName),
1305         lpCookieData);
1306     return FALSE;
1307 }
1308
1309
1310 /***********************************************************************
1311  *           InternetGetCookieW (WININET.@)
1312  *
1313  * Retrieve cookie from the specified url
1314  *
1315  * RETURNS
1316  *    TRUE  on success
1317  *    FALSE on failure
1318  *
1319  */
1320 BOOL WINAPI InternetGetCookieW(LPCSTR lpszUrl, LPCWSTR lpszCookieName,
1321     LPWSTR lpCookieData, LPDWORD lpdwSize)
1322 {
1323     FIXME("STUB\n");
1324     TRACE("(%s,%s,%p)\n", debugstr_a(lpszUrl), debugstr_w(lpszCookieName),
1325         lpCookieData);
1326     return FALSE;
1327 }
1328
1329
1330 /***********************************************************************
1331  *           InternetSetCookieA (WININET.@)
1332  *
1333  * Sets cookie for the specified url
1334  *
1335  * RETURNS
1336  *    TRUE  on success
1337  *    FALSE on failure
1338  *
1339  */
1340 BOOL WINAPI InternetSetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
1341     LPCSTR lpCookieData)
1342 {
1343     FIXME("STUB\n");
1344     TRACE("(%s,%s,%s)\n", debugstr_a(lpszUrl),
1345         debugstr_a(lpszCookieName), debugstr_a(lpCookieData));
1346     return FALSE;
1347 }
1348
1349
1350 /***********************************************************************
1351  *           InternetSetCookieW (WININET.@)
1352  *
1353  * Sets cookie for the specified url
1354  *
1355  * RETURNS
1356  *    TRUE  on success
1357  *    FALSE on failure
1358  *
1359  */
1360 BOOL WINAPI InternetSetCookieW(LPCSTR lpszUrl, LPCWSTR lpszCookieName,
1361     LPCWSTR lpCookieData)
1362 {
1363     FIXME("STUB\n");
1364     TRACE("(%s,%s,%s)\n", debugstr_a(lpszUrl),
1365         debugstr_w(lpszCookieName), debugstr_w(lpCookieData));
1366     return FALSE;
1367 }
1368
1369
1370 /***********************************************************************
1371  *           GetInternetScheme (internal)
1372  *
1373  * Get scheme of url
1374  *
1375  * RETURNS
1376  *    scheme on success
1377  *    INTERNET_SCHEME_UNKNOWN on failure
1378  *
1379  */
1380 INTERNET_SCHEME GetInternetScheme(LPCSTR lpszScheme, INT nMaxCmp)
1381 {
1382     TRACE("\n");
1383     if(lpszScheme==NULL)
1384         return INTERNET_SCHEME_UNKNOWN;
1385
1386     if (!strncasecmp("ftp", lpszScheme, nMaxCmp))
1387         return INTERNET_SCHEME_FTP;
1388     else if (!strncasecmp("gopher", lpszScheme, nMaxCmp))
1389         return INTERNET_SCHEME_GOPHER;
1390     else if (!strncasecmp("http", lpszScheme, nMaxCmp))
1391         return INTERNET_SCHEME_HTTP;
1392     else if (!strncasecmp("https", lpszScheme, nMaxCmp))
1393         return INTERNET_SCHEME_HTTPS;
1394     else if (!strncasecmp("file", lpszScheme, nMaxCmp))
1395         return INTERNET_SCHEME_FILE;
1396     else if (!strncasecmp("news", lpszScheme, nMaxCmp))
1397         return INTERNET_SCHEME_NEWS;
1398     else if (!strncasecmp("mailto", lpszScheme, nMaxCmp))
1399         return INTERNET_SCHEME_MAILTO;
1400     else
1401         return INTERNET_SCHEME_UNKNOWN;
1402 }
1403
1404 /***********************************************************************
1405  *      InternetCheckConnectionA (WININET.@)
1406  *
1407  * Pings a requested host to check internet connection
1408  *
1409  * RETURNS
1410  *   TRUE on success and FALSE on failure. If a failure then
1411  *   ERROR_NOT_CONNECTED is placesd into GetLastError
1412  *
1413  */
1414 BOOL WINAPI InternetCheckConnectionA( LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved )
1415 {
1416 /*
1417  * this is a kludge which runs the resident ping program and reads the output.
1418  *
1419  * Anyone have a better idea?
1420  */
1421
1422   BOOL   rc = FALSE;
1423   char command[1024];
1424   char host[1024];
1425   int status = -1;
1426
1427   FIXME("\n");
1428
1429   /*
1430    * Crack or set the Address
1431    */
1432   if (lpszUrl == NULL)
1433   {
1434      /*
1435       * According to the doc we are supost to use the ip for the next
1436       * server in the WnInet internal server database. I have
1437       * no idea what that is or how to get it.
1438       *
1439       * So someone needs to implement this.
1440       */
1441      FIXME("Unimplemented with URL of NULL\n");
1442      return TRUE;
1443   }
1444   else
1445   {
1446      URL_COMPONENTSA componets;
1447
1448      ZeroMemory(&componets,sizeof(URL_COMPONENTSA));
1449      componets.lpszHostName = (LPSTR)&host;
1450      componets.dwHostNameLength = 1024;
1451
1452      if (!InternetCrackUrlA(lpszUrl,0,0,&componets))
1453        goto End;
1454
1455      TRACE("host name : %s\n",componets.lpszHostName);
1456   }
1457
1458   /*
1459    * Build our ping command
1460    */
1461   strcpy(command,"ping -w 1 ");
1462   strcat(command,host);
1463   strcat(command," >/dev/null 2>/dev/null");
1464
1465   TRACE("Ping command is : %s\n",command);
1466
1467   status = system(command);
1468
1469   TRACE("Ping returned a code of %i \n",status);
1470
1471   /* Ping return code of 0 indicates success */
1472   if (status == 0)
1473      rc = TRUE;
1474
1475 End:
1476
1477   if (rc == FALSE)
1478     SetLastError(ERROR_NOT_CONNECTED);
1479
1480   return rc;
1481 }
1482
1483
1484 /***********************************************************************
1485  *      InternetCheckConnectionW (WININET.@)
1486  *
1487  * Pings a requested host to check internet connection
1488  *
1489  * RETURNS
1490  *   TRUE on success and FALSE on failure. If a failure then
1491  *   ERROR_NOT_CONNECTED is placed into GetLastError
1492  *
1493  */
1494 BOOL WINAPI InternetCheckConnectionW(LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
1495 {
1496     CHAR *szUrl;
1497     INT len;
1498     BOOL rc;
1499
1500     len = lstrlenW(lpszUrl)+1;
1501     if (!(szUrl = (CHAR *)malloc(len*sizeof(CHAR))))
1502         return FALSE;
1503     WideCharToMultiByte(CP_ACP, -1, lpszUrl, -1, szUrl, len, NULL, NULL);
1504     rc = InternetCheckConnectionA((LPCSTR)szUrl, dwFlags, dwReserved);
1505     free(szUrl);
1506
1507     return rc;
1508 }
1509
1510
1511 /**********************************************************
1512  *      InternetOpenUrlA (WININET.@)
1513  *
1514  * Opens an URL
1515  *
1516  * RETURNS
1517  *   handle of connection or NULL on failure
1518  */
1519 HINTERNET WINAPI InternetOpenUrlA(HINTERNET hInternet, LPCSTR lpszUrl,
1520     LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
1521 {
1522   URL_COMPONENTSA urlComponents;
1523   char protocol[32], hostName[MAXHOSTNAME], userName[1024];
1524   char password[1024], path[2048], extra[1024];
1525   HINTERNET client = NULL, client1 = NULL;
1526   urlComponents.dwStructSize = sizeof(URL_COMPONENTSA);
1527   urlComponents.lpszScheme = protocol;
1528   urlComponents.dwSchemeLength = 32;
1529   urlComponents.lpszHostName = hostName;
1530   urlComponents.dwHostNameLength = MAXHOSTNAME;
1531   urlComponents.lpszUserName = userName;
1532   urlComponents.dwUserNameLength = 1024;
1533   urlComponents.lpszPassword = password;
1534   urlComponents.dwPasswordLength = 1024;
1535   urlComponents.lpszUrlPath = path;
1536   urlComponents.dwUrlPathLength = 2048;
1537   urlComponents.lpszExtraInfo = extra;
1538   urlComponents.dwExtraInfoLength = 1024;
1539   if(!InternetCrackUrlA(lpszUrl, strlen(lpszUrl), 0, &urlComponents))
1540     return NULL;
1541   switch(urlComponents.nScheme) {
1542   case INTERNET_SCHEME_FTP:
1543     if(urlComponents.nPort == 0)
1544       urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT;
1545     client = InternetConnectA(hInternet, hostName, urlComponents.nPort,
1546         userName, password, INTERNET_SERVICE_FTP, dwFlags, dwContext);
1547     return FtpOpenFileA(client, path, GENERIC_READ, dwFlags, dwContext);
1548     break;
1549   case INTERNET_SCHEME_HTTP:
1550   case INTERNET_SCHEME_HTTPS:
1551   {
1552     LPCSTR accept[2] = { "*/*", NULL };
1553     char *hostreq=(char*)malloc(strlen(hostName)+9);
1554     sprintf(hostreq, "Host: %s\r\n", hostName);
1555     if(urlComponents.nPort == 0) {
1556       if(urlComponents.nScheme == INTERNET_SCHEME_HTTP)
1557         urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
1558       else
1559         urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
1560     }
1561     client = InternetConnectA(hInternet, hostName, urlComponents.nPort, userName,
1562         password, INTERNET_SERVICE_HTTP, dwFlags, dwContext);
1563     if(client == NULL)
1564       return NULL;
1565     client1 = HttpOpenRequestA(hInternet, NULL, path, NULL, NULL, accept, dwFlags, dwContext);
1566     if(client1 == NULL) {
1567       InternetCloseHandle(client);
1568       return NULL;
1569     }
1570     HttpAddRequestHeadersA(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
1571     HttpAddRequestHeadersA(client1, hostreq, -1L, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
1572     if(!HttpSendRequestA(client1, NULL, 0, NULL, 0)) {
1573       InternetCloseHandle(client1);
1574       InternetCloseHandle(client);
1575       return NULL;
1576     }
1577     return client1;
1578     break;
1579   }
1580   case INTERNET_SCHEME_GOPHER:
1581     /* gopher doesn't seem to be implemented in wine, but it's supposed
1582      * to be supported by InternetOpenUrlA. */
1583   default:
1584     return NULL;
1585   }
1586   if(client != NULL)
1587     InternetCloseHandle(client);
1588 }
1589
1590
1591 /**********************************************************
1592  *      InternetOpenUrlW (WININET.@)
1593  *
1594  * Opens an URL
1595  *
1596  * RETURNS
1597  *   handle of connection or NULL on failure
1598  */
1599 HINTERNET WINAPI InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
1600     LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext)
1601 {
1602     HINTERNET rc = (HINTERNET)NULL;
1603
1604     INT lenUrl = lstrlenW(lpszUrl)+1;
1605     INT lenHeaders = lstrlenW(lpszHeaders)+1;
1606     CHAR *szUrl = (CHAR *)malloc(lenUrl*sizeof(CHAR));
1607     CHAR *szHeaders = (CHAR *)malloc(lenHeaders*sizeof(CHAR));
1608
1609     if (!szUrl || !szHeaders)
1610     {
1611         if (szUrl)
1612             free(szUrl);
1613         if (szHeaders)
1614             free(szHeaders);
1615         return (HINTERNET)NULL;
1616     }
1617
1618     WideCharToMultiByte(CP_ACP, -1, lpszUrl, -1, szUrl, lenUrl,
1619         NULL, NULL);
1620     WideCharToMultiByte(CP_ACP, -1, lpszHeaders, -1, szHeaders, lenHeaders,
1621         NULL, NULL);
1622
1623     rc = InternetOpenUrlA(hInternet, szUrl, szHeaders,
1624         dwHeadersLength, dwFlags, dwContext);
1625
1626     free(szUrl);
1627     free(szHeaders);
1628
1629     return rc;
1630 }
1631
1632
1633 /***********************************************************************
1634  *           INTERNET_SetLastError (internal)
1635  *
1636  * Set last thread specific error
1637  *
1638  * RETURNS
1639  *
1640  */
1641 void INTERNET_SetLastError(DWORD dwError)
1642 {
1643     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1644
1645     SetLastError(dwError);
1646     lpwite->dwError = dwError;
1647 }
1648
1649
1650 /***********************************************************************
1651  *           INTERNET_GetLastError (internal)
1652  *
1653  * Get last thread specific error
1654  *
1655  * RETURNS
1656  *
1657  */
1658 DWORD INTERNET_GetLastError()
1659 {
1660     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1661     return lpwite->dwError;
1662 }
1663
1664
1665 /***********************************************************************
1666  *           INTERNET_WorkerThreadFunc (internal)
1667  *
1668  * Worker thread execution function
1669  *
1670  * RETURNS
1671  *
1672  */
1673 DWORD INTERNET_WorkerThreadFunc(LPVOID *lpvParam)
1674 {
1675     DWORD dwWaitRes;
1676
1677     while (1)
1678     {
1679         if(dwNumJobs > 0) {
1680             INTERNET_ExecuteWork();
1681             continue;
1682         }
1683         dwWaitRes = WaitForMultipleObjects(2, hEventArray, FALSE, MAX_IDLE_WORKER);
1684
1685         if (dwWaitRes == WAIT_OBJECT_0 + 1)
1686             INTERNET_ExecuteWork();
1687         else
1688             break;
1689
1690         InterlockedIncrement(&dwNumIdleThreads);
1691     }
1692
1693     InterlockedDecrement(&dwNumIdleThreads);
1694     InterlockedDecrement(&dwNumThreads);
1695     TRACE("Worker thread exiting\n");
1696     return TRUE;
1697 }
1698
1699
1700 /***********************************************************************
1701  *           INTERNET_InsertWorkRequest (internal)
1702  *
1703  * Insert work request into queue
1704  *
1705  * RETURNS
1706  *
1707  */
1708 BOOL INTERNET_InsertWorkRequest(LPWORKREQUEST lpWorkRequest)
1709 {
1710     BOOL bSuccess = FALSE;
1711     LPWORKREQUEST lpNewRequest;
1712
1713     TRACE("\n");
1714
1715     lpNewRequest = HeapAlloc(GetProcessHeap(), 0, sizeof(WORKREQUEST));
1716     if (lpNewRequest)
1717     {
1718         memcpy(lpNewRequest, lpWorkRequest, sizeof(WORKREQUEST));
1719         lpNewRequest->prev = NULL;
1720
1721         EnterCriticalSection(&csQueue);
1722
1723         lpNewRequest->next = lpWorkQueueTail;
1724         if (lpWorkQueueTail)
1725             lpWorkQueueTail->prev = lpNewRequest;
1726         lpWorkQueueTail = lpNewRequest;
1727         if (!lpHeadWorkQueue)
1728             lpHeadWorkQueue = lpWorkQueueTail;
1729
1730         LeaveCriticalSection(&csQueue);
1731
1732         bSuccess = TRUE;
1733         InterlockedIncrement(&dwNumJobs);
1734     }
1735
1736     return bSuccess;
1737 }
1738
1739
1740 /***********************************************************************
1741  *           INTERNET_GetWorkRequest (internal)
1742  *
1743  * Retrieves work request from queue
1744  *
1745  * RETURNS
1746  *
1747  */
1748 BOOL INTERNET_GetWorkRequest(LPWORKREQUEST lpWorkRequest)
1749 {
1750     BOOL bSuccess = FALSE;
1751     LPWORKREQUEST lpRequest = NULL;
1752
1753     TRACE("\n");
1754
1755     EnterCriticalSection(&csQueue);
1756
1757     if (lpHeadWorkQueue)
1758     {
1759         lpRequest = lpHeadWorkQueue;
1760         lpHeadWorkQueue = lpHeadWorkQueue->prev;
1761         if (lpRequest == lpWorkQueueTail)
1762             lpWorkQueueTail = lpHeadWorkQueue;
1763     }
1764
1765     LeaveCriticalSection(&csQueue);
1766
1767     if (lpRequest)
1768     {
1769         memcpy(lpWorkRequest, lpRequest, sizeof(WORKREQUEST));
1770         HeapFree(GetProcessHeap(), 0, lpRequest);
1771         bSuccess = TRUE;
1772         InterlockedDecrement(&dwNumJobs);
1773     }
1774
1775     return bSuccess;
1776 }
1777
1778
1779 /***********************************************************************
1780  *           INTERNET_AsyncCall (internal)
1781  *
1782  * Retrieves work request from queue
1783  *
1784  * RETURNS
1785  *
1786  */
1787 BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
1788 {
1789     HANDLE hThread;
1790     DWORD dwTID;
1791     BOOL bSuccess = FALSE;
1792
1793     TRACE("\n");
1794
1795     if (InterlockedDecrement(&dwNumIdleThreads) < 0)
1796     {
1797         InterlockedIncrement(&dwNumIdleThreads);
1798
1799         if (InterlockedIncrement(&dwNumThreads) > MAX_WORKER_THREADS ||
1800             !(hThread = CreateThread(NULL, 0,
1801             (LPTHREAD_START_ROUTINE)INTERNET_WorkerThreadFunc, NULL, 0, &dwTID)))
1802         {
1803             InterlockedDecrement(&dwNumThreads);
1804             INTERNET_SetLastError(ERROR_INTERNET_ASYNC_THREAD_FAILED);
1805             goto lerror;
1806         }
1807
1808         TRACE("Created new thread\n");
1809     }
1810
1811     bSuccess = TRUE;
1812     INTERNET_InsertWorkRequest(lpWorkRequest);
1813     SetEvent(hWorkEvent);
1814
1815 lerror:
1816
1817     return bSuccess;
1818 }
1819
1820
1821 /***********************************************************************
1822  *           INTERNET_ExecuteWork (internal)
1823  *
1824  * RETURNS
1825  *
1826  */
1827 VOID INTERNET_ExecuteWork()
1828 {
1829     WORKREQUEST workRequest;
1830
1831     TRACE("\n");
1832
1833     if (INTERNET_GetWorkRequest(&workRequest))
1834     {
1835         TRACE("Got work %d\n", workRequest.asyncall);
1836         switch (workRequest.asyncall)
1837         {
1838             case FTPPUTFILEA:
1839                 FTP_FtpPutFileA((HINTERNET)workRequest.HFTPSESSION, (LPCSTR)workRequest.LPSZLOCALFILE,
1840                     (LPCSTR)workRequest.LPSZNEWREMOTEFILE, workRequest.DWFLAGS, workRequest.DWCONTEXT);
1841                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZLOCALFILE);
1842                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZNEWREMOTEFILE);
1843                 break;
1844
1845             case FTPSETCURRENTDIRECTORYA:
1846                 FTP_FtpSetCurrentDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1847                         (LPCSTR)workRequest.LPSZDIRECTORY);
1848                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1849                 break;
1850
1851             case FTPCREATEDIRECTORYA:
1852                 FTP_FtpCreateDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1853                         (LPCSTR)workRequest.LPSZDIRECTORY);
1854                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1855                 break;
1856
1857             case FTPFINDFIRSTFILEA:
1858                 FTP_FtpFindFirstFileA((HINTERNET)workRequest.HFTPSESSION,
1859                         (LPCSTR)workRequest.LPSZSEARCHFILE,
1860                    (LPWIN32_FIND_DATAA)workRequest.LPFINDFILEDATA, workRequest.DWFLAGS,
1861                    workRequest.DWCONTEXT);
1862                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZSEARCHFILE);
1863                 break;
1864
1865             case FTPGETCURRENTDIRECTORYA:
1866                 FTP_FtpGetCurrentDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1867                         (LPSTR)workRequest.LPSZDIRECTORY, (LPDWORD)workRequest.LPDWDIRECTORY);
1868                 break;
1869
1870             case FTPOPENFILEA:
1871                  FTP_FtpOpenFileA((HINTERNET)workRequest.HFTPSESSION,
1872                     (LPCSTR)workRequest.LPSZFILENAME,
1873                     workRequest.FDWACCESS,
1874                     workRequest.DWFLAGS,
1875                     workRequest.DWCONTEXT);
1876                  HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZFILENAME);
1877                  break;
1878
1879             case FTPGETFILEA:
1880                 FTP_FtpGetFileA((HINTERNET)workRequest.HFTPSESSION,
1881                     (LPCSTR)workRequest.LPSZREMOTEFILE,
1882                     (LPCSTR)workRequest.LPSZNEWFILE,
1883                     (BOOL)workRequest.FFAILIFEXISTS,
1884                     workRequest.DWLOCALFLAGSATTRIBUTE,
1885                     workRequest.DWFLAGS,
1886                     workRequest.DWCONTEXT);
1887                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZREMOTEFILE);
1888                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZNEWFILE);
1889                 break;
1890
1891             case FTPDELETEFILEA:
1892                 FTP_FtpDeleteFileA((HINTERNET)workRequest.HFTPSESSION,
1893                         (LPCSTR)workRequest.LPSZFILENAME);
1894                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZFILENAME);
1895                 break;
1896
1897             case FTPREMOVEDIRECTORYA:
1898                 FTP_FtpRemoveDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1899                         (LPCSTR)workRequest.LPSZDIRECTORY);
1900                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1901                 break;
1902
1903             case FTPRENAMEFILEA:
1904                 FTP_FtpRenameFileA((HINTERNET)workRequest.HFTPSESSION,
1905                         (LPCSTR)workRequest.LPSZSRCFILE,
1906                         (LPCSTR)workRequest.LPSZDESTFILE);
1907                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZSRCFILE);
1908                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDESTFILE);
1909                 break;
1910
1911             case INTERNETFINDNEXTA:
1912                 INTERNET_FindNextFileA((HINTERNET)workRequest.HFTPSESSION,
1913                     (LPWIN32_FIND_DATAA)workRequest.LPFINDFILEDATA);
1914                 break;
1915
1916             case HTTPSENDREQUESTA:
1917                HTTP_HttpSendRequestA((HINTERNET)workRequest.HFTPSESSION,
1918                        (LPCSTR)workRequest.LPSZHEADER,
1919                        workRequest.DWHEADERLENGTH,
1920                        (LPVOID)workRequest.LPOPTIONAL,
1921                        workRequest.DWOPTIONALLENGTH);
1922                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZHEADER);
1923                break;
1924
1925             case HTTPOPENREQUESTA:
1926                HTTP_HttpOpenRequestA((HINTERNET)workRequest.HFTPSESSION,
1927                        (LPCSTR)workRequest.LPSZVERB,
1928                        (LPCSTR)workRequest.LPSZOBJECTNAME,
1929                        (LPCSTR)workRequest.LPSZVERSION,
1930                        (LPCSTR)workRequest.LPSZREFERRER,
1931                        (LPCSTR*)workRequest.LPSZACCEPTTYPES,
1932                        workRequest.DWFLAGS,
1933                        workRequest.DWCONTEXT);
1934                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZVERB);
1935                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZOBJECTNAME);
1936                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZVERSION);
1937                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZREFERRER);
1938                 break;
1939
1940             case SENDCALLBACK:
1941                SendAsyncCallbackInt((LPWININETAPPINFOA)workRequest.param1,
1942                        (HINTERNET)workRequest.param2, workRequest.param3,
1943                         workRequest.param4, (LPVOID)workRequest.param5,
1944                         workRequest.param6);
1945                break;
1946         }
1947     }
1948 }
1949
1950
1951 /***********************************************************************
1952  *          INTERNET_GetResponseBuffer
1953  *
1954  * RETURNS
1955  *
1956  */
1957 LPSTR INTERNET_GetResponseBuffer()
1958 {
1959     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1960     TRACE("\n");
1961     return lpwite->response;
1962 }
1963
1964
1965 /***********************************************************************
1966  *           INTERNET_GetNextLine  (internal)
1967  *
1968  * Parse next line in directory string listing
1969  *
1970  * RETURNS
1971  *   Pointer to beginning of next line
1972  *   NULL on failure
1973  *
1974  */
1975
1976 LPSTR INTERNET_GetNextLine(INT nSocket, LPSTR lpszBuffer, LPDWORD dwBuffer)
1977 {
1978     struct timeval tv;
1979     fd_set infd;
1980     BOOL bSuccess = FALSE;
1981     INT nRecv = 0;
1982
1983     TRACE("\n");
1984
1985     FD_ZERO(&infd);
1986     FD_SET(nSocket, &infd);
1987     tv.tv_sec=RESPONSE_TIMEOUT;
1988     tv.tv_usec=0;
1989
1990     while (nRecv < *dwBuffer)
1991     {
1992         if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0)
1993         {
1994             if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
1995             {
1996                 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1997                 goto lend;
1998             }
1999
2000             if (lpszBuffer[nRecv] == '\n')
2001             {
2002                 bSuccess = TRUE;
2003                 break;
2004             }
2005             if (lpszBuffer[nRecv] != '\r')
2006                 nRecv++;
2007         }
2008         else
2009         {
2010             INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
2011             goto lend;
2012         }
2013     }
2014
2015 lend:
2016     if (bSuccess)
2017     {
2018         lpszBuffer[nRecv] = '\0';
2019         *dwBuffer = nRecv - 1;
2020         TRACE(":%d %s\n", nRecv, lpszBuffer);
2021         return lpszBuffer;
2022     }
2023     else
2024     {
2025         return NULL;
2026     }
2027 }
2028
2029 /***********************************************************************
2030  *
2031  */
2032 BOOL WINAPI InternetQueryDataAvailable( HINTERNET hFile,
2033                                 LPDWORD lpdwNumberOfBytesAvailble,
2034                                 DWORD dwFlags, DWORD dwConext)
2035 {
2036     LPWININETHTTPREQA lpwhr = (LPWININETHTTPREQA) hFile;
2037     INT retval = -1;
2038     int nSocket = -1;
2039
2040
2041     if (NULL == lpwhr)
2042     {
2043         SetLastError(ERROR_NO_MORE_FILES);
2044         return FALSE;
2045     }
2046
2047     TRACE("-->  %p %i %i\n",lpwhr,lpwhr->hdr.htype,lpwhr->nSocketFD);
2048
2049     switch (lpwhr->hdr.htype)
2050     {
2051         case WH_HHTTPREQ:
2052             nSocket = lpwhr->nSocketFD;
2053             break;
2054
2055         default:
2056             break;
2057     }
2058
2059     if (nSocket != -1)
2060     {
2061         char buffer[4048];
2062
2063         retval = recv(nSocket,buffer,4048,MSG_PEEK);
2064     }
2065     else
2066     {
2067         SetLastError(ERROR_NO_MORE_FILES);
2068     }
2069
2070     if (lpdwNumberOfBytesAvailble)
2071     {
2072         (*lpdwNumberOfBytesAvailble) = retval;
2073     }
2074
2075     TRACE("<-- %i\n",retval);
2076     return (retval+1);
2077 }
2078
2079
2080 /***********************************************************************
2081  *
2082  */
2083 BOOL WINAPI InternetLockRequestFile( HINTERNET hInternet, HANDLE
2084 *lphLockReqHandle)
2085 {
2086     FIXME("STUB\n");
2087     return FALSE;
2088 }
2089
2090 BOOL WINAPI InternetUnlockRequestFile( HANDLE hLockHandle)
2091 {
2092     FIXME("STUB\n");
2093     return FALSE;
2094 }
2095
2096
2097 /***********************************************************************
2098  *           InternetAutoDial
2099  *
2100  * On windows this function is supposed to dial the default internet
2101  * connection. We don't want to have Wine dial out to the internet so
2102  * we return TRUE by default. It might be nice to check if we are connected.
2103  *
2104  * RETURNS
2105  *   TRUE on success
2106  *   FALSE on failure
2107  *
2108  */
2109 BOOL WINAPI InternetAutoDial(DWORD dwFlags, HWND hwndParent)
2110 {
2111     FIXME("STUB\n");
2112
2113     /* Tell that we are connected to the internet. */
2114     return TRUE;
2115 }
2116
2117 /***********************************************************************
2118  *           InternetAutoDialHangup
2119  *
2120  * Hangs up an connection made with InternetAutoDial
2121  *
2122  * PARAM
2123  *    dwReserved
2124  * RETURNS
2125  *   TRUE on success
2126  *   FALSE on failure
2127  *
2128  */
2129 BOOL WINAPI InternetAutodialHangup(DWORD dwReserved)
2130 {
2131     FIXME("STUB\n");
2132
2133     /* we didn't dial, we don't disconnect */
2134     return TRUE;
2135 }