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