1621 lines
38 KiB
C++
1621 lines
38 KiB
C++
//
|
|
// Copyright (C) 2001 Microsoft Corp
|
|
//
|
|
// FtpControl.cpp : Implementation
|
|
//
|
|
// JPDup
|
|
// Sanjiv
|
|
//
|
|
#include "precomp.h"
|
|
|
|
#include "MyAlg.h"
|
|
|
|
|
|
//
|
|
// Default constructor
|
|
//
|
|
CFtpControlConnection::CFtpControlConnection()
|
|
{
|
|
MYTRACE_ENTER_NOSHOWEXIT("CFtpControlConnection::CFtpControlConnection()");
|
|
m_ClientConnectedSocket = INVALID_SOCKET;
|
|
m_AlgConnectedSocket = INVALID_SOCKET;
|
|
m_ControlState.m_nAddressNew = 0;
|
|
m_ControlState.m_nPortNew = 0;
|
|
m_nSourcePortReplacement = 0;
|
|
m_RefCount = 0;
|
|
m_pPendingProxy = NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
CFtpControlConnection::~CFtpControlConnection()
|
|
{
|
|
MYTRACE_ENTER_NOSHOWEXIT("CFtpControlConnection::~CFtpControlConnection()");
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Find a unique source port for the public client address given
|
|
//
|
|
USHORT
|
|
PickNewSourcePort(
|
|
ULONG nPublicSourceAddress,
|
|
USHORT nPublicSourcePort
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::PickNewSourcePort()");
|
|
|
|
USHORT nNewSourcePort = 45000-nPublicSourcePort; // example 45000 - 3000
|
|
|
|
bool bPortAvailable;
|
|
|
|
do
|
|
{
|
|
nNewSourcePort--;
|
|
bPortAvailable = g_ControlObjectList.IsSourcePortAvailable(nPublicSourceAddress, nNewSourcePort);
|
|
MYTRACE("Port %d is %s", nNewSourcePort, bPortAvailable ? "Available" : "Inuse" );
|
|
|
|
} while ( (false == bPortAvailable) && (nNewSourcePort > 6001) );
|
|
|
|
return nNewSourcePort;
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize
|
|
//
|
|
HRESULT
|
|
CFtpControlConnection::Init(
|
|
SOCKET AcceptedSocket,
|
|
ULONG nToAddr,
|
|
USHORT nToPort,
|
|
CONNECTION_TYPE ConnType
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::Init");
|
|
|
|
|
|
//
|
|
// Figure what address to use
|
|
//
|
|
ULONG BestAddress;
|
|
|
|
HRESULT hr = g_pIAlgServicesAlgFTP->GetBestSourceAddressForDestinationAddress(
|
|
nToAddr,
|
|
TRUE,
|
|
&BestAddress
|
|
);
|
|
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
MYTRACE_ERROR("Could not get best source address", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
ULONG Err = 0;
|
|
|
|
m_ClientConnectedSocket = AcceptedSocket;
|
|
m_ConnectionType = ConnType;
|
|
|
|
IncReference();
|
|
|
|
m_AlgConnectedSocket = INVALID_SOCKET;
|
|
|
|
|
|
|
|
|
|
Err = MyHelperCreateStreamSocket(BestAddress,0,&m_AlgConnectedSocket);
|
|
|
|
|
|
if ( Err == 0 )
|
|
{
|
|
if ( m_ConnectionType == OUTGOING )
|
|
{
|
|
MYTRACE("OUTGOING FTP");
|
|
|
|
ULONG icsAddr;
|
|
USHORT icsPort;
|
|
|
|
Err = MyHelperQueryLocalEndpointSocket(m_AlgConnectedSocket,&icsAddr,&icsPort);
|
|
MYTRACE("AlgConnectedSocket Local %s:%d",MYTRACE_IP(icsAddr), ntohs(icsPort) );
|
|
|
|
if ( Err == 0 )
|
|
{
|
|
hr = g_pIAlgServicesAlgFTP->PrepareProxyConnection(
|
|
eALG_TCP,
|
|
icsAddr,
|
|
icsPort,
|
|
nToAddr,
|
|
nToPort,
|
|
FALSE,
|
|
&m_pPendingProxy
|
|
);
|
|
}
|
|
}
|
|
else if (m_ConnectionType == INCOMING)
|
|
{
|
|
MYTRACE("INCOMING FTP");
|
|
|
|
ULONG icsAddr,pubAddr;
|
|
USHORT icsPort,pubPort;
|
|
|
|
Err = MyHelperQueryLocalEndpointSocket(m_AlgConnectedSocket,&icsAddr,&icsPort);
|
|
MYTRACE("AlgConnectedSocket Local %s:%d",MYTRACE_IP(icsAddr), ntohs(icsPort) );
|
|
|
|
if (Err == 0)
|
|
{
|
|
Err = MyHelperQueryRemoteEndpointSocket(m_ClientConnectedSocket,&pubAddr,&pubPort);
|
|
|
|
if ( Err == 0 )
|
|
{
|
|
if ( icsAddr == nToAddr )
|
|
{
|
|
//
|
|
// Special case it the FTP server is hosted on the EDGE box
|
|
// we would create a loop the incoming public client address/port
|
|
// this new modified connection would look exacly like
|
|
// the original one example:
|
|
//
|
|
// 1.1.1.2:3000 connects to 1.1.1.1:21
|
|
// we accept this connection
|
|
// and in return we connect to the FTP server destination 1.1.1.1:21
|
|
// asking the NAT to source mofify and replace the source with 1.1.1.2:3000
|
|
// that does not work
|
|
// in order to go arround this we pick another source port example 45000
|
|
//
|
|
|
|
// Cache this info in order to pick a unique one next time
|
|
m_nSourcePortReplacement = PickNewSourcePort(pubAddr, pubPort);
|
|
|
|
pubPort = m_nSourcePortReplacement; // This is the new bogus port to use now
|
|
}
|
|
|
|
hr = g_pIAlgServicesAlgFTP->PrepareSourceModifiedProxyConnection(
|
|
eALG_TCP,
|
|
icsAddr,
|
|
icsPort,
|
|
nToAddr,
|
|
nToPort,
|
|
pubAddr,
|
|
pubPort,
|
|
&m_pPendingProxy
|
|
);
|
|
if ( FAILED(hr) )
|
|
{
|
|
MYTRACE_ERROR("PrepareSourceModifiedProxyConnection",hr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("MyHelperQueryRemoteEndpointSocket",Err);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("LocalEndpointSocket", Err);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("MyHelperCreateStreamSocket",Err);
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) && Err == 0 )
|
|
{
|
|
|
|
Err = MyHelperConnectStreamSocket(
|
|
NULL,
|
|
m_AlgConnectedSocket,
|
|
nToAddr,
|
|
nToPort,
|
|
NULL,
|
|
MyConnectCompletion,
|
|
(void *)this,
|
|
NULL
|
|
);
|
|
|
|
if ( Err != 0 )
|
|
{
|
|
MYTRACE_ERROR("From MyHelperConnectStreamSocket", Err);
|
|
|
|
m_pPendingProxy->Cancel();
|
|
}
|
|
}
|
|
|
|
if ( FAILED(hr) || Err )
|
|
{
|
|
MYTRACE_ERROR("We can't init this Connection", hr);
|
|
|
|
ULONG ref;
|
|
ref = DecReference();
|
|
_ASSERT(ref == 0);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
hr = HRESULT_FROM_WIN32(Err);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
#define MAKE_ADDRESS(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
|
|
#define MAKE_PORT(a,b) ((a) | ((b) << 8))
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
ULONG
|
|
GetNumFromString(UCHAR *String,ULONG *pNum)
|
|
{
|
|
ULONG retval = 0;
|
|
int i = 0;
|
|
while (String[i] != ',')
|
|
{
|
|
retval = retval*10 + (String[i]-'0');
|
|
i++;
|
|
}
|
|
*pNum = i;
|
|
return retval;
|
|
}
|
|
|
|
|
|
//
|
|
// Needs to return in Network address order
|
|
//
|
|
USHORT
|
|
GetUSHORTFromString(UCHAR *String,ULONG *pNum)
|
|
{
|
|
MYTRACE_ENTER("GetUSHORTFromString");
|
|
|
|
|
|
|
|
ULONG Num;
|
|
UCHAR Numbers[2];
|
|
*pNum = 0;
|
|
|
|
Numbers[0] = (UCHAR)GetNumFromString(String,&Num);
|
|
*pNum += Num+1;
|
|
|
|
|
|
Numbers[1] = (UCHAR)GetNumFromString(String+*pNum,&Num);
|
|
*pNum += Num;
|
|
|
|
|
|
USHORT retval = (USHORT)MAKE_PORT((USHORT)Numbers[0], (USHORT)Numbers[1]);
|
|
|
|
return retval;
|
|
}
|
|
|
|
//
|
|
// return the String IP Address as 192,168,0,0, in a ULONG in HOST format
|
|
//
|
|
ULONG
|
|
GetULONGFromString(
|
|
UCHAR* String,
|
|
ULONG* pNum
|
|
)
|
|
{
|
|
UCHAR Numbers[4];
|
|
|
|
ULONG retval = 0;
|
|
ULONG Num;
|
|
|
|
*pNum = 0;
|
|
Numbers[0] = (UCHAR)GetNumFromString(String,&Num);
|
|
*pNum += Num+1;
|
|
|
|
Numbers[1] = (UCHAR)GetNumFromString(String+*pNum,&Num);
|
|
*pNum += Num+1;
|
|
|
|
Numbers[2] = (UCHAR)GetNumFromString(String+*pNum,&Num);
|
|
*pNum += Num+1;
|
|
|
|
Numbers[3] = (UCHAR)GetNumFromString(String+*pNum,&Num);
|
|
*pNum += Num;
|
|
|
|
retval = MAKE_ADDRESS(Numbers[0], Numbers[1], Numbers[2], Numbers[3]);
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
CFtpControlConnection::ConnectCompletionRoutine(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::ConnectCompletionRoutine");
|
|
|
|
|
|
|
|
ULONG Err;
|
|
|
|
|
|
if ( ErrCode )
|
|
{
|
|
MYTRACE_ERROR("ConnectCompletionRoutine", ErrCode);
|
|
|
|
if ( m_pPendingProxy )
|
|
{
|
|
MYTRACE("PendingProxy still active CANCEL");
|
|
m_pPendingProxy->Cancel();
|
|
}
|
|
|
|
ULONG ref;
|
|
ref = DecReference();
|
|
_ASSERT(ref == 0);
|
|
|
|
return;
|
|
}
|
|
|
|
Err = MyHelperReadStreamSocket(
|
|
NULL,
|
|
m_ClientConnectedSocket,
|
|
NULL,
|
|
FTP_MAX_MSG_SIZE,
|
|
0,
|
|
MyReadCompletion,
|
|
(void *)this,
|
|
(void *)CLIENT_READ
|
|
);
|
|
|
|
|
|
if ( Err )
|
|
{
|
|
MYTRACE_ERROR("From MyHelperReadStreamSocket CLIENT_READ",Err);
|
|
ULONG ref;
|
|
ref = DecReference();
|
|
_ASSERT(ref == 0);
|
|
|
|
return;
|
|
}
|
|
|
|
IncReference();
|
|
Err = MyHelperReadStreamSocket(
|
|
NULL,
|
|
m_AlgConnectedSocket,
|
|
NULL,
|
|
FTP_MAX_MSG_SIZE,0,
|
|
MyReadCompletion,
|
|
(void *)this,
|
|
(void *)SERVER_READ
|
|
);
|
|
|
|
if ( Err )
|
|
{
|
|
MYTRACE("MyHelperReadStreamSocket SERVER_READ",Err);
|
|
ULONG ref;
|
|
ref = DecReference();
|
|
_ASSERT(ref == 1);
|
|
|
|
if (ref)
|
|
Shutdown();
|
|
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
ULONG
|
|
CFtpControlConnection::IncReference(void)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::IncReference()");
|
|
ULONG nRef = InterlockedIncrement((LPLONG)&m_RefCount);
|
|
|
|
MYTRACE("REFCOUNT for 0x%X is now %d", this, nRef);
|
|
return nRef;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
ULONG
|
|
CFtpControlConnection::DecReference(void)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::DecReference()");
|
|
|
|
ULONG tmp = InterlockedDecrement((LPLONG)&m_RefCount);
|
|
MYTRACE("REFCOUNT for 0x%X is now %d", this, tmp);
|
|
|
|
if ( tmp > 0 )
|
|
return tmp;
|
|
|
|
MYTRACE("HIT ZERO refcount cleanup the CFtpControlConnection");
|
|
|
|
|
|
if ( m_AlgConnectedSocket == INVALID_SOCKET )
|
|
{
|
|
MYTRACE("SOCKET SERVER ALREADY CLOSED!");
|
|
}
|
|
else
|
|
{
|
|
MYTRACE("CLOSING SOCKET ALGCONNECTED!");
|
|
shutdown(m_AlgConnectedSocket, SD_BOTH);
|
|
closesocket(m_AlgConnectedSocket);
|
|
m_AlgConnectedSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
if ( m_ClientConnectedSocket == INVALID_SOCKET )
|
|
{
|
|
MYTRACE("SOCKET CLIENT ALREADY CLOSED!");
|
|
}
|
|
else
|
|
{
|
|
MYTRACE("CLOSING SOCKET CLIENT CONNECTED!");
|
|
shutdown(m_ClientConnectedSocket, SD_BOTH);
|
|
closesocket(m_ClientConnectedSocket);
|
|
m_ClientConnectedSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
if ( m_pPendingProxy )
|
|
{
|
|
//
|
|
// At this point NAT already cancel this redirect, so no need to call cancel
|
|
// m_pPendingProxy->Cancel();
|
|
// this was causing a ERROR on a multi-client scenario
|
|
//
|
|
m_pPendingProxy->Release();
|
|
m_pPendingProxy = NULL;
|
|
}
|
|
|
|
if ( m_ControlState.m_nPortNew )
|
|
{
|
|
MYTRACE("ReleaseReservedPort-A %d", ntohs(m_ControlState.m_nPortNew));
|
|
g_pIAlgServicesAlgFTP->ReleaseReservedPort(m_ControlState.m_nPortNew,1);
|
|
m_ControlState.m_nPortNew = 0;
|
|
}
|
|
|
|
|
|
//
|
|
// CleanUp the collection of DataChannel
|
|
//
|
|
IDataChannel* pData;
|
|
USHORT Port;
|
|
HANDLE CreationHandle,DeletionHandle;
|
|
|
|
MYTRACE("Empty CDataChannelList");
|
|
|
|
while ( m_DataChannelList.Remove(&pData,&Port,&CreationHandle,&DeletionHandle) )
|
|
{
|
|
//
|
|
// Creation and Deletion events are not used for now
|
|
// NhUnRegisterEvent(CreationHandle); // Hopefully nothing bad will happen ! May have been called before
|
|
// NhUnRegisterEvent(DeletionHandle); // if delete has been called it would mean that Remove has been called.
|
|
//
|
|
|
|
pData->Cancel();
|
|
pData->Release();
|
|
MYTRACE("ReleaseReservedPort-B %d", ntohs(Port));
|
|
g_pIAlgServicesAlgFTP->ReleaseReservedPort(Port,1);
|
|
}
|
|
|
|
|
|
if ( g_ControlObjectList.Remove(this) )
|
|
{
|
|
// happens when this was called from within ChannelDeletion or some DecReferece after that.
|
|
}
|
|
else
|
|
{
|
|
// would happen if this was called from shutdown. not otherwise.
|
|
}
|
|
|
|
delete this;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// The last one to call DecReference would take it off control list.
|
|
// The first one to call DecReference because of fatal error would call Shutdown to start off
|
|
// the DecReference for all the connected stuff.
|
|
//
|
|
void
|
|
CFtpControlConnection::Shutdown()
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::Shutdown()");
|
|
|
|
if ( m_AlgConnectedSocket != INVALID_SOCKET )
|
|
{
|
|
MYTRACE("CLOSING SOCKET ALG CONNECTED! %d", m_AlgConnectedSocket);
|
|
shutdown(m_AlgConnectedSocket, SD_BOTH);
|
|
closesocket(m_AlgConnectedSocket);
|
|
m_AlgConnectedSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
|
|
if ( m_ClientConnectedSocket != INVALID_SOCKET )
|
|
{
|
|
MYTRACE("CLOSING SOCKET CLIENT CONNECTED! %d", m_ClientConnectedSocket);
|
|
shutdown(m_ClientConnectedSocket, SD_BOTH);
|
|
closesocket(m_ClientConnectedSocket);
|
|
m_ClientConnectedSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
CFtpControlConnection::ReadCompletionRoutine(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER Bufferp
|
|
)
|
|
{
|
|
MYTRACE_ENTER( "CFtpControlConnection::ReadCompletionRoutine" );
|
|
|
|
if ( ErrCode || BytesTransferred == 0 )
|
|
{
|
|
|
|
if ( ErrCode )
|
|
{
|
|
MYTRACE("Shutdown because of read ERROR 0x%x", ErrCode);
|
|
}
|
|
else
|
|
{
|
|
MYTRACE("Shutdown because of read 0 bytes");
|
|
}
|
|
|
|
MyHelperReleaseBuffer(Bufferp);
|
|
if (DecReference())
|
|
Shutdown();
|
|
|
|
return;
|
|
}
|
|
|
|
ULONG_PTR ReadType = (ULONG_PTR)Bufferp->Context2;
|
|
|
|
ULONG_PTR WriteType;
|
|
|
|
SOCKET ReadSocket;
|
|
SOCKET WriteSocket;
|
|
|
|
ULONG Err;
|
|
|
|
if ( ReadType == CLIENT_READ )
|
|
{
|
|
WriteType = SERVER_READ;
|
|
ReadSocket = m_ClientConnectedSocket;
|
|
WriteSocket = m_AlgConnectedSocket;
|
|
}
|
|
else
|
|
{
|
|
WriteType = CLIENT_READ;
|
|
ReadSocket = m_AlgConnectedSocket;
|
|
WriteSocket = m_ClientConnectedSocket;
|
|
|
|
}
|
|
|
|
#if defined(DBG) || defined(_DEBUG)
|
|
ULONG TraceAddr = 0;
|
|
USHORT TracePort = 0;
|
|
|
|
if ( ReadSocket != INVALID_SOCKET )
|
|
Err = MyHelperQueryRemoteEndpointSocket(ReadSocket ,&TraceAddr,&TracePort);
|
|
|
|
MYTRACE("from %s (%s:%d)",
|
|
ReadType == CLIENT_READ ? "CLIENT":"SERVER",
|
|
MYTRACE_IP(TraceAddr),
|
|
ntohs(TracePort)
|
|
);
|
|
MYTRACE("EC(0x%x) Buffer size(%d)='%s'", ErrCode, BytesTransferred, MYTRACE_BUFFER2STR((char*)Bufferp->Buffer, BytesTransferred));
|
|
#endif
|
|
if ( (ReadType == CLIENT_READ && m_ConnectionType == OUTGOING) || (ReadType == SERVER_READ && m_ConnectionType == INCOMING) )
|
|
{
|
|
// the number of bytes transferred can change.
|
|
// because the ProcessFtpMessage may have to
|
|
// buffer the Address,Port string from PORT or PASV response command.
|
|
ProcessFtpMessage(Bufferp->Buffer,&BytesTransferred);
|
|
|
|
}
|
|
|
|
|
|
if ( BytesTransferred != 0 && WriteSocket != INVALID_SOCKET )
|
|
{
|
|
IncReference();
|
|
|
|
MYTRACE(
|
|
"Write to %s size(%d)='%s'",
|
|
WriteType == SERVER_READ ? "SERVER" : "CLIENT",
|
|
BytesTransferred,
|
|
MYTRACE_BUFFER2STR((char*)Bufferp->Buffer, BytesTransferred)
|
|
);
|
|
|
|
Err = MyHelperWriteStreamSocket(
|
|
NULL,
|
|
WriteSocket,
|
|
Bufferp,BytesTransferred,
|
|
0,
|
|
MyWriteCompletion,
|
|
(void *)this,(PVOID)WriteType
|
|
);
|
|
|
|
if (Err)
|
|
{
|
|
MYTRACE_ERROR("from MyHelperWriteStreamSocket", Err);
|
|
|
|
DecReference();
|
|
if (DecReference())
|
|
Shutdown(); // I am not going to call the Read again so one more DecReference is needed.
|
|
MyHelperReleaseBuffer(Bufferp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( INVALID_SOCKET == ReadSocket )
|
|
{
|
|
if (DecReference())
|
|
Shutdown();
|
|
}
|
|
else
|
|
{
|
|
Err = MyHelperReadStreamSocket(
|
|
NULL,
|
|
ReadSocket,
|
|
NULL,
|
|
FTP_MAX_MSG_SIZE,
|
|
0,
|
|
MyReadCompletion,
|
|
(void *)this,
|
|
(void *)ReadType
|
|
);
|
|
|
|
|
|
if (Err)
|
|
{
|
|
MYTRACE_ERROR("from MyHelperReadStreamSocket",Err);
|
|
|
|
if (DecReference())
|
|
Shutdown();
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
CFtpControlConnection::WriteCompletionRoutine(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER Bufferp
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::WriteCompletionRoutine");
|
|
|
|
if (BytesTransferred == 0)
|
|
ErrCode = ERROR_IO_CANCELLED;
|
|
|
|
if (ErrCode)
|
|
{
|
|
if (MyHelperIsFatalSocketError(ErrCode) || ErrCode == ERROR_IO_CANCELLED)
|
|
{
|
|
MYTRACE_ERROR("FATAL ERROR", ErrCode);
|
|
MyHelperReleaseBuffer(Bufferp);
|
|
|
|
if (DecReference())
|
|
Shutdown();
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("ANOTHER MyHelperWriteStreamSocket", ErrCode);
|
|
|
|
ULONG_PTR Type = (ULONG_PTR)Bufferp->Context2;
|
|
ULONG Err = MyHelperWriteStreamSocket(
|
|
NULL,
|
|
Bufferp->Socket,
|
|
Bufferp,Bufferp->BytesToTransfer,
|
|
0,
|
|
MyWriteCompletion,
|
|
(void *)this,
|
|
(PVOID)Type
|
|
);
|
|
|
|
if (Err)
|
|
{
|
|
MYTRACE_ERROR("From MyHelperWriteStreamSocket", Err);
|
|
|
|
MyHelperReleaseBuffer(Bufferp);
|
|
if (DecReference())
|
|
Shutdown();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ULONG_PTR Type = (ULONG_PTR)Bufferp->Context2;
|
|
|
|
MYTRACE(Type == CLIENT_READ ? "to CLIENT" : "to SERVER" );
|
|
MYTRACE("EC(0x%x) Buffer size(%d)='%s'", ErrCode, BytesTransferred, MYTRACE_BUFFER2STR((char*)Bufferp->Buffer, BytesTransferred));
|
|
MYTRACE("Write Succeeded now cleanup");
|
|
MyHelperReleaseBuffer(Bufferp);
|
|
DecReference();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
FtpExtractOctet(
|
|
UCHAR** Buffer,
|
|
UCHAR* BufferEnd,
|
|
UCHAR* Octet
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to extract an octet from a string.
|
|
|
|
Arguments:
|
|
|
|
Buffer - points to a pointer to a string where conversion starts; on
|
|
return it points to the pointer to the string where conversion ends
|
|
BufferEnd - points to the end of the string
|
|
Octet - points to a caller-suplied storage to store converted octet
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if successfuly converted, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
bool bSuccess;
|
|
ULONG nDigitFound = 0;
|
|
ULONG Value = 0;
|
|
|
|
while (
|
|
*Buffer <= BufferEnd
|
|
&& nDigitFound < 3
|
|
&& **Buffer >= '0'
|
|
&& **Buffer <= '9'
|
|
)
|
|
{
|
|
Value *= 10;
|
|
Value += **Buffer - '0';
|
|
(*Buffer)++;
|
|
nDigitFound++;
|
|
}
|
|
|
|
bSuccess = nDigitFound > 0 && Value < 256;
|
|
|
|
if ( bSuccess )
|
|
{
|
|
*Octet = (UCHAR)Value;
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
//
|
|
// Extract host and port numbers.
|
|
// example 192,168,0,2,100,200
|
|
//
|
|
bool
|
|
ExtractAddressAndPortCommandValue(
|
|
UCHAR* pCommandBuffer,
|
|
UCHAR* pEndOfBuffer,
|
|
UCHAR* Numbers,
|
|
ULONG* nTotalLen
|
|
)
|
|
{
|
|
UCHAR* pStartingPosition = pCommandBuffer;
|
|
|
|
|
|
bool bSuccess = FtpExtractOctet(
|
|
&pCommandBuffer,
|
|
pEndOfBuffer,
|
|
&Numbers[0]
|
|
);
|
|
|
|
int i = 1;
|
|
|
|
while ( i < 6 && bSuccess && *pCommandBuffer == ',' )
|
|
{
|
|
pCommandBuffer++;
|
|
bSuccess = FtpExtractOctet(
|
|
&pCommandBuffer,
|
|
pEndOfBuffer,
|
|
&Numbers[i]
|
|
);
|
|
i++;
|
|
}
|
|
|
|
if ( bSuccess && i == 6 )
|
|
{
|
|
*nTotalLen = (ULONG)(pCommandBuffer - pStartingPosition);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
#define TOUPPER(c) ((c) > 'z' ? (c) : ((c) < 'a' ? (c) : (c) ^ 0x20))
|
|
|
|
//
|
|
// Look for the "PORT" or "227" command and remap the private address associated with these command
|
|
// to a public address
|
|
//
|
|
void
|
|
CFtpControlConnection::ProcessFtpMessage(
|
|
UCHAR* Buffer,
|
|
ULONG* pBytes
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::ProcessFtpMessage");
|
|
MYTRACE("Buffer size(%d)='%s'", *pBytes, MYTRACE_BUFFER2STR((char*)Buffer, *pBytes));
|
|
|
|
ULONG Bytes = *pBytes;
|
|
UCHAR* pCommandBuffer = reinterpret_cast<UCHAR*>(Buffer);
|
|
UCHAR* EndOfBufferp = reinterpret_cast<UCHAR*>(Buffer + *pBytes);
|
|
|
|
HRESULT hr;
|
|
char *String;
|
|
|
|
UCHAR* pBeginAddressAndPortOld=NULL;
|
|
UCHAR* pEndAddressAndPortOld=NULL;
|
|
|
|
|
|
ULONG nOldAddressLen=0;
|
|
|
|
CONST CHAR *pCommandToFind;
|
|
|
|
// for now lets keep the OUTGOING and INCOMING seperate.
|
|
// can be put together since most of the code is the same.
|
|
// differences in the first few bytes to scan for.
|
|
if ( m_ConnectionType == OUTGOING )
|
|
{
|
|
MYTRACE("OUTGOING - Look for 'PORT ' command");
|
|
pCommandToFind = (PCHAR)"PORT ";
|
|
}
|
|
else
|
|
{
|
|
MYTRACE("INCOMING - Look for '227 ' command ");
|
|
pCommandToFind = (PCHAR)"227 ";
|
|
}
|
|
|
|
while ( *pCommandToFind != '\0' && *pCommandToFind == TOUPPER(*pCommandBuffer))
|
|
{
|
|
pCommandToFind++;
|
|
pCommandBuffer++;
|
|
}
|
|
|
|
if ( *pCommandToFind == '\0' )
|
|
{
|
|
MYTRACE("COMMAND found");
|
|
|
|
//
|
|
// Skip non digit char
|
|
//
|
|
if ( m_ConnectionType == OUTGOING )
|
|
{
|
|
//
|
|
// Skip white space. example -> PORT 10,12,13,14,1,2
|
|
//
|
|
while (*pCommandBuffer == ' ')
|
|
pCommandBuffer++;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Skip non digit char example 227 Entering passive mode (10,12,13,14,1,2)
|
|
//
|
|
while ( pCommandBuffer < EndOfBufferp && !isdigit(*pCommandBuffer) )
|
|
pCommandBuffer++;
|
|
}
|
|
|
|
|
|
//
|
|
// so next stuff should be the addr,port combination.
|
|
//
|
|
UCHAR Numbers[6];
|
|
|
|
|
|
|
|
if ( ExtractAddressAndPortCommandValue(pCommandBuffer, EndOfBufferp, Numbers, &nOldAddressLen) )
|
|
{
|
|
pBeginAddressAndPortOld = pCommandBuffer;
|
|
pEndAddressAndPortOld = pCommandBuffer + nOldAddressLen;
|
|
|
|
m_ControlState.m_nAddressOld = MAKE_ADDRESS(Numbers[0], Numbers[1], Numbers[2], Numbers[3]);
|
|
m_ControlState.m_nPortOld = MAKE_PORT(Numbers[4], Numbers[5]);
|
|
|
|
MYTRACE("***** PRIVATE PORT is %d %d", m_ControlState.m_nPortOld, ntohs(m_ControlState.m_nPortOld));
|
|
|
|
if ( ntohs(m_ControlState.m_nPortOld) <= 1025 )
|
|
{
|
|
//
|
|
// For security reason we will disallow any redirection to ports lower then 1025
|
|
// this port range is reserver for standard port Like 139/Netbios
|
|
// if this port range was requested it probably is the source of hacker attacking this FTP proxy
|
|
//
|
|
MYTRACE("***** Port to redirect is lower then 1025 so rejected");
|
|
m_ControlState.m_nAddressNew = htonl(0);
|
|
m_ControlState.m_nPortNew = htons(0);
|
|
m_ControlState.m_nAddressLenNew = 11;
|
|
strcpy((char*)m_ControlState.m_szAddressPortNew, "0,0,0,0,0,0");
|
|
|
|
// pretend that a Redirection got created
|
|
// This way we send out a PORT command with the Public addapter address and a new reserver PORT
|
|
// but when the public hacker comes back it wil not be redirect but simply droped
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Get best public address to use and reserver a port
|
|
// This will be the Address/Port expose on the public side.
|
|
//
|
|
hr = CreateNewAddress();
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
MYTRACE_ERROR("CreateNewAddress failed",hr);
|
|
// We screwed up. cant make redirects now. so for now lets just act
|
|
// as if nothing happened and carry on with the stuff.
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("NOT a valid PORT command syntax", E_INVALIDARG);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Rebuild the string command with the new address port
|
|
//
|
|
if ( pBeginAddressAndPortOld )
|
|
{
|
|
if ( ntohs(m_ControlState.m_nPortOld) <= 1025 )
|
|
{
|
|
// No need to setup a redirection
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = SetupDataRedirect();
|
|
}
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
// we got screwed badly here. we wont set up redirect and act as if nothing happened.
|
|
MYTRACE_ERROR("Could not setup a redirect", hr);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Move trailing buffer
|
|
// Left if new address is smaller then old address
|
|
// Right if new address is bigger then old address
|
|
//
|
|
|
|
|
|
// This is the right side reminder of the buffer just after the last digit of the ascii port value
|
|
int nReminerSize = (int)(Bytes - (pEndAddressAndPortOld - Buffer));
|
|
|
|
if ( *pBytes + nReminerSize < FTP_MAX_MSG_SIZE )
|
|
{
|
|
int nOffset = m_ControlState.m_nAddressLenNew - nOldAddressLen; // What is the delta size between the old and new address
|
|
|
|
MoveMemory(
|
|
pEndAddressAndPortOld + nOffset, // Destination
|
|
pEndAddressAndPortOld, // Source
|
|
nReminerSize // Size
|
|
);
|
|
|
|
//
|
|
// Insert the new address and port
|
|
//
|
|
memcpy(
|
|
pBeginAddressAndPortOld, // Destination
|
|
m_ControlState.m_szAddressPortNew, // Source
|
|
m_ControlState.m_nAddressLenNew // Size
|
|
);
|
|
|
|
MYTRACE("OLD Address size(%d) %s:%d", nOldAddressLen, MYTRACE_IP(m_ControlState.m_nAddressOld), ntohs(m_ControlState.m_nPortOld));
|
|
MYTRACE("New Address size(%d) %s:%d", m_ControlState.m_nAddressLenNew, MYTRACE_IP(m_ControlState.m_nAddressNew), ntohs(m_ControlState.m_nPortNew));
|
|
|
|
*pBytes = Bytes - nOldAddressLen + m_ControlState.m_nAddressLenNew;
|
|
MYTRACE("Edited COMMAND is '%s' size(%d)", MYTRACE_BUFFER2STR((char*)Buffer, *pBytes), *pBytes);
|
|
|
|
// Now we are sure to have a DataChannel created and in the list of DataChanel
|
|
// on the last DecRefer the ResertPort was deleted twice
|
|
// now by setting m_nPortNew to zero only the DataChannel code will release the port
|
|
//
|
|
m_ControlState.m_nPortNew = 0;
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("Could not alter the command the new address size does not fit in the the current buffer ", E_ABORT);
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
int
|
|
CreateStringFromNumber(UCHAR *String,ULONG Num)
|
|
{
|
|
int retval = 0;
|
|
UCHAR ch1,ch2,ch3;
|
|
|
|
ch3 = (UCHAR)(Num%10) + '0';
|
|
Num = Num/10;
|
|
ch2 = (UCHAR)(Num%10) + '0';
|
|
Num = Num/10;
|
|
ch1 = (UCHAR)(Num%10) + '0';
|
|
_ASSERT(Num == 0);
|
|
if (ch1 != '0') {
|
|
String[retval++] = ch1;
|
|
String[retval++] = ch2;
|
|
String[retval++] = ch3;
|
|
}
|
|
else if (ch2 != '0') {
|
|
String[retval++] = ch2;
|
|
String[retval++] = ch3;
|
|
}
|
|
else {
|
|
String[retval++] = ch3;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
int
|
|
CreateULONGString(UCHAR *String,ULONG Num)
|
|
{
|
|
int retval = 0;
|
|
retval += CreateStringFromNumber(String,Num&0xff);
|
|
String[retval++] = ',';
|
|
retval += CreateStringFromNumber(String+retval,(Num>>8)&0xff);
|
|
String[retval++] = ',';
|
|
retval += CreateStringFromNumber(String+retval,(Num>>16)&0xff);
|
|
String[retval++] = ',';
|
|
retval += CreateStringFromNumber(String+retval,(Num>>24)&0xff);
|
|
return retval;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
int
|
|
CreateUSHORTString(UCHAR *String,USHORT Num)
|
|
{
|
|
int retval = 0;
|
|
retval += CreateStringFromNumber(String,Num&0xff);
|
|
String[retval++] = ',';
|
|
retval += CreateStringFromNumber(String+retval,(Num>>8)&0xff);
|
|
return retval;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
HRESULT
|
|
CFtpControlConnection::CreateNewAddress(void)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::CreateNewAddress");
|
|
|
|
SOCKET sd;
|
|
HRESULT hr = S_OK;
|
|
ULONG Err = 0;
|
|
|
|
sd = (m_ConnectionType == OUTGOING ? m_AlgConnectedSocket : m_ClientConnectedSocket);
|
|
|
|
ULONG OtherAddr,PublicAddr;
|
|
USHORT OtherPort,PublicPort;
|
|
|
|
Err = MyHelperQueryRemoteEndpointSocket(sd,&OtherAddr,&OtherPort);
|
|
|
|
if (Err == 0)
|
|
{
|
|
hr = g_pIAlgServicesAlgFTP->GetBestSourceAddressForDestinationAddress(OtherAddr,FALSE,&PublicAddr);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = g_pIAlgServicesAlgFTP->ReservePort(1,&PublicPort);
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("Could not GetBestSourceAddressForDestinationAddress", hr);
|
|
PublicAddr = 0; // Try with this
|
|
}
|
|
|
|
MYTRACE("ICS Reserved Address %s:%d", MYTRACE_IP(PublicAddr), ntohs(PublicPort));
|
|
m_ControlState.m_nAddressNew = PublicAddr;
|
|
m_ControlState.m_nPortNew = PublicPort;
|
|
|
|
|
|
ULONG StrLen = CreateULONGString(m_ControlState.m_szAddressPortNew,PublicAddr);
|
|
|
|
m_ControlState.m_szAddressPortNew[StrLen++] = ',';
|
|
StrLen += CreateUSHORTString(m_ControlState.m_szAddressPortNew+StrLen,PublicPort);
|
|
m_ControlState.m_nAddressLenNew = StrLen;
|
|
MYTRACE("NEW AddressPort String %s Len(%d)", MYTRACE_BUFFER2STR((char*)m_ControlState.m_szAddressPortNew, StrLen), StrLen);
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
HRESULT
|
|
CFtpControlConnection::SetupDataRedirect(void)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::SetupDataRedirect");
|
|
|
|
ULONG pubAddr,prvAddr,icsAddr;
|
|
USHORT pubPort,prvPort,icsPort;
|
|
ULONG Err = 0;
|
|
|
|
|
|
|
|
switch ( m_ConnectionType )
|
|
{
|
|
case OUTGOING:
|
|
MYTRACE("OUTGOING");
|
|
|
|
Err = MyHelperQueryRemoteEndpointSocket(m_AlgConnectedSocket,&pubAddr,&pubPort);
|
|
pubPort = 0;
|
|
|
|
icsAddr = m_ControlState.m_nAddressNew;
|
|
icsPort = m_ControlState.m_nPortNew;
|
|
|
|
prvAddr = m_ControlState.m_nAddressOld;
|
|
prvPort = m_ControlState.m_nPortOld;
|
|
break;
|
|
|
|
case INCOMING:
|
|
MYTRACE("INCOMING");
|
|
Err = MyHelperQueryRemoteEndpointSocket(m_ClientConnectedSocket,&pubAddr,&pubPort);
|
|
pubPort = 0;
|
|
pubAddr = 0;
|
|
icsAddr = m_ControlState.m_nAddressNew;
|
|
icsPort = m_ControlState.m_nPortNew;
|
|
|
|
prvAddr = m_ControlState.m_nAddressOld;
|
|
prvPort = m_ControlState.m_nPortOld;
|
|
break;
|
|
|
|
default:
|
|
// m_ConnectionType is corrupt
|
|
_ASSERT( FALSE );
|
|
break;
|
|
}
|
|
|
|
|
|
if ( Err != 0 )
|
|
{
|
|
MYTRACE_ERROR("MyHelperQueryRemoteEndpointSocket", Err);
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
HRESULT hr = S_OK;
|
|
IDataChannel* pDataChannel = NULL;
|
|
|
|
hr = g_pIAlgServicesAlgFTP->CreateDataChannel(
|
|
eALG_TCP,
|
|
prvAddr,
|
|
prvPort,
|
|
icsAddr,
|
|
icsPort,
|
|
pubAddr,
|
|
pubPort,
|
|
eALG_INBOUND, //| eALG_OUTBOUND, not needed i suppose since we
|
|
// are not bothered if client tries to open connection.
|
|
(ALG_NOTIFICATION)0,// (eALG_SESSION_CREATION | eALG_SESSION_DELETION),
|
|
FALSE,
|
|
&pDataChannel
|
|
);
|
|
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
MYTRACE_ERROR("g_pIAlgServicesAlgFTP->CreateDataChannel", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
m_DataChannelList.Insert(
|
|
pDataChannel,
|
|
icsPort,
|
|
0,
|
|
0
|
|
);
|
|
|
|
return S_OK;
|
|
|
|
|
|
//
|
|
// Don't use creation and deletion events for now
|
|
//
|
|
#if 0
|
|
HANDLE HandleDataChannelCreation = NULL;
|
|
HANDLE HandleDataChannelDeletion = NULL;
|
|
|
|
HANDLE MyHandleRegisteredCreation = NULL;
|
|
HANDLE MyHandleRegisteredDeletion = NULL;
|
|
|
|
//
|
|
// Get the CREATION handle
|
|
//
|
|
|
|
hr = pDataChannel->GetSessionCreationEventHandle((HANDLE_PTR *)&HandleDataChannelCreation);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
MYTRACE("Creation Handle is %d", HandleDataChannelCreation);
|
|
|
|
MyHandleRegisteredCreation = NhRegisterEvent(
|
|
HandleDataChannelCreation,
|
|
DataChannelCreationCallback,
|
|
(PVOID)this,
|
|
(PVOID)pDataChannel,
|
|
DATA_CREATION_TIMEO
|
|
);
|
|
|
|
if ( MyHandleRegisteredCreation )
|
|
{
|
|
|
|
//
|
|
// Get the DELETION handle
|
|
//
|
|
hr = pDataChannel->GetSessionDeletionEventHandle((HANDLE_PTR *)&HandleDataChannelDeletion);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
MYTRACE("Deletion Handle is %d", HandleDataChannelDeletion);
|
|
|
|
MyHandleRegisteredDeletion = NhRegisterEvent(
|
|
HandleDataChannelDeletion,
|
|
DataChannelDeletionCallback,
|
|
(PVOID)this,
|
|
(PVOID)pDataChannel,
|
|
INFINITE
|
|
);
|
|
|
|
|
|
if ( MyHandleRegisteredDeletion )
|
|
{
|
|
//
|
|
// We have a valid DataChannel
|
|
//
|
|
MYTRACE ("Inserting into DataChannelList");
|
|
|
|
m_DataChannelList.Insert(
|
|
pDataChannel,
|
|
icsPort,
|
|
MyHandleRegisteredCreation,
|
|
MyHandleRegisteredDeletion
|
|
);
|
|
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("NhRegisterEven(HandleDataChannelDeletion)", 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("GetSessionDeletionEventHandle",hr);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("NhRegisterEvent(HandleDataChannelCreation)", 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MYTRACE_ERROR("GetSessionCreationEventHandle",hr);
|
|
}
|
|
|
|
//
|
|
// ERROR if we got here, rollback
|
|
//
|
|
|
|
pDataChannel->Cancel();
|
|
pDataChannel->Release();
|
|
|
|
if ( MyHandleRegisteredCreation )
|
|
NhUnRegisterEvent(MyHandleRegisteredCreation);
|
|
|
|
if ( MyHandleRegisteredDeletion )
|
|
NhUnRegisterEvent(MyHandleRegisteredDeletion);
|
|
|
|
return hr; // return the last error
|
|
#endif
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
CFtpControlConnection::DataChannelDeletion(
|
|
BOOLEAN TimerOrWait,
|
|
PVOID Context
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::DataChannelDeletion");
|
|
|
|
USHORT port;
|
|
IDataChannel *pDataChannel = (IDataChannel *)Context;
|
|
/*
|
|
if (m_DataChannelList.Remove(pDataChannel,&port))
|
|
{
|
|
MYTRACE("Releasing Port");
|
|
pDataChannel->Release();
|
|
g_pIAlgServicesAlgFTP->ReleaseReservedPort(port,1);
|
|
ULONG ref;
|
|
ref = DecReference();
|
|
}
|
|
*/
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
CFtpControlConnection::DataChannelCreation(
|
|
BOOLEAN TimerOrWait,
|
|
PVOID Context
|
|
)
|
|
{
|
|
MYTRACE_ENTER("CFtpControlConnection::DataChannelCreation");
|
|
MYTRACE("TimerOrWait: %d", TimerOrWait);
|
|
|
|
USHORT port;
|
|
if (TimerOrWait==0)
|
|
{
|
|
/*
|
|
IDataChannel *pDataChannel = (IDataChannel *)Context;
|
|
HANDLE DeletionHandle;
|
|
|
|
if ( m_DataChannelList.Remove(pDataChannel,&port,&DeletionHandle))
|
|
{
|
|
MYTRACE("Cancelling DataChannel");
|
|
pDataChannel->Cancel();
|
|
pDataChannel->Release();
|
|
|
|
MYTRACE("Releasing Port");
|
|
g_pIAlgServicesAlgFTP->ReleaseReservedPort(port,1);
|
|
NhUnRegisterEvent(DeletionHandle);
|
|
DecReference();
|
|
}
|
|
*/
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
CComAutoCriticalSection m_AutoCS_FtpIO;
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
DataChannelCreationCallback(
|
|
BOOLEAN TimerOrWait,
|
|
PVOID Context,
|
|
PVOID Context2
|
|
)
|
|
{
|
|
MYTRACE_ENTER("DataChannelCreationCallback");
|
|
|
|
CFtpControlConnection *pFtpControl = (CFtpControlConnection *)Context;
|
|
pFtpControl->DataChannelCreation(TimerOrWait,Context2);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
DataChannelDeletionCallback(
|
|
BOOLEAN TimerOrWait,
|
|
PVOID Context,
|
|
PVOID Context2
|
|
)
|
|
{
|
|
MYTRACE_ENTER("DataChannelDeletionCallback");
|
|
|
|
CFtpControlConnection *pFtpControl = (CFtpControlConnection *)Context;
|
|
pFtpControl->DataChannelDeletion(TimerOrWait,Context2);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
MyAcceptCompletion(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER Bufferp
|
|
)
|
|
{
|
|
m_AutoCS_FtpIO.Lock();
|
|
|
|
MYTRACE_ENTER("MyAcceptCompletion");
|
|
|
|
CAlgFTP* pMainObj = (CAlgFTP*)Bufferp->Context;
|
|
if ( pMainObj )
|
|
pMainObj->AcceptCompletionRoutine(ErrCode,BytesTransferred,Bufferp);
|
|
|
|
m_AutoCS_FtpIO.Unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
MyConnectCompletion(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER pContext
|
|
)
|
|
{
|
|
m_AutoCS_FtpIO.Lock();
|
|
|
|
MYTRACE_ENTER("MyConnectCompletion");
|
|
|
|
|
|
CFtpControlConnection* pControl = (CFtpControlConnection *)pContext; // Special case here see socket.cpp MyHelperpConnectOrCloseCallbackRoutine
|
|
|
|
if ( pControl )
|
|
pControl->ConnectCompletionRoutine(ErrCode,BytesTransferred);
|
|
|
|
m_AutoCS_FtpIO.Unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
MyReadCompletion(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER Bufferp
|
|
)
|
|
{
|
|
m_AutoCS_FtpIO.Lock();
|
|
|
|
MYTRACE_ENTER("");
|
|
|
|
CFtpControlConnection *pControl = (CFtpControlConnection *)Bufferp->Context;
|
|
|
|
if ( pControl )
|
|
pControl->ReadCompletionRoutine(ErrCode,BytesTransferred,Bufferp);
|
|
else
|
|
{
|
|
MYTRACE_ENTER("ERROR ERROR ERROR MyReadCompletion");
|
|
}
|
|
|
|
m_AutoCS_FtpIO.Unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
void
|
|
MyWriteCompletion(
|
|
ULONG ErrCode,
|
|
ULONG BytesTransferred,
|
|
PNH_BUFFER Bufferp
|
|
)
|
|
{
|
|
m_AutoCS_FtpIO.Lock();
|
|
|
|
MYTRACE_ENTER("");
|
|
|
|
CFtpControlConnection *pControl = (CFtpControlConnection *)Bufferp->Context;
|
|
if ( pControl )
|
|
pControl->WriteCompletionRoutine(ErrCode,BytesTransferred,Bufferp);
|
|
else
|
|
{
|
|
MYTRACE_ENTER("ERROR ERROR ERROR MyWriteCompletion");
|
|
}
|
|
|
|
m_AutoCS_FtpIO.Unlock();
|
|
|
|
}
|
|
|