2005 lines
58 KiB
C++
2005 lines
58 KiB
C++
/*++
|
||
|
||
Copyright (c) 1994 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
protocol.cxx
|
||
|
||
Abstract:
|
||
|
||
Contains functions to negotiate data connections with, send commands to and
|
||
receive data from, the FTP server
|
||
|
||
Contents:
|
||
Command
|
||
I_Command
|
||
NegotiateDataConnection
|
||
GetReply
|
||
ReceiveFtpResponse
|
||
AbortTransfer
|
||
(SendCommand)
|
||
(I_SendCommand)
|
||
(I_AttemptDataNegotiation)
|
||
(I_NegotiateDataConnection)
|
||
|
||
Author:
|
||
|
||
Heath Hunnicutt (t-hheath) 21-Jun-1994
|
||
|
||
Environment:
|
||
|
||
Win32 user-level DLL
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include <wininetp.h>
|
||
#include "ftpapih.h"
|
||
|
||
//
|
||
// private prototypes
|
||
//
|
||
|
||
PRIVATE
|
||
DWORD
|
||
__cdecl
|
||
SendCommand(
|
||
IN ICSocket * s,
|
||
IN LPCSTR lpszFormat,
|
||
IN ...
|
||
);
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_SendCommand(
|
||
IN ICSocket * s,
|
||
IN LPCSTR lpszFormat,
|
||
va_list arglist
|
||
);
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_AttemptDataNegotiation(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN va_list arglist
|
||
);
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_NegotiateDataConnection(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN va_list arglist,
|
||
IN BOOL bOverridePassive
|
||
);
|
||
|
||
//
|
||
// functions
|
||
//
|
||
|
||
|
||
DWORD
|
||
Command(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN BOOL fExpectResponse,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN ...
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sends a command to the FTP server on the control connection and optionally
|
||
sets up a data connection. Wrapper for I_Command()
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO describing FTP server and
|
||
our connection to it
|
||
|
||
fExpectResponse - TRUE if we need a data connection
|
||
|
||
dwFlags - controlling how to transfer data between the client
|
||
and server data connection, and how to set up data
|
||
connection
|
||
|
||
prcResponse - pointer to response code returned from server
|
||
|
||
lpszCommandFormat - pointer to command string
|
||
|
||
... - optional arguments for command string
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"Command",
|
||
"%#x, %B, %#x, %#x, %q",
|
||
lpSessionInfo,
|
||
fExpectResponse,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat
|
||
));
|
||
|
||
DWORD error;
|
||
va_list arglist;
|
||
|
||
va_start(arglist, lpszCommandFormat);
|
||
|
||
error = I_Command(lpSessionInfo,
|
||
fExpectResponse,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist
|
||
);
|
||
|
||
va_end(arglist);
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
DWORD
|
||
I_Command(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN BOOL fExpectResponse,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN va_list arglist
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sends a command to the FTP server, and if requested, negotiates a data
|
||
connection
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO describing the FTP server
|
||
and our connection to it
|
||
|
||
fExpectResponse - TRUE if we need a data connection
|
||
|
||
dwFlags - controlling how to transfer data between the client
|
||
and server data connection, and how to set up data
|
||
connection
|
||
|
||
prcResponse - pointer to returned server response
|
||
|
||
lpszCommandFormat - command to send to server
|
||
|
||
arglist - optional arguments for lpszCommandFormat
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"I_Command",
|
||
"%#x, %B, %#x, %#x, %q, %#x",
|
||
lpSessionInfo,
|
||
fExpectResponse,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist
|
||
));
|
||
|
||
DWORD error;
|
||
|
||
INET_ASSERT(lpSessionInfo != NULL);
|
||
INET_ASSERT(prcResponse != NULL);
|
||
INET_ASSERT(lpszCommandFormat != NULL);
|
||
INET_ASSERT( ((dwFlags & FTP_TRANSFER_TYPE_MASK) == FTP_TRANSFER_TYPE_UNKNOWN)
|
||
|| ((dwFlags & FTP_TRANSFER_TYPE_MASK) == FTP_TRANSFER_TYPE_ASCII)
|
||
|| ((dwFlags & FTP_TRANSFER_TYPE_MASK) == FTP_TRANSFER_TYPE_BINARY)
|
||
);
|
||
|
||
//
|
||
// if the control socket is not valid, return "connection dropped"
|
||
//
|
||
|
||
if (!lpSessionInfo->socketControl->IsValid()) {
|
||
error = ERROR_FTP_DROPPED;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// there can only be one data connection established for each FTP session
|
||
//
|
||
|
||
if (lpSessionInfo->socketData->IsValid()) {
|
||
error = ERROR_FTP_TRANSFER_IN_PROGRESS;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// if we need a data connection then send the connection set-up commands
|
||
// and issue the command
|
||
//
|
||
|
||
if (fExpectResponse) {
|
||
error = I_AttemptDataNegotiation(lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist
|
||
);
|
||
if (error == ERROR_SUCCESS) {
|
||
|
||
//
|
||
// check the server response for failure
|
||
//
|
||
|
||
if ((prcResponse->Major != FTP_RESPONSE_PRELIMINARY)
|
||
&& (prcResponse->Major != FTP_RESPONSE_COMPLETE)) {
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// no data connection required, just send the command and check any
|
||
// response from the server for a failure indication
|
||
//
|
||
|
||
error = I_SendCommand(lpSessionInfo->socketControl,
|
||
lpszCommandFormat,
|
||
arglist
|
||
);
|
||
if (error == ERROR_SUCCESS) {
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error == ERROR_SUCCESS) {
|
||
if ((prcResponse->Major != FTP_RESPONSE_COMPLETE)
|
||
&& (prcResponse->Major != FTP_RESPONSE_CONTINUE)
|
||
&& (prcResponse->Major != FTP_RESPONSE_PRELIMINARY)) {
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
quit:
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
DWORD
|
||
NegotiateDataConnection(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN ...
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sets up a data connection between this client and the FTP server. Wrapper
|
||
for I_AttemptDataNegotiation()
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO describing the FTP server
|
||
and our connection to it
|
||
|
||
dwFlags - controlling how to transfer data between the client
|
||
and server data connection, and how to set up data
|
||
connection
|
||
|
||
prcResponse - pointer to returned server response code
|
||
|
||
lpszCommandFormat - command string to send
|
||
|
||
... - optional arguments for lpszCommandFormat
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
error returned by Windows sockets
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"NegotiateDataConnection",
|
||
"%#x, %#x, %#x, %q",
|
||
lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat
|
||
));
|
||
|
||
va_list arglist;
|
||
|
||
va_start(arglist, lpszCommandFormat);
|
||
|
||
DWORD error = I_AttemptDataNegotiation(lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist
|
||
);
|
||
|
||
va_end(arglist);
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
DWORD
|
||
GetReply(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
OUT FTP_RESPONSE_CODE *prcResponse
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Gets the response code from the server. The response text is stored in the
|
||
per-thread last response text field, and the FTP response code is parsed
|
||
off the start of the text and returned in prcResponse
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO for which to get response text
|
||
|
||
prcResponse - pointer to the response code structure
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - Win32 error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"GetReply",
|
||
"%#x, %#x",
|
||
lpSessionInfo,
|
||
prcResponse
|
||
));
|
||
|
||
PCHAR pchReplyBuffer;
|
||
DWORD cchBufferLength;
|
||
DWORD error;
|
||
|
||
INET_ASSERT(prcResponse != NULL);
|
||
|
||
//
|
||
// set up a default error code
|
||
//
|
||
|
||
prcResponse->Major = FTP_RESPONSE_PERMANENT_FAILURE;
|
||
prcResponse->Minor = 0;
|
||
prcResponse->Detail = 0;
|
||
prcResponse->Status = 0;
|
||
|
||
pchReplyBuffer = NULL;
|
||
|
||
//
|
||
// receive the last response on the control socket
|
||
//
|
||
|
||
error = ReceiveFtpResponse(lpSessionInfo->socketControl,
|
||
(LPVOID *)&pchReplyBuffer,
|
||
&cchBufferLength,
|
||
TRUE,
|
||
prcResponse
|
||
);
|
||
if (error == ERROR_SUCCESS) {
|
||
|
||
INET_ASSERT(pchReplyBuffer != NULL);
|
||
|
||
//
|
||
// append this response text to that already stored in this thread's
|
||
// data object
|
||
//
|
||
|
||
InternetSetLastError(0,
|
||
pchReplyBuffer,
|
||
cchBufferLength,
|
||
SLE_APPEND | SLE_ZERO_TERMINATE
|
||
);
|
||
|
||
//
|
||
// extract status code
|
||
//
|
||
|
||
LPSTR lpszError = pchReplyBuffer;
|
||
|
||
ExtractInt(&lpszError, 0, &prcResponse->Status);
|
||
|
||
DEBUG_PRINT(PROTOCOL, INFO, ("FTP status = %d\n", prcResponse->Status));
|
||
|
||
} else {
|
||
|
||
INET_ASSERT(pchReplyBuffer == NULL);
|
||
|
||
}
|
||
|
||
//
|
||
// finished with the buffer
|
||
//
|
||
|
||
if (pchReplyBuffer != NULL) {
|
||
pchReplyBuffer = (PCHAR)FREE_MEMORY((HLOCAL)pchReplyBuffer);
|
||
|
||
INET_ASSERT(pchReplyBuffer == NULL);
|
||
|
||
}
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
DWORD
|
||
ReceiveFtpResponse(
|
||
IN ICSocket * Socket,
|
||
OUT LPVOID * lpBuffer,
|
||
OUT LPDWORD lpdwBufferLength,
|
||
IN BOOL fEndOfLineCheck,
|
||
IN FTP_RESPONSE_CODE * prcResponse
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Receives data from the FTP server. Optionally parses it for end-of-line
|
||
sequence
|
||
|
||
This function is typically going to receive one or more lines of response
|
||
data, i.e. a small amount of data. Also typically, we will not normally
|
||
expect to get EOF(connection) because we are usually reading the control
|
||
connection
|
||
|
||
Arguments:
|
||
|
||
Socket - socket on which to receive data
|
||
|
||
lpBuffer - pointer to pointer to returned data buffer
|
||
|
||
lpdwBufferLength - pointer to returned length of (returned) data buffer
|
||
|
||
fEndOfLineCheck - TRUE if we are to perform an end-of-line check
|
||
|
||
prcResponse - pointer to returned server response code
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"ReceiveFtpResponse",
|
||
"%#x, %#x, %#x, %B, %#x",
|
||
Socket,
|
||
lpBuffer,
|
||
lpdwBufferLength,
|
||
fEndOfLineCheck,
|
||
prcResponse
|
||
));
|
||
|
||
INET_ASSERT(lpBuffer != NULL);
|
||
INET_ASSERT(lpdwBufferLength != NULL);
|
||
|
||
if (fEndOfLineCheck) {
|
||
|
||
INET_ASSERT(prcResponse != NULL);
|
||
|
||
}
|
||
|
||
LPSTR pchBuffer;
|
||
DWORD bufferLength;
|
||
DWORD bufferLeft;
|
||
DWORD bytesReceived;
|
||
int idxPosInLine;
|
||
BOOL fLastLineDigitsSeen;
|
||
BOOL fAtEOL;
|
||
int nNumericReply;
|
||
DWORD error;
|
||
|
||
//
|
||
// initialize variables (for SocketReceive())
|
||
//
|
||
|
||
pchBuffer = NULL;
|
||
bufferLength = 0;
|
||
bufferLeft = 0;
|
||
bytesReceived = 0;
|
||
|
||
//
|
||
// get per-thread info block to determine blocking/non-blocking socket calls
|
||
//
|
||
|
||
LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
|
||
|
||
if (lpThreadInfo == NULL) {
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
goto done;
|
||
}
|
||
|
||
//DWORD asyncFlags;
|
||
//
|
||
//asyncFlags = 0;
|
||
//asyncFlags = lpThreadInfo->IsAsyncWorkerThread ? SF_NON_BLOCKING : 0;
|
||
|
||
//
|
||
// this flag is set to FALSE once the digits are definitely NOT seen, and
|
||
// needs to be TRUE at the start of each new line
|
||
//
|
||
|
||
fLastLineDigitsSeen = TRUE;
|
||
nNumericReply = 0;
|
||
idxPosInLine = 0;
|
||
fAtEOL = FALSE;
|
||
|
||
BOOL eofData;
|
||
|
||
while (TRUE) {
|
||
|
||
//
|
||
// get the next chunk of response data from the server. Since we are
|
||
// expecting a response (i.e. small amount of data (< 1K)) we shouldn't
|
||
// have to do this too many times
|
||
//
|
||
|
||
error = Socket->Receive(
|
||
(LPVOID *)&pchBuffer,
|
||
&bufferLength,
|
||
&bufferLeft,
|
||
&bytesReceived,
|
||
sizeof('\0'), // dwExtraSpace
|
||
SF_EXPAND // SocketReceive will allocate/grow the buffer
|
||
| SF_COMPRESS // and compress any unused space at EOF
|
||
| SF_INDICATE, // and make indications to app
|
||
&eofData
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// if we have hit the end of the data then zero-terminate the buffer
|
||
//
|
||
|
||
if (eofData) {
|
||
|
||
INET_ASSERT(bufferLeft > 0);
|
||
|
||
pchBuffer[bytesReceived] = '\0';
|
||
}
|
||
|
||
//
|
||
// if requested, find out if we got the end-of-line (on the last line)
|
||
//
|
||
|
||
if (fEndOfLineCheck) {
|
||
|
||
//
|
||
// look for the final line of the response
|
||
//
|
||
|
||
for (DWORD bytesChecked = 0;
|
||
bytesChecked < bytesReceived;
|
||
++bytesChecked, ++idxPosInLine) {
|
||
|
||
//
|
||
// ISSUE: fAtEOL && fLastLineDigitsSeen ==> protocol error,
|
||
// since there is data after the response line
|
||
//
|
||
|
||
//
|
||
// if the previous character was an EOL, then the next one must
|
||
// be the start of the next line. Reinitialize the response-
|
||
// decoding state
|
||
//
|
||
|
||
if (fAtEOL) {
|
||
fLastLineDigitsSeen = TRUE;
|
||
nNumericReply = 0;
|
||
idxPosInLine = 0;
|
||
fAtEOL = FALSE;
|
||
}
|
||
|
||
//
|
||
// if (so far) this line has been of the form we expect for a
|
||
// response last-line, check the chars we just received to see
|
||
// if it maintains that form
|
||
//
|
||
// since this form is completely determined by the first four
|
||
// characters of the line, limit the checking to those chars
|
||
//
|
||
|
||
if (fLastLineDigitsSeen && (idxPosInLine < 4)) {
|
||
if (idxPosInLine < 3) {
|
||
|
||
//
|
||
// if one of the first three chars is not a digit, mark
|
||
// this line as a non-response
|
||
//
|
||
|
||
if (!isdigit(pchBuffer[bytesChecked])) {
|
||
fLastLineDigitsSeen = FALSE;
|
||
} else {
|
||
|
||
//
|
||
// store the numeric reply in an int
|
||
//
|
||
|
||
nNumericReply *= 10;
|
||
nNumericReply += (int)(pchBuffer[bytesChecked] - '0');
|
||
}
|
||
} else if (idxPosInLine == 3) {
|
||
|
||
//
|
||
// the first three chars must be digits. If the fourth is a
|
||
// space, then this line has the right form
|
||
//
|
||
|
||
if (pchBuffer[bytesChecked] != ' ') {
|
||
fLastLineDigitsSeen = FALSE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// if at the end of a line, reset vars for the next line
|
||
//
|
||
|
||
if (pchBuffer[bytesChecked] == '\n') {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
INFO,
|
||
("At EOL, and fDigits = %B\n",
|
||
fLastLineDigitsSeen
|
||
));
|
||
|
||
fAtEOL = TRUE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// if this data is expected to end in a proper response line, and that
|
||
// line has been received, stop receiving more data
|
||
//
|
||
|
||
if (fEndOfLineCheck && fLastLineDigitsSeen && fAtEOL) {
|
||
|
||
//
|
||
// we found the end of the response, although we may not have
|
||
// received an EOF(transmission) indication, because the server
|
||
// didn't close the connection. Zero terminate the buffer
|
||
//
|
||
|
||
INET_ASSERT(bufferLeft > 0);
|
||
|
||
pchBuffer[bytesReceived] = '\0';
|
||
|
||
//
|
||
// tear the numeric reply up by digit, placing it into our nicer
|
||
// reply structure
|
||
//
|
||
|
||
INET_ASSERT(nNumericReply >= 0);
|
||
INET_ASSERT(nNumericReply < 1000);
|
||
|
||
prcResponse->Major = (nNumericReply / 100) % 10;
|
||
prcResponse->Minor = (nNumericReply / 10) % 10;
|
||
prcResponse->Detail = (nNumericReply) % 10;
|
||
error = ERROR_SUCCESS;
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// if we were receiving data that was supposed to end in an EOL then this
|
||
// is an error condition. Otherwise, it is the expected way to signal the
|
||
// end of transmission
|
||
//
|
||
|
||
if (eofData) {
|
||
if (fEndOfLineCheck) {
|
||
error = ERROR_FTP_DROPPED;
|
||
goto quit;
|
||
} else {
|
||
|
||
//
|
||
// caller just receiving data. We're done
|
||
//
|
||
|
||
error = ERROR_SUCCESS;
|
||
goto done;
|
||
}
|
||
}
|
||
}
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
quit:
|
||
|
||
INET_ASSERT(error != ERROR_SUCCESS);
|
||
|
||
if (pchBuffer != NULL) {
|
||
pchBuffer = (LPSTR)FREE_MEMORY((HLOCAL)pchBuffer);
|
||
|
||
INET_ASSERT(pchBuffer == NULL);
|
||
|
||
}
|
||
|
||
done:
|
||
|
||
*lpBuffer = pchBuffer;
|
||
*lpdwBufferLength = bytesReceived;
|
||
|
||
INET_ASSERT((pchBuffer != NULL) ? (*(LPDWORD)pchBuffer != 0xc5c5c5c5) : TRUE);
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
DWORD
|
||
AbortTransfer(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Aborts an ongoing transfer. Typically used to terminate a read file
|
||
operation early. We don't expect a response from the server in this case
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO containing context for sesion
|
||
to abort
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_INTERNET_EXTENDED_ERROR
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"AbortTransfer",
|
||
"%#x",
|
||
lpSessionInfo
|
||
));
|
||
|
||
//
|
||
// get per-thread info block to determine blocking/non-blocking socket calls
|
||
//
|
||
|
||
LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
|
||
DWORD error;
|
||
|
||
if (lpThreadInfo == NULL) {
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
goto quit;
|
||
}
|
||
|
||
//DWORD asyncFlags;
|
||
//
|
||
//asyncFlags = 0;
|
||
//asyncFlags = lpThreadInfo->IsAsyncWorkerThread ? SF_NON_BLOCKING : 0;
|
||
|
||
//
|
||
// send an ABORT preceded by the following NVT/Telnet sequences:
|
||
//
|
||
// FF F4 = Interrupt Process (IP)
|
||
// FF F2 = Data Mark (DM)
|
||
//
|
||
|
||
#define ABORT_COMMAND NVT_INTERRUPT_PROCESS_STRING \
|
||
NVT_DATA_MARK_STRING \
|
||
"ABOR" \
|
||
"\r\n"
|
||
|
||
//
|
||
// BUGBUG - the IP/DM sequence should be sent as URGENT data
|
||
//
|
||
|
||
error = lpSessionInfo->socketControl->Send((LPBYTE)ABORT_COMMAND,
|
||
sizeof(ABORT_COMMAND) - 1,
|
||
SF_INDICATE
|
||
);
|
||
|
||
quit:
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
//
|
||
// private functions
|
||
//
|
||
|
||
|
||
PRIVATE
|
||
DWORD
|
||
__cdecl
|
||
SendCommand(
|
||
IN ICSocket * Socket,
|
||
IN LPCSTR lpszFormat,
|
||
IN ...
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sends a command string to the FTP server. Wrapper for I_SendCommand()
|
||
|
||
Arguments:
|
||
|
||
Socket - socket to send data on
|
||
|
||
lpszFormat - printf-style format string
|
||
|
||
... - arguments for lpszFormat
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"SendCommand",
|
||
"%#x, %q",
|
||
Socket,
|
||
lpszFormat
|
||
));
|
||
|
||
va_list arglist;
|
||
DWORD error;
|
||
|
||
va_start(arglist, lpszFormat);
|
||
|
||
error = I_SendCommand(Socket,
|
||
lpszFormat,
|
||
arglist
|
||
);
|
||
|
||
va_end(arglist);
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_SendCommand(
|
||
IN ICSocket * Socket,
|
||
IN LPCSTR lpszFormat,
|
||
va_list arglist
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sends a command string to a server
|
||
|
||
Arguments:
|
||
|
||
Socket - socket to send command on
|
||
|
||
lpszFormat - printf-style format string for command
|
||
|
||
arglist - variable list of arguments for format string
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
error returned from Windows Sockets
|
||
|
||
ERROR_INTERNET_INTERNAL_ERROR
|
||
The string was too large to fit into our stack buffer
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"I_SendCommand",
|
||
"%#x, %q, %#x",
|
||
Socket,
|
||
lpszFormat,
|
||
arglist
|
||
));
|
||
|
||
#define I_SEND_COMMAND_BUFFER_LENGTH 2048 // Arbitrary (but large)
|
||
|
||
//
|
||
// get per-thread info block to determine blocking/non-blocking socket calls
|
||
//
|
||
|
||
LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
|
||
DWORD error;
|
||
|
||
if (lpThreadInfo == NULL) {
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// we need a buffer large enough to be able to handle the longest path plus
|
||
// the command overhead. Typically, we will only be getting short strings
|
||
// (USER, PORT, etc.)
|
||
//
|
||
|
||
//
|
||
// BUGBUG
|
||
// use _vsnprintf() to create the buffer - this allows us to specify the
|
||
// maximum offset in the buffer, so avoiding a stack crash but this
|
||
// brings in the cruntimes which we don't want to do.
|
||
//
|
||
|
||
CHAR buf[I_SEND_COMMAND_BUFFER_LENGTH];
|
||
|
||
{
|
||
int numChars = wvnsprintf(buf, I_SEND_COMMAND_BUFFER_LENGTH, lpszFormat, arglist);
|
||
|
||
INET_ASSERT(numChars <= I_SEND_COMMAND_BUFFER_LENGTH - 2);
|
||
INET_ASSERT(numChars > 0);
|
||
|
||
if (numChars <= I_SEND_COMMAND_BUFFER_LENGTH - 2) {
|
||
|
||
//
|
||
// append trailing "\r\n"
|
||
//
|
||
|
||
buf[numChars++] = '\r';
|
||
buf[numChars++] = '\n';
|
||
|
||
error = Socket->Send((LPVOID)buf, numChars, SF_INDICATE);
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("%d chars blows internal buffer limit (%d chars)\n",
|
||
numChars,
|
||
I_SEND_COMMAND_BUFFER_LENGTH
|
||
));
|
||
|
||
error = ERROR_INVALID_PARAMETER;
|
||
}
|
||
}
|
||
|
||
quit:
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_AttemptDataNegotiation(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN va_list arglist
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Attempts to generate a data connection with server. If passive mode is
|
||
selected & passive mode fails, then we back-down to non-passive
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO describing server to
|
||
connect to
|
||
|
||
dwFlags - controlling how to transfer data between the client
|
||
and server data connection, and how to set up data
|
||
connection
|
||
|
||
prcResponse - pointer to response code variable
|
||
|
||
lpszCommandFormat - command to send
|
||
|
||
arglist - any arguments for command
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - same as I_NegotiateDataConnection
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"I_AttemptDataNegotiation",
|
||
"%#x, %#x, %#x, %q, %#x",
|
||
lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist
|
||
));
|
||
|
||
//
|
||
// first try it without overriding passive mode
|
||
//
|
||
|
||
DWORD error = I_NegotiateDataConnection(lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist,
|
||
FALSE
|
||
);
|
||
|
||
//
|
||
// if the negotiation failed because passive mode wasn't supported or not
|
||
// allowed then try non-passive (if ok to do so)
|
||
//
|
||
|
||
if (error == ERROR_FTP_NO_PASSIVE_MODE) {
|
||
|
||
INET_ASSERT(IsPassiveModeSession(lpSessionInfo));
|
||
|
||
error = I_NegotiateDataConnection(lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist,
|
||
TRUE // no passive mode this time
|
||
);
|
||
}
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
DWORD
|
||
I_NegotiateDataConnection(
|
||
IN LPFTP_SESSION_INFO lpSessionInfo,
|
||
IN DWORD dwFlags,
|
||
IN OUT FTP_RESPONSE_CODE *prcResponse,
|
||
IN LPCSTR lpszCommandFormat,
|
||
IN va_list arglist,
|
||
IN BOOL bOverridePassive
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Sends a command to the FTP server and opens a data channel
|
||
|
||
Arguments:
|
||
|
||
lpSessionInfo - pointer to FTP_SESSION_INFO describing server to
|
||
connect to
|
||
|
||
dwFlags - controlling how to transfer data between the client
|
||
and server data connection, and how to set up data
|
||
connection
|
||
|
||
prcResponse - pointer to response code variable
|
||
|
||
lpszCommandFormat - command to send
|
||
|
||
arglist - any arguments for command
|
||
|
||
bOverridePassive - TRUE if OK to override passive mode (set at connect
|
||
level)
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - WSA error
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"I_NegotiateDataConnection",
|
||
"%#x, %#x, %#x, %q, %#x, %B",
|
||
lpSessionInfo,
|
||
dwFlags,
|
||
prcResponse,
|
||
lpszCommandFormat,
|
||
arglist,
|
||
bOverridePassive
|
||
));
|
||
|
||
PUCHAR puchAddr;
|
||
PCHAR pch;
|
||
|
||
ICSocket * socketControl;
|
||
ICSocket * socketData ;
|
||
ICSocket * socketListener ;
|
||
DWORD error;
|
||
int serr;
|
||
LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
|
||
BOOL isAsync;
|
||
BOOL bPassiveMode = FALSE;
|
||
|
||
if (lpThreadInfo == NULL) {
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
goto quit;
|
||
}
|
||
|
||
isAsync = lpThreadInfo->IsAsyncWorkerThread;
|
||
|
||
//Command(lpSessionInfo,
|
||
// FALSE,
|
||
// FTP_TRANSFER_TYPE_UNKNOWN,
|
||
// prcResponse,
|
||
// "MODE B"
|
||
//// "MODE S"
|
||
// );
|
||
|
||
//
|
||
// tell the server the type of transfer we want - ASCII ('A') or Binary ('I')
|
||
//
|
||
|
||
error = Command(lpSessionInfo,
|
||
FALSE,
|
||
FTP_TRANSFER_TYPE_UNKNOWN,
|
||
prcResponse,
|
||
"TYPE %s",
|
||
((dwFlags & FTP_TRANSFER_TYPE_MASK)
|
||
== FTP_TRANSFER_TYPE_ASCII) ? "A" : "I"
|
||
);
|
||
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
if (prcResponse->Major != FTP_RESPONSE_COMPLETE) {
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
goto quit;
|
||
}
|
||
|
||
socketControl = lpSessionInfo->socketControl;
|
||
socketData = lpSessionInfo->socketData;
|
||
socketListener = lpSessionInfo->socketListener;
|
||
|
||
INET_ASSERT(!socketData->IsValid());
|
||
INET_ASSERT(!socketListener->IsValid());
|
||
|
||
//
|
||
// Get the address of our control socket. We need to know what address
|
||
// family (IPv4 or IPv6) to use for our data connection. And in the
|
||
// active case, we need to provide this address to the server.
|
||
//
|
||
|
||
SOCKADDR_STORAGE ourCtrlAddr;
|
||
error = socketControl->GetSockName((LPSOCKADDR)&ourCtrlAddr,
|
||
sizeof(ourCtrlAddr));
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// we make passive connection if passive mode was specified in
|
||
// InternetConnect() AND we are not overriding it
|
||
//
|
||
|
||
bPassiveMode = IsPassiveModeSession(lpSessionInfo) && !bOverridePassive;
|
||
|
||
//
|
||
// make the required type of data connection
|
||
//
|
||
|
||
if (!bPassiveMode) {
|
||
|
||
SOCKADDR_STORAGE ourDataAddr;
|
||
int cbAddrLen;
|
||
|
||
//
|
||
// standard (non-passive (ACTIVE?)) transfers. We create a socket and
|
||
// tell the server which socket to connect to. The server then initiates
|
||
// the connection with this client
|
||
//
|
||
|
||
error = socketListener->CreateSocket(0, ourCtrlAddr.ss_family,
|
||
SOCK_STREAM, IPPROTO_TCP);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
#if INET_DEBUG
|
||
socketListener->SetSourcePort();
|
||
#endif
|
||
|
||
error = socketListener->Listen();
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// Now tell the server what address and port number it should use to
|
||
// connect to us. The address is the local side of our control
|
||
// connection, and the port number is that of the listening socket.
|
||
//
|
||
|
||
error = socketListener->GetSockName((LPSOCKADDR)&ourDataAddr,
|
||
sizeof(ourDataAddr));
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// BUGBUG - using (global) winsock ntohs() (i.e. not SOCKS)
|
||
//
|
||
|
||
u_short port;
|
||
|
||
if (ourCtrlAddr.ss_family == AF_INET) {
|
||
//
|
||
// Legacy IPv4. The PORT command consists of our IP address
|
||
// formatted as 4 decimal numbers (one per byte) followed by
|
||
// the port number as 2 decimals numbers (one per byte).
|
||
// Byte order is big-endian.
|
||
//
|
||
// REVIEW: RFC 2428 describes the EPRT command, which is
|
||
// intended to replace the PORT command. Should we try it
|
||
// first? At the moment, we only attempt EPRT over IPv6.
|
||
//
|
||
port = _I_ntohs(((LPSOCKADDR_IN)&ourDataAddr)->sin_port);
|
||
puchAddr = (PUCHAR)&((LPSOCKADDR_IN)&ourCtrlAddr)->sin_addr;
|
||
error = SendCommand(socketControl,
|
||
"PORT %d,%d,%d,%d,%d,%d",
|
||
puchAddr[0],
|
||
puchAddr[1],
|
||
puchAddr[2],
|
||
puchAddr[3],
|
||
HIBYTE(port),
|
||
LOBYTE(port)
|
||
);
|
||
} else {
|
||
//
|
||
// IPv6. The EPRT command is defined in RFC 2428, and has the
|
||
// following format:
|
||
// EPRT<space><d><address-family><d><address><d><port><d>
|
||
// where <d> is a delimiter character ('|' recommended),
|
||
// <address-family> is an IANA defined number (1=IPv4, 2=IPv6),
|
||
// <address> is the IP address in common string notation,
|
||
// <port> is the port number in common string notation.
|
||
//
|
||
#define MAX_IPV6_ADDR_LIT_LEN (sizeof("1111:2222:3333:4444:5555:6666:255.255.255.255%4294967295"))
|
||
char Address[MAX_IPV6_ADDR_LIT_LEN];
|
||
error = _I_getnameinfo((LPSOCKADDR)&ourCtrlAddr,
|
||
sizeof(SOCKADDR_IN6), Address,
|
||
sizeof(Address), NULL, 0, NI_NUMERICHOST);
|
||
if (error) {
|
||
goto error_exit;
|
||
}
|
||
port = _I_ntohs(((LPSOCKADDR_IN6)&ourDataAddr)->sin6_port);
|
||
error = SendCommand(socketControl, "EPRT |2|%s|%u", Address, port);
|
||
}
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// read the response from the server. We are expecting something along
|
||
// the lines: "200 PORT Command Successful"
|
||
//
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
if (prcResponse->Major != FTP_RESPONSE_COMPLETE) {
|
||
|
||
//
|
||
// Some IPv6 servers use LPRT instead of EPRT. So we try that.
|
||
// REVIEW: If we change the IPv4 case above to try EPRT first
|
||
// (see REVIEW comment above) then we'd try PORT here for IPv4.
|
||
//
|
||
|
||
if ((ourCtrlAddr.ss_family == AF_INET6) &&
|
||
(prcResponse->Status == FTP_RESPONSE_CMD_NOT_IMPL) ||
|
||
(prcResponse->Status == FTP_RESPONSE_CMD_SYNTAX_ERROR)) {
|
||
|
||
error = SendCommand(socketControl,
|
||
"LPRT 6,16,%u,%u,%u,%u,"
|
||
"%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,"
|
||
"2,%u,%u",
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[0],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[1],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[2],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[3],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[4],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[5],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[6],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[7],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[8],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[9],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[10],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[11],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[12],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[13],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[14],
|
||
((LPSOCKADDR_IN6)(&ourCtrlAddr))->sin6_addr.s6_addr[15],
|
||
HIBYTE(port), LOBYTE(port)
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
if (prcResponse->Major == FTP_RESPONSE_COMPLETE)
|
||
goto GotActiveReply;
|
||
}
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
goto error_exit;
|
||
}
|
||
} else {
|
||
|
||
PCHAR pchTemp;
|
||
|
||
//
|
||
// PASSIVE mode. Due to problems with firewalls not allowing incoming
|
||
// connection requests, we have to ask the server to create a new socket
|
||
// which we then connect to. This is the inverse of the non-PASV connect
|
||
// case above
|
||
//
|
||
|
||
error = socketData->CreateSocket(0, ourCtrlAddr.ss_family,
|
||
SOCK_STREAM, IPPROTO_TCP);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// send the PASV request to the server
|
||
//
|
||
|
||
if (ourCtrlAddr.ss_family == AF_INET) {
|
||
// REVIEW: Attempt EPSV first for IPv4 as well?
|
||
error = SendCommand(socketControl, "PASV");
|
||
} else {
|
||
error = SendCommand(socketControl, "EPSV");
|
||
}
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// Read the response. For the "PASV" command, we are expecting it
|
||
// to return the full address information for the port in the form
|
||
// "227 (h1,h2,h3,h4,p1,p2)"
|
||
// meaning that the server is entering PASSIVE mode (227), and the
|
||
// IP address and socket to connect to being h1.h2.h3.h4, p1p2.
|
||
//
|
||
// For the "EPSV" command, we are expecting a response of the form
|
||
// "229 (<d><d><d><port><d>)"
|
||
// meaning that the server is entering PASSIVE mode (229), the
|
||
// IP address to connect to is that of the control connection, and
|
||
// the port number to connect to is given by <port>.
|
||
//
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
if (prcResponse->Major != FTP_RESPONSE_COMPLETE) {
|
||
|
||
//
|
||
// Some IPv6 servers use LPSV instead of EPSV.
|
||
// The wonderful thing about standards is that
|
||
// there are so many to choose from.
|
||
//
|
||
if ((ourCtrlAddr.ss_family == AF_INET6) &&
|
||
((prcResponse->Status == FTP_RESPONSE_CMD_NOT_IMPL) ||
|
||
(prcResponse->Status == FTP_RESPONSE_CMD_SYNTAX_ERROR))) {
|
||
|
||
error = SendCommand(socketControl, "LPSV");
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
if (prcResponse->Major == FTP_RESPONSE_COMPLETE)
|
||
goto GotPassiveReply;
|
||
}
|
||
|
||
//
|
||
// If we get 500 or 502 (command not implemented), 425
|
||
// (can't open data connection), or 530 (not logged in)
|
||
// then return ERROR_FTP_NO_PASSIVE_MODE, else
|
||
// ERROR_INTERNET_EXTENDED_ERROR.
|
||
//
|
||
|
||
if ((prcResponse->Status == FTP_RESPONSE_CANT_OPEN_DATA)
|
||
|| (prcResponse->Status == FTP_RESPONSE_CMD_NOT_IMPL)
|
||
|| (prcResponse->Status == FTP_RESPONSE_CMD_SYNTAX_ERROR)
|
||
|| (prcResponse->Status == FTP_RESPONSE_NOT_LOGGED_IN)) {
|
||
error = ERROR_FTP_NO_PASSIVE_MODE;
|
||
} else {
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
goto error_exit;
|
||
}
|
||
|
||
GotPassiveReply:
|
||
|
||
//
|
||
// parse the endpoint out of the server response (stored in the per-
|
||
// thread last response info buffer).
|
||
//
|
||
// If we fail to lock the response text, then that's an internal error.
|
||
// If we fail to parse the required information out of the response text
|
||
// then we return an extended error indication, since presumably the
|
||
// server sent response text, but not what we were expecting
|
||
//
|
||
|
||
pch = (PCHAR)InternetLockErrorText();
|
||
if (pch != NULL) {
|
||
if (ourCtrlAddr.ss_family == AF_INET) {
|
||
//
|
||
// Parse respone to PASV command.
|
||
//
|
||
pch = strstr(pch, "227 ");
|
||
if (pch != NULL) {
|
||
pch += sizeof("227 ") - 1;
|
||
while (!isdigit(*pch) && *pch) {
|
||
++pch;
|
||
}
|
||
if (isdigit(*pch)) {
|
||
|
||
int i;
|
||
DWORD octets[6];
|
||
|
||
//
|
||
// parse the individual address parts out of the response
|
||
//
|
||
|
||
for (i = 0; (i < ARRAY_ELEMENTS(octets)) && isdigit(*pch); ++i) {
|
||
if (!ExtractInt(&pch, 0, (LPINT)&octets[i])) {
|
||
break;
|
||
}
|
||
if (octets[i] > 255) {
|
||
break;
|
||
}
|
||
if (i < ARRAY_ELEMENTS(octets) - 1) {
|
||
while (!isdigit(*pch) && *pch) {
|
||
++pch;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// if we successfully parsed the server's address info then
|
||
// try to connect with the address it sent us
|
||
//
|
||
|
||
if ((i == ARRAY_ELEMENTS(octets)) && (octets[i - 1] <= 255)) {
|
||
|
||
SOCKADDR_IN remoteSockaddr;
|
||
|
||
memset(&remoteSockaddr, 0, sizeof(remoteSockaddr));
|
||
remoteSockaddr.sin_family = AF_INET;
|
||
|
||
//
|
||
// N.B. Using (global) winsock ntohs() (i.e. not SOCKS)
|
||
//
|
||
|
||
remoteSockaddr.sin_port = _I_htons(
|
||
(USHORT)((octets[4] << 8)
|
||
| (USHORT)octets[5]));
|
||
puchAddr = (PUCHAR)&remoteSockaddr.sin_addr;
|
||
puchAddr[0] = (UCHAR)octets[0];
|
||
puchAddr[1] = (UCHAR)octets[1];
|
||
puchAddr[2] = (UCHAR)octets[2];
|
||
puchAddr[3] = (UCHAR)octets[3];
|
||
error = socketData->DirectConnect(
|
||
(LPSOCKADDR)&remoteSockaddr);
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to parse 6 address elements\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to locate start of address info in response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to locate \"227\" in response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
CHAR delim;
|
||
//
|
||
// Parse respone to EPSV or LPSV command.
|
||
//
|
||
pchTemp = strstr(pch, "229 ");
|
||
if (pchTemp != NULL) {
|
||
pch = pchTemp + sizeof("229 ") - 1;
|
||
while ((*pch != '(') && (*pch != '\0')) {
|
||
++pch;
|
||
}
|
||
if ((pch[0] == '(') &&
|
||
((delim = pch[1]) != '\0') &&
|
||
(pch[2] == delim) &&
|
||
(pch[3] == delim)) {
|
||
|
||
DWORD port;
|
||
|
||
//
|
||
// parse the port out of the response
|
||
//
|
||
pch += 4;
|
||
if (ExtractInt(&pch, 0, (LPINT)&port)) {
|
||
|
||
//
|
||
// if we successfully parsed the port then
|
||
// try to connect with it
|
||
//
|
||
|
||
SOCKADDR_IN6 remoteSockaddr;
|
||
|
||
error = socketControl->GetPeerName(
|
||
(LPSOCKADDR)&remoteSockaddr,
|
||
sizeof(SOCKADDR_IN6));
|
||
|
||
if (error == ERROR_SUCCESS) {
|
||
//
|
||
// N.B. Using (global) winsock ntohs()
|
||
// (i.e. not SOCKS)
|
||
//
|
||
remoteSockaddr.sin6_port =
|
||
_I_htons((USHORT)port);
|
||
error = socketData->DirectConnect(
|
||
(LPSOCKADDR)&remoteSockaddr);
|
||
}
|
||
} else {
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to parse port\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to locate start of address info in response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else if ((pchTemp = strstr(pch, "228 ")) != NULL) {
|
||
pch = pchTemp + sizeof("228 ") - 1;
|
||
while (!isdigit(*pch) && *pch) {
|
||
++pch;
|
||
}
|
||
if (isdigit(*pch)) {
|
||
|
||
int i;
|
||
DWORD octets[21];
|
||
|
||
//
|
||
// Parse the individual address parts out of
|
||
// the response.
|
||
//
|
||
|
||
for (i = 0; (i < ARRAY_ELEMENTS(octets)) && isdigit(*pch); ++i) {
|
||
if (!ExtractInt(&pch, 0, (LPINT)&octets[i])) {
|
||
break;
|
||
}
|
||
if (octets[i] > 255) {
|
||
break;
|
||
}
|
||
if (i < ARRAY_ELEMENTS(octets) - 1) {
|
||
while (!isdigit(*pch) && *pch) {
|
||
++pch;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// If we successfully parsed the server's address info
|
||
// then try to connect with the address it sent us.
|
||
//
|
||
|
||
if ((i == ARRAY_ELEMENTS(octets)) &&
|
||
(octets[i - 1] <= 255) &&
|
||
(octets[0] == 6) &&
|
||
(octets[1] == 16) &&
|
||
(octets[18] == 2)) {
|
||
|
||
SOCKADDR_IN6 remoteSockaddr;
|
||
|
||
memset(&remoteSockaddr, 0, sizeof remoteSockaddr);
|
||
remoteSockaddr.sin6_family = AF_INET6;
|
||
|
||
//
|
||
// N.B. Using (global) winsock ntohs()
|
||
// (i.e. not SOCKS)
|
||
//
|
||
|
||
remoteSockaddr.sin6_port = _I_htons(
|
||
(USHORT)((octets[19] << 8)
|
||
| (USHORT)octets[20]));
|
||
for (i = 0; i < 16; i++)
|
||
remoteSockaddr.sin6_addr.s6_addr[i] = (UCHAR)octets[i + 2];
|
||
|
||
error = socketData->DirectConnect(
|
||
(LPSOCKADDR)&remoteSockaddr);
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to parse 20 address elements\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to locate start of address info in response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to locate \"229\" or \"228\" in response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
}
|
||
}
|
||
|
||
//
|
||
// unlock the response text
|
||
//
|
||
|
||
//InternetUnlockErrorText();
|
||
} else {
|
||
|
||
DEBUG_PRINT(PROTOCOL,
|
||
ERROR,
|
||
("failed to lock last response text\n"
|
||
));
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
}
|
||
|
||
//
|
||
// bail out if we met with any errors
|
||
//
|
||
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
}
|
||
|
||
GotActiveReply:
|
||
|
||
//
|
||
// issue SIZE command to get file size
|
||
//
|
||
if(StrCmpNI(lpszCommandFormat, "RETR", 4) == 0) { // If we're downloading a file
|
||
error = I_SendCommand(socketControl,
|
||
"SIZE %s",
|
||
arglist
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
if (socketData->IsValid()) {
|
||
ResetSocket(socketData);
|
||
}
|
||
goto error_exit;
|
||
}
|
||
|
||
if (prcResponse->Major == FTP_RESPONSE_COMPLETE) {
|
||
pch = (PCHAR)InternetLockErrorText();
|
||
if (pch != NULL) {
|
||
pch = strstr(pch, "213 ");
|
||
if (pch != NULL) {
|
||
|
||
pch += sizeof("213 ") - 1;
|
||
if ( pch )
|
||
{
|
||
if (*pch && isdigit(*pch)) {
|
||
if (ExtractInt(&pch, 0, (int *) &(lpSessionInfo->dwFileSizeLow))) {
|
||
lpSessionInfo->Flags |= FFTP_KNOWN_FILE_SIZE;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// we have the data connection, send the command
|
||
//
|
||
|
||
error = I_SendCommand(socketControl,
|
||
lpszCommandFormat,
|
||
arglist
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// get the preliminary reply from the FTP server
|
||
//
|
||
|
||
error = GetReply(lpSessionInfo, prcResponse);
|
||
if (error != ERROR_SUCCESS) {
|
||
if (socketData->IsValid()) {
|
||
ResetSocket(socketData);
|
||
}
|
||
goto error_exit;
|
||
}
|
||
|
||
if ((prcResponse->Major != FTP_RESPONSE_PRELIMINARY)
|
||
&& (prcResponse->Major != FTP_RESPONSE_COMPLETE)) {
|
||
if (socketData->IsValid()) {
|
||
ResetSocket(socketData);
|
||
}
|
||
error = ERROR_INTERNET_EXTENDED_ERROR;
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// Parse out file size if its around
|
||
// Assumes the substring containing the file size looks like; "(99999 bytes)"
|
||
//
|
||
if(!(lpSessionInfo->Flags & FFTP_KNOWN_FILE_SIZE)) { // Don't already have the size
|
||
pch = (PCHAR)InternetLockErrorText();
|
||
if (pch != NULL) {
|
||
pch = strstr(pch, "150 ");
|
||
if (pch != NULL) {
|
||
|
||
pch += sizeof("150 ") - 1;
|
||
PCHAR pchEnd = strstr(pch, " bytes)");
|
||
if (pchEnd) {
|
||
DWORD dwFileSize = 0;
|
||
DWORD dwMul = 1;
|
||
PCHAR pchBeg = pch;
|
||
pch = pchEnd - 1;
|
||
while (pch && (pch > pchBeg) && isdigit(*pch)) {
|
||
dwFileSize += ((*pch - '0') * dwMul);
|
||
dwMul *= 10;
|
||
pch--;
|
||
}
|
||
|
||
if (pch && (*pch == '(') && (dwFileSize > 0)) {
|
||
lpSessionInfo->dwFileSizeLow = dwFileSize;
|
||
lpSessionInfo->Flags |= FFTP_KNOWN_FILE_SIZE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// unlock the response text
|
||
//
|
||
|
||
//InternetUnlockErrorText();
|
||
|
||
//
|
||
// if we are expecting the server to create the connection (ACTIVE mode)
|
||
// then perform an accept() on our listening socket in order to establish
|
||
// the connection
|
||
//
|
||
|
||
if (!bPassiveMode) {
|
||
|
||
//
|
||
// if we just accept(), we may hang forever if the server doesn't call
|
||
// back (servers are all alike), so we use select() to wait for the
|
||
// socket to be acceptable before calling accept() proper
|
||
//
|
||
|
||
error = socketListener->SelectAccept(
|
||
*socketData,
|
||
|
||
//
|
||
// BUGBUG - call GetTimeoutValue()
|
||
//
|
||
|
||
GlobalFtpAcceptTimeout
|
||
);
|
||
|
||
if ( error != ERROR_SUCCESS ) {
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// we no longer require the socket we created for listening for the
|
||
// incoming server connection request
|
||
//
|
||
|
||
INET_ASSERT(socketListener != socketControl);
|
||
INET_ASSERT(socketListener != socketData);
|
||
INET_ASSERT(socketListener->GetSocket() != socketControl->GetSocket());
|
||
INET_ASSERT(socketListener->GetSocket() != socketData->GetSocket());
|
||
|
||
#if INET_DEBUG
|
||
socketData->SetSourcePort();
|
||
#endif
|
||
|
||
socketListener->Close();
|
||
if (!socketData->IsValid()) {
|
||
goto error_exit;
|
||
}
|
||
}
|
||
|
||
//
|
||
// set send and receive timeouts for data socket. If we get an error, ignore
|
||
// it. Note this probably means that the socket is (somehow) invalid, and
|
||
// that we should really return an error. But for now (as with the other
|
||
// protocols), I will presume that the error is non-fatal (but note it)
|
||
//
|
||
|
||
socketData->SetTimeout(
|
||
SEND_TIMEOUT,
|
||
(int)GetTimeoutValue(INTERNET_OPTION_DATA_SEND_TIMEOUT)
|
||
);
|
||
socketData->SetTimeout(
|
||
RECEIVE_TIMEOUT,
|
||
(int)GetTimeoutValue(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT)
|
||
);
|
||
|
||
INET_ASSERT(error == ERROR_SUCCESS);
|
||
|
||
INET_ASSERT(lpSessionInfo->socketData == socketData);
|
||
|
||
quit:
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
|
||
|
||
error_exit:
|
||
|
||
if (socketData->IsValid()) {
|
||
socketData->Close();
|
||
}
|
||
if (socketListener->IsValid()) {
|
||
socketListener->Close();
|
||
}
|
||
goto quit;
|
||
}
|