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

   1 /*
   2  * WININET - Ftp implementation
   3  *
   4  * Copyright 1999 Corel Corporation
   5  * Copyright 2004 Mike McCormack for CodeWeavers
   6  * Copyright 2004 Kevin Koltzau
   7  * Copyright 2007 Hans Leidekker
   8  *
   9  * Ulrich Czekalla
  10  * Noureddine Jemmali
  11  *
  12  * Copyright 2000 Andreas Mohr
  13  * Copyright 2002 Jaco Greeff
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2.1 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  28  */
  29
  30 #include "config.h"
  31 #include "wine/port.h"
  32
  33 #if defined(__MINGW32__) || defined (_MSC_VER)
  34 #include <ws2tcpip.h>
  35 #endif
  36
  37 #include <errno.h>
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <sys/types.h>
  43 #ifdef HAVE_SYS_SOCKET_H
  44 # include <sys/socket.h>
  45 #endif
  46 #ifdef HAVE_ARPA_INET_H
  47 # include <arpa/inet.h>
  48 #endif
  49 #ifdef HAVE_UNISTD_H
  50 # include <unistd.h>
  51 #endif
  52 #ifdef HAVE_SYS_IOCTL_H
  53 # include <sys/ioctl.h>
  54 #endif
  55 #include <time.h>
  56 #include <assert.h>
  57
  58 #include "windef.h"
  59 #include "winbase.h"
  60 #include "wingdi.h"
  61 #include "winuser.h"
  62 #include "wininet.h"
  63 #include "winnls.h"
  64 #include "winerror.h"
  65 #include "winreg.h"
  66 #include "winternl.h"
  67 #include "shlwapi.h"
  68
  69 #include "wine/debug.h"
  70 #include "internet.h"
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
  73
  74 typedef struct _ftp_session_t ftp_session_t;
  75
  76 typedef struct
  77 {
  78     object_header_t hdr;
  79     ftp_session_t *lpFtpSession;
  80     BOOL session_deleted;
  81     int nDataSocket;
  82     WCHAR *cache_file;
  83     HANDLE cache_file_handle;
  84 } ftp_file_t;
  85
  86 struct _ftp_session_t
  87 {
  88     object_header_t hdr;
  89     appinfo_t *lpAppInfo;
  90     int sndSocket;
  91     int lstnSocket;
  92     int pasvSocket; /* data socket connected by us in case of passive FTP */
  93     ftp_file_t *download_in_progress;
  94     struct sockaddr_in socketAddress;
  95     struct sockaddr_in lstnSocketAddress;
  96     LPWSTR servername;
  97     INTERNET_PORT serverport;
  98     LPWSTR  lpszPassword;
  99     LPWSTR  lpszUserName;
 100 };
 101
 102 typedef struct
 103 {
 104     BOOL bIsDirectory;
 105     LPWSTR lpszName;
 106     DWORD nSize;
 107     SYSTEMTIME tmLastModified;
 108     unsigned short permissions;
 109 } FILEPROPERTIESW, *LPFILEPROPERTIESW;
 110
 111 typedef struct
 112 {
 113     object_header_t hdr;
 114     ftp_session_t *lpFtpSession;
 115     DWORD index;
 116     DWORD size;
 117     LPFILEPROPERTIESW lpafp;
 118 } WININETFTPFINDNEXTW, *LPWININETFTPFINDNEXTW;
 119
 120 #define DATA_PACKET_SIZE        0x2000
 121 #define szCRLF                  "\r\n"
 122 #define MAX_BACKLOG             5
 123
 124 /* Testing shows that Windows only accepts dwFlags where the last
 125  * 3 (yes 3) bits define FTP_TRANSFER_TYPE_UNKNOWN, FTP_TRANSFER_TYPE_ASCII or FTP_TRANSFER_TYPE_BINARY.
 126  */
 127 #define FTP_CONDITION_MASK      0x0007
 128
 129 typedef enum {
 130   /* FTP commands with arguments. */
 131   FTP_CMD_ACCT,
 132   FTP_CMD_CWD,
 133   FTP_CMD_DELE,
 134   FTP_CMD_MKD,
 135   FTP_CMD_PASS,
 136   FTP_CMD_PORT,
 137   FTP_CMD_RETR,
 138   FTP_CMD_RMD,
 139   FTP_CMD_RNFR,
 140   FTP_CMD_RNTO,
 141   FTP_CMD_STOR,
 142   FTP_CMD_TYPE,
 143   FTP_CMD_USER,
 144   FTP_CMD_SIZE,
 145
 146   /* FTP commands without arguments. */
 147   FTP_CMD_ABOR,
 148   FTP_CMD_LIST,
 149   FTP_CMD_NLST,
 150   FTP_CMD_PASV,
 151   FTP_CMD_PWD,
 152   FTP_CMD_QUIT,
 153 } FTP_COMMAND;
 154
 155 static const CHAR *const szFtpCommands[] = {
 156   "ACCT",
 157   "CWD",
 158   "DELE",
 159   "MKD",
 160   "PASS",
 161   "PORT",
 162   "RETR",
 163   "RMD",
 164   "RNFR",
 165   "RNTO",
 166   "STOR",
 167   "TYPE",
 168   "USER",
 169   "SIZE",
 170   "ABOR",
 171   "LIST",
 172   "NLST",
 173   "PASV",
 174   "PWD",
 175   "QUIT",
 176 };
 177
 178 static const CHAR szMonths[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
 179 static const WCHAR szNoAccount[] = {'n','o','a','c','c','o','u','n','t','\0'};
 180
 181 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
 182         INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext);
 183 static BOOL FTP_SendStore(ftp_session_t*, LPCWSTR lpszRemoteFile, DWORD dwType);
 184 static BOOL FTP_GetDataSocket(ftp_session_t*, LPINT nDataSocket);
 185 static BOOL FTP_SendData(ftp_session_t*, INT nDataSocket, HANDLE hFile);
 186 static INT FTP_ReceiveResponse(ftp_session_t*, DWORD_PTR dwContext);
 187 static BOOL FTP_SendRetrieve(ftp_session_t*, LPCWSTR lpszRemoteFile, DWORD dwType);
 188 static BOOL FTP_RetrieveFileData(ftp_session_t*, INT nDataSocket, HANDLE hFile);
 189 static BOOL FTP_InitListenSocket(ftp_session_t*);
 190 static BOOL FTP_ConnectToHost(ftp_session_t*);
 191 static BOOL FTP_SendPassword(ftp_session_t*);
 192 static BOOL FTP_SendAccount(ftp_session_t*);
 193 static BOOL FTP_SendType(ftp_session_t*, DWORD dwType);
 194 static BOOL FTP_SendPort(ftp_session_t*);
 195 static BOOL FTP_DoPassive(ftp_session_t*);
 196 static BOOL FTP_SendPortOrPasv(ftp_session_t*);
 197 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp);
 198 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW fileprop);
 199 static BOOL FTP_ParseDirectory(ftp_session_t*, INT nSocket, LPCWSTR lpszSearchFile,
 200         LPFILEPROPERTIESW *lpafp, LPDWORD dwfp);
 201 static HINTERNET FTP_ReceiveFileList(ftp_session_t*, INT nSocket, LPCWSTR lpszSearchFile,
 202         LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext);
 203 static DWORD FTP_SetResponseError(DWORD dwResponse);
 204 static BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData);
 205 static BOOL FTP_FtpPutFileW(ftp_session_t*, LPCWSTR lpszLocalFile,
 206         LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext);
 207 static BOOL FTP_FtpSetCurrentDirectoryW(ftp_session_t*, LPCWSTR lpszDirectory);
 208 static BOOL FTP_FtpCreateDirectoryW(ftp_session_t*, LPCWSTR lpszDirectory);
 209 static HINTERNET FTP_FtpFindFirstFileW(ftp_session_t*,
 210         LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext);
 211 static BOOL FTP_FtpGetCurrentDirectoryW(ftp_session_t*, LPWSTR lpszCurrentDirectory,
 212         LPDWORD lpdwCurrentDirectory);
 213 static BOOL FTP_FtpRenameFileW(ftp_session_t*, LPCWSTR lpszSrc, LPCWSTR lpszDest);
 214 static BOOL FTP_FtpRemoveDirectoryW(ftp_session_t*, LPCWSTR lpszDirectory);
 215 static BOOL FTP_FtpDeleteFileW(ftp_session_t*, LPCWSTR lpszFileName);
 216 static BOOL FTP_FtpGetFileW(ftp_session_t*, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
 217         BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
 218         DWORD_PTR dwContext);
 219
 220 /* A temporary helper until we get rid of INTERNET_GetLastError calls */
 221 static BOOL res_to_le(DWORD res)
 222 {
 223     if(res != ERROR_SUCCESS)
 224         INTERNET_SetLastError(res);
 225     return res == ERROR_SUCCESS;
 226 }
 227
 228 /***********************************************************************
 229  *           FtpPutFileA (WININET.@)
 230  *
 231  * Uploads a file to the FTP server
 232  *
 233  * RETURNS
 234  *    TRUE on success
 235  *    FALSE on failure
 236  *
 237  */
 238 BOOL WINAPI FtpPutFileA(HINTERNET hConnect, LPCSTR lpszLocalFile,
 239     LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
 240 {
 241     LPWSTR lpwzLocalFile;
 242     LPWSTR lpwzNewRemoteFile;
 243     BOOL ret;
 244
 245     lpwzLocalFile = heap_strdupAtoW(lpszLocalFile);
 246     lpwzNewRemoteFile = heap_strdupAtoW(lpszNewRemoteFile);
 247     ret = FtpPutFileW(hConnect, lpwzLocalFile, lpwzNewRemoteFile,
 248                       dwFlags, dwContext);
 249     HeapFree(GetProcessHeap(), 0, lpwzLocalFile);
 250     HeapFree(GetProcessHeap(), 0, lpwzNewRemoteFile);
 251     return ret;
 252 }
 253
 254 static void AsyncFtpPutFileProc(WORKREQUEST *workRequest)
 255 {
 256     struct WORKREQ_FTPPUTFILEW const *req = &workRequest->u.FtpPutFileW;
 257     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
 258
 259     TRACE("%p\n", lpwfs);
 260
 261     FTP_FtpPutFileW(lpwfs, req->lpszLocalFile,
 262                req->lpszNewRemoteFile, req->dwFlags, req->dwContext);
 263
 264     HeapFree(GetProcessHeap(), 0, req->lpszLocalFile);
 265     HeapFree(GetProcessHeap(), 0, req->lpszNewRemoteFile);
 266 }
 267
 268 /***********************************************************************
 269  *           FtpPutFileW (WININET.@)
 270  *
 271  * Uploads a file to the FTP server
 272  *
 273  * RETURNS
 274  *    TRUE on success
 275  *    FALSE on failure
 276  *
 277  */
 278 BOOL WINAPI FtpPutFileW(HINTERNET hConnect, LPCWSTR lpszLocalFile,
 279     LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
 280 {
 281     ftp_session_t *lpwfs;
 282     appinfo_t *hIC = NULL;
 283     BOOL r = FALSE;
 284
 285     if (!lpszLocalFile || !lpszNewRemoteFile)
 286     {
 287         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 288         return FALSE;
 289     }
 290
 291     lpwfs = (ftp_session_t*) get_handle_object( hConnect );
 292     if (!lpwfs)
 293     {
 294         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
 295         return FALSE;
 296     }
 297
 298     if (WH_HFTPSESSION != lpwfs->hdr.htype)
 299     {
 300         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 301         goto lend;
 302     }
 303
 304     if (lpwfs->download_in_progress != NULL)
 305     {
 306         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
 307         goto lend;
 308     }
 309
 310     if ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
 311     {
 312         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 313         goto lend;
 314     }
 315
 316     hIC = lpwfs->lpAppInfo;
 317     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 318     {
 319         WORKREQUEST workRequest;
 320         struct WORKREQ_FTPPUTFILEW *req = &workRequest.u.FtpPutFileW;
 321
 322         workRequest.asyncproc = AsyncFtpPutFileProc;
 323         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
 324         req->lpszLocalFile = heap_strdupW(lpszLocalFile);
 325         req->lpszNewRemoteFile = heap_strdupW(lpszNewRemoteFile);
 326         req->dwFlags = dwFlags;
 327         req->dwContext = dwContext;
 328
 329         r = res_to_le(INTERNET_AsyncCall(&workRequest));
 330     }
 331     else
 332     {
 333         r = FTP_FtpPutFileW(lpwfs, lpszLocalFile,
 334             lpszNewRemoteFile, dwFlags, dwContext);
 335     }
 336
 337 lend:
 338     WININET_Release( &lpwfs->hdr );
 339
 340     return r;
 341 }
 342
 343 /***********************************************************************
 344  *           FTP_FtpPutFileW (Internal)
 345  *
 346  * Uploads a file to the FTP server
 347  *
 348  * RETURNS
 349  *    TRUE on success
 350  *    FALSE on failure
 351  *
 352  */
 353 static BOOL FTP_FtpPutFileW(ftp_session_t *lpwfs, LPCWSTR lpszLocalFile,
 354     LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
 355 {
 356     HANDLE hFile;
 357     BOOL bSuccess = FALSE;
 358     appinfo_t *hIC = NULL;
 359     INT nResCode;
 360
 361     TRACE(" lpszLocalFile(%s) lpszNewRemoteFile(%s)\n", debugstr_w(lpszLocalFile), debugstr_w(lpszNewRemoteFile));
 362
 363     /* Clear any error information */
 364     INTERNET_SetLastError(0);
 365
 366     /* Open file to be uploaded */
 367     if (INVALID_HANDLE_VALUE ==
 368         (hFile = CreateFileW(lpszLocalFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)))
 369         /* Let CreateFile set the appropriate error */
 370         return FALSE;
 371
 372     hIC = lpwfs->lpAppInfo;
 373
 374     SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
 375
 376     if (FTP_SendStore(lpwfs, lpszNewRemoteFile, dwFlags))
 377     {
 378         INT nDataSocket;
 379
 380         /* Get data socket to server */
 381         if (FTP_GetDataSocket(lpwfs, &nDataSocket))
 382         {
 383             FTP_SendData(lpwfs, nDataSocket, hFile);
 384             closesocket(nDataSocket);
 385             nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
 386             if (nResCode)
 387             {
 388                 if (nResCode == 226)
 389                     bSuccess = TRUE;
 390                 else
 391                     FTP_SetResponseError(nResCode);
 392             }
 393         }
 394     }
 395
 396     if (lpwfs->lstnSocket != -1)
 397     {
 398         closesocket(lpwfs->lstnSocket);
 399         lpwfs->lstnSocket = -1;
 400     }
 401
 402     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 403     {
 404         INTERNET_ASYNC_RESULT iar;
 405
 406         iar.dwResult = (DWORD)bSuccess;
 407         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 408         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 409             &iar, sizeof(INTERNET_ASYNC_RESULT));
 410     }
 411
 412     CloseHandle(hFile);
 413
 414     return bSuccess;
 415 }
 416
 417
 418 /***********************************************************************
 419  *           FtpSetCurrentDirectoryA (WININET.@)
 420  *
 421  * Change the working directory on the FTP server
 422  *
 423  * RETURNS
 424  *    TRUE on success
 425  *    FALSE on failure
 426  *
 427  */
 428 BOOL WINAPI FtpSetCurrentDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 429 {
 430     LPWSTR lpwzDirectory;
 431     BOOL ret;
 432
 433     lpwzDirectory = heap_strdupAtoW(lpszDirectory);
 434     ret = FtpSetCurrentDirectoryW(hConnect, lpwzDirectory);
 435     HeapFree(GetProcessHeap(), 0, lpwzDirectory);
 436     return ret;
 437 }
 438
 439
 440 static void AsyncFtpSetCurrentDirectoryProc(WORKREQUEST *workRequest)
 441 {
 442     struct WORKREQ_FTPSETCURRENTDIRECTORYW const *req = &workRequest->u.FtpSetCurrentDirectoryW;
 443     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
 444
 445     TRACE("%p\n", lpwfs);
 446
 447     FTP_FtpSetCurrentDirectoryW(lpwfs, req->lpszDirectory);
 448     HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
 449 }
 450
 451 /***********************************************************************
 452  *           FtpSetCurrentDirectoryW (WININET.@)
 453  *
 454  * Change the working directory on the FTP server
 455  *
 456  * RETURNS
 457  *    TRUE on success
 458  *    FALSE on failure
 459  *
 460  */
 461 BOOL WINAPI FtpSetCurrentDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory)
 462 {
 463     ftp_session_t *lpwfs = NULL;
 464     appinfo_t *hIC = NULL;
 465     BOOL r = FALSE;
 466
 467     if (!lpszDirectory)
 468     {
 469         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 470         goto lend;
 471     }
 472
 473     lpwfs = (ftp_session_t*) get_handle_object( hConnect );
 474     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 475     {
 476         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 477         goto lend;
 478     }
 479
 480     if (lpwfs->download_in_progress != NULL)
 481     {
 482         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
 483         goto lend;
 484     }
 485
 486     TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 487
 488     hIC = lpwfs->lpAppInfo;
 489     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 490     {
 491         WORKREQUEST workRequest;
 492         struct WORKREQ_FTPSETCURRENTDIRECTORYW *req;
 493
 494         workRequest.asyncproc = AsyncFtpSetCurrentDirectoryProc;
 495         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
 496         req = &workRequest.u.FtpSetCurrentDirectoryW;
 497         req->lpszDirectory = heap_strdupW(lpszDirectory);
 498
 499         r = res_to_le(INTERNET_AsyncCall(&workRequest));
 500     }
 501     else
 502     {
 503         r = FTP_FtpSetCurrentDirectoryW(lpwfs, lpszDirectory);
 504     }
 505
 506 lend:
 507     if( lpwfs )
 508         WININET_Release( &lpwfs->hdr );
 509
 510     return r;
 511 }
 512
 513
 514 /***********************************************************************
 515  *           FTP_FtpSetCurrentDirectoryW (Internal)
 516  *
 517  * Change the working directory on the FTP server
 518  *
 519  * RETURNS
 520  *    TRUE on success
 521  *    FALSE on failure
 522  *
 523  */
 524 static BOOL FTP_FtpSetCurrentDirectoryW(ftp_session_t *lpwfs, LPCWSTR lpszDirectory)
 525 {
 526     INT nResCode;
 527     appinfo_t *hIC = NULL;
 528     DWORD bSuccess = FALSE;
 529
 530     TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 531
 532     /* Clear any error information */
 533     INTERNET_SetLastError(0);
 534
 535     hIC = lpwfs->lpAppInfo;
 536     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_CWD, lpszDirectory,
 537         lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
 538         goto lend;
 539
 540     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 541
 542     if (nResCode)
 543     {
 544         if (nResCode == 250)
 545             bSuccess = TRUE;
 546         else
 547             FTP_SetResponseError(nResCode);
 548     }
 549
 550 lend:
 551     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 552     {
 553         INTERNET_ASYNC_RESULT iar;
 554
 555         iar.dwResult = bSuccess;
 556         iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
 557         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 558             &iar, sizeof(INTERNET_ASYNC_RESULT));
 559     }
 560     return bSuccess;
 561 }
 562
 563
 564 /***********************************************************************
 565  *           FtpCreateDirectoryA (WININET.@)
 566  *
 567  * Create new directory on the FTP server
 568  *
 569  * RETURNS
 570  *    TRUE on success
 571  *    FALSE on failure
 572  *
 573  */
 574 BOOL WINAPI FtpCreateDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory)
 575 {
 576     LPWSTR lpwzDirectory;
 577     BOOL ret;
 578
 579     lpwzDirectory = heap_strdupAtoW(lpszDirectory);
 580     ret = FtpCreateDirectoryW(hConnect, lpwzDirectory);
 581     HeapFree(GetProcessHeap(), 0, lpwzDirectory);
 582     return ret;
 583 }
 584
 585
 586 static void AsyncFtpCreateDirectoryProc(WORKREQUEST *workRequest)
 587 {
 588     struct WORKREQ_FTPCREATEDIRECTORYW const *req = &workRequest->u.FtpCreateDirectoryW;
 589     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
 590
 591     TRACE(" %p\n", lpwfs);
 592
 593     FTP_FtpCreateDirectoryW(lpwfs, req->lpszDirectory);
 594     HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
 595 }
 596
 597 /***********************************************************************
 598  *           FtpCreateDirectoryW (WININET.@)
 599  *
 600  * Create new directory on the FTP server
 601  *
 602  * RETURNS
 603  *    TRUE on success
 604  *    FALSE on failure
 605  *
 606  */
 607 BOOL WINAPI FtpCreateDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory)
 608 {
 609     ftp_session_t *lpwfs;
 610     appinfo_t *hIC = NULL;
 611     BOOL r = FALSE;
 612
 613     lpwfs = (ftp_session_t*) get_handle_object( hConnect );
 614     if (!lpwfs)
 615     {
 616         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
 617         return FALSE;
 618     }
 619
 620     if (WH_HFTPSESSION != lpwfs->hdr.htype)
 621     {
 622         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 623         goto lend;
 624     }
 625
 626     if (lpwfs->download_in_progress != NULL)
 627     {
 628         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
 629         goto lend;
 630     }
 631
 632     if (!lpszDirectory)
 633     {
 634         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 635         goto lend;
 636     }
 637
 638     hIC = lpwfs->lpAppInfo;
 639     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 640     {
 641         WORKREQUEST workRequest;
 642         struct WORKREQ_FTPCREATEDIRECTORYW *req;
 643
 644         workRequest.asyncproc = AsyncFtpCreateDirectoryProc;
 645         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
 646         req = &workRequest.u.FtpCreateDirectoryW;
 647         req->lpszDirectory = heap_strdupW(lpszDirectory);
 648
 649         r = res_to_le(INTERNET_AsyncCall(&workRequest));
 650     }
 651     else
 652     {
 653         r = FTP_FtpCreateDirectoryW(lpwfs, lpszDirectory);
 654     }
 655 lend:
 656     WININET_Release( &lpwfs->hdr );
 657
 658     return r;
 659 }
 660
 661
 662 /***********************************************************************
 663  *           FTP_FtpCreateDirectoryW (Internal)
 664  *
 665  * Create new directory on the FTP server
 666  *
 667  * RETURNS
 668  *    TRUE on success
 669  *    FALSE on failure
 670  *
 671  */
 672 static BOOL FTP_FtpCreateDirectoryW(ftp_session_t *lpwfs, LPCWSTR lpszDirectory)
 673 {
 674     INT nResCode;
 675     BOOL bSuccess = FALSE;
 676     appinfo_t *hIC = NULL;
 677
 678     TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 679
 680     /* Clear any error information */
 681     INTERNET_SetLastError(0);
 682
 683     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_MKD, lpszDirectory, 0, 0, 0))
 684         goto lend;
 685
 686     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 687     if (nResCode)
 688     {
 689         if (nResCode == 257)
 690             bSuccess = TRUE;
 691         else
 692             FTP_SetResponseError(nResCode);
 693     }
 694
 695 lend:
 696     hIC = lpwfs->lpAppInfo;
 697     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 698     {
 699         INTERNET_ASYNC_RESULT iar;
 700
 701         iar.dwResult = (DWORD)bSuccess;
 702         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
 703         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 704             &iar, sizeof(INTERNET_ASYNC_RESULT));
 705     }
 706
 707     return bSuccess;
 708 }
 709
 710 /***********************************************************************
 711  *           FtpFindFirstFileA (WININET.@)
 712  *
 713  * Search the specified directory
 714  *
 715  * RETURNS
 716  *    HINTERNET on success
 717  *    NULL on failure
 718  *
 719  */
 720 HINTERNET WINAPI FtpFindFirstFileA(HINTERNET hConnect,
 721     LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
 722 {
 723     LPWSTR lpwzSearchFile;
 724     WIN32_FIND_DATAW wfd;
 725     LPWIN32_FIND_DATAW lpFindFileDataW;
 726     HINTERNET ret;
 727
 728     lpwzSearchFile = heap_strdupAtoW(lpszSearchFile);
 729     lpFindFileDataW = lpFindFileData?&wfd:NULL;
 730     ret = FtpFindFirstFileW(hConnect, lpwzSearchFile, lpFindFileDataW, dwFlags, dwContext);
 731     HeapFree(GetProcessHeap(), 0, lpwzSearchFile);
 732
 733     if (ret && lpFindFileData)
 734         WININET_find_data_WtoA(lpFindFileDataW, lpFindFileData);
 735
 736     return ret;
 737 }
 738
 739
 740 static void AsyncFtpFindFirstFileProc(WORKREQUEST *workRequest)
 741 {
 742     struct WORKREQ_FTPFINDFIRSTFILEW const *req = &workRequest->u.FtpFindFirstFileW;
 743     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
 744
 745     TRACE("%p\n", lpwfs);
 746
 747     FTP_FtpFindFirstFileW(lpwfs, req->lpszSearchFile,
 748        req->lpFindFileData, req->dwFlags, req->dwContext);
 749     HeapFree(GetProcessHeap(), 0, req->lpszSearchFile);
 750 }
 751
 752 /***********************************************************************
 753  *           FtpFindFirstFileW (WININET.@)
 754  *
 755  * Search the specified directory
 756  *
 757  * RETURNS
 758  *    HINTERNET on success
 759  *    NULL on failure
 760  *
 761  */
 762 HINTERNET WINAPI FtpFindFirstFileW(HINTERNET hConnect,
 763     LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
 764 {
 765     ftp_session_t *lpwfs;
 766     appinfo_t *hIC = NULL;
 767     HINTERNET r = NULL;
 768
 769     lpwfs = (ftp_session_t*) get_handle_object( hConnect );
 770     if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
 771     {
 772         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 773         goto lend;
 774     }
 775
 776     if (lpwfs->download_in_progress != NULL)
 777     {
 778         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
 779         goto lend;
 780     }
 781
 782     hIC = lpwfs->lpAppInfo;
 783     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 784     {
 785         WORKREQUEST workRequest;
 786         struct WORKREQ_FTPFINDFIRSTFILEW *req;
 787
 788         workRequest.asyncproc = AsyncFtpFindFirstFileProc;
 789         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
 790         req = &workRequest.u.FtpFindFirstFileW;
 791         req->lpszSearchFile = (lpszSearchFile == NULL) ? NULL : heap_strdupW(lpszSearchFile);
 792         req->lpFindFileData = lpFindFileData;
 793         req->dwFlags = dwFlags;
 794         req->dwContext= dwContext;
 795
 796         INTERNET_AsyncCall(&workRequest);
 797         r = NULL;
 798     }
 799     else
 800     {
 801         r = FTP_FtpFindFirstFileW(lpwfs, lpszSearchFile, lpFindFileData,
 802             dwFlags, dwContext);
 803     }
 804 lend:
 805     if( lpwfs )
 806         WININET_Release( &lpwfs->hdr );
 807
 808     return r;
 809 }
 810
 811
 812 /***********************************************************************
 813  *           FTP_FtpFindFirstFileW (Internal)
 814  *
 815  * Search the specified directory
 816  *
 817  * RETURNS
 818  *    HINTERNET on success
 819  *    NULL on failure
 820  *
 821  */
 822 static HINTERNET FTP_FtpFindFirstFileW(ftp_session_t *lpwfs,
 823     LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
 824 {
 825     INT nResCode;
 826     appinfo_t *hIC = NULL;
 827     HINTERNET hFindNext = NULL;
 828
 829     TRACE("\n");
 830
 831     /* Clear any error information */
 832     INTERNET_SetLastError(0);
 833
 834     if (!FTP_InitListenSocket(lpwfs))
 835         goto lend;
 836
 837     if (!FTP_SendType(lpwfs, INTERNET_FLAG_TRANSFER_ASCII))
 838         goto lend;
 839
 840     if (!FTP_SendPortOrPasv(lpwfs))
 841         goto lend;
 842
 843     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_LIST, NULL,
 844         lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
 845         goto lend;
 846
 847     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 848     if (nResCode)
 849     {
 850         if (nResCode == 125 || nResCode == 150)
 851         {
 852             INT nDataSocket;
 853
 854             /* Get data socket to server */
 855             if (FTP_GetDataSocket(lpwfs, &nDataSocket))
 856             {
 857                 hFindNext = FTP_ReceiveFileList(lpwfs, nDataSocket, lpszSearchFile, lpFindFileData, dwContext);
 858                 closesocket(nDataSocket);
 859                 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 860                 if (nResCode != 226 && nResCode != 250)
 861                     INTERNET_SetLastError(ERROR_NO_MORE_FILES);
 862             }
 863         }
 864         else
 865             FTP_SetResponseError(nResCode);
 866     }
 867
 868 lend:
 869     if (lpwfs->lstnSocket != -1)
 870     {
 871         closesocket(lpwfs->lstnSocket);
 872         lpwfs->lstnSocket = -1;
 873     }
 874
 875     hIC = lpwfs->lpAppInfo;
 876     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
 877     {
 878         INTERNET_ASYNC_RESULT iar;
 879
 880         if (hFindNext)
 881         {
 882             iar.dwResult = (DWORD_PTR)hFindNext;
 883             iar.dwError = ERROR_SUCCESS;
 884             SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
 885                 &iar, sizeof(INTERNET_ASYNC_RESULT));
 886         }
 887
 888         iar.dwResult = (DWORD_PTR)hFindNext;
 889         iar.dwError = hFindNext ? ERROR_SUCCESS : INTERNET_GetLastError();
 890         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
 891             &iar, sizeof(INTERNET_ASYNC_RESULT));
 892     }
 893
 894     return hFindNext;
 895 }
 896
 897
 898 /***********************************************************************
 899  *           FtpGetCurrentDirectoryA (WININET.@)
 900  *
 901  * Retrieves the current directory
 902  *
 903  * RETURNS
 904  *    TRUE on success
 905  *    FALSE on failure
 906  *
 907  */
 908 BOOL WINAPI FtpGetCurrentDirectoryA(HINTERNET hFtpSession, LPSTR lpszCurrentDirectory,
 909     LPDWORD lpdwCurrentDirectory)
 910 {
 911     WCHAR *dir = NULL;
 912     DWORD len;
 913     BOOL ret;
 914
 915     if(lpdwCurrentDirectory) {
 916         len = *lpdwCurrentDirectory;
 917         if(lpszCurrentDirectory)
 918         {
 919             dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 920             if (NULL == dir)
 921             {
 922                 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
 923                 return FALSE;
 924             }
 925         }
 926     }
 927     ret = FtpGetCurrentDirectoryW(hFtpSession, lpszCurrentDirectory?dir:NULL, lpdwCurrentDirectory?&len:NULL);
 928
 929     if (ret && lpszCurrentDirectory)
 930         WideCharToMultiByte(CP_ACP, 0, dir, -1, lpszCurrentDirectory, len, NULL, NULL);
 931
 932     if (lpdwCurrentDirectory) *lpdwCurrentDirectory = len;
 933     HeapFree(GetProcessHeap(), 0, dir);
 934     return ret;
 935 }
 936
 937
 938 static void AsyncFtpGetCurrentDirectoryProc(WORKREQUEST *workRequest)
 939 {
 940     struct WORKREQ_FTPGETCURRENTDIRECTORYW const *req = &workRequest->u.FtpGetCurrentDirectoryW;
 941     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
 942
 943     TRACE("%p\n", lpwfs);
 944
 945     FTP_FtpGetCurrentDirectoryW(lpwfs, req->lpszDirectory, req->lpdwDirectory);
 946 }
 947
 948 /***********************************************************************
 949  *           FtpGetCurrentDirectoryW (WININET.@)
 950  *
 951  * Retrieves the current directory
 952  *
 953  * RETURNS
 954  *    TRUE on success
 955  *    FALSE on failure
 956  *
 957  */
 958 BOOL WINAPI FtpGetCurrentDirectoryW(HINTERNET hFtpSession, LPWSTR lpszCurrentDirectory,
 959     LPDWORD lpdwCurrentDirectory)
 960 {
 961     ftp_session_t *lpwfs;
 962     appinfo_t *hIC = NULL;
 963     BOOL r = FALSE;
 964
 965     TRACE("%p %p %p\n", hFtpSession, lpszCurrentDirectory, lpdwCurrentDirectory);
 966
 967     lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
 968     if (NULL == lpwfs)
 969     {
 970         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
 971         goto lend;
 972     }
 973
 974     if (WH_HFTPSESSION != lpwfs->hdr.htype)
 975     {
 976         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
 977         goto lend;
 978     }
 979
 980     if (!lpdwCurrentDirectory)
 981     {
 982         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
 983         goto lend;
 984     }
 985
 986     if (lpszCurrentDirectory == NULL)
 987     {
 988         INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
 989         goto lend;
 990     }
 991
 992     if (lpwfs->download_in_progress != NULL)
 993     {
 994         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
 995         goto lend;
 996     }
 997
 998     hIC = lpwfs->lpAppInfo;
 999     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1000     {
1001         WORKREQUEST workRequest;
1002         struct WORKREQ_FTPGETCURRENTDIRECTORYW *req;
1003
1004         workRequest.asyncproc = AsyncFtpGetCurrentDirectoryProc;
1005         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1006         req = &workRequest.u.FtpGetCurrentDirectoryW;
1007         req->lpszDirectory = lpszCurrentDirectory;
1008         req->lpdwDirectory = lpdwCurrentDirectory;
1009
1010         r = res_to_le(INTERNET_AsyncCall(&workRequest));
1011     }
1012     else
1013     {
1014         r = FTP_FtpGetCurrentDirectoryW(lpwfs, lpszCurrentDirectory,
1015             lpdwCurrentDirectory);
1016     }
1017
1018 lend:
1019     if( lpwfs )
1020         WININET_Release( &lpwfs->hdr );
1021
1022     return r;
1023 }
1024
1025
1026 /***********************************************************************
1027  *           FTP_FtpGetCurrentDirectoryW (Internal)
1028  *
1029  * Retrieves the current directory
1030  *
1031  * RETURNS
1032  *    TRUE on success
1033  *    FALSE on failure
1034  *
1035  */
1036 static BOOL FTP_FtpGetCurrentDirectoryW(ftp_session_t *lpwfs, LPWSTR lpszCurrentDirectory,
1037         LPDWORD lpdwCurrentDirectory)
1038 {
1039     INT nResCode;
1040     appinfo_t *hIC = NULL;
1041     DWORD bSuccess = FALSE;
1042
1043     /* Clear any error information */
1044     INTERNET_SetLastError(0);
1045
1046     hIC = lpwfs->lpAppInfo;
1047     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PWD, NULL,
1048         lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
1049         goto lend;
1050
1051     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1052     if (nResCode)
1053     {
1054         if (nResCode == 257) /* Extract directory name */
1055         {
1056             DWORD firstpos, lastpos, len;
1057             LPWSTR lpszResponseBuffer = heap_strdupAtoW(INTERNET_GetResponseBuffer());
1058
1059             for (firstpos = 0, lastpos = 0; lpszResponseBuffer[lastpos]; lastpos++)
1060             {
1061                 if ('"' == lpszResponseBuffer[lastpos])
1062                 {
1063                     if (!firstpos)
1064                         firstpos = lastpos;
1065                     else
1066                         break;
1067                 }
1068             }
1069             len = lastpos - firstpos;
1070             if (*lpdwCurrentDirectory >= len)
1071             {
1072                 memcpy(lpszCurrentDirectory, &lpszResponseBuffer[firstpos + 1], len * sizeof(WCHAR));
1073                 lpszCurrentDirectory[len - 1] = 0;
1074                 *lpdwCurrentDirectory = len;
1075                 bSuccess = TRUE;
1076             }
1077             else INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
1078
1079             HeapFree(GetProcessHeap(), 0, lpszResponseBuffer);
1080         }
1081         else
1082             FTP_SetResponseError(nResCode);
1083     }
1084
1085 lend:
1086     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1087     {
1088         INTERNET_ASYNC_RESULT iar;
1089
1090         iar.dwResult = bSuccess;
1091         iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
1092         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1093             &iar, sizeof(INTERNET_ASYNC_RESULT));
1094     }
1095
1096     return bSuccess;
1097 }
1098
1099
1100 /***********************************************************************
1101  *           FTPFILE_Destroy(internal)
1102  *
1103  * Closes the file transfer handle. This also 'cleans' the data queue of
1104  * the 'transfer complete' message (this is a bit of a hack though :-/ )
1105  *
1106  */
1107 static void FTPFILE_Destroy(object_header_t *hdr)
1108 {
1109     ftp_file_t *lpwh = (ftp_file_t*) hdr;
1110     ftp_session_t *lpwfs = lpwh->lpFtpSession;
1111     INT nResCode;
1112
1113     TRACE("\n");
1114
1115     if (lpwh->cache_file_handle != INVALID_HANDLE_VALUE)
1116         CloseHandle(lpwh->cache_file_handle);
1117
1118     HeapFree(GetProcessHeap(), 0, lpwh->cache_file);
1119
1120     if (!lpwh->session_deleted)
1121         lpwfs->download_in_progress = NULL;
1122
1123     if (lpwh->nDataSocket != -1)
1124         closesocket(lpwh->nDataSocket);
1125
1126     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1127     if (nResCode > 0 && nResCode != 226) WARN("server reports failed transfer\n");
1128
1129     WININET_Release(&lpwh->lpFtpSession->hdr);
1130 }
1131
1132 static DWORD FTPFILE_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
1133 {
1134     switch(option) {
1135     case INTERNET_OPTION_HANDLE_TYPE:
1136         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
1137
1138         if (*size < sizeof(ULONG))
1139             return ERROR_INSUFFICIENT_BUFFER;
1140
1141         *size = sizeof(DWORD);
1142         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_FTP_FILE;
1143         return ERROR_SUCCESS;
1144     case INTERNET_OPTION_DATAFILE_NAME:
1145     {
1146         DWORD required;
1147         ftp_file_t *file = (ftp_file_t *)hdr;
1148
1149         TRACE("INTERNET_OPTION_DATAFILE_NAME\n");
1150
1151         if (!file->cache_file)
1152         {
1153             *size = 0;
1154             return ERROR_INTERNET_ITEM_NOT_FOUND;
1155         }
1156         if (unicode)
1157         {
1158             required = (lstrlenW(file->cache_file) + 1) * sizeof(WCHAR);
1159             if (*size < required)
1160                 return ERROR_INSUFFICIENT_BUFFER;
1161
1162             *size = required;
1163             memcpy(buffer, file->cache_file, *size);
1164             return ERROR_SUCCESS;
1165         }
1166         else
1167         {
1168             required = WideCharToMultiByte(CP_ACP, 0, file->cache_file, -1, NULL, 0, NULL, NULL);
1169             if (required > *size)
1170                 return ERROR_INSUFFICIENT_BUFFER;
1171
1172             *size = WideCharToMultiByte(CP_ACP, 0, file->cache_file, -1, buffer, *size, NULL, NULL);
1173             return ERROR_SUCCESS;
1174         }
1175     }
1176     }
1177     return INET_QueryOption(hdr, option, buffer, size, unicode);
1178 }
1179
1180 static DWORD FTPFILE_ReadFile(object_header_t *hdr, void *buffer, DWORD size, DWORD *read)
1181 {
1182     ftp_file_t *file = (ftp_file_t*)hdr;
1183     int res;
1184     DWORD error;
1185
1186     if (file->nDataSocket == -1)
1187         return ERROR_INTERNET_DISCONNECTED;
1188
1189     /* FIXME: FTP should use NETCON_ stuff */
1190     res = recv(file->nDataSocket, buffer, size, MSG_WAITALL);
1191     *read = res>0 ? res : 0;
1192
1193     error = res >= 0 ? ERROR_SUCCESS : INTERNET_ERROR_BASE; /* FIXME */
1194     if (error == ERROR_SUCCESS && file->cache_file)
1195     {
1196         DWORD bytes_written;
1197
1198         if (!WriteFile(file->cache_file_handle, buffer, *read, &bytes_written, NULL))
1199             WARN("WriteFile failed: %u\n", GetLastError());
1200     }
1201     return error;
1202 }
1203
1204 static DWORD FTPFILE_ReadFileExA(object_header_t *hdr, INTERNET_BUFFERSA *buffers,
1205     DWORD flags, DWORD_PTR context)
1206 {
1207     return FTPFILE_ReadFile(hdr, buffers->lpvBuffer, buffers->dwBufferLength, &buffers->dwBufferLength);
1208 }
1209
1210 static DWORD FTPFILE_ReadFileExW(object_header_t *hdr, INTERNET_BUFFERSW *buffers,
1211     DWORD flags, DWORD_PTR context)
1212 {
1213     return FTPFILE_ReadFile(hdr, buffers->lpvBuffer, buffers->dwBufferLength, &buffers->dwBufferLength);
1214 }
1215
1216 static DWORD FTPFILE_WriteFile(object_header_t *hdr, const void *buffer, DWORD size, DWORD *written)
1217 {
1218     ftp_file_t *lpwh = (ftp_file_t*) hdr;
1219     int res;
1220
1221     res = send(lpwh->nDataSocket, buffer, size, 0);
1222
1223     *written = res>0 ? res : 0;
1224     return res >= 0 ? ERROR_SUCCESS : sock_get_error(errno);
1225 }
1226
1227 static void FTP_ReceiveRequestData(ftp_file_t *file, BOOL first_notif)
1228 {
1229     INTERNET_ASYNC_RESULT iar;
1230     BYTE buffer[4096];
1231     int available;
1232
1233     TRACE("%p\n", file);
1234
1235     available = recv(file->nDataSocket, buffer, sizeof(buffer), MSG_PEEK);
1236
1237     if(available != -1) {
1238         iar.dwResult = (DWORD_PTR)file->hdr.hInternet;
1239         iar.dwError = first_notif ? 0 : available;
1240     }else {
1241         iar.dwResult = 0;
1242         iar.dwError = INTERNET_GetLastError();
1243     }
1244
1245     INTERNET_SendCallback(&file->hdr, file->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE, &iar,
1246                           sizeof(INTERNET_ASYNC_RESULT));
1247 }
1248
1249 static void FTPFILE_AsyncQueryDataAvailableProc(WORKREQUEST *workRequest)
1250 {
1251     ftp_file_t *file = (ftp_file_t*)workRequest->hdr;
1252
1253     FTP_ReceiveRequestData(file, FALSE);
1254 }
1255
1256 static DWORD FTPFILE_QueryDataAvailable(object_header_t *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
1257 {
1258     ftp_file_t *file = (ftp_file_t*) hdr;
1259     int retval, unread = 0;
1260
1261     TRACE("(%p %p %x %lx)\n", file, available, flags, ctx);
1262
1263 #ifdef FIONREAD
1264     retval = ioctlsocket(file->nDataSocket, FIONREAD, &unread);
1265     if (!retval)
1266         TRACE("%d bytes of queued, but unread data\n", unread);
1267 #else
1268     FIXME("FIONREAD not available\n");
1269 #endif
1270
1271     *available = unread;
1272
1273     if(!unread) {
1274         BYTE byte;
1275
1276         *available = 0;
1277
1278         retval = recv(file->nDataSocket, &byte, 1, MSG_PEEK);
1279         if(retval > 0) {
1280             WORKREQUEST workRequest;
1281
1282             *available = 0;
1283             workRequest.asyncproc = FTPFILE_AsyncQueryDataAvailableProc;
1284             workRequest.hdr = WININET_AddRef( &file->hdr );
1285
1286             INTERNET_AsyncCall(&workRequest);
1287
1288             return ERROR_IO_PENDING;
1289         }
1290     }
1291
1292     return ERROR_SUCCESS;
1293 }
1294
1295
1296 static const object_vtbl_t FTPFILEVtbl = {
1297     FTPFILE_Destroy,
1298     NULL,
1299     FTPFILE_QueryOption,
1300     NULL,
1301     FTPFILE_ReadFile,
1302     FTPFILE_ReadFileExA,
1303     FTPFILE_ReadFileExW,
1304     FTPFILE_WriteFile,
1305     FTPFILE_QueryDataAvailable,
1306     NULL
1307 };
1308
1309 /***********************************************************************
1310  *           FTP_FtpOpenFileW (Internal)
1311  *
1312  * Open a remote file for writing or reading
1313  *
1314  * RETURNS
1315  *    HINTERNET handle on success
1316  *    NULL on failure
1317  *
1318  */
1319 static HINTERNET FTP_FtpOpenFileW(ftp_session_t *lpwfs,
1320         LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1321         DWORD_PTR dwContext)
1322 {
1323     INT nDataSocket;
1324     BOOL bSuccess = FALSE;
1325     ftp_file_t *lpwh = NULL;
1326     appinfo_t *hIC = NULL;
1327
1328     TRACE("\n");
1329
1330     /* Clear any error information */
1331     INTERNET_SetLastError(0);
1332
1333     if (GENERIC_READ == fdwAccess)
1334     {
1335         /* Set up socket to retrieve data */
1336         bSuccess = FTP_SendRetrieve(lpwfs, lpszFileName, dwFlags);
1337     }
1338     else if (GENERIC_WRITE == fdwAccess)
1339     {
1340         /* Set up socket to send data */
1341         bSuccess = FTP_SendStore(lpwfs, lpszFileName, dwFlags);
1342     }
1343
1344     /* Get data socket to server */
1345     if (bSuccess && FTP_GetDataSocket(lpwfs, &nDataSocket))
1346     {
1347         lpwh = alloc_object(&lpwfs->hdr, &FTPFILEVtbl, sizeof(ftp_file_t));
1348         lpwh->hdr.htype = WH_HFILE;
1349         lpwh->hdr.dwFlags = dwFlags;
1350         lpwh->hdr.dwContext = dwContext;
1351         lpwh->nDataSocket = nDataSocket;
1352         lpwh->cache_file = NULL;
1353         lpwh->cache_file_handle = INVALID_HANDLE_VALUE;
1354         lpwh->session_deleted = FALSE;
1355
1356         WININET_AddRef( &lpwfs->hdr );
1357         lpwh->lpFtpSession = lpwfs;
1358         list_add_head( &lpwfs->hdr.children, &lpwh->hdr.entry );
1359
1360         /* Indicate that a download is currently in progress */
1361         lpwfs->download_in_progress = lpwh;
1362     }
1363
1364     if (lpwfs->lstnSocket != -1)
1365     {
1366         closesocket(lpwfs->lstnSocket);
1367         lpwfs->lstnSocket = -1;
1368     }
1369
1370     if (bSuccess && fdwAccess == GENERIC_READ)
1371     {
1372         WCHAR filename[MAX_PATH + 1];
1373         URL_COMPONENTSW uc;
1374         DWORD len;
1375
1376         memset(&uc, 0, sizeof(uc));
1377         uc.dwStructSize = sizeof(uc);
1378         uc.nScheme      = INTERNET_SCHEME_FTP;
1379         uc.lpszHostName = lpwfs->servername;
1380         uc.nPort        = lpwfs->serverport;
1381         uc.lpszUserName = lpwfs->lpszUserName;
1382         uc.lpszUrlPath  = heap_strdupW(lpszFileName);
1383
1384         if (!InternetCreateUrlW(&uc, 0, NULL, &len) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1385         {
1386             WCHAR *url = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1387
1388             if (url && InternetCreateUrlW(&uc, 0, url, &len) && CreateUrlCacheEntryW(url, 0, NULL, filename, 0))
1389             {
1390                 lpwh->cache_file = heap_strdupW(filename);
1391                 lpwh->cache_file_handle = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ,
1392                                                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1393                 if (lpwh->cache_file_handle == INVALID_HANDLE_VALUE)
1394                 {
1395                     WARN("Could not create cache file: %u\n", GetLastError());
1396                     HeapFree(GetProcessHeap(), 0, lpwh->cache_file);
1397                     lpwh->cache_file = NULL;
1398                 }
1399             }
1400             HeapFree(GetProcessHeap(), 0, url);
1401         }
1402         HeapFree(GetProcessHeap(), 0, uc.lpszUrlPath);
1403     }
1404
1405     hIC = lpwfs->lpAppInfo;
1406     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1407     {
1408         INTERNET_ASYNC_RESULT iar;
1409
1410         if (lpwh)
1411         {
1412             iar.dwResult = (DWORD_PTR)lpwh->hdr.hInternet;
1413             iar.dwError = ERROR_SUCCESS;
1414             SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
1415                 &iar, sizeof(INTERNET_ASYNC_RESULT));
1416         }
1417
1418         if(bSuccess) {
1419             FTP_ReceiveRequestData(lpwh, TRUE);
1420         }else {
1421             iar.dwResult = 0;
1422             iar.dwError = INTERNET_GetLastError();
1423             SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1424                     &iar, sizeof(INTERNET_ASYNC_RESULT));
1425         }
1426     }
1427
1428     if(!bSuccess) {
1429         if(lpwh)
1430             WININET_Release( &lpwh->hdr );
1431         return FALSE;
1432     }
1433
1434     return lpwh->hdr.hInternet;
1435 }
1436
1437
1438 /***********************************************************************
1439  *           FtpOpenFileA (WININET.@)
1440  *
1441  * Open a remote file for writing or reading
1442  *
1443  * RETURNS
1444  *    HINTERNET handle on success
1445  *    NULL on failure
1446  *
1447  */
1448 HINTERNET WINAPI FtpOpenFileA(HINTERNET hFtpSession,
1449     LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1450     DWORD_PTR dwContext)
1451 {
1452     LPWSTR lpwzFileName;
1453     HINTERNET ret;
1454
1455     lpwzFileName = heap_strdupAtoW(lpszFileName);
1456     ret = FtpOpenFileW(hFtpSession, lpwzFileName, fdwAccess, dwFlags, dwContext);
1457     HeapFree(GetProcessHeap(), 0, lpwzFileName);
1458     return ret;
1459 }
1460
1461
1462 static void AsyncFtpOpenFileProc(WORKREQUEST *workRequest)
1463 {
1464     struct WORKREQ_FTPOPENFILEW const *req = &workRequest->u.FtpOpenFileW;
1465     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1466
1467     TRACE("%p\n", lpwfs);
1468
1469     FTP_FtpOpenFileW(lpwfs, req->lpszFilename,
1470         req->dwAccess, req->dwFlags, req->dwContext);
1471     HeapFree(GetProcessHeap(), 0, req->lpszFilename);
1472 }
1473
1474 /***********************************************************************
1475  *           FtpOpenFileW (WININET.@)
1476  *
1477  * Open a remote file for writing or reading
1478  *
1479  * RETURNS
1480  *    HINTERNET handle on success
1481  *    NULL on failure
1482  *
1483  */
1484 HINTERNET WINAPI FtpOpenFileW(HINTERNET hFtpSession,
1485     LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1486     DWORD_PTR dwContext)
1487 {
1488     ftp_session_t *lpwfs;
1489     appinfo_t *hIC = NULL;
1490     HINTERNET r = NULL;
1491
1492     TRACE("(%p,%s,0x%08x,0x%08x,0x%08lx)\n", hFtpSession,
1493         debugstr_w(lpszFileName), fdwAccess, dwFlags, dwContext);
1494
1495     lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1496     if (!lpwfs)
1497     {
1498         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1499         return FALSE;
1500     }
1501
1502     if (WH_HFTPSESSION != lpwfs->hdr.htype)
1503     {
1504         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1505         goto lend;
1506     }
1507
1508     if ((!lpszFileName) ||
1509         ((fdwAccess != GENERIC_READ) && (fdwAccess != GENERIC_WRITE)) ||
1510         ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY))
1511     {
1512         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1513         goto lend;
1514     }
1515
1516     if (lpwfs->download_in_progress != NULL)
1517     {
1518         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1519         goto lend;
1520     }
1521
1522     hIC = lpwfs->lpAppInfo;
1523     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1524     {
1525         WORKREQUEST workRequest;
1526         struct WORKREQ_FTPOPENFILEW *req;
1527
1528         workRequest.asyncproc = AsyncFtpOpenFileProc;
1529         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1530         req = &workRequest.u.FtpOpenFileW;
1531         req->lpszFilename = heap_strdupW(lpszFileName);
1532         req->dwAccess = fdwAccess;
1533         req->dwFlags = dwFlags;
1534         req->dwContext = dwContext;
1535
1536         INTERNET_AsyncCall(&workRequest);
1537         r = NULL;
1538     }
1539     else
1540     {
1541         r = FTP_FtpOpenFileW(lpwfs, lpszFileName, fdwAccess, dwFlags, dwContext);
1542     }
1543
1544 lend:
1545     WININET_Release( &lpwfs->hdr );
1546
1547     return r;
1548 }
1549
1550
1551 /***********************************************************************
1552  *           FtpGetFileA (WININET.@)
1553  *
1554  * Retrieve file from the FTP server
1555  *
1556  * RETURNS
1557  *    TRUE on success
1558  *    FALSE on failure
1559  *
1560  */
1561 BOOL WINAPI FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile,
1562     BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1563     DWORD_PTR dwContext)
1564 {
1565     LPWSTR lpwzRemoteFile;
1566     LPWSTR lpwzNewFile;
1567     BOOL ret;
1568
1569     lpwzRemoteFile = heap_strdupAtoW(lpszRemoteFile);
1570     lpwzNewFile = heap_strdupAtoW(lpszNewFile);
1571     ret = FtpGetFileW(hInternet, lpwzRemoteFile, lpwzNewFile, fFailIfExists,
1572         dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1573     HeapFree(GetProcessHeap(), 0, lpwzRemoteFile);
1574     HeapFree(GetProcessHeap(), 0, lpwzNewFile);
1575     return ret;
1576 }
1577
1578
1579 static void AsyncFtpGetFileProc(WORKREQUEST *workRequest)
1580 {
1581     struct WORKREQ_FTPGETFILEW const *req = &workRequest->u.FtpGetFileW;
1582     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1583
1584     TRACE("%p\n", lpwfs);
1585
1586     FTP_FtpGetFileW(lpwfs, req->lpszRemoteFile,
1587              req->lpszNewFile, req->fFailIfExists,
1588              req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext);
1589     HeapFree(GetProcessHeap(), 0, req->lpszRemoteFile);
1590     HeapFree(GetProcessHeap(), 0, req->lpszNewFile);
1591 }
1592
1593
1594 /***********************************************************************
1595  *           FtpGetFileW (WININET.@)
1596  *
1597  * Retrieve file from the FTP server
1598  *
1599  * RETURNS
1600  *    TRUE on success
1601  *    FALSE on failure
1602  *
1603  */
1604 BOOL WINAPI FtpGetFileW(HINTERNET hInternet, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1605     BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1606     DWORD_PTR dwContext)
1607 {
1608     ftp_session_t *lpwfs;
1609     appinfo_t *hIC = NULL;
1610     BOOL r = FALSE;
1611
1612     if (!lpszRemoteFile || !lpszNewFile)
1613     {
1614         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1615         return FALSE;
1616     }
1617
1618     lpwfs = (ftp_session_t*) get_handle_object( hInternet );
1619     if (!lpwfs)
1620     {
1621         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1622         return FALSE;
1623     }
1624
1625     if (WH_HFTPSESSION != lpwfs->hdr.htype)
1626     {
1627         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1628         goto lend;
1629     }
1630
1631     if ((dwInternetFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
1632     {
1633         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1634         goto lend;
1635     }
1636
1637     if (lpwfs->download_in_progress != NULL)
1638     {
1639         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1640         goto lend;
1641     }
1642
1643     hIC = lpwfs->lpAppInfo;
1644     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1645     {
1646         WORKREQUEST workRequest;
1647         struct WORKREQ_FTPGETFILEW *req;
1648
1649         workRequest.asyncproc = AsyncFtpGetFileProc;
1650         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1651         req = &workRequest.u.FtpGetFileW;
1652         req->lpszRemoteFile = heap_strdupW(lpszRemoteFile);
1653         req->lpszNewFile = heap_strdupW(lpszNewFile);
1654         req->dwLocalFlagsAttribute = dwLocalFlagsAttribute;
1655         req->fFailIfExists = fFailIfExists;
1656         req->dwFlags = dwInternetFlags;
1657         req->dwContext = dwContext;
1658
1659         r = res_to_le(INTERNET_AsyncCall(&workRequest));
1660     }
1661     else
1662     {
1663         r = FTP_FtpGetFileW(lpwfs, lpszRemoteFile, lpszNewFile,
1664            fFailIfExists, dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1665     }
1666
1667 lend:
1668     WININET_Release( &lpwfs->hdr );
1669
1670     return r;
1671 }
1672
1673
1674 /***********************************************************************
1675  *           FTP_FtpGetFileW (Internal)
1676  *
1677  * Retrieve file from the FTP server
1678  *
1679  * RETURNS
1680  *    TRUE on success
1681  *    FALSE on failure
1682  *
1683  */
1684 static BOOL FTP_FtpGetFileW(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1685         BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1686         DWORD_PTR dwContext)
1687 {
1688     BOOL bSuccess = FALSE;
1689     HANDLE hFile;
1690     appinfo_t *hIC = NULL;
1691
1692     TRACE("lpszRemoteFile(%s) lpszNewFile(%s)\n", debugstr_w(lpszRemoteFile), debugstr_w(lpszNewFile));
1693
1694     /* Clear any error information */
1695     INTERNET_SetLastError(0);
1696
1697     /* Ensure we can write to lpszNewfile by opening it */
1698     hFile = CreateFileW(lpszNewFile, GENERIC_WRITE, 0, 0, fFailIfExists ?
1699         CREATE_NEW : CREATE_ALWAYS, dwLocalFlagsAttribute, 0);
1700     if (INVALID_HANDLE_VALUE == hFile)
1701         return FALSE;
1702
1703     /* Set up socket to retrieve data */
1704     if (FTP_SendRetrieve(lpwfs, lpszRemoteFile, dwInternetFlags))
1705     {
1706         INT nDataSocket;
1707
1708         /* Get data socket to server */
1709         if (FTP_GetDataSocket(lpwfs, &nDataSocket))
1710         {
1711             INT nResCode;
1712
1713             /* Receive data */
1714             FTP_RetrieveFileData(lpwfs, nDataSocket, hFile);
1715             closesocket(nDataSocket);
1716
1717             nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
1718             if (nResCode)
1719             {
1720                 if (nResCode == 226)
1721                     bSuccess = TRUE;
1722                 else
1723                     FTP_SetResponseError(nResCode);
1724             }
1725         }
1726     }
1727
1728     if (lpwfs->lstnSocket != -1)
1729     {
1730         closesocket(lpwfs->lstnSocket);
1731         lpwfs->lstnSocket = -1;
1732     }
1733
1734     CloseHandle(hFile);
1735
1736     hIC = lpwfs->lpAppInfo;
1737     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1738     {
1739         INTERNET_ASYNC_RESULT iar;
1740
1741         iar.dwResult = (DWORD)bSuccess;
1742         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1743         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1744             &iar, sizeof(INTERNET_ASYNC_RESULT));
1745     }
1746
1747     if (!bSuccess) DeleteFileW(lpszNewFile);
1748     return bSuccess;
1749 }
1750
1751 /***********************************************************************
1752  *           FtpGetFileSize  (WININET.@)
1753  */
1754 DWORD WINAPI FtpGetFileSize( HINTERNET hFile, LPDWORD lpdwFileSizeHigh )
1755 {
1756     FIXME("(%p, %p)\n", hFile, lpdwFileSizeHigh);
1757
1758     if (lpdwFileSizeHigh)
1759         *lpdwFileSizeHigh = 0;
1760
1761     return 0;
1762 }
1763
1764 /***********************************************************************
1765  *           FtpDeleteFileA  (WININET.@)
1766  *
1767  * Delete a file on the ftp server
1768  *
1769  * RETURNS
1770  *    TRUE on success
1771  *    FALSE on failure
1772  *
1773  */
1774 BOOL WINAPI FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName)
1775 {
1776     LPWSTR lpwzFileName;
1777     BOOL ret;
1778
1779     lpwzFileName = heap_strdupAtoW(lpszFileName);
1780     ret = FtpDeleteFileW(hFtpSession, lpwzFileName);
1781     HeapFree(GetProcessHeap(), 0, lpwzFileName);
1782     return ret;
1783 }
1784
1785 static void AsyncFtpDeleteFileProc(WORKREQUEST *workRequest)
1786 {
1787     struct WORKREQ_FTPDELETEFILEW const *req = &workRequest->u.FtpDeleteFileW;
1788     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1789
1790     TRACE("%p\n", lpwfs);
1791
1792     FTP_FtpDeleteFileW(lpwfs, req->lpszFilename);
1793     HeapFree(GetProcessHeap(), 0, req->lpszFilename);
1794 }
1795
1796 /***********************************************************************
1797  *           FtpDeleteFileW  (WININET.@)
1798  *
1799  * Delete a file on the ftp server
1800  *
1801  * RETURNS
1802  *    TRUE on success
1803  *    FALSE on failure
1804  *
1805  */
1806 BOOL WINAPI FtpDeleteFileW(HINTERNET hFtpSession, LPCWSTR lpszFileName)
1807 {
1808     ftp_session_t *lpwfs;
1809     appinfo_t *hIC = NULL;
1810     BOOL r = FALSE;
1811
1812     lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1813     if (!lpwfs)
1814     {
1815         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1816         return FALSE;
1817     }
1818
1819     if (WH_HFTPSESSION != lpwfs->hdr.htype)
1820     {
1821         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1822         goto lend;
1823     }
1824
1825     if (lpwfs->download_in_progress != NULL)
1826     {
1827         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1828         goto lend;
1829     }
1830
1831     if (!lpszFileName)
1832     {
1833         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1834         goto lend;
1835     }
1836
1837     hIC = lpwfs->lpAppInfo;
1838     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1839     {
1840         WORKREQUEST workRequest;
1841         struct WORKREQ_FTPDELETEFILEW *req;
1842
1843         workRequest.asyncproc = AsyncFtpDeleteFileProc;
1844         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1845         req = &workRequest.u.FtpDeleteFileW;
1846         req->lpszFilename = heap_strdupW(lpszFileName);
1847
1848         r = res_to_le(INTERNET_AsyncCall(&workRequest));
1849     }
1850     else
1851     {
1852         r = FTP_FtpDeleteFileW(lpwfs, lpszFileName);
1853     }
1854
1855 lend:
1856     WININET_Release( &lpwfs->hdr );
1857
1858     return r;
1859 }
1860
1861 /***********************************************************************
1862  *           FTP_FtpDeleteFileW  (Internal)
1863  *
1864  * Delete a file on the ftp server
1865  *
1866  * RETURNS
1867  *    TRUE on success
1868  *    FALSE on failure
1869  *
1870  */
1871 BOOL FTP_FtpDeleteFileW(ftp_session_t *lpwfs, LPCWSTR lpszFileName)
1872 {
1873     INT nResCode;
1874     BOOL bSuccess = FALSE;
1875     appinfo_t *hIC = NULL;
1876
1877     TRACE("%p\n", lpwfs);
1878
1879     /* Clear any error information */
1880     INTERNET_SetLastError(0);
1881
1882     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_DELE, lpszFileName, 0, 0, 0))
1883         goto lend;
1884
1885     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1886     if (nResCode)
1887     {
1888         if (nResCode == 250)
1889             bSuccess = TRUE;
1890         else
1891             FTP_SetResponseError(nResCode);
1892     }
1893 lend:
1894     hIC = lpwfs->lpAppInfo;
1895     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1896     {
1897         INTERNET_ASYNC_RESULT iar;
1898
1899         iar.dwResult = (DWORD)bSuccess;
1900         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1901         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1902             &iar, sizeof(INTERNET_ASYNC_RESULT));
1903     }
1904
1905     return bSuccess;
1906 }
1907
1908
1909 /***********************************************************************
1910  *           FtpRemoveDirectoryA  (WININET.@)
1911  *
1912  * Remove a directory on the ftp server
1913  *
1914  * RETURNS
1915  *    TRUE on success
1916  *    FALSE on failure
1917  *
1918  */
1919 BOOL WINAPI FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory)
1920 {
1921     LPWSTR lpwzDirectory;
1922     BOOL ret;
1923
1924     lpwzDirectory = heap_strdupAtoW(lpszDirectory);
1925     ret = FtpRemoveDirectoryW(hFtpSession, lpwzDirectory);
1926     HeapFree(GetProcessHeap(), 0, lpwzDirectory);
1927     return ret;
1928 }
1929
1930 static void AsyncFtpRemoveDirectoryProc(WORKREQUEST *workRequest)
1931 {
1932     struct WORKREQ_FTPREMOVEDIRECTORYW const *req = &workRequest->u.FtpRemoveDirectoryW;
1933     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1934
1935     TRACE("%p\n", lpwfs);
1936
1937     FTP_FtpRemoveDirectoryW(lpwfs, req->lpszDirectory);
1938     HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
1939 }
1940
1941 /***********************************************************************
1942  *           FtpRemoveDirectoryW  (WININET.@)
1943  *
1944  * Remove a directory on the ftp server
1945  *
1946  * RETURNS
1947  *    TRUE on success
1948  *    FALSE on failure
1949  *
1950  */
1951 BOOL WINAPI FtpRemoveDirectoryW(HINTERNET hFtpSession, LPCWSTR lpszDirectory)
1952 {
1953     ftp_session_t *lpwfs;
1954     appinfo_t *hIC = NULL;
1955     BOOL r = FALSE;
1956
1957     lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1958     if (!lpwfs)
1959     {
1960         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1961         return FALSE;
1962     }
1963
1964     if (WH_HFTPSESSION != lpwfs->hdr.htype)
1965     {
1966         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1967         goto lend;
1968     }
1969
1970     if (lpwfs->download_in_progress != NULL)
1971     {
1972         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1973         goto lend;
1974     }
1975
1976     if (!lpszDirectory)
1977     {
1978         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1979         goto lend;
1980     }
1981
1982     hIC = lpwfs->lpAppInfo;
1983     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1984     {
1985         WORKREQUEST workRequest;
1986         struct WORKREQ_FTPREMOVEDIRECTORYW *req;
1987
1988         workRequest.asyncproc = AsyncFtpRemoveDirectoryProc;
1989         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1990         req = &workRequest.u.FtpRemoveDirectoryW;
1991         req->lpszDirectory = heap_strdupW(lpszDirectory);
1992
1993         r = res_to_le(INTERNET_AsyncCall(&workRequest));
1994     }
1995     else
1996     {
1997         r = FTP_FtpRemoveDirectoryW(lpwfs, lpszDirectory);
1998     }
1999
2000 lend:
2001     WININET_Release( &lpwfs->hdr );
2002
2003     return r;
2004 }
2005
2006 /***********************************************************************
2007  *           FTP_FtpRemoveDirectoryW  (Internal)
2008  *
2009  * Remove a directory on the ftp server
2010  *
2011  * RETURNS
2012  *    TRUE on success
2013  *    FALSE on failure
2014  *
2015  */
2016 BOOL FTP_FtpRemoveDirectoryW(ftp_session_t *lpwfs, LPCWSTR lpszDirectory)
2017 {
2018     INT nResCode;
2019     BOOL bSuccess = FALSE;
2020     appinfo_t *hIC = NULL;
2021
2022     TRACE("\n");
2023
2024     /* Clear any error information */
2025     INTERNET_SetLastError(0);
2026
2027     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RMD, lpszDirectory, 0, 0, 0))
2028         goto lend;
2029
2030     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2031     if (nResCode)
2032     {
2033         if (nResCode == 250)
2034             bSuccess = TRUE;
2035         else
2036             FTP_SetResponseError(nResCode);
2037     }
2038
2039 lend:
2040     hIC = lpwfs->lpAppInfo;
2041     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2042     {
2043         INTERNET_ASYNC_RESULT iar;
2044
2045         iar.dwResult = (DWORD)bSuccess;
2046         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
2047         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
2048             &iar, sizeof(INTERNET_ASYNC_RESULT));
2049     }
2050
2051     return bSuccess;
2052 }
2053
2054
2055 /***********************************************************************
2056  *           FtpRenameFileA  (WININET.@)
2057  *
2058  * Rename a file on the ftp server
2059  *
2060  * RETURNS
2061  *    TRUE on success
2062  *    FALSE on failure
2063  *
2064  */
2065 BOOL WINAPI FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
2066 {
2067     LPWSTR lpwzSrc;
2068     LPWSTR lpwzDest;
2069     BOOL ret;
2070
2071     lpwzSrc = heap_strdupAtoW(lpszSrc);
2072     lpwzDest = heap_strdupAtoW(lpszDest);
2073     ret = FtpRenameFileW(hFtpSession, lpwzSrc, lpwzDest);
2074     HeapFree(GetProcessHeap(), 0, lpwzSrc);
2075     HeapFree(GetProcessHeap(), 0, lpwzDest);
2076     return ret;
2077 }
2078
2079 static void AsyncFtpRenameFileProc(WORKREQUEST *workRequest)
2080 {
2081     struct WORKREQ_FTPRENAMEFILEW const *req = &workRequest->u.FtpRenameFileW;
2082     ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
2083
2084     TRACE("%p\n", lpwfs);
2085
2086     FTP_FtpRenameFileW(lpwfs, req->lpszSrcFile, req->lpszDestFile);
2087     HeapFree(GetProcessHeap(), 0, req->lpszSrcFile);
2088     HeapFree(GetProcessHeap(), 0, req->lpszDestFile);
2089 }
2090
2091 /***********************************************************************
2092  *           FtpRenameFileW  (WININET.@)
2093  *
2094  * Rename a file on the ftp server
2095  *
2096  * RETURNS
2097  *    TRUE on success
2098  *    FALSE on failure
2099  *
2100  */
2101 BOOL WINAPI FtpRenameFileW(HINTERNET hFtpSession, LPCWSTR lpszSrc, LPCWSTR lpszDest)
2102 {
2103     ftp_session_t *lpwfs;
2104     appinfo_t *hIC = NULL;
2105     BOOL r = FALSE;
2106
2107     lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
2108     if (!lpwfs)
2109     {
2110         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2111         return FALSE;
2112     }
2113
2114     if (WH_HFTPSESSION != lpwfs->hdr.htype)
2115     {
2116         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2117         goto lend;
2118     }
2119
2120     if (lpwfs->download_in_progress != NULL)
2121     {
2122         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
2123         goto lend;
2124     }
2125
2126     if (!lpszSrc || !lpszDest)
2127     {
2128         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2129         goto lend;
2130     }
2131
2132     hIC = lpwfs->lpAppInfo;
2133     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2134     {
2135         WORKREQUEST workRequest;
2136         struct WORKREQ_FTPRENAMEFILEW *req;
2137
2138         workRequest.asyncproc = AsyncFtpRenameFileProc;
2139         workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
2140         req = &workRequest.u.FtpRenameFileW;
2141         req->lpszSrcFile = heap_strdupW(lpszSrc);
2142         req->lpszDestFile = heap_strdupW(lpszDest);
2143
2144         r = res_to_le(INTERNET_AsyncCall(&workRequest));
2145     }
2146     else
2147     {
2148         r = FTP_FtpRenameFileW(lpwfs, lpszSrc, lpszDest);
2149     }
2150
2151 lend:
2152     WININET_Release( &lpwfs->hdr );
2153
2154     return r;
2155 }
2156
2157 /***********************************************************************
2158  *           FTP_FtpRenameFileW  (Internal)
2159  *
2160  * Rename a file on the ftp server
2161  *
2162  * RETURNS
2163  *    TRUE on success
2164  *    FALSE on failure
2165  *
2166  */
2167 BOOL FTP_FtpRenameFileW(ftp_session_t *lpwfs, LPCWSTR lpszSrc, LPCWSTR lpszDest)
2168 {
2169     INT nResCode;
2170     BOOL bSuccess = FALSE;
2171     appinfo_t *hIC = NULL;
2172
2173     TRACE("\n");
2174
2175     /* Clear any error information */
2176     INTERNET_SetLastError(0);
2177
2178     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNFR, lpszSrc, 0, 0, 0))
2179         goto lend;
2180
2181     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2182     if (nResCode == 350)
2183     {
2184         if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNTO, lpszDest, 0, 0, 0))
2185             goto lend;
2186
2187         nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2188     }
2189
2190     if (nResCode == 250)
2191         bSuccess = TRUE;
2192     else
2193         FTP_SetResponseError(nResCode);
2194
2195 lend:
2196     hIC = lpwfs->lpAppInfo;
2197     if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2198     {
2199         INTERNET_ASYNC_RESULT iar;
2200
2201         iar.dwResult = (DWORD)bSuccess;
2202         iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
2203         SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
2204             &iar, sizeof(INTERNET_ASYNC_RESULT));
2205     }
2206
2207     return bSuccess;
2208 }
2209
2210 /***********************************************************************
2211  *           FtpCommandA  (WININET.@)
2212  */
2213 BOOL WINAPI FtpCommandA( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
2214                          LPCSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
2215 {
2216     BOOL r;
2217     WCHAR *cmdW;
2218
2219     TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
2220           debugstr_a(lpszCommand), dwContext, phFtpCommand);
2221
2222     if (fExpectResponse)
2223     {
2224         FIXME("data connection not supported\n");
2225         return FALSE;
2226     }
2227
2228     if (!lpszCommand || !lpszCommand[0])
2229     {
2230         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2231         return FALSE;
2232     }
2233
2234     if (!(cmdW = heap_strdupAtoW(lpszCommand)))
2235     {
2236         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2237         return FALSE;
2238     }
2239
2240     r = FtpCommandW(hConnect, fExpectResponse, dwFlags, cmdW, dwContext, phFtpCommand);
2241
2242     HeapFree(GetProcessHeap(), 0, cmdW);
2243     return r;
2244 }
2245
2246 /***********************************************************************
2247  *           FtpCommandW  (WININET.@)
2248  */
2249 BOOL WINAPI FtpCommandW( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
2250                          LPCWSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
2251 {
2252     BOOL r = FALSE;
2253     ftp_session_t *lpwfs;
2254     LPSTR cmd = NULL;
2255     DWORD len, nBytesSent= 0;
2256     INT nResCode, nRC = 0;
2257
2258     TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
2259            debugstr_w(lpszCommand), dwContext, phFtpCommand);
2260
2261     if (!lpszCommand || !lpszCommand[0])
2262     {
2263         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2264         return FALSE;
2265     }
2266
2267     if (fExpectResponse)
2268     {
2269         FIXME("data connection not supported\n");
2270         return FALSE;
2271     }
2272
2273     lpwfs = (ftp_session_t*) get_handle_object( hConnect );
2274     if (!lpwfs)
2275     {
2276         INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2277         return FALSE;
2278     }
2279
2280     if (WH_HFTPSESSION != lpwfs->hdr.htype)
2281     {
2282         INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2283         goto lend;
2284     }
2285
2286     if (lpwfs->download_in_progress != NULL)
2287     {
2288         INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
2289         goto lend;
2290     }
2291
2292     len = WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, NULL, 0, NULL, NULL) + strlen(szCRLF);
2293     if ((cmd = HeapAlloc(GetProcessHeap(), 0, len )))
2294         WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, cmd, len, NULL, NULL);
2295     else
2296     {
2297         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2298         goto lend;
2299     }
2300
2301     strcat(cmd, szCRLF);
2302     len--;
2303
2304     TRACE("Sending (%s) len(%d)\n", cmd, len);
2305     while ((nBytesSent < len) && (nRC != -1))
2306     {
2307         nRC = send(lpwfs->sndSocket, cmd + nBytesSent, len - nBytesSent, 0);
2308         if (nRC != -1)
2309         {
2310             nBytesSent += nRC;
2311             TRACE("Sent %d bytes\n", nRC);
2312         }
2313     }
2314
2315     if (nBytesSent)
2316     {
2317         nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2318         if (nResCode > 0 && nResCode < 400)
2319             r = TRUE;
2320         else
2321             FTP_SetResponseError(nResCode);
2322     }
2323
2324 lend:
2325     WININET_Release( &lpwfs->hdr );
2326     HeapFree(GetProcessHeap(), 0, cmd);
2327     return r;
2328 }
2329
2330
2331 /***********************************************************************
2332  *           FTPSESSION_Destroy (internal)
2333  *
2334  * Deallocate session handle
2335  */
2336 static void FTPSESSION_Destroy(object_header_t *hdr)
2337 {
2338     ftp_session_t *lpwfs = (ftp_session_t*) hdr;
2339
2340     TRACE("\n");
2341
2342     WININET_Release(&lpwfs->lpAppInfo->hdr);
2343
2344     HeapFree(GetProcessHeap(), 0, lpwfs->lpszPassword);
2345     HeapFree(GetProcessHeap(), 0, lpwfs->lpszUserName);
2346     HeapFree(GetProcessHeap(), 0, lpwfs->servername);
2347 }
2348
2349 static void FTPSESSION_CloseConnection(object_header_t *hdr)
2350 {
2351     ftp_session_t *lpwfs = (ftp_session_t*) hdr;
2352
2353     TRACE("\n");
2354
2355     SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
2356                       INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
2357
2358     if (lpwfs->download_in_progress != NULL)
2359         lpwfs->download_in_progress->session_deleted = TRUE;
2360
2361      if (lpwfs->sndSocket != -1)
2362          closesocket(lpwfs->sndSocket);
2363
2364      if (lpwfs->lstnSocket != -1)
2365          closesocket(lpwfs->lstnSocket);
2366
2367     if (lpwfs->pasvSocket != -1)
2368         closesocket(lpwfs->pasvSocket);
2369
2370     SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
2371                       INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
2372 }
2373
2374 static DWORD FTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
2375 {
2376     switch(option) {
2377     case INTERNET_OPTION_HANDLE_TYPE:
2378         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
2379
2380         if (*size < sizeof(ULONG))
2381             return ERROR_INSUFFICIENT_BUFFER;
2382
2383         *size = sizeof(DWORD);
2384         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_FTP;
2385         return ERROR_SUCCESS;
2386     }
2387
2388     return INET_QueryOption(hdr, option, buffer, size, unicode);
2389 }
2390
2391 static const object_vtbl_t FTPSESSIONVtbl = {
2392     FTPSESSION_Destroy,
2393     FTPSESSION_CloseConnection,
2394     FTPSESSION_QueryOption,
2395     NULL,
2396     NULL,
2397     NULL,
2398     NULL,
2399     NULL,
2400     NULL
2401 };
2402
2403
2404 /***********************************************************************
2405  *           FTP_Connect (internal)
2406  *
2407  * Connect to a ftp server
2408  *
2409  * RETURNS
2410  *   HINTERNET a session handle on success
2411  *   NULL on failure
2412  *
2413  * NOTES:
2414  *
2415  * Windows uses 'anonymous' as the username, when given a NULL username
2416  * and a NULL password. The password is first looked up in:
2417  *
2418  * HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\EmailName
2419  *
2420  * If this entry is not present it uses the current username as the password.
2421  *
2422  */
2423
2424 HINTERNET FTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
2425         INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
2426         LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
2427         DWORD dwInternalFlags)
2428 {
2429     static const WCHAR szKey[] = {'S','o','f','t','w','a','r','e','\\',
2430                                    'M','i','c','r','o','s','o','f','t','\\',
2431                                    'W','i','n','d','o','w','s','\\',
2432                                    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2433                                    'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0};
2434     static const WCHAR szValue[] = {'E','m','a','i','l','N','a','m','e',0};
2435     static const WCHAR szDefaultUsername[] = {'a','n','o','n','y','m','o','u','s','\0'};
2436     static const WCHAR szEmpty[] = {'\0'};
2437     struct sockaddr_in socketAddr;
2438     INT nsocket = -1;
2439     UINT sock_namelen;
2440     BOOL bSuccess = FALSE;
2441     ftp_session_t *lpwfs = NULL;
2442     char szaddr[INET_ADDRSTRLEN];
2443
2444     TRACE("%p  Server(%s) Port(%d) User(%s) Paswd(%s)\n",
2445             hIC, debugstr_w(lpszServerName),
2446             nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword));
2447
2448     assert( hIC->hdr.htype == WH_HINIT );
2449
2450     if ((!lpszUserName || !*lpszUserName) && lpszPassword && *lpszPassword)
2451     {
2452         INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2453         return NULL;
2454     }
2455
2456     lpwfs = alloc_object(&hIC->hdr, &FTPSESSIONVtbl, sizeof(ftp_session_t));
2457     if (NULL == lpwfs)
2458     {
2459         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2460         return NULL;
2461     }
2462
2463     if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
2464         lpwfs->serverport = INTERNET_DEFAULT_FTP_PORT;
2465     else
2466         lpwfs->serverport = nServerPort;
2467
2468     lpwfs->hdr.htype = WH_HFTPSESSION;
2469     lpwfs->hdr.dwFlags = dwFlags;
2470     lpwfs->hdr.dwContext = dwContext;
2471     lpwfs->hdr.dwInternalFlags |= dwInternalFlags;
2472     lpwfs->download_in_progress = NULL;
2473     lpwfs->sndSocket = -1;
2474     lpwfs->lstnSocket = -1;
2475     lpwfs->pasvSocket = -1;
2476
2477     WININET_AddRef( &hIC->hdr );
2478     lpwfs->lpAppInfo = hIC;
2479     list_add_head( &hIC->hdr.children, &lpwfs->hdr.entry );
2480
2481     if(hIC->proxy && hIC->accessType == INTERNET_OPEN_TYPE_PROXY) {
2482         if(strchrW(hIC->proxy, ' '))
2483             FIXME("Several proxies not implemented.\n");
2484         if(hIC->proxyBypass)
2485             FIXME("Proxy bypass is ignored.\n");
2486     }
2487     if (!lpszUserName || !strlenW(lpszUserName)) {
2488         HKEY key;
2489         WCHAR szPassword[MAX_PATH];
2490         DWORD len = sizeof(szPassword);
2491
2492         lpwfs->lpszUserName = heap_strdupW(szDefaultUsername);
2493
2494         RegOpenKeyW(HKEY_CURRENT_USER, szKey, &key);
2495         if (RegQueryValueExW(key, szValue, NULL, NULL, (LPBYTE)szPassword, &len)) {
2496             /* Nothing in the registry, get the username and use that as the password */
2497             if (!GetUserNameW(szPassword, &len)) {
2498                 /* Should never get here, but use an empty password as failsafe */
2499                 strcpyW(szPassword, szEmpty);
2500             }
2501         }
2502         RegCloseKey(key);
2503
2504         TRACE("Password used for anonymous ftp : (%s)\n", debugstr_w(szPassword));
2505         lpwfs->lpszPassword = heap_strdupW(szPassword);
2506     }
2507     else {
2508         lpwfs->lpszUserName = heap_strdupW(lpszUserName);
2509         lpwfs->lpszPassword = heap_strdupW(lpszPassword ? lpszPassword : szEmpty);
2510     }
2511     lpwfs->servername = heap_strdupW(lpszServerName);
2512
2513     /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
2514     if (!(lpwfs->hdr.dwInternalFlags & INET_OPENURL))
2515     {
2516         INTERNET_ASYNC_RESULT iar;
2517
2518         iar.dwResult = (DWORD_PTR)lpwfs->hdr.hInternet;
2519         iar.dwError = ERROR_SUCCESS;
2520
2521         SendAsyncCallback(&hIC->hdr, dwContext,
2522                       INTERNET_STATUS_HANDLE_CREATED, &iar,
2523                       sizeof(INTERNET_ASYNC_RESULT));
2524     }
2525
2526     SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_RESOLVING_NAME,
2527         (LPWSTR) lpszServerName, (strlenW(lpszServerName)+1) * sizeof(WCHAR));
2528
2529     sock_namelen = sizeof(socketAddr);
2530     if (!GetAddress(lpszServerName, lpwfs->serverport, (struct sockaddr *)&socketAddr, &sock_namelen))
2531     {
2532         INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
2533         goto lerror;
2534     }
2535
2536     if (socketAddr.sin_family != AF_INET)
2537     {
2538         WARN("unsupported address family %d\n", socketAddr.sin_family);
2539         INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2540         goto lerror;
2541     }
2542
2543     inet_ntop(socketAddr.sin_family, &socketAddr.sin_addr, szaddr, sizeof(szaddr));
2544     SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_NAME_RESOLVED,
2545                       szaddr, strlen(szaddr)+1);
2546
2547     nsocket = socket(AF_INET,SOCK_STREAM,0);
2548     if (nsocket == -1)
2549     {
2550         INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2551         goto lerror;
2552     }
2553
2554     SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
2555                       szaddr, strlen(szaddr)+1);
2556
2557     if (connect(nsocket, (struct sockaddr *)&socketAddr, sock_namelen) < 0)
2558     {
2559         ERR("Unable to connect (%s)\n", strerror(errno));
2560         INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2561         closesocket(nsocket);
2562     }
2563     else
2564     {
2565         TRACE("Connected to server\n");
2566         lpwfs->sndSocket = nsocket;
2567         SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
2568                           szaddr, strlen(szaddr)+1);
2569
2570         sock_namelen = sizeof(lpwfs->socketAddress);
2571         getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
2572
2573         if (FTP_ConnectToHost(lpwfs))
2574         {
2575             TRACE("Successfully logged into server\n");
2576             bSuccess = TRUE;
2577         }
2578     }
2579
2580 lerror:
2581     if (!bSuccess)
2582     {
2583         if(lpwfs)
2584             WININET_Release( &lpwfs->hdr );
2585         return NULL;
2586     }
2587
2588     return lpwfs->hdr.hInternet;
2589 }
2590
2591
2592 /***********************************************************************
2593  *           FTP_ConnectToHost (internal)
2594  *
2595  * Connect to a ftp server
2596  *
2597  * RETURNS
2598  *   TRUE on success
2599  *   NULL on failure
2600  *
2601  */
2602 static BOOL FTP_ConnectToHost(ftp_session_t *lpwfs)
2603 {
2604     INT nResCode;
2605     BOOL bSuccess = FALSE;
2606
2607     TRACE("\n");
2608     FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2609
2610     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
2611         goto lend;
2612
2613     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2614     if (nResCode)
2615     {
2616         /* Login successful... */
2617         if (nResCode == 230)
2618             bSuccess = TRUE;
2619         /* User name okay, need password... */
2620         else if (nResCode == 331)
2621             bSuccess = FTP_SendPassword(lpwfs);
2622         /* Need account for login... */
2623         else if (nResCode == 332)
2624             bSuccess = FTP_SendAccount(lpwfs);
2625         else
2626             FTP_SetResponseError(nResCode);
2627     }
2628
2629     TRACE("Returning %d\n", bSuccess);
2630 lend:
2631     return bSuccess;
2632 }
2633
2634
2635 /***********************************************************************
2636  *           FTP_SendCommandA (internal)
2637  *
2638  * Send command to server
2639  *
2640  * RETURNS
2641  *   TRUE on success
2642  *   NULL on failure
2643  *
2644  */
2645 static BOOL FTP_SendCommandA(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
2646         INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
2647 {
2648         DWORD len;
2649         CHAR *buf;
2650         DWORD nBytesSent = 0;
2651         int nRC = 0;
2652         DWORD dwParamLen;
2653
2654         TRACE("%d: (%s) %d\n", ftpCmd, lpszParam, nSocket);
2655
2656         if (lpfnStatusCB)
2657         {
2658             lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
2659         }
2660
2661         dwParamLen = lpszParam?strlen(lpszParam)+1:0;
2662         len = dwParamLen + strlen(szFtpCommands[ftpCmd]) + strlen(szCRLF);
2663         if (NULL == (buf = HeapAlloc(GetProcessHeap(), 0, len+1)))
2664         {
2665             INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2666             return FALSE;
2667         }
2668         sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], dwParamLen ? " " : "",
2669                 dwParamLen ? lpszParam : "", szCRLF);
2670
2671         TRACE("Sending (%s) len(%d)\n", buf, len);
2672         while((nBytesSent < len) && (nRC != -1))
2673         {
2674                 nRC = send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
2675                 nBytesSent += nRC;
2676         }
2677
2678         HeapFree(GetProcessHeap(), 0, (LPVOID)buf);
2679
2680         if (lpfnStatusCB)
2681         {
2682             lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_REQUEST_SENT,
2683                          &nBytesSent, sizeof(DWORD));
2684         }
2685
2686         TRACE("Sent %d bytes\n", nBytesSent);
2687         return (nRC != -1);
2688 }
2689
2690 /***********************************************************************
2691  *           FTP_SendCommand (internal)
2692  *
2693  * Send command to server
2694  *
2695  * RETURNS
2696  *   TRUE on success
2697  *   NULL on failure
2698  *
2699  */
2700 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
2701         INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
2702 {
2703     BOOL ret;
2704     LPSTR lpszParamA = heap_strdupWtoA(lpszParam);
2705     ret = FTP_SendCommandA(nSocket, ftpCmd, lpszParamA, lpfnStatusCB, hdr, dwContext);
2706     HeapFree(GetProcessHeap(), 0, lpszParamA);
2707     return ret;
2708 }
2709
2710 /***********************************************************************
2711  *           FTP_ReceiveResponse (internal)
2712  *
2713  * Receive response from server
2714  *
2715  * RETURNS
2716  *   Reply code on success
2717  *   0 on failure
2718  *
2719  */
2720 INT FTP_ReceiveResponse(ftp_session_t *lpwfs, DWORD_PTR dwContext)
2721 {
2722     LPSTR lpszResponse = INTERNET_GetResponseBuffer();
2723     DWORD nRecv;
2724     INT rc = 0;
2725     char firstprefix[5];
2726     BOOL multiline = FALSE;
2727
2728     TRACE("socket(%d)\n", lpwfs->sndSocket);
2729
2730     SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2731
2732     while(1)
2733     {
2734         if (!INTERNET_GetNextLine(lpwfs->sndSocket, &nRecv))
2735             goto lerror;
2736
2737         if (nRecv >= 3)
2738         {
2739             if(!multiline)
2740             {
2741                 if(lpszResponse[3] != '-')
2742                     break;
2743                 else
2744                 {  /* Start of multiline response.  Loop until we get "nnn " */
2745                     multiline = TRUE;
2746                     memcpy(firstprefix, lpszResponse, 3);
2747                     firstprefix[3] = ' ';
2748                     firstprefix[4] = '\0';
2749                 }
2750             }
2751             else
2752             {
2753                 if(!memcmp(firstprefix, lpszResponse, 4))
2754                     break;
2755             }
2756         }
2757     }
2758
2759     if (nRecv >= 3)
2760     {
2761         rc = atoi(lpszResponse);
2762
2763         SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2764                     &nRecv, sizeof(DWORD));
2765     }
2766
2767 lerror:
2768     TRACE("return %d\n", rc);
2769     return rc;
2770 }
2771
2772
2773 /***********************************************************************
2774  *           FTP_SendPassword (internal)
2775  *
2776  * Send password to ftp server
2777  *
2778  * RETURNS
2779  *   TRUE on success
2780  *   NULL on failure
2781  *
2782  */
2783 static BOOL FTP_SendPassword(ftp_session_t *lpwfs)
2784 {
2785     INT nResCode;
2786     BOOL bSuccess = FALSE;
2787
2788     TRACE("\n");
2789     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
2790         goto lend;
2791
2792     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2793     if (nResCode)
2794     {
2795         TRACE("Received reply code %d\n", nResCode);
2796         /* Login successful... */
2797         if (nResCode == 230)
2798             bSuccess = TRUE;
2799         /* Command not implemented, superfluous at the server site... */
2800         /* Need account for login... */
2801         else if (nResCode == 332)
2802             bSuccess = FTP_SendAccount(lpwfs);
2803         else
2804             FTP_SetResponseError(nResCode);
2805     }
2806
2807 lend:
2808     TRACE("Returning %d\n", bSuccess);
2809     return bSuccess;
2810 }
2811
2812
2813 /***********************************************************************
2814  *           FTP_SendAccount (internal)
2815  *
2816  *
2817  *
2818  * RETURNS
2819  *   TRUE on success
2820  *   FALSE on failure
2821  *
2822  */
2823 static BOOL FTP_SendAccount(ftp_session_t *lpwfs)
2824 {
2825     INT nResCode;
2826     BOOL bSuccess = FALSE;
2827
2828     TRACE("\n");
2829     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, szNoAccount, 0, 0, 0))
2830         goto lend;
2831
2832     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2833     if (nResCode)
2834         bSuccess = TRUE;
2835     else
2836         FTP_SetResponseError(nResCode);
2837
2838 lend:
2839     return bSuccess;
2840 }
2841
2842
2843 /***********************************************************************
2844  *           FTP_SendStore (internal)
2845  *
2846  * Send request to upload file to ftp server
2847  *
2848  * RETURNS
2849  *   TRUE on success
2850  *   FALSE on failure
2851  *
2852  */
2853 static BOOL FTP_SendStore(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2854 {
2855     INT nResCode;
2856     BOOL bSuccess = FALSE;
2857
2858     TRACE("\n");
2859     if (!FTP_InitListenSocket(lpwfs))
2860         goto lend;
2861
2862     if (!FTP_SendType(lpwfs, dwType))
2863         goto lend;
2864
2865     if (!FTP_SendPortOrPasv(lpwfs))
2866         goto lend;
2867
2868     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
2869             goto lend;
2870     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2871     if (nResCode)
2872     {
2873         if (nResCode == 150 || nResCode == 125)
2874             bSuccess = TRUE;
2875         else
2876             FTP_SetResponseError(nResCode);
2877     }
2878
2879 lend:
2880     if (!bSuccess && lpwfs->lstnSocket != -1)
2881     {
2882         closesocket(lpwfs->lstnSocket);
2883         lpwfs->lstnSocket = -1;
2884     }
2885
2886     return bSuccess;
2887 }
2888
2889
2890 /***********************************************************************
2891  *           FTP_InitListenSocket (internal)
2892  *
2893  * Create a socket to listen for server response
2894  *
2895  * RETURNS
2896  *   TRUE on success
2897  *   FALSE on failure
2898  *
2899  */
2900 static BOOL FTP_InitListenSocket(ftp_session_t *lpwfs)
2901 {
2902     BOOL bSuccess = FALSE;
2903     socklen_t namelen = sizeof(lpwfs->lstnSocketAddress);
2904
2905     TRACE("\n");
2906
2907     lpwfs->lstnSocket = socket(PF_INET, SOCK_STREAM, 0);
2908     if (lpwfs->lstnSocket == -1)
2909     {
2910         TRACE("Unable to create listening socket\n");
2911             goto lend;
2912     }
2913
2914     /* We obtain our ip addr from the name of the command channel socket */
2915     lpwfs->lstnSocketAddress = lpwfs->socketAddress;
2916
2917     /* and get the system to assign us a port */
2918     lpwfs->lstnSocketAddress.sin_port = htons(0);
2919
2920     if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(lpwfs->lstnSocketAddress)) == -1)
2921     {
2922         TRACE("Unable to bind socket\n");
2923         goto lend;
2924     }
2925
2926     if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
2927     {
2928         TRACE("listen failed\n");
2929         goto lend;
2930     }
2931
2932     if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
2933         bSuccess = TRUE;
2934
2935 lend:
2936     if (!bSuccess && lpwfs->lstnSocket != -1)
2937     {
2938         closesocket(lpwfs->lstnSocket);
2939         lpwfs->lstnSocket = -1;
2940     }
2941
2942     return bSuccess;
2943 }
2944
2945
2946 /***********************************************************************
2947  *           FTP_SendType (internal)
2948  *
2949  * Tell server type of data being transferred
2950  *
2951  * RETURNS
2952  *   TRUE on success
2953  *   FALSE on failure
2954  *
2955  * W98SE doesn't cache the type that's currently set
2956  * (i.e. it sends it always),
2957  * so we probably don't want to do that either.
2958  */
2959 static BOOL FTP_SendType(ftp_session_t *lpwfs, DWORD dwType)
2960 {
2961     INT nResCode;
2962     WCHAR type[] = { 'I','\0' };
2963     BOOL bSuccess = FALSE;
2964
2965     TRACE("\n");
2966     if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
2967         type[0] = 'A';
2968
2969     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
2970         goto lend;
2971
2972     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext)/100;
2973     if (nResCode)
2974     {
2975         if (nResCode == 2)
2976             bSuccess = TRUE;
2977         else
2978             FTP_SetResponseError(nResCode);
2979     }
2980
2981 lend:
2982     return bSuccess;
2983 }
2984
2985
2986 #if 0  /* FIXME: should probably be used for FtpGetFileSize */
2987 /***********************************************************************
2988  *           FTP_GetFileSize (internal)
2989  *
2990  * Retrieves from the server the size of the given file
2991  *
2992  * RETURNS
2993  *   TRUE on success
2994  *   FALSE on failure
2995  *
2996  */
2997 static BOOL FTP_GetFileSize(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD *dwSize)
2998 {
2999     INT nResCode;
3000     BOOL bSuccess = FALSE;
3001
3002     TRACE("\n");
3003
3004     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_SIZE, lpszRemoteFile, 0, 0, 0))
3005         goto lend;
3006
3007     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3008     if (nResCode)
3009     {
3010         if (nResCode == 213) {
3011             /* Now parses the output to get the actual file size */
3012             int i;
3013             LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
3014
3015             for (i = 0; (lpszResponseBuffer[i] != ' ') && (lpszResponseBuffer[i] != '\0'); i++) ;
3016             if (lpszResponseBuffer[i] == '\0') return FALSE;
3017             *dwSize = atol(&(lpszResponseBuffer[i + 1]));
3018
3019             bSuccess = TRUE;
3020         } else {
3021             FTP_SetResponseError(nResCode);
3022         }
3023     }
3024
3025 lend:
3026     return bSuccess;
3027 }
3028 #endif
3029
3030
3031 /***********************************************************************
3032  *           FTP_SendPort (internal)
3033  *
3034  * Tell server which port to use
3035  *
3036  * RETURNS
3037  *   TRUE on success
3038  *   FALSE on failure
3039  *
3040  */
3041 static BOOL FTP_SendPort(ftp_session_t *lpwfs)
3042 {
3043     static const WCHAR szIPFormat[] = {'%','d',',','%','d',',','%','d',',','%','d',',','%','d',',','%','d','\0'};
3044     INT nResCode;
3045     WCHAR szIPAddress[64];
3046     BOOL bSuccess = FALSE;
3047     TRACE("\n");
3048
3049     sprintfW(szIPAddress, szIPFormat,
3050          lpwfs->lstnSocketAddress.sin_addr.s_addr&0x000000FF,
3051         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x0000FF00)>>8,
3052         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x00FF0000)>>16,
3053         (lpwfs->lstnSocketAddress.sin_addr.s_addr&0xFF000000)>>24,
3054         lpwfs->lstnSocketAddress.sin_port & 0xFF,
3055         (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
3056
3057     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
3058         goto lend;
3059
3060     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3061     if (nResCode)
3062     {
3063         if (nResCode == 200)
3064             bSuccess = TRUE;
3065         else
3066             FTP_SetResponseError(nResCode);
3067     }
3068
3069 lend:
3070     return bSuccess;
3071 }
3072
3073
3074 /***********************************************************************
3075  *           FTP_DoPassive (internal)
3076  *
3077  * Tell server that we want to do passive transfers
3078  * and connect data socket
3079  *
3080  * RETURNS
3081  *   TRUE on success
3082  *   FALSE on failure
3083  *
3084  */
3085 static BOOL FTP_DoPassive(ftp_session_t *lpwfs)
3086 {
3087     INT nResCode;
3088     BOOL bSuccess = FALSE;
3089
3090     TRACE("\n");
3091     if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
3092         goto lend;
3093
3094     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3095     if (nResCode)
3096     {
3097         if (nResCode == 227)
3098         {
3099             LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
3100             LPSTR p;
3101             int f[6];
3102             int i;
3103             char *pAddr, *pPort;
3104             INT nsocket = -1;
3105             struct sockaddr_in dataSocketAddress;
3106
3107             p = lpszResponseBuffer+4; /* skip status code */
3108             while (*p != '\0' && (*p < '0' || *p > '9')) p++;
3109
3110             if (*p == '\0')
3111             {
3112                 ERR("no address found in response, aborting\n");
3113                 goto lend;
3114             }
3115
3116             if (sscanf(p, "%d,%d,%d,%d,%d,%d",  &f[0], &f[1], &f[2], &f[3],
3117                                                 &f[4], &f[5]) != 6)
3118             {
3119                 ERR("unknown response address format '%s', aborting\n", p);
3120                 goto lend;
3121             }
3122             for (i=0; i < 6; i++)
3123                 f[i] = f[i] & 0xff;
3124
3125             dataSocketAddress = lpwfs->socketAddress;
3126             pAddr = (char *)&(dataSocketAddress.sin_addr.s_addr);
3127             pPort = (char *)&(dataSocketAddress.sin_port);
3128             pAddr[0] = f[0];
3129             pAddr[1] = f[1];
3130             pAddr[2] = f[2];
3131             pAddr[3] = f[3];
3132             pPort[0] = f[4];
3133             pPort[1] = f[5];
3134
3135             nsocket = socket(AF_INET,SOCK_STREAM,0);
3136             if (nsocket == -1)
3137                 goto lend;
3138
3139             if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
3140             {
3141                 ERR("can't connect passive FTP data port.\n");
3142                 closesocket(nsocket);
3143                 goto lend;
3144             }
3145             lpwfs->pasvSocket = nsocket;
3146             bSuccess = TRUE;
3147         }
3148         else
3149             FTP_SetResponseError(nResCode);
3150     }
3151
3152 lend:
3153     return bSuccess;
3154 }
3155
3156
3157 static BOOL FTP_SendPortOrPasv(ftp_session_t *lpwfs)
3158 {
3159     if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
3160     {
3161         if (!FTP_DoPassive(lpwfs))
3162             return FALSE;
3163     }
3164     else
3165     {
3166         if (!FTP_SendPort(lpwfs))
3167             return FALSE;
3168     }
3169     return TRUE;
3170 }
3171
3172
3173 /***********************************************************************
3174  *           FTP_GetDataSocket (internal)
3175  *
3176  * Either accepts an incoming data socket connection from the server
3177  * or just returns the already opened socket after a PASV command
3178  * in case of passive FTP.
3179  *
3180  *
3181  * RETURNS
3182  *   TRUE on success
3183  *   FALSE on failure
3184  *
3185  */
3186 static BOOL FTP_GetDataSocket(ftp_session_t *lpwfs, LPINT nDataSocket)
3187 {
3188     struct sockaddr_in saddr;
3189     socklen_t addrlen = sizeof(struct sockaddr);
3190
3191     TRACE("\n");
3192     if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
3193     {
3194         *nDataSocket = lpwfs->pasvSocket;
3195         lpwfs->pasvSocket = -1;
3196     }
3197     else
3198     {
3199         *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
3200         closesocket(lpwfs->lstnSocket);
3201         lpwfs->lstnSocket = -1;
3202     }
3203     return *nDataSocket != -1;
3204 }
3205
3206
3207 /***********************************************************************
3208  *           FTP_SendData (internal)
3209  *
3210  * Send data to the server
3211  *
3212  * RETURNS
3213  *   TRUE on success
3214  *   FALSE on failure
3215  *
3216  */
3217 static BOOL FTP_SendData(ftp_session_t *lpwfs, INT nDataSocket, HANDLE hFile)
3218 {
3219     BY_HANDLE_FILE_INFORMATION fi;
3220     DWORD nBytesRead = 0;
3221     DWORD nBytesSent = 0;
3222     DWORD nTotalSent = 0;
3223     DWORD nBytesToSend, nLen;
3224     int nRC = 1;
3225     time_t s_long_time, e_long_time;
3226     LONG nSeconds;
3227     CHAR *lpszBuffer;
3228
3229     TRACE("\n");
3230     lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
3231
3232     /* Get the size of the file. */
3233     GetFileInformationByHandle(hFile, &fi);
3234     time(&s_long_time);
3235
3236     do
3237     {
3238         nBytesToSend = nBytesRead - nBytesSent;
3239
3240         if (nBytesToSend <= 0)
3241         {
3242             /* Read data from file. */
3243             nBytesSent = 0;
3244             if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
3245             ERR("Failed reading from file\n");
3246
3247             if (nBytesRead > 0)
3248                 nBytesToSend = nBytesRead;
3249             else
3250                 break;
3251         }
3252
3253         nLen = DATA_PACKET_SIZE < nBytesToSend ?
3254             DATA_PACKET_SIZE : nBytesToSend;
3255         nRC  = send(nDataSocket, lpszBuffer, nLen, 0);
3256
3257         if (nRC != -1)
3258         {
3259             nBytesSent += nRC;
3260             nTotalSent += nRC;
3261         }
3262
3263         /* Do some computation to display the status. */
3264         time(&e_long_time);
3265         nSeconds = e_long_time - s_long_time;
3266         if( nSeconds / 60 > 0 )
3267         {
3268             TRACE( "%d bytes of %d bytes (%d%%) in %d min %d sec estimated remaining time %d sec\n",
3269             nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
3270             nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
3271         }
3272         else
3273         {
3274             TRACE( "%d bytes of %d bytes (%d%%) in %d sec estimated remaining time %d sec\n",
3275             nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
3276             (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
3277         }
3278     } while (nRC != -1);
3279
3280     TRACE("file transfer complete!\n");
3281
3282     HeapFree(GetProcessHeap(), 0, lpszBuffer);
3283
3284     return nTotalSent;
3285 }
3286
3287
3288 /***********************************************************************
3289  *           FTP_SendRetrieve (internal)
3290  *
3291  * Send request to retrieve a file
3292  *
3293  * RETURNS
3294  *   Number of bytes to be received on success
3295  *   0 on failure
3296  *
3297  */
3298 static BOOL FTP_SendRetrieve(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
3299 {
3300     INT nResCode;
3301     BOOL ret;
3302
3303     TRACE("\n");
3304     if (!(ret = FTP_InitListenSocket(lpwfs)))
3305         goto lend;
3306
3307     if (!(ret = FTP_SendType(lpwfs, dwType)))
3308         goto lend;
3309
3310     if (!(ret = FTP_SendPortOrPasv(lpwfs)))
3311         goto lend;
3312
3313     if (!(ret = FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0)))
3314         goto lend;
3315
3316     nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3317     if ((nResCode != 125) && (nResCode != 150)) {
3318         /* That means that we got an error getting the file. */
3319         FTP_SetResponseError(nResCode);
3320         ret = FALSE;
3321     }
3322
3323 lend:
3324     if (!ret && lpwfs->lstnSocket != -1)
3325     {
3326         closesocket(lpwfs->lstnSocket);
3327         lpwfs->lstnSocket = -1;
3328     }
3329
3330     return ret;
3331 }
3332
3333
3334 /***********************************************************************
3335  *           FTP_RetrieveData  (internal)
3336  *
3337  * Retrieve data from server
3338  *
3339  * RETURNS
3340  *   TRUE on success
3341  *   FALSE on failure
3342  *
3343  */
3344 static BOOL FTP_RetrieveFileData(ftp_session_t *lpwfs, INT nDataSocket, HANDLE hFile)
3345 {
3346     DWORD nBytesWritten;
3347     INT nRC = 0;
3348     CHAR *lpszBuffer;
3349
3350     TRACE("\n");
3351
3352     lpszBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHAR)*DATA_PACKET_SIZE);
3353     if (NULL == lpszBuffer)
3354     {
3355         INTERNET_SetLastError(ERROR_OUTOFMEMORY);
3356         return FALSE;
3357     }
3358
3359     while (nRC != -1)
3360     {
3361         nRC = recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
3362         if (nRC != -1)
3363         {
3364             /* other side closed socket. */
3365             if (nRC == 0)
3366                 goto recv_end;
3367             WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
3368         }
3369     }
3370
3371     TRACE("Data transfer complete\n");
3372
3373 recv_end:
3374     HeapFree(GetProcessHeap(), 0, lpszBuffer);
3375
3376     return  (nRC != -1);
3377 }
3378
3379 /***********************************************************************
3380  *           FTPFINDNEXT_Destroy (internal)
3381  *
3382  * Deallocate session handle
3383  */
3384 static void FTPFINDNEXT_Destroy(object_header_t *hdr)
3385 {
3386     LPWININETFTPFINDNEXTW lpwfn = (LPWININETFTPFINDNEXTW) hdr;
3387     DWORD i;
3388
3389     TRACE("\n");
3390
3391     WININET_Release(&lpwfn->lpFtpSession->hdr);
3392
3393     for (i = 0; i < lpwfn->size; i++)
3394     {
3395         HeapFree(GetProcessHeap(), 0, lpwfn->lpafp[i].lpszName);
3396     }
3397
3398     HeapFree(GetProcessHeap(), 0, lpwfn->lpafp);
3399 }
3400
3401 static DWORD FTPFINDNEXT_FindNextFileProc(WININETFTPFINDNEXTW *find, LPVOID data)
3402 {
3403     WIN32_FIND_DATAW *find_data = data;
3404     DWORD res = ERROR_SUCCESS;
3405
3406     TRACE("index(%d) size(%d)\n", find->index, find->size);
3407
3408     ZeroMemory(find_data, sizeof(WIN32_FIND_DATAW));
3409
3410     if (find->index < find->size) {
3411         FTP_ConvertFileProp(&find->lpafp[find->index], find_data);
3412         find->index++;
3413
3414         TRACE("Name: %s\nSize: %d\n", debugstr_w(find_data->cFileName), find_data->nFileSizeLow);
3415     }else {
3416         res = ERROR_NO_MORE_FILES;
3417     }
3418
3419     if (find->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3420     {
3421         INTERNET_ASYNC_RESULT iar;
3422
3423         iar.dwResult = (res == ERROR_SUCCESS);
3424         iar.dwError = res;
3425
3426         INTERNET_SendCallback(&find->hdr, find->hdr.dwContext,
3427                               INTERNET_STATUS_REQUEST_COMPLETE, &iar,
3428                               sizeof(INTERNET_ASYNC_RESULT));
3429     }
3430
3431     return res;
3432 }
3433
3434 static void FTPFINDNEXT_AsyncFindNextFileProc(WORKREQUEST *workRequest)
3435 {
3436     struct WORKREQ_FTPFINDNEXTW *req = &workRequest->u.FtpFindNextW;
3437
3438     FTPFINDNEXT_FindNextFileProc((WININETFTPFINDNEXTW*)workRequest->hdr, req->lpFindFileData);
3439 }
3440
3441 static DWORD FTPFINDNEXT_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
3442 {
3443     switch(option) {
3444     case INTERNET_OPTION_HANDLE_TYPE:
3445         TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
3446
3447         if (*size < sizeof(ULONG))
3448             return ERROR_INSUFFICIENT_BUFFER;
3449
3450         *size = sizeof(DWORD);
3451         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_FTP_FIND;
3452         return ERROR_SUCCESS;
3453     }
3454
3455     return INET_QueryOption(hdr, option, buffer, size, unicode);
3456 }
3457
3458 static DWORD FTPFINDNEXT_FindNextFileW(object_header_t *hdr, void *data)
3459 {
3460     WININETFTPFINDNEXTW *find = (WININETFTPFINDNEXTW*)hdr;
3461
3462     if (find->lpFtpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3463     {
3464         WORKREQUEST workRequest;
3465         struct WORKREQ_FTPFINDNEXTW *req;
3466
3467         workRequest.asyncproc = FTPFINDNEXT_AsyncFindNextFileProc;
3468         workRequest.hdr = WININET_AddRef( &find->hdr );
3469         req = &workRequest.u.FtpFindNextW;
3470         req->lpFindFileData = data;
3471
3472         INTERNET_AsyncCall(&workRequest);
3473
3474         return ERROR_SUCCESS;
3475     }
3476
3477     return FTPFINDNEXT_FindNextFileProc(find, data);
3478 }
3479
3480 static const object_vtbl_t FTPFINDNEXTVtbl = {
3481     FTPFINDNEXT_Destroy,
3482     NULL,
3483     FTPFINDNEXT_QueryOption,
3484     NULL,
3485     NULL,
3486     NULL,
3487     NULL,
3488     NULL,
3489     NULL,
3490     FTPFINDNEXT_FindNextFileW
3491 };
3492
3493 /***********************************************************************
3494  *           FTP_ReceiveFileList (internal)
3495  *
3496  * Read file list from server
3497  *
3498  * RETURNS
3499  *   Handle to file list on success
3500  *   NULL on failure
3501  *
3502  */
3503 static HINTERNET FTP_ReceiveFileList(ftp_session_t *lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3504         LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext)
3505 {
3506     DWORD dwSize = 0;
3507     LPFILEPROPERTIESW lpafp = NULL;
3508     LPWININETFTPFINDNEXTW lpwfn = NULL;
3509
3510     TRACE("(%p,%d,%s,%p,%08lx)\n", lpwfs, nSocket, debugstr_w(lpszSearchFile), lpFindFileData, dwContext);
3511
3512     if (FTP_ParseDirectory(lpwfs, nSocket, lpszSearchFile, &lpafp, &dwSize))
3513     {
3514         if(lpFindFileData)
3515             FTP_ConvertFileProp(lpafp, lpFindFileData);
3516
3517         lpwfn = alloc_object(&lpwfs->hdr, &FTPFINDNEXTVtbl, sizeof(WININETFTPFINDNEXTW));
3518         if (lpwfn)
3519         {
3520             lpwfn->hdr.htype = WH_HFTPFINDNEXT;
3521             lpwfn->hdr.dwContext = dwContext;
3522             lpwfn->index = 1; /* Next index is 1 since we return index 0 */
3523             lpwfn->size = dwSize;
3524             lpwfn->lpafp = lpafp;
3525
3526             WININET_AddRef( &lpwfs->hdr );
3527             lpwfn->lpFtpSession = lpwfs;
3528             list_add_head( &lpwfs->hdr.children, &lpwfn->hdr.entry );
3529         }
3530     }
3531
3532     TRACE("Matched %d files\n", dwSize);
3533     return lpwfn ? lpwfn->hdr.hInternet : NULL;
3534 }
3535
3536
3537 /***********************************************************************
3538  *           FTP_ConvertFileProp (internal)
3539  *
3540  * Converts FILEPROPERTIESW struct to WIN32_FIND_DATAA
3541  *
3542  * RETURNS
3543  *   TRUE on success
3544  *   FALSE on failure
3545  *
3546  */
3547 static BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData)
3548 {
3549     BOOL bSuccess = FALSE;
3550
3551     ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAW));
3552
3553     if (lpafp)
3554     {
3555         SystemTimeToFileTime( &lpafp->tmLastModified, &lpFindFileData->ftLastAccessTime );
3556         lpFindFileData->ftLastWriteTime = lpFindFileData->ftLastAccessTime;
3557         lpFindFileData->ftCreationTime = lpFindFileData->ftLastAccessTime;
3558
3559         /* Not all fields are filled in */
3560         lpFindFileData->nFileSizeHigh = 0; /* We do not handle files bigger than 0xFFFFFFFF bytes yet :-) */
3561         lpFindFileData->nFileSizeLow = lpafp->nSize;
3562
3563         if (lpafp->bIsDirectory)
3564             lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
3565
3566         if (lpafp->lpszName)
3567             lstrcpynW(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
3568
3569         bSuccess = TRUE;
3570     }
3571
3572     return bSuccess;
3573 }
3574
3575 /***********************************************************************
3576  *           FTP_ParseNextFile (internal)
3577  *
3578  * Parse the next line in file listing
3579  *
3580  * RETURNS
3581  *   TRUE on success
3582  *   FALSE on failure
3583  */
3584 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW lpfp)
3585 {
3586     static const char szSpace[] = " \t";
3587     DWORD nBufLen;
3588     char *pszLine;
3589     char *pszToken;
3590     char *pszTmp;
3591     BOOL found = FALSE;
3592     int i;
3593
3594     lpfp->lpszName = NULL;
3595     do {
3596         if(!(pszLine = INTERNET_GetNextLine(nSocket, &nBufLen)))
3597             return FALSE;
3598
3599         pszToken = strtok(pszLine, szSpace);
3600         /* ls format
3601          * <Permissions> <NoLinks> <owner>   <group> <size> <date>  <time or year> <filename>
3602          *
3603          * For instance:
3604          * drwx--s---     2         pcarrier  ens     512    Sep 28  1995           pcarrier
3605          */
3606         if(!isdigit(pszToken[0]) && 10 == strlen(pszToken)) {
3607             if(!FTP_ParsePermission(pszToken, lpfp))
3608                 lpfp->bIsDirectory = FALSE;
3609             for(i=0; i<=3; i++) {
3610               if(!(pszToken = strtok(NULL, szSpace)))
3611                   break;
3612             }
3613             if(!pszToken) continue;
3614             if(lpfp->bIsDirectory) {
3615                 TRACE("Is directory\n");
3616                 lpfp->nSize = 0;
3617             }
3618             else {
3619                 TRACE("Size: %s\n", pszToken);
3620                 lpfp->nSize = atol(pszToken);
3621             }
3622
3623             lpfp->tmLastModified.wSecond = 0;
3624             lpfp->tmLastModified.wMinute = 0;
3625             lpfp->tmLastModified.wHour   = 0;
3626             lpfp->tmLastModified.wDay    = 0;
3627             lpfp->tmLastModified.wMonth  = 0;
3628             lpfp->tmLastModified.wYear   = 0;
3629
3630             /* Determine month */
3631             pszToken = strtok(NULL, szSpace);
3632             if(!pszToken) continue;
3633             if(strlen(pszToken) >= 3) {
3634                 pszToken[3] = 0;
3635                 if((pszTmp = StrStrIA(szMonths, pszToken)))
3636                     lpfp->tmLastModified.wMonth = ((pszTmp - szMonths) / 3)+1;
3637             }
3638             /* Determine day */
3639             pszToken = strtok(NULL, szSpace);
3640             if(!pszToken) continue;
3641             lpfp->tmLastModified.wDay = atoi(pszToken);
3642             /* Determine time or year */
3643             pszToken = strtok(NULL, szSpace);
3644             if(!pszToken) continue;
3645             if((pszTmp = strchr(pszToken, ':'))) {
3646                 SYSTEMTIME curr_time;
3647                 *pszTmp = 0;
3648                 pszTmp++;
3649                 lpfp->tmLastModified.wMinute = atoi(pszTmp);
3650                 lpfp->tmLastModified.wHour = atoi(pszToken);
3651                 GetLocalTime( &curr_time );
3652                 lpfp->tmLastModified.wYear = curr_time.wYear;
3653             }
3654             else {
3655                 lpfp->tmLastModified.wYear = atoi(pszToken);
3656                 lpfp->tmLastModified.wHour = 12;
3657             }
3658             TRACE("Mod time: %02d:%02d:%02d  %04d/%02d/%02d\n",
3659                   lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
3660                   lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
3661
3662             pszToken = strtok(NULL, szSpace);
3663             if(!pszToken) continue;
3664             lpfp->lpszName = heap_strdupAtoW(pszToken);
3665             TRACE("File: %s\n", debugstr_w(lpfp->lpszName));
3666         }
3667         /* NT way of parsing ... :
3668
3669                 07-13-03  08:55PM       <DIR>          sakpatch
3670                 05-09-03  06:02PM             12656686 2003-04-21bgm_cmd_e.rgz
3671         */
3672         else if(isdigit(pszToken[0]) && 8 == strlen(pszToken)) {
3673             int mon, mday, year, hour, min;
3674             lpfp->permissions = 0xFFFF; /* No idea, put full permission :-) */
3675
3676             sscanf(pszToken, "%d-%d-%d", &mon, &mday, &year);
3677             lpfp->tmLastModified.wDay   = mday;
3678             lpfp->tmLastModified.wMonth = mon;
3679             lpfp->tmLastModified.wYear  = year;
3680
3681             /* Hacky and bad Y2K protection :-) */
3682             if (lpfp->tmLastModified.wYear < 70) lpfp->tmLastModified.wYear += 2000;
3683
3684             pszToken = strtok(NULL, szSpace);
3685             if(!pszToken) continue;
3686             sscanf(pszToken, "%d:%d", &hour, &min);
3687             lpfp->tmLastModified.wHour   = hour;
3688             lpfp->tmLastModified.wMinute = min;
3689             if((pszToken[5] == 'P') && (pszToken[6] == 'M')) {
3690                 lpfp->tmLastModified.wHour += 12;
3691             }
3692             lpfp->tmLastModified.wSecond = 0;
3693
3694             TRACE("Mod time: %02d:%02d:%02d  %04d/%02d/%02d\n",
3695                   lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
3696                   lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
3697
3698             pszToken = strtok(NULL, szSpace);
3699             if(!pszToken) continue;
3700             if(!strcasecmp(pszToken, "<DIR>")) {
3701                 lpfp->bIsDirectory = TRUE;
3702                 lpfp->nSize = 0;
3703                 TRACE("Is directory\n");
3704             }
3705             else {
3706                 lpfp->bIsDirectory = FALSE;
3707                 lpfp->nSize = atol(pszToken);
3708                 TRACE("Size: %d\n", lpfp->nSize);
3709             }
3710
3711             pszToken = strtok(NULL, szSpace);
3712             if(!pszToken) continue;
3713             lpfp->lpszName = heap_strdupAtoW(pszToken);
3714             TRACE("Name: %s\n", debugstr_w(lpfp->lpszName));
3715         }
3716         /* EPLF format - http://cr.yp.to/ftp/list/eplf.html */
3717         else if(pszToken[0] == '+') {
3718             FIXME("EPLF Format not implemented\n");
3719         }
3720
3721         if(lpfp->lpszName) {
3722             if((lpszSearchFile == NULL) ||
3723                (PathMatchSpecW(lpfp->lpszName, lpszSearchFile))) {
3724                 found = TRUE;
3725                 TRACE("Matched: %s\n", debugstr_w(lpfp->lpszName));
3726             }
3727             else {
3728                 HeapFree(GetProcessHeap(), 0, lpfp->lpszName);
3729                 lpfp->lpszName = NULL;
3730             }
3731         }
3732     } while(!found);
3733     return TRUE;
3734 }
3735
3736 /***********************************************************************
3737  *           FTP_ParseDirectory (internal)
3738  *
3739  * Parse string of directory information
3740  *
3741  * RETURNS
3742  *   TRUE on success
3743  *   FALSE on failure
3744  */
3745 static BOOL FTP_ParseDirectory(ftp_session_t *lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3746     LPFILEPROPERTIESW *lpafp, LPDWORD dwfp)
3747 {
3748     BOOL bSuccess = TRUE;
3749     INT sizeFilePropArray = 500;/*20; */
3750     INT indexFilePropArray = -1;
3751
3752     TRACE("\n");
3753
3754     /* Allocate initial file properties array */
3755     *lpafp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FILEPROPERTIESW)*(sizeFilePropArray));
3756     if (!*lpafp)
3757         return FALSE;
3758
3759     do {
3760         if (indexFilePropArray+1 >= sizeFilePropArray)
3761         {
3762             LPFILEPROPERTIESW tmpafp;
3763
3764             sizeFilePropArray *= 2;
3765             tmpafp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *lpafp,
3766                 sizeof(FILEPROPERTIESW)*sizeFilePropArray);
3767             if (NULL == tmpafp)
3768             {
3769                 bSuccess = FALSE;
3770                 break;
3771             }
3772
3773             *lpafp = tmpafp;
3774         }
3775         indexFilePropArray++;
3776     } while (FTP_ParseNextFile(nSocket, lpszSearchFile, &(*lpafp)[indexFilePropArray]));
3777
3778     if (bSuccess && indexFilePropArray)
3779     {
3780         if (indexFilePropArray < sizeFilePropArray - 1)
3781         {
3782             LPFILEPROPERTIESW tmpafp;
3783
3784             tmpafp = HeapReAlloc(GetProcessHeap(), 0, *lpafp,
3785                 sizeof(FILEPROPERTIESW)*indexFilePropArray);
3786             if (NULL != tmpafp)
3787                 *lpafp = tmpafp;
3788         }
3789         *dwfp = indexFilePropArray;
3790     }
3791     else
3792     {
3793         HeapFree(GetProcessHeap(), 0, *lpafp);
3794         INTERNET_SetLastError(ERROR_NO_MORE_FILES);
3795         bSuccess = FALSE;
3796     }
3797
3798     return bSuccess;
3799 }
3800
3801
3802 /***********************************************************************
3803  *           FTP_ParsePermission (internal)
3804  *
3805  * Parse permission string of directory information
3806  *
3807  * RETURNS
3808  *   TRUE on success
3809  *   FALSE on failure
3810  *
3811  */
3812 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp)
3813 {
3814     BOOL bSuccess = TRUE;
3815     unsigned short nPermission = 0;
3816     INT nPos = 1;
3817     INT nLast  = 9;
3818
3819     TRACE("\n");
3820     if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
3821     {
3822         bSuccess = FALSE;
3823         return bSuccess;
3824     }
3825
3826     lpfp->bIsDirectory = (*lpszPermission == 'd');
3827     do
3828     {
3829         switch (nPos)
3830         {
3831             case 1:
3832                 nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
3833                 break;
3834             case 2:
3835                 nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
3836                 break;
3837             case 3:
3838                 nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
3839                 break;
3840             case 4:
3841                 nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
3842                 break;
3843             case 5:
3844                 nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
3845                 break;
3846             case 6:
3847                 nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
3848                 break;
3849             case 7:
3850                 nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
3851                 break;
3852             case 8:
3853                 nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
3854                 break;
3855             case 9:
3856                 nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
3857                 break;
3858         }
3859         nPos++;
3860     }while (nPos <= nLast);
3861
3862     lpfp->permissions = nPermission;
3863     return bSuccess;
3864 }
3865
3866
3867 /***********************************************************************
3868  *           FTP_SetResponseError (internal)
3869  *
3870  * Set the appropriate error code for a given response from the server
3871  *
3872  * RETURNS
3873  *
3874  */
3875 static DWORD FTP_SetResponseError(DWORD dwResponse)
3876 {
3877     DWORD dwCode = 0;
3878
3879     switch(dwResponse)
3880     {
3881     case 425: /* Cannot open data connection. */
3882         dwCode = ERROR_INTERNET_CANNOT_CONNECT;
3883         break;
3884
3885     case 426: /* Connection closed, transer aborted. */
3886         dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
3887         break;
3888
3889     case 530: /* Not logged in. Login incorrect. */
3890         dwCode = ERROR_INTERNET_LOGIN_FAILURE;
3891         break;
3892
3893     case 421: /* Service not available - Server may be shutting down. */
3894     case 450: /* File action not taken. File may be busy. */
3895     case 451: /* Action aborted. Server error. */
3896     case 452: /* Action not taken. Insufficient storage space on server. */
3897     case 500: /* Syntax error. Command unrecognized. */
3898     case 501: /* Syntax error. Error in parameters or arguments. */
3899     case 502: /* Command not implemented. */
3900     case 503: /* Bad sequence of commands. */
3901     case 504: /* Command not implemented for that parameter. */
3902     case 532: /* Need account for storing files */
3903     case 550: /* File action not taken. File not found or no access. */
3904     case 551: /* Requested action aborted. Page type unknown */
3905     case 552: /* Action aborted. Exceeded storage allocation */
3906     case 553: /* Action not taken. File name not allowed. */
3907
3908     default:
3909         dwCode = ERROR_INTERNET_EXTENDED_ERROR;
3910         break;
3911     }
3912
3913     INTERNET_SetLastError(dwCode);
3914     return dwCode;
3915 }