able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/svcs/ftp/server/sockutil.cxx

1328 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**********************************************************************/
/** 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 ******************************/
Reference in a new issue Copy permalink