dlls/wininet/internet.c

   1 /*
   2  * Wininet
   3  *
   4  * Copyright 1999 Corel Corporation
   5  *
   6  * Ulrich Czekalla
   7  *
   8  */
   9
  10 #include "config.h"
  11
  12 #include <string.h>
  13 #include <sys/types.h>
  14 #ifdef HAVE_SYS_SOCKET_H
  15 # include <sys/socket.h>
  16 #endif
  17 #include <stdlib.h>
  18 #include <ctype.h>
  19
  20 #include "windows.h"
  21 #include "wininet.h"
  22 #include "debugtools.h"
  23 #include "winerror.h"
  24 #include "winsock.h"
  25 #include "heap.h"
  26
  27 #include "internet.h"
  28
  29 DEFAULT_DEBUG_CHANNEL(wininet);
  30
  31 #define MAX_IDLE_WORKER 1000*60*1
  32 #define MAX_WORKER_THREADS 10
  33 #define RESPONSE_TIMEOUT        30
  34
  35 #define GET_HWININET_FROM_LPWININETFINDNEXT(lpwh) \
  36 (LPWININETAPPINFOA)(((LPWININETFTPSESSIONA)(lpwh->hdr.lpwhparent))->hdr.lpwhparent)
  37
  38 typedef struct
  39 {
  40     DWORD  dwError;
  41     CHAR   response[MAX_REPLY_LEN];
  42 } WITHREADERROR, *LPWITHREADERROR;
  43
  44 INTERNET_SCHEME GetInternetScheme(LPCSTR lpszScheme, INT nMaxCmp);
  45 BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData);
  46 VOID INTERNET_ExecuteWork();
  47
  48 DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES;
  49 DWORD dwNumThreads;
  50 DWORD dwNumIdleThreads;
  51 HANDLE hEventArray[2];
  52 #define hQuitEvent hEventArray[0]
  53 #define hWorkEvent hEventArray[1]
  54 CRITICAL_SECTION csQueue;
  55 LPWORKREQUEST lpHeadWorkQueue;
  56 LPWORKREQUEST lpWorkQueueTail;
  57
  58 /***********************************************************************
  59  * WININET_LibMain [Internal] Initializes the internal 'WININET.DLL'.
  60  *
  61  * PARAMS
  62  *     hinstDLL    [I] handle to the DLL's instance
  63  *     fdwReason   [I]
  64  *     lpvReserved [I] reserved, must be NULL
  65  *
  66  * RETURNS
  67  *     Success: TRUE
  68  *     Failure: FALSE
  69  */
  70
  71 BOOL WINAPI
  72 WININET_LibMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  73 {
  74     TRACE("%x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
  75
  76     switch (fdwReason) {
  77         case DLL_PROCESS_ATTACH:
  78
  79             g_dwTlsErrIndex = TlsAlloc();
  80
  81             if (g_dwTlsErrIndex == TLS_OUT_OF_INDEXES)
  82                 return FALSE;
  83
  84             hQuitEvent = CreateEventA(0, TRUE, FALSE, NULL);
  85             hWorkEvent = CreateEventA(0, FALSE, FALSE, NULL);
  86             InitializeCriticalSection(&csQueue);
  87
  88             dwNumThreads = 0;
  89             dwNumIdleThreads = 0;
  90
  91         case DLL_THREAD_ATTACH:
  92             {
  93                 LPWITHREADERROR lpwite = HeapAlloc(GetProcessHeap(), 0, sizeof(WITHREADERROR));
  94                 if (NULL == lpwite)
  95                     return FALSE;
  96
  97                 TlsSetValue(g_dwTlsErrIndex, (LPVOID)lpwite);
  98             }
  99             break;
 100
 101         case DLL_THREAD_DETACH:
 102             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 103                         {
 104                                 LPVOID lpwite = TlsGetValue(g_dwTlsErrIndex);
 105                                 if (lpwite)
 106                    HeapFree(GetProcessHeap(), 0, lpwite);
 107                         }
 108             break;
 109
 110         case DLL_PROCESS_DETACH:
 111
 112             if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
 113             {
 114                 HeapFree(GetProcessHeap(), 0, TlsGetValue(g_dwTlsErrIndex));
 115                 TlsFree(g_dwTlsErrIndex);
 116             }
 117
 118             SetEvent(hQuitEvent);
 119
 120             CloseHandle(hQuitEvent);
 121             CloseHandle(hWorkEvent);
 122             DeleteCriticalSection(&csQueue);
 123             break;
 124     }
 125
 126     return TRUE;
 127 }
 128
 129
 130 /***********************************************************************
 131  *           InternetOpenA   (WININET.113)
 132  *
 133  * Per-application initialization of wininet
 134  *
 135  * RETURNS
 136  *    HINTERNET on success
 137  *    NULL on failure
 138  *
 139  */
 140 INTERNETAPI HINTERNET WINAPI InternetOpenA(LPCSTR lpszAgent,
 141         DWORD dwAccessType, LPCSTR lpszProxy,
 142         LPCSTR lpszProxyBypass, DWORD dwFlags)
 143 {
 144     LPWININETAPPINFOA lpwai = NULL;
 145
 146     TRACE("\n");
 147
 148     /* Clear any error information */
 149     INTERNET_SetLastError(0);
 150
 151     lpwai = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETAPPINFOA));
 152     if (NULL == lpwai)
 153         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 154     else
 155     {
 156         memset(lpwai, 0, sizeof(WININETAPPINFOA));
 157         lpwai->hdr.htype = WH_HINIT;
 158         lpwai->hdr.lpwhparent = NULL;
 159         lpwai->hdr.dwFlags = dwFlags;
 160         if (NULL != lpszAgent)
 161             lpwai->lpszAgent = HEAP_strdupA(GetProcessHeap(),0,lpszAgent);
 162         if (NULL != lpszProxy)
 163             lpwai->lpszProxy = HEAP_strdupA(GetProcessHeap(),0,lpszProxy);
 164         if (NULL != lpszProxyBypass)
 165             lpwai->lpszProxyBypass = HEAP_strdupA(GetProcessHeap(),0,lpszProxyBypass);
 166         lpwai->dwAccessType = dwAccessType;
 167     }
 168
 169     return (HINTERNET)lpwai;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           InternetGetLastResponseInfoA (WININET.108)
 175  *
 176  * Return last wininet error description on the calling thread
 177  *
 178  * RETURNS
 179  *    TRUE on success of writting to buffer
 180  *    FALSE on failure
 181  *
 182  */
 183 BOOL WINAPI InternetGetLastResponseInfoA(LPDWORD lpdwError,
 184     LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
 185 {
 186     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
 187
 188     TRACE("\n");
 189
 190     *lpdwError = lpwite->dwError;
 191     if (lpwite->dwError)
 192     {
 193         strncpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
 194         *lpdwBufferLength = strlen(lpszBuffer);
 195     }
 196     else
 197         *lpdwBufferLength = 0;
 198
 199     return TRUE;
 200 }
 201
 202
 203 /***********************************************************************
 204  *           InternetGetConnectedState (WININET.103)
 205  *
 206  * Return connected state
 207  *
 208  * RETURNS
 209  *    TRUE if connected
 210  *    if lpdwStatus is not null, return the status (off line,
 211  *    modem, lan...) in it.
 212  *    FALSE if not connected
 213  */
 214 BOOL WINAPI InternetGetConnectedState(LPDWORD lpdwStatus, DWORD dwReserved)
 215 {
 216     FIXME("Stub\n");
 217     return FALSE;
 218 }
 219
 220
 221 /***********************************************************************
 222  *           InternetConnectA (WININET.93)
 223  *
 224  * Open a ftp, gopher or http session
 225  *
 226  * RETURNS
 227  *    HINTERNET a session handle on success
 228  *    NULL on failure
 229  *
 230  */
 231 INTERNETAPI HINTERNET WINAPI InternetConnectA(HINTERNET hInternet,
 232     LPCSTR lpszServerName, INTERNET_PORT nServerPort,
 233     LPCSTR lpszUserName, LPCSTR lpszPassword,
 234     DWORD dwService, DWORD dwFlags, DWORD dwContext)
 235 {
 236     HINTERNET rc = (HINTERNET) NULL;
 237
 238     TRACE("\n");
 239
 240     /* Clear any error information */
 241     INTERNET_SetLastError(0);
 242
 243     switch (dwService)
 244     {
 245         case INTERNET_SERVICE_FTP:
 246             rc = FTP_Connect(hInternet, lpszServerName, nServerPort,
 247             lpszUserName, lpszPassword, dwFlags, dwContext);
 248             break;
 249
 250         case INTERNET_SERVICE_HTTP:
 251             rc = HTTP_Connect(hInternet, lpszServerName, nServerPort,
 252             lpszUserName, lpszPassword, dwFlags, dwContext);
 253             break;
 254
 255         case INTERNET_SERVICE_GOPHER:
 256         default:
 257             break;
 258     }
 259
 260     return rc;
 261 }
 262
 263 /***********************************************************************
 264  *           InternetFindNextFileA (WININET.102)
 265  *
 266  * Continues a file search from a previous call to FindFirstFile
 267  *
 268  * RETURNS
 269  *    TRUE on success
 270  *    FALSE on failure
 271  *
 272  */
 273 BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
 274 {
 275     LPWININETAPPINFOA hIC = NULL;
 276     LPWININETFINDNEXTA lpwh = (LPWININETFINDNEXTA) hFind;
 277
 278     TRACE("\n");
 279
 280     if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
 281     {
 282         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 283         return FALSE;
 284     }
 285
 286     hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
 287     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 288     {
 289         WORKREQUEST workRequest;
 290
 291         workRequest.asyncall = INTERNETFINDNEXTA;
 292         workRequest.HFTPSESSION = (DWORD)hFind;
 293         workRequest.LPFINDFILEDATA = (DWORD)lpvFindData;
 294
 295         return INTERNET_AsyncCall(&workRequest);
 296     }
 297     else
 298     {
 299         return INTERNET_FindNextFileA(hFind, lpvFindData);
 300     }
 301 }
 302
 303 /***********************************************************************
 304  *           INTERNET_FindNextFileA (Internal)
 305  *
 306  * Continues a file search from a previous call to FindFirstFile
 307  *
 308  * RETURNS
 309  *    TRUE on success
 310  *    FALSE on failure
 311  *
 312  */
 313 BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
 314 {
 315     BOOL bSuccess = TRUE;
 316     LPWININETAPPINFOA hIC = NULL;
 317     LPWIN32_FIND_DATAA lpFindFileData;
 318     LPWININETFINDNEXTA lpwh = (LPWININETFINDNEXTA) hFind;
 319
 320     TRACE("\n");
 321
 322     if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
 323     {
 324         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 325         return FALSE;
 326     }
 327
 328     /* Clear any error information */
 329     INTERNET_SetLastError(0);
 330
 331     if (lpwh->hdr.lpwhparent->htype != WH_HFTPSESSION)
 332     {
 333         FIXME("Only FTP find next supported\n");
 334         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 335         return FALSE;
 336     }
 337
 338     TRACE("index(%d) size(%ld)\n", lpwh->index, lpwh->size);
 339
 340     lpFindFileData = (LPWIN32_FIND_DATAA) lpvFindData;
 341     ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
 342
 343     if (lpwh->index >= lpwh->size)
 344     {
 345         INTERNET_SetLastError(ERROR_NO_MORE_FILES);
 346         bSuccess = FALSE;
 347         goto lend;
 348     }
 349
 350     FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData);
 351     lpwh->index++;
 352
 353     TRACE("\nName: %s\nSize: %ld\n", lpFindFileData->cFileName, lpFindFileData->nFileSizeLow);
 354
 355 lend:
 356
 357     hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
 358     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 359     {
 360         INTERNET_ASYNC_RESULT iar;
 361
 362         iar.dwResult = (DWORD)bSuccess;
 363         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 364
 365         hIC->lpfnStatusCB(hFind, lpwh->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 366         &iar, sizeof(INTERNET_ASYNC_RESULT));
 367     }
 368
 369     return bSuccess;
 370 }
 371
 372
 373 /***********************************************************************
 374  *           INTERNET_CloseHandle (internal)
 375  *
 376  * Close internet handle
 377  *
 378  * RETURNS
 379  *    Void
 380  *
 381  */
 382 VOID INTERNET_CloseHandle(LPWININETAPPINFOA lpwai)
 383 {
 384     if (lpwai->lpszAgent)
 385         HeapFree(GetProcessHeap(), 0, lpwai->lpszAgent);
 386
 387     if (lpwai->lpszProxy)
 388         HeapFree(GetProcessHeap(), 0, lpwai->lpszProxy);
 389
 390     if (lpwai->lpszProxyBypass)
 391         HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyBypass);
 392
 393     HeapFree(GetProcessHeap(), 0, lpwai);
 394 }
 395
 396
 397 /***********************************************************************
 398  *           InternetCloseHandle (WININET.89)
 399  *
 400  * Generic close handle function
 401  *
 402  * RETURNS
 403  *    TRUE on success
 404  *    FALSE on failure
 405  *
 406  */
 407 BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
 408 {
 409     BOOL retval = FALSE;
 410     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hInternet;
 411
 412     TRACE("\n");
 413     if (NULL == lpwh)
 414         return FALSE;
 415
 416     /* Clear any error information */
 417     INTERNET_SetLastError(0);
 418
 419     switch (lpwh->htype)
 420     {
 421         case WH_HINIT:
 422             INTERNET_CloseHandle((LPWININETAPPINFOA) lpwh);
 423             break;
 424
 425         case WH_HHTTPSESSION:
 426             HTTP_CloseHTTPSessionHandle((LPWININETHTTPSESSIONA) lpwh);
 427             break;
 428
 429         case WH_HHTTPREQ:
 430             HTTP_CloseHTTPRequestHandle((LPWININETHTTPREQA) lpwh);
 431             break;
 432
 433         case WH_HFTPSESSION:
 434             retval = FTP_CloseSessionHandle((LPWININETFTPSESSIONA) lpwh);
 435             break;
 436
 437         case WH_HFINDNEXT:
 438             retval = FTP_CloseFindNextHandle((LPWININETFINDNEXTA) lpwh);
 439             break;
 440
 441         default:
 442             break;
 443     }
 444
 445     return retval;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           SetUrlComponentValue (Internal)
 451  *
 452  * Helper function for InternetCrackUrlA
 453  *
 454  * RETURNS
 455  *    TRUE on success
 456  *    FALSE on failure
 457  *
 458  */
 459 BOOL SetUrlComponentValue(LPSTR* lppszComponent, LPDWORD dwComponentLen, LPCSTR lpszStart, INT len)
 460 {
 461     TRACE("%s (%d)\n", lpszStart, len);
 462
 463     if (*dwComponentLen != 0)
 464     {
 465         if (*lppszComponent == NULL)
 466         {
 467             *lppszComponent = (LPSTR)lpszStart;
 468             *dwComponentLen = len;
 469         }
 470         else
 471         {
 472             INT ncpylen = min((*dwComponentLen)-1, len);
 473             strncpy(*lppszComponent, lpszStart, ncpylen);
 474             (*lppszComponent)[ncpylen] = '\0';
 475             *dwComponentLen = ncpylen;
 476         }
 477     }
 478
 479     return TRUE;
 480 }
 481
 482
 483 /***********************************************************************
 484  *           InternetCrackUrlA (WININET.95)
 485  *
 486  * Break up URL into its components
 487  *
 488  * TODO: Hadnle dwFlags
 489  *
 490  * RETURNS
 491  *    TRUE on success
 492  *    FALSE on failure
 493  *
 494  */
 495 BOOL WINAPI InternetCrackUrlA(LPCSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags,
 496                 LPURL_COMPONENTSA lpUrlComponents)
 497 {
 498   /*
 499    * RFC 1808
 500    * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
 501    *
 502    */
 503     LPSTR lpszParam    = NULL;
 504     BOOL  bIsAbsolute = FALSE;
 505     LPSTR lpszap = (char*)lpszUrl;
 506     LPSTR lpszcp = NULL;
 507
 508     TRACE("\n");
 509
 510     /* Determine if the URI is absolute. */
 511     while (*lpszap != '\0')
 512     {
 513         if (isalnum(*lpszap))
 514         {
 515             lpszap++;
 516             continue;
 517         }
 518         if ((*lpszap == ':') && (lpszap - lpszUrl >= 2))
 519         {
 520             bIsAbsolute = TRUE;
 521             lpszcp = lpszap;
 522         }
 523         else
 524         {
 525             lpszcp = (LPSTR)lpszUrl; /* Relative url */
 526         }
 527
 528         break;
 529     }
 530
 531     /* Parse <params> */
 532     lpszParam = strpbrk(lpszap, ";?");
 533     if (lpszParam != NULL)
 534     {
 535         if (!SetUrlComponentValue(&lpUrlComponents->lpszExtraInfo,
 536              &lpUrlComponents->dwExtraInfoLength, lpszParam+1, strlen(lpszParam+1)))
 537         {
 538             return FALSE;
 539         }
 540         }
 541
 542     if (bIsAbsolute) /* Parse <protocol>:[//<net_loc>] */
 543         {
 544         LPSTR lpszNetLoc;
 545
 546         /* Get scheme first. */
 547         lpUrlComponents->nScheme = GetInternetScheme(lpszUrl, lpszcp - lpszUrl);
 548         if (!SetUrlComponentValue(&lpUrlComponents->lpszScheme,
 549                     &lpUrlComponents->dwSchemeLength, lpszUrl, lpszcp - lpszUrl))
 550             return FALSE;
 551
 552         /* Eat ':' in protocol. */
 553         lpszcp++;
 554
 555         /* Skip over slashes. */
 556         if (*lpszcp == '/')
 557         {
 558             lpszcp++;
 559             if (*lpszcp == '/')
 560             {
 561                 lpszcp++;
 562                 if (*lpszcp == '/')
 563                     lpszcp++;
 564             }
 565         }
 566
 567         lpszNetLoc = strpbrk(lpszcp, "/");
 568         if (lpszParam)
 569         {
 570             if (lpszNetLoc)
 571                lpszNetLoc = min(lpszNetLoc, lpszParam);
 572         else
 573                lpszNetLoc = lpszParam;
 574         }
 575         else if (!lpszNetLoc)
 576             lpszNetLoc = lpszcp + strlen(lpszcp);
 577
 578         /* Parse net-loc */
 579         if (lpszNetLoc)
 580         {
 581             LPSTR lpszHost;
 582             LPSTR lpszPort;
 583
 584                 /* [<user>[<:password>]@]<host>[:<port>] */
 585             /* First find the user and password if they exist */
 586
 587             lpszHost = strchr(lpszcp, '@');
 588             if (lpszHost == NULL || lpszHost > lpszNetLoc)
 589                 {
 590                 /* username and password not specified. */
 591                 SetUrlComponentValue(&lpUrlComponents->lpszUserName,
 592                         &lpUrlComponents->dwUserNameLength, NULL, 0);
 593                 SetUrlComponentValue(&lpUrlComponents->lpszPassword,
 594                         &lpUrlComponents->dwPasswordLength, NULL, 0);
 595                 }
 596             else /* Parse out username and password */
 597                 {
 598                 LPSTR lpszUser = lpszcp;
 599                 LPSTR lpszPasswd = lpszHost;
 600
 601                 while (lpszcp < lpszHost)
 602                         {
 603                    if (*lpszcp == ':')
 604                        lpszPasswd = lpszcp;
 605
 606                    lpszcp++;
 607                     }
 608
 609                 SetUrlComponentValue(&lpUrlComponents->lpszUserName,
 610                         &lpUrlComponents->dwUserNameLength, lpszUser, lpszPasswd - lpszUser);
 611
 612                 SetUrlComponentValue(&lpUrlComponents->lpszPassword,
 613                         &lpUrlComponents->dwPasswordLength,
 614                         lpszPasswd == lpszHost ? NULL : ++lpszPasswd,
 615                         lpszHost - lpszPasswd);
 616
 617                 lpszcp++; /* Advance to beginning of host */
 618                 }
 619
 620             /* Parse <host><:port> */
 621
 622             lpszHost = lpszcp;
 623             lpszPort = lpszNetLoc;
 624
 625             while (lpszcp < lpszNetLoc)
 626                     {
 627                 if (*lpszcp == ':')
 628                     lpszPort = lpszcp;
 629
 630                 lpszcp++;
 631                 }
 632
 633             SetUrlComponentValue(&lpUrlComponents->lpszHostName,
 634                &lpUrlComponents->dwHostNameLength, lpszHost, lpszPort - lpszHost);
 635
 636             if (lpszPort != lpszNetLoc)
 637                 lpUrlComponents->nPort = atoi(++lpszPort);
 638             }
 639         }
 640
 641     /* Here lpszcp points to:
 642      *
 643      * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
 644      *                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 645      */
 646     if (lpszcp != 0 && *lpszcp != '\0' && (!lpszParam || lpszcp < lpszParam))
 647     {
 648         INT len;
 649
 650         /* Only truncate the parameter list if it's already been saved
 651          * in lpUrlComponents->lpszExtraInfo.
 652          */
 653         if (lpszParam && lpUrlComponents->dwExtraInfoLength)
 654             len = lpszParam - lpszcp;
 655         else
 656         {
 657             /* Leave the parameter list in lpszUrlPath.  Strip off any trailing
 658              * newlines if necessary.
 659              */
 660             LPSTR lpsznewline = strchr (lpszcp, '\n');
 661             if (lpsznewline != NULL)
 662                 len = lpsznewline - lpszcp;
 663             else
 664                 len = strlen(lpszcp);
 665         }
 666
 667         if (!SetUrlComponentValue(&lpUrlComponents->lpszUrlPath,
 668          &lpUrlComponents->dwUrlPathLength, lpszcp, len))
 669          return FALSE;
 670     }
 671     else
 672     {
 673         lpUrlComponents->dwUrlPathLength = 0;
 674     }
 675
 676     TRACE("%s: host(%s) path(%s) extra(%s)\n", lpszUrl, lpUrlComponents->lpszHostName,
 677           lpUrlComponents->lpszUrlPath, lpUrlComponents->lpszExtraInfo);
 678
 679     return TRUE;
 680 }
 681
 682
 683 /***********************************************************************
 684  *           InternetAttemptConnect (WININET.81)
 685  *
 686  * Attempt to make a connection to the internet
 687  *
 688  * RETURNS
 689  *    ERROR_SUCCESS on success
 690  *    Error value   on failure
 691  *
 692  */
 693 INTERNETAPI DWORD WINAPI InternetAttemptConnect(DWORD dwReserved)
 694 {
 695     FIXME("Stub\n");
 696     return ERROR_SUCCESS;
 697 }
 698
 699
 700 /***********************************************************************
 701  *           InternetCanonicalizeUrlA (WININET.85)
 702  *
 703  * Escape unsafe characters and spaces
 704  *
 705  * RETURNS
 706  *    TRUE on success
 707  *    FALSE on failure
 708  *
 709  */
 710 BOOL WINAPI InternetCanonicalizeUrlA(LPCSTR lpszUrl, LPSTR lpszBuffer,
 711         LPDWORD lpdwBufferLength, DWORD dwFlags)
 712 {
 713     BOOL bSuccess = FALSE;
 714
 715     FIXME("Stub!\n");
 716
 717     if (lpszUrl)
 718     {
 719         strncpy(lpszBuffer, lpszUrl, *lpdwBufferLength);
 720         *lpdwBufferLength = strlen(lpszBuffer);
 721         bSuccess = TRUE;
 722     }
 723
 724     return bSuccess;
 725 }
 726
 727
 728 /***********************************************************************
 729  *           InternetSetStatusCallback (WININET.133)
 730  *
 731  * Sets up a callback function which is called as progress is made
 732  * during an operation.
 733  *
 734  * RETURNS
 735  *    Previous callback or NULL         on success
 736  *    INTERNET_INVALID_STATUS_CALLBACK  on failure
 737  *
 738  */
 739 INTERNETAPI INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallback(
 740         HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
 741 {
 742     INTERNET_STATUS_CALLBACK retVal;
 743     LPWININETAPPINFOA lpwai = (LPWININETAPPINFOA)hInternet;
 744
 745     TRACE("0x%08lx\n", (ULONG)hInternet);
 746     if (lpwai->hdr.htype != WH_HINIT)
 747         return INTERNET_INVALID_STATUS_CALLBACK;
 748
 749     retVal = lpwai->lpfnStatusCB;
 750     lpwai->lpfnStatusCB = lpfnIntCB;
 751
 752     return retVal;
 753 }
 754
 755
 756 /***********************************************************************
 757  *           InternetWriteFile (WININET.138)
 758  *
 759  * Write data to an open internet file
 760  *
 761  * RETURNS
 762  *    TRUE  on success
 763  *    FALSE on failure
 764  *
 765  */
 766 BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer ,
 767         DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
 768 {
 769     BOOL retval = FALSE;
 770     int nSocket = INVALID_SOCKET;
 771     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hFile;
 772
 773     TRACE("\n");
 774     if (NULL == lpwh)
 775         return FALSE;
 776
 777     switch (lpwh->htype)
 778     {
 779         case WH_HHTTPREQ:
 780             nSocket = ((LPWININETHTTPREQA)hFile)->nSocketFD;
 781             break;
 782
 783         case WH_HFILE:
 784             nSocket = ((LPWININETFILE)hFile)->nDataSocket;
 785             break;
 786
 787         default:
 788             break;
 789     }
 790
 791     if (INVALID_SOCKET != nSocket)
 792     {
 793         *lpdwNumOfBytesWritten = INTERNET_WriteDataToStream(nSocket, lpBuffer, dwNumOfBytesToWrite);
 794         if (*lpdwNumOfBytesWritten < 0)
 795             *lpdwNumOfBytesWritten = 0;
 796         else
 797             retval = TRUE;
 798     }
 799
 800     return retval;
 801 }
 802
 803
 804 /***********************************************************************
 805  *           InternetReadFile (WININET.121)
 806  *
 807  * Read data from an open internet file
 808  *
 809  * RETURNS
 810  *    TRUE  on success
 811  *    FALSE on failure
 812  *
 813  */
 814 BOOL WINAPI InternetReadFile(HINTERNET hFile, LPVOID lpBuffer,
 815         DWORD dwNumOfBytesToRead, LPDWORD dwNumOfBytesRead)
 816 {
 817     BOOL retval = FALSE;
 818     int nSocket = INVALID_SOCKET;
 819     LPWININETHANDLEHEADER lpwh = (LPWININETHANDLEHEADER) hFile;
 820
 821     TRACE("\n");
 822     if (NULL == lpwh)
 823         return FALSE;
 824
 825     switch (lpwh->htype)
 826     {
 827         case WH_HHTTPREQ:
 828             nSocket = ((LPWININETHTTPREQA)hFile)->nSocketFD;
 829             break;
 830
 831         case WH_HFILE:
 832             nSocket = ((LPWININETFILE)hFile)->nDataSocket;
 833             break;
 834
 835         default:
 836             break;
 837     }
 838
 839     if (INVALID_SOCKET != nSocket)
 840     {
 841         *dwNumOfBytesRead = INTERNET_ReadDataFromStream(nSocket, lpBuffer, dwNumOfBytesToRead);
 842         if (*dwNumOfBytesRead < 0)
 843             *dwNumOfBytesRead = 0;
 844         else
 845             retval = TRUE;
 846     }
 847
 848     return retval;
 849 }
 850
 851
 852 /***********************************************************************
 853  *           InternetQueryOptionA
 854  *
 855  * Queries an options on the specified handle
 856  *
 857  * RETURNS
 858  *    TRUE  on success
 859  *    FALSE on failure
 860  *
 861  */
 862 BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
 863         LPVOID lpBuffer, LPDWORD lpdwBufferLength)
 864 {
 865     LPWININETHANDLEHEADER lpwhh;
 866     BOOL bSuccess = FALSE;
 867
 868     TRACE("0x%08lx\n", dwOption);
 869
 870     if (NULL == hInternet)
 871     {
 872         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 873         return FALSE;
 874     }
 875
 876     lpwhh = (LPWININETHANDLEHEADER) hInternet;
 877
 878     switch (dwOption)
 879     {
 880        case INTERNET_OPTION_HANDLE_TYPE:
 881        {
 882          ULONG type = lpwhh->htype;
 883          TRACE("INTERNET_OPTION_HANDLE_TYPE: %ld\n", type);
 884
 885          if (*lpdwBufferLength < sizeof(ULONG))
 886              INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
 887          else
 888          {
 889              memcpy(lpBuffer, &type, sizeof(ULONG));
 890              *lpdwBufferLength = sizeof(ULONG);
 891              bSuccess = TRUE;
 892          }
 893
 894          break;
 895        }
 896
 897        default:
 898          FIXME("Stub!");
 899          break;
 900     }
 901
 902     return bSuccess;
 903 }
 904
 905
 906 /***********************************************************************
 907  *           GetInternetScheme (internal)
 908  *
 909  * Get scheme of url
 910  *
 911  * RETURNS
 912  *    scheme on success
 913  *    INTERNET_SCHEME_UNKNOWN on failure
 914  *
 915  */
 916 INTERNET_SCHEME GetInternetScheme(LPCSTR lpszScheme, INT nMaxCmp)
 917 {
 918     if(lpszScheme==NULL)
 919         return INTERNET_SCHEME_UNKNOWN;
 920
 921     if (!strncasecmp("ftp", lpszScheme, nMaxCmp))
 922         return INTERNET_SCHEME_FTP;
 923     else if (!strncasecmp("gopher", lpszScheme, nMaxCmp))
 924         return INTERNET_SCHEME_GOPHER;
 925     else if (!strncasecmp("http", lpszScheme, nMaxCmp))
 926         return INTERNET_SCHEME_HTTP;
 927     else if (!strncasecmp("https", lpszScheme, nMaxCmp))
 928         return INTERNET_SCHEME_HTTPS;
 929     else if (!strncasecmp("file", lpszScheme, nMaxCmp))
 930         return INTERNET_SCHEME_FILE;
 931     else if (!strncasecmp("news", lpszScheme, nMaxCmp))
 932         return INTERNET_SCHEME_NEWS;
 933     else if (!strncasecmp("mailto", lpszScheme, nMaxCmp))
 934         return INTERNET_SCHEME_MAILTO;
 935     else
 936         return INTERNET_SCHEME_UNKNOWN;
 937 }
 938
 939 /***********************************************************************
 940  *      InternetCheckConnectionA
 941  *
 942  * Pings a requested host to check internet connection
 943  *
 944  * RETURNS
 945  *
 946  *  TRUE on success and FALSE on failure. if a failures then
 947  *   ERROR_NOT_CONNECTED is places into GetLastError
 948  *
 949  */
 950 BOOL WINAPI InternetCheckConnectionA( LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved )
 951 {
 952 /*
 953  * this is a kludge which runs the resident ping program and reads the output.
 954  *
 955  * Anyone have a better idea?
 956  */
 957
 958   BOOL   rc = FALSE;
 959   char command[1024];
 960   char host[1024];
 961   int status = -1;
 962
 963   /*
 964    * Crack or set the Address
 965    */
 966   if (lpszUrl == NULL)
 967   {
 968      /*
 969       * According to the doc we are supost to use the ip for the next
 970       * server in the WnInet internal server database. I have
 971       * no idea what that is or how to get it.
 972       *
 973       * So someone needs to implement this.
 974       */
 975      FIXME("Unimplemented with URL of NULL");
 976      return TRUE;
 977   }
 978   else
 979   {
 980      URL_COMPONENTSA componets;
 981
 982      ZeroMemory(&componets,sizeof(URL_COMPONENTSA));
 983      componets.lpszHostName = (LPSTR)&host;
 984      componets.dwHostNameLength = 1024;
 985
 986      if (!InternetCrackUrlA(lpszUrl,0,0,&componets))
 987        goto End;
 988
 989      TRACE("host name : %s\n",componets.lpszHostName);
 990   }
 991
 992   /*
 993    * Build our ping command
 994    */
 995   strcpy(command,"ping -w 1 ");
 996   strcat(command,host);
 997   strcat(command," >/dev/null 2>/dev/null");
 998
 999   TRACE("Ping command is : %s\n",command);
1000
1001   status = system(command);
1002
1003   TRACE("Ping returned a code of %i \n",status);
1004
1005   /* Ping return code of 0 indicates success */
1006   if (status == 0)
1007      rc = TRUE;
1008
1009 End:
1010
1011   if (rc == FALSE)
1012     SetLastError(ERROR_NOT_CONNECTED);
1013
1014   return rc;
1015 }
1016
1017
1018
1019 /***********************************************************************
1020  *           INTERNET_WriteDataToStream (internal)
1021  *
1022  * Send data to server
1023  *
1024  * RETURNS
1025  *
1026  *   number of characters sent on success
1027  *   -1 on error
1028  */
1029 int INTERNET_WriteDataToStream(int nDataSocket, LPCVOID Buffer, DWORD BytesToWrite)
1030 {
1031     if (INVALID_SOCKET == nDataSocket)
1032         return SOCKET_ERROR;
1033
1034     return send(nDataSocket, Buffer, BytesToWrite, 0);
1035 }
1036
1037
1038 /***********************************************************************
1039  *           INTERNET_ReadDataFromStream (internal)
1040  *
1041  * Read data from http server
1042  *
1043  * RETURNS
1044  *
1045  *   number of characters sent on success
1046  *   -1 on error
1047  */
1048 int INTERNET_ReadDataFromStream(int nDataSocket, LPVOID Buffer, DWORD BytesToRead)
1049 {
1050     if (INVALID_SOCKET == nDataSocket)
1051         return SOCKET_ERROR;
1052
1053     return recv(nDataSocket, Buffer, BytesToRead, 0);
1054 }
1055
1056
1057 /***********************************************************************
1058  *           INTERNET_SetLastError (internal)
1059  *
1060  * Set last thread specific error
1061  *
1062  * RETURNS
1063  *
1064  */
1065 void INTERNET_SetLastError(DWORD dwError)
1066 {
1067     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1068
1069     SetLastError(dwError);
1070     lpwite->dwError = dwError;
1071 }
1072
1073
1074 /***********************************************************************
1075  *           INTERNET_GetLastError (internal)
1076  *
1077  * Get last thread specific error
1078  *
1079  * RETURNS
1080  *
1081  */
1082 DWORD INTERNET_GetLastError()
1083 {
1084     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1085     return lpwite->dwError;
1086 }
1087
1088
1089 /***********************************************************************
1090  *           INTERNET_WorkerThreadFunc (internal)
1091  *
1092  * Worker thread execution function
1093  *
1094  * RETURNS
1095  *
1096  */
1097 DWORD INTERNET_WorkerThreadFunc(LPVOID *lpvParam)
1098 {
1099     DWORD dwWaitRes;
1100
1101     while (1)
1102     {
1103         dwWaitRes = WaitForMultipleObjects(2, hEventArray, FALSE, MAX_IDLE_WORKER);
1104
1105         if (dwWaitRes == WAIT_OBJECT_0 + 1)
1106             INTERNET_ExecuteWork();
1107         else
1108             break;
1109
1110         InterlockedIncrement(&dwNumIdleThreads);
1111     }
1112
1113     InterlockedDecrement(&dwNumIdleThreads);
1114     InterlockedDecrement(&dwNumThreads);
1115     TRACE("Worker thread exiting\n");
1116     return TRUE;
1117 }
1118
1119
1120 /***********************************************************************
1121  *           INTERNET_InsertWorkRequest (internal)
1122  *
1123  * Insert work request into queue
1124  *
1125  * RETURNS
1126  *
1127  */
1128 BOOL INTERNET_InsertWorkRequest(LPWORKREQUEST lpWorkRequest)
1129 {
1130     BOOL bSuccess = FALSE;
1131     LPWORKREQUEST lpNewRequest;
1132
1133     TRACE("\n");
1134
1135     lpNewRequest = HeapAlloc(GetProcessHeap(), 0, sizeof(WORKREQUEST));
1136     if (lpNewRequest)
1137     {
1138         memcpy(lpNewRequest, lpWorkRequest, sizeof(WORKREQUEST));
1139         lpNewRequest->prev = NULL;
1140
1141         EnterCriticalSection(&csQueue);
1142
1143         lpNewRequest->next = lpWorkQueueTail;
1144         if (lpWorkQueueTail)
1145             lpWorkQueueTail->prev = lpNewRequest;
1146         lpWorkQueueTail = lpNewRequest;
1147         if (!lpHeadWorkQueue)
1148             lpHeadWorkQueue = lpWorkQueueTail;
1149
1150         LeaveCriticalSection(&csQueue);
1151
1152         bSuccess = TRUE;
1153     }
1154
1155     return bSuccess;
1156 }
1157
1158
1159 /***********************************************************************
1160  *           INTERNET_GetWorkRequest (internal)
1161  *
1162  * Retrieves work request from queue
1163  *
1164  * RETURNS
1165  *
1166  */
1167 BOOL INTERNET_GetWorkRequest(LPWORKREQUEST lpWorkRequest)
1168 {
1169     BOOL bSuccess = FALSE;
1170     LPWORKREQUEST lpRequest = NULL;
1171
1172     TRACE("\n");
1173
1174     EnterCriticalSection(&csQueue);
1175
1176     if (lpHeadWorkQueue)
1177     {
1178         lpRequest = lpHeadWorkQueue;
1179         lpHeadWorkQueue = lpHeadWorkQueue->prev;
1180         if (lpRequest == lpWorkQueueTail)
1181             lpWorkQueueTail = lpHeadWorkQueue;
1182     }
1183
1184     LeaveCriticalSection(&csQueue);
1185
1186     if (lpRequest)
1187     {
1188         memcpy(lpWorkRequest, lpRequest, sizeof(WORKREQUEST));
1189         HeapFree(GetProcessHeap(), 0, lpRequest);
1190         bSuccess = TRUE;
1191     }
1192
1193     return bSuccess;
1194 }
1195
1196
1197 /***********************************************************************
1198  *           INTERNET_AsyncCall (internal)
1199  *
1200  * Retrieves work request from queue
1201  *
1202  * RETURNS
1203  *
1204  */
1205 BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
1206 {
1207     HANDLE hThread;
1208     DWORD dwTID;
1209     BOOL bSuccess = FALSE;
1210
1211     TRACE("\n");
1212
1213     if (InterlockedDecrement(&dwNumIdleThreads) < 0)
1214     {
1215         InterlockedIncrement(&dwNumIdleThreads);
1216
1217         if (InterlockedIncrement(&dwNumThreads) > MAX_WORKER_THREADS ||
1218             !(hThread = CreateThread(NULL, 0,
1219             (LPTHREAD_START_ROUTINE)INTERNET_WorkerThreadFunc, NULL, 0, &dwTID)))
1220         {
1221             InterlockedDecrement(&dwNumThreads);
1222             INTERNET_SetLastError(ERROR_INTERNET_ASYNC_THREAD_FAILED);
1223             goto lerror;
1224         }
1225
1226         TRACE("Created new thread\n");
1227     }
1228
1229     bSuccess = TRUE;
1230     INTERNET_InsertWorkRequest(lpWorkRequest);
1231     SetEvent(hWorkEvent);
1232
1233 lerror:
1234
1235     return bSuccess;
1236 }
1237
1238
1239 /***********************************************************************
1240  *           INTERNET_ExecuteWork (internal)
1241  *
1242  * RETURNS
1243  *
1244  */
1245 VOID INTERNET_ExecuteWork()
1246 {
1247     WORKREQUEST workRequest;
1248
1249     TRACE("\n");
1250
1251     if (INTERNET_GetWorkRequest(&workRequest))
1252     {
1253         switch (workRequest.asyncall)
1254         {
1255             case FTPPUTFILEA:
1256                 FTP_FtpPutFileA((HINTERNET)workRequest.HFTPSESSION, (LPCSTR)workRequest.LPSZLOCALFILE,
1257                     (LPCSTR)workRequest.LPSZNEWREMOTEFILE, workRequest.DWFLAGS, workRequest.DWCONTEXT);
1258                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZLOCALFILE);
1259                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZNEWREMOTEFILE);
1260                 break;
1261
1262             case FTPSETCURRENTDIRECTORYA:
1263                 FTP_FtpSetCurrentDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1264                         (LPCSTR)workRequest.LPSZDIRECTORY);
1265                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1266                 break;
1267
1268             case FTPCREATEDIRECTORYA:
1269                 FTP_FtpCreateDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1270                         (LPCSTR)workRequest.LPSZDIRECTORY);
1271                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1272                 break;
1273
1274             case FTPFINDFIRSTFILEA:
1275                 FTP_FtpFindFirstFileA((HINTERNET)workRequest.HFTPSESSION,
1276                         (LPCSTR)workRequest.LPSZSEARCHFILE,
1277                    (LPWIN32_FIND_DATAA)workRequest.LPFINDFILEDATA, workRequest.DWFLAGS,
1278                    workRequest.DWCONTEXT);
1279                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZSEARCHFILE);
1280                 break;
1281
1282             case FTPGETCURRENTDIRECTORYA:
1283                 FTP_FtpGetCurrentDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1284                         (LPSTR)workRequest.LPSZDIRECTORY, (LPDWORD)workRequest.LPDWDIRECTORY);
1285                 break;
1286
1287             case FTPOPENFILEA:
1288                  FTP_FtpOpenFileA((HINTERNET)workRequest.HFTPSESSION,
1289                     (LPCSTR)workRequest.LPSZFILENAME,
1290                     workRequest.FDWACCESS,
1291                     workRequest.DWFLAGS,
1292                     workRequest.DWCONTEXT);
1293                  HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZFILENAME);
1294                  break;
1295
1296             case FTPGETFILEA:
1297                 FTP_FtpGetFileA((HINTERNET)workRequest.HFTPSESSION,
1298                     (LPCSTR)workRequest.LPSZREMOTEFILE,
1299                     (LPCSTR)workRequest.LPSZNEWFILE,
1300                     (BOOL)workRequest.FFAILIFEXISTS,
1301                     workRequest.DWLOCALFLAGSATTRIBUTE,
1302                     workRequest.DWFLAGS,
1303                     workRequest.DWCONTEXT);
1304                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZREMOTEFILE);
1305                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZNEWFILE);
1306                 break;
1307
1308             case FTPDELETEFILEA:
1309                 FTP_FtpDeleteFileA((HINTERNET)workRequest.HFTPSESSION,
1310                         (LPCSTR)workRequest.LPSZFILENAME);
1311                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZFILENAME);
1312                 break;
1313
1314             case FTPREMOVEDIRECTORYA:
1315                 FTP_FtpRemoveDirectoryA((HINTERNET)workRequest.HFTPSESSION,
1316                         (LPCSTR)workRequest.LPSZDIRECTORY);
1317                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDIRECTORY);
1318                 break;
1319
1320             case FTPRENAMEFILEA:
1321                 FTP_FtpRenameFileA((HINTERNET)workRequest.HFTPSESSION,
1322                         (LPCSTR)workRequest.LPSZSRCFILE,
1323                         (LPCSTR)workRequest.LPSZDESTFILE);
1324                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZSRCFILE);
1325                 HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZDESTFILE);
1326                 break;
1327
1328             case INTERNETFINDNEXTA:
1329                 INTERNET_FindNextFileA((HINTERNET)workRequest.HFTPSESSION,
1330                     (LPWIN32_FIND_DATAA)workRequest.LPFINDFILEDATA);
1331                 break;
1332
1333             case HTTPSENDREQUESTA:
1334                HTTP_HttpSendRequestA((HINTERNET)workRequest.HFTPSESSION,
1335                        (LPCSTR)workRequest.LPSZHEADER,
1336                        workRequest.DWHEADERLENGTH,
1337                        (LPVOID)workRequest.LPOPTIONAL,
1338                        workRequest.DWOPTIONALLENGTH);
1339                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZHEADER);
1340                break;
1341
1342             case HTTPOPENREQUESTA:
1343                HTTP_HttpOpenRequestA((HINTERNET)workRequest.HFTPSESSION,
1344                        (LPCSTR)workRequest.LPSZVERB,
1345                        (LPCSTR)workRequest.LPSZOBJECTNAME,
1346                        (LPCSTR)workRequest.LPSZVERSION,
1347                        (LPCSTR)workRequest.LPSZREFERRER,
1348                        (LPCSTR*)workRequest.LPSZACCEPTTYPES,
1349                        workRequest.DWFLAGS,
1350                        workRequest.DWCONTEXT);
1351                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZVERB);
1352                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZOBJECTNAME);
1353                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZVERSION);
1354                HeapFree(GetProcessHeap(), 0, (LPVOID)workRequest.LPSZREFERRER);
1355                 break;
1356
1357         }
1358     }
1359 }
1360
1361
1362 /***********************************************************************
1363  *          INTERNET_GetResponseBuffer
1364  *
1365  * RETURNS
1366  *
1367  */
1368 LPSTR INTERNET_GetResponseBuffer()
1369 {
1370     LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
1371     return lpwite->response;
1372 }
1373
1374
1375 /***********************************************************************
1376  *           INTERNET_GetNextLine  (internal)
1377  *
1378  * Parse next line in directory string listing
1379  *
1380  * RETURNS
1381  *   Pointer to begining of next line
1382  *   NULL on failure
1383  *
1384  */
1385
1386 LPSTR INTERNET_GetNextLine(INT nSocket, LPSTR lpszBuffer, LPDWORD dwBuffer)
1387 {
1388     struct timeval tv;
1389     fd_set infd;
1390     BOOL bSuccess = FALSE;
1391     INT nRecv = 0;
1392
1393     TRACE("\n");
1394
1395     FD_ZERO(&infd);
1396     FD_SET(nSocket, &infd);
1397     tv.tv_sec=RESPONSE_TIMEOUT;
1398     tv.tv_usec=0;
1399
1400     while (nRecv < *dwBuffer)
1401     {
1402         if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0)
1403         {
1404             if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
1405             {
1406                 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1407                 goto lend;
1408             }
1409
1410             if (lpszBuffer[nRecv] == '\n')
1411             {
1412                 bSuccess = TRUE;
1413                 break;
1414             }
1415             if (lpszBuffer[nRecv] != '\r')
1416                 nRecv++;
1417         }
1418         else
1419         {
1420             INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
1421             goto lend;
1422 }
1423     }
1424
1425 lend:
1426     if (bSuccess)
1427     {
1428         lpszBuffer[nRecv] = '\0';
1429         *dwBuffer = nRecv - 1;
1430         TRACE(":%d %s\n", nRecv, lpszBuffer);
1431         return lpszBuffer;
1432     }
1433     else
1434     {
1435         return NULL;
1436     }
1437 }
1438