mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1327 lines
30 KiB
1327 lines
30 KiB
/**********************************************************************/
|
|
/** Microsoft Windows NT **/
|
|
/** Copyright(c) Microsoft Corp., 1993 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
sockutil.cxx
|
|
|
|
This module contains utility routines for managing & manipulating
|
|
sockets.
|
|
|
|
Functions exported by this module:
|
|
|
|
InitializeSockets
|
|
TerminateSockets
|
|
CreateDataSocket
|
|
CreateFtpdSocket
|
|
CloseSocket
|
|
ResetSocket
|
|
AcceptSocket
|
|
SockSend
|
|
SockRecv
|
|
SockPrintf2
|
|
ReplyToUser()
|
|
SockReadLine
|
|
SockMultilineMessage2
|
|
|
|
|
|
|
|
FILE HISTORY:
|
|
KeithMo 07-Mar-1993 Created.
|
|
MuraliK April-1995 Misc modifications (removed usage of various
|
|
socket functions/modified them)
|
|
|
|
*/
|
|
|
|
|
|
#include "ftpdp.hxx"
|
|
|
|
|
|
//
|
|
// Private constants.
|
|
//
|
|
|
|
#define DEFAULT_BUFFER_SIZE 4096 // bytes
|
|
|
|
//
|
|
// Private globals.
|
|
//
|
|
|
|
|
|
//
|
|
// Private prototypes.
|
|
//
|
|
|
|
SOCKERR
|
|
vSockPrintf(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
LPCSTR pszFormat,
|
|
va_list args
|
|
);
|
|
|
|
SOCKERR
|
|
vSockReply(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
UINT ReplyCode,
|
|
CHAR chSeparator,
|
|
LPCSTR pszFormat,
|
|
va_list args
|
|
);
|
|
|
|
BOOL
|
|
vTelnetEscapeIAC(
|
|
PCHAR pszBuffer,
|
|
PINT pcchBufChars,
|
|
INT ccbMaxLen
|
|
);
|
|
|
|
//
|
|
// Public functions.
|
|
//
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: CreateDataSocket
|
|
|
|
SYNOPSIS: Creates a data socket for the specified address & port.
|
|
|
|
ENTRY: psock - Will receive the new socket ID if successful.
|
|
|
|
addrLocal - The local Internet address for the socket
|
|
in network byte order.
|
|
|
|
portLocal - The local port for the socket in network
|
|
byte order.
|
|
|
|
addrRemote - The remote Internet address for the socket
|
|
in network byte order.
|
|
|
|
portRemote - The remote port for the socket in network
|
|
byte order.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 10-Mar-1993 Created.
|
|
KeithMo 07-Sep-1993 Enable SO_REUSEADDR.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
CreateDataSocket(
|
|
SOCKET * psock,
|
|
ULONG addrLocal,
|
|
PORT portLocal,
|
|
ULONG addrRemote,
|
|
PORT portRemote
|
|
)
|
|
{
|
|
SOCKET sNew = INVALID_SOCKET;
|
|
SOCKERR serr = 0;
|
|
SOCKADDR_IN sockAddr;
|
|
|
|
//
|
|
// Just to be paranoid...
|
|
//
|
|
|
|
DBG_ASSERT( psock != NULL );
|
|
*psock = INVALID_SOCKET;
|
|
|
|
//
|
|
// Create the socket.
|
|
//
|
|
|
|
sNew = WSASocketW(AF_INET,
|
|
SOCK_STREAM,
|
|
IPPROTO_TCP,
|
|
NULL,
|
|
0,
|
|
WSA_FLAG_OVERLAPPED);
|
|
|
|
serr = ( sNew == INVALID_SOCKET ) ? WSAGetLastError() : 0;
|
|
|
|
if( serr == 0 )
|
|
{
|
|
BOOL fReuseAddr = TRUE;
|
|
|
|
//
|
|
// Since we always bind to the same local port,
|
|
// allow the reuse of address/port pairs.
|
|
//
|
|
|
|
if( setsockopt( sNew,
|
|
SOL_SOCKET,
|
|
SO_REUSEADDR,
|
|
(CHAR *)&fReuseAddr,
|
|
sizeof(fReuseAddr) ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Bind the local internet address & port to the socket.
|
|
//
|
|
|
|
sockAddr.sin_family = AF_INET;
|
|
sockAddr.sin_addr.s_addr = addrLocal;
|
|
sockAddr.sin_port = portLocal;
|
|
|
|
if( bind( sNew, (SOCKADDR *)&sockAddr, sizeof(sockAddr) ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Connect to the remote internet address & port.
|
|
//
|
|
|
|
sockAddr.sin_family = AF_INET;
|
|
sockAddr.sin_addr.s_addr = addrRemote;
|
|
sockAddr.sin_port = portRemote;
|
|
|
|
if( connect( sNew, (SOCKADDR *)&sockAddr, sizeof(sockAddr) ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Success! Return the socket to the caller.
|
|
//
|
|
|
|
DBG_ASSERT( sNew != INVALID_SOCKET );
|
|
*psock = sNew;
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"data socket %d connected from (%08lX,%04X) to (%08lX,%04X)\n",
|
|
sNew,
|
|
ntohl( addrLocal ),
|
|
ntohs( portLocal ),
|
|
ntohl( addrRemote ),
|
|
ntohs( portRemote ) ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Something fatal happened. Close the socket if
|
|
// managed to actually open it.
|
|
//
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"no data socket from (%08lX,%04X) to (%08lX, %04X), error %d\n",
|
|
ntohl( addrLocal ),
|
|
ntohs( portLocal ),
|
|
ntohl( addrRemote ),
|
|
ntohs( portRemote ),
|
|
serr ));
|
|
|
|
}
|
|
|
|
if( sNew != INVALID_SOCKET )
|
|
{
|
|
ResetSocket( sNew );
|
|
}
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // CreateDataSocket
|
|
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: CreateFtpdSocket
|
|
|
|
SYNOPSIS: Creates a new socket at the FTPD port.
|
|
This will be used by the passive data transfer.
|
|
|
|
ENTRY: psock - Will receive the new socket ID if successful.
|
|
|
|
addrLocal - The lcoal Internet address for the socket
|
|
in network byte order.
|
|
|
|
portLocal - The local port for the socket in network
|
|
byte order.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 08-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
CreateFtpdSocket(
|
|
SOCKET * psock,
|
|
ULONG addrLocal,
|
|
PORT portLocal,
|
|
FTP_SERVER_INSTANCE *pInstance
|
|
)
|
|
{
|
|
SOCKET sNew = INVALID_SOCKET;
|
|
SOCKERR serr = 0;
|
|
|
|
//
|
|
// Just to be paranoid...
|
|
//
|
|
|
|
DBG_ASSERT( psock != NULL );
|
|
*psock = INVALID_SOCKET;
|
|
|
|
//
|
|
// Create the connection socket.
|
|
//
|
|
|
|
sNew = WSASocketW(AF_INET,
|
|
SOCK_STREAM,
|
|
IPPROTO_TCP,
|
|
NULL,
|
|
0,
|
|
WSA_FLAG_OVERLAPPED);
|
|
|
|
|
|
serr = ( sNew == INVALID_SOCKET ) ? WSAGetLastError() : 0;
|
|
|
|
if( serr == 0 )
|
|
{
|
|
BOOL fReuseAddr = FALSE;
|
|
|
|
//
|
|
// Muck around with the socket options a bit.
|
|
// Berkeley FTPD does this.
|
|
//
|
|
|
|
if( setsockopt( sNew,
|
|
SOL_SOCKET,
|
|
SO_REUSEADDR,
|
|
(CHAR *)&fReuseAddr,
|
|
sizeof(fReuseAddr) ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
SOCKADDR_IN sockAddr;
|
|
|
|
//
|
|
// Bind an address to the socket.
|
|
//
|
|
|
|
sockAddr.sin_family = AF_INET;
|
|
sockAddr.sin_addr.s_addr = addrLocal;
|
|
sockAddr.sin_port = portLocal;
|
|
|
|
if( bind( sNew, (SOCKADDR *)&sockAddr, sizeof(sockAddr) ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Put the socket into listen mode.
|
|
//
|
|
|
|
if( listen( sNew, (INT)pInstance->NumListenBacklog()) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Success! Return the socket to the caller.
|
|
//
|
|
|
|
DBG_ASSERT( sNew != INVALID_SOCKET );
|
|
*psock = sNew;
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"connection socket %d created at (%08lX,%04X)\n",
|
|
sNew,
|
|
ntohl( addrLocal ),
|
|
ntohs( portLocal ) ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Something fatal happened. Close the socket if
|
|
// managed to actually open it.
|
|
//
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"no connection socket at (%08lX, %04X), error %d\n",
|
|
ntohl( addrLocal ),
|
|
ntohs( portLocal ),
|
|
serr ));
|
|
|
|
}
|
|
|
|
if( sNew != INVALID_SOCKET )
|
|
{
|
|
ResetSocket( sNew );
|
|
}
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // CreateFtpdSocket
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: CloseSocket
|
|
|
|
SYNOPSIS: Closes the specified socket. This is just a thin
|
|
wrapper around the "real" closesocket() API.
|
|
|
|
ENTRY: sock - The socket to close.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 26-Apr-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
CloseSocket(
|
|
SOCKET sock
|
|
)
|
|
{
|
|
SOCKERR serr = 0;
|
|
|
|
//
|
|
// Close the socket.
|
|
//
|
|
|
|
if( closesocket( sock ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
if( serr == 0 )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"closed socket %d\n",
|
|
sock ));
|
|
}
|
|
else
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"cannot close socket %d, error %d\n",
|
|
sock,
|
|
serr ));
|
|
}
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // CloseSocket
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: ResetSocket
|
|
|
|
SYNOPSIS: Performs a "hard" close on the given socket.
|
|
|
|
ENTRY: sock - The socket to close.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 08-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
ResetSocket(
|
|
SOCKET sock
|
|
)
|
|
{
|
|
SOCKERR serr = 0;
|
|
LINGER linger;
|
|
|
|
//
|
|
// Enable linger with a timeout of zero. This will
|
|
// force the hard close when we call closesocket().
|
|
//
|
|
// We ignore the error return from setsockopt. If it
|
|
// fails, we'll just try to close the socket anyway.
|
|
//
|
|
|
|
linger.l_onoff = TRUE;
|
|
linger.l_linger = 0;
|
|
|
|
setsockopt( sock,
|
|
SOL_SOCKET,
|
|
SO_LINGER,
|
|
(CHAR *)&linger,
|
|
sizeof(linger) );
|
|
|
|
//
|
|
// Close the socket.
|
|
//
|
|
|
|
if( closesocket( sock ) != 0 )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
|
|
IF_DEBUG( SOCKETS )
|
|
{
|
|
if( serr == 0 )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"reset socket %d\n",
|
|
sock ));
|
|
}
|
|
else
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"cannot reset socket %d, error %d\n",
|
|
sock,
|
|
serr ));
|
|
}
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // ResetSocket
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: AcceptSocket
|
|
|
|
SYNOPSIS: Waits for a connection to the specified socket.
|
|
The socket is assumed to be "listening".
|
|
|
|
ENTRY: sockListen - The socket to accept on.
|
|
|
|
psockNew - Will receive the newly "accepted" socket
|
|
if successful.
|
|
|
|
paddr - Will receive the client's network address.
|
|
|
|
fEnforceTimeout - If TRUE, this routine will enforce
|
|
the idle-client timeout. If FALSE, no timeouts
|
|
are enforced (and this routine may block
|
|
indefinitely).
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 27-Apr-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
AcceptSocket(
|
|
SOCKET sockListen,
|
|
SOCKET * psockNew,
|
|
LPSOCKADDR_IN paddr,
|
|
BOOL fEnforceTimeout,
|
|
FTP_SERVER_INSTANCE *pInstance
|
|
)
|
|
{
|
|
SOCKERR serr = 0;
|
|
SOCKET sockNew = INVALID_SOCKET;
|
|
BOOL fRead = FALSE;
|
|
|
|
DBG_ASSERT( psockNew != NULL );
|
|
DBG_ASSERT( paddr != NULL );
|
|
|
|
if( fEnforceTimeout ) {
|
|
|
|
//
|
|
// Timeouts are to be enforced, so wait for a connection
|
|
// to the socket.
|
|
//
|
|
|
|
serr = WaitForSocketWorker(
|
|
sockListen,
|
|
INVALID_SOCKET,
|
|
&fRead,
|
|
NULL,
|
|
pInstance->QueryConnectionTimeout()
|
|
);
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
INT cbAddr = sizeof(SOCKADDR_IN);
|
|
|
|
//
|
|
// Wait for the actual connection.
|
|
//
|
|
|
|
sockNew = accept( sockListen, (SOCKADDR *)paddr, &cbAddr );
|
|
|
|
if( sockNew == INVALID_SOCKET )
|
|
{
|
|
serr = WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the (potentially invalid) socket to the caller.
|
|
//
|
|
|
|
*psockNew = sockNew;
|
|
|
|
return serr;
|
|
|
|
} // AcceptSocket
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SockSend
|
|
|
|
SYNOPSIS: Sends a block of bytes to a specified socket.
|
|
|
|
ENTRY: pUserData - The user initiating the request.
|
|
|
|
sock - The target socket.
|
|
|
|
pBuffer - Contains the data to send.
|
|
|
|
cbBuffer - The size (in bytes) of the buffer.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 13-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
SockSend(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
LPVOID pBuffer,
|
|
DWORD cbBuffer
|
|
)
|
|
{
|
|
SOCKERR serr = 0;
|
|
INT cbSent;
|
|
DWORD dwBytesSent = 0;
|
|
|
|
DBG_ASSERT( pBuffer != NULL );
|
|
|
|
//
|
|
// Loop until there's no more data to send.
|
|
//
|
|
|
|
while( cbBuffer > 0 ) {
|
|
|
|
//
|
|
// Wait for the socket to become writeable.
|
|
//
|
|
BOOL fWrite = FALSE;
|
|
|
|
serr = WaitForSocketWorker(
|
|
INVALID_SOCKET,
|
|
sock,
|
|
NULL,
|
|
&fWrite,
|
|
(pUserData != NULL) ?
|
|
pUserData->QueryInstance()->QueryConnectionTimeout():
|
|
FTP_DEF_SEND_TIMEOUT
|
|
);
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Write a block to the socket.
|
|
//
|
|
|
|
cbSent = send( sock, (CHAR *)pBuffer, (INT)cbBuffer, 0 );
|
|
|
|
if( cbSent < 0 )
|
|
{
|
|
//
|
|
// Socket error.
|
|
//
|
|
|
|
serr = WSAGetLastError();
|
|
}
|
|
else
|
|
{
|
|
dwBytesSent += (DWORD)cbSent;
|
|
|
|
IF_DEBUG( SEND )
|
|
{
|
|
if( pUserData && TEST_UF( pUserData, TRANSFER ) )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"send %d bytes @%p to socket %d\n",
|
|
cbSent,
|
|
pBuffer,
|
|
sock ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// added a check for special case when we are sending and thinking that we are sending
|
|
// synchronoulsy on socket which was set to non blocking mode. In that case when buffer space
|
|
// in winsock becomes exhausted send return WSAEWOULDBLOCK. So then we just retry.
|
|
|
|
if ( serr != WSAEWOULDBLOCK )
|
|
{
|
|
if( serr != 0 )
|
|
{
|
|
break;
|
|
}
|
|
|
|
pBuffer = (LPVOID)( (LPBYTE)pBuffer + cbSent );
|
|
cbBuffer -= (DWORD)cbSent;
|
|
}
|
|
}
|
|
|
|
if( serr != 0 )
|
|
{
|
|
IF_DEBUG( SEND )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"socket error %d during send on socket %d.\n",
|
|
serr,
|
|
sock));
|
|
}
|
|
}
|
|
|
|
if( pUserData != NULL ) {
|
|
pUserData->QueryInstance()->QueryStatsObj()->UpdateTotalBytesSent(
|
|
dwBytesSent );
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // SockSend
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SockRecv
|
|
|
|
SYNOPSIS: Receives a block of bytes from a specified socket.
|
|
|
|
ENTRY: pUserData - The user initiating the request.
|
|
|
|
sock - The target socket.
|
|
|
|
pBuffer - Will receive the data.
|
|
|
|
cbBuffer - The size (in bytes) of the buffer.
|
|
|
|
pbReceived - Will receive the actual number of bytes
|
|
received. This value is undefined if this function
|
|
fails.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 13-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
SockRecv(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
LPVOID pBuffer,
|
|
DWORD cbBuffer,
|
|
LPDWORD pbReceived
|
|
)
|
|
{
|
|
SOCKERR serr = 0;
|
|
DWORD cbTotal = 0;
|
|
INT cbReceived;
|
|
DWORD dwBytesRecv = 0;
|
|
|
|
DBG_ASSERT( pBuffer != NULL );
|
|
DBG_ASSERT( pbReceived != NULL );
|
|
|
|
//
|
|
// Loop until the buffer's full.
|
|
//
|
|
|
|
while (cbBuffer > 0) {
|
|
|
|
BOOL fRead = FALSE;
|
|
|
|
//
|
|
// Wait for the socket to become readable.
|
|
//
|
|
|
|
serr = WaitForSocketWorker(
|
|
sock,
|
|
INVALID_SOCKET,
|
|
&fRead,
|
|
NULL,
|
|
(pUserData != NULL) ?
|
|
pUserData->QueryInstance()->QueryConnectionTimeout():
|
|
FTP_DEF_RECV_TIMEOUT
|
|
);
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Read a block from the socket.
|
|
//
|
|
DBG_ASSERT( fRead);
|
|
|
|
cbReceived = recv( sock, (CHAR *)pBuffer, (INT)cbBuffer, 0 );
|
|
|
|
if( cbReceived < 0 )
|
|
{
|
|
//
|
|
// Socket error.
|
|
//
|
|
|
|
serr = WSAGetLastError();
|
|
}
|
|
else
|
|
{
|
|
dwBytesRecv += (DWORD)cbReceived;
|
|
|
|
IF_DEBUG( RECV )
|
|
{
|
|
if( pUserData && TEST_UF( pUserData, TRANSFER ) )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"received %d bytes @%p from socket %d\n",
|
|
cbReceived,
|
|
pBuffer,
|
|
sock ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ( serr != 0 ) || ( cbReceived == 0 ) )
|
|
{
|
|
//
|
|
// End of file, socket closed, timeout, or socket error.
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
pBuffer = (LPVOID)( (LPBYTE)pBuffer + cbReceived );
|
|
cbBuffer -= (DWORD)cbReceived;
|
|
cbTotal += (DWORD)cbReceived;
|
|
}
|
|
|
|
if( serr == 0 )
|
|
{
|
|
//
|
|
// Return total byte count to caller.
|
|
//
|
|
|
|
*pbReceived = cbTotal;
|
|
}
|
|
else
|
|
{
|
|
IF_DEBUG( RECV )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"socket error %d during recv on socket %d\n",
|
|
serr,
|
|
sock ));
|
|
}
|
|
}
|
|
|
|
if( pUserData != NULL ) {
|
|
pUserData->QueryInstance()->QueryStatsObj()->UpdateTotalBytesReceived(
|
|
dwBytesRecv );
|
|
}
|
|
|
|
return serr;
|
|
|
|
} // SockRecv
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SockPrintf2
|
|
|
|
SYNOPSIS: Send a formatted string to a specific socket.
|
|
|
|
ENTRY: pUserData - The user initiating the request.
|
|
|
|
sock - The target socket.
|
|
|
|
pszFormat - A printf-style format string.
|
|
|
|
... - Any other parameters needed by the format string.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 10-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
__cdecl
|
|
SockPrintf2(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
LPCSTR pszFormat,
|
|
...
|
|
)
|
|
{
|
|
va_list ArgPtr;
|
|
SOCKERR serr;
|
|
|
|
//
|
|
// Let the worker do the dirty work.
|
|
//
|
|
|
|
va_start( ArgPtr, pszFormat );
|
|
|
|
serr = vSockPrintf( pUserData,
|
|
sock,
|
|
pszFormat,
|
|
ArgPtr );
|
|
|
|
va_end( ArgPtr );
|
|
|
|
return serr;
|
|
|
|
} // SockPrintf2
|
|
|
|
|
|
|
|
SOCKERR
|
|
__cdecl
|
|
ReplyToUser(
|
|
IN LPUSER_DATA pUserData,
|
|
IN UINT ReplyCode,
|
|
IN LPCSTR pszFormat,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
This function sends an FTP reply to the user data object. The reply
|
|
is usually sent over the control socket.
|
|
|
|
Arguments:
|
|
pUserData pointer to UserData object initiating the reply
|
|
ReplyCode One of the REPLY_* manifests.
|
|
pszFormat pointer to null-terminated string containing the format
|
|
... additional paramters if any required.
|
|
|
|
Returns:
|
|
SOCKET error code. 0 on success and !0 on failure.
|
|
|
|
History:
|
|
MuraliK
|
|
--*/
|
|
{
|
|
va_list ArgPtr;
|
|
SOCKERR serr;
|
|
|
|
DBG_ASSERT( pUserData != NULL);
|
|
|
|
pUserData->SetLastReplyCode( ReplyCode );
|
|
|
|
if ( pUserData->QueryControlSocket() != INVALID_SOCKET) {
|
|
|
|
//
|
|
// Let the worker do the dirty work.
|
|
//
|
|
|
|
va_start( ArgPtr, pszFormat );
|
|
|
|
serr = vSockReply( pUserData,
|
|
pUserData->QueryControlSocket(),
|
|
ReplyCode,
|
|
' ',
|
|
pszFormat,
|
|
ArgPtr );
|
|
|
|
va_end( ArgPtr );
|
|
} else {
|
|
|
|
serr = WSAECONNABORTED;
|
|
}
|
|
|
|
|
|
return serr;
|
|
|
|
} // ReplyToUser()
|
|
|
|
|
|
// Private functions
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: vSockPrintf
|
|
|
|
SYNOPSIS: Worker function for printf-to-socket functions.
|
|
|
|
ENTRY: pUserData - The user initiating the request.
|
|
|
|
sock - The target socket.
|
|
|
|
pszFormat - The format string.
|
|
|
|
args - Variable number of arguments.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 17-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
vSockPrintf(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
LPCSTR pszFormat,
|
|
va_list args
|
|
)
|
|
{
|
|
INT cchBuffer = 0;
|
|
INT buffMaxLen;
|
|
SOCKERR serr = 0;
|
|
CHAR szBuffer[MAX_REPLY_LENGTH];
|
|
|
|
DBG_ASSERT( pszFormat != NULL );
|
|
|
|
//
|
|
// Render the format into our local buffer.
|
|
//
|
|
|
|
|
|
DBG_ASSERT( MAX_REPLY_LENGTH > 3);
|
|
buffMaxLen = MAX_REPLY_LENGTH - 3;
|
|
cchBuffer = _vsnprintf( szBuffer,
|
|
buffMaxLen,
|
|
pszFormat, args );
|
|
//
|
|
// The string length is long, we get back -1.
|
|
// so we get the string length for partial data.
|
|
//
|
|
|
|
if ( cchBuffer == -1 ) {
|
|
|
|
//
|
|
// terminate the string properly,
|
|
// since _vsnprintf() does not terminate properly on failure.
|
|
//
|
|
cchBuffer = buffMaxLen;
|
|
szBuffer[ buffMaxLen] = '\0';
|
|
}
|
|
|
|
IF_DEBUG( SOCKETS ) {
|
|
DBGPRINTF(( DBG_CONTEXT, "sending '%s'\n", szBuffer ));
|
|
}
|
|
|
|
//
|
|
// Escape all telnet IAC bytes with a second IAC
|
|
//
|
|
vTelnetEscapeIAC( szBuffer, &cchBuffer, MAX_REPLY_LENGTH - 3 );
|
|
|
|
strcpy( szBuffer + cchBuffer, "\r\n" );
|
|
cchBuffer += 2;
|
|
|
|
//
|
|
// Blast it out to the client.
|
|
//
|
|
|
|
serr = SockSend( pUserData, sock, szBuffer, cchBuffer );
|
|
return serr;
|
|
|
|
} // vSockPrintf
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: vSockReply
|
|
|
|
SYNOPSIS: Worker function for reply functions.
|
|
|
|
ENTRY: pUserData - The user initiating the request.
|
|
|
|
sock - The target socket.
|
|
|
|
ReplyCode - A three digit reply code from RFC 959.
|
|
|
|
chSeparator - Should be either ' ' (normal reply) or
|
|
'-' (first line of multi-line reply).
|
|
|
|
pszFormat - The format string.
|
|
|
|
args - Variable number of arguments.
|
|
|
|
RETURNS: SOCKERR - 0 if successful, !0 if not.
|
|
|
|
HISTORY:
|
|
KeithMo 17-Mar-1993 Created.
|
|
|
|
********************************************************************/
|
|
SOCKERR
|
|
vSockReply(
|
|
LPUSER_DATA pUserData,
|
|
SOCKET sock,
|
|
UINT ReplyCode,
|
|
CHAR chSeparator,
|
|
LPCSTR pszFormat,
|
|
va_list args
|
|
)
|
|
{
|
|
INT cchBuffer;
|
|
INT cchBuffer1;
|
|
INT buffMaxLen;
|
|
SOCKERR serr = 0;
|
|
CHAR szBuffer[MAX_REPLY_LENGTH];
|
|
|
|
DBG_ASSERT( ( ReplyCode >= 100 ) && ( ReplyCode < 600 ) );
|
|
|
|
//
|
|
// Render the format into our local buffer.
|
|
//
|
|
|
|
cchBuffer = wsprintfA( szBuffer,
|
|
"%u%c",
|
|
ReplyCode,
|
|
chSeparator );
|
|
|
|
DBG_ASSERT( MAX_REPLY_LENGTH > cchBuffer + 3);
|
|
buffMaxLen = MAX_REPLY_LENGTH - cchBuffer - 3;
|
|
cchBuffer1 = _vsnprintf( szBuffer + cchBuffer,
|
|
buffMaxLen,
|
|
pszFormat, args );
|
|
//
|
|
// The string length is long, we get back -1.
|
|
// so we get the string length for partial data.
|
|
//
|
|
|
|
if ( cchBuffer1 == -1 ) {
|
|
|
|
//
|
|
// terminate the string properly,
|
|
// since _vsnprintf() does not terminate properly on failure.
|
|
//
|
|
cchBuffer = buffMaxLen;
|
|
szBuffer[ buffMaxLen] = '\0';
|
|
} else {
|
|
|
|
cchBuffer += cchBuffer1;
|
|
}
|
|
|
|
IF_DEBUG( SOCKETS ) {
|
|
DBGPRINTF(( DBG_CONTEXT, "sending '%s'\n",szBuffer ));
|
|
}
|
|
|
|
//
|
|
// Escape all telnet IAC bytes with a second IAC
|
|
//
|
|
vTelnetEscapeIAC( szBuffer, &cchBuffer, MAX_REPLY_LENGTH - 3 );
|
|
|
|
strcpy( szBuffer + cchBuffer, "\r\n" );
|
|
cchBuffer += 2;
|
|
|
|
//
|
|
// Blast it out to the client.
|
|
//
|
|
|
|
serr = SockSend( pUserData, sock, szBuffer, cchBuffer );
|
|
|
|
return serr;
|
|
|
|
} // vSockReply
|
|
|
|
|
|
DWORD
|
|
FtpFormatResponseMessage( IN UINT uiReplyCode,
|
|
IN LPCTSTR pszReplyMsg,
|
|
OUT LPTSTR pszReplyBuffer,
|
|
IN DWORD cchReplyBuffer)
|
|
/*++
|
|
This function formats the message to be sent to the client,
|
|
given the reply code and the message to be sent.
|
|
|
|
The formatting function takes care of the reply buffer length
|
|
and ensures the safe write of data. If the reply buffer is
|
|
not sufficient to hold the entire message, the reply msg is trunctaed.
|
|
|
|
Arguments:
|
|
uiReplyCode reply code to be used.
|
|
pszReplyMsg pointer to string containing the reply message
|
|
pszReplyBuffer pointer to character buffer where the reply message
|
|
can be sent.
|
|
cchReplyBuffer character count for the length of reply buffer.
|
|
|
|
Returns:
|
|
length of the data written to the reply buffer.
|
|
|
|
--*/
|
|
{
|
|
DWORD len;
|
|
|
|
DBG_ASSERT( pszReplyMsg != NULL && pszReplyBuffer != NULL);
|
|
|
|
len = lstrlen( pszReplyMsg) + 10; // 10 chars are required for aux info.
|
|
|
|
if ( len >= cchReplyBuffer) {
|
|
|
|
// truncate the message since length is too high.
|
|
|
|
len = wsprintf( pszReplyBuffer, TEXT("%u \r\n"),
|
|
uiReplyCode);
|
|
|
|
DBG_ASSERT( len >= 3); // length greater than formatting string
|
|
DBG_ASSERT( len < cchReplyBuffer);
|
|
|
|
lstrcpyn( pszReplyBuffer + len, pszReplyMsg, cchReplyBuffer - len);
|
|
|
|
len = lstrlen( pszReplyBuffer);
|
|
DBG_ASSERT( len < cchReplyBuffer);
|
|
|
|
} else {
|
|
|
|
len = wsprintf( pszReplyBuffer, TEXT("%u %s\r\n"),
|
|
uiReplyCode,
|
|
pszReplyMsg);
|
|
DBG_ASSERT( len >= 4);
|
|
DBG_ASSERT( len <= cchReplyBuffer);
|
|
}
|
|
|
|
return (len);
|
|
} // FtpFormatResponseMessage()
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: vTelnetEscapeIAC
|
|
|
|
SYNOPSIS: replace (in place) all 0xFF bytes in a buffer with 0xFF 0xFF.
|
|
This is the TELNET escape sequence for an IAC value data byte.
|
|
|
|
ENTRY: pszBuffer - data buffer.
|
|
|
|
pcchBufChars - on entry, current number of chars in buffer.
|
|
on return, number of chars in buffer.
|
|
|
|
cchMaxLen - maximum characters in the output buffer
|
|
|
|
RETURNS: TRUE - success, FALSE - overflow.
|
|
|
|
HISTORY:
|
|
RobSol 25-April-2001 Created.
|
|
|
|
********************************************************************/
|
|
BOOL
|
|
vTelnetEscapeIAC( IN OUT PCHAR pszBuffer,
|
|
IN OUT PINT pcchBufChars,
|
|
IN INT cchMaxLen)
|
|
{
|
|
|
|
# define CHAR_IAC ((CHAR)(-1))
|
|
|
|
PCHAR pszFirstIAC;
|
|
PCHAR pSrc, pDst;
|
|
BOOL fReturn = TRUE;
|
|
CHAR szBuf[MAX_REPLY_LENGTH];
|
|
INT cCharsInDst;
|
|
|
|
DBG_ASSERT( pszBuffer );
|
|
DBG_ASSERT( pcchBufChars );
|
|
DBG_ASSERT( cchMaxLen <= MAX_REPLY_LENGTH );
|
|
|
|
if ((pszFirstIAC = strchr( pszBuffer, CHAR_IAC)) == NULL) {
|
|
|
|
//
|
|
// no IAC - return.
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// we'll expand the string into a temp buffer, then copy back.
|
|
//
|
|
|
|
pSrc = pszFirstIAC;
|
|
pDst = szBuf;
|
|
cCharsInDst = DIFF(pszFirstIAC - pszBuffer);
|
|
|
|
do {
|
|
if (*pSrc == CHAR_IAC) {
|
|
|
|
//
|
|
// this is a char to escape
|
|
//
|
|
|
|
if ((cCharsInDst + 1) < cchMaxLen) {
|
|
|
|
//
|
|
// we have space to escape the char, so do it.
|
|
//
|
|
|
|
cCharsInDst++;
|
|
*pDst++ = CHAR_IAC;
|
|
} else {
|
|
|
|
//
|
|
// overflow.
|
|
//
|
|
|
|
fReturn = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
*pDst++ = *pSrc++;
|
|
|
|
} while ((++cCharsInDst < cchMaxLen) && (*pSrc != '\0'));
|
|
|
|
//
|
|
// copy the expanded data back into the input buffer and terminate the string
|
|
//
|
|
|
|
memcpy( pszFirstIAC, szBuf, pDst - szBuf);
|
|
pszBuffer[ cCharsInDst ] = '\0';
|
|
|
|
*pcchBufChars = cCharsInDst;
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
/************************ End of File ******************************/
|