git.oblomov.eu Git - wine/blob - dlls/wininet/ftp.c

   1 /*
   2  * WININET - Ftp implementation
   3  *
   4  * Copyright 1999 Corel Corporation
   5  *
   6  * Ulrich Czekalla
   7  * Noureddine Jemmali
   8  *
   9  * Copyright 2000 Andreas Mohr
  10  */
  11
  12 #include "config.h"
  13
  14 #include <errno.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <sys/types.h>
  19 #ifdef HAVE_SYS_SOCKET_H
  20 # include <sys/socket.h>
  21 #endif
  22 #include <unistd.h>
  23 #include <time.h>
  24
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "wininet.h"
  29 #include "winerror.h"
  30
  31 #include "debugtools.h"
  32 #include "internet.h"
  33
  34 DEFAULT_DEBUG_CHANNEL(wininet);
  35
  36 #define NOACCOUNT               "noaccount"
  37 #define DATA_PACKET_SIZE        0x2000
  38 #define szCRLF                  "\r\n"
  39 #define MAX_BACKLOG             5
  40
  41 typedef enum {
  42   /* FTP commands with arguments. */
  43   FTP_CMD_ACCT,
  44   FTP_CMD_CWD,
  45   FTP_CMD_DELE,
  46   FTP_CMD_MKD,
  47   FTP_CMD_PASS,
  48   FTP_CMD_PORT,
  49   FTP_CMD_RETR,
  50   FTP_CMD_RMD,
  51   FTP_CMD_RNFR,
  52   FTP_CMD_RNTO,
  53   FTP_CMD_STOR,
  54   FTP_CMD_TYPE,
  55   FTP_CMD_USER,
  56
  57   /* FTP commands without arguments. */
  58   FTP_CMD_ABOR,
  59   FTP_CMD_LIST,
  60   FTP_CMD_NLST,
  61   FTP_CMD_PASV,
  62   FTP_CMD_PWD,
  63   FTP_CMD_QUIT,
  64 } FTP_COMMAND;
  65
  66 static const CHAR *szFtpCommands[] = {
  67   "ACCT",
  68   "CWD",
  69   "DELE",
  70   "MKD",
  71   "PASS",
  72   "PORT",
  73   "RETR",
  74   "RMD",
  75   "RNFR",
  76   "RNTO",
  77   "STOR",
  78   "TYPE",
  79   "USER",
  80   "ABOR",
  81   "LIST",
  82   "NLST",
  83   "PASV",
  84   "PWD",
  85   "QUIT",
  86 };
  87
  88 static const CHAR szMonths[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
  89
  90 BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
  91         INTERNET_STATUS_CALLBACK lpfnStatusCB, HINTERNET hHandle, DWORD dwContext);
  92 BOOL FTP_SendStore(LPWININETFTPSESSIONA lpwfs, LPCSTR lpszRemoteFile, DWORD dwType);
  93 BOOL FTP_GetDataSocket(LPWININETFTPSESSIONA lpwfs, LPINT nDataSocket);
  94 BOOL FTP_SendData(LPWININETFTPSESSIONA lpwfs, INT nDataSocket, HANDLE hFile);
  95 INT FTP_ReceiveResponse(INT nSocket, LPSTR lpszResponse, DWORD dwResponse,
  96         INTERNET_STATUS_CALLBACK lpfnStatusCB, HINTERNET hHandle, DWORD dwContext);
  97 DWORD FTP_SendRetrieve(LPWININETFTPSESSIONA lpwfs, LPCSTR lpszRemoteFile, DWORD dwType);
  98 BOOL FTP_RetrieveFileData(LPWININETFTPSESSIONA lpwfs, INT nDataSocket, DWORD nBytes, HANDLE hFile);
  99 BOOL FTP_InitListenSocket(LPWININETFTPSESSIONA lpwfs);
 100 BOOL FTP_ConnectToHost(LPWININETFTPSESSIONA lpwfs);
 101 BOOL FTP_SendPassword(LPWININETFTPSESSIONA lpwfs);
 102 BOOL FTP_SendAccount(LPWININETFTPSESSIONA lpwfs);
 103 BOOL FTP_SendType(LPWININETFTPSESSIONA lpwfs, DWORD dwType);
 104 BOOL FTP_SendPort(LPWININETFTPSESSIONA lpwfs);
 105 BOOL FTP_DoPassive(LPWININETFTPSESSIONA lpwfs);
 106 BOOL FTP_SendPortOrPasv(LPWININETFTPSESSIONA lpwfs);
 107 BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESA lpfp);
 108 BOOL FTP_ParseDirectory(LPWININETFTPSESSIONA lpwfs, INT nSocket, LPFILEPROPERTIESA *lpafp, LPDWORD dwfp);
 109 HINTERNET FTP_ReceiveFileList(LPWININETFTPSESSIONA lpwfs, INT nSocket,
 110         LPWIN32_FIND_DATAA lpFindFileData, DWORD dwContext);
 111 DWORD FTP_SetResponseError(DWORD dwResponse);
 112
 113 inline static LPSTR FTP_strdup( LPCSTR str )
 114 {
 115     LPSTR ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 );
 116     if (ret) strcpy( ret, str );
 117     return ret;
 118 }
 119
 120 /***********************************************************************
 121  *           FtpPutFileA (WININET.@)
 122  *
 123  * Uploads a file to the FTP server
 124  *
 125  * RETURNS
 126  *    TRUE on success
 127  *    FALSE on failure
 128  *
 129  */
 130 BOOL WINAPI FtpPutFileA(HINTERNET hConnect, LPCSTR lpszLocalFile,
 131     LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD dwContext)
 132 {
 133     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 134     LPWININETAPPINFOA hIC = NULL;
 135
 136     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 137     {
 138         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 139         return FALSE;
 140     }
 141
 142     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 143     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 144     {
 145         WORKREQUEST workRequest;
 146
 147         workRequest.asyncall = FTPPUTFILEA;
 148         workRequest.HFTPSESSION = (DWORD)hConnect;
 149         workRequest.LPSZLOCALFILE = (DWORD)FTP_strdup(lpszLocalFile);
 150         workRequest.LPSZNEWREMOTEFILE = (DWORD)FTP_strdup(lpszNewRemoteFile);
 151         workRequest.DWFLAGS = dwFlags;
 152         workRequest.DWCONTEXT = dwContext;
 153
 154         return INTERNET_AsyncCall(&workRequest);
 155     }
 156     else
 157     {
 158         return FTP_FtpPutFileA(hConnect, lpszLocalFile,
 159                 lpszNewRemoteFile, dwFlags, dwContext);
 160     }
 161 }
 162
 163 /***********************************************************************
 164  *           FTP_FtpPutFileA (Internal)
 165  *
 166  * Uploads a file to the FTP server
 167  *
 168  * RETURNS
 169  *    TRUE on success
 170  *    FALSE on failure
 171  *
 172  */
 173 BOOL WINAPI FTP_FtpPutFileA(HINTERNET hConnect, LPCSTR lpszLocalFile,
 174     LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD dwContext)
 175 {
 176     HANDLE hFile = (HANDLE)NULL;
 177     BOOL bSuccess = FALSE;
 178     LPWININETAPPINFOA hIC = NULL;
 179     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 180     INT nResCode;
 181
 182     TRACE(" lpszLocalFile(%s) lpszNewRemoteFile(%s)\n", lpszLocalFile, lpszNewRemoteFile);
 183     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 184     {
 185         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 186         return FALSE;
 187     }
 188
 189     /* Clear any error information */
 190     INTERNET_SetLastError(0);
 191
 192     /* Open file to be uploaded */
 193     if (INVALID_HANDLE_VALUE ==
 194         (hFile = CreateFileA(lpszLocalFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)))
 195     {
 196         INTERNET_SetLastError(ERROR_FILE_NOT_FOUND);
 197         goto lend;
 198     }
 199
 200     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 201     if (hIC->lpfnStatusCB)
 202         hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
 203
 204     if (FTP_SendStore(lpwfs, lpszNewRemoteFile, dwFlags))
 205     {
 206         INT nDataSocket;
 207
 208         /* Get data socket to server */
 209         if (FTP_GetDataSocket(lpwfs, &nDataSocket))
 210         {
 211             FTP_SendData(lpwfs, nDataSocket, hFile);
 212             close(nDataSocket);
 213             nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 214                                            MAX_REPLY_LEN, 0, 0, 0);
 215             if (nResCode)
 216             {
 217                 if (nResCode == 226)
 218                     bSuccess = TRUE;
 219                 else
 220                     FTP_SetResponseError(nResCode);
 221             }
 222         }
 223     }
 224
 225 lend:
 226     if (lpwfs->lstnSocket != -1)
 227         close(lpwfs->lstnSocket);
 228
 229     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC  && hIC->lpfnStatusCB)
 230     {
 231         INTERNET_ASYNC_RESULT iar;
 232
 233         iar.dwResult = (DWORD)bSuccess;
 234         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 235         hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 236             &iar, sizeof(INTERNET_ASYNC_RESULT));
 237     }
 238
 239     if (hFile)
 240         CloseHandle(hFile);
 241
 242     return bSuccess;
 243 }
 244
 245
 246 /***********************************************************************
 247  *           FtpSetCurrentDirectoryA (WININET.@)
 248  *
 249  * Change the working directory on the FTP server
 250  *
 251  * RETURNS
 252  *    TRUE on success
 253  *    FALSE on failure
 254  *
 255  */
 256 BOOL WINAPI FtpSetCurrentDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 257 {
 258     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 259     LPWININETAPPINFOA hIC = NULL;
 260
 261     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 262     {
 263         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 264         return FALSE;
 265     }
 266
 267     TRACE("lpszDirectory(%s)\n", lpszDirectory);
 268
 269     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 270     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 271     {
 272         WORKREQUEST workRequest;
 273
 274         workRequest.asyncall = FTPSETCURRENTDIRECTORYA;
 275         workRequest.HFTPSESSION = (DWORD)hConnect;
 276         workRequest.LPSZDIRECTORY = (DWORD)FTP_strdup(lpszDirectory);
 277
 278         return INTERNET_AsyncCall(&workRequest);
 279     }
 280     else
 281     {
 282         return FTP_FtpSetCurrentDirectoryA(hConnect, lpszDirectory);
 283     }
 284 }
 285
 286
 287 /***********************************************************************
 288  *           FTP_FtpSetCurrentDirectoryA (Internal)
 289  *
 290  * Change the working directory on the FTP server
 291  *
 292  * RETURNS
 293  *    TRUE on success
 294  *    FALSE on failure
 295  *
 296  */
 297 BOOL WINAPI FTP_FtpSetCurrentDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 298 {
 299     INT nResCode;
 300     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 301     LPWININETAPPINFOA hIC = NULL;
 302     DWORD bSuccess = FALSE;
 303
 304     TRACE("lpszDirectory(%s)\n", lpszDirectory);
 305
 306     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 307     {
 308         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 309         return FALSE;
 310     }
 311
 312     /* Clear any error information */
 313     INTERNET_SetLastError(0);
 314
 315     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 316     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_CWD, lpszDirectory,
 317         hIC->lpfnStatusCB, hConnect, lpwfs->hdr.dwContext))
 318         goto lend;
 319
 320     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 321         MAX_REPLY_LEN, hIC->lpfnStatusCB, hConnect, lpwfs->hdr.dwContext);
 322
 323     if (nResCode)
 324     {
 325         if (nResCode == 250)
 326             bSuccess = TRUE;
 327         else
 328             FTP_SetResponseError(nResCode);
 329     }
 330
 331 lend:
 332     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 333     {
 334         INTERNET_ASYNC_RESULT iar;
 335
 336         iar.dwResult = (DWORD)bSuccess;
 337         iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
 338         hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 339             &iar, sizeof(INTERNET_ASYNC_RESULT));
 340     }
 341     return bSuccess;
 342 }
 343
 344
 345 /***********************************************************************
 346  *           FtpCreateDirectoryA (WININET.@)
 347  *
 348  * Create new directory on the FTP server
 349  *
 350  * RETURNS
 351  *    TRUE on success
 352  *    FALSE on failure
 353  *
 354  */
 355 BOOL WINAPI FtpCreateDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 356 {
 357     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 358     LPWININETAPPINFOA hIC = NULL;
 359
 360     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 361     {
 362         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 363         return FALSE;
 364     }
 365
 366     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 367     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 368     {
 369         WORKREQUEST workRequest;
 370
 371         workRequest.asyncall = FTPCREATEDIRECTORYA;
 372         workRequest.HFTPSESSION = (DWORD)hConnect;
 373         workRequest.LPSZDIRECTORY = (DWORD)FTP_strdup(lpszDirectory);
 374
 375         return INTERNET_AsyncCall(&workRequest);
 376     }
 377     else
 378     {
 379         return FTP_FtpCreateDirectoryA(hConnect, lpszDirectory);
 380     }
 381 }
 382
 383
 384 /***********************************************************************
 385  *           FTP_FtpCreateDirectoryA (Internal)
 386  *
 387  * Create new directory on the FTP server
 388  *
 389  * RETURNS
 390  *    TRUE on success
 391  *    FALSE on failure
 392  *
 393  */
 394 BOOL WINAPI FTP_FtpCreateDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 395 {
 396     INT nResCode;
 397     BOOL bSuccess = FALSE;
 398     LPWININETAPPINFOA hIC = NULL;
 399     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 400
 401     TRACE("\n");
 402     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 403     {
 404         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 405         return FALSE;
 406     }
 407
 408     /* Clear any error information */
 409     INTERNET_SetLastError(0);
 410
 411     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_MKD, lpszDirectory, 0, 0, 0))
 412         goto lend;
 413
 414     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 415         MAX_REPLY_LEN, 0, 0, 0);
 416     if (nResCode)
 417     {
 418         if (nResCode == 257)
 419             bSuccess = TRUE;
 420         else
 421             FTP_SetResponseError(nResCode);
 422     }
 423
 424 lend:
 425     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 426     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 427     {
 428         INTERNET_ASYNC_RESULT iar;
 429
 430         iar.dwResult = (DWORD)bSuccess;
 431         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 432         hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 433             &iar, sizeof(INTERNET_ASYNC_RESULT));
 434     }
 435
 436     return bSuccess;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           FtpFindFirstFileA (WININET.@)
 442  *
 443  * Search the specified directory
 444  *
 445  * RETURNS
 446  *    HINTERNET on success
 447  *    NULL on failure
 448  *
 449  */
 450 INTERNETAPI HINTERNET WINAPI FtpFindFirstFileA(HINTERNET hConnect,
 451     LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD dwContext)
 452 {
 453     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 454     LPWININETAPPINFOA hIC = NULL;
 455
 456     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 457     {
 458         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 459         return FALSE;
 460     }
 461
 462     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 463     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 464     {
 465         WORKREQUEST workRequest;
 466
 467         workRequest.asyncall = FTPFINDFIRSTFILEA;
 468         workRequest.HFTPSESSION = (DWORD)hConnect;
 469         workRequest.LPSZSEARCHFILE = (DWORD)FTP_strdup(lpszSearchFile);
 470         workRequest.LPFINDFILEDATA = (DWORD)lpFindFileData;
 471         workRequest.DWFLAGS = dwFlags;
 472         workRequest.DWCONTEXT= dwContext;
 473
 474         INTERNET_AsyncCall(&workRequest);
 475         return NULL;
 476     }
 477     else
 478     {
 479         return FTP_FtpFindFirstFileA(hConnect, lpszSearchFile, lpFindFileData,
 480                 dwFlags, dwContext);
 481     }
 482 }
 483
 484
 485 /***********************************************************************
 486  *           FTP_FtpFindFirstFileA (Internal)
 487  *
 488  * Search the specified directory
 489  *
 490  * RETURNS
 491  *    HINTERNET on success
 492  *    NULL on failure
 493  *
 494  */
 495 INTERNETAPI HINTERNET WINAPI FTP_FtpFindFirstFileA(HINTERNET hConnect,
 496     LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD dwContext)
 497 {
 498     INT nResCode;
 499     LPWININETAPPINFOA hIC = NULL;
 500     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hConnect;
 501     LPWININETFINDNEXTA hFindNext = NULL;
 502
 503     TRACE("\n");
 504
 505     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 506     {
 507         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 508         return FALSE;
 509     }
 510
 511     /* Clear any error information */
 512     INTERNET_SetLastError(0);
 513
 514     if (!FTP_InitListenSocket(lpwfs))
 515         goto lend;
 516
 517     if (!FTP_SendType(lpwfs, INTERNET_FLAG_TRANSFER_ASCII))
 518         goto lend;
 519
 520     if (!FTP_SendPortOrPasv(lpwfs))
 521         goto lend;
 522
 523     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 524     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_LIST, lpszSearchFile,
 525         hIC->lpfnStatusCB, hConnect, lpwfs->hdr.dwContext))
 526         goto lend;
 527
 528     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 529         MAX_REPLY_LEN, hIC->lpfnStatusCB, hConnect, lpwfs->hdr.dwContext);
 530     if (nResCode)
 531     {
 532         if (nResCode == 125 || nResCode == 150)
 533         {
 534             INT nDataSocket;
 535
 536             /* Get data socket to server */
 537             if (FTP_GetDataSocket(lpwfs, &nDataSocket))
 538             {
 539                 hFindNext = FTP_ReceiveFileList(lpwfs, nDataSocket, lpFindFileData, dwContext);
 540
 541                 nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 542                     MAX_REPLY_LEN, hIC->lpfnStatusCB, hConnect, lpwfs->hdr.dwContext);
 543                 if (nResCode != 226 && nResCode != 250)
 544                     INTERNET_SetLastError(ERROR_NO_MORE_FILES);
 545
 546                 close(nDataSocket);
 547             }
 548         }
 549         else
 550             FTP_SetResponseError(nResCode);
 551     }
 552
 553 lend:
 554     if (lpwfs->lstnSocket != -1)
 555         close(lpwfs->lstnSocket);
 556
 557     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 558     {
 559         INTERNET_ASYNC_RESULT iar;
 560
 561         if (hFindNext)
 562         {
 563             iar.dwResult = (DWORD)hFindNext;
 564             iar.dwError = ERROR_SUCCESS;
 565             hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
 566                 &iar, sizeof(INTERNET_ASYNC_RESULT));
 567         }
 568
 569         iar.dwResult = (DWORD)hFindNext;
 570         iar.dwError = hFindNext ? ERROR_SUCCESS : INTERNET_GetLastError();
 571         hIC->lpfnStatusCB(hConnect, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 572             &iar, sizeof(INTERNET_ASYNC_RESULT));
 573     }
 574
 575     return (HINTERNET)hFindNext;
 576 }
 577
 578
 579 /***********************************************************************
 580  *           FtpGetCurrentDirectoryA (WININET.@)
 581  *
 582  * Retrieves the current directory
 583  *
 584  * RETURNS
 585  *    TRUE on success
 586  *    FALSE on failure
 587  *
 588  */
 589 BOOL WINAPI FtpGetCurrentDirectoryA(HINTERNET hFtpSession, LPSTR lpszCurrentDirectory,
 590         LPDWORD lpdwCurrentDirectory)
 591 {
 592     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
 593     LPWININETAPPINFOA hIC = NULL;
 594
 595     TRACE("len(%ld)\n", *lpdwCurrentDirectory);
 596
 597     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 598     {
 599         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 600         return FALSE;
 601     }
 602
 603     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 604     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 605     {
 606         WORKREQUEST workRequest;
 607
 608         workRequest.asyncall =  FTPGETCURRENTDIRECTORYA;
 609         workRequest.HFTPSESSION = (DWORD)hFtpSession;
 610         workRequest.LPSZDIRECTORY = (DWORD)lpszCurrentDirectory;
 611         workRequest.LPDWDIRECTORY = (DWORD)lpdwCurrentDirectory;
 612
 613         return INTERNET_AsyncCall(&workRequest);
 614     }
 615     else
 616     {
 617         return FTP_FtpGetCurrentDirectoryA(hFtpSession, lpszCurrentDirectory,
 618                 lpdwCurrentDirectory);
 619     }
 620 }
 621
 622
 623 /***********************************************************************
 624  *           FTP_FtpGetCurrentDirectoryA (Internal)
 625  *
 626  * Retrieves the current directory
 627  *
 628  * RETURNS
 629  *    TRUE on success
 630  *    FALSE on failure
 631  *
 632  */
 633 BOOL WINAPI FTP_FtpGetCurrentDirectoryA(HINTERNET hFtpSession, LPSTR lpszCurrentDirectory,
 634         LPDWORD lpdwCurrentDirectory)
 635 {
 636     INT nResCode;
 637     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
 638     LPWININETAPPINFOA hIC = NULL;
 639     DWORD bSuccess = FALSE;
 640
 641     TRACE("len(%ld)\n", *lpdwCurrentDirectory);
 642
 643     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 644     {
 645         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 646         return FALSE;
 647     }
 648
 649     /* Clear any error information */
 650     INTERNET_SetLastError(0);
 651
 652     ZeroMemory(lpszCurrentDirectory, *lpdwCurrentDirectory);
 653
 654     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 655     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PWD, NULL,
 656         hIC->lpfnStatusCB, hFtpSession, lpwfs->hdr.dwContext))
 657         goto lend;
 658
 659     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 660         MAX_REPLY_LEN, hIC->lpfnStatusCB, hFtpSession, lpwfs->hdr.dwContext);
 661     if (nResCode)
 662     {
 663         if (nResCode == 257) /* Extract directory name */
 664         {
 665             INT firstpos, lastpos, len;
 666             LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
 667
 668             for (firstpos = 0, lastpos = 0; lpszResponseBuffer[lastpos]; lastpos++)
 669             {
 670                 if ('"' == lpszResponseBuffer[lastpos])
 671                 {
 672                     if (!firstpos)
 673                         firstpos = lastpos;
 674                     else
 675                         break;
 676                 }
 677             }
 678
 679             len = lastpos - firstpos - 1;
 680             strncpy(lpszCurrentDirectory, &lpszResponseBuffer[firstpos+1],
 681                 len < *lpdwCurrentDirectory ? len : *lpdwCurrentDirectory);
 682             *lpdwCurrentDirectory = len;
 683             bSuccess = TRUE;
 684         }
 685         else
 686             FTP_SetResponseError(nResCode);
 687     }
 688
 689 lend:
 690     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 691     {
 692         INTERNET_ASYNC_RESULT iar;
 693
 694         iar.dwResult = (DWORD)bSuccess;
 695         iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
 696         hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 697             &iar, sizeof(INTERNET_ASYNC_RESULT));
 698     }
 699
 700     return (DWORD) bSuccess;
 701 }
 702
 703 /***********************************************************************
 704  *           FtpOpenFileA (WININET.@)
 705  *
 706  * Open a remote file for writing or reading
 707  *
 708  * RETURNS
 709  *    HINTERNET handle on success
 710  *    NULL on failure
 711  *
 712  */
 713 INTERNETAPI HINTERNET WINAPI FtpOpenFileA(HINTERNET hFtpSession,
 714         LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
 715         DWORD dwContext)
 716 {
 717     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
 718     LPWININETAPPINFOA hIC = NULL;
 719
 720     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 721     {
 722         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 723         return FALSE;
 724     }
 725
 726     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 727     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 728     {
 729         WORKREQUEST workRequest;
 730
 731         workRequest.asyncall = FTPOPENFILEA;
 732         workRequest.HFTPSESSION = (DWORD)hFtpSession;
 733         workRequest.LPSZFILENAME = (DWORD)FTP_strdup(lpszFileName);
 734         workRequest.FDWACCESS = fdwAccess;
 735         workRequest.DWFLAGS = dwFlags;
 736         workRequest.DWCONTEXT = dwContext;
 737
 738         INTERNET_AsyncCall(&workRequest);
 739         return NULL;
 740     }
 741     else
 742     {
 743         return FTP_FtpOpenFileA(hFtpSession, lpszFileName, fdwAccess, dwFlags, dwContext);
 744     }
 745 }
 746
 747
 748 /***********************************************************************
 749  *           FTP_FtpOpenFileA (Internal)
 750  *
 751  * Open a remote file for writing or reading
 752  *
 753  * RETURNS
 754  *    HINTERNET handle on success
 755  *    NULL on failure
 756  *
 757  */
 758 HINTERNET FTP_FtpOpenFileA(HINTERNET hFtpSession,
 759         LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
 760         DWORD dwContext)
 761 {
 762     INT nDataSocket;
 763     BOOL bSuccess = FALSE;
 764     LPWININETFILE hFile = NULL;
 765     LPWININETAPPINFOA hIC = NULL;
 766     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
 767
 768     TRACE("\n");
 769
 770     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 771     {
 772         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 773         return FALSE;
 774     }
 775
 776     /* Clear any error information */
 777     INTERNET_SetLastError(0);
 778
 779     if (GENERIC_READ == fdwAccess)
 780     {
 781         /* Set up socket to retrieve data */
 782         bSuccess = FTP_SendRetrieve(lpwfs, lpszFileName, dwFlags);
 783     }
 784     else if (GENERIC_WRITE == fdwAccess)
 785     {
 786         /* Set up socket to send data */
 787         bSuccess = FTP_SendStore(lpwfs, lpszFileName, dwFlags);
 788     }
 789
 790     /* Get data socket to server */
 791     if (bSuccess && FTP_GetDataSocket(lpwfs, &nDataSocket))
 792     {
 793         hFile = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETFILE));
 794         hFile->hdr.htype = WH_HFILE;
 795         hFile->hdr.dwFlags = dwFlags;
 796         hFile->hdr.dwContext = dwContext;
 797         hFile->hdr.lpwhparent = hFtpSession;
 798         hFile->nDataSocket = nDataSocket;
 799     }
 800
 801     if (lpwfs->lstnSocket != -1)
 802         close(lpwfs->lstnSocket);
 803
 804     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 805     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 806     {
 807         INTERNET_ASYNC_RESULT iar;
 808
 809         if (hFile)
 810         {
 811             iar.dwResult = (DWORD)hFile;
 812             iar.dwError = ERROR_SUCCESS;
 813             hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
 814                 &iar, sizeof(INTERNET_ASYNC_RESULT));
 815         }
 816
 817         iar.dwResult = (DWORD)bSuccess;
 818         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 819         hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 820             &iar, sizeof(INTERNET_ASYNC_RESULT));
 821     }
 822
 823     return (HINTERNET)hFile;
 824 }
 825
 826
 827 /***********************************************************************
 828  *           FtpGetFileA (WININET.@)
 829  *
 830  * Retrieve file from the FTP server
 831  *
 832  * RETURNS
 833  *    TRUE on success
 834  *    FALSE on failure
 835  *
 836  */
 837 BOOL WINAPI FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile,
 838         BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
 839         DWORD dwContext)
 840 {
 841     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hInternet;
 842     LPWININETAPPINFOA hIC = NULL;
 843
 844     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 845     {
 846         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 847         return FALSE;
 848     }
 849
 850     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 851     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 852     {
 853         WORKREQUEST workRequest;
 854
 855         workRequest.asyncall = FTPGETFILEA;
 856         workRequest.HFTPSESSION = (DWORD)hInternet;
 857         workRequest.LPSZREMOTEFILE = (DWORD)FTP_strdup(lpszRemoteFile);
 858         workRequest.LPSZNEWFILE = (DWORD)FTP_strdup(lpszNewFile);
 859         workRequest.DWLOCALFLAGSATTRIBUTE  = dwLocalFlagsAttribute;
 860         workRequest.FFAILIFEXISTS = (DWORD)fFailIfExists;
 861         workRequest.DWFLAGS = dwInternetFlags;
 862         workRequest.DWCONTEXT = dwContext;
 863
 864         return INTERNET_AsyncCall(&workRequest);
 865     }
 866     else
 867     {
 868         return FTP_FtpGetFileA(hInternet, lpszRemoteFile, lpszNewFile,
 869            fFailIfExists, dwLocalFlagsAttribute, dwInternetFlags, dwContext);
 870     }
 871 }
 872
 873
 874 /***********************************************************************
 875  *           FTP_FtpGetFileA (Internal)
 876  *
 877  * Retrieve file from the FTP server
 878  *
 879  * RETURNS
 880  *    TRUE on success
 881  *    FALSE on failure
 882  *
 883  */
 884 BOOL WINAPI FTP_FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile,
 885         BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
 886         DWORD dwContext)
 887 {
 888     DWORD nBytes;
 889     BOOL bSuccess = FALSE;
 890     HANDLE hFile;
 891     LPWININETAPPINFOA hIC = NULL;
 892     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hInternet;
 893
 894     TRACE("lpszRemoteFile(%s) lpszNewFile(%s)\n", lpszRemoteFile, lpszNewFile);
 895     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 896     {
 897         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 898         return FALSE;
 899     }
 900
 901     /* Clear any error information */
 902     INTERNET_SetLastError(0);
 903
 904     /* Ensure we can write to lpszNewfile by opening it */
 905     hFile = CreateFileA(lpszNewFile, GENERIC_WRITE, 0, 0, fFailIfExists ?
 906         CREATE_NEW : CREATE_ALWAYS, dwLocalFlagsAttribute, 0);
 907     if (INVALID_HANDLE_VALUE == hFile)
 908         goto lend;
 909
 910     /* Set up socket to retrieve data */
 911     nBytes = FTP_SendRetrieve(lpwfs, lpszRemoteFile, dwInternetFlags);
 912
 913     if (nBytes > 0)
 914     {
 915         INT nDataSocket;
 916
 917         /* Get data socket to server */
 918         if (FTP_GetDataSocket(lpwfs, &nDataSocket))
 919         {
 920             INT nResCode;
 921
 922             /* Receive data */
 923             FTP_RetrieveFileData(lpwfs, nDataSocket, nBytes, hFile);
 924             nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
 925             MAX_REPLY_LEN, 0, 0, 0);
 926             if (nResCode)
 927             {
 928                 if (nResCode == 226)
 929                     bSuccess = TRUE;
 930                 else
 931                     FTP_SetResponseError(nResCode);
 932             }
 933             close(nDataSocket);
 934         }
 935     }
 936
 937 lend:
 938     if (lpwfs->lstnSocket != -1)
 939         close(lpwfs->lstnSocket);
 940
 941     if (hFile)
 942         CloseHandle(hFile);
 943
 944     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 945     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
 946     {
 947         INTERNET_ASYNC_RESULT iar;
 948
 949         iar.dwResult = (DWORD)bSuccess;
 950         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 951         hIC->lpfnStatusCB(hInternet, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 952             &iar, sizeof(INTERNET_ASYNC_RESULT));
 953     }
 954
 955     return bSuccess;
 956 }
 957
 958
 959 /***********************************************************************
 960  *           FtpDeleteFileA  (WININET.@)
 961  *
 962  * Delete a file on the ftp server
 963  *
 964  * RETURNS
 965  *    TRUE on success
 966  *    FALSE on failure
 967  *
 968  */
 969 BOOL WINAPI FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName)
 970 {
 971     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
 972     LPWININETAPPINFOA hIC = NULL;
 973
 974     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 975     {
 976         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 977         return FALSE;
 978     }
 979
 980     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
 981     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 982     {
 983         WORKREQUEST workRequest;
 984
 985         workRequest.asyncall = FTPRENAMEFILEA;
 986         workRequest.HFTPSESSION = (DWORD)hFtpSession;
 987         workRequest.LPSZFILENAME = (DWORD)FTP_strdup(lpszFileName);
 988
 989         return INTERNET_AsyncCall(&workRequest);
 990     }
 991     else
 992     {
 993         return FTP_FtpDeleteFileA(hFtpSession, lpszFileName);
 994     }
 995 }
 996
 997
 998 /***********************************************************************
 999  *           FTP_FtpDeleteFileA  (Internal)
1000  *
1001  * Delete a file on the ftp server
1002  *
1003  * RETURNS
1004  *    TRUE on success
1005  *    FALSE on failure
1006  *
1007  */
1008 BOOL FTP_FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName)
1009 {
1010     INT nResCode;
1011     BOOL bSuccess = FALSE;
1012     LPWININETAPPINFOA hIC = NULL;
1013     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
1014
1015     TRACE("0x%08lx\n", (ULONG) hFtpSession);
1016     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
1017     {
1018         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1019         return FALSE;
1020     }
1021
1022     /* Clear any error information */
1023     INTERNET_SetLastError(0);
1024
1025     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_DELE, lpszFileName, 0, 0, 0))
1026         goto lend;
1027
1028     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1029         MAX_REPLY_LEN, 0, 0, 0);
1030     if (nResCode)
1031     {
1032         if (nResCode == 250)
1033             bSuccess = TRUE;
1034         else
1035             FTP_SetResponseError(nResCode);
1036     }
1037 lend:
1038     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
1039     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
1040     {
1041         INTERNET_ASYNC_RESULT iar;
1042
1043         iar.dwResult = (DWORD)bSuccess;
1044         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1045         hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1046             &iar, sizeof(INTERNET_ASYNC_RESULT));
1047     }
1048
1049     return bSuccess;
1050 }
1051
1052
1053 /***********************************************************************
1054  *           FtpRemoveDirectoryA  (WININET.@)
1055  *
1056  * Remove a directory on the ftp server
1057  *
1058  * RETURNS
1059  *    TRUE on success
1060  *    FALSE on failure
1061  *
1062  */
1063 BOOL WINAPI FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory)
1064 {
1065     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
1066     LPWININETAPPINFOA hIC = NULL;
1067
1068     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
1069     {
1070         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1071         return FALSE;
1072     }
1073
1074     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
1075     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1076     {
1077         WORKREQUEST workRequest;
1078
1079         workRequest.asyncall = FTPREMOVEDIRECTORYA;
1080         workRequest.HFTPSESSION = (DWORD)hFtpSession;
1081         workRequest.LPSZDIRECTORY = (DWORD)FTP_strdup(lpszDirectory);
1082
1083         return INTERNET_AsyncCall(&workRequest);
1084     }
1085     else
1086     {
1087         return FTP_FtpRemoveDirectoryA(hFtpSession, lpszDirectory);
1088     }
1089 }
1090
1091
1092 /***********************************************************************
1093  *           FTP_FtpRemoveDirectoryA  (Internal)
1094  *
1095  * Remove a directory on the ftp server
1096  *
1097  * RETURNS
1098  *    TRUE on success
1099  *    FALSE on failure
1100  *
1101  */
1102 BOOL FTP_FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory)
1103 {
1104     INT nResCode;
1105     BOOL bSuccess = FALSE;
1106     LPWININETAPPINFOA hIC = NULL;
1107     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
1108
1109     TRACE("\n");
1110     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
1111     {
1112         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1113         return FALSE;
1114     }
1115
1116     /* Clear any error information */
1117     INTERNET_SetLastError(0);
1118
1119     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RMD, lpszDirectory, 0, 0, 0))
1120         goto lend;
1121
1122     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1123         MAX_REPLY_LEN, 0, 0, 0);
1124     if (nResCode)
1125     {
1126         if (nResCode == 250)
1127             bSuccess = TRUE;
1128         else
1129             FTP_SetResponseError(nResCode);
1130     }
1131
1132 lend:
1133     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
1134     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
1135     {
1136         INTERNET_ASYNC_RESULT iar;
1137
1138         iar.dwResult = (DWORD)bSuccess;
1139         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1140         hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1141             &iar, sizeof(INTERNET_ASYNC_RESULT));
1142     }
1143
1144     return bSuccess;
1145 }
1146
1147
1148 /***********************************************************************
1149  *           FtpRenameFileA  (WININET.@)
1150  *
1151  * Rename a file on the ftp server
1152  *
1153  * RETURNS
1154  *    TRUE on success
1155  *    FALSE on failure
1156  *
1157  */
1158 BOOL WINAPI FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
1159 {
1160     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
1161     LPWININETAPPINFOA hIC = NULL;
1162
1163     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
1164     {
1165         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1166         return FALSE;
1167     }
1168
1169     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
1170     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1171     {
1172         WORKREQUEST workRequest;
1173
1174         workRequest.asyncall = FTPRENAMEFILEA;
1175         workRequest.HFTPSESSION = (DWORD)hFtpSession;
1176         workRequest.LPSZSRCFILE = (DWORD)FTP_strdup(lpszSrc);
1177         workRequest.LPSZDESTFILE = (DWORD)FTP_strdup(lpszDest);
1178
1179         return INTERNET_AsyncCall(&workRequest);
1180     }
1181     else
1182     {
1183         return FTP_FtpRenameFileA(hFtpSession, lpszSrc, lpszDest);
1184     }
1185 }
1186
1187 /***********************************************************************
1188  *           FTP_FtpRenameFileA  (Internal)
1189  *
1190  * Rename a file on the ftp server
1191  *
1192  * RETURNS
1193  *    TRUE on success
1194  *    FALSE on failure
1195  *
1196  */
1197 BOOL FTP_FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
1198 {
1199     INT nResCode;
1200     BOOL bSuccess = FALSE;
1201     LPWININETAPPINFOA hIC = NULL;
1202     LPWININETFTPSESSIONA lpwfs = (LPWININETFTPSESSIONA) hFtpSession;
1203
1204     TRACE("\n");
1205     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
1206     {
1207         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1208         return FALSE;
1209     }
1210
1211     /* Clear any error information */
1212     INTERNET_SetLastError(0);
1213
1214     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNFR, lpszSrc, 0, 0, 0))
1215         goto lend;
1216
1217     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket,
1218         INTERNET_GetResponseBuffer(), MAX_REPLY_LEN, 0, 0, 0);
1219     if (nResCode == 350)
1220     {
1221         if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNTO, lpszDest, 0, 0, 0))
1222             goto lend;
1223
1224         nResCode = FTP_ReceiveResponse(lpwfs->sndSocket,
1225                     INTERNET_GetResponseBuffer(), MAX_REPLY_LEN, 0, 0, 0);
1226     }
1227
1228     if (nResCode == 250)
1229         bSuccess = TRUE;
1230     else
1231         FTP_SetResponseError(nResCode);
1232
1233 lend:
1234     hIC = (LPWININETAPPINFOA) lpwfs->hdr.lpwhparent;
1235     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
1236     {
1237         INTERNET_ASYNC_RESULT iar;
1238
1239         iar.dwResult = (DWORD)bSuccess;
1240         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1241         hIC->lpfnStatusCB(hFtpSession, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1242             &iar, sizeof(INTERNET_ASYNC_RESULT));
1243     }
1244
1245     return bSuccess;
1246 }
1247
1248
1249 /***********************************************************************
1250  *           FTP_Connect (internal)
1251  *
1252  * Connect to a ftp server
1253  *
1254  * RETURNS
1255  *   HINTERNET a session handle on success
1256  *   NULL on failure
1257  *
1258  */
1259
1260 HINTERNET FTP_Connect(HINTERNET hInternet, LPCSTR lpszServerName,
1261         INTERNET_PORT nServerPort, LPCSTR lpszUserName,
1262         LPCSTR lpszPassword, DWORD dwFlags, DWORD dwContext)
1263 {
1264     struct sockaddr_in socketAddr;
1265     struct hostent *phe = NULL;
1266     INT nsocket = -1, sock_namelen;
1267     LPWININETAPPINFOA hIC = NULL;
1268     BOOL bSuccess = FALSE;
1269     LPWININETFTPSESSIONA lpwfs = NULL;
1270
1271     TRACE("0x%08lx  Server(%s) Port(%d) User(%s) Paswd(%s)\n",
1272             (ULONG) hInternet, lpszServerName,
1273             nServerPort, lpszUserName, lpszPassword);
1274
1275     if (((LPWININETHANDLEHEADER)hInternet)->htype != WH_HINIT)
1276         goto lerror;
1277
1278     hIC = (LPWININETAPPINFOA) hInternet;
1279
1280     if (NULL == lpszUserName && NULL != lpszPassword)
1281     {
1282         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_USER_NAME);
1283         goto lerror;
1284     }
1285
1286     if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
1287         nServerPort = INTERNET_DEFAULT_FTP_PORT;
1288
1289     if (hIC->lpfnStatusCB)
1290         hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_RESOLVING_NAME,
1291             (LPSTR) lpszServerName, strlen(lpszServerName));
1292
1293     if (!GetAddress(lpszServerName, nServerPort, &phe, &socketAddr))
1294     {
1295         INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
1296         goto lerror;
1297     }
1298
1299     if (hIC->lpfnStatusCB)
1300         hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_NAME_RESOLVED,
1301             (LPSTR) lpszServerName, strlen(lpszServerName));
1302
1303     nsocket = socket(AF_INET,SOCK_STREAM,0);
1304     if (nsocket == -1)
1305     {
1306         INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
1307         goto lerror;
1308     }
1309
1310     if (hIC->lpfnStatusCB)
1311         hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
1312              &socketAddr, sizeof(struct sockaddr_in));
1313
1314     if (connect(nsocket, (struct sockaddr *)&socketAddr, sizeof(socketAddr)) < 0)
1315     {
1316         ERR("Unable to connect (%s)\n", strerror(errno));
1317         INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
1318     }
1319     else
1320     {
1321         TRACE("Connected to server\n");
1322         if (hIC->lpfnStatusCB)
1323             hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
1324                 &socketAddr, sizeof(struct sockaddr_in));
1325
1326         lpwfs = HeapAlloc(GetProcessHeap(), 0, sizeof(WININETFTPSESSIONA));
1327         if (NULL == lpwfs)
1328         {
1329             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1330             goto lerror;
1331         }
1332
1333         lpwfs->hdr.htype = WH_HFTPSESSION;
1334         lpwfs->hdr.dwFlags = dwFlags;
1335         lpwfs->hdr.dwContext = dwContext;
1336         lpwfs->hdr.lpwhparent = (LPWININETHANDLEHEADER)hInternet;
1337         lpwfs->sndSocket = nsocket;
1338         sock_namelen = sizeof(lpwfs->socketAddress);
1339         getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
1340         lpwfs->phostent = phe;
1341
1342         if (NULL == lpszUserName)
1343         {
1344             lpwfs->lpszUserName = FTP_strdup("anonymous");
1345             lpwfs->lpszPassword = FTP_strdup("user@server");
1346         }
1347         else
1348         {
1349             lpwfs->lpszUserName = FTP_strdup(lpszUserName);
1350             lpwfs->lpszPassword = FTP_strdup(lpszPassword);
1351         }
1352
1353         if (FTP_ConnectToHost(lpwfs))
1354         {
1355             if (hIC->lpfnStatusCB)
1356             {
1357                 INTERNET_ASYNC_RESULT iar;
1358
1359                 iar.dwResult = (DWORD)lpwfs;
1360                 iar.dwError = ERROR_SUCCESS;
1361
1362                 hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_HANDLE_CREATED,
1363                     &iar, sizeof(INTERNET_ASYNC_RESULT));
1364             }
1365             TRACE("Successfully logged into server\n");
1366             bSuccess = TRUE;
1367         }
1368     }
1369
1370 lerror:
1371     if (!bSuccess && nsocket == -1)
1372         close(nsocket);
1373
1374     if (!bSuccess && lpwfs)
1375     {
1376         HeapFree(GetProcessHeap(), 0, lpwfs);
1377         lpwfs = NULL;
1378     }
1379
1380     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
1381     {
1382         INTERNET_ASYNC_RESULT iar;
1383
1384         iar.dwResult = (DWORD)lpwfs;
1385         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1386         hIC->lpfnStatusCB(hInternet, dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1387             &iar, sizeof(INTERNET_ASYNC_RESULT));
1388     }
1389
1390     return (HINTERNET) lpwfs;
1391 }
1392
1393
1394 /***********************************************************************
1395  *           FTP_ConnectToHost (internal)
1396  *
1397  * Connect to a ftp server
1398  *
1399  * RETURNS
1400  *   TRUE on success
1401  *   NULL on failure
1402  *
1403  */
1404 BOOL FTP_ConnectToHost(LPWININETFTPSESSIONA lpwfs)
1405 {
1406     INT nResCode;
1407     BOOL bSuccess = FALSE;
1408
1409     TRACE("\n");
1410     FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(), MAX_REPLY_LEN, 0, 0, 0);
1411
1412     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
1413         goto lend;
1414
1415     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1416         MAX_REPLY_LEN, 0, 0, 0);
1417     if (nResCode)
1418     {
1419         /* Login successful... */
1420         if (nResCode == 230)
1421             bSuccess = TRUE;
1422         /* User name okay, need password... */
1423         else if (nResCode == 331)
1424             bSuccess = FTP_SendPassword(lpwfs);
1425         /* Need account for login... */
1426         else if (nResCode == 332)
1427             bSuccess = FTP_SendAccount(lpwfs);
1428         else
1429             FTP_SetResponseError(nResCode);
1430     }
1431
1432     TRACE("Returning %d\n", bSuccess);
1433 lend:
1434     return bSuccess;
1435 }
1436
1437
1438 /***********************************************************************
1439  *           FTP_SendCommand (internal)
1440  *
1441  * Send command to server
1442  *
1443  * RETURNS
1444  *   TRUE on success
1445  *   NULL on failure
1446  *
1447  */
1448 BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
1449         INTERNET_STATUS_CALLBACK lpfnStatusCB, HINTERNET hHandle, DWORD dwContext)
1450 {
1451         DWORD len;
1452         CHAR *buf;
1453         DWORD nBytesSent = 0;
1454         DWORD nRC = 0;
1455         BOOL bParamHasLen;
1456
1457         TRACE("%d: (%s) %d\n", ftpCmd, lpszParam, nSocket);
1458
1459         if (lpfnStatusCB)
1460                 lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
1461
1462         bParamHasLen = lpszParam && strlen(lpszParam) > 0;
1463         len = (bParamHasLen ? strlen(lpszParam) : -1) + strlen(szFtpCommands[ftpCmd]) +
1464             strlen(szCRLF)+ 1;
1465         if (NULL == (buf = HeapAlloc(GetProcessHeap(), 0, len+1)))
1466         {
1467             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1468             return FALSE;
1469         }
1470         sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], bParamHasLen ? " " : "",
1471                 bParamHasLen ? lpszParam : "", szCRLF);
1472
1473         TRACE("Sending (%s) len(%ld)\n", buf, len);
1474         while((nBytesSent < len) && (nRC != -1))
1475         {
1476                 nRC = send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
1477                 nBytesSent += nRC;
1478         }
1479
1480         HeapFree(GetProcessHeap(), 0, (LPVOID)buf);
1481
1482         if (lpfnStatusCB)
1483                 lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_REQUEST_SENT,
1484                         &nBytesSent, sizeof(DWORD));
1485
1486         TRACE("Sent %ld bytes\n", nBytesSent);
1487         return (nRC != -1);
1488 }
1489
1490
1491 /***********************************************************************
1492  *           FTP_ReceiveResponse (internal)
1493  *
1494  * Receive response from server
1495  *
1496  * RETURNS
1497  *   Reply code on success
1498  *   0 on failure
1499  *
1500  */
1501
1502 INT FTP_ReceiveResponse(INT nSocket, LPSTR lpszResponse, DWORD dwResponse,
1503         INTERNET_STATUS_CALLBACK lpfnStatusCB, HINTERNET hHandle, DWORD dwContext)
1504 {
1505     DWORD nRecv;
1506     INT rc = 0;
1507     char firstprefix[5];
1508     BOOL multiline = FALSE;
1509
1510
1511     TRACE("socket(%d) \n", nSocket);
1512
1513     if (lpfnStatusCB)
1514         lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
1515
1516     while(1)
1517     {
1518         nRecv = dwResponse;
1519         if (!INTERNET_GetNextLine(nSocket, lpszResponse, &nRecv))
1520             goto lerror;
1521
1522         if (nRecv >= 3)
1523         {
1524             if(!multiline)
1525             {
1526                 if(lpszResponse[3] != '-')
1527                     break;
1528                 else
1529                 {  /* Start of multiline repsonse.  Loop until we get "nnn " */
1530                     multiline = TRUE;
1531                     memcpy(firstprefix, lpszResponse, 3);
1532                     firstprefix[3] = ' ';
1533                     firstprefix[4] = '\0';
1534                 }
1535             }
1536             else
1537             {
1538                 if(!memcmp(firstprefix, lpszResponse, 4))
1539                     break;
1540             }
1541         }
1542     }
1543
1544     if (nRecv >= 3)
1545     {
1546         lpszResponse[nRecv] = '\0';
1547         rc = atoi(lpszResponse);
1548
1549         if (lpfnStatusCB)
1550             lpfnStatusCB(hHandle, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
1551                     &nRecv, sizeof(DWORD));
1552     }
1553
1554 lerror:
1555     TRACE("return %d\n", rc);
1556     return rc;
1557 }
1558
1559
1560 /***********************************************************************
1561  *           FTP_SendPassword (internal)
1562  *
1563  * Send password to ftp server
1564  *
1565  * RETURNS
1566  *   TRUE on success
1567  *   NULL on failure
1568  *
1569  */
1570 BOOL FTP_SendPassword(LPWININETFTPSESSIONA lpwfs)
1571 {
1572     INT nResCode;
1573     BOOL bSuccess = FALSE;
1574
1575     TRACE("\n");
1576     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
1577         goto lend;
1578
1579     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1580         MAX_REPLY_LEN, 0, 0, 0);
1581     if (nResCode)
1582     {
1583         TRACE("Received reply code %d\n", nResCode);
1584         /* Login successful... */
1585         if (nResCode == 230)
1586             bSuccess = TRUE;
1587         /* Command not implemented, superfluous at the server site... */
1588         /* Need account for login... */
1589         else if (nResCode == 332)
1590             bSuccess = FTP_SendAccount(lpwfs);
1591         else
1592             FTP_SetResponseError(nResCode);
1593     }
1594
1595 lend:
1596     TRACE("Returning %d\n", bSuccess);
1597     return bSuccess;
1598 }
1599
1600
1601 /***********************************************************************
1602  *           FTP_SendAccount (internal)
1603  *
1604  *
1605  *
1606  * RETURNS
1607  *   TRUE on success
1608  *   FALSE on failure
1609  *
1610  */
1611 BOOL FTP_SendAccount(LPWININETFTPSESSIONA lpwfs)
1612 {
1613     INT nResCode;
1614     BOOL bSuccess = FALSE;
1615
1616     TRACE("\n");
1617     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, NOACCOUNT, 0, 0, 0))
1618         goto lend;
1619
1620     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1621         MAX_REPLY_LEN, 0,  0, 0);
1622     if (nResCode)
1623         bSuccess = TRUE;
1624     else
1625         FTP_SetResponseError(nResCode);
1626
1627 lend:
1628     return bSuccess;
1629 }
1630
1631
1632 /***********************************************************************
1633  *           FTP_SendStore (internal)
1634  *
1635  * Send request to upload file to ftp server
1636  *
1637  * RETURNS
1638  *   TRUE on success
1639  *   FALSE on failure
1640  *
1641  */
1642 BOOL FTP_SendStore(LPWININETFTPSESSIONA lpwfs, LPCSTR lpszRemoteFile, DWORD dwType)
1643 {
1644     INT nResCode;
1645     BOOL bSuccess = FALSE;
1646
1647     TRACE("\n");
1648     if (!FTP_InitListenSocket(lpwfs))
1649         goto lend;
1650
1651     if (!FTP_SendType(lpwfs, dwType))
1652         goto lend;
1653
1654     if (!FTP_SendPortOrPasv(lpwfs))
1655         goto lend;
1656
1657     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
1658             goto lend;
1659     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1660        MAX_REPLY_LEN, 0, 0, 0);
1661     if (nResCode)
1662     {
1663         if (nResCode == 150)
1664             bSuccess = TRUE;
1665         else
1666             FTP_SetResponseError(nResCode);
1667     }
1668
1669 lend:
1670     if (!bSuccess && lpwfs->lstnSocket != -1)
1671     {
1672         close(lpwfs->lstnSocket);
1673         lpwfs->lstnSocket = -1;
1674     }
1675
1676     return bSuccess;
1677 }
1678
1679
1680 /***********************************************************************
1681  *           FTP_InitListenSocket (internal)
1682  *
1683  * Create a socket to listen for server response
1684  *
1685  * RETURNS
1686  *   TRUE on success
1687  *   FALSE on failure
1688  *
1689  */
1690 BOOL FTP_InitListenSocket(LPWININETFTPSESSIONA lpwfs)
1691 {
1692     BOOL bSuccess = FALSE;
1693     size_t namelen = sizeof(struct sockaddr_in);
1694
1695     TRACE("\n");
1696
1697     lpwfs->lstnSocket = socket(PF_INET, SOCK_STREAM, 0);
1698     if (lpwfs->lstnSocket == -1)
1699     {
1700         TRACE("Unable to create listening socket\n");
1701             goto lend;
1702     }
1703
1704     /* We obtain our ip addr from the name of the command channel socket */
1705     lpwfs->lstnSocketAddress = lpwfs->socketAddress;
1706
1707     /* and get the system to assign us a port */
1708     lpwfs->lstnSocketAddress.sin_port = htons((u_short) 0);
1709
1710     if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(struct sockaddr_in)) == -1)
1711     {
1712         TRACE("Unable to bind socket\n");
1713         goto lend;
1714     }
1715
1716     if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
1717     {
1718         TRACE("listen failed\n");
1719         goto lend;
1720     }
1721
1722     if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
1723         bSuccess = TRUE;
1724
1725 lend:
1726     if (!bSuccess && lpwfs->lstnSocket == -1)
1727     {
1728         close(lpwfs->lstnSocket);
1729         lpwfs->lstnSocket = -1;
1730     }
1731
1732     return bSuccess;
1733 }
1734
1735
1736 /***********************************************************************
1737  *           FTP_SendType (internal)
1738  *
1739  * Tell server type of data being transfered
1740  *
1741  * RETURNS
1742  *   TRUE on success
1743  *   FALSE on failure
1744  *
1745  * W98SE doesn't cache the type that's currently set
1746  * (i.e. it sends it always),
1747  * so we probably don't want to do that either.
1748  */
1749 BOOL FTP_SendType(LPWININETFTPSESSIONA lpwfs, DWORD dwType)
1750 {
1751     INT nResCode;
1752     CHAR type[2] = { "I\0" };
1753     BOOL bSuccess = FALSE;
1754
1755     TRACE("\n");
1756     if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
1757         *type = 'A';
1758
1759     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
1760         goto lend;
1761
1762     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1763         MAX_REPLY_LEN, 0, 0, 0)/100;
1764     if (nResCode)
1765     {
1766         if (nResCode == 2)
1767             bSuccess = TRUE;
1768         else
1769             FTP_SetResponseError(nResCode);
1770     }
1771
1772 lend:
1773     return bSuccess;
1774 }
1775
1776
1777 /***********************************************************************
1778  *           FTP_SendPort (internal)
1779  *
1780  * Tell server which port to use
1781  *
1782  * RETURNS
1783  *   TRUE on success
1784  *   FALSE on failure
1785  *
1786  */
1787 BOOL FTP_SendPort(LPWININETFTPSESSIONA lpwfs)
1788 {
1789     INT nResCode;
1790     CHAR szIPAddress[64];
1791     BOOL bSuccess = FALSE;
1792     TRACE("\n");
1793
1794     sprintf(szIPAddress, "%d,%d,%d,%d,%d,%d",
1795          lpwfs->lstnSocketAddress.sin_addr.s_addr&0x000000FF,
1796         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x0000FF00)>>8,
1797         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x00FF0000)>>16,
1798         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0xFF000000)>>24,
1799         lpwfs->lstnSocketAddress.sin_port & 0xFF,
1800         (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
1801
1802     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
1803         goto lend;
1804
1805     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1806         MAX_REPLY_LEN,0, 0, 0);
1807     if (nResCode)
1808     {
1809         if (nResCode == 200)
1810             bSuccess = TRUE;
1811         else
1812             FTP_SetResponseError(nResCode);
1813     }
1814
1815 lend:
1816     return bSuccess;
1817 }
1818
1819
1820 /***********************************************************************
1821  *           FTP_DoPassive (internal)
1822  *
1823  * Tell server that we want to do passive transfers
1824  * and connect data socket
1825  *
1826  * RETURNS
1827  *   TRUE on success
1828  *   FALSE on failure
1829  *
1830  */
1831 BOOL FTP_DoPassive(LPWININETFTPSESSIONA lpwfs)
1832 {
1833     INT nResCode;
1834     BOOL bSuccess = FALSE;
1835
1836     TRACE("\n");
1837     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
1838         goto lend;
1839
1840     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
1841         MAX_REPLY_LEN,0, 0, 0);
1842     if (nResCode)
1843     {
1844         if (nResCode == 227)
1845         {
1846             LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
1847             LPSTR p;
1848             int f[6];
1849             int i;
1850             char *pAddr, *pPort;
1851             INT nsocket = -1;
1852             struct sockaddr_in dataSocketAddress;
1853
1854             p = lpszResponseBuffer+4; /* skip status code */
1855
1856             /* do a very strict check; we can improve that later. */
1857
1858             if (strncmp(p, "Entering Passive Mode", 21))
1859             {
1860                 ERR("unknown response '%.*s', aborting\n", 21, p);
1861                 goto lend;
1862             }
1863             p += 21; /* skip string */
1864             if ((*p++ != ' ') || (*p++ != '('))
1865             {
1866                 ERR("unknown response format, aborting\n");
1867                 goto lend;
1868             }
1869
1870             if (sscanf(p, "%d,%d,%d,%d,%d,%d",  &f[0], &f[1], &f[2], &f[3],
1871                                                 &f[4], &f[5]) != 6)
1872             {
1873                 ERR("unknown response address format '%s', aborting\n", p);
1874                 goto lend;
1875             }
1876             for (i=0; i < 6; i++)
1877                 f[i] = f[i] & 0xff;
1878
1879             dataSocketAddress = lpwfs->socketAddress;
1880             pAddr = (char *)&(dataSocketAddress.sin_addr.s_addr);
1881             pPort = (char *)&(dataSocketAddress.sin_port);
1882             pAddr[0] = f[0];
1883             pAddr[1] = f[1];
1884             pAddr[2] = f[2];
1885             pAddr[3] = f[3];
1886             pPort[0] = f[4];
1887             pPort[1] = f[5];
1888
1889             nsocket = socket(AF_INET,SOCK_STREAM,0);
1890             if (nsocket == -1)
1891                 goto lend;
1892
1893             if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
1894             {
1895                 ERR("can't connect passive FTP data port.\n");
1896                 goto lend;
1897             }
1898             lpwfs->pasvSocket = nsocket;
1899             bSuccess = TRUE;
1900         }
1901         else
1902             FTP_SetResponseError(nResCode);
1903     }
1904
1905 lend:
1906     return bSuccess;
1907 }
1908
1909
1910 BOOL FTP_SendPortOrPasv(LPWININETFTPSESSIONA lpwfs)
1911 {
1912     if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
1913     {
1914         if (!FTP_DoPassive(lpwfs))
1915             return FALSE;
1916     }
1917     else
1918     {
1919         if (!FTP_SendPort(lpwfs))
1920             return FALSE;
1921     }
1922     return TRUE;
1923 }
1924
1925
1926 /***********************************************************************
1927  *           FTP_GetDataSocket (internal)
1928  *
1929  * Either accepts an incoming data socket connection from the server
1930  * or just returns the already opened socket after a PASV command
1931  * in case of passive FTP.
1932  *
1933  *
1934  * RETURNS
1935  *   TRUE on success
1936  *   FALSE on failure
1937  *
1938  */
1939 BOOL FTP_GetDataSocket(LPWININETFTPSESSIONA lpwfs, LPINT nDataSocket)
1940 {
1941     struct sockaddr_in saddr;
1942     size_t addrlen = sizeof(struct sockaddr);
1943
1944     TRACE("\n");
1945     if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
1946     {
1947         *nDataSocket = lpwfs->pasvSocket;
1948     }
1949     else
1950     {
1951         *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
1952         close(lpwfs->lstnSocket);
1953         lpwfs->lstnSocket = -1;
1954     }
1955     return *nDataSocket != -1;
1956 }
1957
1958
1959 /***********************************************************************
1960  *           FTP_SendData (internal)
1961  *
1962  * Send data to the server
1963  *
1964  * RETURNS
1965  *   TRUE on success
1966  *   FALSE on failure
1967  *
1968  */
1969 BOOL FTP_SendData(LPWININETFTPSESSIONA lpwfs, INT nDataSocket, HANDLE hFile)
1970 {
1971     BY_HANDLE_FILE_INFORMATION fi;
1972     DWORD nBytesRead = 0;
1973     DWORD nBytesSent = 0;
1974     DWORD nTotalSent = 0;
1975     DWORD nBytesToSend, nLen, nRC = 1;
1976     time_t s_long_time, e_long_time;
1977     LONG nSeconds;
1978     CHAR *lpszBuffer;
1979
1980     TRACE("\n");
1981     lpszBuffer = HeapAlloc(GetProcessHeap(), 0, sizeof(CHAR)*DATA_PACKET_SIZE);
1982     memset(lpszBuffer, 0, sizeof(CHAR)*DATA_PACKET_SIZE);
1983
1984     /* Get the size of the file. */
1985     GetFileInformationByHandle(hFile, &fi);
1986     time(&s_long_time);
1987
1988     do
1989     {
1990         nBytesToSend = nBytesRead - nBytesSent;
1991
1992         if (nBytesToSend <= 0)
1993         {
1994             /* Read data from file. */
1995             nBytesSent = 0;
1996             if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
1997             ERR("Failed reading from file\n");
1998
1999             if (nBytesRead > 0)
2000                 nBytesToSend = nBytesRead;
2001             else
2002                 break;
2003         }
2004
2005         nLen = DATA_PACKET_SIZE < nBytesToSend ?
2006             DATA_PACKET_SIZE : nBytesToSend;
2007         nRC  = send(nDataSocket, lpszBuffer, nLen, 0);
2008
2009         if (nRC != -1)
2010         {
2011             nBytesSent += nRC;
2012             nTotalSent += nRC;
2013         }
2014
2015         /* Do some computation to display the status. */
2016         time(&e_long_time);
2017         nSeconds = e_long_time - s_long_time;
2018         if( nSeconds / 60 > 0 )
2019         {
2020             TRACE( "%ld bytes of %d bytes (%ld%%) in %ld min %ld sec estimated remainig time %ld sec\n",
2021             nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
2022             nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
2023         }
2024         else
2025         {
2026             TRACE( "%ld bytes of %d bytes (%ld%%) in %ld sec estimated remainig time %ld sec\n",
2027             nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
2028             (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
2029         }
2030     } while (nRC != -1);
2031
2032     TRACE("file transfer complete!\n");
2033
2034     if(lpszBuffer != NULL)
2035         HeapFree(GetProcessHeap(), 0, lpszBuffer);
2036
2037     return nTotalSent;
2038 }
2039
2040
2041 /***********************************************************************
2042  *           FTP_SendRetrieve (internal)
2043  *
2044  * Send request to retrieve a file
2045  *
2046  * RETURNS
2047  *   Number of bytes to be received on success
2048  *   0 on failure
2049  *
2050  */
2051 DWORD FTP_SendRetrieve(LPWININETFTPSESSIONA lpwfs, LPCSTR lpszRemoteFile, DWORD dwType)
2052 {
2053     INT nResCode;
2054     DWORD nResult = 0;
2055
2056     TRACE("\n");
2057     if (!FTP_InitListenSocket(lpwfs))
2058         goto lend;
2059
2060     if (!FTP_SendType(lpwfs, dwType))
2061         goto lend;
2062
2063     if (!FTP_SendPortOrPasv(lpwfs))
2064         goto lend;
2065
2066     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0))
2067         goto lend;
2068
2069     nResCode = FTP_ReceiveResponse(lpwfs->sndSocket, INTERNET_GetResponseBuffer(),
2070         MAX_REPLY_LEN, 0, 0, 0);
2071     if (nResCode)
2072     {
2073         if (nResCode == 125 || nResCode == 150)
2074         {
2075             /* Parse size of data to be retrieved */
2076             INT i, sizepos = -1;
2077             LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
2078             for (i = strlen(lpszResponseBuffer) - 1; i >= 0; i--)
2079             {
2080                 if ('(' == lpszResponseBuffer[i])
2081                 {
2082                     sizepos = i;
2083                     break;
2084                 }
2085             }
2086
2087             if (sizepos >= 0)
2088             {
2089                 nResult = atol(&lpszResponseBuffer[sizepos+1]);
2090                 TRACE("Waiting to receive %ld bytes\n", nResult);
2091             }
2092         }
2093     }
2094
2095 lend:
2096     if (0 == nResult && lpwfs->lstnSocket != -1)
2097     {
2098         close(lpwfs->lstnSocket);
2099         lpwfs->lstnSocket = -1;
2100     }
2101
2102     return nResult;
2103 }
2104
2105
2106 /***********************************************************************
2107  *           FTP_RetrieveData  (internal)
2108  *
2109  * Retrieve data from server
2110  *
2111  * RETURNS
2112  *   TRUE on success
2113  *   FALSE on failure
2114  *
2115  */
2116 BOOL FTP_RetrieveFileData(LPWININETFTPSESSIONA lpwfs, INT nDataSocket, DWORD nBytes, HANDLE hFile)
2117 {
2118     DWORD nBytesWritten;
2119     DWORD nBytesReceived = 0;
2120     INT nRC = 0;
2121     CHAR *lpszBuffer;
2122
2123     TRACE("\n");
2124
2125     if (INVALID_HANDLE_VALUE == hFile)
2126         return FALSE;
2127
2128     lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
2129     if (NULL == lpszBuffer)
2130     {
2131         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2132         return FALSE;
2133     }
2134
2135     while (nBytesReceived < nBytes && nRC != -1)
2136     {
2137         nRC = recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
2138         if (nRC != -1)
2139         {
2140             /* other side closed socket. */
2141             if (nRC == 0)
2142                 goto recv_end;
2143             WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
2144             nBytesReceived += nRC;
2145         }
2146
2147         TRACE("%ld bytes of %ld (%ld%%)\r", nBytesReceived, nBytes,
2148            nBytesReceived * 100 / nBytes);
2149     }
2150
2151     TRACE("Data transfer complete\n");
2152     if (NULL != lpszBuffer)
2153         HeapFree(GetProcessHeap(), 0, lpszBuffer);
2154
2155 recv_end:
2156     return  (nRC != -1);
2157 }
2158
2159
2160 /***********************************************************************
2161  *           FTP_CloseSessionHandle (internal)
2162  *
2163  * Deallocate session handle
2164  *
2165  * RETURNS
2166  *   TRUE on success
2167  *   FALSE on failure
2168  *
2169  */
2170 BOOL FTP_CloseSessionHandle(LPWININETFTPSESSIONA lpwfs)
2171 {
2172     if (lpwfs->sndSocket != -1)
2173         close(lpwfs->sndSocket);
2174
2175     if (lpwfs->lstnSocket != -1)
2176         close(lpwfs->lstnSocket);
2177
2178     if (lpwfs->lpszPassword)
2179         HeapFree(GetProcessHeap(), 0, lpwfs->lpszPassword);
2180
2181     if (lpwfs->lpszUserName)
2182         HeapFree(GetProcessHeap(), 0, lpwfs->lpszUserName);
2183
2184     HeapFree(GetProcessHeap(), 0, lpwfs);
2185
2186     return TRUE;
2187 }
2188
2189
2190 /***********************************************************************
2191  *           FTP_CloseSessionHandle (internal)
2192  *
2193  * Deallocate session handle
2194  *
2195  * RETURNS
2196  *   TRUE on success
2197  *   FALSE on failure
2198  *
2199  */
2200 BOOL FTP_CloseFindNextHandle(LPWININETFINDNEXTA lpwfn)
2201 {
2202     INT i;
2203
2204     TRACE("\n");
2205
2206     for (i = 0; i < lpwfn->size; i++)
2207     {
2208         if (NULL != lpwfn->lpafp[i].lpszName)
2209             HeapFree(GetProcessHeap(), 0, lpwfn->lpafp[i].lpszName);
2210     }
2211
2212     HeapFree(GetProcessHeap(), 0, lpwfn->lpafp);
2213     HeapFree(GetProcessHeap(), 0, lpwfn);
2214
2215     return TRUE;
2216 }
2217
2218
2219 /***********************************************************************
2220  *           FTP_ReceiveFileList (internal)
2221  *
2222  * Read file list from server
2223  *
2224  * RETURNS
2225  *   Handle to file list on success
2226  *   NULL on failure
2227  *
2228  */
2229 HINTERNET FTP_ReceiveFileList(LPWININETFTPSESSIONA lpwfs, INT nSocket,
2230         LPWIN32_FIND_DATAA lpFindFileData, DWORD dwContext)
2231 {
2232     DWORD dwSize = 0;
2233     LPFILEPROPERTIESA lpafp = NULL;
2234     LPWININETFINDNEXTA lpwfn = NULL;
2235
2236     TRACE("\n");
2237
2238     if (FTP_ParseDirectory(lpwfs, nSocket, &lpafp, &dwSize))
2239     {
2240         FTP_ConvertFileProp(lpafp, lpFindFileData);
2241
2242         lpwfn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETFINDNEXTA));
2243         if (NULL != lpwfn)
2244         {
2245             lpwfn->hdr.htype = WH_HFINDNEXT;
2246             lpwfn->hdr.lpwhparent = (LPWININETHANDLEHEADER)lpwfs;
2247             lpwfn->hdr.dwContext = dwContext;
2248             lpwfn->index = 1; /* Next index is 1 since we return index 0 */
2249             lpwfn->size = dwSize;
2250             lpwfn->lpafp = lpafp;
2251         }
2252     }
2253
2254     TRACE("Matched %ld files\n", dwSize);
2255     return (HINTERNET)lpwfn;
2256 }
2257
2258
2259 /***********************************************************************
2260  *           FTP_ConvertFileProp (internal)
2261  *
2262  * Converts FILEPROPERTIESA struct to WIN32_FIND_DATAA
2263  *
2264  * RETURNS
2265  *   TRUE on success
2266  *   FALSE on failure
2267  *
2268  */
2269 BOOL FTP_ConvertFileProp(LPFILEPROPERTIESA lpafp, LPWIN32_FIND_DATAA lpFindFileData)
2270 {
2271     BOOL bSuccess = FALSE;
2272
2273     ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
2274
2275     if (lpafp)
2276     {
2277         DWORD access = mktime(&lpafp->tmLastModified);
2278
2279         /* Not all fields are filled in */
2280         lpFindFileData->ftLastAccessTime.dwHighDateTime = HIWORD(access);
2281         lpFindFileData->ftLastAccessTime.dwLowDateTime  = LOWORD(access);
2282         lpFindFileData->nFileSizeHigh = HIWORD(lpafp->nSize);
2283         lpFindFileData->nFileSizeLow = LOWORD(lpafp->nSize);
2284
2285         if (lpafp->bIsDirectory)
2286             lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
2287
2288         if (lpafp->lpszName)
2289             strncpy(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
2290
2291         bSuccess = TRUE;
2292     }
2293
2294     return bSuccess;
2295 }
2296
2297
2298 /***********************************************************************
2299  *           FTP_ParseDirectory (internal)
2300  *
2301  * Parse string of directory information
2302  *
2303  * RETURNS
2304  *   TRUE on success
2305  *   FALSE on failure
2306  *
2307  * FIXME: - This function needs serious clea-up
2308  *        - We should consider both UNIX and NT list formats
2309  */
2310 #define MAX_MONTH_LEN 10
2311 #define MIN_LEN_DIR_ENTRY 15
2312
2313 BOOL FTP_ParseDirectory(LPWININETFTPSESSIONA lpwfs, INT nSocket, LPFILEPROPERTIESA *lpafp, LPDWORD dwfp)
2314 {
2315   /*
2316    * <Permissions> <NoLinks> <owner>   <group> <size> <date>  <time or year> <filename>
2317    *
2318    * For instance:
2319    * drwx--s---     2         pcarrier  ens     512    Sep 28  1995           pcarrier
2320    */
2321     CHAR* pszMinutes;
2322     CHAR* pszHour;
2323     time_t aTime;
2324     struct tm* apTM;
2325     CHAR pszMonth[MAX_MONTH_LEN];
2326     CHAR* pszMatch;
2327     BOOL bSuccess = TRUE;
2328     DWORD nBufLen = MAX_REPLY_LEN;
2329     LPFILEPROPERTIESA curFileProp = NULL;
2330     CHAR* pszLine  = NULL;
2331     CHAR* pszToken = NULL;
2332     INT nTokenToSkip = 3;
2333     INT nCount = 0;
2334     INT nSeconds = 0;
2335     INT nMinutes = 0;
2336     INT nHour    = 0;
2337     INT nDay     = 0;
2338     INT nMonth   = 0;
2339     INT nYear    = 0;
2340     INT sizeFilePropArray = 20;
2341     INT indexFilePropArray = 0;
2342
2343     TRACE("\n");
2344
2345     /* Allocate intial file properties array */
2346     *lpafp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FILEPROPERTIESA)*(sizeFilePropArray));
2347     if (NULL == lpafp)
2348     {
2349         bSuccess = FALSE;
2350         goto lend;
2351     }
2352
2353     while ((pszLine = INTERNET_GetNextLine(nSocket, INTERNET_GetResponseBuffer(), &nBufLen)) != NULL)
2354     {
2355         if (sizeFilePropArray <= indexFilePropArray)
2356         {
2357             LPFILEPROPERTIESA tmpafp;
2358
2359             sizeFilePropArray *= 2;
2360             tmpafp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *lpafp,
2361                 sizeof(FILEPROPERTIESA)*sizeFilePropArray);
2362             if (NULL == tmpafp)
2363             {
2364                 bSuccess = FALSE;
2365                 goto lend;
2366             }
2367
2368             *lpafp = tmpafp;
2369         }
2370
2371         curFileProp = &((*lpafp)[indexFilePropArray]);
2372
2373         /* First Parse the permissions. */
2374         pszToken = strtok(pszLine, " \t" );
2375
2376         /* HACK! If this is not a file listing skip the line */
2377         if (!pszToken || 10 != strlen(pszToken) || nBufLen <= MIN_LEN_DIR_ENTRY)
2378         {
2379             nBufLen = MAX_REPLY_LEN;
2380             continue;
2381         }
2382
2383         FTP_ParsePermission(pszToken, curFileProp);
2384
2385         nTokenToSkip = 3;
2386         nCount = 0;
2387         do
2388         {
2389             pszToken = strtok( NULL, " \t" );
2390             nCount++;
2391         } while( nCount <= nTokenToSkip );
2392
2393         /* Store the size of the file in the param list. */
2394         TRACE("nSize-> %s\n", pszToken);
2395         if (pszToken != NULL)
2396             curFileProp->nSize = atol(pszToken);
2397
2398         /* Parse last modified time. */
2399         nSeconds = 0;
2400         nMinutes = 0;
2401         nHour    = 0;
2402         nDay     = 0;
2403         nMonth   = 0;
2404         nYear    = 0;
2405
2406         pszToken = strtok( NULL, " \t" );
2407         strncpy(pszMonth, pszToken, MAX_MONTH_LEN);
2408         CharUpperA(pszMonth);
2409         pszMatch = strstr(szMonths, pszMonth);
2410         if( pszMatch != NULL )
2411             nMonth = (pszMatch - szMonths) / 3;
2412
2413         pszToken = strtok(NULL, " \t");
2414         TRACE("nDay -> %s\n", pszToken);
2415         if (pszToken != NULL)
2416             nDay = atoi(pszToken);
2417
2418         pszToken = strtok(NULL, " \t");
2419         pszMinutes = strchr(pszToken, ':');
2420         if( pszMinutes != NULL )
2421         {
2422             pszMinutes++;
2423             nMinutes = atoi(pszMinutes);
2424             pszHour = pszMinutes - 3;
2425             if (pszHour != NULL)
2426                 nHour = atoi(pszHour);
2427             time(&aTime);
2428             apTM = localtime( &aTime );
2429             nYear = apTM->tm_year;
2430         }
2431         else
2432         {
2433             nYear  = atoi(pszToken);
2434             nYear -= 1900;
2435             nHour  = 12;
2436         }
2437
2438         curFileProp->tmLastModified.tm_sec  = nSeconds;
2439         curFileProp->tmLastModified.tm_min  = nMinutes;
2440         curFileProp->tmLastModified.tm_hour = nHour;
2441         curFileProp->tmLastModified.tm_mday = nDay;
2442         curFileProp->tmLastModified.tm_mon  = nMonth;
2443         curFileProp->tmLastModified.tm_year = nYear;
2444
2445         pszToken = strtok(NULL, " \t");
2446         if(pszToken != NULL)
2447         {
2448             curFileProp->lpszName = FTP_strdup(pszToken);
2449             TRACE(": %s\n", curFileProp->lpszName);
2450         }
2451
2452         nBufLen = MAX_REPLY_LEN;
2453         indexFilePropArray++;
2454     }
2455
2456     if (bSuccess && indexFilePropArray)
2457     {
2458         if (indexFilePropArray < sizeFilePropArray - 1)
2459         {
2460             LPFILEPROPERTIESA tmpafp;
2461
2462             tmpafp = HeapReAlloc(GetProcessHeap(), 0, *lpafp,
2463                 sizeof(FILEPROPERTIESA)*indexFilePropArray);
2464             if (NULL == tmpafp)
2465                 *lpafp = tmpafp;
2466         }
2467         *dwfp = indexFilePropArray;
2468     }
2469     else
2470     {
2471         HeapFree(GetProcessHeap(), 0, *lpafp);
2472         INTERNET_SetLastError(ERROR_NO_MORE_FILES);
2473         bSuccess = FALSE;
2474     }
2475
2476 lend:
2477     return bSuccess;
2478 }
2479
2480
2481 /***********************************************************************
2482  *           FTP_ParsePermission (internal)
2483  *
2484  * Parse permission string of directory information
2485  *
2486  * RETURNS
2487  *   TRUE on success
2488  *   FALSE on failure
2489  *
2490  */
2491 BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESA lpfp)
2492 {
2493     BOOL bSuccess = TRUE;
2494     unsigned short nPermission = 0;
2495     INT nPos = 1;
2496     INT nLast  = 9;
2497
2498     TRACE("\n");
2499     if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
2500     {
2501         bSuccess = FALSE;
2502         return bSuccess;
2503     }
2504
2505     lpfp->bIsDirectory = (*lpszPermission == 'd');
2506     do
2507     {
2508         switch (nPos)
2509         {
2510             case 1:
2511                 nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
2512                 break;
2513             case 2:
2514                 nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
2515                 break;
2516             case 3:
2517                 nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
2518                 break;
2519             case 4:
2520                 nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
2521                 break;
2522             case 5:
2523                 nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
2524                 break;
2525             case 6:
2526                 nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
2527                 break;
2528             case 7:
2529                 nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
2530                 break;
2531             case 8:
2532                 nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
2533                 break;
2534             case 9:
2535                 nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
2536                 break;
2537         }
2538         nPos++;
2539     }while (nPos <= nLast);
2540
2541     lpfp->permissions = nPermission;
2542     return bSuccess;
2543 }
2544
2545
2546 /***********************************************************************
2547  *           FTP_SetResponseError (internal)
2548  *
2549  * Set the appropriate error code for a given response from the server
2550  *
2551  * RETURNS
2552  *
2553  */
2554 DWORD FTP_SetResponseError(DWORD dwResponse)
2555 {
2556     DWORD dwCode = 0;
2557
2558     switch(dwResponse)
2559     {
2560         case 421: /* Service not available - Server may be shutting down. */
2561             dwCode = ERROR_INTERNET_TIMEOUT;
2562             break;
2563
2564         case 425: /* Cannot open data connection. */
2565             dwCode = ERROR_INTERNET_CANNOT_CONNECT;
2566             break;
2567
2568         case 426: /* Connection closed, transer aborted. */
2569             dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
2570             break;
2571
2572         case 500: /* Syntax error. Command unrecognized. */
2573         case 501: /* Syntax error. Error in parameters or arguments. */
2574             dwCode = ERROR_INTERNET_INCORRECT_FORMAT;
2575             break;
2576
2577         case 530: /* Not logged in. Login incorrect. */
2578             dwCode = ERROR_INTERNET_LOGIN_FAILURE;
2579             break;
2580
2581         case 550: /* File action not taken. File not found or no access. */
2582             dwCode = ERROR_INTERNET_ITEM_NOT_FOUND;
2583             break;
2584
2585         case 450: /* File action not taken. File may be busy. */
2586         case 451: /* Action aborted. Server error. */
2587         case 452: /* Action not taken. Insufficient storage space on server. */
2588         case 502: /* Command not implemented. */
2589         case 503: /* Bad sequence of command. */
2590         case 504: /* Command not implemented for that parameter. */
2591         case 532: /* Need account for storing files */
2592         case 551: /* Requested action aborted. Page type unknown */
2593         case 552: /* Action aborted. Exceeded storage allocation */
2594         case 553: /* Action not taken. File name not allowed. */
2595
2596         default:
2597             dwCode = ERROR_INTERNET_INTERNAL_ERROR;
2598             break;
2599     }
2600
2601     INTERNET_SetLastError(dwCode);
2602     return dwCode;
2603 }