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