763 lines
18 KiB
C++
763 lines
18 KiB
C++
/**********************************************************************/
|
||
/** Microsoft Windows NT **/
|
||
/** Copyright(c) Microsoft Corp., 1994 **/
|
||
/**********************************************************************/
|
||
|
||
/*
|
||
connect.cxx
|
||
|
||
This module contains the connection accept routine called by the connection
|
||
thread.
|
||
|
||
|
||
FILE HISTORY:
|
||
Johnl 08-Aug-1994 Lifted from FTP server
|
||
|
||
*/
|
||
|
||
#define INCL_INETSRV_INCS
|
||
#include "smtpinc.h"
|
||
#include <rdns.hxx>
|
||
#include "smtpcli.hxx"
|
||
|
||
|
||
|
||
//
|
||
// Private prototypes.
|
||
//
|
||
|
||
VOID
|
||
SmtpCompletion(
|
||
PVOID pvContext,
|
||
DWORD cbWritten,
|
||
DWORD dwCompletionStatus,
|
||
OVERLAPPED * lpo
|
||
);
|
||
|
||
SOCKERR CloseSocket( SOCKET sock );
|
||
|
||
BOOL
|
||
SendError(
|
||
SOCKET socket,
|
||
DWORD ids
|
||
);
|
||
|
||
//
|
||
// Private functions.
|
||
//
|
||
|
||
/*++
|
||
This function dereferences User data and kills the UserData object if the
|
||
reference count hits 0. Before killing the user data, it also removes
|
||
the connection from the list of active connections.
|
||
|
||
--*/
|
||
VOID DereferenceUserDataAndKill(IN OUT CLIENT_CONNECTION * pUserData)
|
||
{
|
||
pUserData->DisconnectClient();
|
||
((SMTP_CONNECTION*)pUserData)->QuerySmtpInstance()->RemoveConnection(pUserData);
|
||
delete pUserData;
|
||
|
||
} // DereferenceUserDataAndKill()
|
||
|
||
void HandleErrorCondition(SOCKET sock, SMTP_SERVER_INSTANCE *pInstance, DWORD dwError, PSOCKADDR_IN pSockAddr)
|
||
{
|
||
char ErrorBuf[4 *MAX_PATH];
|
||
const CHAR * apszSubStrings[2];
|
||
CHAR pchAddr1[50] = "";
|
||
CHAR pchAddr2[50] = "";
|
||
DWORD SendSize;
|
||
|
||
_ASSERT(pSockAddr != NULL);
|
||
_ASSERT(pInstance != NULL);
|
||
_ASSERT(sock != INVALID_SOCKET);
|
||
|
||
SendSize = wsprintf (ErrorBuf, "%d-%s %s\r\n",
|
||
SMTP_RESP_SRV_UNAVAIL,
|
||
pInstance->GetConnectResponse(),
|
||
SMTP_SRV_UNAVAIL_MSG);
|
||
|
||
CLIENT_CONNECTION::WriteSocket(sock, ErrorBuf, SendSize );
|
||
|
||
if(dwError == ERROR_REMOTE_SESSION_LIMIT_EXCEEDED)
|
||
{
|
||
_itoa(pInstance->QueryInstanceId(), pchAddr1, 10);
|
||
InetNtoa(pSockAddr->sin_addr, pchAddr2 );
|
||
|
||
apszSubStrings[0] = pchAddr1;
|
||
apszSubStrings[1] = pchAddr2;
|
||
|
||
SmtpLogEvent(SMTP_MAX_CONNECTION_REACHED,
|
||
2,
|
||
apszSubStrings,
|
||
NO_ERROR );
|
||
}
|
||
}
|
||
|
||
BOOL VerifyClient(SMTP_CONNECTION * pNewClient, PSOCKADDR_IN psockAddrRemote)
|
||
{
|
||
AC_RESULT acIpAccess;
|
||
BOOL fNeedDnsCheck = FALSE;
|
||
BOOL fRet = TRUE;
|
||
struct hostent* pH = NULL;
|
||
|
||
pNewClient->QueryAccessCheck()->BindAddr( (PSOCKADDR)psockAddrRemote );
|
||
if ( pNewClient->BindInstanceAccessCheck() )
|
||
{
|
||
acIpAccess = pNewClient->QueryAccessCheck()->CheckIpAccess( &fNeedDnsCheck);
|
||
if ( (acIpAccess == AC_IN_DENY_LIST) ||
|
||
((acIpAccess == AC_NOT_IN_GRANT_LIST) && !fNeedDnsCheck) )
|
||
{
|
||
fRet = FALSE;
|
||
}
|
||
else if (fNeedDnsCheck)
|
||
{
|
||
pH = gethostbyaddr( (char*)(&((PSOCKADDR_IN)psockAddrRemote)->sin_addr),
|
||
4, PF_INET );
|
||
if(pH != NULL)
|
||
{
|
||
acIpAccess = pNewClient->QueryAccessCheck()->CheckName(pH->h_name);
|
||
}
|
||
else
|
||
{
|
||
acIpAccess = AC_IN_DENY_LIST;
|
||
}
|
||
}
|
||
|
||
if ( (acIpAccess == AC_IN_DENY_LIST) ||
|
||
(acIpAccess == AC_NOT_IN_GRANT_LIST))
|
||
{
|
||
fRet = FALSE;
|
||
}
|
||
|
||
pNewClient->UnbindInstanceAccessCheck();
|
||
}
|
||
|
||
|
||
if(!fRet)
|
||
{
|
||
SetLastError(ERROR_ACCESS_DENIED);
|
||
}
|
||
|
||
return fRet;
|
||
}
|
||
|
||
BOOL
|
||
ProcessNewClient(
|
||
IN SOCKET sNew,
|
||
IN PVOID EndpointObject,
|
||
IN SMTP_SERVER_INSTANCE *pInstance,
|
||
IN BOOL fMaxConnExceeded,
|
||
IN PSOCKADDR_IN psockAddrRemote,
|
||
IN PSOCKADDR_IN psockAddrLocal = NULL,
|
||
IN PATQ_CONTEXT patqContext = NULL,
|
||
IN PVOID pvBuff = NULL,
|
||
IN DWORD cbWritten = 0,
|
||
OUT LPBOOL pfAtqToBeFreed = NULL
|
||
)
|
||
{
|
||
SMTP_CONNECTION * pNewClient = NULL;
|
||
DWORD err = NO_ERROR;
|
||
BOOL fReturn = FALSE;
|
||
BOOL fMaxExceeded = FALSE;
|
||
DBG_CODE( CHAR pchAddr[32];);
|
||
BOOL fSockToBeFreed = TRUE;
|
||
BOOL fDereferenceInstance = FALSE;
|
||
BOOL fSupressErrorResponse = FALSE;
|
||
CLIENT_CONN_PARAMS clientParams;
|
||
|
||
TraceFunctEnterEx((LPARAM) NULL, "ProcessNewClient");
|
||
|
||
DBG_CODE( InetNtoa( psockAddrRemote->sin_addr, pchAddr));
|
||
|
||
if ( pfAtqToBeFreed != NULL)
|
||
{
|
||
*pfAtqToBeFreed = TRUE;
|
||
}
|
||
|
||
clientParams.sClient = sNew;
|
||
clientParams.pAtqContext = patqContext;
|
||
clientParams.pAddrLocal = (PSOCKADDR) psockAddrLocal;
|
||
clientParams.pAddrRemote = (PSOCKADDR)psockAddrRemote;
|
||
clientParams.pvInitialBuff = pvBuff;
|
||
clientParams.cbInitialBuff = cbWritten ;
|
||
clientParams.pEndpoint = (PIIS_ENDPOINT)EndpointObject;
|
||
|
||
if( pInstance && (pInstance->IsShuttingDown() || (pInstance->QueryServerState( ) != MD_SERVER_STATE_STARTED)))
|
||
{
|
||
DBGPRINTF((DBG_CONTEXT," Service instance is shutting down\n"));
|
||
}
|
||
else if ( !fMaxConnExceeded)
|
||
{
|
||
|
||
// DBGPRINTF((DBG_CONTEXT,"Getting a connection object\n"));
|
||
|
||
pNewClient = (SMTP_CONNECTION *) pInstance->CreateNewConnection( &clientParams);
|
||
|
||
if(pNewClient)
|
||
{
|
||
if(!VerifyClient(pNewClient, psockAddrRemote))
|
||
{
|
||
//
|
||
// Depending on metabase configuration, either require clients
|
||
// whose IPs are blocked to authenticate, or drop the connection.
|
||
//
|
||
if(pInstance->GetDeniedIpAction() == SMTPDENIEDIP_REQAUTH)
|
||
pNewClient->RequireAuth();
|
||
else
|
||
{
|
||
_ASSERT(pInstance->GetDeniedIpAction() == SMTPDENIEDIP_DROPCONN);
|
||
DereferenceUserDataAndKill(pNewClient);
|
||
pNewClient = NULL;
|
||
fSockToBeFreed = FALSE;
|
||
fDereferenceInstance = FALSE;
|
||
SetLastError(ERROR_ACCESS_DENIED);
|
||
|
||
//
|
||
// We have closed the socket... don't write to it!!!
|
||
//
|
||
fSupressErrorResponse = TRUE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
err = ERROR_REMOTE_SESSION_LIMIT_EXCEEDED;
|
||
SetLastError(err);
|
||
}
|
||
|
||
if( pNewClient != NULL)
|
||
{
|
||
|
||
//DBGPRINTF((DBG_CONTEXT,"New connection object is non-null\n"));
|
||
|
||
//
|
||
// Start off processing this client connection.
|
||
//
|
||
// Once we make a reset call, the USER_DATA object is created
|
||
// with the socket and atq context.
|
||
// From now on USER_DATA will take care of freeing
|
||
// ATQ context & socket
|
||
//
|
||
|
||
fSockToBeFreed = FALSE;
|
||
|
||
//
|
||
// At this point we have the context for the AcceptExed socket.
|
||
// Set the context in the AtqContext if need be.
|
||
//
|
||
|
||
if ( patqContext != NULL)
|
||
{
|
||
//DBGPRINTF((DBG_CONTEXT,"AtqContext is not NULL\n"));
|
||
|
||
|
||
//
|
||
// Associate client connection object with this control socket
|
||
// handle for future completions.
|
||
//
|
||
|
||
AtqContextSetInfo(patqContext,
|
||
ATQ_INFO_COMPLETION_CONTEXT,
|
||
(UINT_PTR) pNewClient);
|
||
}
|
||
else
|
||
{
|
||
//DBGPRINTF((DBG_CONTEXT,"AtqContext is NULL\n"));
|
||
|
||
if(!pNewClient->AddToAtqHandles((HANDLE) sNew,EndpointObject, pInstance->QueryConnectionTimeout(),
|
||
SmtpCompletion))
|
||
{
|
||
err = GetLastError();
|
||
DBGPRINTF((DBG_CONTEXT,"AddToAtqHandles() failed- err= %d\n", err));
|
||
DebugTrace((LPARAM) NULL, "pNewClient->AddToAtqHandles failed- err = %d", err);
|
||
|
||
DereferenceUserDataAndKill(pNewClient);
|
||
fDereferenceInstance = FALSE;
|
||
fSockToBeFreed = FALSE;
|
||
pNewClient = NULL;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
err = GetLastError();
|
||
|
||
if(err != ERROR_ACCESS_DENIED)
|
||
fDereferenceInstance = TRUE;
|
||
}
|
||
|
||
if ( (pNewClient == NULL) || (err != NO_ERROR) )
|
||
{
|
||
|
||
// DBGPRINTF((DBG_CONTEXT,"New connection object is NULL\n"));
|
||
|
||
//
|
||
// Failed to allocate new connection
|
||
// Reasons:
|
||
// 1) Max connections might have been exceeded.
|
||
// 2) Not enough memory is available.
|
||
//
|
||
// handle the failures and notify client.
|
||
//
|
||
|
||
if (!fSupressErrorResponse)
|
||
HandleErrorCondition(sNew, pInstance, err, psockAddrRemote);
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
//DBGPRINTF((DBG_CONTEXT,"Calling StartSession()\n"));
|
||
|
||
if(!pNewClient->StartSession())
|
||
{
|
||
err = GetLastError();
|
||
DBGPRINTF((DBG_CONTEXT,"StartSession() failed - err= %d\n", err));
|
||
DebugTrace((LPARAM) NULL, "pNewClient->StartSession() failed- err = %d", err);
|
||
|
||
DereferenceUserDataAndKill(pNewClient);
|
||
pNewClient = NULL;
|
||
fSockToBeFreed = FALSE;
|
||
fDereferenceInstance = FALSE;
|
||
}
|
||
else
|
||
{
|
||
fReturn = TRUE;
|
||
}
|
||
}
|
||
|
||
|
||
if ( fSockToBeFreed )
|
||
{
|
||
if ( patqContext != NULL)
|
||
{
|
||
// ensure that socket is shut down.
|
||
DBG_REQUIRE( AtqCloseSocket( patqContext, TRUE));
|
||
}
|
||
else
|
||
{
|
||
|
||
CloseSocket( sNew);
|
||
}
|
||
}
|
||
|
||
|
||
if ( pfAtqToBeFreed != NULL)
|
||
{
|
||
|
||
*pfAtqToBeFreed = fSockToBeFreed;
|
||
}
|
||
|
||
if (pInstance && fDereferenceInstance )
|
||
{
|
||
pInstance->DecrementCurrentConnections();
|
||
pInstance->Dereference();
|
||
}
|
||
|
||
TraceFunctLeaveEx((LPARAM) NULL);
|
||
return (fReturn);
|
||
|
||
} // ProcessNewClient()
|
||
|
||
/*******************************************************************
|
||
|
||
NAME: SmtpOnConnect
|
||
|
||
SYNOPSIS: Handles the incoming connection indication from the
|
||
connection thread
|
||
|
||
|
||
ENTRY: sNew - New client socket
|
||
|
||
HISTORY:
|
||
KeithMo 09-Mar-1993 Created.
|
||
Johnl 02-Aug-1994 Reworked from FTP server
|
||
|
||
********************************************************************/
|
||
|
||
VOID SmtpOnConnect( IN SOCKET sNew,
|
||
IN SOCKADDR_IN * psockaddr, //Should be SOCKADDR *
|
||
IN PVOID pEndpointContext,
|
||
IN PVOID pEndpointObject )
|
||
{
|
||
|
||
PIIS_ENDPOINT pEndpoint = (PIIS_ENDPOINT)pEndpointContext;
|
||
INT cbAddr = sizeof( sockaddr );
|
||
SOCKADDR_IN sockaddr;
|
||
SMTP_SERVER_INSTANCE *pInstance;
|
||
BOOL fProcessed;
|
||
BOOL fMaxConnExceeded;
|
||
|
||
DBG_ASSERT( sNew != INVALID_SOCKET );
|
||
DBG_ASSERT( psockaddr != NULL );
|
||
|
||
if ( g_pInetSvc->QueryCurrentServiceState() != SERVICE_RUNNING )
|
||
{
|
||
|
||
DBGPRINTF((DBG_CONTEXT,"Connection attempt on inactive service\n"));
|
||
|
||
goto error_exit;
|
||
|
||
}
|
||
|
||
if ( getsockname( sNew, (PSOCKADDR) &sockaddr, &cbAddr ) != 0 )
|
||
{
|
||
goto error_exit;
|
||
}
|
||
|
||
//
|
||
// Find Instance
|
||
//
|
||
pInstance = (SMTP_SERVER_INSTANCE *)
|
||
((PIIS_ENDPOINT)pEndpointContext)->FindAndReferenceInstance(
|
||
(LPCSTR)NULL,
|
||
sockaddr.sin_addr.s_addr,
|
||
&fMaxConnExceeded);
|
||
|
||
if ( pInstance == NULL )
|
||
{
|
||
|
||
//
|
||
// Site is not permitted to access this server.
|
||
// Dont establish this connection. We should send a message.
|
||
//
|
||
|
||
goto error_exit;
|
||
}
|
||
|
||
fProcessed = ProcessNewClient( sNew,
|
||
pEndpointObject,
|
||
pInstance,
|
||
fMaxConnExceeded,
|
||
psockaddr);
|
||
|
||
if ( fProcessed)
|
||
{
|
||
//StatCheckAndSetMaxConnections();
|
||
}
|
||
|
||
return;
|
||
|
||
error_exit:
|
||
|
||
CloseSocket( sNew );
|
||
|
||
return;
|
||
|
||
} // SmtpOnConnect
|
||
|
||
|
||
|
||
VOID
|
||
SmtpOnConnectEx(
|
||
VOID * patqContext,
|
||
DWORD cbWritten,
|
||
DWORD err,
|
||
OVERLAPPED * lpo
|
||
)
|
||
{
|
||
BOOL fAllowConnection = FALSE;
|
||
PVOID pvBuff = NULL;
|
||
PSOCKADDR_IN psockAddrLocal = NULL;
|
||
PSOCKADDR_IN psockAddrRemote = NULL;
|
||
SOCKET sNew;
|
||
PIIS_ENDPOINT pEndpoint;
|
||
PSMTP_SERVER_INSTANCE pInstance;
|
||
BOOL fProcessed = FALSE;
|
||
BOOL fAtqContextToBeFreed = TRUE;
|
||
BOOL fMaxConnExceeded;
|
||
|
||
if ( err || !lpo || g_IsShuttingDown)
|
||
{
|
||
if(g_IsShuttingDown)
|
||
{
|
||
DBGPRINTF(( DBG_CONTEXT,
|
||
"[SmtpOnConnectEx] Completion failed because of shutdown %d, Atq context %lx\n",
|
||
err,
|
||
patqContext ));
|
||
|
||
}
|
||
else
|
||
{
|
||
DBGPRINTF(( DBG_CONTEXT,
|
||
"[SmtpOnConnectEx] Completion failed with error %d, Atq context %lx\n",
|
||
err,
|
||
patqContext ));
|
||
}
|
||
|
||
goto exit;
|
||
}
|
||
|
||
|
||
//
|
||
// Get AcceptEx parameters
|
||
//
|
||
|
||
AtqGetAcceptExAddrs( (PATQ_CONTEXT) patqContext,
|
||
&sNew,
|
||
&pvBuff,
|
||
(PVOID*)&pEndpoint,
|
||
(PSOCKADDR *) &psockAddrLocal,
|
||
(PSOCKADDR *) &psockAddrRemote );
|
||
|
||
|
||
if ( g_pInetSvc->QueryCurrentServiceState() != SERVICE_RUNNING )
|
||
{
|
||
|
||
DBGPRINTF((DBG_CONTEXT,"Connection attempt on inactive service\n"));
|
||
|
||
goto exit ;
|
||
}
|
||
|
||
//
|
||
// Find Instance
|
||
//
|
||
|
||
pInstance = (SMTP_SERVER_INSTANCE *)
|
||
((PIIS_ENDPOINT)pEndpoint)->FindAndReferenceInstance(
|
||
(LPCSTR)NULL,
|
||
psockAddrLocal->sin_addr.s_addr,
|
||
&fMaxConnExceeded
|
||
);
|
||
|
||
if(pInstance == NULL)
|
||
{
|
||
//
|
||
// Site is not permitted to access this server.
|
||
// Dont establish this connection. We should send a message.
|
||
//
|
||
|
||
// DBGPRINTF((DBG_CONTEXT,
|
||
// "Unable to find instance [err %d]\n",GetLastError()));
|
||
goto exit;
|
||
}
|
||
|
||
|
||
//
|
||
// Set the timeout for future IOs on this context
|
||
//
|
||
|
||
AtqContextSetInfo( (PATQ_CONTEXT) patqContext,
|
||
ATQ_INFO_TIMEOUT,
|
||
(UINT_PTR) pInstance->QueryConnectionTimeout());
|
||
|
||
|
||
fProcessed = ProcessNewClient( sNew,
|
||
pEndpoint,
|
||
pInstance,
|
||
fMaxConnExceeded,
|
||
psockAddrRemote,
|
||
psockAddrLocal,
|
||
(PATQ_CONTEXT ) patqContext,
|
||
pvBuff,
|
||
cbWritten,
|
||
&fAtqContextToBeFreed);
|
||
|
||
|
||
exit:
|
||
|
||
if ( !fProcessed && fAtqContextToBeFreed )
|
||
{
|
||
|
||
// DBGPRINTF((DBG_CONTEXT,
|
||
// "ProcessNewClient returned false\n"));
|
||
|
||
//
|
||
// We failed to process this connection. Free up resources properly
|
||
//
|
||
|
||
DBG_REQUIRE( AtqCloseSocket( (PATQ_CONTEXT )patqContext, FALSE));
|
||
AtqFreeContext( (PATQ_CONTEXT ) patqContext, TRUE );
|
||
}
|
||
|
||
return;
|
||
|
||
} // SmtpOnConnectEx
|
||
|
||
|
||
|
||
#if 0
|
||
BOOL
|
||
SendError(
|
||
SOCKET socket,
|
||
DWORD ids
|
||
)
|
||
{
|
||
STR strResponse;
|
||
|
||
if ( !strResponse.Resize( 512 ) ||
|
||
!HTTP_REQ_BASE::BuildExtendedStatus( &strResponse,
|
||
HT_FORBIDDEN,
|
||
NO_ERROR,
|
||
ids ))
|
||
{
|
||
DBGPRINTF((DBG_CONTEXT,
|
||
"[SendError] Failed to build status (error %d)\n",
|
||
GetLastError()));
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Do a synchronous send
|
||
//
|
||
|
||
send( socket,
|
||
strResponse.QueryStr(),
|
||
strResponse.QueryCB(),
|
||
0 );
|
||
|
||
return TRUE ;
|
||
} // SendError
|
||
#endif
|
||
|
||
/*******************************************************************
|
||
|
||
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 0
|
||
shutdown( sock, 1 ); // Davidtr sez not needed
|
||
#endif
|
||
|
||
if( closesocket( sock ) != 0 )
|
||
{
|
||
serr = WSAGetLastError();
|
||
}
|
||
|
||
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
|
||
|
||
/*++
|
||
|
||
Description:
|
||
|
||
Handles a completed IO.
|
||
|
||
Arguments:
|
||
|
||
pvContext: the context pointer specified in the initial IO
|
||
cbWritten: the number of bytes sent
|
||
dwCompletionStatus: the status of the completion (usually NO_ERROR)
|
||
lpo: the overlapped structure associated with the IO
|
||
|
||
Returns:
|
||
|
||
nothing.
|
||
|
||
--*/
|
||
VOID
|
||
SmtpCompletion(
|
||
PVOID pvContext,
|
||
DWORD cbWritten,
|
||
DWORD dwCompletionStatus,
|
||
OVERLAPPED * lpo
|
||
)
|
||
{
|
||
BOOL WasProcessed;
|
||
SMTP_CONNECTION *pCC = (SMTP_CONNECTION *) pvContext;
|
||
|
||
_ASSERT(pCC);
|
||
_ASSERT(pCC->IsValid());
|
||
_ASSERT(pCC->QuerySmtpInstance() != NULL);
|
||
|
||
//
|
||
// if we could not process a command, or we were
|
||
// told to destroy this object, close the connection.
|
||
//
|
||
WasProcessed = pCC->ProcessClient(cbWritten, dwCompletionStatus, lpo);
|
||
}
|
||
|
||
/*++
|
||
|
||
Description:
|
||
|
||
Handles a completed IO.
|
||
|
||
Arguments:
|
||
|
||
pvContext: the context pointer specified in the initial IO
|
||
cbWritten: the number of bytes sent
|
||
dwCompletionStatus: the status of the completion (usually NO_ERROR)
|
||
lpo: the overlapped structure associated with the IO
|
||
|
||
Returns:
|
||
|
||
nothing.
|
||
|
||
--*/
|
||
VOID
|
||
SmtpCompletionFIO(
|
||
PFIO_CONTEXT pFIOContext,
|
||
FH_OVERLAPPED *pOverlapped,
|
||
DWORD cbWritten,
|
||
DWORD dwCompletionStatus)
|
||
{
|
||
BOOL WasProcessed;
|
||
SMTP_CONNECTION *pCC = (SMTP_CONNECTION *) (((SERVEREVENT_OVERLAPPED *) pOverlapped)->ThisPtr);
|
||
|
||
_ASSERT(pCC);
|
||
_ASSERT(pCC->IsValid());
|
||
_ASSERT(pCC->QuerySmtpInstance() != NULL);
|
||
|
||
//
|
||
// if we could not process a command, or we were
|
||
// told to destroy this object, close the connection.
|
||
//
|
||
WasProcessed = pCC->ProcessClient(cbWritten, dwCompletionStatus, (OVERLAPPED *) pOverlapped);
|
||
}
|
||
|
||
#if 0
|
||
VOID
|
||
ServerEventCompletion(
|
||
PVOID pvContext,
|
||
DWORD cbWritten,
|
||
DWORD dwCompletionStatus,
|
||
OVERLAPPED * lpo
|
||
)
|
||
{
|
||
SERVEREVENT_OVERLAPPED * Ov = (SERVEREVENT_OVERLAPPED *) lpo;
|
||
|
||
_ASSERT(pvContext);
|
||
|
||
Ov->Overlapped.pfnCompletion(Ov->ThisPtr, cbWritten, dwCompletionStatus, lpo);
|
||
|
||
}
|
||
#endif
|
||
|