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