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