ftp.c File Reference

#include "ws2tcpip.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wininet.h"
#include "winnls.h"
#include "winerror.h"
#include "winreg.h"
#include "winternl.h"
#include "shlwapi.h"
#include "wine/debug.h"
#include "internet.h"

Include dependency graph for ftp.c:

Go to the source code of this file.

Classes
struct	ftp_file_t
struct	_ftp_session_t
struct	FILEPROPERTIESW
struct	WININETFTPFINDNEXTW
struct	put_file_task_t
struct	directory_task_t
struct	find_first_file_task_t
struct	get_current_dir_task_t
struct	open_file_task_t
struct	get_file_task_t
struct	delete_file_task_t
struct	rename_file_task_t
struct	find_next_task_t

Macros
#define	RESPONSE_TIMEOUT   30
#define	DATA_PACKET_SIZE   0x2000
#define	szCRLF   "\r\n"
#define	MAX_BACKLOG   5
#define	FTP_CONDITION_MASK   0x0007

Typedefs
typedef struct _ftp_session_t	ftp_session_t
typedef struct FILEPROPERTIESW *	LPFILEPROPERTIESW
typedef struct WININETFTPFINDNEXTW *	LPWININETFTPFINDNEXTW

Enumerations
enum	FTP_COMMAND {   FTP_CMD_ACCT , FTP_CMD_CWD , FTP_CMD_DELE , FTP_CMD_MKD ,   FTP_CMD_PASS , FTP_CMD_PORT , FTP_CMD_RETR , FTP_CMD_RMD ,   FTP_CMD_RNFR , FTP_CMD_RNTO , FTP_CMD_STOR , FTP_CMD_TYPE ,   FTP_CMD_USER , FTP_CMD_SIZE , FTP_CMD_ABOR , FTP_CMD_LIST ,   FTP_CMD_NLST , FTP_CMD_PASV , FTP_CMD_PWD , FTP_CMD_QUIT }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wininet)
static BOOL	FTP_SendCommand (INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam, INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
static BOOL	FTP_SendStore (ftp_session_t *, LPCWSTR lpszRemoteFile, DWORD dwType)
static BOOL	FTP_GetDataSocket (ftp_session_t *, LPINT nDataSocket)
static BOOL	FTP_SendData (ftp_session_t *, INT nDataSocket, HANDLE hFile)
static INT	FTP_ReceiveResponse (ftp_session_t *, DWORD_PTR dwContext)
static BOOL	FTP_SendRetrieve (ftp_session_t *, LPCWSTR lpszRemoteFile, DWORD dwType)
static BOOL	FTP_RetrieveFileData (ftp_session_t *, INT nDataSocket, HANDLE hFile)
static BOOL	FTP_InitListenSocket (ftp_session_t *)
static BOOL	FTP_ConnectToHost (ftp_session_t *)
static BOOL	FTP_SendPassword (ftp_session_t *)
static BOOL	FTP_SendAccount (ftp_session_t *)
static BOOL	FTP_SendType (ftp_session_t *, DWORD dwType)
static BOOL	FTP_SendPort (ftp_session_t *)
static BOOL	FTP_DoPassive (ftp_session_t *)
static BOOL	FTP_SendPortOrPasv (ftp_session_t *)
static BOOL	FTP_ParsePermission (LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp)
static BOOL	FTP_ParseNextFile (INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW fileprop)
static BOOL	FTP_ParseDirectory (ftp_session_t *, INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW *lpafp, LPDWORD dwfp)
static HINTERNET	FTP_ReceiveFileList (ftp_session_t *, INT nSocket, LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext)
static DWORD	FTP_SetResponseError (DWORD dwResponse)
static BOOL	FTP_ConvertFileProp (LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData)
static BOOL	FTP_FtpPutFileW (ftp_session_t *, LPCWSTR lpszLocalFile, LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
static BOOL	FTP_FtpSetCurrentDirectoryW (ftp_session_t *, LPCWSTR lpszDirectory)
static BOOL	FTP_FtpCreateDirectoryW (ftp_session_t *, LPCWSTR lpszDirectory)
static HINTERNET	FTP_FtpFindFirstFileW (ftp_session_t *, LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
static BOOL	FTP_FtpGetCurrentDirectoryW (ftp_session_t *, LPWSTR lpszCurrentDirectory, LPDWORD lpdwCurrentDirectory)
static BOOL	FTP_FtpRenameFileW (ftp_session_t *, LPCWSTR lpszSrc, LPCWSTR lpszDest)
static BOOL	FTP_FtpRemoveDirectoryW (ftp_session_t *, LPCWSTR lpszDirectory)
static BOOL	FTP_FtpDeleteFileW (ftp_session_t *, LPCWSTR lpszFileName)
static BOOL	FTP_FtpGetFileW (ftp_session_t *, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile, BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags, DWORD_PTR dwContext)
static BOOL	res_to_le (DWORD res)
BOOL WINAPI	FtpPutFileA (HINTERNET hConnect, LPCSTR lpszLocalFile, LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
static void	AsyncFtpPutFileProc (task_header_t *hdr)
BOOL WINAPI	FtpPutFileW (HINTERNET hConnect, LPCWSTR lpszLocalFile, LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	FtpSetCurrentDirectoryA (HINTERNET hConnect, LPCSTR lpszDirectory)
static void	AsyncFtpSetCurrentDirectoryProc (task_header_t *hdr)
BOOL WINAPI	FtpSetCurrentDirectoryW (HINTERNET hConnect, LPCWSTR lpszDirectory)
BOOL WINAPI	FtpCreateDirectoryA (HINTERNET hConnect, LPCSTR lpszDirectory)
static void	AsyncFtpCreateDirectoryProc (task_header_t *hdr)
BOOL WINAPI	FtpCreateDirectoryW (HINTERNET hConnect, LPCWSTR lpszDirectory)
HINTERNET WINAPI	FtpFindFirstFileA (HINTERNET hConnect, LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
static void	AsyncFtpFindFirstFileProc (task_header_t *hdr)
HINTERNET WINAPI	FtpFindFirstFileW (HINTERNET hConnect, LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	FtpGetCurrentDirectoryA (HINTERNET hFtpSession, LPSTR lpszCurrentDirectory, LPDWORD lpdwCurrentDirectory)
static void	AsyncFtpGetCurrentDirectoryProc (task_header_t *hdr)
BOOL WINAPI	FtpGetCurrentDirectoryW (HINTERNET hFtpSession, LPWSTR lpszCurrentDirectory, LPDWORD lpdwCurrentDirectory)
static void	FTPFILE_Destroy (object_header_t *hdr)
static DWORD	FTPFILE_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
static DWORD	FTPFILE_ReadFile (object_header_t *hdr, void *buffer, DWORD size, DWORD *read, DWORD flags, DWORD_PTR context)
static DWORD	FTPFILE_WriteFile (object_header_t *hdr, const void *buffer, DWORD size, DWORD *written)
static void	FTP_ReceiveRequestData (ftp_file_t *file, BOOL first_notif)
static void	FTPFILE_AsyncQueryDataAvailableProc (task_header_t *task)
static DWORD	FTPFILE_QueryDataAvailable (object_header_t *hdr, DWORD *available, DWORD flags, DWORD_PTR ctx)
static DWORD	FTPFILE_LockRequestFile (object_header_t *hdr, req_file_t **ret)
static HINTERNET	FTP_FtpOpenFileW (ftp_session_t *lpwfs, LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags, DWORD_PTR dwContext)
HINTERNET WINAPI	FtpOpenFileA (HINTERNET hFtpSession, LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags, DWORD_PTR dwContext)
static void	AsyncFtpOpenFileProc (task_header_t *hdr)
HINTERNET WINAPI	FtpOpenFileW (HINTERNET hFtpSession, LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags, DWORD_PTR dwContext)
BOOL WINAPI	FtpGetFileA (HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile, BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags, DWORD_PTR dwContext)
static void	AsyncFtpGetFileProc (task_header_t *hdr)
BOOL WINAPI	FtpGetFileW (HINTERNET hInternet, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile, BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags, DWORD_PTR dwContext)
DWORD WINAPI	FtpGetFileSize (HINTERNET hFile, LPDWORD lpdwFileSizeHigh)
BOOL WINAPI	FtpDeleteFileA (HINTERNET hFtpSession, LPCSTR lpszFileName)
static void	AsyncFtpDeleteFileProc (task_header_t *hdr)
BOOL WINAPI	FtpDeleteFileW (HINTERNET hFtpSession, LPCWSTR lpszFileName)
BOOL WINAPI	FtpRemoveDirectoryA (HINTERNET hFtpSession, LPCSTR lpszDirectory)
static void	AsyncFtpRemoveDirectoryProc (task_header_t *hdr)
BOOL WINAPI	FtpRemoveDirectoryW (HINTERNET hFtpSession, LPCWSTR lpszDirectory)
BOOL WINAPI	FtpRenameFileA (HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
static void	AsyncFtpRenameFileProc (task_header_t *hdr)
BOOL WINAPI	FtpRenameFileW (HINTERNET hFtpSession, LPCWSTR lpszSrc, LPCWSTR lpszDest)
BOOL WINAPI	FtpCommandA (HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags, LPCSTR lpszCommand, DWORD_PTR dwContext, HINTERNET *phFtpCommand)
BOOL WINAPI	FtpCommandW (HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags, LPCWSTR lpszCommand, DWORD_PTR dwContext, HINTERNET *phFtpCommand)
static void	FTPSESSION_Destroy (object_header_t *hdr)
static void	FTPSESSION_CloseConnection (object_header_t *hdr)
static DWORD	FTPSESSION_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
HINTERNET	FTP_Connect (appinfo_t *hIC, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext, DWORD dwInternalFlags)
static LPSTR	FTP_GetNextLine (INT nSocket, LPDWORD dwLen)
static BOOL	FTP_SendCommandA (INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam, INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
static void	FTPFINDNEXT_Destroy (object_header_t *hdr)
static DWORD	FTPFINDNEXT_FindNextFileProc (WININETFTPFINDNEXTW *find, LPVOID data)
static void	FTPFINDNEXT_AsyncFindNextFileProc (task_header_t *hdr)
static DWORD	FTPFINDNEXT_QueryOption (object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
static DWORD	FTPFINDNEXT_FindNextFileW (object_header_t *hdr, void *data)

Variables
static const CHAR *const	szFtpCommands []
static const CHAR	szMonths [] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC"
static const object_vtbl_t	FTPFILEVtbl
static const object_vtbl_t	FTPSESSIONVtbl
static const object_vtbl_t	FTPFINDNEXTVtbl

Macro Definition Documentation

DATA_PACKET_SIZE

#define DATA_PACKET_SIZE   0x2000

Definition at line 107 of file ftp.c.

FTP_CONDITION_MASK

#define FTP_CONDITION_MASK   0x0007

Definition at line 114 of file ftp.c.

MAX_BACKLOG

#define MAX_BACKLOG   5

Definition at line 109 of file ftp.c.

RESPONSE_TIMEOUT

#define RESPONSE_TIMEOUT   30

Definition at line 59 of file ftp.c.

szCRLF

#define szCRLF   "\r\n"

Definition at line 108 of file ftp.c.

Typedef Documentation

ftp_session_t

typedef struct _ftp_session_t ftp_session_t

Definition at line 61 of file ftp.c.

LPFILEPROPERTIESW

typedef struct FILEPROPERTIESW * LPFILEPROPERTIESW

LPWININETFTPFINDNEXTW

typedef struct WININETFTPFINDNEXTW * LPWININETFTPFINDNEXTW

Enumeration Type Documentation

FTP_COMMAND

enum FTP_COMMAND

Enumerator
FTP_CMD_ACCT
FTP_CMD_CWD
FTP_CMD_DELE
FTP_CMD_MKD
FTP_CMD_PASS
FTP_CMD_PORT
FTP_CMD_RETR
FTP_CMD_RMD
FTP_CMD_RNFR
FTP_CMD_RNTO
FTP_CMD_STOR
FTP_CMD_TYPE
FTP_CMD_USER
FTP_CMD_SIZE
FTP_CMD_ABOR
FTP_CMD_LIST
FTP_CMD_NLST
FTP_CMD_PASV
FTP_CMD_PWD
FTP_CMD_QUIT

Definition at line 116 of file ftp.c.

             {
  /* FTP commands with arguments. */
  FTP_CMD_ACCT,
  FTP_CMD_CWD,
  FTP_CMD_DELE,
  FTP_CMD_MKD,
  FTP_CMD_PASS,
  FTP_CMD_PORT,
  FTP_CMD_RETR,
  FTP_CMD_RMD,
  FTP_CMD_RNFR,
  FTP_CMD_RNTO,
  FTP_CMD_STOR,
  FTP_CMD_TYPE,
  FTP_CMD_USER,
  FTP_CMD_SIZE,
 
  /* FTP commands without arguments. */
  FTP_CMD_ABOR,
  FTP_CMD_LIST,
  FTP_CMD_NLST,
  FTP_CMD_PASV,
  FTP_CMD_PWD,
  FTP_CMD_QUIT,
} FTP_COMMAND;

Function Documentation

AsyncFtpCreateDirectoryProc()

static void AsyncFtpCreateDirectoryProc ( task_header_t *  hdr )

static

Definition at line 578 of file ftp.c.

{
    directory_task_t *task = (directory_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE(" %p\n", session);
 
    FTP_FtpCreateDirectoryW(session, task->directory);
    heap_free(task->directory);
}

Referenced by FtpCreateDirectoryW().

AsyncFtpDeleteFileProc()

static void AsyncFtpDeleteFileProc ( task_header_t *  hdr )

static

Definition at line 1793 of file ftp.c.

{
    delete_file_task_t *task = (delete_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpDeleteFileW(session, task->file_name);
    heap_free(task->file_name);
}

Referenced by FtpDeleteFileW().

AsyncFtpFindFirstFileProc()

static void AsyncFtpFindFirstFileProc ( task_header_t *  hdr )

static

Definition at line 736 of file ftp.c.

{
    find_first_file_task_t *task = (find_first_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpFindFirstFileW(session, task->search_file, task->find_file_data, task->flags, task->context);
    heap_free(task->search_file);
}

Referenced by FtpFindFirstFileW().

AsyncFtpGetCurrentDirectoryProc()

static void AsyncFtpGetCurrentDirectoryProc ( task_header_t *  hdr )

static

Definition at line 951 of file ftp.c.

{
    get_current_dir_task_t *task = (get_current_dir_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpGetCurrentDirectoryW(session, task->directory, task->directory_len);
}

Referenced by FtpGetCurrentDirectoryW().

AsyncFtpGetFileProc()

static void AsyncFtpGetFileProc ( task_header_t *  hdr )

static

Definition at line 1586 of file ftp.c.

{
    get_file_task_t *task = (get_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpGetFileW(session, task->remote_file, task->new_file, task->fail_if_exists,
             task->local_attr, task->flags, task->context);
    heap_free(task->remote_file);
    heap_free(task->new_file);
}

Referenced by FtpGetFileW().

AsyncFtpOpenFileProc()

static void AsyncFtpOpenFileProc ( task_header_t *  hdr )

static

Definition at line 1464 of file ftp.c.

{
    open_file_task_t *task = (open_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpOpenFileW(session, task->file_name, task->access, task->flags, task->context);
    heap_free(task->file_name);
}

Referenced by FtpOpenFileW().

AsyncFtpPutFileProc()

static void AsyncFtpPutFileProc ( task_header_t *  hdr )

static

Definition at line 248 of file ftp.c.

{
    put_file_task_t *task = (put_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpPutFileW(session, task->local_file, task->remote_file,
               task->flags, task->context);
 
    heap_free(task->local_file);
    heap_free(task->remote_file);
}

Referenced by FtpPutFileW().

AsyncFtpRemoveDirectoryProc()

static void AsyncFtpRemoveDirectoryProc ( task_header_t *  hdr )

static

Definition at line 1935 of file ftp.c.

{
    directory_task_t *task = (directory_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpRemoveDirectoryW(session, task->directory);
    heap_free(task->directory);
}

Referenced by FtpRemoveDirectoryW().

AsyncFtpRenameFileProc()

static void AsyncFtpRenameFileProc ( task_header_t *  hdr )

static

Definition at line 2087 of file ftp.c.

{
    rename_file_task_t *task = (rename_file_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpRenameFileW(session, task->src_file, task->dst_file);
    heap_free(task->src_file);
    heap_free(task->dst_file);
}

Referenced by FtpRenameFileW().

AsyncFtpSetCurrentDirectoryProc()

static void AsyncFtpSetCurrentDirectoryProc ( task_header_t *  hdr )

static

Definition at line 435 of file ftp.c.

{
    directory_task_t *task = (directory_task_t*)hdr;
    ftp_session_t *session = (ftp_session_t*)task->hdr.hdr;
 
    TRACE("%p\n", session);
 
    FTP_FtpSetCurrentDirectoryW(session, task->directory);
    heap_free(task->directory);
}

Referenced by FtpSetCurrentDirectoryW().

FTP_Connect()

HINTERNET FTP_Connect	(	appinfo_t *	hIC,
		LPCWSTR	lpszServerName,
		INTERNET_PORT	nServerPort,
		LPCWSTR	lpszUserName,
		LPCWSTR	lpszPassword,
		DWORD	dwFlags,
		DWORD_PTR	dwContext,
		DWORD	dwInternalFlags
	)

Definition at line 2428 of file ftp.c.

{
    struct sockaddr_in socketAddr;
    INT nsocket = -1;
    socklen_t sock_namelen;
    BOOL bSuccess = FALSE;
    ftp_session_t *lpwfs = NULL;
    char szaddr[INET6_ADDRSTRLEN];
 
    TRACE("%p  Server(%s) Port(%d) User(%s) Paswd(%s)\n",
        hIC, debugstr_w(lpszServerName),
        nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword));
 
    assert( hIC->hdr.htype == WH_HINIT );
 
    if ((!lpszUserName || !*lpszUserName) && lpszPassword && *lpszPassword)
    {
    INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    lpwfs = alloc_object(&hIC->hdr, &FTPSESSIONVtbl, sizeof(ftp_session_t));
    if (NULL == lpwfs)
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
 
    if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
        lpwfs->serverport = INTERNET_DEFAULT_FTP_PORT;
    else
        lpwfs->serverport = nServerPort;
 
    lpwfs->hdr.htype = WH_HFTPSESSION;
    lpwfs->hdr.dwFlags = dwFlags;
    lpwfs->hdr.dwContext = dwContext;
    lpwfs->hdr.dwInternalFlags |= dwInternalFlags;
    lpwfs->download_in_progress = NULL;
    lpwfs->sndSocket = -1;
    lpwfs->lstnSocket = -1;
    lpwfs->pasvSocket = -1;
 
    WININET_AddRef( &hIC->hdr );
    lpwfs->lpAppInfo = hIC;
    list_add_head( &hIC->hdr.children, &lpwfs->hdr.entry );
 
    if(hIC->proxy && hIC->accessType == INTERNET_OPEN_TYPE_PROXY) {
        if(wcschr(hIC->proxy, ' '))
            FIXME("Several proxies not implemented.\n");
        if(hIC->proxyBypass)
            FIXME("Proxy bypass is ignored.\n");
    }
    if (!lpszUserName || !lpszUserName[0]) {
        HKEY key;
        WCHAR szPassword[MAX_PATH];
        DWORD len = sizeof(szPassword);
 
        lpwfs->lpszUserName = heap_strdupW(L"anonymous");
 
        RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", &key);
        if (RegQueryValueExW(key, L"EmailName", NULL, NULL, (LPBYTE)szPassword, &len)) {
            /* Nothing in the registry, get the username and use that as the password */
            if (!GetUserNameW(szPassword, &len)) {
                /* Should never get here, but use an empty password as failsafe */
                lstrcpyW(szPassword, L"");
            }
        }
        RegCloseKey(key);
 
        TRACE("Password used for anonymous ftp : (%s)\n", debugstr_w(szPassword));
        lpwfs->lpszPassword = heap_strdupW(szPassword);
    }
    else {
        lpwfs->lpszUserName = heap_strdupW(lpszUserName);
        lpwfs->lpszPassword = heap_strdupW(lpszPassword ? lpszPassword : L"");
    }
    lpwfs->servername = heap_strdupW(lpszServerName);
 
    /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
    if (!(lpwfs->hdr.dwInternalFlags & INET_OPENURL))
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD_PTR)lpwfs->hdr.hInternet;
        iar.dwError = ERROR_SUCCESS;
 
        INTERNET_SendCallback(&hIC->hdr, dwContext,
                      INTERNET_STATUS_HANDLE_CREATED, &iar,
                      sizeof(INTERNET_ASYNC_RESULT));
    }
 
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_RESOLVING_NAME,
        (LPWSTR) lpszServerName, (lstrlenW(lpszServerName)+1) * sizeof(WCHAR));
 
    sock_namelen = sizeof(socketAddr);
    if (!GetAddress(lpszServerName, lpwfs->serverport, (struct sockaddr *)&socketAddr, &sock_namelen, szaddr))
    {
    INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
        goto lerror;
    }
 
    if (socketAddr.sin_family != AF_INET)
    {
        WARN("unsupported address family %d\n", socketAddr.sin_family);
        INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
        goto lerror;
    }
 
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_NAME_RESOLVED,
                      szaddr, strlen(szaddr)+1);
 
    init_winsock();
    nsocket = socket(AF_INET,SOCK_STREAM,0);
    if (nsocket == -1)
    {
    INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
        goto lerror;
    }
 
    INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
                      szaddr, strlen(szaddr)+1);
 
    if (connect(nsocket, (struct sockaddr *)&socketAddr, sock_namelen) < 0)
    {
    ERR("Unable to connect (%d)\n", WSAGetLastError());
    INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
    closesocket(nsocket);
    }
    else
    {
        TRACE("Connected to server\n");
    lpwfs->sndSocket = nsocket;
        INTERNET_SendCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
                          szaddr, strlen(szaddr)+1);
 
    sock_namelen = sizeof(lpwfs->socketAddress);
    getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
 
        if (FTP_ConnectToHost(lpwfs))
        {
            TRACE("Successfully logged into server\n");
            bSuccess = TRUE;
        }
    }
 
lerror:
    if (!bSuccess)
    {
        WININET_Release(&lpwfs->hdr);
        return NULL;
    }
 
    return lpwfs->hdr.hInternet;
}

Referenced by INTERNET_InternetOpenUrlW(), and InternetConnectW().

FTP_ConnectToHost()

static BOOL FTP_ConnectToHost ( ftp_session_t *  lpwfs )

static

Definition at line 2597 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        /* Login successful... */
        if (nResCode == 230)
            bSuccess = TRUE;
        /* User name okay, need password... */
        else if (nResCode == 331)
            bSuccess = FTP_SendPassword(lpwfs);
        /* Need account for login... */
        else if (nResCode == 332)
            bSuccess = FTP_SendAccount(lpwfs);
        else
            FTP_SetResponseError(nResCode);
    }
 
    TRACE("Returning %d\n", bSuccess);
lend:
    return bSuccess;
}

Referenced by FTP_Connect().

FTP_ConvertFileProp()

static BOOL FTP_ConvertFileProp ( LPFILEPROPERTIESW  lpafp, LPWIN32_FIND_DATAW  lpFindFileData  )

static

Definition at line 3589 of file ftp.c.

{
    BOOL bSuccess = FALSE;
 
    ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAW));
 
    if (lpafp)
    {
        SystemTimeToFileTime( &lpafp->tmLastModified, &lpFindFileData->ftLastAccessTime );
    lpFindFileData->ftLastWriteTime = lpFindFileData->ftLastAccessTime;
    lpFindFileData->ftCreationTime = lpFindFileData->ftLastAccessTime;
 
        /* Not all fields are filled in */
        lpFindFileData->nFileSizeHigh = 0; /* We do not handle files bigger than 0xFFFFFFFF bytes yet :-) */
        lpFindFileData->nFileSizeLow = lpafp->nSize;
 
    if (lpafp->bIsDirectory)
        lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
 
        if (lpafp->lpszName)
            lstrcpynW(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
 
    bSuccess = TRUE;
    }
 
    return bSuccess;
}

Referenced by FTP_ReceiveFileList(), and FTPFINDNEXT_FindNextFileProc().

FTP_DoPassive()

static BOOL FTP_DoPassive ( ftp_session_t *  lpwfs )

static

Definition at line 3131 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 227)
    {
        LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
        LPSTR p;
        int f[6];
        int i;
        char *pAddr, *pPort;
        INT nsocket = -1;
        struct sockaddr_in dataSocketAddress;
 
        p = lpszResponseBuffer+4; /* skip status code */
        while (*p != '\0' && (*p < '0' || *p > '9')) p++;
 
        if (*p == '\0')
        {
        ERR("no address found in response, aborting\n");
        goto lend;
        }
 
        if (sscanf(p, "%d,%d,%d,%d,%d,%d",  &f[0], &f[1], &f[2], &f[3],
                            &f[4], &f[5]) != 6)
        {
        ERR("unknown response address format '%s', aborting\n", p);
        goto lend;
        }
        for (i=0; i < 6; i++)
        f[i] = f[i] & 0xff;
 
        dataSocketAddress = lpwfs->socketAddress;
        pAddr = (char *)&(dataSocketAddress.sin_addr.S_un.S_addr);
        pPort = (char *)&(dataSocketAddress.sin_port);
            pAddr[0] = f[0];
            pAddr[1] = f[1];
            pAddr[2] = f[2];
            pAddr[3] = f[3];
        pPort[0] = f[4];
        pPort[1] = f[5];
 
            nsocket = socket(AF_INET,SOCK_STREAM,0);
            if (nsocket == -1)
                goto lend;
 
        if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
            {
            ERR("can't connect passive FTP data port.\n");
                closesocket(nsocket);
            goto lend;
            }
        lpwfs->pasvSocket = nsocket;
            bSuccess = TRUE;
    }
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    return bSuccess;
}

Referenced by FTP_SendPortOrPasv().

FTP_FtpCreateDirectoryW()

static BOOL FTP_FtpCreateDirectoryW ( ftp_session_t *  lpwfs, LPCWSTR  lpszDirectory  )

static

Definition at line 661 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
    appinfo_t *hIC = NULL;
 
    TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_MKD, lpszDirectory, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 257)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return bSuccess;
}

Referenced by AsyncFtpCreateDirectoryProc(), and FtpCreateDirectoryW().

FTP_FtpDeleteFileW()

BOOL FTP_FtpDeleteFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszFileName  )

static

Definition at line 1876 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
    appinfo_t *hIC = NULL;
 
    TRACE("%p\n", lpwfs);
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_DELE, lpszFileName, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 250)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
lend:
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return bSuccess;
}

Referenced by AsyncFtpDeleteFileProc(), and FtpDeleteFileW().

FTP_FtpFindFirstFileW()

static HINTERNET FTP_FtpFindFirstFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszSearchFile, LPWIN32_FIND_DATAW  lpFindFileData, DWORD  dwFlags, DWORD_PTR  dwContext  )

static

Definition at line 814 of file ftp.c.

{
    INT nResCode;
    appinfo_t *hIC = NULL;
    HINTERNET hFindNext = NULL;
    LPWSTR lpszSearchPath = NULL;
 
    TRACE("\n");
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (!FTP_InitListenSocket(lpwfs))
        goto lend;
 
    if (!FTP_SendType(lpwfs, INTERNET_FLAG_TRANSFER_ASCII))
        goto lend;
 
    if (!FTP_SendPortOrPasv(lpwfs))
        goto lend;
 
    /* split search path into file and path */
    if (lpszSearchFile)
    {
        LPCWSTR name = lpszSearchFile, p;
        if ((p = wcsrchr( name, '\\' ))) name = p + 1;
        if ((p = wcsrchr( name, '/' ))) name = p + 1;
        if (name != lpszSearchFile)
        {
            lpszSearchPath = heap_strndupW(lpszSearchFile, name - lpszSearchFile);
            lpszSearchFile = name;
        }
    }
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_LIST, lpszSearchPath,
        lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 125 || nResCode == 150)
        {
            INT nDataSocket;
 
            /* Get data socket to server */
            if (FTP_GetDataSocket(lpwfs, &nDataSocket))
            {
                hFindNext = FTP_ReceiveFileList(lpwfs, nDataSocket, lpszSearchFile, lpFindFileData, dwContext);
                closesocket(nDataSocket);
                nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
                if (nResCode != 226 && nResCode != 250)
                    INTERNET_SetLastError(ERROR_NO_MORE_FILES);
            }
        }
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    heap_free(lpszSearchPath);
 
    if (lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        if (hFindNext)
    {
            iar.dwResult = (DWORD_PTR)hFindNext;
            iar.dwError = ERROR_SUCCESS;
            INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
                &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
        iar.dwResult = (DWORD_PTR)hFindNext;
        iar.dwError = hFindNext ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return hFindNext;
}

Referenced by AsyncFtpFindFirstFileProc(), and FtpFindFirstFileW().

FTP_FtpGetCurrentDirectoryW()

static BOOL FTP_FtpGetCurrentDirectoryW ( ftp_session_t *  lpwfs, LPWSTR  lpszCurrentDirectory, LPDWORD  lpdwCurrentDirectory  )

static

Definition at line 1046 of file ftp.c.

{
    INT nResCode;
    appinfo_t *hIC = NULL;
    BOOL bSuccess = FALSE;
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    hIC = lpwfs->lpAppInfo;
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PWD, NULL,
        lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 257) /* Extract directory name */
        {
            DWORD firstpos, lastpos, len;
            LPWSTR lpszResponseBuffer = heap_strdupAtoW(INTERNET_GetResponseBuffer());
 
            for (firstpos = 0, lastpos = 0; lpszResponseBuffer[lastpos]; lastpos++)
            {
                if ('"' == lpszResponseBuffer[lastpos])
                {
                    if (!firstpos)
                        firstpos = lastpos;
                    else
                        break;
                }
            }
            len = lastpos - firstpos;
            if (*lpdwCurrentDirectory >= len)
            {
                memcpy(lpszCurrentDirectory, &lpszResponseBuffer[firstpos + 1], len * sizeof(WCHAR));
                lpszCurrentDirectory[len - 1] = 0;
                *lpdwCurrentDirectory = len;
                bSuccess = TRUE;
            }
            else INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
 
            heap_free(lpszResponseBuffer);
        }
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return bSuccess;
}

Referenced by AsyncFtpGetCurrentDirectoryProc(), and FtpGetCurrentDirectoryW().

FTP_FtpGetFileW()

static BOOL FTP_FtpGetFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszRemoteFile, LPCWSTR  lpszNewFile, BOOL  fFailIfExists, DWORD  dwLocalFlagsAttribute, DWORD  dwInternetFlags, DWORD_PTR  dwContext  )

static

Definition at line 1687 of file ftp.c.

{
    BOOL bSuccess = FALSE;
    HANDLE hFile;
    appinfo_t *hIC = NULL;
 
    TRACE("lpszRemoteFile(%s) lpszNewFile(%s)\n", debugstr_w(lpszRemoteFile), debugstr_w(lpszNewFile));
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    /* Ensure we can write to lpszNewfile by opening it */
    hFile = CreateFileW(lpszNewFile, GENERIC_WRITE, 0, 0, fFailIfExists ?
        CREATE_NEW : CREATE_ALWAYS, dwLocalFlagsAttribute, 0);
    if (INVALID_HANDLE_VALUE == hFile)
        return FALSE;
 
    /* Set up socket to retrieve data */
    if (FTP_SendRetrieve(lpwfs, lpszRemoteFile, dwInternetFlags))
    {
        INT nDataSocket;
 
        /* Get data socket to server */
        if (FTP_GetDataSocket(lpwfs, &nDataSocket))
        {
            INT nResCode;
 
            /* Receive data */
            FTP_RetrieveFileData(lpwfs, nDataSocket, hFile);
            closesocket(nDataSocket);
 
            nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
            if (nResCode)
            {
                if (nResCode == 226)
                    bSuccess = TRUE;
                else
                    FTP_SetResponseError(nResCode);
            }
        }
    }
 
    if (lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    CloseHandle(hFile);
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    if (!bSuccess) DeleteFileW(lpszNewFile);
    return bSuccess;
}

Referenced by AsyncFtpGetFileProc(), and FtpGetFileW().

FTP_FtpOpenFileW()

static HINTERNET FTP_FtpOpenFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszFileName, DWORD  fdwAccess, DWORD  dwFlags, DWORD_PTR  dwContext  )

static

Definition at line 1317 of file ftp.c.

{
    INT nDataSocket;
    BOOL bSuccess = FALSE;
    ftp_file_t *lpwh = NULL;
    appinfo_t *hIC = NULL;
 
    TRACE("\n");
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (GENERIC_READ == fdwAccess)
    {
        /* Set up socket to retrieve data */
        bSuccess = FTP_SendRetrieve(lpwfs, lpszFileName, dwFlags);
    }
    else if (GENERIC_WRITE == fdwAccess)
    {
        /* Set up socket to send data */
        bSuccess = FTP_SendStore(lpwfs, lpszFileName, dwFlags);
    }
 
    /* Get data socket to server */
    if (bSuccess && FTP_GetDataSocket(lpwfs, &nDataSocket))
    {
        lpwh = alloc_object(&lpwfs->hdr, &FTPFILEVtbl, sizeof(ftp_file_t));
        lpwh->hdr.htype = WH_HFILE;
        lpwh->hdr.dwFlags = dwFlags;
        lpwh->hdr.dwContext = dwContext;
        lpwh->nDataSocket = nDataSocket;
        lpwh->cache_file = NULL;
        lpwh->cache_file_handle = INVALID_HANDLE_VALUE;
        lpwh->session_deleted = FALSE;
 
        WININET_AddRef( &lpwfs->hdr );
        lpwh->lpFtpSession = lpwfs;
        list_add_head( &lpwfs->hdr.children, &lpwh->hdr.entry );
 
    /* Indicate that a download is currently in progress */
    lpwfs->download_in_progress = lpwh;
    }
 
    if (lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    if (bSuccess && fdwAccess == GENERIC_READ)
    {
        WCHAR filename[MAX_PATH + 1];
        URL_COMPONENTSW uc;
        DWORD len;
 
        memset(&uc, 0, sizeof(uc));
        uc.dwStructSize = sizeof(uc);
        uc.nScheme      = INTERNET_SCHEME_FTP;
        uc.lpszHostName = lpwfs->servername;
        uc.nPort        = lpwfs->serverport;
        uc.lpszUserName = lpwfs->lpszUserName;
        uc.lpszUrlPath  = heap_strdupW(lpszFileName);
 
        if (!InternetCreateUrlW(&uc, 0, NULL, &len) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
            WCHAR *url = heap_alloc(len * sizeof(WCHAR));
 
            if (url && InternetCreateUrlW(&uc, 0, url, &len) && CreateUrlCacheEntryW(url, 0, NULL, filename, 0))
            {
                lpwh->cache_file = heap_strdupW(filename);
                lpwh->cache_file_handle = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ,
                                                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
                if (lpwh->cache_file_handle == INVALID_HANDLE_VALUE)
                {
                    WARN("Could not create cache file: %u\n", GetLastError());
                    heap_free(lpwh->cache_file);
                    lpwh->cache_file = NULL;
                }
            }
            heap_free(url);
        }
        heap_free(uc.lpszUrlPath);
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
    if (lpwh)
    {
            iar.dwResult = (DWORD_PTR)lpwh->hdr.hInternet;
            iar.dwError = ERROR_SUCCESS;
            INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_HANDLE_CREATED,
                &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
        if(bSuccess) {
            FTP_ReceiveRequestData(lpwh, TRUE);
        }else {
            iar.dwResult = 0;
            iar.dwError = INTERNET_GetLastError();
            INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
                    &iar, sizeof(INTERNET_ASYNC_RESULT));
        }
    }
 
    if(!bSuccess)
        return FALSE;
 
    return lpwh->hdr.hInternet;
}

Referenced by AsyncFtpOpenFileProc(), and FtpOpenFileW().

FTP_FtpPutFileW()

static BOOL FTP_FtpPutFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszLocalFile, LPCWSTR  lpszNewRemoteFile, DWORD  dwFlags, DWORD_PTR  dwContext  )

static

Definition at line 344 of file ftp.c.

{
    HANDLE hFile;
    BOOL bSuccess = FALSE;
    appinfo_t *hIC = NULL;
    INT nResCode;
 
    TRACE(" lpszLocalFile(%s) lpszNewRemoteFile(%s)\n", debugstr_w(lpszLocalFile), debugstr_w(lpszNewRemoteFile));
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    /* Open file to be uploaded */
    if (INVALID_HANDLE_VALUE ==
        (hFile = CreateFileW(lpszLocalFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)))
        /* Let CreateFile set the appropriate error */
        return FALSE;
 
    hIC = lpwfs->lpAppInfo;
 
    INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
 
    if (FTP_SendStore(lpwfs, lpszNewRemoteFile, dwFlags))
    {
        INT nDataSocket;
 
        /* Get data socket to server */
        if (FTP_GetDataSocket(lpwfs, &nDataSocket))
        {
            FTP_SendData(lpwfs, nDataSocket, hFile);
            closesocket(nDataSocket);
        nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
        if (nResCode)
        {
            if (nResCode == 226)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
        }
        }
    }
 
    if (lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    CloseHandle(hFile);
 
    return bSuccess;
}

Referenced by AsyncFtpPutFileProc(), and FtpPutFileW().

FTP_FtpRemoveDirectoryW()

BOOL FTP_FtpRemoveDirectoryW ( ftp_session_t *  lpwfs, LPCWSTR  lpszDirectory  )

static

Definition at line 2018 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
    appinfo_t *hIC = NULL;
 
    TRACE("\n");
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RMD, lpszDirectory, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 250)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return bSuccess;
}

Referenced by AsyncFtpRemoveDirectoryProc(), and FtpRemoveDirectoryW().

FTP_FtpRenameFileW()

BOOL FTP_FtpRenameFileW ( ftp_session_t *  lpwfs, LPCWSTR  lpszSrc, LPCWSTR  lpszDest  )

static

Definition at line 2172 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
    appinfo_t *hIC = NULL;
 
    TRACE("\n");
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNFR, lpszSrc, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode == 350)
    {
        if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNTO, lpszDest, 0, 0, 0))
            goto lend;
 
        nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    }
 
    if (nResCode == 250)
        bSuccess = TRUE;
    else
        FTP_SetResponseError(nResCode);
 
lend:
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (DWORD)bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return bSuccess;
}

Referenced by AsyncFtpRenameFileProc(), and FtpRenameFileW().

FTP_FtpSetCurrentDirectoryW()

static BOOL FTP_FtpSetCurrentDirectoryW ( ftp_session_t *  lpwfs, LPCWSTR  lpszDirectory  )

static

Definition at line 516 of file ftp.c.

{
    INT nResCode;
    appinfo_t *hIC = NULL;
    BOOL bSuccess = FALSE;
 
    TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 
    /* Clear any error information */
    INTERNET_SetLastError(0);
 
    hIC = lpwfs->lpAppInfo;
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_CWD, lpszDirectory,
        lpwfs->hdr.lpfnStatusCB, &lpwfs->hdr, lpwfs->hdr.dwContext))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
 
    if (nResCode)
    {
        if (nResCode == 250)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = bSuccess;
        iar.dwError = bSuccess ? ERROR_SUCCESS : ERROR_INTERNET_EXTENDED_ERROR;
        INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
            &iar, sizeof(INTERNET_ASYNC_RESULT));
    }
    return bSuccess;
}

Referenced by AsyncFtpSetCurrentDirectoryProc(), and FtpSetCurrentDirectoryW().

FTP_GetDataSocket()

static BOOL FTP_GetDataSocket ( ftp_session_t *  lpwfs, LPINT  nDataSocket  )

static

Definition at line 3232 of file ftp.c.

{
    struct sockaddr_in saddr;
    socklen_t addrlen = sizeof(saddr);
 
    TRACE("\n");
    if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
    {
    *nDataSocket = lpwfs->pasvSocket;
    lpwfs->pasvSocket = -1;
    }
    else
    {
        *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
    return *nDataSocket != -1;
}

Referenced by FTP_FtpFindFirstFileW(), FTP_FtpGetFileW(), FTP_FtpOpenFileW(), and FTP_FtpPutFileW().

FTP_GetNextLine()

static LPSTR FTP_GetNextLine ( INT  nSocket, LPDWORD  dwLen  )

static

Definition at line 2640 of file ftp.c.

{
    struct timeval tv = {RESPONSE_TIMEOUT,0};
    FD_SET set;
    INT nRecv = 0;
    LPSTR lpszBuffer = INTERNET_GetResponseBuffer();
 
    TRACE("\n");
 
    FD_ZERO(&set);
    FD_SET(nSocket, &set);
 
    while (nRecv < MAX_REPLY_LEN)
    {
        if (select(nSocket+1, &set, NULL, NULL, &tv) > 0)
        {
            if (sock_recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
            {
                INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
                return NULL;
            }
 
            if (lpszBuffer[nRecv] == '\n')
            {
                lpszBuffer[nRecv] = '\0';
                *dwLen = nRecv - 1;
                TRACE(":%d %s\n", nRecv, lpszBuffer);
                return lpszBuffer;
            }
            if (lpszBuffer[nRecv] != '\r')
                nRecv++;
        }
    else
    {
            INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
            return NULL;
        }
    }
 
    return NULL;
}

Referenced by FTP_ParseNextFile(), and FTP_ReceiveResponse().

FTP_InitListenSocket()

static BOOL FTP_InitListenSocket ( ftp_session_t *  lpwfs )

static

Definition at line 2946 of file ftp.c.

{
    BOOL bSuccess = FALSE;
    socklen_t namelen = sizeof(lpwfs->lstnSocketAddress);
 
    TRACE("\n");
 
    init_winsock();
    lpwfs->lstnSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (lpwfs->lstnSocket == -1)
    {
        TRACE("Unable to create listening socket\n");
            goto lend;
    }
 
    /* We obtain our ip addr from the name of the command channel socket */
    lpwfs->lstnSocketAddress = lpwfs->socketAddress;
 
    /* and get the system to assign us a port */
    lpwfs->lstnSocketAddress.sin_port = htons(0);
 
    if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(lpwfs->lstnSocketAddress)) == -1)
    {
        TRACE("Unable to bind socket\n");
        goto lend;
    }
 
    if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
    {
        TRACE("listen failed\n");
        goto lend;
    }
 
    if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
        bSuccess = TRUE;
 
lend:
    if (!bSuccess && lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    return bSuccess;
}

Referenced by FTP_FtpFindFirstFileW(), FTP_SendRetrieve(), and FTP_SendStore().

FTP_ParseDirectory()

static BOOL FTP_ParseDirectory ( ftp_session_t *  lpwfs, INT  nSocket, LPCWSTR  lpszSearchFile, LPFILEPROPERTIESW *  lpafp, LPDWORD  dwfp  )

static

Definition at line 3787 of file ftp.c.

{
    BOOL bSuccess = TRUE;
    INT sizeFilePropArray = 500;/*20; */
    INT indexFilePropArray = -1;
 
    TRACE("\n");
 
    /* Allocate initial file properties array */
    *lpafp = heap_alloc_zero(sizeof(FILEPROPERTIESW)*(sizeFilePropArray));
    if (!*lpafp)
        return FALSE;
 
    do {
        if (indexFilePropArray+1 >= sizeFilePropArray)
        {
            LPFILEPROPERTIESW tmpafp;
 
            sizeFilePropArray *= 2;
            tmpafp = heap_realloc_zero(*lpafp, sizeof(FILEPROPERTIESW)*sizeFilePropArray);
            if (NULL == tmpafp)
            {
                bSuccess = FALSE;
                break;
            }
 
            *lpafp = tmpafp;
        }
        indexFilePropArray++;
    } while (FTP_ParseNextFile(nSocket, lpszSearchFile, &(*lpafp)[indexFilePropArray]));
 
    if (bSuccess && indexFilePropArray)
    {
        if (indexFilePropArray < sizeFilePropArray - 1)
        {
            LPFILEPROPERTIESW tmpafp;
 
            tmpafp = heap_realloc(*lpafp, sizeof(FILEPROPERTIESW)*indexFilePropArray);
            if (NULL != tmpafp)
                *lpafp = tmpafp;
        }
        *dwfp = indexFilePropArray;
    }
    else
    {
        heap_free(*lpafp);
        INTERNET_SetLastError(ERROR_NO_MORE_FILES);
        bSuccess = FALSE;
    }
 
    return bSuccess;
}

Referenced by FTP_ReceiveFileList().

FTP_ParseNextFile()

static BOOL FTP_ParseNextFile ( INT  nSocket, LPCWSTR  lpszSearchFile, LPFILEPROPERTIESW  fileprop  )

static

Definition at line 3626 of file ftp.c.

{
    static const char szSpace[] = " \t";
    DWORD nBufLen;
    char *pszLine;
    char *pszToken;
    char *pszTmp;
    BOOL found = FALSE;
    int i;
 
    lpfp->lpszName = NULL;
    do {
        if(!(pszLine = FTP_GetNextLine(nSocket, &nBufLen)))
            return FALSE;
 
        pszToken = strtok(pszLine, szSpace);
        /* ls format
         * <Permissions> <NoLinks> <owner>   <group> <size> <date>  <time or year> <filename>
         *
         * For instance:
         * drwx--s---     2         pcarrier  ens     512    Sep 28  1995           pcarrier
         */
        if(!isdigit(pszToken[0]) && 10 == strlen(pszToken)) {
            if(!FTP_ParsePermission(pszToken, lpfp))
                lpfp->bIsDirectory = FALSE;
            for(i=0; i<=3; i++) {
              if(!(pszToken = strtok(NULL, szSpace)))
                  break;
            }
            if(!pszToken) continue;
            if(lpfp->bIsDirectory) {
                TRACE("Is directory\n");
                lpfp->nSize = 0;
            }
            else {
                TRACE("Size: %s\n", pszToken);
                lpfp->nSize = atol(pszToken);
            }
 
            lpfp->tmLastModified.wSecond = 0;
            lpfp->tmLastModified.wMinute = 0;
            lpfp->tmLastModified.wHour   = 0;
            lpfp->tmLastModified.wDay    = 0;
            lpfp->tmLastModified.wMonth  = 0;
            lpfp->tmLastModified.wYear   = 0;
 
            /* Determine month */
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            if(strlen(pszToken) >= 3) {
                pszToken[3] = 0;
                if((pszTmp = StrStrIA(szMonths, pszToken)))
                    lpfp->tmLastModified.wMonth = ((pszTmp - szMonths) / 3)+1;
            }
            /* Determine day */
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            lpfp->tmLastModified.wDay = atoi(pszToken);
            /* Determine time or year */
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            if((pszTmp = strchr(pszToken, ':'))) {
                SYSTEMTIME curr_time;
                *pszTmp = 0;
                pszTmp++;
                lpfp->tmLastModified.wMinute = atoi(pszTmp);
                lpfp->tmLastModified.wHour = atoi(pszToken);
                GetLocalTime( &curr_time );
                lpfp->tmLastModified.wYear = curr_time.wYear;
            }
            else {
                lpfp->tmLastModified.wYear = atoi(pszToken);
                lpfp->tmLastModified.wHour = 12;
            }
            TRACE("Mod time: %02d:%02d:%02d  %04d/%02d/%02d\n",
                  lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
                  lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
 
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            lpfp->lpszName = heap_strdupAtoW(pszToken);
            TRACE("File: %s\n", debugstr_w(lpfp->lpszName));
        }
        /* NT way of parsing ... :
 
                07-13-03  08:55PM       <DIR>          sakpatch
                05-09-03  06:02PM             12656686 2003-04-21bgm_cmd_e.rgz
        */
        else if(isdigit(pszToken[0]) && 8 == strlen(pszToken)) {
            int mon, mday, year, hour, min;
            lpfp->permissions = 0xFFFF; /* No idea, put full permission :-) */
 
            sscanf(pszToken, "%d-%d-%d", &mon, &mday, &year);
            lpfp->tmLastModified.wDay   = mday;
            lpfp->tmLastModified.wMonth = mon;
            lpfp->tmLastModified.wYear  = year;
 
            /* Hacky and bad Y2K protection :-) */
            if (lpfp->tmLastModified.wYear < 70) lpfp->tmLastModified.wYear += 2000;
 
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            sscanf(pszToken, "%d:%d", &hour, &min);
            lpfp->tmLastModified.wHour   = hour;
            lpfp->tmLastModified.wMinute = min;
            if((pszToken[5] == 'P') && (pszToken[6] == 'M')) {
                lpfp->tmLastModified.wHour += 12;
            }
            lpfp->tmLastModified.wSecond = 0;
 
            TRACE("Mod time: %02d:%02d:%02d  %04d/%02d/%02d\n",
                  lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
                  lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
 
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            if(!stricmp(pszToken, "<DIR>")) {
                lpfp->bIsDirectory = TRUE;
                lpfp->nSize = 0;
                TRACE("Is directory\n");
            }
            else {
                lpfp->bIsDirectory = FALSE;
                lpfp->nSize = atol(pszToken);
                TRACE("Size: %d\n", lpfp->nSize);
            }
 
            pszToken = strtok(NULL, szSpace);
            if(!pszToken) continue;
            lpfp->lpszName = heap_strdupAtoW(pszToken);
            TRACE("Name: %s\n", debugstr_w(lpfp->lpszName));
        }
        /* EPLF format - http://cr.yp.to/ftp/list/eplf.html */
        else if(pszToken[0] == '+') {
            FIXME("EPLF Format not implemented\n");
        }
 
        if(lpfp->lpszName) {
            if((lpszSearchFile == NULL) ||
           (PathMatchSpecW(lpfp->lpszName, lpszSearchFile))) {
                found = TRUE;
                TRACE("Matched: %s\n", debugstr_w(lpfp->lpszName));
            }
            else {
                heap_free(lpfp->lpszName);
                lpfp->lpszName = NULL;
            }
        }
    } while(!found);
    return TRUE;
}

Referenced by FTP_ParseDirectory().

FTP_ParsePermission()

static BOOL FTP_ParsePermission ( LPCSTR  lpszPermission, LPFILEPROPERTIESW  lpfp  )

static

Definition at line 3852 of file ftp.c.

{
    BOOL bSuccess = TRUE;
    unsigned short nPermission = 0;
    INT nPos = 1;
    INT nLast  = 9;
 
    TRACE("\n");
    if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
    {
        bSuccess = FALSE;
        return bSuccess;
    }
 
    lpfp->bIsDirectory = (*lpszPermission == 'd');
    do
    {
        switch (nPos)
        {
            case 1:
                nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
                break;
            case 2:
                nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
                break;
            case 3:
                nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
                break;
            case 4:
                nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
                break;
            case 5:
                nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
                break;
            case 6:
                nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
                break;
            case 7:
                nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
                break;
            case 8:
                nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
                break;
            case 9:
                nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
                break;
        }
        nPos++;
    }while (nPos <= nLast);
 
    lpfp->permissions = nPermission;
    return bSuccess;
}

Referenced by FTP_ParseNextFile().

FTP_ReceiveFileList()

static HINTERNET FTP_ReceiveFileList ( ftp_session_t *  lpwfs, INT  nSocket, LPCWSTR  lpszSearchFile, LPWIN32_FIND_DATAW  lpFindFileData, DWORD_PTR  dwContext  )

static

Definition at line 3545 of file ftp.c.

{
    DWORD dwSize = 0;
    LPFILEPROPERTIESW lpafp = NULL;
    LPWININETFTPFINDNEXTW lpwfn = NULL;
 
    TRACE("(%p,%d,%s,%p,%08lx)\n", lpwfs, nSocket, debugstr_w(lpszSearchFile), lpFindFileData, dwContext);
 
    if (FTP_ParseDirectory(lpwfs, nSocket, lpszSearchFile, &lpafp, &dwSize))
    {
        if(lpFindFileData)
            FTP_ConvertFileProp(lpafp, lpFindFileData);
 
        lpwfn = alloc_object(&lpwfs->hdr, &FTPFINDNEXTVtbl, sizeof(WININETFTPFINDNEXTW));
        if (lpwfn)
        {
            lpwfn->hdr.htype = WH_HFTPFINDNEXT;
            lpwfn->hdr.dwContext = dwContext;
            lpwfn->index = 1; /* Next index is 1 since we return index 0 */
            lpwfn->size = dwSize;
            lpwfn->lpafp = lpafp;
 
            WININET_AddRef( &lpwfs->hdr );
            lpwfn->lpFtpSession = lpwfs;
            list_add_head( &lpwfs->hdr.children, &lpwfn->hdr.entry );
        }
    }
 
    TRACE("Matched %d files\n", dwSize);
    return lpwfn ? lpwfn->hdr.hInternet : NULL;
}

Referenced by FTP_FtpFindFirstFileW().

FTP_ReceiveRequestData()

static void FTP_ReceiveRequestData ( ftp_file_t *  file, BOOL  first_notif  )

static

Definition at line 1226 of file ftp.c.

{
    INTERNET_ASYNC_RESULT iar;
    BYTE buffer[4096];
    int available;
 
    TRACE("%p\n", file);
 
    available = sock_recv(file->nDataSocket, buffer, sizeof(buffer), MSG_PEEK);
 
    if(available != -1) {
        iar.dwResult = (DWORD_PTR)file->hdr.hInternet;
        iar.dwError = first_notif ? 0 : available;
    }else {
        iar.dwResult = 0;
        iar.dwError = INTERNET_GetLastError();
    }
 
    INTERNET_SendCallback(&file->hdr, file->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE, &iar,
                          sizeof(INTERNET_ASYNC_RESULT));
}

Referenced by FTP_FtpOpenFileW(), and FTPFILE_AsyncQueryDataAvailableProc().

FTP_ReceiveResponse()

INT FTP_ReceiveResponse ( ftp_session_t *  lpwfs, DWORD_PTR  dwContext  )

static

Definition at line 2766 of file ftp.c.

{
    LPSTR lpszResponse = INTERNET_GetResponseBuffer();
    DWORD nRecv;
    INT rc = 0;
    char firstprefix[5];
    BOOL multiline = FALSE;
 
    TRACE("socket(%d)\n", lpwfs->sndSocket);
 
    INTERNET_SendCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
 
    while(1)
    {
    if (!FTP_GetNextLine(lpwfs->sndSocket, &nRecv))
        goto lerror;
 
        if (nRecv >= 3)
    {
        if(!multiline)
        {
            if(lpszResponse[3] != '-')
            break;
        else
        {  /* Start of multiline response.  Loop until we get "nnn " */
            multiline = TRUE;
            memcpy(firstprefix, lpszResponse, 3);
            firstprefix[3] = ' ';
            firstprefix[4] = '\0';
        }
        }
        else
        {
            if(!memcmp(firstprefix, lpszResponse, 4))
            break;
        }
    }
    }
 
    if (nRecv >= 3)
    {
        rc = atoi(lpszResponse);
 
        INTERNET_SendCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
            &nRecv, sizeof(DWORD));
    }
 
lerror:
    TRACE("return %d\n", rc);
    return rc;
}

Referenced by FTP_ConnectToHost(), FTP_DoPassive(), FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetCurrentDirectoryW(), FTP_FtpGetFileW(), FTP_FtpPutFileW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_FtpSetCurrentDirectoryW(), FTP_SendAccount(), FTP_SendPassword(), FTP_SendPort(), FTP_SendRetrieve(), FTP_SendStore(), FTP_SendType(), FtpCommandW(), and FTPFILE_Destroy().

FTP_RetrieveFileData()

static BOOL FTP_RetrieveFileData ( ftp_session_t *  lpwfs, INT  nDataSocket, HANDLE  hFile  )

static

Definition at line 3389 of file ftp.c.

{
    DWORD nBytesWritten;
    INT nRC = 0;
    CHAR *lpszBuffer;
 
    TRACE("\n");
 
    lpszBuffer = heap_alloc_zero(sizeof(CHAR)*DATA_PACKET_SIZE);
    if (NULL == lpszBuffer)
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    while (nRC != -1)
    {
        nRC = sock_recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
        if (nRC != -1)
        {
            /* other side closed socket. */
            if (nRC == 0)
                goto recv_end;
            WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
        }
    }
 
    TRACE("Data transfer complete\n");
 
recv_end:
    heap_free(lpszBuffer);
    return (nRC != -1);
}

Referenced by FTP_FtpGetFileW().

FTP_SendAccount()

static BOOL FTP_SendAccount ( ftp_session_t *  lpwfs )

static

Definition at line 2869 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, L"noaccount", 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
        bSuccess = TRUE;
    else
        FTP_SetResponseError(nResCode);
 
lend:
    return bSuccess;
}

Referenced by FTP_ConnectToHost(), and FTP_SendPassword().

FTP_SendCommand()

static BOOL FTP_SendCommand ( INT  nSocket, FTP_COMMAND  ftpCmd, LPCWSTR  lpszParam, INTERNET_STATUS_CALLBACK  lpfnStatusCB, object_header_t *  hdr, DWORD_PTR  dwContext  )

static

Definition at line 2746 of file ftp.c.

{
    BOOL ret;
    LPSTR lpszParamA = heap_strdupWtoA(lpszParam);
    ret = FTP_SendCommandA(nSocket, ftpCmd, lpszParamA, lpfnStatusCB, hdr, dwContext);
    heap_free(lpszParamA);
    return ret;
}

Referenced by FTP_ConnectToHost(), FTP_DoPassive(), FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetCurrentDirectoryW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_FtpSetCurrentDirectoryW(), FTP_SendAccount(), FTP_SendPassword(), FTP_SendPort(), FTP_SendRetrieve(), FTP_SendStore(), and FTP_SendType().

FTP_SendCommandA()

static BOOL FTP_SendCommandA ( INT  nSocket, FTP_COMMAND  ftpCmd, LPCSTR  lpszParam, INTERNET_STATUS_CALLBACK  lpfnStatusCB, object_header_t *  hdr, DWORD_PTR  dwContext  )

static

Definition at line 2692 of file ftp.c.

{
        DWORD len;
    CHAR *buf;
    DWORD nBytesSent = 0;
    int nRC = 0;
    DWORD dwParamLen;
 
    TRACE("%d: (%s) %d\n", ftpCmd, debugstr_a(lpszParam), nSocket);
 
    if (lpfnStatusCB)
        {
            lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
        }
 
    dwParamLen = lpszParam?strlen(lpszParam)+1:0;
    len = dwParamLen + strlen(szFtpCommands[ftpCmd]) + strlen(szCRLF);
    if (NULL == (buf = heap_alloc(len+1)))
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], dwParamLen ? " " : "",
        dwParamLen ? lpszParam : "", szCRLF);
 
    TRACE("Sending (%s) len(%d)\n", debugstr_a(buf), len);
    while((nBytesSent < len) && (nRC != -1))
    {
        nRC = sock_send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
        nBytesSent += nRC;
    }
    heap_free(buf);
 
    if (lpfnStatusCB)
        {
            lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_REQUEST_SENT,
                         &nBytesSent, sizeof(DWORD));
        }
 
    TRACE("Sent %d bytes\n", nBytesSent);
    return (nRC != -1);
}

Referenced by FTP_SendCommand().

FTP_SendData()

static BOOL FTP_SendData ( ftp_session_t *  lpwfs, INT  nDataSocket, HANDLE  hFile  )

static

Definition at line 3263 of file ftp.c.

{
    BY_HANDLE_FILE_INFORMATION fi;
    DWORD nBytesRead = 0;
    DWORD nBytesSent = 0;
    DWORD nTotalSent = 0;
    DWORD nBytesToSend, nLen;
    int nRC = 1;
    time_t s_long_time, e_long_time;
    LONG nSeconds;
    CHAR *lpszBuffer;
 
    TRACE("\n");
    lpszBuffer = heap_alloc_zero(sizeof(CHAR)*DATA_PACKET_SIZE);
 
    /* Get the size of the file. */
    GetFileInformationByHandle(hFile, &fi);
    time(&s_long_time);
 
    do
    {
        nBytesToSend = nBytesRead - nBytesSent;
 
        if (nBytesToSend <= 0)
        {
            /* Read data from file. */
            nBytesSent = 0;
            if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
            ERR("Failed reading from file\n");
 
            if (nBytesRead > 0)
                nBytesToSend = nBytesRead;
            else
                break;
        }
 
        nLen = DATA_PACKET_SIZE < nBytesToSend ?
            DATA_PACKET_SIZE : nBytesToSend;
        nRC  = sock_send(nDataSocket, lpszBuffer, nLen, 0);
 
        if (nRC != -1)
        {
            nBytesSent += nRC;
            nTotalSent += nRC;
        }
 
        /* Do some computation to display the status. */
        time(&e_long_time);
        nSeconds = e_long_time - s_long_time;
        if( nSeconds / 60 > 0 )
        {
            TRACE( "%d bytes of %d bytes (%d%%) in %d min %d sec estimated remaining time %d sec\n",
            nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
            nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
        }
        else
        {
            TRACE( "%d bytes of %d bytes (%d%%) in %d sec estimated remaining time %d sec\n",
            nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
            (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
        }
    } while (nRC != -1);
 
    TRACE("file transfer complete!\n");
 
    heap_free(lpszBuffer);
    return nTotalSent;
}

Referenced by FTP_FtpPutFileW().

FTP_SendPassword()

static BOOL FTP_SendPassword ( ftp_session_t *  lpwfs )

static

Definition at line 2829 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        TRACE("Received reply code %d\n", nResCode);
        /* Login successful... */
        if (nResCode == 230)
            bSuccess = TRUE;
        /* Command not implemented, superfluous at the server site... */
        /* Need account for login... */
        else if (nResCode == 332)
            bSuccess = FTP_SendAccount(lpwfs);
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    TRACE("Returning %d\n", bSuccess);
    return bSuccess;
}

Referenced by FTP_ConnectToHost().

FTP_SendPort()

static BOOL FTP_SendPort ( ftp_session_t *  lpwfs )

static

Definition at line 3088 of file ftp.c.

{
    INT nResCode;
    WCHAR szIPAddress[64];
    BOOL bSuccess = FALSE;
    TRACE("\n");
 
    swprintf(szIPAddress, ARRAY_SIZE(szIPAddress), L"%d,%d,%d,%d,%d,%d",
     lpwfs->lstnSocketAddress.sin_addr.S_un.S_addr&0x000000FF,
        (lpwfs->lstnSocketAddress.sin_addr.S_un.S_addr&0x0000FF00)>>8,
        (lpwfs->lstnSocketAddress.sin_addr.S_un.S_addr&0x00FF0000)>>16,
        (lpwfs->lstnSocketAddress.sin_addr.S_un.S_addr&0xFF000000)>>24,
        lpwfs->lstnSocketAddress.sin_port & 0xFF,
        (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 200)
            bSuccess = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    return bSuccess;
}

Referenced by FTP_SendPortOrPasv().

FTP_SendPortOrPasv()

static BOOL FTP_SendPortOrPasv ( ftp_session_t *  lpwfs )

static

Definition at line 3203 of file ftp.c.

{
    if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
    {
        if (!FTP_DoPassive(lpwfs))
            return FALSE;
    }
    else
    {
    if (!FTP_SendPort(lpwfs))
            return FALSE;
    }
    return TRUE;
}

Referenced by FTP_FtpFindFirstFileW(), FTP_SendRetrieve(), and FTP_SendStore().

FTP_SendRetrieve()

static BOOL FTP_SendRetrieve ( ftp_session_t *  lpwfs, LPCWSTR  lpszRemoteFile, DWORD  dwType  )

static

Definition at line 3343 of file ftp.c.

{
    INT nResCode;
    BOOL ret;
 
    TRACE("\n");
    if (!(ret = FTP_InitListenSocket(lpwfs)))
        goto lend;
 
    if (!(ret = FTP_SendType(lpwfs, dwType)))
        goto lend;
 
    if (!(ret = FTP_SendPortOrPasv(lpwfs)))
        goto lend;
 
    if (!(ret = FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0)))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if ((nResCode != 125) && (nResCode != 150)) {
    /* That means that we got an error getting the file. */
        FTP_SetResponseError(nResCode);
    ret = FALSE;
    }
 
lend:
    if (!ret && lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    return ret;
}

Referenced by FTP_FtpGetFileW(), and FTP_FtpOpenFileW().

FTP_SendStore()

static BOOL FTP_SendStore ( ftp_session_t *  lpwfs, LPCWSTR  lpszRemoteFile, DWORD  dwType  )

static

Definition at line 2899 of file ftp.c.

{
    INT nResCode;
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    if (!FTP_InitListenSocket(lpwfs))
        goto lend;
 
    if (!FTP_SendType(lpwfs, dwType))
        goto lend;
 
    if (!FTP_SendPortOrPasv(lpwfs))
        goto lend;
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
        goto lend;
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode)
    {
        if (nResCode == 150 || nResCode == 125)
            bSuccess = TRUE;
    else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    if (!bSuccess && lpwfs->lstnSocket != -1)
    {
        closesocket(lpwfs->lstnSocket);
        lpwfs->lstnSocket = -1;
    }
 
    return bSuccess;
}

Referenced by FTP_FtpOpenFileW(), and FTP_FtpPutFileW().

FTP_SendType()

static BOOL FTP_SendType ( ftp_session_t *  lpwfs, DWORD  dwType  )

static

Definition at line 3006 of file ftp.c.

{
    INT nResCode;
    WCHAR type[] = L"I";
    BOOL bSuccess = FALSE;
 
    TRACE("\n");
    if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
        type[0] = 'A';
 
    if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
        goto lend;
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext)/100;
    if (nResCode)
    {
        if (nResCode == 2)
            bSuccess = TRUE;
    else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    return bSuccess;
}

Referenced by FTP_FtpFindFirstFileW(), FTP_SendRetrieve(), and FTP_SendStore().

FTP_SetResponseError()

static DWORD FTP_SetResponseError ( DWORD  dwResponse )

static

Definition at line 3915 of file ftp.c.

{
    DWORD dwCode = 0;
 
    switch(dwResponse)
    {
    case 425: /* Cannot open data connection. */
        dwCode = ERROR_INTERNET_CANNOT_CONNECT;
        break;
 
    case 426: /* Connection closed, transfer aborted. */
        dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
        break;
 
    case 530: /* Not logged in. Login incorrect. */
        dwCode = ERROR_INTERNET_LOGIN_FAILURE;
        break;
 
    case 421: /* Service not available - Server may be shutting down. */
    case 450: /* File action not taken. File may be busy. */
    case 451: /* Action aborted. Server error. */
    case 452: /* Action not taken. Insufficient storage space on server. */
    case 500: /* Syntax error. Command unrecognized. */
    case 501: /* Syntax error. Error in parameters or arguments. */
    case 502: /* Command not implemented. */
    case 503: /* Bad sequence of commands. */
    case 504: /* Command not implemented for that parameter. */
    case 532: /* Need account for storing files */
    case 550: /* File action not taken. File not found or no access. */
    case 551: /* Requested action aborted. Page type unknown */
    case 552: /* Action aborted. Exceeded storage allocation */
    case 553: /* Action not taken. File name not allowed. */
 
    default:
        dwCode = ERROR_INTERNET_EXTENDED_ERROR;
        break;
    }
 
    INTERNET_SetLastError(dwCode);
    return dwCode;
}

Referenced by FTP_ConnectToHost(), FTP_DoPassive(), FTP_FtpCreateDirectoryW(), FTP_FtpDeleteFileW(), FTP_FtpFindFirstFileW(), FTP_FtpGetCurrentDirectoryW(), FTP_FtpGetFileW(), FTP_FtpPutFileW(), FTP_FtpRemoveDirectoryW(), FTP_FtpRenameFileW(), FTP_FtpSetCurrentDirectoryW(), FTP_SendAccount(), FTP_SendPassword(), FTP_SendPort(), FTP_SendRetrieve(), FTP_SendStore(), FTP_SendType(), and FtpCommandW().

FtpCommandA()

BOOL WINAPI FtpCommandA	(	HINTERNET	hConnect,
		BOOL	fExpectResponse,
		DWORD	dwFlags,
		LPCSTR	lpszCommand,
		DWORD_PTR	dwContext,
		HINTERNET *	phFtpCommand
	)

Definition at line 2218 of file ftp.c.

{
    BOOL r;
    WCHAR *cmdW;
 
    TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
          debugstr_a(lpszCommand), dwContext, phFtpCommand);
 
    if (fExpectResponse)
    {
        FIXME("data connection not supported\n");
        return FALSE;
    }
 
    if (!lpszCommand || !lpszCommand[0])
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!(cmdW = heap_strdupAtoW(lpszCommand)))
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    r = FtpCommandW(hConnect, fExpectResponse, dwFlags, cmdW, dwContext, phFtpCommand);
 
    heap_free(cmdW);
    return r;
}

FtpCommandW()

BOOL WINAPI FtpCommandW	(	HINTERNET	hConnect,
		BOOL	fExpectResponse,
		DWORD	dwFlags,
		LPCWSTR	lpszCommand,
		DWORD_PTR	dwContext,
		HINTERNET *	phFtpCommand
	)

Definition at line 2254 of file ftp.c.

{
    BOOL r = FALSE;
    ftp_session_t *lpwfs;
    LPSTR cmd = NULL;
    DWORD len, nBytesSent= 0;
    INT nResCode, nRC = 0;
 
    TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
           debugstr_w(lpszCommand), dwContext, phFtpCommand);
 
    if (!lpszCommand || !lpszCommand[0])
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (fExpectResponse)
    {
        FIXME("data connection not supported\n");
        return FALSE;
    }
 
    lpwfs = (ftp_session_t*) get_handle_object( hConnect );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    len = WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, NULL, 0, NULL, NULL) + strlen(szCRLF);
    if ((cmd = heap_alloc(len)))
        WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, cmd, len, NULL, NULL);
    else
    {
        INTERNET_SetLastError(ERROR_OUTOFMEMORY);
        goto lend;
    }
 
    strcat(cmd, szCRLF);
    len--;
 
    TRACE("Sending (%s) len(%d)\n", debugstr_a(cmd), len);
    while ((nBytesSent < len) && (nRC != -1))
    {
        nRC = sock_send(lpwfs->sndSocket, cmd + nBytesSent, len - nBytesSent, 0);
        if (nRC != -1)
        {
            nBytesSent += nRC;
            TRACE("Sent %d bytes\n", nRC);
        }
    }
 
    if (nBytesSent)
    {
        nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
        if (nResCode > 0 && nResCode < 400)
            r = TRUE;
        else
            FTP_SetResponseError(nResCode);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
    heap_free( cmd );
    return r;
}

Referenced by FtpCommandA().

FtpCreateDirectoryA()

BOOL WINAPI FtpCreateDirectoryA	(	HINTERNET	hConnect,
		LPCSTR	lpszDirectory
	)

Definition at line 566 of file ftp.c.

{
    LPWSTR lpwzDirectory;
    BOOL ret;
 
    lpwzDirectory = heap_strdupAtoW(lpszDirectory);
    ret = FtpCreateDirectoryW(hConnect, lpwzDirectory);
    heap_free(lpwzDirectory);
    return ret;
}

Referenced by test_createdir(), and test_openfile().

FtpCreateDirectoryW()

BOOL WINAPI FtpCreateDirectoryW	(	HINTERNET	hConnect,
		LPCWSTR	lpszDirectory
	)

Definition at line 599 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    lpwfs = (ftp_session_t*) get_handle_object( hConnect );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    if (!lpszDirectory)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        directory_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpCreateDirectoryProc, sizeof(*task));
        task->directory = heap_strdupW(lpszDirectory);
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpCreateDirectoryW(lpwfs, lpszDirectory);
    }
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpCreateDirectoryA().

FtpDeleteFileA()

BOOL WINAPI FtpDeleteFileA	(	HINTERNET	hFtpSession,
		LPCSTR	lpszFileName
	)

Definition at line 1777 of file ftp.c.

{
    LPWSTR lpwzFileName;
    BOOL ret;
 
    lpwzFileName = heap_strdupAtoW(lpszFileName);
    ret = FtpDeleteFileW(hFtpSession, lpwzFileName);
    heap_free(lpwzFileName);
    return ret;
}

Referenced by test_deletefile(), and test_openfile().

FtpDeleteFileW()

BOOL WINAPI FtpDeleteFileW	(	HINTERNET	hFtpSession,
		LPCWSTR	lpszFileName
	)

Definition at line 1814 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    if (!lpszFileName)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        delete_file_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpDeleteFileProc, sizeof(*task));
        task->file_name = heap_strdupW(lpszFileName);
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpDeleteFileW(lpwfs, lpszFileName);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpDeleteFileA().

FTPFILE_AsyncQueryDataAvailableProc()

static void FTPFILE_AsyncQueryDataAvailableProc ( task_header_t *  task )

static

Definition at line 1248 of file ftp.c.

{
    ftp_file_t *file = (ftp_file_t*)task->hdr;
 
    FTP_ReceiveRequestData(file, FALSE);
}

Referenced by FTPFILE_QueryDataAvailable().

FTPFILE_Destroy()

static void FTPFILE_Destroy ( object_header_t *  hdr )

static

Definition at line 1117 of file ftp.c.

{
    ftp_file_t *lpwh = (ftp_file_t*) hdr;
    ftp_session_t *lpwfs = lpwh->lpFtpSession;
    INT nResCode;
 
    TRACE("\n");
 
    if (lpwh->cache_file_handle != INVALID_HANDLE_VALUE)
        CloseHandle(lpwh->cache_file_handle);
 
    heap_free(lpwh->cache_file);
 
    if (!lpwh->session_deleted)
        lpwfs->download_in_progress = NULL;
 
    if (lpwh->nDataSocket != -1)
        closesocket(lpwh->nDataSocket);
 
    nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
    if (nResCode > 0 && nResCode != 226) WARN("server reports failed transfer\n");
 
    WININET_Release(&lpwh->lpFtpSession->hdr);
}

FTPFILE_LockRequestFile()

static DWORD FTPFILE_LockRequestFile ( object_header_t *  hdr, req_file_t **  ret  )

static

Definition at line 1288 of file ftp.c.

{
    ftp_file_t *file = (ftp_file_t*)hdr;
    FIXME("%p\n", file);
    return ERROR_NOT_SUPPORTED;
}

FTPFILE_QueryDataAvailable()

static DWORD FTPFILE_QueryDataAvailable ( object_header_t *  hdr, DWORD *  available, DWORD  flags, DWORD_PTR  ctx  )

static

Definition at line 1255 of file ftp.c.

{
    ftp_file_t *file = (ftp_file_t*) hdr;
    ULONG unread = 0;
    int retval;
 
    TRACE("(%p %p %x %lx)\n", file, available, flags, ctx);
 
    retval = ioctlsocket(file->nDataSocket, FIONREAD, &unread);
    if (!retval)
        TRACE("%d bytes of queued, but unread data\n", unread);
 
    *available = unread;
 
    if(!unread) {
        BYTE byte;
 
        *available = 0;
 
        retval = sock_recv(file->nDataSocket, &byte, 1, MSG_PEEK);
        if(retval > 0) {
            task_header_t *task;
 
            task = alloc_async_task(&file->hdr, FTPFILE_AsyncQueryDataAvailableProc, sizeof(*task));
            INTERNET_AsyncCall(task);
 
            return ERROR_IO_PENDING;
        }
    }
 
    return ERROR_SUCCESS;
}

FTPFILE_QueryOption()

static DWORD FTPFILE_QueryOption ( object_header_t *  hdr, DWORD  option, void *  buffer, DWORD *  size, BOOL  unicode  )

static

Definition at line 1142 of file ftp.c.

{
    switch(option) {
    case INTERNET_OPTION_HANDLE_TYPE:
        TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(DWORD);
        *(DWORD*)buffer = INTERNET_HANDLE_TYPE_FTP_FILE;
        return ERROR_SUCCESS;
    case INTERNET_OPTION_DATAFILE_NAME:
    {
        DWORD required;
        ftp_file_t *file = (ftp_file_t *)hdr;
 
        TRACE("INTERNET_OPTION_DATAFILE_NAME\n");
 
        if (!file->cache_file)
        {
            *size = 0;
            return ERROR_INTERNET_ITEM_NOT_FOUND;
        }
        if (unicode)
        {
            required = (lstrlenW(file->cache_file) + 1) * sizeof(WCHAR);
            if (*size < required)
                return ERROR_INSUFFICIENT_BUFFER;
 
            *size = required;
            memcpy(buffer, file->cache_file, *size);
            return ERROR_SUCCESS;
        }
        else
        {
            required = WideCharToMultiByte(CP_ACP, 0, file->cache_file, -1, NULL, 0, NULL, NULL);
            if (required > *size)
                return ERROR_INSUFFICIENT_BUFFER;
 
            *size = WideCharToMultiByte(CP_ACP, 0, file->cache_file, -1, buffer, *size, NULL, NULL);
            return ERROR_SUCCESS;
        }
    }
    }
    return INET_QueryOption(hdr, option, buffer, size, unicode);
}

FTPFILE_ReadFile()

static DWORD FTPFILE_ReadFile ( object_header_t *  hdr, void *  buffer, DWORD  size, DWORD *  read, DWORD  flags, DWORD_PTR  context  )

static

Definition at line 1190 of file ftp.c.

{
    ftp_file_t *file = (ftp_file_t*)hdr;
    int res;
    DWORD error;
 
    if (file->nDataSocket == -1)
        return ERROR_INTERNET_DISCONNECTED;
 
    /* FIXME: FTP should use NETCON_ stuff */
    res = sock_recv(file->nDataSocket, buffer, size, MSG_WAITALL);
    *read = res>0 ? res : 0;
 
    error = res >= 0 ? ERROR_SUCCESS : INTERNET_ERROR_BASE; /* FIXME */
    if (error == ERROR_SUCCESS && file->cache_file)
    {
        DWORD bytes_written;
 
        if (!WriteFile(file->cache_file_handle, buffer, *read, &bytes_written, NULL))
            WARN("WriteFile failed: %u\n", GetLastError());
    }
    return error;
}

FTPFILE_WriteFile()

static DWORD FTPFILE_WriteFile ( object_header_t *  hdr, const void *  buffer, DWORD  size, DWORD *  written  )

static

Definition at line 1215 of file ftp.c.

{
    ftp_file_t *lpwh = (ftp_file_t*) hdr;
    int res;
 
    res = sock_send(lpwh->nDataSocket, buffer, size, 0);
 
    *written = res>0 ? res : 0;
    return res >= 0 ? ERROR_SUCCESS : WSAGetLastError();
}

FtpFindFirstFileA()

HINTERNET WINAPI FtpFindFirstFileA	(	HINTERNET	hConnect,
		LPCSTR	lpszSearchFile,
		LPWIN32_FIND_DATAA	lpFindFileData,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 709 of file ftp.c.

{
    LPWSTR lpwzSearchFile;
    WIN32_FIND_DATAW wfd;
    LPWIN32_FIND_DATAW lpFindFileDataW;
    HINTERNET ret;
 
    lpwzSearchFile = heap_strdupAtoW(lpszSearchFile);
    lpFindFileDataW = lpFindFileData?&wfd:NULL;
    ret = FtpFindFirstFileW(hConnect, lpwzSearchFile, lpFindFileDataW, dwFlags, dwContext);
    heap_free(lpwzSearchFile);
 
    if (ret && lpFindFileData)
        WININET_find_data_WtoA(lpFindFileDataW, lpFindFileData);
 
    return ret;
}

Referenced by test_find_first_file().

FtpFindFirstFileW()

HINTERNET WINAPI FtpFindFirstFileW	(	HINTERNET	hConnect,
		LPCWSTR	lpszSearchFile,
		LPWIN32_FIND_DATAW	lpFindFileData,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 757 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    HINTERNET r = NULL;
 
    lpwfs = (ftp_session_t*) get_handle_object( hConnect );
    if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        find_first_file_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpFindFirstFileProc, sizeof(*task));
        task->search_file = heap_strdupW(lpszSearchFile);
        task->find_file_data = lpFindFileData;
        task->flags = dwFlags;
        task->context = dwContext;
 
        INTERNET_AsyncCall(&task->hdr);
        r = NULL;
    }
    else
    {
        r = FTP_FtpFindFirstFileW(lpwfs, lpszSearchFile, lpFindFileData,
            dwFlags, dwContext);
    }
lend:
    if( lpwfs )
        WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpFindFirstFileA().

FTPFINDNEXT_AsyncFindNextFileProc()

static void FTPFINDNEXT_AsyncFindNextFileProc ( task_header_t *  hdr )

static

Definition at line 3482 of file ftp.c.

{
    find_next_task_t *task = (find_next_task_t*)hdr;
 
    FTPFINDNEXT_FindNextFileProc((WININETFTPFINDNEXTW*)task->hdr.hdr, task->find_data);
}

Referenced by FTPFINDNEXT_FindNextFileW().

FTPFINDNEXT_Destroy()

static void FTPFINDNEXT_Destroy ( object_header_t *  hdr )

static

Definition at line 3428 of file ftp.c.

{
    LPWININETFTPFINDNEXTW lpwfn = (LPWININETFTPFINDNEXTW) hdr;
    DWORD i;
 
    TRACE("\n");
 
    WININET_Release(&lpwfn->lpFtpSession->hdr);
 
    for (i = 0; i < lpwfn->size; i++)
    {
        heap_free(lpwfn->lpafp[i].lpszName);
    }
    heap_free(lpwfn->lpafp);
}

FTPFINDNEXT_FindNextFileProc()

static DWORD FTPFINDNEXT_FindNextFileProc ( WININETFTPFINDNEXTW *  find, LPVOID  data  )

static

Definition at line 3444 of file ftp.c.

{
    WIN32_FIND_DATAW *find_data = data;
    DWORD res = ERROR_SUCCESS;
 
    TRACE("index(%d) size(%d)\n", find->index, find->size);
 
    ZeroMemory(find_data, sizeof(WIN32_FIND_DATAW));
 
    if (find->index < find->size) {
        FTP_ConvertFileProp(&find->lpafp[find->index], find_data);
        find->index++;
 
        TRACE("Name: %s\nSize: %d\n", debugstr_w(find_data->cFileName), find_data->nFileSizeLow);
    }else {
        res = ERROR_NO_MORE_FILES;
    }
 
    if (find->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        INTERNET_ASYNC_RESULT iar;
 
        iar.dwResult = (res == ERROR_SUCCESS);
        iar.dwError = res;
 
        INTERNET_SendCallback(&find->hdr, find->hdr.dwContext,
                              INTERNET_STATUS_REQUEST_COMPLETE, &iar,
                              sizeof(INTERNET_ASYNC_RESULT));
    }
 
    return res;
}

Referenced by FTPFINDNEXT_AsyncFindNextFileProc(), and FTPFINDNEXT_FindNextFileW().

FTPFINDNEXT_FindNextFileW()

static DWORD FTPFINDNEXT_FindNextFileW ( object_header_t *  hdr, void *  data  )

static

Definition at line 3506 of file ftp.c.

{
    WININETFTPFINDNEXTW *find = (WININETFTPFINDNEXTW*)hdr;
 
    if (find->lpFtpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        find_next_task_t *task;
 
        task = alloc_async_task(&find->hdr, FTPFINDNEXT_AsyncFindNextFileProc, sizeof(*task));
        task->find_data = data;
 
        INTERNET_AsyncCall(&task->hdr);
        return ERROR_SUCCESS;
    }
 
    return FTPFINDNEXT_FindNextFileProc(find, data);
}

FTPFINDNEXT_QueryOption()

static DWORD FTPFINDNEXT_QueryOption ( object_header_t *  hdr, DWORD  option, void *  buffer, DWORD *  size, BOOL  unicode  )

static

Definition at line 3489 of file ftp.c.

{
    switch(option) {
    case INTERNET_OPTION_HANDLE_TYPE:
        TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(DWORD);
        *(DWORD*)buffer = INTERNET_HANDLE_TYPE_FTP_FIND;
        return ERROR_SUCCESS;
    }
 
    return INET_QueryOption(hdr, option, buffer, size, unicode);
}

FtpGetCurrentDirectoryA()

BOOL WINAPI FtpGetCurrentDirectoryA	(	HINTERNET	hFtpSession,
		LPSTR	lpszCurrentDirectory,
		LPDWORD	lpdwCurrentDirectory
	)

Definition at line 916 of file ftp.c.

{
    WCHAR *dir = NULL;
    DWORD len;
    BOOL ret;
 
    if(lpdwCurrentDirectory) {
        len = *lpdwCurrentDirectory;
        if(lpszCurrentDirectory)
        {
            dir = heap_alloc(len * sizeof(WCHAR));
            if (NULL == dir)
            {
                INTERNET_SetLastError(ERROR_OUTOFMEMORY);
                return FALSE;
            }
        }
    }
    ret = FtpGetCurrentDirectoryW(hFtpSession, lpszCurrentDirectory?dir:NULL, lpdwCurrentDirectory?&len:NULL);
 
    if (ret && lpszCurrentDirectory)
        WideCharToMultiByte(CP_ACP, 0, dir, -1, lpszCurrentDirectory, len, NULL, NULL);
 
    if (lpdwCurrentDirectory) *lpdwCurrentDirectory = len;
    heap_free(dir);
    return ret;
}

Referenced by test_get_current_dir().

FtpGetCurrentDirectoryW()

BOOL WINAPI FtpGetCurrentDirectoryW	(	HINTERNET	hFtpSession,
		LPWSTR	lpszCurrentDirectory,
		LPDWORD	lpdwCurrentDirectory
	)

Definition at line 971 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    TRACE("%p %p %p\n", hFtpSession, lpszCurrentDirectory, lpdwCurrentDirectory);
 
    lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
    if (NULL == lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        goto lend;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (!lpdwCurrentDirectory)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    if (lpszCurrentDirectory == NULL)
    {
        INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        get_current_dir_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpGetCurrentDirectoryProc, sizeof(*task));
        task->directory = lpszCurrentDirectory;
        task->directory_len = lpdwCurrentDirectory;
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpGetCurrentDirectoryW(lpwfs, lpszCurrentDirectory,
            lpdwCurrentDirectory);
    }
 
lend:
    if( lpwfs )
        WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpGetCurrentDirectoryA().

FtpGetFileA()

BOOL WINAPI FtpGetFileA	(	HINTERNET	hInternet,
		LPCSTR	lpszRemoteFile,
		LPCSTR	lpszNewFile,
		BOOL	fFailIfExists,
		DWORD	dwLocalFlagsAttribute,
		DWORD	dwInternetFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1559 of file ftp.c.

{
    LPWSTR lpwzRemoteFile;
    LPWSTR lpwzNewFile;
    BOOL ret;
 
    lpwzRemoteFile = heap_strdupAtoW(lpszRemoteFile);
    lpwzNewFile = heap_strdupAtoW(lpszNewFile);
    ret = FtpGetFileW(hInternet, lpwzRemoteFile, lpwzNewFile, fFailIfExists,
        dwLocalFlagsAttribute, dwInternetFlags, dwContext);
    heap_free(lpwzRemoteFile);
    heap_free(lpwzNewFile);
    return ret;
}

Referenced by test_getfile(), test_getfile_no_open(), and test_openfile().

FtpGetFileSize()

DWORD WINAPI FtpGetFileSize	(	HINTERNET	hFile,
		LPDWORD	lpdwFileSizeHigh
	)

Definition at line 1757 of file ftp.c.

{
    FIXME("(%p, %p)\n", hFile, lpdwFileSizeHigh);
 
    if (lpdwFileSizeHigh)
        *lpdwFileSizeHigh = 0;
 
    return 0;
}

Referenced by FtpProtocol_start_downloading(), and CDownloadManager::ThreadFunc().

FtpGetFileW()

BOOL WINAPI FtpGetFileW	(	HINTERNET	hInternet,
		LPCWSTR	lpszRemoteFile,
		LPCWSTR	lpszNewFile,
		BOOL	fFailIfExists,
		DWORD	dwLocalFlagsAttribute,
		DWORD	dwInternetFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1610 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    if (!lpszRemoteFile || !lpszNewFile)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    lpwfs = (ftp_session_t*) get_handle_object( hInternet );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if ((dwInternetFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        get_file_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpGetFileProc, sizeof(*task));
        task->remote_file = heap_strdupW(lpszRemoteFile);
        task->new_file = heap_strdupW(lpszNewFile);
        task->local_attr = dwLocalFlagsAttribute;
        task->fail_if_exists = fFailIfExists;
        task->flags = dwInternetFlags;
        task->context = dwContext;
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpGetFileW(lpwfs, lpszRemoteFile, lpszNewFile,
           fFailIfExists, dwLocalFlagsAttribute, dwInternetFlags, dwContext);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpGetFileA().

FtpOpenFileA()

HINTERNET WINAPI FtpOpenFileA	(	HINTERNET	hFtpSession,
		LPCSTR	lpszFileName,
		DWORD	fdwAccess,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1443 of file ftp.c.

{
    LPWSTR lpwzFileName;
    HINTERNET ret;
 
    lpwzFileName = heap_strdupAtoW(lpszFileName);
    ret = FtpOpenFileW(hFtpSession, lpwzFileName, fdwAccess, dwFlags, dwContext);
    heap_free(lpwzFileName);
    return ret;
}

Referenced by test_find_first_file(), and test_openfile().

FtpOpenFileW()

HINTERNET WINAPI FtpOpenFileW	(	HINTERNET	hFtpSession,
		LPCWSTR	lpszFileName,
		DWORD	fdwAccess,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 1485 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    HINTERNET r = NULL;
 
    TRACE("(%p,%s,0x%08x,0x%08x,0x%08lx)\n", hFtpSession,
        debugstr_w(lpszFileName), fdwAccess, dwFlags, dwContext);
 
    lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if ((!lpszFileName) ||
        ((fdwAccess != GENERIC_READ) && (fdwAccess != GENERIC_WRITE)) ||
        ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY))
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        open_file_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpOpenFileProc, sizeof(*task));
        task->file_name = heap_strdupW(lpszFileName);
        task->access = fdwAccess;
        task->flags = dwFlags;
        task->context = dwContext;
 
        INTERNET_AsyncCall(&task->hdr);
        r = NULL;
    }
    else
    {
    r = FTP_FtpOpenFileW(lpwfs, lpszFileName, fdwAccess, dwFlags, dwContext);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpOpenFileA(), and INTERNET_InternetOpenUrlW().

FtpPutFileA()

BOOL WINAPI FtpPutFileA	(	HINTERNET	hConnect,
		LPCSTR	lpszLocalFile,
		LPCSTR	lpszNewRemoteFile,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 224 of file ftp.c.

{
    LPWSTR lpwzLocalFile;
    LPWSTR lpwzNewRemoteFile;
    BOOL ret;
 
    lpwzLocalFile = heap_strdupAtoW(lpszLocalFile);
    lpwzNewRemoteFile = heap_strdupAtoW(lpszNewRemoteFile);
    ret = FtpPutFileW(hConnect, lpwzLocalFile, lpwzNewRemoteFile,
                      dwFlags, dwContext);
    heap_free(lpwzLocalFile);
    heap_free(lpwzNewRemoteFile);
    return ret;
}

Referenced by test_openfile(), and test_putfile().

FtpPutFileW()

BOOL WINAPI FtpPutFileW	(	HINTERNET	hConnect,
		LPCWSTR	lpszLocalFile,
		LPCWSTR	lpszNewRemoteFile,
		DWORD	dwFlags,
		DWORD_PTR	dwContext
	)

Definition at line 272 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    if (!lpszLocalFile || !lpszNewRemoteFile)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    lpwfs = (ftp_session_t*) get_handle_object( hConnect );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    if ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        put_file_task_t *task = alloc_async_task(&lpwfs->hdr, AsyncFtpPutFileProc, sizeof(*task));
 
        task->local_file = heap_strdupW(lpszLocalFile);
        task->remote_file = heap_strdupW(lpszNewRemoteFile);
        task->flags = dwFlags;
        task->context = dwContext;
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpPutFileW(lpwfs, lpszLocalFile,
        lpszNewRemoteFile, dwFlags, dwContext);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpPutFileA().

FtpRemoveDirectoryA()

BOOL WINAPI FtpRemoveDirectoryA	(	HINTERNET	hFtpSession,
		LPCSTR	lpszDirectory
	)

Definition at line 1924 of file ftp.c.

{
    LPWSTR lpwzDirectory;
    BOOL ret;
 
    lpwzDirectory = heap_strdupAtoW(lpszDirectory);
    ret = FtpRemoveDirectoryW(hFtpSession, lpwzDirectory);
    heap_free(lpwzDirectory);
    return ret;
}

Referenced by test_openfile(), and test_removedir().

FtpRemoveDirectoryW()

BOOL WINAPI FtpRemoveDirectoryW	(	HINTERNET	hFtpSession,
		LPCWSTR	lpszDirectory
	)

Definition at line 1956 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    if (!lpszDirectory)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        directory_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpRemoveDirectoryProc, sizeof(*task));
        task->directory = heap_strdupW(lpszDirectory);
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpRemoveDirectoryW(lpwfs, lpszDirectory);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpRemoveDirectoryA().

FtpRenameFileA()

BOOL WINAPI FtpRenameFileA	(	HINTERNET	hFtpSession,
		LPCSTR	lpszSrc,
		LPCSTR	lpszDest
	)

Definition at line 2067 of file ftp.c.

{
    LPWSTR lpwzSrc;
    LPWSTR lpwzDest;
    BOOL ret;
 
    lpwzSrc = heap_strdupAtoW(lpszSrc);
    lpwzDest = heap_strdupAtoW(lpszDest);
    ret = FtpRenameFileW(hFtpSession, lpwzSrc, lpwzDest);
    heap_free(lpwzSrc);
    heap_free(lpwzDest);
    return ret;
}

Referenced by test_openfile(), and test_renamefile().

FtpRenameFileW()

BOOL WINAPI FtpRenameFileW	(	HINTERNET	hFtpSession,
		LPCWSTR	lpszSrc,
		LPCWSTR	lpszDest
	)

Definition at line 2109 of file ftp.c.

{
    ftp_session_t *lpwfs;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
    if (!lpwfs)
    {
        INTERNET_SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    if (!lpszSrc || !lpszDest)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        rename_file_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpRenameFileProc, sizeof(*task));
        task->src_file = heap_strdupW(lpszSrc);
        task->dst_file = heap_strdupW(lpszDest);
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpRenameFileW(lpwfs, lpszSrc, lpszDest);
    }
 
lend:
    WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpRenameFileA().

FTPSESSION_CloseConnection()

static void FTPSESSION_CloseConnection ( object_header_t *  hdr )

static

Definition at line 2354 of file ftp.c.

{
    ftp_session_t *lpwfs = (ftp_session_t*) hdr;
 
    TRACE("\n");
 
    INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
                      INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
 
    if (lpwfs->download_in_progress != NULL)
        lpwfs->download_in_progress->session_deleted = TRUE;
 
    if (lpwfs->sndSocket != -1)
        closesocket(lpwfs->sndSocket);
 
    if (lpwfs->lstnSocket != -1)
        closesocket(lpwfs->lstnSocket);
 
    if (lpwfs->pasvSocket != -1)
        closesocket(lpwfs->pasvSocket);
 
    INTERNET_SendCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
                      INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
}

FTPSESSION_Destroy()

static void FTPSESSION_Destroy ( object_header_t *  hdr )

static

Definition at line 2341 of file ftp.c.

{
    ftp_session_t *lpwfs = (ftp_session_t*) hdr;
 
    TRACE("\n");
 
    WININET_Release(&lpwfs->lpAppInfo->hdr);
 
    heap_free(lpwfs->lpszPassword);
    heap_free(lpwfs->lpszUserName);
    heap_free(lpwfs->servername);
}

FTPSESSION_QueryOption()

static DWORD FTPSESSION_QueryOption ( object_header_t *  hdr, DWORD  option, void *  buffer, DWORD *  size, BOOL  unicode  )

static

Definition at line 2379 of file ftp.c.

{
    switch(option) {
    case INTERNET_OPTION_HANDLE_TYPE:
        TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
 
        if (*size < sizeof(ULONG))
            return ERROR_INSUFFICIENT_BUFFER;
 
        *size = sizeof(DWORD);
        *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_FTP;
        return ERROR_SUCCESS;
    }
 
    return INET_QueryOption(hdr, option, buffer, size, unicode);
}

FtpSetCurrentDirectoryA()

BOOL WINAPI FtpSetCurrentDirectoryA	(	HINTERNET	hConnect,
		LPCSTR	lpszDirectory
	)

Definition at line 419 of file ftp.c.

{
    LPWSTR lpwzDirectory;
    BOOL ret;
 
    lpwzDirectory = heap_strdupAtoW(lpszDirectory);
    ret = FtpSetCurrentDirectoryW(hConnect, lpwzDirectory);
    heap_free(lpwzDirectory);
    return ret;
}

Referenced by test_find_first_file().

FtpSetCurrentDirectoryW()

BOOL WINAPI FtpSetCurrentDirectoryW	(	HINTERNET	hConnect,
		LPCWSTR	lpszDirectory
	)

Definition at line 456 of file ftp.c.

{
    ftp_session_t *lpwfs = NULL;
    appinfo_t *hIC = NULL;
    BOOL r = FALSE;
 
    if (!lpszDirectory)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        goto lend;
    }
 
    lpwfs = (ftp_session_t*) get_handle_object( hConnect );
    if (NULL == lpwfs || WH_HFTPSESSION != lpwfs->hdr.htype)
    {
        INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
        goto lend;
    }
 
    if (lpwfs->download_in_progress != NULL)
    {
        INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
        goto lend;
    }
 
    TRACE("lpszDirectory(%s)\n", debugstr_w(lpszDirectory));
 
    hIC = lpwfs->lpAppInfo;
    if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
    {
        directory_task_t *task;
 
        task = alloc_async_task(&lpwfs->hdr, AsyncFtpSetCurrentDirectoryProc, sizeof(*task));
        task->directory = heap_strdupW(lpszDirectory);
 
        r = res_to_le(INTERNET_AsyncCall(&task->hdr));
    }
    else
    {
        r = FTP_FtpSetCurrentDirectoryW(lpwfs, lpszDirectory);
    }
 
lend:
    if( lpwfs )
        WININET_Release( &lpwfs->hdr );
 
    return r;
}

Referenced by FtpSetCurrentDirectoryA().

res_to_le()

static BOOL res_to_le ( DWORD  res )

static

Definition at line 207 of file ftp.c.

{
    if(res != ERROR_SUCCESS)
        INTERNET_SetLastError(res);
    return res == ERROR_SUCCESS;
}

Referenced by FtpCreateDirectoryW(), FtpDeleteFileW(), FtpGetCurrentDirectoryW(), FtpGetFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), and FtpSetCurrentDirectoryW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wininet

)

Variable Documentation

FTPFILEVtbl

const object_vtbl_t FTPFILEVtbl

static

Initial value:

= {
    FTPFILE_Destroy,
    NULL,
    FTPFILE_QueryOption,
    INET_SetOption,
    FTPFILE_ReadFile,
    FTPFILE_WriteFile,
    FTPFILE_QueryDataAvailable,
    NULL,
    FTPFILE_LockRequestFile
}

Definition at line 1295 of file ftp.c.

Referenced by FTP_FtpOpenFileW().

FTPFINDNEXTVtbl

const object_vtbl_t FTPFINDNEXTVtbl

static

Initial value:

= {
    FTPFINDNEXT_Destroy,
    NULL,
    FTPFINDNEXT_QueryOption,
    INET_SetOption,
    NULL,
    NULL,
    NULL,
    FTPFINDNEXT_FindNextFileW
}

Definition at line 3524 of file ftp.c.

Referenced by FTP_ReceiveFileList().

FTPSESSIONVtbl

const object_vtbl_t FTPSESSIONVtbl

static

Initial value:

= {
    FTPSESSION_Destroy,
    FTPSESSION_CloseConnection,
    FTPSESSION_QueryOption,
    INET_SetOption,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 2396 of file ftp.c.

Referenced by FTP_Connect().

szFtpCommands

const CHAR* const szFtpCommands[]

static

Initial value:

= {
  "ACCT",
  "CWD",
  "DELE",
  "MKD",
  "PASS",
  "PORT",
  "RETR",
  "RMD",
  "RNFR",
  "RNTO",
  "STOR",
  "TYPE",
  "USER",
  "SIZE",
  "ABOR",
  "LIST",
  "NLST",
  "PASV",
  "PWD",
  "QUIT",
}

Definition at line 142 of file ftp.c.

Referenced by FTP_SendCommandA().

szMonths

const CHAR szMonths[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC"

static

Definition at line 165 of file ftp.c.

Referenced by FTP_ParseNextFile().