Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/inetsrv/iis/svcs/smtp/server/smtpcli.cxx
Microsoft 50969b0ea2 First commit
2020-09-30 16:53:55 +02:00

10393 lines
334 KiB
C++
Raw Permalink Blame History

/*++
Copyright (c) 1994 Microsoft Corporation
Module Name :
smtpcli.cxx
Abstract:
This module defines the functions for derived class of connections
for Internet Services ( class SMTP_CONNECTION)
Author:
Rohan Phillips ( Rohanp ) 11-Dec-1995
Project:
SMTP Server DLL
Functions Exported:
SMTP_CONNECTION::~SMTP_CONNECTION()
BOOL SMTP_CONNECTION::ProcessClient( IN DWORD cbWritten,
IN DWORD dwCompletionStatus,
IN BOOL fIOCompletion)
BOOL SMTP_CONNECTION::StartupSession( VOID)
Revision History:
--*/
/************************************************************
* Include Headers
************************************************************/
#define INCL_INETSRV_INCS
#include "smtpinc.h"
//
// ATL includes
//
#define _ATL_NO_DEBUG_CRT
#define _ASSERTE _ASSERT
#define _WINDLL
#include "atlbase.h"
extern CComModule _Module;
#include "atlcom.h"
#undef _WINDLL
//
// SEO includes
//
#include "seo.h"
#include "seolib.h"
#include <memory.h>
#include <issperr.h>
#include "smtpcli.hxx"
#include "headers.hxx"
#include "timeconv.h"
#include "base64.hxx"
#include "smtpout.hxx"
#include <smtpevents.h>
#include <smtpevent.h>
#include <smtpguid.h>
extern "C"
{
#include <secint.h>
}
//
// Dispatcher implementation
//
#include "pe_dispi.hxx"
int strcasecmp(char *s1, char *s2);
int strncasecmp(char *s1, char *s2, int n);
#define IMSG_PROGID L"Exchange.IMsg"
#define MAILMSG_PROGID L"Exchange.MailMsg"
extern CHAR g_VersionString[];
// provide memory for static declared in SMTP_CONNECTION
CPool SMTP_CONNECTION::Pool(CLIENT_CONNECTION_SIGNATURE_VALID);
static char * HelpText= "214-This server supports the following commands:\r\n"
"214 HELO EHLO STARTTLS RCPT DATA RSET MAIL QUIT HELP";
static char * Daynames[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
static const char * SMTP_TOO_MANY_RCPTS = "Too many recipients";
static const char * PasswordParam = "Password:";
static const char * UserParam = "Username:";
static LONG g_NumRoutingThreads = 0;
LONG g_cProcessClientThreads = 0;
// Format strings for "Received:" lines
static const char szFormatReceivedFormatSuccess[] = "Received: from %s ([%s]) by %s%s with Microsoft SMTPSVC(%s);\r\n\t %s, %s\r\n";
static const char szFormatReceivedFormatUnverified[] = "Received: from %s ([%s] unverified) by %s%s with Microsoft SMTPSVC(%s);\r\n\t %s, %s\r\n";
static const char szFormatReceivedFormatFailed[] = "Received: from %s ([%s] RDNS failed) by %s%s with Microsoft SMTPSVC(%s);\r\n\t %s, %s\r\n";
// Search strings to identify our own "Received:" lines (subsections of above lines)
static const char szFormatReceivedServer[] = ") by %s";
static const char szFormatReceivedService[] = " with Microsoft SMTPSVC(";
// Amount of time (FILETIME / 100ns units) we wait if we detect a looping message
#define SMTP_LOOP_DELAY 6000000000 // == 10 minutes
#define SMTP_TIMEOUT 99
#define SMTP_CONTENT_FILE_IO_TIMEOUT 5*60*1000
#define ATQ_LOCATOR (DWORD)'Dd9D'
//ATQ Write file modes
#define BLOCKING 0
#define NONBLOCKING 1
//Trailer byte status
#define CRLF_NEEDED 0
#define CR_SEEN 1
#define CRLF_SEEN 2
#define CR_MISSING 3
#define WHITESPACE " \t\r\n"
/************************************************************
* Functions
************************************************************/
extern void GenerateMessageId (char * Buffer, DWORD BuffLen);
extern DWORD GetIncreasingMsgId();
extern VOID InternetCompletion(PVOID pvContext, DWORD cbWritten,
DWORD dwCompletionStatus, OVERLAPPED * lpo);
/*++
Name:
SMTP_CONNECTION::SMTP_CONNECTION
Constructs a new SMTP connection object for the client
connection given the client connection socket and socket
address. This constructor is private. Only the Static
member funtion, declared below, can call it.
Arguments:
sClient socket for communicating with client
psockAddrRemote pointer to address of the remote client
( the value should be copied).
psockAddrLocal pointer to address for the local card through
which the client came in.
pAtqContext pointer to ATQ Context used for AcceptEx'ed conn.
pvInitialRequest pointer to void buffer containing the initial request
cbInitialData count of bytes of data read initially.
--*/
SMTP_CONNECTION::SMTP_CONNECTION(
IN PSMTP_SERVER_INSTANCE pInstance,
IN SOCKET sClient,
IN const SOCKADDR_IN * psockAddrRemote,
IN const SOCKADDR_IN * psockAddrLocal /* = NULL */ ,
IN PATQ_CONTEXT pAtqContext /* = NULL */ ,
IN PVOID pvInitialRequest/* = NULL*/ ,
IN DWORD cbInitialData /* = 0 */
)
: m_encryptCtx(FALSE),
m_securityCtx(pInstance,
TCPAUTH_SERVER| TCPAUTH_UUENCODE,
((PSMTP_SERVER_INSTANCE)pInstance)->QueryAuthentication()),
CLIENT_CONNECTION ( sClient, psockAddrRemote,
psockAddrLocal, pAtqContext,
pvInitialRequest, cbInitialData )
{
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::SMTP_CONNECTION");
DebugTrace( (LPARAM)this, "New connection created");
_ASSERT(pInstance != NULL);
//
// By default, we use the smallish receive buffer inherited from
// the case CLIENT_CONNECTION object.
//
m_precvBuffer = m_recvBuffer;
m_cbMaxRecvBuffer = sizeof(m_recvBuffer);
m_pOutputBuffer = m_OutputBuffer;
m_cbMaxOutputBuffer = sizeof(m_OutputBuffer);
m_pIMsg = NULL;
m_pIMsgRecips = NULL;
m_szHeloAddr[0] = '\0';
// m_FromAddr = NULL;
m_szFromAddress[0] = '\0';
m_pszArgs = NULL;
m_pInstance = pInstance;
m_IMsgHandle = NULL;
m_pBindInterface = NULL;
m_cbRecvBufferOffset = 0;
m_pFileWriteBuffer = NULL;
m_pFileWriteBuffer = new CBuffer();
m_HopCount = 0;
m_LocalHopCount = 0;
if(!m_pFileWriteBuffer)
{
ErrorTrace((LPARAM)this, "Failed to get the write buffer Err : %d",
GetLastError());
_ASSERT(0);
}
m_AtqLocator = ATQ_LOCATOR;
// inbound protocol extension related initializations
m_fAsyncEventCompletion = FALSE;
m_fAsyncEOD = FALSE;
m_fIsPeUnderway = FALSE;
m_pIEventRouter = NULL;
m_pCInboundDispatcher = NULL;
// m_CInboundContext is a data member
m_fPeBlobReady = FALSE;
m_pPeBlobCallback = NULL;
ZeroMemory(&m_FileOverLapped, sizeof(m_FileOverLapped));
m_FileOverLapped.SeoOverlapped.Overlapped.pfnCompletion = SmtpCompletionFIO;
m_FileOverLapped.SeoOverlapped.ThisPtr = this;
m_LineCompletionState = SEEN_NOTHING;
m_Truncate = FALSE;
m_BufrWasFull = FALSE;
m_szUsedAuthKeyword[0] = '\0';
m_szAuthenticatedUserNameFromSink[0] = '\0';
//keep track of per instance connection object
pInstance->IncConnInObjs();
TraceFunctLeaveEx((LPARAM) this);
}
SMTP_CONNECTION::~SMTP_CONNECTION (void)
{
PSMTP_SERVER_INSTANCE pInstance = NULL;
CAddr * pAddress = NULL;
char *pTempBuffer = NULL;
// CBuffer * pBuff;
TraceFunctEnterEx((LPARAM)this, "~SMTP_CONNECTION");
ReleasImsg(TRUE);
/*
pAddress = (CAddr *) InterlockedExchangePointer((PVOID *) &m_FromAddr, (PVOID) NULL);
if(pAddress != NULL)
{
delete pAddress;
}*/
pInstance = (PSMTP_SERVER_INSTANCE ) InterlockedExchangePointer((PVOID *) &m_pInstance, (PVOID) NULL);
if(pInstance != NULL)
{
pInstance->DecrementCurrentConnections();
pInstance->DecConnInObjs();
pInstance->Dereference();
}
pTempBuffer = (char *) InterlockedExchangePointer((PVOID *) &m_precvBuffer, (PVOID) &m_recvBuffer[0]);
if (pTempBuffer != m_recvBuffer) {
delete [] pTempBuffer;
}
pTempBuffer = (char *) InterlockedExchangePointer((PVOID *) &m_pOutputBuffer, (PVOID) &m_OutputBuffer[0]);
if (pTempBuffer != m_OutputBuffer) {
delete [] pTempBuffer;
}
if(m_pFileWriteBuffer)
{
delete m_pFileWriteBuffer;
}
if ( NULL != m_pPeBlobCallback) {
m_pPeBlobCallback->Release();
}
if(m_pCInboundDispatcher)
m_pCInboundDispatcher->Release();
if(m_pProviderPackagesInfo)
m_pProviderPackagesInfo->Release();
DebugTrace( (LPARAM)this, "Connection deleted");
TraceFunctLeaveEx((LPARAM)this);
}
/*++
Name :
SMTP_CONNECTION::InitializeObject
Description:
Initializes all member variables and pre-allocates
a mail context class
Arguments:
Returns:
TRUE if memory can be allocated.
FALSE if no memory can be allocated
--*/
BOOL SMTP_CONNECTION::InitializeObject (BOOL IsSecureConnection)
{
BOOL fRet = TRUE;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::InitializeObject");
_ASSERT(m_pInstance != NULL);
StartProcessingTimer();
m_cbReceived = 0;
m_cbParsable = 0;
m_cbTempBDATLen = 0;
m_OutputBufferSize = 0;
m_cbCurrentWriteBuffer = 0;
m_TotalMsgSize = 0;
m_SessionSize = 0;
m_cbDotStrippedTotalMsgSize = 0;
m_ProtocolErrors = 0;
m_dwUnsuccessfulLogons = 0;
m_HeaderSize = 0;
m_cPendingIoCount = 0;
m_cActiveThreads = 0;
m_CurrentOffset = 0;
m_HelloSent = FALSE;
m_RecvdMailCmd = FALSE;
m_RecvdAuthCmd = FALSE;
m_Nooped = FALSE;
m_TimeToRewriteHeader = TRUE;
m_RecvdRcptCmd = FALSE;
m_InHeader = TRUE;
m_LongBodyLine = FALSE;
m_fFoundEmbeddedCrlfDotCrlf = FALSE;
m_fScannedForCrlfDotCrlf = FALSE;
m_fSeenRFC822FromAddress = FALSE;
m_fSeenRFC822ToAddress = FALSE;
m_fSeenRFC822CcAddress = FALSE;
m_fSeenRFC822BccAddress = FALSE;
m_fSeenRFC822Subject = FALSE;
m_fSeenRFC822MsgId = FALSE;
m_fSeenRFC822SenderAddress = FALSE;
m_fSeenXPriority = FALSE;
m_fSeenXOriginalArrivalTime = FALSE;
m_fSeenContentType = FALSE;
m_fSetContentType = FALSE;
m_HeaderFlags = 0;
m_MailBodyError = NO_ERROR;
m_State = HELO;
m_NeedToQuit = FALSE;
m_pSmtpStats = NULL;
m_WritingData = FALSE;
//m_fReverseDnsFailed = FALSE;
m_DNSLookupRetCode = SUCCESS;
m_fUseMbsCta = FALSE;
m_fAuthenticated = FALSE;
m_fMayRelay = FALSE;
m_fClearText = FALSE;
m_fDidUserCmd = FALSE;
m_fAuthAnon = FALSE;
m_SecurePort = IsSecureConnection;
m_fNegotiatingSSL = m_SecurePort;
m_szUsedAuthKeyword[0] = '\0';
m_cbRecvBufferOffset = 0;
m_fPeBlobReady = FALSE;
if ( NULL != m_pPeBlobCallback) {
m_pPeBlobCallback->Release();
}
m_pPeBlobCallback = NULL;
m_fIsLastChunk = FALSE;
m_fIsBinaryMime = FALSE;
m_fIsChunkComplete = FALSE;
m_dwTrailerStatus = CRLF_SEEN;
m_nChunkSize = 0;
m_nBytesRemainingInChunk = 0;
m_MailBodyDiagnostic = ERR_NONE;
m_LineCompletionState = SEEN_NOTHING;
m_Truncate = FALSE;
m_BufrWasFull = FALSE;
m_fBufferFullInBDAT = FALSE;
m_fRecvBufferFull = FALSE;
m_pInstance->LockGenCrit();
if(m_pInstance->QueryAuthentication() & INET_INFO_AUTH_ANONYMOUS)
{
m_fAuthAnon = TRUE;
}
// Advertise this property to sinks (EXPS)
HrSetISessionProperty(ISESSION_PID_ANONYMOUS_AUTH, m_fAuthAnon);
//
// Copy IP Address for instance and remote into session
//
CopyIPAddressesToSession();
//
// Initialize Security Context
//
m_pProviderPackagesInfo = m_pInstance->GetAddRefdProviderPackagesInfo();
if(!m_pProviderPackagesInfo)
{
fRet = FALSE;
goto Exit;
}
if (!m_securityCtx.SetInstanceAuthPackageNames(
m_pProviderPackagesInfo->GetProviderPackagesCount(),
m_pProviderPackagesInfo->GetProviderNames(),
m_pProviderPackagesInfo->GetProviderPackages()))
{
ErrorTrace((LPARAM)this, "SetInstanceAuthPackageNames FAILED <Err=%u>",
GetLastError());
fRet = FALSE;
goto Exit;
}
//
// We want to set up the Cleartext authentication package
// for this connection based on the instance configuration.
// To enable MBS CTA,
// MD_SMTP_CLEARTEXT_AUTH_PROVIDER must be set to the package name.
// To disable it, the md value must be set to "".
//
m_securityCtx.SetCleartextPackageName(
m_pInstance->GetCleartextAuthPackage(),
m_pInstance->GetMembershipBroker());
if (*m_pInstance->GetCleartextAuthPackage() == '\0' ||
*m_pInstance->GetMembershipBroker() == '\0')
{
m_fUseMbsCta = FALSE;
}
else
{
m_fUseMbsCta = TRUE;
}
Exit:
m_pInstance->UnLockGenCrit();
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
/*++
Name :
SMTP_CONNECTION::CreateSmtpConnection
Description:
This is the static member function than is the only
entity that is allowed to create an SMTP_CONNECTION
class. This class cannot be allocated on the stack.
Arguments:
sClient socket for communicating with client
psockAddrRemote pointer to address of the remote client
( the value should be copied).
psockAddrLocal pointer to address for the local card through
which the client came in.
pAtqContext pointer to ATQ Context used for AcceptEx'ed conn.
pvInitialRequest pointer to void buffer containing the initial request
cbInitialData count of bytes of data read initially.
Returns:
A pointer to an SMTP_CONNECTION class or NULL
--*/
SMTP_CONNECTION * SMTP_CONNECTION::CreateSmtpConnection (IN PCLIENT_CONN_PARAMS ClientParams,
IN PSMTP_SERVER_INSTANCE pInst)
{
SMTP_CONNECTION * pSmtpObj = NULL;
PIIS_ENDPOINT pTmpEndPoint = NULL;
pSmtpObj = new SMTP_CONNECTION (pInst, ClientParams->sClient, (const SOCKADDR_IN *) ClientParams->pAddrRemote, (const SOCKADDR_IN *) ClientParams->pAddrLocal,
ClientParams->pAtqContext, ClientParams->pvInitialBuff, ClientParams->cbInitialBuff);
if(pSmtpObj == NULL)
{
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
pTmpEndPoint = (PIIS_ENDPOINT)ClientParams->pEndpoint;
if(!pSmtpObj->InitializeObject(FALSE))
{
delete pSmtpObj;
return NULL;
}
return pSmtpObj;
}
#define MAX_LOG_ERROR_LEN (500)
void SMTP_CONNECTION::TransactionLog(
const char *pszOperation,
const char *pszParameters,
const char *pszTarget,
DWORD dwWin32Error,
DWORD dwServiceSpecificStatus
)
{
INETLOG_INFORMATION translog;
DWORD dwLog;
DWORD cchError = MAX_LOG_ERROR_LEN;
char VersionString[] = "SMTP";
char szParametersBuffer[1024] = ""; //Data portion of buffer information
ZeroMemory(&translog, sizeof(translog));
translog.pszVersion = VersionString;
translog.pszClientHostName = (char *) QueryClientHostName();
translog.cbClientHostName = lstrlen(translog.pszClientHostName);
translog.pszClientUserName = (char *) QueryClientUserName();
translog.pszServerAddress = (char *) QueryLocalHostName();
translog.pszOperation = (char *)pszOperation;
translog.cbOperation = lstrlen ((char *)pszOperation);
translog.pszTarget = (char *)pszTarget;
translog.cbTarget = lstrlen ((char *)pszTarget);
translog.pszParameters = (char *)pszParameters;
if (pszParameters) {
lstrcpyn(szParametersBuffer, pszParameters, sizeof(szParametersBuffer)-sizeof(CHAR));
translog.pszParameters = szParametersBuffer;
} else {
translog.pszParameters = "";
}
translog.dwBytesSent = m_dwCmdBytesSent;
translog.dwBytesRecvd = m_dwCmdBytesRecv;
translog.dwWin32Status = dwWin32Error;
translog.dwProtocolStatus = dwServiceSpecificStatus;
translog.msTimeForProcessing = QueryProcessingTime();
if(QuerySmtpInstance() != NULL)
dwLog = QuerySmtpInstance()->m_Logging.LogInformation( &translog);
}
/*++
Name :
SMTP_CONNECTION::SendSmtpResponse
Description:
This function sends data that was queued in the internal
m_pOutputBuffer buffer
Arguments:
SyncSend - Flag that signifies sync or async send
Returns:
TRUE if the string was sent. False otherwise
--*/
BOOL SMTP_CONNECTION::SendSmtpResponse(BOOL SyncSend)
{
BOOL RetStatus = TRUE;
DWORD cbMessage = m_OutputBufferSize;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::SendSmtpResponse");
//IncPendingIoCount();
//if m_OutputBufferSize > 0that means there is
//something in the buffer, therefore, we will send it.
if (m_OutputBufferSize)
{
//
// If we are using SSL, encrypt the output buffer now. Note that
// FormatSmtpMsg already left header space for the seal header.
//
if (m_SecurePort && !m_fNegotiatingSSL)
{
char *Buffer = &(m_pOutputBuffer[m_encryptCtx.GetSealHeaderSize()]);
RetStatus = m_encryptCtx.SealMessage(
(UCHAR *) Buffer,
m_OutputBufferSize,
(UCHAR *) m_pOutputBuffer,
&cbMessage);
}
if (RetStatus) {
RetStatus = CLIENT_CONNECTION::WriteFile(m_pOutputBuffer, cbMessage);
}
if(RetStatus)
{
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentTotal, cbMessage);
AddCommandBytesSent(cbMessage);
}
else
{
DebugTrace((LPARAM) this, "WriteFile failed with error %d", GetLastError());
}
m_OutputBufferSize = 0;
}
//DecPendingIoCount();
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
BOOL SMTP_CONNECTION::WriteMailFile(char * Buffer, DWORD BuffSize, BOOL *lpfWritePended)
{
BOOL fResult = FALSE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::WriteMailFileBuffer");
if(!BuffSize && !Buffer)
{
//Simply flush the buffers if we have something to flush
if(!m_cbCurrentWriteBuffer)
{//Aynsc WRITE succeeded. Let this thread go thru - atq will call back
*lpfWritePended = FALSE;
return TRUE;
}
if(!WriteMailFileAtq((char*)m_pFileWriteBuffer->GetData(), m_cbCurrentWriteBuffer, NONBLOCKING))
{
m_MailBodyError = GetLastError();
ErrorTrace((LPARAM) this, "Async Write of to mail file failed : %d",m_MailBodyError);
fResult = FALSE;
}
else
{
//Aynsc WRITE succeeded. Let this thread go thru - atq will call back
*lpfWritePended = TRUE;
fResult = TRUE;
}
TraceFunctLeaveEx((LPARAM) this);
return fResult;
}
//If the data to be written can fit in we take it in and come back
//else we pend a write
//Though the var name is a result of its original use, we now use this
//buffer as a WRITEFILE buffer
if(m_cbCurrentWriteBuffer + BuffSize > SMTP_WRITE_BUFFER_SIZE)
{
//Update the input buffers so that we can
//go back and start processing the input buffers
//after the async WRITE completes
//MoveMemory ((void *)QueryMRcvBuffer(), Buffer, m_cbReceived);
if(!WriteMailFileAtq((char*)m_pFileWriteBuffer->GetData(), m_cbCurrentWriteBuffer, NONBLOCKING))
{
*lpfWritePended = FALSE;
m_MailBodyError = GetLastError();
ErrorTrace((LPARAM) this, "Async Write of to mail file failed : %d",m_MailBodyError);
fResult = FALSE;
}
else
{
//Aynsc WRITE succeeded. Let this thread go thru - atq will call back
*lpfWritePended = TRUE;
fResult = TRUE;
}
}
//Copy the data into the buffer only if we have the space to do so
else
{
CopyMemory((m_pFileWriteBuffer->GetData() + m_cbCurrentWriteBuffer),Buffer,BuffSize);
m_cbCurrentWriteBuffer += BuffSize;
fResult = TRUE;
}
TraceFunctLeaveEx((LPARAM) this);
return fResult;
}
/*++
Name:
SMTP_CONNECTION::WriteMailFileAtq
Description:
While chunking, once header parsing is done the data is
dumped to the disk asynchronously using WriteMailFileAtq( )
Arguments:
None.
Returns:
TRUE if successfully pended a write to the file, FALSE otherwise
--*/
BOOL SMTP_CONNECTION::WriteMailFileAtq(char * InputLine, DWORD dwBytesToWrite, DWORD dwIoMode)
{
TraceFunctEnterEx( (LPARAM)this, "SMTP_CONNECTION::WriteMailFileAtq");
DebugTrace( (LPARAM)this, "WriteFile 0x%08X, len: %d, LPO: 0x%08X",
InputLine,
dwBytesToWrite,
m_FileOverLapped.SeoOverlapped );
//ZeroMemory( (void*)&m_FileOverLapped, sizeof(OVERLAPPED) );
//if(dwIoMode == BLOCKING)
// m_FileOverLapped.SeoOverlapped.Overlapped.hEvent = (HANDLE)1;
m_FileOverLapped.SeoOverlapped.Overlapped.Offset = m_CurrentOffset;
m_FileOverLapped.m_LastIoState = WRITEFILEIO;
m_FileOverLapped.m_cbIoSize = dwBytesToWrite;
m_FileOverLapped.m_pIoBuffer = (LPBYTE)InputLine;
//
// increment the overall pending io count for this session
//
IncPendingIoCount();
_ASSERT(m_FileOverLapped.SeoOverlapped.Overlapped.pfnCompletion != NULL);
m_FileOverLapped.SeoOverlapped.ThisPtr = this;
if (FIOWriteFile(m_IMsgHandle,
InputLine,
dwBytesToWrite,
&(m_FileOverLapped.SeoOverlapped.Overlapped)) == FALSE)
#if 0
if ( AtqWriteFile(m_pAtqFileContext,
InputLine,
dwBytesToWrite,
(OVERLAPPED *) &(m_FileOverLapped.SeoOverlapped.Overlapped) ) == FALSE)
#endif
{
DecPendingIoCount();
ErrorTrace( (LPARAM)this, "AtqWriteFile failed.");
}
else
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
ErrorTrace( (LPARAM)this, "WriteMailFileAtq failed. err: %d", GetLastError() );
if(!HandleInternalError(GetLastError()))
DisconnectClient();
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
/*++
Name:
SMTP_CONNECTION::HandleInternalError
Description:
Contains code to handle common error conditions during inbound message flow.
Arguments:
[IN] DWORD Error code
Returns:
TRUE if error was handled
FALSE otherwise
--*/
BOOL SMTP_CONNECTION::HandleInternalError(DWORD dwErr)
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::HandleInternalError");
if(dwErr == ERROR_DISK_FULL)
{
FormatSmtpMessage(SMTP_RESP_NORESOURCES, ENO_RESOURCES, " Unable to accept message because the server is out of disk space.\r\n");
ErrorTrace((LPARAM) this, "Rejecting message: Out of disk space");
SendSmtpResponse();
DisconnectClient();
return TRUE;
}
return FALSE;
}
#if 0
/*++
Name :
SMTP_CONNECTION::FreeAtqFileContext
Description :
Frees AtqContext associated with message file used for doing async writes
in case of chunking.
Arguments :
None. Operates on m_pAtqFileContext
Returns :
Nothing
--*/
void SMTP_CONNECTION::FreeAtqFileContext( void )
{
PFIO_CONTEXT pFIO;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::FreeAtqFileContext");
pFIO = (PATQ_CONTEXT)InterlockedExchangePointer( (PVOID *)&m_pIMsgHandle, NULL );
if ( pFIO != NULL )
{
DebugTrace((LPARAM) this, "Freeing AtqFileContext!");
ReleaseContext(pFIO);
}
TraceFunctLeaveEx((LPARAM) this);
}
#endif
void SMTP_CONNECTION::ReInitClassVariables(void)
{
_ASSERT (m_pInstance != NULL);
//reset all variables to their initial state
m_HeaderFlags = 0;
m_TotalMsgSize = 0;
m_cbDotStrippedTotalMsgSize = 0;
m_CurrentOffset = 0;
m_State = HELO;
m_RecvdMailCmd = FALSE;
m_InHeader = TRUE;
m_LongBodyLine = FALSE;
m_fFoundEmbeddedCrlfDotCrlf = FALSE;
m_fScannedForCrlfDotCrlf = FALSE;
m_fSeenRFC822FromAddress = FALSE;
m_fSeenRFC822ToAddress = FALSE;
m_fSeenRFC822CcAddress = FALSE;
m_fSeenRFC822BccAddress = FALSE;
m_fSeenRFC822Subject = FALSE;
m_fSeenRFC822MsgId = FALSE;
m_fSeenXPriority = FALSE;
m_fSeenXOriginalArrivalTime = FALSE;
m_fSeenContentType = FALSE;
m_fSetContentType = FALSE;
m_fSeenRFC822SenderAddress = FALSE;
m_TimeToRewriteHeader = TRUE;
m_MailBodyError = NO_ERROR;
m_RecvdRcptCmd = FALSE;
m_WritingData = FALSE;
m_fIsLastChunk = FALSE;
m_fIsBinaryMime = FALSE;
m_fIsChunkComplete = FALSE;
m_dwTrailerStatus = CRLF_SEEN;
m_nChunkSize = 0;
m_nBytesRemainingInChunk = 0;
m_MailBodyDiagnostic = ERR_NONE;
m_cbCurrentWriteBuffer = 0;
m_cbRecvBufferOffset = 0;
m_fAsyncEOD = FALSE;
m_LineCompletionState = SEEN_NOTHING;
m_Truncate = FALSE;
m_BufrWasFull = FALSE;
m_fBufferFullInBDAT = FALSE;
//Clear the senders address if it's
//still there.
m_szFromAddress[0] = '\0';
ReleasImsg(TRUE);
}
/*++
Name :
SMTP_CONNECTION::SmtpGetCommand
Description:
This function determines which SMTP input command was sent
by the client
Arguments:
Request - Buffer the client sent
RequestLen - Length of the buffer
Returns:
Index into our array of function pointers
--*/
int SMTP_CONNECTION::SmtpGetCommand(const char * Request, DWORD RequestLen, LPDWORD CmdSize)
{
DWORD Loop = 0;
char Cmd[SMTP_MAX_COMMANDLINE_LEN];
char * ptr = NULL;
char *psearch = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::SmtpGetCommand");
//start out with no errors
CommandErrorType = SMTP_COMMAND_NOERROR;
//we will copy the command into Cmd starting from
//the beginning
ptr = Cmd;
//start looking for the space from the beginning
//of the buffer
psearch = (char *) Request;
//search for the command and copy it into Cmd. We stop
//looking when we encounter the first space.
while (*psearch != '\0' && !isspace ((UCHAR) *psearch) && ptr < &Cmd[SMTP_MAX_COMMANDLINE_LEN - 2])
*ptr++ = *psearch++;
//null terminate the buffer
*ptr = '\0';
//now, look through the list of SMTP commands
//and compare it to what the client gave us.
while (SmtpCommands[Loop] != NULL)
{
if (!::strcasecmp((char *) Cmd, (char * )SmtpCommands[Loop]))
{
goto Exit;
}
Loop++;
}
//set error to COMMAND_NOT FOUND if we do not recognize the command
CommandErrorType = SMTP_COMMAND_NOT_FOUND;
Exit:
//If no error, send back the index in the array
//If there was an error, send back the index of
//the last element in the array. This is our
//catch all error function.
if (CommandErrorType == SMTP_COMMAND_NOERROR)
{
*CmdSize = DWORD (ptr - Cmd);
TraceFunctLeaveEx((LPARAM) this);
return Loop;
}
else
{
//
// This is not always an error since a protocol sink may be installed
//
DebugTrace((LPARAM) this, "Native command %s was not found in command table", Cmd);
TraceFunctLeaveEx((LPARAM) this);
return (DWORD) LAST_SMTP_STATE;
}
}
/*++
Name :
SMTP_CONNECTION::FormatSmtpMessage( IN const char * Format, ...)
Description:
This function will build a sting in the output buffer with
the given input parameters. If the new data cannot fit in the
buffer, this function will send whatever data is in the buffer,
then build the string.
Arguments:
String to send
Returns:
TRUE if response was queued
--*/
BOOL SMTP_CONNECTION::FormatSmtpMessage(DWORD dwCode, const char * szEnhancedCodes, IN const char * Format, ...)
{
int BytesWritten;
va_list arglist;
char *Buffer;
DWORD AvailableBytes;
DWORD HeaderOffset = (m_SecurePort ? m_encryptCtx.GetSealHeaderSize() : 0);
DWORD SealOverhead = (m_SecurePort ?
(m_encryptCtx.GetSealHeaderSize() +
m_encryptCtx.GetSealTrailerSize()) : 0);
char RealFormat[MAX_PATH];
RealFormat[0] = '\0';
//If we get passed dwCode we use it
//If we get passed enhance status code only if we advertise them
//
if(dwCode)
{
if(m_pInstance->AllowEnhancedCodes() && szEnhancedCodes)
{
sprintf(RealFormat,"%d %s",dwCode,szEnhancedCodes);
}
else
sprintf(RealFormat,"%d",dwCode);
}
strcat(RealFormat,Format);
Buffer = &(m_pOutputBuffer[m_OutputBufferSize + HeaderOffset]);
AvailableBytes = m_cbMaxOutputBuffer - m_OutputBufferSize - SealOverhead;
//if BytesWritten is < 0, that means there is no space
//left in the buffer. Therefore, we flush any pending
//responses to make space. Then we try to place the
//information in the buffer again. It should never
//fail this time.
va_start (arglist, Format);
BytesWritten = _vsnprintf (Buffer, AvailableBytes, (const char *)RealFormat, arglist);
if(BytesWritten < 0)
{
//flush any pending response
SendSmtpResponse();
_ASSERT (m_OutputBufferSize == 0);
Buffer = &m_pOutputBuffer[HeaderOffset];
AvailableBytes = m_cbMaxOutputBuffer - SealOverhead;
BytesWritten = _vsnprintf (Buffer, AvailableBytes, Format, arglist);
_ASSERT (BytesWritten > 0);
}
va_end(arglist);
m_OutputBufferSize += (DWORD) BytesWritten;
//m_OutputBufferSize += vsprintf (&m_pOutputBuffer[m_OutputBufferSize], Format, arglist);
return TRUE;
}
BOOL SMTP_CONNECTION::FormatSmtpMessage(unsigned char *DataBuffer, DWORD dwBytes)
{
int BytesWritten = 0;
char *Buffer;
DWORD AvailableBytes = 0;
DWORD HeaderOffset = (m_SecurePort ? m_encryptCtx.GetSealHeaderSize() : 0);
DWORD SealOverhead = (m_SecurePort ?
(m_encryptCtx.GetSealHeaderSize() +
m_encryptCtx.GetSealTrailerSize()) : 0);
Buffer = &(m_pOutputBuffer[m_OutputBufferSize + HeaderOffset]);
AvailableBytes = m_cbMaxOutputBuffer - m_OutputBufferSize - SealOverhead;
//if BytesWritten is < 0, that means there is no space
//left in the buffer. Therefore, we flush any pending
//responses to make space. Then we try to place the
//information in the buffer again. It should never
//fail this time.
if( dwBytes + 2 < AvailableBytes)//+2 for CRLF
{
CopyMemory(Buffer, DataBuffer, dwBytes);
Buffer[dwBytes] = '\r';
Buffer[dwBytes + 1] = '\n';
BytesWritten = dwBytes + 2;
}
else
{
//flush any pending response
SendSmtpResponse();
_ASSERT (m_OutputBufferSize == 0);
Buffer = &m_pOutputBuffer[HeaderOffset];
AvailableBytes = max(dwBytes, m_cbMaxOutputBuffer - SealOverhead - 2);
CopyMemory(Buffer, DataBuffer, AvailableBytes);
Buffer[dwBytes] = '\r';
Buffer[dwBytes + 1] = '\n';
BytesWritten = dwBytes + 2;
_ASSERT (BytesWritten > 0);
}
m_OutputBufferSize += (DWORD) BytesWritten;
return TRUE;
}
BOOL SMTP_CONNECTION::PE_FastFormatSmtpMessage(LPSTR pszBuffer, DWORD dwBytes)
{
LPSTR Buffer;
DWORD BytesWritten = 0;
DWORD AvailableBytes = 0;
DWORD HeaderOffset = (m_SecurePort ? m_encryptCtx.GetSealHeaderSize() : 0);
DWORD SealOverhead = (m_SecurePort ?
(m_encryptCtx.GetSealHeaderSize() +
m_encryptCtx.GetSealTrailerSize()) : 0);
Buffer = &(m_pOutputBuffer[m_OutputBufferSize + HeaderOffset]);
AvailableBytes = m_cbMaxOutputBuffer - m_OutputBufferSize - SealOverhead;
// Write as many buffers as we need to
while (BytesWritten < dwBytes)
{
if ((dwBytes - BytesWritten) <= AvailableBytes)
{
CopyMemory(Buffer, pszBuffer, dwBytes - BytesWritten);
m_OutputBufferSize += (dwBytes - BytesWritten);
BytesWritten = dwBytes; // BytesWritten += (dwBytes - BytesWritten)
}
else
{
// We don't have enough buffer space, so write whatever we have left
CopyMemory(Buffer, pszBuffer, AvailableBytes);
BytesWritten += AvailableBytes;
m_OutputBufferSize += AvailableBytes;
pszBuffer += AvailableBytes;
//flush any pending response
SendSmtpResponse();
_ASSERT (m_OutputBufferSize == 0);
Buffer = &m_pOutputBuffer[HeaderOffset];
AvailableBytes = m_cbMaxOutputBuffer - SealOverhead;
}
}
return(TRUE);
}
BOOL SMTP_CONNECTION::DoesClientHaveIpAccess()
{
AC_RESULT acIpAccess;
ADDRESS_CHECK acAccessCheck;
METADATA_REF_HANDLER rfAccessCheck;
BOOL fNeedDnsCheck = FALSE;
BOOL fRet = TRUE;
struct hostent* pH = NULL;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::DoesClientHaveIpAccess");
m_pInstance->LockGenCrit();
acAccessCheck.BindAddr( (PSOCKADDR)&m_saClient );
if ( !rfAccessCheck.CopyFrom( m_pInstance->QueryRelayMetaDataRefHandler() ) )
{
m_pInstance->UnLockGenCrit();
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
m_pInstance->UnLockGenCrit();
acAccessCheck.BindCheckList( (LPBYTE)rfAccessCheck.GetPtr(), rfAccessCheck.GetSize() );
acIpAccess = acAccessCheck.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)(&m_saClient))->sin_addr),
4, PF_INET );
if(pH != NULL)
{
acIpAccess = acAccessCheck.CheckName(pH->h_name);
}
else
{
acIpAccess = AC_IN_DENY_LIST;
}
}
if ( (acIpAccess == AC_IN_DENY_LIST) ||
(acIpAccess == AC_NOT_IN_GRANT_LIST))
{
fRet = FALSE;
}
acAccessCheck.UnbindCheckList();
rfAccessCheck.Reset( (IMDCOM*) g_pInetSvc->QueryMDObject() );
if(!fRet)
{
SetLastError(ERROR_ACCESS_DENIED);
}
TraceFunctLeaveEx((LPARAM)this);
return fRet;
}
/*++
Name :
SMTP_CONNECTION::ProcessReadIO
Description:
This function gets a buffer from ATQ, parses the buffer to
find out what command the client sent, then executes that
cammnd.
Arguments:
InputBufferLen - Number of bytes that was written
dwCompletionStatus -Holds error code from ATQ, if any
lpo - Pointer to overlapped structure
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::ProcessReadIO(IN DWORD InputBufferLen,
IN DWORD dwCompletionStatus,
IN OUT OVERLAPPED * lpo)
{
BOOL fReturn = TRUE;
const char * InputLine;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessReadIO");
_ASSERT (m_pInstance != NULL);
m_cbReceived += InputBufferLen;
// Firewall against bugs where we overflow the read buffer
if(m_cbReceived > QueryMaxReadSize())
{
DisconnectClient();
_ASSERT(0 && "Buffer overflow");
return FALSE;
}
InputLine = QueryMRcvBuffer();
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesRcvdTotal, InputBufferLen);
if (!m_fNegotiatingSSL)
{
if (m_SecurePort)
{
fReturn = DecryptInputBuffer();
}
else
{
m_cbParsable = m_cbReceived;
m_SessionSize += InputBufferLen;
}
if (fReturn)
{
fReturn = ProcessInputBuffer();
}
}
else // negotiating SSL
{
//
// If we are still doing the handshake let CEncryptCtx::Converse handle it.
// Converse returns in the following situations:
//
// o The negotiation succeeded. cbExtra returns the number of bytes that
// were not consumed by the SSL handshake. These bytes are "application
// data" which should be decrypted and processed by the SMTP protocol.
//
// o The negotiation failed. The connection will be dropped.
//
// o More data is needed from the client to complete the negotiation. A
// read should be posted.
//
DWORD dw;
BOOL fMore;
DWORD dwBytes = MAX_SSL_FRAGMENT_SIZE;
BOOL fApplicationDataAvailable = FALSE;
DWORD cbExtra = 0;
dw = m_encryptCtx.Converse( (LPVOID) InputLine,
m_cbReceived,
(PUCHAR) m_pOutputBuffer,
&dwBytes,
&fMore,
(LPSTR) QueryLocalHostName(),
(LPSTR) QueryLocalPortName(),
(LPVOID) QuerySmtpInstance(),
QuerySmtpInstance()->QueryInstanceId(),
&cbExtra
);
if ( dw == NO_ERROR )
{
//
// reset the read buffer
//
if ( cbExtra )
{
fApplicationDataAvailable = TRUE;
MoveMemory( (PVOID)InputLine, InputLine + (m_cbReceived - cbExtra), cbExtra );
}
m_cbReceived = cbExtra;
//
// send any bytes required for the client
//
if ( dwBytes != 0 )
{
WriteFile( m_pOutputBuffer, dwBytes );
}
if ( fMore )
{
//
// more handshaking required - repost the read
//
_ASSERT( dwBytes != 0 );
}
else
{
//
// completed negotiation. Turn off the flag indicating thats
// what we are doing
//
m_fNegotiatingSSL = FALSE;
}
}
else if ( dw == SEC_E_INCOMPLETE_MESSAGE )
{
//
// haven't received the full packet from the client
//
_ASSERT( dwBytes == 0 );
}
else
{
ErrorTrace((LPARAM)this, "SSL handshake failed, Error = %d", dw);
DisconnectClient( dw );
fReturn = FALSE;
}
if ( fApplicationDataAvailable )
{
//
// Application data is already available, no need to post a read
//
fReturn = DecryptInputBuffer();
if ( fReturn )
fReturn = ProcessInputBuffer();
}
else if (fReturn)
{
//
// If we are continuing, we need to post a read
//
_ASSERT (m_cbReceived < QueryMaxReadSize() );
IncPendingIoCount();
m_LastClientIo = READIO;
fReturn = ReadFile( QueryMRcvBuffer() + m_cbReceived,
QueryMaxReadSize() - m_cbReceived );
if (!fReturn)
{
DisconnectClient();
DecPendingIoCount();
}
}
else
{
m_CInboundContext.SetWin32Status(dw);
ProtocolLog(STARTTLS, (char *) QueryClientUserName(), dw, SMTP_RESP_BAD_SEQ, 0, 0);
}
}
return( fReturn );
}
/*++
Name :
SMTP_CONNECTION::ProcessFileWrite
Description:
Handles completion of an async Write issued against a message file by
WriteMailFileAtq
Arguments:
cbRead count of bytes read
dwCompletionStatus Error code for IO operation
lpo Overlapped structure
Returns:
TRUE if connection should stay open
FALSE if this object should be deleted
--*/
BOOL SMTP_CONNECTION::ProcessFileWrite(
IN DWORD BytesWritten,
IN DWORD dwCompletionStatus,
IN OUT OVERLAPPED *lpo
)
{
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::ProcessFileWrite");
SMTPCLI_FILE_OVERLAPPED * lpFileOverlapped;
_ASSERT(lpo);
lpFileOverlapped = (SMTPCLI_FILE_OVERLAPPED*)lpo;
// In case of async Write to disk file, a successsful completion
// will always mean all the data has been written out
// Check for partial completions or errors
// and Disconnect if something failed
if( BytesWritten != lpFileOverlapped->m_cbIoSize || dwCompletionStatus != NO_ERROR )
{
ErrorTrace( (LPARAM)this,
"Message WriteFile error: %d, bytes %d, expected %d",
dwCompletionStatus,
BytesWritten,
lpFileOverlapped->m_cbIoSize );
//Close the file Handle and disconnect the client
DisconnectClient();
return( FALSE );
}
else
{
DebugTrace( (LPARAM)this,
"WriteFile complete. bytes %d, lpo: 0x%08X",
BytesWritten, lpo );
}
m_CurrentOffset += BytesWritten;
//We write out of the Write buffer
//We need throw away the data that was written out and
//move the remaining data to the start of the buffer
// if(m_cbReceived)
// MoveMemory ((void *)QueryMRcvBuffer(), (void *)(QueryMRcvBuffer() + BytesWritten), m_cbReceived);
m_cbCurrentWriteBuffer = 0;
//Time to go back and process the remaining data in the buffer
//Adjust the buffer for the next read only in case of Sync write
return(ProcessInputBuffer());
}
BOOL SMTP_CONNECTION::PendReadIO(DWORD UndecryptedTailSize)
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::PendReadIO");
BOOL fReturn = TRUE;
m_LastClientIo = READIO;
m_cbReceived = m_cbParsable + UndecryptedTailSize;
_ASSERT (m_cbReceived < QueryMaxReadSize());
//increment this IO
IncPendingIoCount();
fReturn = ReadFile(QueryMRcvBuffer() + m_cbReceived, QueryMaxReadSize() - m_cbReceived);
if(!fReturn)
{
DecPendingIoCount();
DisconnectClient();
}
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
/*++
Name :
SMTP_CONNECTION::ProcessInputBuffer
Description:
This function takes the receive buffer, parses the buffer to
find out what command the client sent, then executes that
command.
Arguments:
lpfMailQueued -- On return, TRUE if processing the client command
caused a mail message to be queued.
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::ProcessInputBuffer(void)
{
BOOL fReturn = TRUE;
const char * InputLine;
DWORD UndecryptedTailSize = m_cbReceived - m_cbParsable;
BOOL fWritePended = FALSE;
BOOL fShouldImposeLimit = TRUE;
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessInputBuffer");
if(m_pInstance->GetMaxMsgSizeBeforeClose() > 0 &&
m_SessionSize > m_pInstance->GetMaxMsgSizeBeforeClose())
{
hr = m_pInstance->TriggerMaxMsgSizeEvent(
GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit );
if(FAILED(hr) || fShouldImposeLimit)
{
m_MailBodyError = ERROR_ALLOTTED_SPACE_EXCEEDED;
ErrorTrace((LPARAM) this,
"SMTP_RESP_NOSTORAGE, SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG - %d",
m_SessionSize);
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
m_cbParsable = 0;
m_cbReceived = 0;
// Client won't be expecting this, but atleast an admin can tell
// what's wrong from this response.
FormatSmtpMessage(SMTP_RESP_NOSTORAGE, ENO_RESOURCES," %s\r\n",
SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG);
SendSmtpResponse();
DisconnectClient();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
//Start processing at the point after the temporary BDAT chunk
InputLine = QueryMRcvBuffer() + m_cbTempBDATLen + m_cbRecvBufferOffset;
if ( TRUE == m_fPeBlobReady) {
fReturn = ProcessPeBlob( InputLine, m_cbParsable);
if ( FALSE == fReturn) {
TraceFunctLeaveEx( ( LPARAM) this);
return FALSE;
}
MoveMemory ( ( void *) QueryMRcvBuffer(), InputLine + m_cbParsable, UndecryptedTailSize);
m_cbParsable = 0;
m_cbReceived = UndecryptedTailSize;
// always pend a read in this state regardless of previous fReturn
fReturn = PendReadIO( UndecryptedTailSize);
TraceFunctLeaveEx( ( LPARAM) this);
return fReturn;
}
if (m_State == DATA)
{
BOOL fAsyncOp = FALSE;
fReturn = ProcessDATAMailBody(InputLine, UndecryptedTailSize, &fAsyncOp);
if(!fReturn || fAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//
// There is additional data pipelined behind the mailbody. DoDATACommandEx
// moves this to the beginning of the input buffer after processing the
// mail body, so the place to begin parsing is m_pRecvBuffer.
//
InputLine = QueryMRcvBuffer();
_ASSERT(m_State == HELO);
}
PROCESS_BDAT:
if(m_State == BDAT && !m_fIsChunkComplete)
{
BOOL fAsyncOp = FALSE;
fReturn = ProcessBDATMailBody(InputLine, UndecryptedTailSize, &fAsyncOp);
if(!fReturn || fAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//
// All the mailbody was processed and the input buffer points to the
// next SMTP command after readjusting for any *saved* BDAT data (If a
// header spans 2 chunks, ProcessBDAT will save the partial header from
// the previous chunk till it can complete it using the next chunk.
// m_cbTempBdatLen represents the number of saved bytes)
//
InputLine = QueryMRcvBuffer() + m_cbTempBDATLen;
}
else if(m_State == AUTH)
{
fReturn = DoAuthNegotiation(InputLine, m_cbParsable);
if(!fReturn)
{
++m_ProtocolErrors;
}
if(m_State == AUTH)
{
fReturn = PendReadIO(UndecryptedTailSize);
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
}
_ASSERT(m_State != DATA);
PCHAR pszSearch;
DWORD IntermediateSize;
DWORD CmdSize = 0;
//if we got here, then a read completed. Process the
//entire buffer before returning(Pipelining).
//use to be while ((pszSearch = strstr(QueryRcvBuffer(), CRLF)) != NULL)
//Reset the the offset ptr into the recv buffer
//we use this to keeo track of where to continue processing from
m_cbRecvBufferOffset = 0;
BOOL fAsyncOp = FALSE;
while ((pszSearch = IsLineComplete(InputLine,m_cbParsable - m_cbTempBDATLen)) != NULL)
{
//Null terminate the end of the command
*pszSearch = '\0';
IntermediateSize = (DWORD)(pszSearch - InputLine);
StartProcessingTimer();
ResetCommandCounters();
SetCommandBytesRecv( IntermediateSize );
if(!SmtpParseCompleteCommand((PCHAR)InputLine, pszSearch, IntermediateSize, &CmdSize))
{
ErrorTrace((LPARAM)this, "Discarding illegal SMTP command");
continue;
}
// we might run into a sink that does async operations
// So update state data that the async thread could see
m_cbRecvBufferOffset += (DWORD)(pszSearch - (QueryMRcvBuffer() + m_cbTempBDATLen) + 2);
m_cbParsable -= (IntermediateSize + 2);
m_cbReceived = m_cbParsable + UndecryptedTailSize;
// before firing each command load any session properties from ISession
HrGetISessionProperties();
//
// Increment the pending IO count in case this returns async
//
IncPendingIoCount();
fReturn = GlueDispatch((char *)InputLine, IntermediateSize, CmdSize, &fAsyncOp);
//
// Assert check that fAsyncOp isn't true when GlueDispatch fails
//
_ASSERT( (!fAsyncOp) || fReturn );
if(!fAsyncOp)
{
//
// Decrement the pending IO count since GlueDispatch
// returned sync (and we incremented the count above).
// ProcessClient is above us in the callstack and always has a
// pending IO reference, so this should never return zero
//
_VERIFY(DecPendingIoCount() > 0);
}
if (fReturn == TRUE && fAsyncOp)
{
//We returned from Dispatcher because some sink did an async operation
//We need to simply leave. The thread on which the async operation completes
//will continue with the sink firing. The dispacther will keep the context
//which will allow it to do so..
//So as to keep the connection alive - bump up the ref count
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// log this command and the response
if (m_State != DATA &&
m_State != BDAT &&
m_State != AUTH &&
m_State != QUIT &&
m_dwCurrentCommand != DATA &&
m_dwCurrentCommand != BDAT &&
m_dwCurrentCommand != AUTH &&
m_dwCurrentCommand != QUIT)
{
const char *pszCommand = SmtpCommands[m_dwCurrentCommand];
DWORD cCmd = (pszCommand) ? strlen(pszCommand) : 0;
ProtocolLog(m_dwCurrentCommand,
InputLine + cCmd,
m_CInboundContext.m_dwWin32Status,
m_CInboundContext.m_dwSmtpStatus,
0,
0);
}
if (fReturn == TRUE)
{
//All Sinks completed synchronously
m_cbRecvBufferOffset = 0;
InputLine = pszSearch + 2; //skip CRLF
if(m_State != DATA && m_State != BDAT)
{
continue;
}
else if (m_State == BDAT && m_fIsLastChunk && m_nChunkSize == 0)
{
// The BDAT RFC allows the last chunk to be zero-sized. This
// should indicate that the message is done. However no chunk
// data is left to be parsed (so m_cbParsable *may* be 0 and if
// nonzero, it indicates pipelined SMTP commands after the zero
// byte BDAT chunk).
goto PROCESS_BDAT;
}
else if (m_State == BDAT && m_cbParsable)
{
//We are in BDAT mode and there is some data that can be parsed
MoveMemory ((void *)(QueryMRcvBuffer() + m_cbTempBDATLen), InputLine, m_cbReceived - m_cbTempBDATLen );
InputLine = QueryMRcvBuffer();
goto PROCESS_BDAT;
}
else
{
break; // no more data
}
}
else
{
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}//end if(fReturn == TRUE)
}//end while
// if IsLineComplete failed because we passed in a negative length
// than drop the session. something is corrupt
if ((int) m_cbParsable - (int) m_cbTempBDATLen < 0) {
DisconnectClient();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
_ASSERT(m_cbReceived <= QueryMaxReadSize());
//
// If there is additional data left at the end of the buffer move it to the
// beginning - clearing out already processed data.
//
if(m_cbParsable != 0 && // Additional data in buffer?
(QueryMRcvBuffer() + m_cbTempBDATLen != InputLine)) // Is MoveMemory needed?
{
MoveMemory ((void *)(QueryMRcvBuffer() + m_cbTempBDATLen),
InputLine, m_cbParsable+UndecryptedTailSize-m_cbTempBDATLen);
}
SendSmtpResponse();
m_cbReceived = m_cbParsable + UndecryptedTailSize;
//
// Bad input from the client can cause us to fill up the buffer
// completely. We can neither process the data available to us already
// because it is incomplete, nor attempt to complete it by posting more
// reads on the socket, because we do not have any more space. A well
// behaved server in such a situation should discard the data as it arrives
// and after all the data has been received, respond with an error. Note
// that legal input can never fill up the buffer because the buffer size
// used is large enough to accomodate all valid SMTP commands.
//
// This function checks for such situations, frees up buffer space when
// it detects such an error and transitions the session to an error state.
// If the recv-buffer is full, there was an error and we need to free
// some space to do error processing (see function description).
//
// m_cbReceived should never be > QueryMaxReadSize() - at most it is equal
// to QueryMaxReadSize(). The following if() is just defensive programming.
//
if(QueryMaxReadSize() <= m_cbReceived)
HandleFullRecvBuffer();
_ASSERT (m_cbReceived < QueryMaxReadSize());
//pend an I/O
IncPendingIoCount();
m_LastClientIo = READIO;
fReturn = ReadFile(QueryMRcvBuffer() + m_cbReceived, QueryMaxReadSize() - m_cbReceived);
if(!fReturn)
{
DisconnectClient();
DecPendingIoCount();
}
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//-----------------------------------------------------------------------------
// Description:
// Helper function for SMTP command parser. This is called when we have
// a complete CRLF terminated line available from the client. It is
// responsible for parsing the Input from the client and setting
// m_dwCurrentCommand to the command received.
//
// Arguments:
// IN CHAR *InputLine - Pointer to CRLF terminated buffer containing command
// IN CHAR *pszSearch - Pointer to CRLF that marks the end of the command
// IN ULONG IntermediateSize - Length of command, excluding CRLF
// IN ULONG UndecryptedTailSize - If using TLS, these bytes are encrypted
// OUT DWORD *pdwCmdSize - If command was successfully parsed (this function
// returned TRUE), this is initialized to the size of the command
// keyword (excluding arguments).
//
// Returns:
// TRUE - If command was successfully parsed. CmdSize will be initialized
// to the size of the SMTP keyword.
// FALSE - If the input was not recognized as a command. This function
// will format the appropriate error message and send it to the
// client.
//-----------------------------------------------------------------------------
BOOL SMTP_CONNECTION::SmtpParseCompleteCommand(
const CHAR *InputLine,
CHAR *pszSearch,
ULONG IntermediateSize,
DWORD *pdwCmdSize)
{
BOOL fReturn = FALSE;
DWORD UndecryptedTailSize = m_cbReceived - m_cbParsable;
DWORD dwError = 0;
LPSTR pszExtended = NULL;
LPSTR pszText = NULL;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::SmtpParseCompleteCommand");
//
// Blank lines are accepted for interoperability purposes. Some SMTP
// implementations append an extra CRLF to some SMTP commands. We will
// silently accept and ignore blank lines.
//
if (*InputLine == 0) {
MoveMemory((PVOID)InputLine, pszSearch + 2, m_cbReceived - m_cbTempBDATLen);
m_cbParsable -= IntermediateSize + 2;
m_cbReceived = m_cbParsable + UndecryptedTailSize;
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
//
// Excessively long command was received from client and we could not fit
// it in our input buffer. So the m_fBufferFull flag was set and the command
// bytes discarded (so that we could receive the end of line and respond
// with an error message).
//
if(m_fRecvBufferFull) {
m_fRecvBufferFull = FALSE;
dwError = SMTP_RESP_BAD_CMD;
pszExtended = (LPSTR) ESYNTAX_ERROR;
pszText = (LPSTR) SMTP_BAD_CMD_STR;
fReturn = FALSE;
goto Exit;
}
//
// Error case when an overly long SMTP command has to be discarded because
// there isn't enough space to hold it all in the buffer. Can happen while
// chunking (see where this member variable is set). In this situation, all
// bytes received are discarded without parsing, till a CRLF is encountered.
// Then IsLineComplete succeeds and we execute this if-statement.
//
if(m_fBufferFullInBDAT) {
m_fBufferFullInBDAT = FALSE;
dwError = SMTP_RESP_BAD_SEQ;
pszExtended = (LPSTR) ESYNTAX_ERROR;
pszText = (LPSTR) SMTP_BDAT_EXPECTED;
fReturn = FALSE;
goto Exit;
}
//
// SMTP events are fired upon the _EOD event and "_EOD" appears in the
// SmtpDispatchTable and SmtpCommands[] array. However it isn't an SMTP
// command. Ideally "_EOD" should never be returned from SmtpGetCommand,
// but the event firing mechanism is tied to "_EOD" as a string. So we
// firewall this case in the parser.
//
// Other strings unimplemented by SMTP should be handled by GlueDispatch
// which checks if SMTP sinks are registered to handle that string and
// fires events for that string. "_EOD" is the only string for which
// events must not be fired from the SMTP command parser.
//
if(!strncasecmp((char *)InputLine, "_EOD", sizeof("_EOD") - 1))
{
dwError = SMTP_RESP_BAD_CMD;
pszExtended = (LPSTR) ENOT_IMPLEMENTED;
pszText = (LPSTR) SMTP_BAD_CMD_STR;
fReturn = FALSE;
goto Exit;
}
m_dwCurrentCommand = SmtpGetCommand(InputLine, IntermediateSize, pdwCmdSize);
if(m_State == BDAT &&
m_dwCurrentCommand != BDAT &&
m_dwCurrentCommand != RSET &&
m_dwCurrentCommand != QUIT &&
m_dwCurrentCommand != NOOP)
{
dwError = SMTP_RESP_BAD_SEQ;
pszExtended = (LPSTR) ESYNTAX_ERROR;
pszText = (LPSTR) SMTP_BDAT_EXPECTED;
fReturn = FALSE;
goto Exit;
}
fReturn = TRUE;
Exit:
//
// Error detected during command parsing by one of the if-statements in this
// function. Discard the line containing the erroneous command (till the CRLF,
// which is at pszSearch) from the receive buffer, and return an error message,
// if one was set by the preceding if-statements, to the client.
//
if(!fReturn)
{
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
m_ProtocolErrors++;
MoveMemory((PVOID)InputLine, pszSearch + 2, m_cbReceived - m_cbTempBDATLen);
m_cbParsable -= IntermediateSize + 2;
m_cbReceived = m_cbParsable + UndecryptedTailSize;
if(0 != dwError && pszExtended && pszText)
{
PE_CdFormatSmtpMessage(dwError, pszExtended, " %s\r\n", pszText);
PE_SendSmtpResponse();
}
}
TraceFunctLeaveEx((LPARAM)this);
return fReturn;
}
//-----------------------------------------------------------------------------
// Description:
// Certain syntax errors by the client can result in the recv buffer being
// filled by with client input that does not contain CRLFs. Since SMTP
// processes line-by-line, it cannot process the data in the recv buffer
// which lacks CRLFs. It cannot receive additional data (that may contain
// the CRLFs) either, since the buffer is already full. This function
// detects such a state, switches over to an "error mode" and discards
// the received bytes to clear buffer space. Later, when the CRLF is
// received, and SMTP tries to parse the line (which is really a partial
// line, since we discarded the beginning of the line here), we will
// realize that we are in the "error-mode" and instead of parsing the
// partial line, we will discard it an respond with the appropriate error.
// Arguments:
// None.
// Returns:
// None.
// Notes:
// See SMTP_CONNECTION::SmtpParseCommand() for the rest of the processing
// done in "error-mode" when the CRLF is received.
//-----------------------------------------------------------------------------
void SMTP_CONNECTION::HandleFullRecvBuffer()
{
DWORD UndecryptedTailSize = m_cbReceived - m_cbParsable;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::HandleFullRecvBuffer");
_ASSERT(QueryMaxReadSize() == m_cbReceived);
//
// The receive buffer can fill up if we have more than QueryMaxReadSize()
// bytes in it that cannot be processed till more data is received from
// the client. This does not happen in the normal processing of SMTP
// commands, since each SMTP command is limited to 512 bytes, which can
// comfortably fit in the recv buffer.
//
// However, while processing BDAT, CreateMailBodyFromChunk may save the
// bytes of a partially received header line in the recv buffer by setting
// m_cbTempBDATLen > 0. For example, suppose the client is sending BDAT
// chunks, and the first chunk comprises of 500 bytes of data without a
// CRLF. In this case, SMTP cannot determine whether or not these 500
// bytes are part of a header. This is because unless the complete line
// has been received we cannot decide whether or not the line follows
// the header syntax. Therefore SMTP will save the 500 bytes by setting
// m_cbTempBDATLen == 500, and any bytes sent by the client will be
// appended at an offset of 500 in the recv buffer. When the next chunk
// arrives, SMTP will again try to process the 500 saved bytes + the
// bytes from the new chunk, as a complete header line.
//
// A client cannot fill up the buffer by sending thousands of bytes like
// this, without CRLFs, forcing SMTP to save the partial header. SMTP has
// a maximum limit on how long a header line can be (this is 1000 bytes).
// If this limit is exceeded, SMTP can determine that the line is not a
// syntactically correct header, and it does not have to wait for the
// terminating CRLF for the line so that it can parse the complete line
// according to header syntax.
//
// Thus it is impossible to occupy > 999 bytes of space as a saved BDAT
// partial header. However, even if we occupy the maximum possible 999
// bytes, the recv buffer (being sized 1024) will have only 26 bytes
// available for processing SMTP commands. This is clearly inadequate
// (in theory anyway) because SMTP commands have a max size of 512. In
// fact, we do not even have enough space to receive and reject illegal
// commands which can exceed 26 bytes (since a command-line must be
// completely received, till the terminating CRLF, before we can parse
// and reject it, in the ordinary course of things).
//
// Fortunately, during BDAT, the only commands allowed to be issued are
// all shorter than 26 bytes: BDAT, RSET and QUIT. We take advantage of
// this fact if we are caught in the "out of space" scenario, and the
// follwing if-statement sets m_fBufrFullInBDAT flag. When this flag is
// set, SMTP will discard every byte it receives from the client
// (following the saved m_cbTempBDATLen bytes) till a CRLF is received
// (note that the CRLF marks the end of the illegal SMTP command). Then
// SMTP responds with "BDAT expected" (see the command loop above) and
// resets the m_fBufrFullInBDAT flag to the normal state.
//
// Note that if the buffer is full, then m_cbTempBDATLen *must* be > 0.
// We only run out of recv buffer space during chunking. Thus the
// additional check for m_cbTempBDATLen > 0 in the following if-statement.
//
if(m_cbTempBDATLen > 0)
{
// Flag error so we know what response to generate when we do get CRLF
m_fBufferFullInBDAT = TRUE;
// Discard everything after the saved BDAT chunk except Undecrypted tail
PBYTE pbDiscardStart = (PBYTE) (QueryMRcvBuffer() + m_cbTempBDATLen);
PBYTE pbDiscardEnd = (PBYTE) (QueryMRcvBuffer() + m_cbParsable);
DWORD cbBytesToDiscard = m_cbParsable - m_cbTempBDATLen;
DWORD cbBytesToMove = UndecryptedTailSize;
// Keep CR if it's at the end. If the next packet has LF as the
// first byte we want to process the CRLF with IsLineComplete.
if(*(pbDiscardEnd - 1) == CR)
{
pbDiscardEnd--;
cbBytesToDiscard--;
cbBytesToMove++;
}
m_cbParsable -= cbBytesToDiscard;
m_cbReceived -= cbBytesToDiscard;
_ASSERT(pbDiscardEnd > pbDiscardStart);
MoveMemory((PVOID)pbDiscardStart, pbDiscardEnd, cbBytesToMove);
goto Exit;
}
//
// SMTP has a finite capacity to buffer data - QueryMaxReadSize() bytes
// at a time. So if the client sends a *very* long command that has no
// CRLFs in the first QueryMaxReadSize() bytes we cannot process that
// command. It is clearly an illegal command since SMTP commands are
// restricted to 512 bytes at the most.
//
// The error is handled by discarding all the command-bytes received so
// far, thus clearing space in the buffer. Then we can pend a read for
// the next batch of bytes before responding with "unrecognised command"
//
if(m_cbParsable > 0)
{
ErrorTrace((LPARAM)this, "Command too long, recv buffer full");
// We already handled (m_cbTempBDATLen > 0) in the previous 'if'
_ASSERT(m_cbTempBDATLen == 0);
// Flag error so we know what response to generate when we do get CRLF
m_fRecvBufferFull = TRUE;
int cbBytesToClear = m_cbParsable;
int cbBytesToMove = UndecryptedTailSize;
m_cbParsable = 0;
m_cbReceived = UndecryptedTailSize;
// If the last byte is CR, then an LF might be the first byte of the
// next packet. Save the last byte of this packet so that IsLineComplete
// will work in this situation.
if(*(QueryMRcvBuffer() + cbBytesToClear - 1) == '\r')
{
m_cbParsable = 1;
m_cbReceived = m_cbParsable + UndecryptedTailSize;
cbBytesToClear--;
cbBytesToMove++;
}
_ASSERT(cbBytesToClear > 0);
MoveMemory(QueryMRcvBuffer(), QueryMRcvBuffer() + cbBytesToClear,
cbBytesToMove);
goto Exit;
}
Exit:
_ASSERT(QueryMaxReadSize() > m_cbReceived);
TraceFunctLeaveEx((LPARAM)this);
return;
}
/*++
Name:
SMTP_CONNECTION::HrGetISessionProperties
Description:
A sink may set certain properties on the session
which should control SMTP behaviour, this function
pulls those properties from ISession and writes
them as session parameters (members of SMTP_CONNECTION)
Arguments:
None.
Returns:
HRESULT - Success or Error
If there isn't a sink or if a property was not
set by sink, an error may be returned.
--*/
HRESULT SMTP_CONNECTION::HrGetISessionProperties()
{
IMailMsgPropertyBag *pISessionProperties = NULL;
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::HrGetISessionProperties");
//
// This is for the EXPS (or any other) AUTH sink, which replaces SMTP
// authentication --- if the session is authenticated using the sink
// we should mark it as such. We pull the "AUTH" properties when we are
// about to process a command that is affected by the AUTH settings. We
// exclude commands like DATA and BDAT because they MUST have been
// preceded by MAIL, for which the AUTH setting would have already been
// checked.
//
if(!m_fAuthenticated &&
(m_dwCurrentCommand == MAIL ||
m_dwCurrentCommand == TURN ||
m_dwCurrentCommand == ETRN ||
m_dwCurrentCommand == VRFY ||
m_dwCurrentCommand == HELP))
{
pISessionProperties = (IMailMsgPropertyBag *)GetSessionPropertyBag();
//
// Usage of ISESSION_PID_IS_SESSION_AUTHENTICATED property: The AUTH
// sink sets this to TRUE when a successful authentication occurs.
//
hr = pISessionProperties->GetBool(
ISESSION_PID_IS_SESSION_AUTHENTICATED,
(DWORD *) &m_fAuthenticated);
if(FAILED(hr))
{
DebugTrace((LPARAM)this, "Can't get authenticated property for Session. hr - %08x", hr);
hr = S_OK;
goto Exit;
}
hr = pISessionProperties->GetStringA(
ISESSION_PID_AUTHENTICATED_USERNAME,
sizeof(m_szAuthenticatedUserNameFromSink),
m_szAuthenticatedUserNameFromSink);
if(FAILED(hr))
{
m_szAuthenticatedUserNameFromSink[0] = '\0';
DebugTrace((LPARAM)this, "Can't get username for Session. hr - %08x", hr);
hr = S_OK;
}
//
// Protocol sinks may set ISESSION_PID_MAY_RELAY if the authenticated
// user is permitted to relay even if the ip checks fail and "Allow all
// authenticated users to relay" isn't checked.
//
hr = pISessionProperties->GetBool(
ISESSION_PID_MAY_RELAY,
(DWORD *) &m_fMayRelay);
if(FAILED(hr)) {
m_fMayRelay = FALSE;
if (hr != MAILMSG_E_PROPNOTFOUND)
DebugTrace((LPARAM)this, "Can't get May Relay for Session. hr - %08x", hr);
hr = S_OK;
}
}
Exit:
TraceFunctLeaveEx((LPARAM)this);
return hr;
}
/*++
Description:
This function is called set BOOL properties in the ISession property
bag that must be advertised to protocol sinks.
Arguments:
dwPropId - Propid to set
pvValue - Value of property
Returns:
Success HRESULT if the property was set.
E_FAIL if no ISession pointer exists.
Error HRESULT on other failures.
--*/
HRESULT SMTP_CONNECTION::HrSetISessionProperty(DWORD dwPropId, BOOL fValue)
{
IMailMsgPropertyBag *pISessionProperties = NULL;
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::HrSetISessionProperty");
pISessionProperties = (IMailMsgPropertyBag *) GetSessionPropertyBag();
if(!pISessionProperties) {
_ASSERT(0 && "No ISession props!");
TraceFunctLeaveEx((LPARAM) this);
return E_FAIL;
}
hr = pISessionProperties->PutBool(dwPropId, fValue);
TraceFunctLeaveEx((LPARAM) this);
return hr;
}
/*++
Name :
SMTP_CONNECTION::ProcessClient
Description:
Main function for this class. Processes the connection based
on current state of the connection.
It may invoke or be invoked by ATQ functions.
Arguments:
cbWritten count of bytes written
dwCompletionStatus Error Code for last IO operation
lpo Overlapped stucture
Returns:
TRUE when processing is incomplete.
FALSE when the connection is completely processed and this
object may be deleted.
Note :
--*/
BOOL SMTP_CONNECTION::ProcessClient( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
{
BOOL fIsAtqThread = TRUE;
BOOL RetStatus;
BOOL fMailQueued = FALSE;
PSMTP_SERVER_INSTANCE pInstance = m_pInstance; //save the instance pointer
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessClient()");
_ASSERT (m_pInstance != NULL);
pInstance->IncProcessClientThreads();
InterlockedIncrement(&g_cProcessClientThreads);
//
// increment the number of threads processing this client
//
IncThreadCount();
//if lpo == NULL, then we timed out. Send an appropriate message
//then close the connection
if( (lpo == NULL) && (dwCompletionStatus == ERROR_SEM_TIMEOUT))
{
//
// fake a pending IO as we'll dec the overall count in the
// exit processing of this routine needs to happen before
// DisconnectClient else completing threads could tear us down
//
IncPendingIoCount();
FormatSmtpMessage (SMTP_RESP_ERROR, NULL," %s\r\n",SMTP_TIMEOUT_MSG );
SendSmtpResponse(); //flush the response
ProtocolLog(SMTP_TIMEOUT, (char *) QueryClientUserName(), inet_addr((char *)QueryClientHostName()), ERROR_SEM_TIMEOUT);
DebugTrace( (LPARAM)this, "client timed out");
DisconnectClient();
}
else if((InputBufferLen == 0) || (dwCompletionStatus != NO_ERROR))
{
//
DebugTrace((LPARAM) this, "SMTP_CONNECTION::ProcessClient: InputBufferLen = %d dwCompletionStatus = %d - Closing connection", InputBufferLen, dwCompletionStatus);
// If this is a mail file write then we handle error: if not a mailfile write or we are unable to
// handle the error, then we simply disconnect.
if( lpo != &m_Overlapped && lpo != QueryAtqOverlapped() && !HandleInternalError(dwCompletionStatus))
DisconnectClient();
}
else if (lpo == &m_Overlapped || lpo == QueryAtqOverlapped())
{
//
// Is this a real IO completion or a completion status
// posted to notify us an async sink completed?
//
if( m_fAsyncEventCompletion )
{
//
// A portocol event sink completed async, called our
// completion routine, posted a completion status which is
// being dequeued here. Our job is now to pend the next read
// (via ProcessInputBuffer)
//
m_fAsyncEventCompletion = FALSE;
RetStatus = ProcessInputBuffer();
}
else
{
//A client based async IO completed
RetStatus = ProcessReadIO(InputBufferLen, dwCompletionStatus, lpo);
if((m_pInstance->GetMaxErrors() > 0) && (m_ProtocolErrors >= m_pInstance->GetMaxErrors()))
{
//If there are too many error, break the connection
FormatSmtpMessage (SMTP_RESP_SRV_UNAVAIL, NULL," %s\r\n",SMTP_TOO_MANY_ERR_MSG);
FatalTrace((LPARAM) this, "Too many errors. Error count = %d", m_ProtocolErrors);
SendSmtpResponse();
DisconnectClient();
}
}
}
else
{
//A Mail File Write completed
SMTPCLI_FILE_OVERLAPPED* lpFileOverlapped = (SMTPCLI_FILE_OVERLAPPED*)lpo;
_ASSERT( lpFileOverlapped->m_LastIoState == WRITEFILEIO );
if (lpFileOverlapped->m_LastIoState == WRITEFILEIO)
{
RetStatus = ProcessFileWrite(InputBufferLen, dwCompletionStatus, lpo);
}
}
//
// decrement the number of threads processing this client if the thread exiting
// is an Atq pool thread
//
//if(fIsAtqThread)
DecThreadCount();
DebugTrace((LPARAM)this,"SMTPLCI - Pending IOs: %d", m_cPendingIoCount);
DebugTrace((LPARAM)this,"SMTPCLI - Num Threads: %d", m_cActiveThreads);
// Do NOT Touch the member variables past this POINT!
// This object may be deleted!
//
// decrement the overall pending IO count for this session
// tracing and ASSERTs if we're going down.
//
if (DecPendingIoCount() == 0)
{
ProtocolLog(QUIT, (char *) QueryClientUserName() , QuerySessionTime(),
(m_CInboundContext.m_dwCommandStatus | EXPE_DROP_SESSION) ? ERROR_VC_DISCONNECTED : NO_ERROR);
DebugTrace((LPARAM)this, "Pending IO count == 0, disconnecting.");
if(m_DoCleanup)
DisconnectClient();
m_pInstance->RemoveConnection(this);
delete this;
}
//if(fIsAtqThread)
//{
pInstance->DecProcessClientThreads();
InterlockedDecrement(&g_cProcessClientThreads);
//}
// We are not the last thread, so we will return TRUE
// to keep the object around
//TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::StartSession
Description:
Starts up a session for new client.
starts off a receive request from client.
Arguments:
Returns:
TRUE if everything is O.K
FALSE if a write or a pended read failed
--*/
BOOL SMTP_CONNECTION::StartSession( void)
{
SYSTEMTIME st;
BOOL fRet;
char szDateBuf [cMaxArpaDate];
char FullName[MAX_PATH + 1];
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::StartSession");
StartSessionTimer();
if(!m_pFileWriteBuffer || !m_pFileWriteBuffer->GetData())
{
ErrorTrace((LPARAM)this, "Failed to get the write buffer Err : %d",
GetLastError());
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//
// If we are negotiating SSL, we need to let the SSL handshake happen
// first. Else, we are either done with the SSL handshake or we are
// talking over the unsecured port, so just go ahead and send the server
// greeting.
//
if (!m_fNegotiatingSSL)
{
_ASSERT (m_pInstance != NULL);
//Dump the header line into the buffer to format the greeting
GetLocalTime(&st);
GetArpaDate(szDateBuf);
m_pInstance->LockGenCrit();
lstrcpy(FullName, m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
PE_CdFormatSmtpMessage(SMTP_RESP_READY,NULL," %s %s %s, %s \r\n",
FullName,
m_pInstance->GetConnectResponse(),
Daynames[st.wDayOfWeek],
szDateBuf);
//send the greeting
if(!PE_SendSmtpResponse())
{
DebugTrace( (LPARAM) this, "SendSmtpResponse() returned FALSE!");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
//kick off our first read
m_LastClientIo = READIO;
//
// increment the overall pending io count for this session
//
_ASSERT(m_cPendingIoCount == 0);
IncPendingIoCount();
fRet = ReadFile(QueryMRcvBuffer(), QueryMaxReadSize());
if(!fRet)
{
int err = GetLastError();
ErrorTrace((LPARAM)this, "Readfile failed, err = %d", err);
DecPendingIoCount(); //if one of these operations fail,
PE_DisconnectClient(); //AND the ReadFile failed the "last error" is lost.
if(err != ERROR_SUCCESS)
SetLastError(err); //restore last error that occurred so higher level routine knows what happened
}
DebugTrace((LPARAM)this, "SendSmtpResponse() returned %d", fRet);
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
/*++
Name :
SMTP_CONNECTION::CheckArguments
Description:
checks the arguments of what the client sends
for the required space command et al.
Arguments:
Arguments from client
Returns:
NULL if arguments are not correct
A pointer into the input buffer where
the rest of the data is.
--*/
char * SMTP_CONNECTION::CheckArgument(char * Argument, BOOL WriteError)
{
if(*Argument =='\0')
{
if(WriteError)
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","Argument missing" );
return NULL;
}
if(!isspace((UCHAR)*Argument))
{
if(WriteError)
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n",SMTP_BAD_CMD_STR);
return NULL;
}
//get rid of white space
while(isspace((UCHAR)*Argument))
Argument++;
//is there anything after here ?
if(*Argument =='\0')
{
if(WriteError)
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n", "Argument missing" );
return NULL;
}
return Argument;
}
void SMTP_CONNECTION::FormatEhloResponse(void)
{
char FullName [MAX_PATH + 1];
unsigned char AuthPackages [500];
DWORD BytesRet = 0;
DWORD ConnectionStatus = 0;
if(m_SecurePort)
ConnectionStatus |= SMTP_IS_SSL_CONNECTION;
if(m_fAuthenticated)
ConnectionStatus |= SMTP_IS_AUTH_CONNECTION;
m_pInstance->LockGenCrit();
lstrcpy(FullName, m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL, "-%s %s [%s]\r\n", FullName,"Hello", QueryClientHostName());
if(m_pInstance->AllowAuth())
{
if(m_pInstance->QueryAuthentication() != 0)
{
if(m_pInstance->QueryAuthentication() & INET_INFO_AUTH_NT_AUTH)
{
BytesRet = sizeof(AuthPackages);
m_securityCtx.GetInstanceAuthPackageNames(AuthPackages, &BytesRet, PkgFmtSpace);
}
if(BytesRet > 0)
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-AUTH %s",AuthPackages);
if(m_pInstance->AllowLogin(ConnectionStatus))
{
PE_FormatSmtpMessage(" LOGIN\r\n");
}
else
{
PE_FormatSmtpMessage("\r\n");
}
if(m_pInstance->AllowLogin(ConnectionStatus))
{
//For backward compatibility
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-AUTH=%s\r\n","LOGIN");
}
}
else if(m_pInstance->AllowLogin(ConnectionStatus))
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-AUTH=LOGIN\r\n");
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-AUTH LOGIN\r\n");
}
if(g_SmtpPlatformType == PtNtServer && m_pInstance->AllowTURN())
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n","TURN");
}
}
}
if (m_pInstance->GetMaxMsgSize() > 0)
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s %u\r\n","SIZE", m_pInstance->GetMaxMsgSize());
}
else
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s\r\n","SIZE");
}
if(g_SmtpPlatformType == PtNtServer && m_pInstance->AllowETRN())
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s\r\n", "ETRN");
}
if(m_pInstance->ShouldPipeLineIn())
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s\r\n","PIPELINING");
}
if(m_pInstance->AllowDSN())
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "DSN");
}
if(m_pInstance->AllowEnhancedCodes())
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s\r\n", "ENHANCEDSTATUSCODES");
}
if(m_pInstance->AllowEightBitMime())
{
PE_CdFormatSmtpMessage(SMTP_RESP_OK, NULL,"-%s\r\n", "8bitmime");
}
// Chunking related advertisements
if(m_pInstance->AllowBinaryMime())
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "BINARYMIME");
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "CHUNKING");
}
else if(m_pInstance->AllowChunking())
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "CHUNKING");
}
// verify - we need to advertise it whether we support it or not.
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n","VRFY");
// Expand
if(m_pInstance->AllowExpand(ConnectionStatus))
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "EXPN");
}
//
// Check that we have a certificate installed with which we can negotiate
// a SSL session
//
if (!m_SecurePort && // TLS is advertized only if we haven't already negotiated it
m_encryptCtx.CheckServerCert(
(LPSTR) QueryLocalHostName(),
(LPSTR) QueryLocalPortName(),
(LPVOID) QuerySmtpInstance(),
QuerySmtpInstance()->QueryInstanceId()))
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n","TLS");
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL,"-%s\r\n", "STARTTLS");
}
PE_CdFormatSmtpMessage (SMTP_RESP_OK, NULL," %s\r\n","OK");
}
/*++
Name :
SMTP_CONNECTION::DoEHLOCommand
Description:
Responds to the SMTP EHLO command
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoEHLOCommand(const char * InputLine, DWORD ParametSize)
{
BOOL RetStatus = TRUE;
char * Args = (char *) InputLine;
CAddr * NewAddress = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoEHLOCommand");
_ASSERT (m_pInstance != NULL);
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","BDAT Expected" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// pgopi -- don't cound multiple ehlo's as error. This is per bug 82160
//if (m_HelloSent)
// ++m_ProtocolErrors;
Args = CheckArgument(Args, !m_pInstance->ShouldAcceptNoDomain());
if(Args != NULL)
{
if(m_pInstance->ShouldValidateHeloDomain())
{
if(!ValidateDRUMSDomain(Args, lstrlen(Args)))
{
//Not a valid domain -
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
}
else
{
//Is reverse DNS lookup enabled
if(m_pInstance->IsReverseLookupEnabled())
{
m_DNSLookupRetCode = VerifiyClient (Args, QueryClientHostName());
if(m_DNSLookupRetCode == NO_MATCH)
{
//We failed in DNS lookup
if(m_pInstance->fDisconnectOnRDNSFail())
{
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, ENO_SECURITY," %s\r\n",SMTP_RDNS_REJECTION);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Connection RDNS failed for %s", Args);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
else if(m_DNSLookupRetCode == LOOKUP_FAILED)
{
//We had an internal DNS failure
if(m_pInstance->fDisconnectOnRDNSFail())
{
PE_CdFormatSmtpMessage (SMTP_RESP_SRV_UNAVAIL, EINTERNAL_ERROR," %s\r\n",SMTP_RDNS_FAILURE);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Connection RDNS DNS failure for %s", Args);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
} else {
m_DNSLookupRetCode = SUCCESS;
}
FormatEhloResponse();
strncpy(m_szHeloAddr, Args, MAX_INTERNET_NAME);
m_szHeloAddr[MAX_INTERNET_NAME] = '\0';
m_HelloSent = TRUE;
m_State = HELO;
}
}
else
{
FormatEhloResponse();
strncpy(m_szHeloAddr, Args, MAX_INTERNET_NAME);
m_szHeloAddr[MAX_INTERNET_NAME] = '\0';
m_HelloSent = TRUE;
m_State = HELO;
}
}
else if(m_pInstance->ShouldAcceptNoDomain())
{
FormatEhloResponse();
if(m_szHeloAddr[0] != '\0')
{
m_szHeloAddr[0] = '\0';
}
m_HelloSent = TRUE;
m_State = HELO;
}
//we can either accept the HELO or EHLO as the 1st command
RetStatus = PE_SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::DoHELOCommand
Description:
Responds to the SMTP HELO command
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoHELOCommand(const char * InputLine, DWORD ParameterSize)
{
char * Args = (char *) InputLine;
CAddr * NewAddress = NULL;
char FullName[MAX_PATH + 1];
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoHELOCommand");
_ASSERT (m_pInstance != NULL);
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","BDAT Expected" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// pgopi--don't cound multiple ehlo's as error. This is per bug 82160
//if (m_HelloSent)
// ++m_ProtocolErrors;
Args = CheckArgument(Args, !m_pInstance->ShouldAcceptNoDomain());
if(Args != NULL)
{
if(m_pInstance->ShouldValidateHeloDomain())
{
if(!ValidateDRUMSDomain(Args, lstrlen(Args)))
{
//Not a valid domain -
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
}
else
{
if(m_pInstance->IsReverseLookupEnabled())
{
m_DNSLookupRetCode = VerifiyClient (Args, QueryClientHostName());
if(m_DNSLookupRetCode == NO_MATCH)
{
//We failed in DNS lookup
if(m_pInstance->fDisconnectOnRDNSFail())
{
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, ENO_SECURITY," %s\r\n",SMTP_RDNS_REJECTION);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Connection RDNS failed for %s", Args);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
else if(m_DNSLookupRetCode == LOOKUP_FAILED)
{
//We had an internal DNS failure
if(m_pInstance->fDisconnectOnRDNSFail())
{
PE_CdFormatSmtpMessage (SMTP_RESP_SRV_UNAVAIL, EINTERNAL_ERROR," %s\r\n",SMTP_RDNS_FAILURE);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Connection RDNS DNS failure for %s", Args);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
} else {
m_DNSLookupRetCode = SUCCESS;
}
m_pInstance->LockGenCrit();
strcpy(FullName, m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
PE_CdFormatSmtpMessage (SMTP_RESP_OK,NULL," %s %s [%s]\r\n", FullName,
"Hello", QueryClientHostName());
strncpy(m_szHeloAddr, Args, MAX_INTERNET_NAME);
m_szHeloAddr[MAX_INTERNET_NAME] = '\0';
m_HelloSent = TRUE;
m_State = HELO;
}
}
else
{
m_pInstance->LockGenCrit();
strcpy(FullName, m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
PE_CdFormatSmtpMessage (SMTP_RESP_OK,NULL," %s %s [%s]\r\n", FullName,
"Hello", QueryClientHostName());
strncpy(m_szHeloAddr, Args, MAX_INTERNET_NAME);
m_szHeloAddr[MAX_INTERNET_NAME] = '\0';
m_HelloSent = TRUE;
m_State = HELO;
}
}
else if(m_pInstance->ShouldAcceptNoDomain())
{
m_pInstance->LockGenCrit();
lstrcpy(FullName, m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
PE_CdFormatSmtpMessage (SMTP_RESP_OK,NULL," %s %s [%s]\r\n", FullName,
"Hello", QueryClientHostName());
if(m_szHeloAddr[0] != '\0')
{
m_szHeloAddr[0] = '\0';
}
m_HelloSent = TRUE;
m_State = HELO;
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::DoRSETCommand
Description:
Responds to the SMTP RSET command.
Deletes all stored info, and resets
all flags.
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoRSETCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoRSETCommand");
_ASSERT (m_pInstance != NULL);
m_State = HELO;
m_TotalMsgSize = 0;
m_cbDotStrippedTotalMsgSize = 0;
m_RecvdMailCmd = FALSE;
m_HeaderSize = 0;
m_InHeader = TRUE;
m_LongBodyLine = FALSE;
m_fFoundEmbeddedCrlfDotCrlf = FALSE;
m_fScannedForCrlfDotCrlf = FALSE;
m_fSeenRFC822FromAddress = FALSE;
m_fSeenRFC822ToAddress = FALSE;
m_fSeenRFC822CcAddress = FALSE;
m_fSeenRFC822BccAddress = FALSE;
m_fSeenRFC822Subject = FALSE;
m_fSeenRFC822MsgId = FALSE;
m_fSeenXPriority = FALSE;
m_fSeenXOriginalArrivalTime = FALSE;
m_fSeenContentType = FALSE;
m_fSetContentType = FALSE;
m_TimeToRewriteHeader = TRUE;
m_MailBodyError = NO_ERROR;
m_RecvdRcptCmd = FALSE;
m_CurrentOffset = 0;
m_HopCount = 0;
m_LocalHopCount = 0;
m_fIsLastChunk = FALSE;
m_fIsBinaryMime = FALSE;
m_fIsChunkComplete = FALSE;
m_dwTrailerStatus = CRLF_SEEN;
m_nChunkSize = 0;
m_nBytesRemainingInChunk = 0;
m_MailBodyDiagnostic = ERR_NONE;
m_cbRecvBufferOffset = 0;
m_ProtocolErrors = 0;
m_fBufferFullInBDAT = FALSE;
if(m_cbTempBDATLen)
{
m_cbParsable -= m_cbTempBDATLen;
m_cbTempBDATLen = 0;
}
m_szFromAddress[0] = '\0';
//Free the possible ATQ context associated with this File handle
//This will be if we were processing BDAT before RSET
//FreeAtqFileContext();
ReleasImsg(TRUE);
PE_CdFormatSmtpMessage (SMTP_RESP_OK, EPROT_SUCCESS," %s\r\n",SMTP_RSET_OK_STR);
RetStatus= PE_SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::DoNOOPCommand
Description:
Responds to the SMTP NOOP command.
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoNOOPCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoNOOPCommand");
_ASSERT (m_pInstance != NULL);
//send an OK
PE_CdFormatSmtpMessage (SMTP_RESP_OK, EPROT_SUCCESS," OK\r\n");
RetStatus = PE_SendSmtpResponse();
if(!m_Nooped)
{
m_Nooped = TRUE;
}
else
{
m_ProtocolErrors++;
}
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::DoETRNCommand
Description:
Responds to the SMTP ETRN command.
Arguments:
Parsed to determine the ETRN domain(s) to send mail to.
Returns:
TRUE in all cases. We are agreeing to give our best effort to the ETRN command
re the protocol. Mail is not necessarily in the retry queue so it may not be delivered.
--*/
BOOL SMTP_CONNECTION::DoETRNCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus;
char * Ptr = NULL;
CHAR szNode[SMTP_MAX_DOMAIN_NAME_LEN];
DWORD Ret = 0;
// DWORD strLen;
BOOL bSubDomain;
DWORD dwMessagesQueued;
HRESULT hr;
// BOOL bWildCard;
// DOMAIN_ROUTE_ACTION_TYPE action;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoETRNCommand");
_ASSERT (m_pInstance != NULL);
bSubDomain = FALSE;
dwMessagesQueued = 0;
// bWildCard = FALSE;
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","BDAT Expected" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// check that the hello has been sent, and that we are not in the middle of sending
// a message
//NimishK : removed the check for HELO EHLO
if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", "Client was not authenticated");
ErrorTrace((LPARAM) this, "DoDataCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(m_RecvdMailCmd)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", SMTP_NO_ETRN_IN_MSG);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "In DoETRNCommand():SMTP_RESP_BAD_SEQ, SMTP_NO_ETRN_IN_MSG");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//start parsing from the beginning of the line
Ptr = (char *) InputLine;
//check if argument have the right format (at least one parameter)
Ptr = CheckArgument(Ptr);
if (Ptr == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// remove any whitespace
while((isspace ((UCHAR)*Ptr)))
{
Ptr++;
}
// check for ETRN subdomain character
if (*Ptr == '@')
{
//We could probably move this check to aqueue or keep it here
if (!(QuerySmtpInstance()->AllowEtrnSubDomains()))
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n", "Invalid domain name");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_ARGS - Invalid domain name");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
bSubDomain = TRUE;
}
// for @ command, check that this is at least a second tier domain (to avoid @com attack)
if (bSubDomain)
{
if (!strchr(Ptr,'.'))
{
PE_CdFormatSmtpMessage (SMTP_RESP_NODE_INVALID, EINVALID_ARGS," Node %s not allowed: First tier domain\r\n", Ptr);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_NODE_INVALID - First tier domains are not allowed");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
lstrcpyn(szNode, Ptr, AB_MAX_DOMAIN);
char *szTmp;
if (bSubDomain)
szTmp = szNode + 1;
else
szTmp = szNode;
if(!ValidateDRUMSDomain(szTmp, lstrlen(szTmp)))
{
//Not a valid domain -
SetLastError(ERROR_INVALID_DATA);
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n", "Invalid domain name");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_ARGS - Invalid domain name");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//So we have a valid domain
//Call into connection manager to start the queue
//If multiple domains were dequed because the domain name was either wild card
//or specifed with the @ sign
hr = m_pInstance->GetConnManPtr()->ETRNDomain(lstrlen(szNode),szNode, &dwMessagesQueued);
if(!FAILED(hr))
{
//We know about this ETRN domain
if(!dwMessagesQueued)
{
if (bSubDomain || hr == AQ_S_SMTP_WILD_CARD_NODE)
{
PE_CdFormatSmtpMessage (SMTP_RESP_ETRN_ZERO_MSGS, EPROT_SUCCESS," Ok, no messages waiting for node %s and sub nodes\r\n",
szNode);
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_ETRN_ZERO_MSGS, EPROT_SUCCESS," Ok, no messages waiting for node %s\r\n", szNode);
}
}
else
{
if (bSubDomain || hr == AQ_S_SMTP_WILD_CARD_NODE)
{
PE_CdFormatSmtpMessage (SMTP_RESP_ETRN_N_MSGS, EPROT_SUCCESS,
" OK, %d pending messages for wildcard node %s started\r\n", dwMessagesQueued, szNode);
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_ETRN_N_MSGS, EPROT_SUCCESS,
" OK, %d pending messages for node %s started\r\n",dwMessagesQueued, szNode);
}
}
}
else
{
if (hr == AQ_E_SMTP_ETRN_NODE_INVALID)
{
PE_CdFormatSmtpMessage (SMTP_RESP_NODE_INVALID, EINVALID_ARGS," Node %s not allowed: not configured as ETRN domain\r\n", szNode);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_ARGS - Domain not allowed");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_ERROR, EINTERNAL_ERROR," Action aborted - internal error\r\n");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
ErrorTrace((LPARAM) this, "Internal error ETRN processing");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
RetStatus = PE_SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::DoSTARTTLSCommand
Description:
Responds to the SMTP STARTTLS command.
Arguments:
Parsed to determine the TLS protocol to use.
Returns:
TRUE normally. A FALSE return indicates to the caller that the
client connection should be dropped.
--*/
BOOL SMTP_CONNECTION::DoSTARTTLSCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus, fStartSSL;
char * Ptr = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoSTARTTLSCommand");
_ASSERT (m_pInstance != NULL);
fStartSSL = FALSE;
//
// check that the hello has been sent, and that we are not in the middle of sending
// a message
//
if(!m_pInstance->AllowMailFromNoHello() && !m_HelloSent)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","Send hello first" );
ProtocolLog(STARTTLS, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Send hello first");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Check that we have a certificate installed with which we can negotiate
// a SSL session
//
if (!m_encryptCtx.CheckServerCert(
(LPSTR) QueryLocalHostName(),
(LPSTR) QueryLocalPortName(),
(LPVOID) QuerySmtpInstance(),
QuerySmtpInstance()->QueryInstanceId())) {
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, ENO_SECURITY," %s\r\n", SMTP_NO_CERT_MSG);
ProtocolLog(STARTTLS, (char *)InputLine, NO_ERROR, SMTP_RESP_TRANS_FAILED, 0, 0);
ErrorTrace((LPARAM) this, "In DoSTARTTLSCommand():SMTP_RESP_TRANS_FAILED, SMTP_NO_CERT_MSG");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// if we are already secure, reject the request
//
if(m_SecurePort)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", SMTP_ONLY_ONE_TLS_MSG);
ProtocolLog(STARTTLS, (char *)InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "In DoSTARTTLSCommand():SMTP_RESP_BAD_SEQ, SMTP_ONLY_ONE_TLS_MSG");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Switch over to using a large receive buffer, because a SSL fragment
// may be up to 32K big.
fStartSSL = SwitchToBigSSLBuffers();
if (fStartSSL) {
PE_CdFormatSmtpMessage(SMTP_RESP_READY, EPROT_SUCCESS," %s\r\n", SMTP_READY_STR);
ProtocolLog(STARTTLS, (char *) InputLine, NO_ERROR, SMTP_RESP_READY, 0, 0);
} else {
PE_CdFormatSmtpMessage(SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n", SMTP_NO_MEMORY);
ProtocolLog(STARTTLS, (char *) InputLine, NO_ERROR, SMTP_RESP_NORESOURCES, 0, 0);
}
fStartSSL = TRUE;
RetStatus = PE_SendSmtpResponse();
if (fStartSSL)
m_SecurePort = m_fNegotiatingSSL = TRUE;
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
BOOL SMTP_CONNECTION::DoTLSCommand(const char * InputLine, DWORD parameterSize)
{
return DoSTARTTLSCommand(InputLine, parameterSize);
}
//
// the default handler for end of data. commit the recipients list and
// insert the message into the queue
//
BOOL SMTP_CONNECTION::Do_EODCommand(const char * InputLine, DWORD parameterSize)
{
TraceFunctEnter("SMTP_CONNECTION::Do_EODCommand");
HRESULT hr;
char MessageId[1024];
BOOL fQRet;
MessageId[0] = 0;
if( m_pIMsg )
{
m_pIMsg->GetStringA( IMMPID_MP_RFC822_MSG_ID, sizeof( MessageId ), MessageId );
}
MessageId[sizeof(MessageId)-1] = 0; // NULL terminate it.
if(m_HopCount >= m_pInstance->GetMaxHopCount())
{
fQRet = m_pInstance->SubmitFailedMessage(m_pIMsg, MESSAGE_FAILURE_HOP_COUNT_EXCEEDED, 0);
FatalTrace((LPARAM) this, "Hop count exceeded");
}
else
{
// check to see if we need to hold this message
if (m_LocalHopCount >= 2) // if we're hitting this server for the 3rd time (or more)
{
if( m_pIMsg )
{
// Update the deferred delivery time property for this message
SYSTEMTIME SystemTime;
ULARGE_INTEGER ftDeferred; // == FILETIME
DWORD cbProp = 0;
BOOL fSuccess;
// Get the current system time
GetSystemTime (&SystemTime);
// Convert it to a file time
fSuccess = SystemTimeToFileTime(&SystemTime, (FILETIME*)&ftDeferred);
_ASSERT(fSuccess);
// Add 10 minutes
ftDeferred.QuadPart += SMTP_LOOP_DELAY;
hr = m_pIMsg->PutProperty(IMMPID_MP_DEFERRED_DELIVERY_FILETIME,
sizeof(FILETIME), (BYTE *) &ftDeferred);
DebugTrace( (LPARAM)this, "Possible Loop : Delaying message 10 minutes");
}
}
fQRet = m_pInstance->InsertIntoQueue(m_pIMsg);
}
if(fQRet)
{
ReleasImsg(FALSE);
}
else
{
m_MailBodyError = GetLastError();
//FatalTrace((LPARAM) this, "SetEndOfFile failed on file %s !!! (err=%d)", MailInfo->GetMailFileName(), m_MailBodyError);
m_CInboundContext.SetWin32Status(m_MailBodyError);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE );
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//Get the offset of the filename and send it back to the client
//we send the status back to the client immediately, just incase
//the session breaks abnormally, or because the client times out.
//If the client times out, it would send another message and we
//would get duplicate mail messages.
//Note that the response string is limited in length, so we'll truncate
//the MessageId if it is too long. Otherwise the reponse will be truncated
//elsewhere, like before the SMTP_QUEUE_MAIL string which will be confusing.
//MAX_REWRITTEN_MSGID is actually the maximum possible length of the entire
//"Message-ID: xxx" header in a message.
_ASSERT(sizeof(MessageId)/sizeof(char) > MAX_REWRITTEN_MSGID);
MessageId[MAX_REWRITTEN_MSGID] = '\0';
PE_CdFormatSmtpMessage (SMTP_RESP_OK, EMESSAGE_GOOD, " %s %s\r\n",MessageId, SMTP_QUEUE_MAIL);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::DoQUITCommand
Description:
Responds to the SMTP QUIT command.
This function always returns false.
This will stop all processing and
delete this object.
Arguments:
Are ignored
Returns:
Always return FALSE
--*/
BOOL SMTP_CONNECTION::DoQUITCommand(const char * InputLine, DWORD parameterSize)
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoQUITCommand");
_ASSERT (m_pInstance != NULL);
//set our state
m_State = QUIT;
//send the quit response
m_pInstance->LockGenCrit();
PE_CdFormatSmtpMessage (SMTP_RESP_CLOSE, E_GOODBYE, " %s %s\r\n",m_pInstance->GetFQDomainName(), SMTP_QUIT_OK_STR);
m_pInstance->UnLockGenCrit();
PE_SendSmtpResponse();
//disconnect the client
PE_DisconnectClient();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
BOOL SMTP_CONNECTION::DoSizeCommand(char * Value, char * InputLine)
{
DWORD EstMailSize = 0;
DWORD EstSessionSize = 0;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoSizeCommand");
_ASSERT (m_pInstance != NULL);
EstMailSize = atoi (Value);
EstSessionSize = m_SessionSize + EstMailSize;
if (EstMailSize == 0)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","Invalid arguments" );
ErrorTrace((LPARAM) this, "SMTP_RESP_MBX_SYNTAX, SMTP_BAD_CMD_STR. Client sent 0 in SIZE command");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//check to make sure we are going over the servers max file size
if((m_pInstance->GetMaxMsgSize() > 0) && (EstMailSize > m_pInstance->GetMaxMsgSize()))
{
BOOL fShouldImposeLimit = TRUE;
if( FAILED( m_pInstance->TriggerMaxMsgSizeEvent( GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit ) ) || fShouldImposeLimit )
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOSTORAGE, EMESSAGE_TOO_BIG," %s\r\n", SMTP_MAX_MSG_SIZE_EXCEEDED_MSG );
ErrorTrace((LPARAM) this, "SMTP_RESP_NOSTORAGE, SMTP_MAX_MSG_SIZE_EXCEEDED_MSG - %d", EstMailSize);
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
// Check that the maximum session size has not been exceeded
if((m_pInstance->GetMaxMsgSizeBeforeClose() > 0) && (EstSessionSize > m_pInstance->GetMaxMsgSizeBeforeClose()))
{
BOOL fShouldImposeLimit = TRUE;
if( FAILED( m_pInstance->TriggerMaxMsgSizeEvent( GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit ) ) || fShouldImposeLimit )
{
ErrorTrace((LPARAM) this, "SMTP_RESP_NOSTORAGE, SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG - %d", EstMailSize);
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
DebugTrace((LPARAM) this, "GetMaxMsgSizeBeforeClose() exceeded - closing connection");
// Client won't be expecting this, but atleast an admin can tell
// what's wrong from this response.
FormatSmtpMessage(SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n",
SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG);
SendSmtpResponse();
DisconnectClient();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
return TRUE;
}
BOOL SMTP_CONNECTION::DoBodyCommand (char * Value, char * InputLine)
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoBodyCommand");
_ASSERT (m_pInstance != NULL);
if(!_strnicmp(Value, (char * )"8bitmime", 8))
{
m_pIMsg->PutDWORD(IMMPID_MP_EIGHTBIT_MIME_OPTION, 1);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else if((!_strnicmp(Value, (char * )"BINARYMIME", 10)) && m_pInstance->AllowBinaryMime())
{
m_fIsBinaryMime = TRUE; //Need to get rid of this **
m_pIMsg->PutDWORD(IMMPID_MP_BINARYMIME_OPTION, 1);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else if(!_strnicmp(Value, (char * )"7bit", 4))
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n", SMTP_BAD_BODY_TYPE_STR );
ErrorTrace((LPARAM) this, "SMTP_RESP_MBX_SYNTAX, SMTP_BAD_BODY_TYPE_STR.");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
BOOL SMTP_CONNECTION::DoRetCommand (char * Value, char * InputLine)
{
char RetDsnValue[10];
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoRetCommand");
_ASSERT (m_pInstance != NULL);
//strict size checking
if(strlen(Value) < 5)
{
hr = m_pIMsg->GetStringA(IMMPID_MP_DSN_RET_VALUE, sizeof(RetDsnValue), RetDsnValue);
if(FAILED(hr))
{
if(!_strnicmp(Value, (char * )"FULL", 4) ||
!_strnicmp(Value, (char * )"HDRS", 4))
{
hr = m_pIMsg->PutStringA(IMMPID_MP_DSN_RET_VALUE, Value);
if(!FAILED(hr))
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE );
ErrorTrace((LPARAM) this, "Failed to set RET value to IMSG");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
}
}
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n","Invalid arguments" );
ErrorTrace((LPARAM) this, "SMTP_RESP_MBX_SYNTAX, SMTP_BAD_CMD_STR. Client sent bad RET value");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
BOOL SMTP_CONNECTION::IsXtext(char * Xtext)
{
char * StartPtr = Xtext;
char NextChar = '\0';
while((NextChar = *StartPtr++) != '\0')
{
if(NextChar == '+')
{
NextChar = *StartPtr++;
if(!isascii((UCHAR)NextChar) || !isxdigit((UCHAR)NextChar))
{
return FALSE;
}
}
else if(NextChar < '!' || NextChar > '~' || NextChar == '=')
{
return FALSE;
}
}
return TRUE;
}
BOOL SMTP_CONNECTION::DoEnvidCommand (char * Value, char * InputLine)
{
HRESULT hr = S_OK;
char EnvidValue[MAX_MAIL_FROM_ENVID_LEN+1];
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoEnvidCommand");
_ASSERT (m_pInstance != NULL);
_ASSERT (Value != NULL);
_ASSERT (InputLine != NULL);
hr = m_pIMsg->GetStringA(IMMPID_MP_DSN_ENVID_VALUE, sizeof(EnvidValue), EnvidValue);
if(FAILED(hr))
{
DWORD ValueLength = lstrlen(Value);
if((ValueLength != 0) && (ValueLength <= MAX_MAIL_FROM_ENVID_LEN))
{
if(IsXtext(Value))
{
hr = m_pIMsg->PutStringA(IMMPID_MP_DSN_ENVID_VALUE, Value);
if(!FAILED(hr))
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE );
ErrorTrace((LPARAM) this, "Failed to set ENVID value to IMSG");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
}
}
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n","Invalid arguments" );
ErrorTrace((LPARAM) this, "SMTP_RESP_MBX_SYNTAX, SMTP_BAD_CMD_STR. Client sent bad envid value");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
BOOL SMTP_CONNECTION::DoNotifyCommand (char * Value, DWORD * pdwNotifyValue)
{
*pdwNotifyValue = 0;
char * SearchPtr = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoNotifyCommand");
_ASSERT (Value != NULL);
if(!strcasecmp(Value, "NEVER"))
{
*pdwNotifyValue = RP_DSN_NOTIFY_NEVER;
}
else
{
for(SearchPtr = Value; SearchPtr != NULL; Value = SearchPtr)
{
SearchPtr = strchr(SearchPtr, ',');
if(SearchPtr != NULL)
{
*SearchPtr++ = '\0';
}
if(!strcasecmp(Value, "SUCCESS"))
{
*pdwNotifyValue |= RP_DSN_NOTIFY_SUCCESS;
}
else if(!strcasecmp(Value, "FAILURE"))
{
*pdwNotifyValue |= RP_DSN_NOTIFY_FAILURE;
}
else if(!strcasecmp(Value, "DELAY"))
{
*pdwNotifyValue |= RP_DSN_NOTIFY_DELAY;
}
else
{
*pdwNotifyValue = RP_DSN_NOTIFY_INVALID;
break;
}
}
if(!*pdwNotifyValue)
{
*pdwNotifyValue = RP_DSN_NOTIFY_INVALID;
}
}
if(*pdwNotifyValue == RP_DSN_NOTIFY_INVALID)
{
return FALSE;
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
BOOL SMTP_CONNECTION::DoMailFromAuthArg (char * Value)
{
HRESULT hr = S_OK;
char chDummy;
DWORD ValueLength;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoMailFromAuthArg");
_ASSERT (m_pInstance != NULL);
_ASSERT (Value != NULL);
ValueLength = lstrlen(Value);
if((ValueLength != 0) && (ValueLength <= MAX_MAIL_FROM_AUTH_LEN)) {
//
// Verify that the property doesn't already exist.
//
hr = m_pIMsg->GetStringA(IMMPID_MP_INBOUND_MAIL_FROM_AUTH, 0, &chDummy);
if(hr == STG_E_UNKNOWN) {
if(IsXtext(Value)) {
hr = m_pIMsg->PutStringA(IMMPID_MP_INBOUND_MAIL_FROM_AUTH, Value);
if(!FAILED(hr)) {
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
} else {
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE );
ErrorTrace((LPARAM) this, "Failed to set AUTH value to IMSG");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
}
}
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n","Invalid arguments" );
ErrorTrace((LPARAM) this, "SMTP_RESP_MBX_SYNTAX, SMTP_BAD_CMD_STR. Client sent bad auth value");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
BOOL SMTP_CONNECTION::DoOrcptCommand (char * Value)
{
char * XtextPtr = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoOrcptCommand");
_ASSERT (m_pInstance != NULL);
DWORD ValueLength = lstrlen(Value);
if((ValueLength != 0) && (ValueLength <= MAX_RCPT_TO_ORCPT_LEN))
{
//NK** : Parse out the address type and validate it against IANA registered
// mail address type
if(XtextPtr = strchr(Value,';'))
{
if(IsXtext(XtextPtr+1))
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
}
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
BOOL SMTP_CONNECTION::DoSmtpArgs (char *InputLine)
{
char * Value = NULL;
char * EndOfLine = NULL;
char * Cmd = NULL;
char * LinePtr = InputLine;
char * SearchPtr = NULL;
while(LinePtr && *LinePtr != '\0')
{
//find the beginning of the keyword
LinePtr = (char *) strchr (LinePtr, '=');
if(LinePtr != NULL)
{
SearchPtr = LinePtr;
//Cmd = LinePtr - 4;
while( (*SearchPtr != ' ') && (*SearchPtr != '\0'))
{
SearchPtr--;
}
Cmd = SearchPtr + 1;
*LinePtr++ = '\0';
Value = LinePtr;
//Back track to the beginning of the byte
//before the size command. If that character
//is a space, then we need to Null terminate
//the string there. If it's not a space, then
//this is an error.
EndOfLine = Cmd - 1;
if(*EndOfLine == ' ')
*EndOfLine = '\0';
else if(*EndOfLine != '\0')
{
continue;
}
LinePtr = (char *) strchr(LinePtr, ' ');
if(LinePtr != NULL)
{
*LinePtr++ = '\0';
}
if(!strcasecmp(Cmd, "SIZE"))
{
if(!DoSizeCommand(Value, InputLine))
return FALSE;
}
else if(!strcasecmp(Cmd, "BODY"))
{
if(!DoBodyCommand (Value, InputLine))
return FALSE;
}
else if(!strcasecmp(Cmd, "RET") && m_pInstance->AllowDSN())
{
if(!DoRetCommand (Value, InputLine))
return FALSE;
}
else if(!strcasecmp(Cmd, "ENVID") && m_pInstance->AllowDSN())
{
if(!DoEnvidCommand (Value, InputLine))
return FALSE;
}
else if(!strcasecmp(Cmd, "AUTH"))
{
if(! DoMailFromAuthArg(Value))
return FALSE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","Invalid arguments" );
++m_ProtocolErrors;
return FALSE;
}
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","Invalid arguments" );
++m_ProtocolErrors;
return FALSE;
}
}
return TRUE;
}
BOOL SMTP_CONNECTION::DoRcptArgs (char *InputLine, char * szORCPTval, DWORD * pdwNotifyVal)
{
char * Value = NULL;
char * EndOfLine = NULL;
char * Cmd = NULL;
char * LinePtr = InputLine;
char * SearchPtr = NULL;
*pdwNotifyVal = 0;
BOOL fDoneOrcptCmd = FALSE;
BOOL fDoneNotifyCmd = FALSE;
while(LinePtr && *LinePtr != '\0')
{
if(!m_pInstance->AllowDSN())
return FALSE;
//find the beginning of the keyword
LinePtr = (char *) strchr (LinePtr, '=');
if(LinePtr != NULL)
{
SearchPtr = LinePtr;
//Cmd = LinePtr - 4;
while( (*SearchPtr != ' ') && (*SearchPtr != '\0'))
{
SearchPtr--;
}
Cmd = SearchPtr + 1;
*LinePtr++ = '\0';
Value = LinePtr;
//Back track to the beginning of the byte
//before the size command. If that character
//is a space, then we need to Null terminate
//the string there. If it's not a space, then
//this is an error.
EndOfLine = Cmd - 1;
if(*EndOfLine == ' ')
*EndOfLine = '\0';
else if(*EndOfLine != '\0')
{
continue;
}
LinePtr = (char *) strchr(LinePtr, ' ');
if(LinePtr != NULL)
{
*LinePtr++ = '\0';
}
if(!strcasecmp(Cmd, "NOTIFY") )
{
if( fDoneNotifyCmd || ( !DoNotifyCommand( Value, pdwNotifyVal ) ) )
{
return FALSE;
}
fDoneNotifyCmd = TRUE;
}
else if(!strcasecmp(Cmd, "ORCPT"))
{
if( ( !fDoneOrcptCmd ) && DoOrcptCommand(Value))
{
strcpy(szORCPTval,Value);
fDoneOrcptCmd = TRUE;
}
else
{
*szORCPTval = '\0';
return FALSE;
}
}
else
{
return FALSE;
}
}
else
{
return FALSE;
}
}
return TRUE;
}
//NK** : Receive header always completes sync
BOOL SMTP_CONNECTION::WriteRcvHeader(void)
{
char * Address = NULL;
char * VersionNum = NULL;
CHAR szText[2024];
char szDateBuf [cMaxArpaDate];
DWORD cbText = 0;
DWORD Error = NO_ERROR;
DWORD EstMailSize = 0;
SYSTEMTIME st;
HRESULT hr;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::WriteRcvHeader");
if(m_IMsgHandle == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//get the name of the sender to place into the mail header
Address = (char *) QueryClientUserName();
_ASSERT (Address != NULL);
//Dump the header line into the buffer
GetLocalTime(&st);
GetArpaDate(szDateBuf);
VersionNum = strchr(g_VersionString, ':');
if(VersionNum)
{
VersionNum += 2;
}
else
{
VersionNum = "";
}
m_pInstance->LockGenCrit();
if(m_DNSLookupRetCode == SUCCESS)
{
m_HeaderSize = wsprintf(szText,szFormatReceivedFormatSuccess,
Address, QueryClientHostName(), m_pInstance->GetFQDomainName(),
(m_SecurePort ? " over TLS secured channel" : ""),VersionNum,
Daynames[st.wDayOfWeek], szDateBuf);
}
else if ( m_DNSLookupRetCode == LOOKUP_FAILED)
{
m_HeaderSize = wsprintf(szText,szFormatReceivedFormatUnverified,
Address, QueryClientHostName(), m_pInstance->GetFQDomainName(),
(m_SecurePort ? " over TLS secured channel" : ""),VersionNum,
Daynames[st.wDayOfWeek], szDateBuf);
}
else
{
m_HeaderSize = wsprintf(szText,szFormatReceivedFormatFailed,
Address, QueryClientHostName(), m_pInstance->GetFQDomainName(),
(m_SecurePort ? " over TLS secured channel" : ""),VersionNum,
Daynames[st.wDayOfWeek], szDateBuf);
}
m_pInstance->UnLockGenCrit();
//if EstMailSize > 0, then the size command was given. If the size command was
//given and the value was 0, we would have caught it above and would skip over
//this peice of code.
if (EstMailSize > 0)
{
if(SetFilePointer(m_IMsgHandle->m_hFile, EstMailSize + cbText,
NULL, FILE_BEGIN) == 0xFFFFFFFF)
{
Error = GetLastError();
DWORD Offset = EstMailSize + cbText;
//FormatSmtpMessage ("%d %s %s\r\n",SMTP_RESP_NORESOURCES, ENO_RESOURCES, SMTP_NO_STORAGE );
//ProtocolLog(MAIL, (char *)InputLine, Error, SMTP_RESP_NORESOURCES, 0, 0);
FatalTrace((LPARAM) this, " SetFilePointer failed - %d", GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
if(!SetEndOfFile(m_IMsgHandle->m_hFile))
{
Error = GetLastError();
//ProtocolLog(MAIL, (char *)InputLine, Error, SMTP_RESP_NORESOURCES, 0, 0);
//PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE );
FatalTrace((LPARAM) this, " SetEndOfFile failed - %d", GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
DWORD dwPointer;
dwPointer = SetFilePointer(m_IMsgHandle->m_hFile, 0, NULL, FILE_BEGIN);
//if we get here, this should always pass
_ASSERT (dwPointer != 0xFFFFFFFF);
}
_ASSERT(m_pFileWriteBuffer);
_ASSERT(m_pFileWriteBuffer->GetData());
CopyMemory((m_pFileWriteBuffer->GetData() + m_cbCurrentWriteBuffer),szText,m_HeaderSize);
m_cbCurrentWriteBuffer += m_HeaderSize;
wsprintf(szText,"%s, %s",Daynames[st.wDayOfWeek], szDateBuf);
hr = m_pIMsg->PutStringA(IMMPID_MP_ARRIVAL_TIME, szText);
if(FAILED(hr))
{
Error = GetLastError();
//FormatSmtpMessage ("%d %s %s\r\n",SMTP_RESP_NORESOURCES, ENO_RESOURCES, SMTP_NO_STORAGE );
FatalTrace((LPARAM) this, " MailInfo->SetSenderToStream");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::DoMAILCommand
Description:
Responds to the SMTP MAIL command.
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoMAILCommand(const char * InputLine, DWORD ParameterSize)
{
char * Ptr = NULL;
char * SizeCmd = NULL;
//char * Address = NULL;
char * Value = NULL;
CAddr * NewAddress = NULL;
DWORD EstMailSize = 0;
DWORD cbText = 0;
DWORD Error = NO_ERROR;
BOOL FoundSizeCmd = FALSE;
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoMAILCommand");
_ASSERT (m_pInstance != NULL);
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","BDAT Expected" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Check if HELO or EHELO
if(!m_pInstance->AllowMailFromNoHello() && !m_HelloSent)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n", "Send hello first" );
ErrorTrace((LPARAM) this, "DoMAILCommand - SMTP_RESP_BAD_SEQ, Send hello first");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_HelloSent)
{
m_HelloSent = TRUE;
}
if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", "Client was not authenticated");
ErrorTrace((LPARAM) this, "DoMAILCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//disallow mail from more than once
if(m_RecvdMailCmd)
{
++m_ProtocolErrors;
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n", "Sender already specified" );
ErrorTrace((LPARAM) this, "DoMAILCommand - SMTP_RESP_BAD_SEQ, Sender already specified");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//We should reset the current hop count when we get a new mail. If we don't
//do this, we might NDR the mail that comes later in the session.
m_HopCount = 0;
m_LocalHopCount = 0;
//start parsing from the beginning of the line
Ptr = (char *) InputLine;
//check if argument have the right format
Ptr = CheckArgument(Ptr);
if (Ptr == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//skip over from:
Ptr = SkipWord (Ptr, "From", 4);
if (Ptr == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
DWORD dwAddressLen = 0;
DWORD dwCanonAddrLen = 0;
char * ArgPtr = NULL;
char * AddrPtr = NULL;
char * CanonAddrPtr = NULL;
char * DomainPtr = NULL;
m_szFromAddress[0] = '\0';
//Parse out the address and possible argumets from the input line
if(!Extract821AddressFromLine(Ptr,&AddrPtr,&dwAddressLen,&ArgPtr))
{
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Check if we have valid tail and address
if(!AddrPtr)
{
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Check for the special case <> from address
if(dwAddressLen == 2 && *AddrPtr == '<' && *(AddrPtr+1) == '>')
{
//simply copy this as the validated address
lstrcpy(m_szFromAddress,"<>");
}
else
{
//Extract the canonical address in the <local-part> "@" <domain> form
if(!ExtractCanonical821Address(AddrPtr,dwAddressLen,&CanonAddrPtr,&dwCanonAddrLen))
{
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//If we have a Canonical addr - validate it
if(CanonAddrPtr)
{
strncpy(m_szFromAddress,CanonAddrPtr,dwCanonAddrLen);
*(m_szFromAddress + dwCanonAddrLen) = '\0';
if(!Validate821Address(m_szFromAddress, dwCanonAddrLen))
{
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Extract
if(!Get821AddressDomain(m_szFromAddress,dwCanonAddrLen,&DomainPtr))
{
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
//Is the RDNS enabled for MAILFROM command
if(m_pInstance->IsRDNSEnabledForMAIL())
{
DWORD dwDNSLookupRetCode = SUCCESS;
//If we have the RDNS option on MAIL from domain
//we cannot get a NULL domain on MAIL from
if(DomainPtr)
{
dwDNSLookupRetCode = VerifiyClient (DomainPtr,DomainPtr);
if(dwDNSLookupRetCode == NO_MATCH)
{
PE_CdFormatSmtpMessage (SMTP_RESP_REJECT_MAILFROM, ENO_SECURITY_TMP," %s\r\n",SMTP_RDNS_REJECTION);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Mail From : RDNS failed for %s", DomainPtr);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else if(m_DNSLookupRetCode == LOOKUP_FAILED)
{
//We had an internal DNS failure
PE_CdFormatSmtpMessage (SMTP_RESP_REJECT_MAILFROM, EINTERNAL_ERROR," %s\r\n",SMTP_RDNS_FAILURE);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected MAILFROM : RDNS DNS failure for %s", DomainPtr);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_REJECT_MAILFROM, ENO_SECURITY_TMP," %s\r\n",SMTP_RDNS_REJECTION);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "Rejected Mail From : no domain specified");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
}
}
else
{
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//rewrite the address if it's not the NULL address,
//and the masquerading option is on
if(m_pInstance->ShouldMasquerade() && !ISNULLADDRESS(m_szFromAddress)
&& (!DomainPtr || m_pInstance->IsALocalDomain(DomainPtr)))
{
if(!m_pInstance->MasqueradeDomain(m_szFromAddress, DomainPtr))
{
//it failed. Inform the user
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
else if(!DomainPtr && !ISNULLADDRESS(m_szFromAddress))
{
//If there is no domain on this address,
//then append the current domain to this
//address. However, if we get the <>
//address, don't append a domain
if(!m_pInstance->AppendLocalDomain (m_szFromAddress))
{
//it failed. Inform the user
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
}
//parse the arguments, if any
if(!DoSmtpArgs (ArgPtr))
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
_ASSERT (m_szFromAddress != NULL);
_ASSERT (m_szFromAddress[0] != '\0');
hr = m_pIMsg->PutStringA(IMMPID_MP_SENDER_ADDRESS_SMTP, m_szFromAddress);
if(FAILED(hr))
{
Error = GetLastError();
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE );
m_CInboundContext.SetWin32Status(Error);
FatalTrace((LPARAM) this, " MailInfo->SetSenderToStream");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
m_RecvdMailCmd = TRUE;
m_State = MAIL;
PE_CdFormatSmtpMessage (SMTP_RESP_OK, ESENDER_ADDRESS_VALID," %s....Sender OK\r\n", m_szFromAddress);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::DoRCPTCommand
Description:
Responds to the SMTP RCPT command.
This funcion gets the addresses and
places then into a linked list.
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoRCPTCommand(const char * InputLine, DWORD ParameterSize)
{
char * ToName = NULL;
char * ThisAddress = NULL;
CAddr * NewAddress = NULL;
CAddr * TempAddress = NULL;
BOOL IsDomainValid = TRUE; //assume everyone is O.K
BOOL RelayThisMail = FALSE;
BOOL DropQuotaExceeded = FALSE;
DWORD dwPropId = IMMPID_RP_ADDRESS_SMTP;
DWORD dwNewRecipIndex = 0;
HRESULT hr = S_OK;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoRCPTCommand");
_ASSERT(m_pInstance != NULL);
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "BDAT Expected" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_HelloSent)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Send hello first" );
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Send hello first");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n","Client was not authenticated");
ErrorTrace((LPARAM) this, "DoRCPTCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//see if we got a valid return path before going on
if(!m_RecvdMailCmd || !m_pIMsg || !m_pIMsgRecips || (m_szFromAddress[0] == '\0') )
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", SMTP_NEED_MAIL_FROM_MSG);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "In DoRCPTCommand():SMTP_RESP_BAD_SEQ, SMTP_NEED_MAIL_FROM_MSG");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//start at inputline
ToName = (char *) InputLine;
//set the state
m_State = RCPT;
m_RecvdRcptCmd = TRUE;
//check if argument have the right format
ToName = CheckArgument(ToName);
if (ToName == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
ToName = SkipWord (ToName, "To", 2);
if (ToName == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
char * DomainPtr = NULL;
char * ArgPtr = NULL;
char szRcptAddress[MAX_INTERNET_NAME + 1];
szRcptAddress[0] = '\0';
DWORD dwNotifyVal;
char szOrcptVal[MAX_RCPT_TO_ORCPT_LEN + 1];
szOrcptVal[0] = '\0';
if(!ExtractAndValidateRcpt(ToName, &ArgPtr, szRcptAddress, &DomainPtr ))
{
// If failed. Inform the user
SetLastError(ERROR_INVALID_DATA);
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Parse out the DSN values if any
//parse the arguments, if any
if(!DoRcptArgs (ArgPtr, szOrcptVal, &dwNotifyVal))
{
//it failed. Inform the user
DWORD dwError = GetLastError();
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","Invalid arguments" );
m_CInboundContext.SetWin32Status(dwError);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//check to see if there is any room in the inn.
//if the remote queue entry is allocated, check
//that also.
DWORD TotalRcpts = 0;
hr = m_pIMsgRecips->Count(&TotalRcpts);
if( FAILED(hr) || ((m_pInstance->GetMaxRcpts() > 0) && ((TotalRcpts + 1) > m_pInstance->GetMaxRcpts())))
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOSTORAGE, ETOO_MANY_RCPTS, " %s\r\n",SMTP_TOO_MANY_RCPTS);
ErrorTrace((LPARAM) this, "Exceeded MaxRcpts %d", TotalRcpts + 1);
// don't count too many rcpts as protocol errors as this will
// close the connection.
//++m_ProtocolErrors;
delete NewAddress;
NewAddress = NULL;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//If the relay check feature is enabled make sure that this
//recipient is to be accepted for relay
if(m_pInstance->IsRelayEnabled())
{
hr = HrShouldAcceptRcpt(DomainPtr);
if ( S_OK == hr ) RelayThisMail = TRUE;
else if (S_FALSE == hr ) RelayThisMail = FALSE;
else
{
// Currently, HrShouldAcceptRcpt only return error when AQueue is already shut down or out of memory.
_ASSERT(FAILED(hr));
PE_CdFormatSmtpMessage (SMTP_RESP_SRV_UNAVAIL, ESVC_SHUTDOWN," %s\r\n",SMTP_SRV_UNAVAIL_STR);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
if (m_pInstance->IsDropDirQuotaCheckingEnabled())
{
//We only enforce drop dir quota checking on local and alias domains. Since
//this is turned on by default, we assume that anyone who has setup there own
//non-default drop domain is has some agent the will process mail put in it.
if (m_pInstance->IsADefaultOrAliasDropDomain(DomainPtr))
DropQuotaExceeded = m_pInstance->IsDropDirQuotaExceeded();
}
ThisAddress = szRcptAddress;
if(RelayThisMail && !DropQuotaExceeded)
{
hr = m_pIMsgRecips->AddPrimary(1, (LPCTSTR *) &ThisAddress, &dwPropId,
&dwNewRecipIndex, NULL, 0);
if(!FAILED(hr))
{
//If we have any associated DSn values set them
if(szOrcptVal && szOrcptVal[0] != '\0')
{
hr = m_pIMsgRecips->PutStringA(dwNewRecipIndex, IMMPID_RP_DSN_ORCPT_VALUE,(LPCSTR)szOrcptVal);
if(FAILED(hr))
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE);
ErrorTrace((LPARAM) this, "Exceeded MaxRcpts %d", TotalRcpts + 1);
}
}
//If we have any associated DSn values set them
//If we have any associated DSn values set them
if(!FAILED(hr) && dwNotifyVal & RP_DSN_NOTIFY_MASK)
{
//hr = m_pIMsgRecips->PutDWORD(dwNewRecipIndex, IMMPID_RP_DSN_NOTIFY_VALUE, dwNotifyVal);
hr = m_pIMsgRecips->PutDWORD(dwNewRecipIndex,IMMPID_RP_RECIPIENT_FLAGS, dwNotifyVal);
if(FAILED(hr))
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n", SMTP_NO_STORAGE);
ErrorTrace((LPARAM) this, "Exceeded MaxRcpts %d", TotalRcpts + 1);
}
}
if(!FAILED(hr))
{
PE_CdFormatSmtpMessage (SMTP_RESP_OK, EVALID_DEST_ADDRESS, " %s \r\n",szRcptAddress);
}
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE);
ErrorTrace((LPARAM) this, "Exceeded MaxRcpts %d", TotalRcpts + 1);
}
}
else if (DropQuotaExceeded)
{
PE_CdFormatSmtpMessage (SMTP_INSUFF_STORAGE_CODE, EMAILBOX_FULL, " Mailbox full\r\n");
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOT_FOUND, ENO_FORWARDING, " Unable to relay for %s\r\n", szRcptAddress);
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::HrShouldAcceptRcpt
Description:
Check whether we should accept the recipients
Arguments:
szDomainName
Returns:
HRESULT:
S_OK: we should accept it
S_FALSE: we should not accept it
other error code:
Currently we only return error when HrGetDomainInfoFlags returns AQUEUE_E_SHUTDOWN ( fix for bug 214591 )
or E_OUTOFMEMORY
--*/
HRESULT SMTP_CONNECTION::HrShouldAcceptRcpt(char * szDomainName )
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::HrShouldAcceptRcpt");
HRESULT hr;
DWORD dwDomainInfoFlags;
hr = m_pInstance->HrGetDomainInfoFlags(szDomainName, &dwDomainInfoFlags);
if (SUCCEEDED(hr)) {
if ( (dwDomainInfoFlags & DOMAIN_INFO_LOCAL_MAILBOX) ||
(dwDomainInfoFlags & DOMAIN_INFO_ALIAS) ||
(dwDomainInfoFlags & DOMAIN_INFO_LOCAL_DROP)) {
TraceFunctLeaveEx((LPARAM) this);
return S_OK;
}
else if(dwDomainInfoFlags & DOMAIN_INFO_DOMAIN_RELAY) {
TraceFunctLeaveEx((LPARAM) this);
return S_OK;
}
else if( (m_fAuthenticated && (dwDomainInfoFlags & DOMAIN_INFO_AUTH_RELAY)) ||
DoesClientHaveIpAccess() ) {
TraceFunctLeaveEx((LPARAM) this);
return S_OK;
}
}
else if (AQUEUE_E_SHUTDOWN == hr || E_OUTOFMEMORY == hr)
{
// special case: if Aqueue is already shutdown or we're out of memory, return with error
ErrorTrace((LPARAM) this, "HrGetDomainInfoFlags() failed with 0x%x", hr);
TraceFunctLeaveEx((LPARAM) this);
return hr;
}
else
{
DebugTrace((LPARAM) this, "HrGetDomainInfoFlags() failed with 0x%x", hr);
if(DoesClientHaveIpAccess() ||
(m_fAuthenticated && m_pInstance->RelayForAuthUsers())) {
TraceFunctLeaveEx((LPARAM) this);
return S_OK;
}
}
//
// See if this connection is permitted to relay..
//
if (m_fMayRelay) {
TraceFunctLeaveEx((LPARAM) this);
return S_OK;
}
TraceFunctLeaveEx((LPARAM) this);
return S_FALSE;
}
BOOL SMTP_CONNECTION::ExtractAndValidateRcpt(char * ToName, char ** ppArgument, char * szRcptAddress, char ** ppDomain )
{
DWORD dwAddressLen = 0;
DWORD dwCanonAddrLen = 0;
char * AddrPtr = NULL;
char * CanonAddrPtr = NULL;
//Parse out the address and possible argumets from the input line
if(!Extract821AddressFromLine(ToName,&AddrPtr,&dwAddressLen,ppArgument))
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
//Check if we have valid tail and address
if(!AddrPtr)
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
//Extract the canonical address in the <local-part> "@" <domain> form
if(!ExtractCanonical821Address(AddrPtr,dwAddressLen,&CanonAddrPtr,&dwCanonAddrLen))
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
//If we have a Canonical addr - validate it
if(CanonAddrPtr)
{
strncpy(szRcptAddress,CanonAddrPtr,dwCanonAddrLen);
*(szRcptAddress + dwCanonAddrLen) = '\0';
if(!Validate821Address(szRcptAddress, dwCanonAddrLen))
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
//Extract
if(!Get821AddressDomain(szRcptAddress,dwCanonAddrLen,ppDomain))
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
}
else
{
SetLastError(ERROR_INVALID_DATA);
return FALSE;
}
if(!(*ppDomain) && !ISNULLADDRESS(szRcptAddress))
{
//If there is no domain on this address,
//then append the current domain to this
//address.
if(!m_pInstance->AppendLocalDomain (szRcptAddress))
{
return FALSE;
}
//Update the DomainPtr to be after the '@' sign
//we could be safer and do a strchr
(*ppDomain) = szRcptAddress + dwCanonAddrLen + 1;
}
return TRUE;
}
BOOL SMTP_CONNECTION::BindToStoreDrive(void)
{
SMTP_ALLOC_PARAMS AllocParams;
DWORD Error = 0;
BOOL fRet = FALSE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::BindToStore");
AllocParams.BindInterfacePtr = (PVOID) m_pBindInterface;
AllocParams.IMsgPtr = (PVOID) m_pIMsg;
AllocParams.hContent = NULL;
AllocParams.hr = S_OK;
//For client context pass in something that will stay around the lifetime of the
//atqcontext -
AllocParams.pAtqClientContext = m_pInstance;
if(m_pInstance->AllocNewMessage (&AllocParams) && !FAILED(AllocParams.hr))
{
m_IMsgHandle = AllocParams.hContent;
if(WriteRcvHeader())
{
fRet = TRUE;
}
else
{
Error = GetLastError();
//ProtocolLog(, (char *)InputLine, Error, SMTP_RESP_NORESOURCES, 0, 0);
FatalTrace((LPARAM) this, "WriteRcvHeader failed %d", Error);
SetLastError(Error);
}
}
else
{
FatalTrace((LPARAM) this,
"AllocNewMessage failed hr 0x%08X, GetLastError %d",
AllocParams.hr, GetLastError());
}
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
/*++
Name :
SMTP_CONNECTION::DoDATACommand
Description:
Responds to the SMTP DATA command.
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
both are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoDATACommand(const char * InputLine, DWORD parameterSize)
{
HRESULT hr = S_OK;
DWORD TotalRcpts = 0;
DWORD fIsBinaryMime = 0;
DWORD Error = 0;
_ASSERT(m_pInstance != NULL);
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoDATACommand");
//If the current state is BDAT the only command that can be received is BDAT
if(m_State == BDAT)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","BDAT Expected" );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - BDAT Expected");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(m_pIMsgRecips && m_pIMsg)
{
hr = m_pIMsgRecips->Count(&TotalRcpts);
if(!FAILED(hr))
{
m_pIMsg->PutDWORD( IMMPID_MP_NUM_RECIPIENTS, TotalRcpts );
hr = m_pIMsg->GetDWORD(IMMPID_MP_BINARYMIME_OPTION, &fIsBinaryMime);
}
}
// Cannot use the DATA command if the body type was BINARYMIME
if(!FAILED(hr) && fIsBinaryMime)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n", "Body type BINARYMIME requires BDAT" );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_ARGS - Body type BINARYMIME requires BDAT");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
}
//Only save data if HELO was sent and there is at least one recipient.
//send a message stating "no good recepients",
//or something like that if both lists are empty.
else if(!m_HelloSent)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n", "Send hello first" );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Send hello first");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
}
else if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", "Client was not authenticated");
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_MUST_SECURE, 0, 0);
ErrorTrace((LPARAM) this, "DoDataCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else if (!m_RecvdMailCmd || !m_pIMsg)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","Need mail command." );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Need mail command.");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
}
else if(TotalRcpts)
{
m_cbCurrentWriteBuffer = 0;
if(BindToStoreDrive())
{
m_State = DATA;
if(!m_pInstance->ShouldParseHdrs())
{
m_TimeToRewriteHeader = FALSE;
m_InHeader = FALSE;
}
PE_CdFormatSmtpMessage (SMTP_RESP_START, NULL," %s\r\n",SMTP_START_MAIL_STR);
}
else
{
DWORD dwErr = GetLastError();
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_MEMORY);
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ProtocolLog(DATA, (char *)InputLine, ERROR_NOT_ENOUGH_MEMORY, SMTP_RESP_NORESOURCES, 0, 0);
SmtpLogEventEx(SMTP_EVENT_CANNOT_CREATE_FILE, m_pInstance->GetMailQueueDir(), dwErr);
ErrorTrace((LPARAM) this, "DoDataCommand - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
}
}
else if (!m_RecvdRcptCmd)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Need Rcpt command." );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Need Rcpt command.");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, ESYNTAX_ERROR," %s\r\n", SMTP_NO_VALID_RECIPS );
ProtocolLog(DATA, (char *) InputLine, NO_ERROR, SMTP_RESP_TRANS_FAILED, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_TRANS_FAILED, SMTP_NO_VALID_RECIPS");
++m_ProtocolErrors;
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::DoBDATCommand
Description:
Responds to the SMTP BDAT command. Parses to check if this
is the last BDAT.
Error processing for BDAT is more complex than other SMTP commands
because the RFC forbids a response to BDAT (even error responses that
the server cannot process BDAT). If we try to send an error response
immediately after a BDAT command, we will go out of sync with the
client because the client is not expecting a response... it is trying
to send us chunk data, and the client expects us to have posted a TCP
read to receive the chunk data.
Errors handled by this function fall into 2 categories:
(1) Errors by the client, such as sending improperly formatted
chunksizes, bad syntax for the BDAT command.
(2) Errors such as failure to allocate memory, restrictions on session
size and message size, client must authenticate first, client must
negotiate TLS first, etc.
In the first case, we can reject the command with an error response,
if the BDAT command is garbled, there's not much we can do.
In the second case, we can generate a reasonable error response to be
sent to the client. We should wait for our turn before doing so, i.e.
we should accept and discard the BDAT chunks sent by the client, and
when it it time to ack the chunk, then we send the error response. This
is implemented by setting the m_MailBodyDiagnostic to the appropriate error, and
calling AcceptAndDiscardBDAT which handles receiving and discarding
chunk data and generating error responses when appropriate.
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoBDATCommand(const char * InputLine, DWORD parameterSize)
{
HRESULT hr = S_OK;
DWORD TotalRcpts = 0;
MailBodyDiagnosticCode mailBodyDiagnostic = ERR_NONE;
_ASSERT(m_pInstance != NULL);
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoBDATCommand");
if(m_pIMsgRecips && m_pIMsg)
{
hr = m_pIMsgRecips->Count(&TotalRcpts);
m_pIMsg->PutDWORD( IMMPID_MP_NUM_RECIPIENTS, TotalRcpts );
}
//We parse this command ONLY if we advertise either chunking or binarymime
if(!m_pInstance->AllowChunking() && !m_pInstance->AllowBinaryMime())
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_CMD, EINVALID_COMMAND," %s\r\n", SMTP_NOT_IMPL_STR);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_BAD_CMD, SMTP_NOT_IMPL_STR");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_HelloSent)
{
ProtocolLog(BDAT, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Send hello first");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
mailBodyDiagnostic = ERR_HELO_NEEDED;
}
else if(!m_fAuthAnon && !m_fAuthenticated)
{
ProtocolLog(BDAT, (char *) InputLine, NO_ERROR, SMTP_RESP_MUST_SECURE, 0, 0);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
mailBodyDiagnostic = ERR_AUTH_NEEDED;
}
else if (!m_RecvdMailCmd || !m_pIMsg)
{
ProtocolLog(BDAT, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Need mail command.");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
mailBodyDiagnostic = ERR_MAIL_NEEDED;
}
else if (!m_RecvdRcptCmd)
{
ProtocolLog(BDAT, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_BAD_SEQ - Need Rcpt command.");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
mailBodyDiagnostic = ERR_RCPT_NEEDED;
}
else if (FAILED(hr) || 0 == TotalRcpts)
{
ProtocolLog(BDAT, (char *) InputLine, NO_ERROR, SMTP_RESP_TRANS_FAILED, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_TRANS_FAILED, SMTP_NO_VALID_RECIPS");
++m_ProtocolErrors;
mailBodyDiagnostic = ERR_NO_VALID_RCPTS;
}
char * Argument = (char *) InputLine;
DWORD dwEstMsgSize = 0;
DWORD dwEstSessionSize = 0;
m_nChunkSize = 0;
m_nBytesRemainingInChunk = 0;
// Just parse for size and if this is last chunk
Argument = CheckArgument(Argument);
if (Argument == NULL)
{
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_MBX_SYNTAX, 0,0);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_MBX_SYNTAX, Client sent no CHUNK SIZE");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// make sure the argument is all digits
BOOL fBadChunkSize = FALSE;
for( int i=0; ( ( Argument[i] != 0 ) && ( Argument[i] != ' ' ) ) ; i++ )
{
if( !isdigit( (UCHAR) Argument[i] ) )
{
fBadChunkSize = TRUE;
break;
}
}
// Get the chunk size
m_nChunkSize = atoi (Argument);
m_nBytesRemainingInChunk = m_nChunkSize + m_cbTempBDATLen;
if(m_nChunkSize < 0)
{
fBadChunkSize = TRUE;
}
else if(m_nChunkSize == 0 && m_State != BDAT)
{
// Chunk size may be 0, but not on the first chunk
fBadChunkSize = TRUE;
}
if( fBadChunkSize )
{
PE_CdFormatSmtpMessage (SMTP_RESP_MBX_SYNTAX, ESYNTAX_ERROR," %s\r\n","Invalid CHUNK size value" );
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_MBX_SYNTAX, 0,0);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_MBX_SYNTAX, Client sent 0 as CHUNK SIZE");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
// Add this to the mail already received
// check to make sure we are not going over the servers max message size
dwEstSessionSize = m_nBytesRemainingInChunk + m_SessionSize;
dwEstMsgSize = m_nBytesRemainingInChunk + m_TotalMsgSize;
if(ERR_NONE == mailBodyDiagnostic)
{
if((m_pInstance->GetMaxMsgSize() > 0) && (dwEstMsgSize > m_pInstance->GetMaxMsgSize()))
{
BOOL fShouldImposeLimit = TRUE;
if( FAILED( m_pInstance->TriggerMaxMsgSizeEvent( GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit ) ) || fShouldImposeLimit )
{
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_NOSTORAGE, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_NOSTORAGE, SMTP_MAX_MSG_SIZE_EXCEEDED_MSG - %d", dwEstMsgSize);
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
mailBodyDiagnostic = ERR_MAX_MSG_SIZE;
}
}
}
// Check that we are below the max session size allowed on the Server.
if((m_pInstance->GetMaxMsgSizeBeforeClose() > 0) && (dwEstSessionSize > m_pInstance->GetMaxMsgSizeBeforeClose()))
{
BOOL fShouldImposeLimit = TRUE;
if( FAILED( m_pInstance->TriggerMaxMsgSizeEvent( GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit ) ) || fShouldImposeLimit )
{
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_NOSTORAGE, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_NOSTORAGE, SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG - %d", dwEstSessionSize);
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
// Client won't be expecting this, but atleast an admin can tell
// what's wrong from this response.
FormatSmtpMessage(SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n",
SMTP_MAX_SESSION_SIZE_EXCEEDED_MSG);
SendSmtpResponse();
DisconnectClient();
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
//Check for the presence of the LAST keyword
Argument = strchr(Argument,' ');
if(Argument != NULL)
{
//get rid of white space
while(isspace((UCHAR)*Argument))
Argument++;
if(*Argument != '\0')
{
if(!_strnicmp(Argument,(char *)"LAST",4))
{
//This is the last BDAT chunk
m_fIsLastChunk = TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_MBX_SYNTAX, ESYNTAX_ERROR," %s\r\n", "Invalid CHUNK size value" );
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_MBX_SYNTAX, 0,0);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_MBX_SYNTAX, Client sent 0 as CHUNK SIZE");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
}
// Only the last chunk is allowed to have size = 0
if(!m_fIsLastChunk && m_nChunkSize == 0)
{
PE_CdFormatSmtpMessage(SMTP_RESP_MBX_SYNTAX, ESYNTAX_ERROR," %s\r\n",
"Invalid CHUNK size value" );
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_MBX_SYNTAX, 0,0);
ErrorTrace((LPARAM) this,
"DoBDATCommand - SMTP_RESP_MBX_SYNTAX, Client sent 0 as CHUNK SIZE");
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
m_fIsChunkComplete = FALSE;
if(m_State != BDAT)
{
//we are here for the first time
m_State = BDAT;
m_cbCurrentWriteBuffer = 0;
// If there was an error while processing this BDAT command, flag it (m_MailBodyDiagnostic) & exit.
m_MailBodyDiagnostic = mailBodyDiagnostic;
if(mailBodyDiagnostic != ERR_NONE)
goto Exit;
if(!BindToStoreDrive())
{
//
// Cannot process BDAT due to error accessing mail-store. Flag the error & exit.
//
m_MailBodyError = ERROR_NOT_ENOUGH_MEMORY;
m_MailBodyDiagnostic = ERR_OUT_OF_MEMORY;
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ProtocolLog(BDAT, (char *)InputLine, ERROR_NOT_ENOUGH_MEMORY, SMTP_RESP_NORESOURCES, 0, 0);
ErrorTrace((LPARAM) this, "DoBDATCommand - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - Allocating stream failed");
SmtpLogEventEx(SMTP_EVENT_INVALID_MAIL_QUEUE_DIR , "Invalid Mail Queue Directory", GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
//
// If there was an error during this BDAT, flag it... but if there was an error in a
// previous BDAT command (within the same group of BDATs), preserve it. Once a BDAT fails,
// all subsequent BDATs will fail. m_MailBodyDiagnostic is reset only when a new BDAT group is
// started (the first BDAT in a group of BDATs or RSET).
//
if(m_MailBodyDiagnostic == ERR_NONE) // Don't overwrite
m_MailBodyDiagnostic = mailBodyDiagnostic; // Error during this BDAT
if(m_MailBodyDiagnostic != ERR_NONE) // Should this BDAT succeed?
goto Exit;
// There is no response for BDAT command
if(!m_pInstance->ShouldParseHdrs())
{
m_TimeToRewriteHeader = FALSE;
m_InHeader = FALSE;
}
Exit:
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
void SMTP_CONNECTION::ReleasRcptList(void)
{
IMailMsgRecipients * pRcptList = NULL;
IMailMsgRecipientsAdd * pRcptListAdd = NULL;
pRcptListAdd = (IMailMsgRecipientsAdd *) InterlockedExchangePointer((PVOID *) &m_pIMsgRecips, (PVOID) NULL);
if (pRcptListAdd != NULL)
{
pRcptListAdd->Release();
}
pRcptList = (IMailMsgRecipients *) InterlockedExchangePointer((PVOID *) &m_pIMsgRecipsTemp, (PVOID) NULL);
if (pRcptList != NULL)
{
pRcptList->Release();
}
}
void SMTP_CONNECTION::ReleasImsg(BOOL DeleteIMsg)
{
IMailMsgProperties * pMsg = NULL;
IMailMsgQueueMgmt * pMgmt = NULL;
HRESULT hr = S_OK;
pMsg = (IMailMsgProperties *) InterlockedExchangePointer((PVOID *) &m_pIMsg, (PVOID) NULL);
if (pMsg != NULL)
{
ReleasRcptList();
if(m_pBindInterface)
{
//if(DeleteIMsg)
//{
// m_pBindAtqInterface->ReleaseATQHandle();
//}
m_pBindInterface->Release();
}
if(DeleteIMsg)
{
hr = pMsg->QueryInterface(IID_IMailMsgQueueMgmt, (void **)&pMgmt);
if(!FAILED(hr))
{
pMgmt->Delete(NULL);
pMgmt->Release();
}
}
pMsg->Release();
}
}
/*++
Name :
SMTP_CONNECTION::HandleCompletedMessage
Description:
This function gets called when the client
sends the CRLF.CRLF sequence saying the
message is complete. The function truncates
the message to the current size, if the client
lied and gave us a larger size in the FROM command,
and them queues the message to the Local/Remote
queues for processing.
Arguments:
None.
Returns:
TRUE if the message was written to disk and queued.
FALSE in all other cases.
--*/
BOOL SMTP_CONNECTION::HandleCompletedMessage(DWORD dwCommand, BOOL *pfAsyncOp)
{
DWORD AbOffset = 0;
char MessageId[1024];
HRESULT hr = S_OK;
DWORD TrailerSize = 0; //used to strip out the trailing ".CRLF"
BOOL fPended = FALSE;
BOOL fQRet = TRUE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::HandleCompletedMessage(void)");
_ASSERT(m_pInstance != NULL);
//hack to make transaction logging work
AddCommandBytesRecv(m_TotalMsgSize);
MessageId[0] = 0;
if( m_pIMsg )
{
m_pIMsg->GetStringA( IMMPID_MP_RFC822_MSG_ID, sizeof( MessageId ), MessageId );
m_pIMsg->PutDWORD( IMMPID_MP_MSG_SIZE_HINT, m_TotalMsgSize );
}
MessageId[sizeof(MessageId)-1] = 0; // NULL terminate it.
//Depending on dwCommand the TrailerSize will vary
//For BDAT = 0
//For DATA = 3
if(dwCommand == BDAT )
TrailerSize = 0;
DWORD cbTotalMsgSize = 0;
if( m_fFoundEmbeddedCrlfDotCrlf )
{
cbTotalMsgSize = m_cbDotStrippedTotalMsgSize;
}
else
{
cbTotalMsgSize = m_TotalMsgSize;
}
if(SetFilePointer(m_IMsgHandle->m_hFile, (cbTotalMsgSize + m_HeaderSize) - TrailerSize, NULL, FILE_BEGIN) == 0xFFFFFFFF)
{
m_MailBodyError = GetLastError();
//FatalTrace((LPARAM) this, "SetFilePointer failed on file %s !!! (err=%d)", MailInfo->GetMailFileName(), m_MailBodyError);
m_CInboundContext.SetWin32Status(m_MailBodyError);
ProtocolLog(dwCommand, MessageId, m_MailBodyError, SMTP_RESP_NORESOURCES, 0, 0);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE );
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
if(!SetEndOfFile(m_IMsgHandle->m_hFile))
{
m_MailBodyError = GetLastError();
// FatalTrace((LPARAM) this, "SetEndOfFile failed on file %s !!! (err=%d)", MailInfo->GetMailFileName(), m_MailBodyError);
m_CInboundContext.SetWin32Status(m_MailBodyError);
ProtocolLog(dwCommand, MessageId, m_MailBodyError, SMTP_RESP_NORESOURCES, 0, 0);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE );
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
hr = m_pIMsgRecipsTemp->WriteList(m_pIMsgRecips);
if(FAILED(hr))
{
m_MailBodyError = GetLastError();
//FatalTrace((LPARAM) this, "SetEndOfFile failed on file %s !!! (err=%d)", MailInfo->GetMailFileName(), m_MailBodyError);
m_CInboundContext.SetWin32Status(m_MailBodyError);
ProtocolLog(dwCommand, MessageId, m_MailBodyError, SMTP_RESP_NORESOURCES, 0, 0);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE );
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_pIMsg->PutDWORD( IMMPID_MP_SCANNED_FOR_CRLF_DOT_CRLF, m_fScannedForCrlfDotCrlf );
m_pIMsg->PutDWORD( IMMPID_MP_FOUND_EMBEDDED_CRLF_DOT_CRLF, m_fFoundEmbeddedCrlfDotCrlf );
hr = m_pIMsg->Commit(NULL);
if(FAILED(hr))
{
m_MailBodyError = GetLastError();
//FatalTrace((LPARAM) this, "SetEndOfFile failed on file %s !!! (err=%d)", MailInfo->GetMailFileName(), m_MailBodyError);
m_CInboundContext.SetWin32Status(m_MailBodyError);
ProtocolLog(dwCommand, MessageId, m_MailBodyError, SMTP_RESP_NORESOURCES, 0, 0);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE );
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
ReleasRcptList();
// Fire the end of data event. The default implementation of this
// commits the message
char szVerb[] = "_EOD";
DWORD CmdSize;
m_dwCurrentCommand = SmtpGetCommand(szVerb, sizeof(szVerb), &CmdSize);
BOOL fReturn =
GlueDispatch((char *)szVerb, sizeof(szVerb), CmdSize, pfAsyncOp);
if (!fReturn) {
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
if (*pfAsyncOp) {
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
SendSmtpResponse();
ProtocolLog(dwCommand, MessageId, NO_ERROR, SMTP_RESP_OK, 0, 0);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
/*++
Name :
BOOL SMTP_CONNECTION::RewriteHeader
Description:
This function adds a message ID, and other
headers if they are missing
Arguments:
OUT BOOL *lfWritePended - Set to TRUE is an async write was
pended.
Returns:
FALSE if WriteFile failed
TRUE otherwise
--*/
BOOL SMTP_CONNECTION::RewriteHeader(BOOL *lpfWritePended)
{
char Buffer [MAX_REWRITTEN_HEADERS];
char szMsgId[MAX_REWRITTEN_MSGID];
char MessageId [REWRITTEN_GEN_MSGID_BUFFER];
char szSmtpFromAddress[MAX_INTERNET_NAME + 6] = "smtp:";
char szOriginalArrivalTime[64];
int NumToWrite;
int MsgIdSize = 0;
int CurrentRewriteBufferSize = 0;
*lpfWritePended = FALSE;
//***NOTE***
//If you add *anything* to this function, make sure you update MAX_REWRITTEN_HEADERS
//to support allow room for this as well.
//Rewrite header creates its own buffer and writes out
//add the mail from field if we did not see it.
if(!(m_HeaderFlags & H_FROM))
{
_ASSERT(m_szFromAddress[0] != '\0');
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "From: %s\r\n", m_szFromAddress);
CurrentRewriteBufferSize += NumToWrite;
m_pIMsg->PutStringA( IMMPID_MP_RFC822_FROM_ADDRESS, m_szFromAddress );
strncat(szSmtpFromAddress, m_szFromAddress, MAX_INTERNET_NAME);
}
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
if(!(m_HeaderFlags & H_RCPT))
{
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "Bcc:\r\n");
CurrentRewriteBufferSize += NumToWrite;
}
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
//add the return path field if we did not see it.
if(!(m_HeaderFlags & H_RETURNPATH))
{
_ASSERT(m_szFromAddress[0] != '\0');
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "Return-Path: %s\r\n", m_szFromAddress);
CurrentRewriteBufferSize += NumToWrite;
}
//add the message ID field if we did not see it.
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
if(!(m_HeaderFlags & H_MID))
{
GenerateMessageId (MessageId, sizeof(MessageId));
m_pInstance->LockGenCrit();
MsgIdSize = sprintf( szMsgId, "<%s%8.8x@%s>", MessageId, GetIncreasingMsgId(), m_pInstance->GetFQDomainName());
m_pInstance->UnLockGenCrit();
_ASSERT(MsgIdSize < MAX_REWRITTEN_MSGID);
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "Message-ID: %s\r\n", szMsgId);
szMsgId[sizeof(szMsgId)-1]=0;
CurrentRewriteBufferSize += NumToWrite;
}
if( !( m_HeaderFlags & H_X_ORIGINAL_ARRIVAL_TIME ) )
{
GetSysAndFileTimeAsString( szOriginalArrivalTime );
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "X-OriginalArrivalTime: %s\r\n", szOriginalArrivalTime);
szOriginalArrivalTime[sizeof(szOriginalArrivalTime)-1]=0;
CurrentRewriteBufferSize += NumToWrite;
}
//add the Date field if we did not see it.
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
if(!(m_HeaderFlags & H_DATE))
{
char szDateBuf [cMaxArpaDate];
GetArpaDate(szDateBuf);
NumToWrite = sprintf(Buffer + CurrentRewriteBufferSize, "Date: %s\r\n", szDateBuf);
CurrentRewriteBufferSize += NumToWrite;
}
//Did we see the seperator. If not add one
//blank line to the message
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
if(!(m_HeaderFlags & H_EOH))
{
sprintf(Buffer + CurrentRewriteBufferSize,"\r\n", 2);
CurrentRewriteBufferSize += 2;
}
_ASSERT(MAX_REWRITTEN_HEADERS > CurrentRewriteBufferSize);
if(CurrentRewriteBufferSize)
{
//Write out the data
if(!WriteMailFile(Buffer, CurrentRewriteBufferSize, lpfWritePended))
{
m_MailBodyError = GetLastError();
return FALSE;
}
else if(!*lpfWritePended)
{
//
// Update the header size and message-properties if the data got copied
// to the write-buffer. If a write was pended (because the write buffer is
// currently full), then we will do nothing, and ATQ will call us back when
// the write completes. This code-path will be called again.
//
m_HeaderSize += CurrentRewriteBufferSize;
if(!(m_HeaderFlags & H_FROM))
m_pIMsg->PutStringA( IMMPID_MP_FROM_ADDRESS, szSmtpFromAddress );
if(!(m_HeaderFlags & H_MID))
{
if( FAILED( m_pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_ID, szMsgId ) ) )
return FALSE;
}
if(!(m_HeaderFlags & H_X_ORIGINAL_ARRIVAL_TIME))
{
if( FAILED( m_pIMsg->PutStringA(
IMMPID_MP_ORIGINAL_ARRIVAL_TIME,
szOriginalArrivalTime ) ) )
return FALSE;
}
}
}
return TRUE;
}
/*++
Name :
SMTP_CONNECTION::CreateMailBody
Description:
Responds to the SMTP data command.
This funcion spools the mail to a
directory
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
UndecryptedTailSize -- amount of undecrypted data at end of buffer
Returns:
TRUE if all data(incliding terminating .)
has been received
FALSE on all errors (disk full, etc.)
--*/
BOOL SMTP_CONNECTION::CreateMailBody(char * InputLine, DWORD ParameterSize,
DWORD UndecryptedTailSize, BOOL *lfWritePended)
{
BOOL MailDone = FALSE;
DWORD IntermediateSize = 0;
PCHAR pszSearch = NULL;
DWORD TotalMsgSize = 0;
char c1, c2;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::CreateMailBody");
_ASSERT (m_pInstance != NULL);
_ASSERT (m_cbParsable <= QueryMaxReadSize());
// 7/2/99 MILANS
// The following if statement is completely unnecessary. One should not adjust the line
// state at the beginning of this function - rather, they should do so as a line is scanned
// and, for the final (potentially partial) line at the end, when they move the (partial) line
// as the last step in this function.
// Nevertheless, in the light of the time, I am leaving the if statement in place.
//the state of the line completion parsing automaton is to be set to the initial state if
//for each line except the following case:
//if the buffer was full in the last iteration --- the data got shifted out and now we are
//parsing the newly read data. so the state of the line completion automaton must
if(!m_BufrWasFull)
m_LineCompletionState = SEEN_NOTHING; //automaton state for IsLineCompleteRFC822
m_BufrWasFull = FALSE;
while ((pszSearch = IsLineCompleteRFC822(InputLine, m_cbParsable, UndecryptedTailSize, &m_BufrWasFull)) != NULL)
{
//If the buffer is full and we are not using the entire buffer; then some of the data in the full
//buffer is data that we have already parsed and processed in preceding iterations. we can discard
//this data and read in fresh data which may have the CRLFx we are looking for. to do this, break
//out of this loop, move inputline to the beginning of buffer (done outside loop) and just return.
//a read is pended and this function is called with freshly read data appended to the "inadequate
//data". If even then the no CRLFx is found, and the buffer is filled up, we need to start truncation.
if(m_BufrWasFull && InputLine > QueryMRcvBuffer())
break;
_ASSERT (m_cbParsable <= QueryMaxReadSize());
//stuff in CRLF if it wasn't there
if(!m_Truncate && m_BufrWasFull)
{
c1 = *pszSearch;
c2 = *(pszSearch+1);
*pszSearch = CR;
*(pszSearch+1) = LF;
}
IntermediateSize = (DWORD)(pszSearch - InputLine);
TotalMsgSize = m_TotalMsgSize + (IntermediateSize + 2);
//don't write the '.' to the file
if( (InputLine [0] == '.') && (IntermediateSize == 1) && !m_LongBodyLine )
{
//the minimum message size is 3 (.CRLF). If we are done, and the size
//of the message is 3 bytes, that means that the body of the message
//is missing. So, just write the headers and go.
if(TotalMsgSize == 3 && m_TimeToRewriteHeader)
{
if(!RewriteHeader(lfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
return TRUE;
}
else if(*lfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_TimeToRewriteHeader = FALSE;
}
//We are at the end of the message flush our write buffer
//if there is something in it
if(!WriteMailFile(NULL, 0, lfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
return TRUE;
}
else if(*lfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_cbParsable -= 3; // 1for the . + 2 for CRLF
m_cbReceived = m_cbParsable + UndecryptedTailSize;
if(m_cbReceived)
{
//we need to +2 to pszSearch because it points to the CR character
MoveMemory ((void *)QueryMRcvBuffer(), pszSearch + 2, m_cbReceived);
}
//DebugTrace((LPARAM) this, "got ending dot for file %s", MailInfo->GetMailFileName());
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_Truncate && m_InHeader && ( m_MailBodyError == NO_ERROR ))
{
//the code I stole from SendMail assumes the
//line has a terminating '\0', so we terminate
//the line. We will put back the carriage
//return later.
*pszSearch = '\0';
char *pszValueBuf = NULL;
//remove header. return false if the line is not a header or the line is NULL
//chompheader returns everything after ":" into pszValueBuf
if( m_InHeader = ChompHeader( InputLine, m_HeaderFlags, &pszValueBuf) )
{
GetAndPersistRFC822Headers( InputLine, pszValueBuf);
if(FAILED(m_MailBodyError))
{
ErrorTrace((LPARAM) this, "Error persisting 822 headers 0x%08x", m_MailBodyError);
m_MailBodyDiagnostic = ERR_RETRY;
*pszSearch = CR;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
else
{
//in case we have <header><CRLF><CRLF><sp><body><CRLF><x> we have seen
//an end of header after the 1st <CRLF> but because IsLineComplete822 halts at
//the third <CRLF> the inputstring to ChompHeader() is
//<CRLF><sp><body><NULL> rather than just <NULL> had there been no <sp> after
//the second <CRLF>. Thus ChompHeader will not set the EOH flag correctly.
//we do this here.
if( InputLine[0] == CR &&
InputLine[1] == LF &&
(InputLine[2] == ' ' || InputLine[2] == '\t') )
m_HeaderFlags |= H_EOH;
}
*pszSearch = CR;
}
//If we are not in the header and this is
//the first time m_TimeToRewriteHeader is
//TRUE, then add any missing headers we
//care about. Set m_TimeToRewriteHeader
//to false so that we don't enter this
//part of the code again. If ReWriteHeader
//fails, we are probably out of disk space,
//so set m_NoStorage to TRUE such that we
//don't waste our time writing to disk.
//We still have to accept the mail, but we
//throw it away. We will send a message
//back to our client when all is done.
if(!m_InHeader && m_TimeToRewriteHeader && (m_MailBodyError == NO_ERROR))
{
//So there was nothing to write so now write headers
if(!RewriteHeader(lfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
return TRUE;
}
else if(*lfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_TimeToRewriteHeader = FALSE;
}
//restore InputLine for mail file write, if we put in a CRLF
if(!m_Truncate && m_BufrWasFull)
{
*pszSearch = c1;
*(pszSearch + 1) = c2;
}
char *pInputLine = InputLine;
DWORD cbIntermediateSize = IntermediateSize + 2;
if(m_MailBodyError == NO_ERROR)
{
//if we had a full buffer without CRLFx in the previous iteration, we did a
//MoveMemory() and the beginning of the buffer is not the beginning of the line.
//dot stripping is only done for the beginning of the line.
if( !m_LongBodyLine )
{
if( *pInputLine == '.' )
{
pInputLine++;
cbIntermediateSize --;
m_fFoundEmbeddedCrlfDotCrlf = TRUE;
}
}
//write to the file if we have not gone over our alloted limit
//and if WriteFile did not give us back any errors
if((m_pInstance->GetMaxMsgSize() > 0) ||
(m_pInstance->GetMaxMsgSizeBeforeClose() > 0))
{
BOOL fShouldImposeLimit = TRUE;
// if the total msg size is not exceeded continue writing to file.
// Else, trigger the MaxMsgSize event to see
// if we can continue to write to the file.
if ( m_pInstance->GetMaxMsgSize() > 0 && TotalMsgSize > m_pInstance->GetMaxMsgSize() )
{
if( FAILED( m_pInstance->TriggerMaxMsgSizeEvent( GetSessionPropertyBag(), m_pIMsg, &fShouldImposeLimit ) ) || fShouldImposeLimit )
{
m_MailBodyError = ERROR_ALLOTTED_SPACE_EXCEEDED;
m_MailBodyDiagnostic = ERR_MAX_MSG_SIZE;
ProtocolLog(BDAT, (char *)InputLine, NO_ERROR, SMTP_RESP_NOSTORAGE, 0, 0);
ErrorTrace((LPARAM) this, "SMTP_RESP_NOSTORAGE, SMTP_MAX_MSG_SIZE_EXCEEDED_MSG - %d", TotalMsgSize);
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToSize);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
if(!WriteMailFile(pInputLine, cbIntermediateSize , lfWritePended))
{
m_MailBodyError = GetLastError();
m_MailBodyDiagnostic = ERR_RETRY;
return TRUE;
}
else if(*lfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
else if (!WriteMailFile(pInputLine, cbIntermediateSize, lfWritePended))
{
m_MailBodyError = GetLastError();
m_MailBodyDiagnostic = ERR_RETRY;
return TRUE;
}
else if(*lfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
//We managed to copy data to write buffer without having to write
//out
m_cbParsable -= IntermediateSize + 2;
m_cbReceived -= IntermediateSize + 2;
m_TotalMsgSize += IntermediateSize + 2;
m_cbDotStrippedTotalMsgSize += cbIntermediateSize;
m_cbRecvBufferOffset += IntermediateSize + 2;
_ASSERT (m_cbParsable <= QueryMaxReadSize());
InputLine = pszSearch + 2; //if m_BufrWasFull && UndecryptedTailSize == 0 then InputLine is pointing
//1 byte beyond end of allocated storage; this is not an error.
//if the buffer is filled up:
//since we are done parsing it, we can discard it. this is done by setting m_cbParsable to 0
//then we quit the IsLineComplete loop so that we can exit this function and pend a read for
//fresh data. If the buffer was filled up, it also means that a CRLFx was not found, so we
//ought to enter truncation mode (unless we have already done so) because this line was too
//long.
if(m_BufrWasFull)
{
// raid 196100 - We should not flush all buffers since it may contain some chars we want to save.
//m_cbParsable = 0;
m_LongBodyLine = TRUE; //Next return of pszSearch in while() is not beginning of a new line.
if(!m_Truncate)
m_Truncate = TRUE; //this looks silly... but the point is simply that we are "switching"
break; //states, to truncation mode. The if() reminds you that it is possible
} //to be in truncation mode already.
//if the buffer still has room:
//IsLineComplete returned because it found a CRLFx. in normal (non truncation mode) processing
//this case means nothing, but if we were in truncation mode, then it means that we have hit the
//end of the header we were truncating, so we need to get back to normal mode.
else
{
m_LongBodyLine = FALSE;
if(m_Truncate)
m_Truncate = FALSE;
}
}
if(m_cbParsable != 0)
{
//if there is stuff left in the buffer, move it up
//to the top, then pend a read at the end of where
//the last data left off
_ASSERT (m_cbParsable <= QueryMaxReadSize());
m_cbReceived = m_cbParsable + UndecryptedTailSize;
MoveMemory ((void *)QueryMRcvBuffer(), InputLine, m_cbReceived);
m_cbRecvBufferOffset = 0;
m_LineCompletionState = SEEN_NOTHING;
}
else
{ // m_cbParsable == 0
m_cbReceived = UndecryptedTailSize;
if(m_cbReceived > 0) //anything to move?
MoveMemory ((void *)QueryMRcvBuffer(), InputLine, m_cbReceived);
m_cbRecvBufferOffset = 0;
m_LineCompletionState = SEEN_NOTHING;
}
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
/*++
NAME: SMTP_CONNECTION::IsLineCompleteRFC822
DESCRIPTION:
Parses InputLine till it encounters a CRLFx where x is a nontab
and nonspace character. When CRLFx is found it means that the true
end of a line has been found, in other words ... there are no more
continuations of this line.
Implementation is as a finite state machine (FSM).
The SMTP_CONNECTION member m_LineCompletion keeps track of the
state of the FSM between calls so that if the FSM does not hit
its exit state (CRLFx found) by the time it has scanned the input,
the caller may obtain more input data and resume the parsing. Thus
this member variable is "implicitly" passed to the function.
If the message receive buffer (returned by QueryMRcvBuffer()) is
filled up, so that the caller has no chance of getting more data
(since there is no space), this function returns a pointer to the
last but one item in InputLine and sets the flag FullBuffer. The
purpose being that the caller can put a CRLF at the position
returned and proceed as though CRLFx had been found.
A special condition occurs if the InputLine starts off as .CRLF
and the initial state is 1. This means that either the message is
just .CRLF or a CRLF.CRLF has been found. Thus the end of the message
has been found and the function returns.
PARAMETERS:
InputLine Input data
nBytes Bytes to parse
UndecryptedTailSize Data that occupies buffer space but can't
be parsed
p_FullBuffer If the function fails to find CRLFx, is there
enough room left in the buffer so that we can
get more input from the user?
m_LineCompletionState Implicit parameter... you need to Initialize
this.
RETURNS:
Pointer to CR if CRLFx found
Pointer to second last byte of buffer if there is no CRLFx
NULL if there is no CRLFx and the buffer is not full.
--*/
char * SMTP_CONNECTION::IsLineCompleteRFC822(
IN char *InputLine,
IN DWORD nBytes,
IN DWORD UndecryptedTailSize,
OUT BOOL *p_FullBuffer
)
{
ASSERT(InputLine);
char *pCh;
char *pLastChar = InputLine + nBytes - 1; //end of input
DWORD dwSave = 0;
//One exceptional case : the last line of input
if(nBytes >= 3)
{
if(InputLine[0] == '.' && InputLine[1] == CR && InputLine[2] == LF)
{
*p_FullBuffer = FALSE;
return &InputLine[1];
}
}
for(pCh = InputLine; pCh <= pLastChar; pCh++)
{
switch(m_LineCompletionState)
{
case SEEN_NOTHING: //need CR
if(*pCh == CR) {
m_LineCompletionState = SEEN_CR; //seen CR go on to state_2
dwSave = 1; // save CR if necessary
}
break;
case SEEN_CR: //seen CR need LF
if(*pCh == LF) {
m_LineCompletionState = SEEN_CRLF; //seen LF goto state_3
dwSave = 2; // save CRLF if necessary
} else if(*pCh != CR) {
m_LineCompletionState = SEEN_NOTHING;//if CR stay in this state, else go back to 1
dwSave = 0;
}
break;
case SEEN_CRLF: //seen CRLF, need x
if(*pCh != ' ' && *pCh != '\t') //CRLFx found
{
*p_FullBuffer = FALSE;
m_LineCompletionState = SEEN_NOTHING; //seen CRLFx, go back to initial state
return pCh - 2; //returning pointer to the CR
} else {
m_LineCompletionState = SEEN_NOTHING; //didn't get either x or CR, nothing matched --- start over again.
dwSave = 0;
}
break;
}
}
//buffer is full && CRLFx not found.
// raid 196100 - we need to save some bytes (CR, LF, or CRLF) if necessary
// when buffer is full
if(*p_FullBuffer = (pLastChar >= QueryMRcvBuffer() + QueryMaxReadSize() - UndecryptedTailSize - 1))
return pLastChar - 1 - dwSave; //assumption: nbytes is atleast 2
return NULL; //buffer has room left && CRLFx not found
}
/*++
Name :
SMTP_CONNECTION::CreateMailBodyFromChunk
Description:
Responds to the SMTP BDAT command.
This function spools the mail to a
directory keeping track of chunk size
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
UndecryptedTailSize -- amount of undecrypted data at end of buffer
Returns:
TRUE if all data(incliding terminating .)
has been received
FALSE on all errors (disk full, etc.)
--*/
BOOL SMTP_CONNECTION::CreateMailBodyFromChunk (char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize, BOOL *lpfWritePended)
{
BOOL MailDone = FALSE;
DWORD IntermediateSize = 0;
PCHAR pszSearch = NULL;
char MailFileName[MAX_PATH];
DWORD TotalMsgSize = 0;
DWORD SessionSize = 0;
// HRESULT hr;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::CreateMailBodyFromChunk");
_ASSERT (m_pInstance != NULL);
_ASSERT (m_cbParsable <= QueryMaxReadSize());
MailFileName[0] = '\0';
//
// m_cbTempBDATLen is used to save BDAT chunk bytes for headers spanning multiple
// BDAT chunks. So we need to parse from the very beginning of the buffer if there
// are saved BDAT header bytes.
//
if(m_cbTempBDATLen)
{
InputLine = QueryMRcvBuffer();
}
//
// Process the chunk data line-by-line till a line is encountered which is not a
// header. At this point m_InHeader is set to FALSE and we never enter this loop
// again. Instead all chunk data will be directly dumped to disk as the mail body.
//
// It can be determined that a line is either header/non-header if:
// - It is CRLF terminated (it can be examined for the header syntax)
// - If we have 1000+ bytes without a CRLF it is not a header
//
// If it does not meet either condition, we must save the data (set m_cbTempBDATLen)
// and post a read for the next chunk hoping that with the fresh data, either of the
// two conditions will apply.
//
while (m_InHeader &&
((pszSearch = IsLineComplete((const char *)InputLine, m_cbParsable)) != NULL ||
m_cbParsable > 1000 ||
m_cbParsable >= (DWORD)m_nBytesRemainingInChunk))
{
_ASSERT (m_cbParsable <= QueryMaxReadSize());
// Found a CRLF in the received data
if(pszSearch != NULL)
{
IntermediateSize = (DWORD)(pszSearch - InputLine);
TotalMsgSize = m_TotalMsgSize + (IntermediateSize + 2);
//
// There are IntermediateSize+2 bytes in this CRLF terminated line.
// If that is > the number of bytes in the current BDAT chunk:
// - The chunk was fully received
// - Some extra bytes (pipelined SMTP command) were received after it.
// - The CRLF found by IslineComplete is outside this chunk.
//
if(( m_nBytesRemainingInChunk - ((int)IntermediateSize + 2) ) < 0)
{
if(m_fIsLastChunk || m_nBytesRemainingInChunk > 1000)
{
//
// We're done with header parsing because either:
// - This is the last BDAT chunk OR
// - We have 1000 bytes of mailbody data without a CRLF
//
m_InHeader = FALSE;
}
else
{
//
// In this else-block the following is true:
// - This is not the last BDAT chunk
// - We have < 1000 bytes in the current BDAT chunk
// - The CRLF (pszSearch) is outside the current BDAT chunk
// - We still haven't hit a non-header line
//
// We do not know if this is a header. This chunk is saved
// as the first m_cbTempBDATLen bytes in the recv buffer. The
// next chunk is appended to this and both will be processed
// together.
//
m_cbTempBDATLen = m_nBytesRemainingInChunk;
m_nBytesRemainingInChunk = 0;
break;
}
}
//look for all the headers we care about.
//If we are out of storage, forget it.
if(m_InHeader && (m_MailBodyError == NO_ERROR))
{
//For parsing we terminate the line.
//We will put back the carraige return later
*pszSearch = '\0';
//skip over continuation lines
if((InputLine[0] != ' ') && (InputLine[0] != '\t'))
{
char *pszValueBuf = NULL;
//see if we are still in the header portion
//of the body
if (m_InHeader = ChompHeader(InputLine, m_HeaderFlags, &pszValueBuf))
{
//Process and Promote RFC822 Headers
GetAndPersistRFC822Headers( InputLine, pszValueBuf );
}
}
//put back the carraige return
*pszSearch = CR;
}
}
else if((m_cbParsable > 1000) || m_fIsLastChunk)
{
//We could not parse the line inspite of having 1000 parsable bytes
//That tells me it is not a 822 header
m_InHeader = FALSE;
}
else
{
//We do not have a parsed line and we have not exceeded the 1000byte
//limit - looks like what we have is a partial header line
//Keep the data around
m_cbTempBDATLen = m_nBytesRemainingInChunk;
m_nBytesRemainingInChunk = 0;
break;
}
//if we are done with headers break
if(!m_InHeader)
break;
//We are still processing headers
if(m_MailBodyError == NO_ERROR)
{
if(!WriteMailFile(InputLine, IntermediateSize + 2, lpfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
m_InHeader = FALSE;
}
else if(*lpfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//Update the remaining bytes expected in this chunk
else
{
//Once we write out chunk data - we should no longer have any saved of portion of chunk
//
m_cbTempBDATLen = 0;
m_nBytesRemainingInChunk -= IntermediateSize + 2;
}
}
else
m_InHeader = FALSE;
InputLine = pszSearch + 2;
m_cbParsable -= (IntermediateSize + 2);
m_cbReceived -= IntermediateSize + 2;
m_TotalMsgSize += IntermediateSize + 2;
m_cbRecvBufferOffset += (IntermediateSize + 2);
_ASSERT (m_cbParsable < QueryMaxReadSize());
}//end while
// If we are done with headers - it is time to write any missing headers
if(!m_InHeader && m_TimeToRewriteHeader && (m_MailBodyError == NO_ERROR))
{
//So there was nothing to write so now write headers
if(!RewriteHeader(lpfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
ErrorTrace( (LPARAM)this, "Rewrite headers failed. err: %d",m_MailBodyError);
}
else if(*lpfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_TimeToRewriteHeader = FALSE;
}
//If we did write something during our header parsing we need to update m_cbReceived
m_cbReceived = m_cbParsable + UndecryptedTailSize;
// Now that we are thru with headers and there is more data in the buffer
// that is part of the chunk - simply dump it to disk asynchronously
if(!m_InHeader && m_nBytesRemainingInChunk && m_cbParsable)
{
DWORD dwBytesToWrite = m_nBytesRemainingInChunk;
// Simply write the parsable data or the remaining bytes in this chunk
// to the file - which ever is smaller
if(m_nBytesRemainingInChunk > (int) m_cbParsable)
dwBytesToWrite = m_cbParsable;
if(m_MailBodyError == NO_ERROR)
{
//write to the file if we ahve had no errors
if(!WriteMailFile(InputLine, dwBytesToWrite, lpfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
}
else if(*lpfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//Now that we have copied stuff to out buffer
//update the state data
m_TotalMsgSize += dwBytesToWrite;
m_nBytesRemainingInChunk -= dwBytesToWrite;
//We are down to last bytes - keep a track of trailing CRLF
if(m_fIsLastChunk && (m_nBytesRemainingInChunk < 2) )
{
//We have the second last byte - there is one more byte to be read.
if(m_nBytesRemainingInChunk)
{
if(*(InputLine + dwBytesToWrite -1) == '\r')
m_dwTrailerStatus = CR_SEEN;
else
m_dwTrailerStatus = CR_MISSING;
}
else if(dwBytesToWrite > 1) //We got the last byte
{
//We have last two bytes together
if(!strncmp((InputLine + dwBytesToWrite - 2),"\r\n", 2))
m_dwTrailerStatus = CRLF_SEEN;
else
m_dwTrailerStatus = CRLF_NEEDED;
}
else if(m_dwTrailerStatus == CR_SEEN && (*(InputLine + dwBytesToWrite -1) == '\n'))
m_dwTrailerStatus = CRLF_SEEN;
else
m_dwTrailerStatus = CRLF_NEEDED;
}
//Update IO buffer parameters to reflect the state after WRITE
m_cbReceived -= dwBytesToWrite;
m_cbParsable -= dwBytesToWrite;
//Once we write out chunk data - we should no longer have any saved of portion of chunk
//
m_cbTempBDATLen = 0;
m_cbRecvBufferOffset = 0;
}
InputLine += dwBytesToWrite;
_ASSERT (m_cbParsable < QueryMaxReadSize());
}
//Adjust the buffer for the next read only if did comsume any data
//and there is more data remaining in the input buffer
//
if(m_cbReceived && (QueryMRcvBuffer() != InputLine))
{
MoveMemory ((void *)QueryMRcvBuffer(), InputLine, m_cbReceived);
}
m_cbRecvBufferOffset = 0;
//If we are done with current chunk
if(!m_nBytesRemainingInChunk)
{
if(m_MailBodyError == NO_ERROR)
{
if(m_fIsLastChunk)
{
//we are done with all the chunks
//We have written the Last chunk and need to see if we need to put the trailing CRLF
if(m_dwTrailerStatus == CRLF_NEEDED)
{
if(!WriteMailFile("\r\n", 2, lpfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
}
else if(*lpfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_TotalMsgSize += 2;
m_dwTrailerStatus = CRLF_SEEN;
}
//Flush all the data to disk
if(!WriteMailFile(NULL, 0, lpfWritePended))
{
m_MailBodyDiagnostic = ERR_RETRY;
m_MailBodyError = GetLastError();
}
else if(*lpfWritePended)
{
//Go away - Atq will call us back when the write file completes
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//Go back to HELO state
m_State = HELO;
m_fIsChunkComplete = FALSE;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
else
{
//Chunk completion response
ProtocolLog(BDAT, (char *) MailFileName, NO_ERROR, SMTP_RESP_OK, 0, 0);
FormatSmtpMessage (SMTP_RESP_OK, EMESSAGE_GOOD," %s, %d Octets\r\n", SMTP_BDAT_CHUNK_OK_STR, m_nChunkSize );
}
m_fIsChunkComplete = TRUE;
}
else
{
// We had error during handling the Chunk, now that chunk has been consumed
//we can respond with an error
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
/*++
Name :
SMTP_CONNECTION::DoDATACommandEx
Description:
Responds to the SMTP data command.
This funcion spools the mail to a
directory
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
Returns:
Currently this function always returns TRUE.
--*/
BOOL SMTP_CONNECTION::DoDATACommandEx(const char * InputLine1, DWORD ParameterSize, DWORD UndecryptedTailSize,BOOL *lpfWritePended, BOOL *pfAsyncOp)
{
LPSTR InputLine = (LPSTR) InputLine1;
BOOL fRet = TRUE;
BOOL fProcess = TRUE;
PSMTP_IIS_SERVICE pService = (PSMTP_IIS_SERVICE) g_pInetSvc;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoDATACommandEx");
_ASSERT (m_pInstance != NULL);
//
// we scan for <CRLF>.<CRLF> when processing the msg body of the DATA
// command.
//
m_fScannedForCrlfDotCrlf = TRUE;
if(CreateMailBody(InputLine, ParameterSize, UndecryptedTailSize, lpfWritePended))
{
if(m_MailBodyDiagnostic != NO_ERROR)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//increment our counters
//make sure the size of the file is proper.
//subtract 3 bytes accounting for the .CRLF.
//We don't write that portion to the file.
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesRcvdMsg, (m_TotalMsgSize - 3));
BUMP_COUNTER(QuerySmtpInstance(), NumMsgRecvd);
//if there was no error while parsing the
//header, and writimg the file to disk,
//then save the rest of the file, send
//a message id back to the client, and
//queue the message
if(m_MailBodyError == NO_ERROR)
{
//call HandleCompletedMessage() to see
//if we should process this message
HandleCompletedMessage(DATA, pfAsyncOp);
if (*pfAsyncOp) {
m_fAsyncEOD = TRUE;
return TRUE;
}
//We got all the data and written it to disk.
//Now, we'll pend a read to pick up the quit
//response, to get any other mail the client
//sends. We need to re-initialize our class
//variables first.
ReInitClassVariables();
_ASSERT (m_cbReceived < QueryMaxReadSize());
}
else
{
//else, format the appropriate message,
//and delete all objects pertaining to
//this file.
//flush any pending responses
SendSmtpResponse();
//re-initialize out class variables
ReInitClassVariables();
_ASSERT (m_cbReceived < QueryMaxReadSize());
}
}
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
//-----------------------------------------------------------------------------
// Description:
// This function handles receiving the mailbody sent by a client using the
// DATA command. It wraps the functionality of DoDATACommandEx (the
// function to parse and process the mailbody) and AcceptAndDiscardDATA
// (the function that handles errors that occur during DoDATACommandEx).
//
// The reason for a separate function to do error processing for mailbody
// errors is that when a mailbody error occurs, SMTP cannot directly abort
// the transaction and return an error response. Instead it must continue
// to post reads for the mailbody, and after the mailbody has been completely
// received, respond with the appropriate error.
//
// So when an error occurs during DoDATACommandEx, it stops processing and
// sets m_MailBodyDiagnostic. AcceptAndDiscardData takes over and keeps
// posting reads till the body has been sent by the client. Then it uses
// m_MailBodyDiagnostic to generate the error response.
//
// Arguments:
// IN char *InputLine - Pointer to data being processed
// IN DWORD UndecryptedTailSize - If using SSL, this is the encrypted tail
// OUT BOOL *pfAsyncOp - Set to TRUE if a read of write was pended. In
// this case.
// Returns:
// TRUE - Success. All received data must be passed into this function
// till the state goes to HELO after which data should be parsed as
// SMTP commands. Failures while processing DATA are caught internally
// (flagged by m_MailBodyDiagnostic and m_MailBodyError) and we still
// return TRUE.
// FALSE - A failure occurred that cannot be handled (like a TCP/IP
// failure). In this case we should disconnect.
//
//-----------------------------------------------------------------------------
BOOL SMTP_CONNECTION::ProcessDATAMailBody(const char *InputLine, DWORD UndecryptedTailSize, BOOL *pfAsyncOp)
{
BOOL fReturn = TRUE;
BOOL fWritePended = FALSE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessDATA");
_ASSERT(m_State == DATA);
*pfAsyncOp = FALSE;
if(m_MailBodyDiagnostic != ERR_NONE)
goto MAILBODY_ERROR;
//
// DoDATACommandEx handles parsing the mailbody, processing the headers and
// persisting them to the IMailMsg, and writing the mailbody to a file. In
// addition, when the mailbody has been received, it triggers the _EOD event
// which may return async (due to installed event handlers). We pre-increment
// the pending IO count to cover this case.
//
IncPendingIoCount();
fReturn = DoDATACommandEx(InputLine, m_cbParsable, UndecryptedTailSize, &fWritePended, pfAsyncOp);
_ASSERT(fReturn && "All errors are flagged by m_MailBodyDiagnostic and m_MailBodyError");
//
// DoDATACommandEx/CreateMailBody always return immediately after they pend I/Os
// (expecting the I/O completion threads to resume processing). So if the I/O pend
// succeeds, DoDATACommandEx must have succeeded.
//
if(*pfAsyncOp || fWritePended)
_ASSERT(m_MailBodyDiagnostic == ERR_NONE);
if(*pfAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Decrement the pending IO count since DoDataCommandEx returned sync (and
// we incremented the count above). ProcessClient is above us in the
// callstack and always has a pending IO reference, so this should never
// return zero
//
_VERIFY(DecPendingIoCount() > 0);
//
// If a Write was pended we simply want to release this thread back to IIS
// The completion thread will continue with the processing
//
if(fWritePended)
{
*pfAsyncOp = TRUE;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(m_MailBodyDiagnostic != ERR_NONE)
{
_ASSERT(!*pfAsyncOp && !fWritePended);
//
// Shift out bytes that already got parsed during DoDATACommandEx.
//
MoveMemory(QueryMRcvBuffer(), QueryMRcvBuffer() + m_cbRecvBufferOffset, m_cbParsable);
m_cbRecvBufferOffset = 0;
goto MAILBODY_ERROR;
}
if(m_State == DATA)
{
//
// If the state is still equal to DATA, then we need to keep
// pending reads to pickup the rest of the message. When the
// state changes to HELO, then we can stop pending reads, and
// go back into parsing commands.
//
fReturn = PendReadIO(UndecryptedTailSize);
*pfAsyncOp = TRUE;
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//
// Done with mail body. Go back to parsing commands.
//
_ASSERT(m_State == HELO);
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
MAILBODY_ERROR:
_ASSERT(m_MailBodyDiagnostic != ERR_NONE);
//
// DoBDATCommandEx (and other parts of smtpcli) use m_cbRecvBufferOffset to
// keep track of bytes in the beginning of the recv buffer that have been
// processed, but have not been shifted out (this is needed for header parsing).
// All reads/processing therefore start at (recv buffer + offset). During error
// processing however there's no parsing of headers, so this offset should be
// set to 0 before calling into discard, and the saved bytes shifted out. The
// ASSERT below verifies this.
//
_ASSERT(m_cbRecvBufferOffset == 0 && "All of recv buffer is not being used");
fReturn = AcceptAndDiscardDATA(QueryMRcvBuffer(), UndecryptedTailSize, pfAsyncOp);
//
// If something failed during error processing, disconnect with an error
// (this violates the RFC, but there's no option). If we succeeded and a
// read was pended, all data in the input buffer has been consumed. The
// read I/O completion thread will pick up processing.
//
if(!fReturn || *pfAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//
// All the mailbody was processed and the input buffer contains only SMTP
// commands. Fall through the the command parsing code.
//
_ASSERT(m_State == HELO);
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
//-----------------------------------------------------------------------------
// Description:
// Analogous to ProcessDATAMailBody
// Arguments:
// Same as ProcessDATAMailBody
// Returns:
// Same as ProcessDATAMailBody
//-----------------------------------------------------------------------------
BOOL SMTP_CONNECTION::ProcessBDATMailBody(const char *InputLine, DWORD UndecryptedTailSize, BOOL *pfAsyncOp)
{
BOOL fWritePended = FALSE;
BOOL fReturn = FALSE;
_ASSERT(!m_fIsChunkComplete && m_State == BDAT);
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessBDATMailBody");
*pfAsyncOp = FALSE;
//
// We are in the midst of error processing, skip right to it.
//
if(m_MailBodyDiagnostic != ERR_NONE)
goto MAILBODY_ERROR;
//
// Increment the pending IO count in case DoBDATCommandEx returns async.
// When the message is completely received, DoBDATCommandEx will trigger
// into the _EOD event, which may optionally return async. This increment
// serves to keep track of that.
//
IncPendingIoCount();
fReturn = DoBDATCommandEx(InputLine, m_cbParsable, UndecryptedTailSize, &fWritePended, pfAsyncOp);
if(m_MailBodyDiagnostic != ERR_NONE)
{
_ASSERT(!fWritePended && !*pfAsyncOp && "Shouldn't be pending read/write on failure");
_VERIFY(DecPendingIoCount() > 0);
goto MAILBODY_ERROR;
}
// The completion thread will call us when more data arrives
if (*pfAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Decrement the pending IO count since DoBDATCommandEx returned sync (and
// we incremented the count above). ProcessClient is above us in the
// callstack and always has a pending IO reference, so this should never
// return zero
//
_VERIFY(DecPendingIoCount() > 0);
//
// If a Write was pended we simply want to release this thread back to IIS
// The completion thread will continue with the processing
//
if(fWritePended)
{
*pfAsyncOp = TRUE;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(m_State == BDAT && !m_fIsChunkComplete)
{
//
// We still are not done with current chunk So Pend read to pickup the
// rest of the chunk. When the state changes to HELO or the current
// chunk completes, then we can stop pending reads, and go back into
// parsing commands.
//
fReturn = PendReadIO(UndecryptedTailSize);
*pfAsyncOp = TRUE;
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
else if(m_cbTempBDATLen)
{
//
// Flush the response to the chunk just processed (why is this needed
// specifically for m_cbTempBDATLen > 0 only? Shouldn't all responses
// be treated equally -- gpulla).
//
SendSmtpResponse();
}
//
// Done with current chunk. Go back to parsing commands.
//
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
MAILBODY_ERROR:
_ASSERT(m_MailBodyDiagnostic != ERR_NONE);
//
// m_cbTempBDATLen is an offset into the recv buffer. It is set to > 0 when
// DoBDATCommandEx needs to save the start of a header that spans multiple
// chunks. Since discard does no header parsing, this is unneccessary, and
// the "offset" number of bytes (if non-zero) should be reset and shifted
// out before calling into discard.
//
if(m_cbTempBDATLen)
{
MoveMemory(QueryMRcvBuffer(), QueryMRcvBuffer() + m_cbTempBDATLen, m_cbReceived);
m_cbTempBDATLen = 0;
}
fReturn = AcceptAndDiscardBDAT(QueryMRcvBuffer(), UndecryptedTailSize, pfAsyncOp);
//
// If something failed during error processing, disconnect with an error
// (this violates the RFC, but there's no option). If we succeeded and a
// read was pended, all data in the input buffer has been consumed. The
// read I/O completion thread will pick up processing.
//
if(!fReturn || *pfAsyncOp)
{
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
_ASSERT(m_nBytesRemainingInChunk == 0 && "Expected chunk to be done");
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
/*++
Name :
SMTP_CONNECTION::DoBDATCommandEx
Description:
Handles the data chunks received after a valid BDAT command.
This funcion spools the mail to a directory.
In the first chunk it parses for header.
Once the header is written in current chunk and subsequent chunks it simply
dumps the data to the disk
Arguments:
InputLine - Buffer received from client
paramterSize - amount of data in buffer
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoBDATCommandEx(const char * InputLine1, DWORD ParameterSize, DWORD UndecryptedTailSize, BOOL *lpfWritePended, BOOL *pfAsyncOp)
{
LPSTR InputLine = (LPSTR) InputLine1;
BOOL fRet = TRUE;
BOOL fProcess = TRUE;
PSMTP_IIS_SERVICE pService = (PSMTP_IIS_SERVICE) g_pInetSvc;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoBDATCommandEx");
_ASSERT (m_pInstance != NULL);
*lpfWritePended = FALSE;
// We make this call only while we are parsing the headers
// Once we are done parsing the headers
if(CreateMailBodyFromChunk (InputLine, ParameterSize, UndecryptedTailSize, lpfWritePended))
{
m_WritingData = FALSE;
//increment our counters
//make sure the size of the file is proper.
//subtract 3 bytes accounting for the .CRLF.
//We don't write that portion to the file.
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesRcvdMsg, (m_TotalMsgSize - 3));
BUMP_COUNTER(QuerySmtpInstance(), NumMsgRecvd);
//if there was no error while parsing the
//header, and writimg the file to disk,
//then save the rest of the file, send
//a message id back to the client, and
//queue the message
if(m_MailBodyError == NO_ERROR)
{
//call HandleCompletedMessage() to see
//if we should process this message
fProcess = HandleCompletedMessage(BDAT, pfAsyncOp);
if (*pfAsyncOp) {
m_fAsyncEOD = TRUE;
return TRUE;
}
//We got all the data and written it to disk.
//Now, we'll pend a read to pick up the quit
//response, to get any other mail the client
//sends. We need to re-initialize our class
//variables first.
ReInitClassVariables();
_ASSERT (m_cbReceived < QueryMaxReadSize());
}
else
{
//else, format the appropriate message,
//and delete all objects pertaining to
//this file.
if(m_MailBodyError == ERROR_BAD_LENGTH)
FormatSmtpMessage (SMTP_RESP_MBX_SYNTAX,ESYNTAX_ERROR," %s\r\n","Badly formed BDAT Chunk");
else
FormatSmtpMessage (SMTP_RESP_NORESOURCES,ENO_RESOURCES," %s\r\n", SMTP_NO_STORAGE);
//flush any pending responses
SendSmtpResponse();
//re-initialize out class variables
ReInitClassVariables();
_ASSERT (m_cbReceived < QueryMaxReadSize());
}
}
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
/*++
Name :
SMTP_CONNECTION::DoHELPCommand
Description:
Responds to the SMTP HELP command.
send a help text description
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoHELPCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus;
char szHelpCmds[MAX_PATH];
DWORD ConnectionStatus = 0;
if(m_SecurePort)
ConnectionStatus |= SMTP_IS_SSL_CONNECTION;
if(m_fAuthenticated)
ConnectionStatus |= SMTP_IS_AUTH_CONNECTION;
_ASSERT (m_pInstance != NULL);
if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY," %s\r\n", "Client was not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
return TRUE;
}
strcpy(szHelpCmds,HelpText);
if(m_pInstance->AllowAuth())
{
if(m_pInstance->QueryAuthentication() != 0)
{
strcat(szHelpCmds, " AUTH");
if(g_SmtpPlatformType == PtNtServer && m_pInstance->AllowTURN())
{
strcat(szHelpCmds, " TURN");
}
}
}
if(g_SmtpPlatformType == PtNtServer && m_pInstance->AllowETRN())
{
strcat(szHelpCmds, " ETRN");
}
// Chunking related advertisements
if(m_pInstance->AllowBinaryMime() || m_pInstance->AllowChunking())
{
strcat(szHelpCmds, " BDAT");
}
// verify
if(m_pInstance->AllowVerify(ConnectionStatus))
{
strcat(szHelpCmds, " VRFY");
}
// Expand
if(m_pInstance->AllowExpand(ConnectionStatus))
{
strcat(szHelpCmds, " EXPN");
}
PE_FormatSmtpMessage ("%s\r\n", szHelpCmds);
RetStatus = PE_SendSmtpResponse();
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::DoVRFYCommand
Description:
Responds to the SMTP VRFY command.
send a help text description. We
do not really verify an address here.
This function is just a stub.
Arguments:
The name to verify from the client
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoVRFYCommand(const char * InputLine, DWORD ParameterSize)
{
BOOL RetStatus = TRUE;
char * VrfyAddr = NULL;
char * DomainPtr = NULL;
char * ArgPtr = NULL;
char szAddr[MAX_INTERNET_NAME + 1];
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoVRFYCommand");
szAddr[0] = '\0';
DWORD ConnectionStatus = 0;
_ASSERT (m_pInstance != NULL);
if(!m_fAuthAnon && !m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY," %s\r\n","Client was not authenticated");
ErrorTrace((LPARAM) this, "DoVrfyCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//start at the beginning;
VrfyAddr = (char *) InputLine;
//check the arguments for good form
VrfyAddr = CheckArgument(VrfyAddr);
if (VrfyAddr == NULL)
{
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(ExtractAndValidateRcpt(VrfyAddr, &ArgPtr, szAddr, &DomainPtr))
{
//The address is valid
//Do we allow verify
if(m_SecurePort)
ConnectionStatus |= SMTP_IS_SSL_CONNECTION;
if(m_fAuthenticated)
ConnectionStatus |= SMTP_IS_AUTH_CONNECTION;
if(!m_pInstance->AllowVerify(ConnectionStatus))
{
PE_CdFormatSmtpMessage (SMTP_RESP_VRFY_CODE, EVALID_DEST_ADDRESS," %s <%s>\r\n", "Cannot VRFY user, but will accept message for", szAddr);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Check the domain to be either belonging to a ALIAS,DEFAULT,DROP,DELIVER
//We also check the relay restrictions
HRESULT hr = HrShouldAcceptRcpt(DomainPtr);
if( S_FALSE == hr )
{
PE_CdFormatSmtpMessage (SMTP_RESP_NOT_FOUND, ENO_FORWARDING, " Cannot relay to <%s>\r\n",szAddr);
}
else if (S_OK == hr)
{
PE_CdFormatSmtpMessage (SMTP_RESP_VRFY_CODE, EVALID_DEST_ADDRESS," %s <%s>\r\n", "Cannot VRFY user, but will take message for", szAddr);
}
else
{
// Currently, HrShouldAcceptRcpt only return error when AQueue is already shut down or out of memory.
_ASSERT(FAILED(hr));
PE_CdFormatSmtpMessage (SMTP_RESP_SRV_UNAVAIL, ESVC_SHUTDOWN," %s\r\n",SMTP_SRV_UNAVAIL_STR);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
else
{
//it failed. Inform the user
HandleAddressError((char *)InputLine);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Reply strings
//
typedef struct _AUTH_REPLY {
LPSTR Reply;
DWORD Len;
} AUTH_REPLY, *PAUTH_REPLY;
char *
SzNextSeparator(IN char * sz, IN CHAR ch1, IN CHAR ch2)
{
char * sz1 = NULL;
char * sz2 = NULL;
sz1 = strchr(sz, ch1);
sz2 = strchr(sz, ch2);
if (sz1 == sz2)
return sz1;
else if (sz1 > sz2)
return sz2 ? sz2 : sz1;
else
return sz1 ? sz1 : sz2;
}
BOOL SMTP_CONNECTION::DoUSERCommand(const CHAR *InputLine, DWORD dwLineSize, unsigned char * OutputBuffer, DWORD * dwBytes, DWORD * ResponseCode, char * szECode)
{
char szUserName[MAX_USER_NAME_LEN + MAX_SERVER_NAME_LEN +1];
char szLogonDomainAndUserName[MAX_USER_NAME_LEN + (2 * (MAX_SERVER_NAME_LEN + 1))];
char lpszDefaultLogonDomain [MAX_SERVER_NAME_LEN + 1];
char * pSeparator1 = NULL;
char * pSeparator2 = NULL;
BUFFER BuffData;
DWORD DecodedLen = 0;
DWORD BuffLen = 0;
BOOL fRet = TRUE;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::DoUSERCommand");
*ResponseCode = SMTP_RESP_AUTH1_PASSED;;
m_pInstance->LockGenCrit();
lstrcpyn(lpszDefaultLogonDomain, m_pInstance->GetDefaultLogonDomain(), MAX_SERVER_NAME_LEN);
m_pInstance->UnLockGenCrit();
if(!uudecode ((char *) InputLine, &BuffData, &DecodedLen, FALSE) ||
(DecodedLen == 0))
{
*ResponseCode = SMTP_RESP_BAD_ARGS;
lstrcpy((char *)szECode, "5.7.3");
lstrcpy((char *) OutputBuffer, "Cannot decode arguments");
m_securityCtx.Reset();
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
lstrcpyn(szUserName, (char *) BuffData.QueryPtr(), sizeof(szUserName) - 1);
if (UseMbsCta())
{
// MBS clear text authentication, does not support domain
lstrcpy(szLogonDomainAndUserName, szUserName);
}
else
{
// if NT clear text authentication is used, we do some special operations:
// if no default logon domain is not present in user name, and default
// logon domain is set, then prepend default logon domain to username
pSeparator1 = SzNextSeparator(szUserName,'\\','/');
if(pSeparator1 == NULL && (lpszDefaultLogonDomain[0] != '\0'))
{
wsprintf(szLogonDomainAndUserName, "%s/%s", lpszDefaultLogonDomain, szUserName);
}
else
{
if( pSeparator1 != NULL )
{
//
// HACK-O-RAMA: bug 74776 hack, if a username comes in with "REDMOND\\user"
// allow it. This is to allow buggy Netscape 4.0 browser client to work.
//
if( ( (*pSeparator1) == '\\' ) && ( (*(pSeparator1+1)) == '\\' ) )
{
MoveMemory( pSeparator1, pSeparator1+1, strlen( pSeparator1 ) );
}
//check if we have the mailbox name at the end
pSeparator2 = SzNextSeparator(pSeparator1 + 1,'\\','/');
if(pSeparator2 != NULL)
{
//If we do simply ignore it by terminating the user string there
*pSeparator2 = '\0';
}
}
lstrcpy(szLogonDomainAndUserName, szUserName);
}
}
DebugTrace((LPARAM)this, "LogonDomainAndUser: %s", szLogonDomainAndUserName);
fRet = ProcessAuthInfo(AuthCommandUser, szLogonDomainAndUserName, OutputBuffer, &BuffLen);
if(!fRet)
{
*ResponseCode = SMTP_RESP_AUTH_REJECT;
lstrcpy((char *)szECode, "5.7.3");
lstrcpy((char *) OutputBuffer, "Invalid user name");
*dwBytes = lstrlen("Invalid user name");
}
else
{
*dwBytes = BuffLen;
}
return fRet;
}
//+---------------------------------------------------------------
//
// Function: SMTP_CONNECTION::DoPASSCommand
//
// Synopsis: Valid in the Authorization State.
// pswd for clear-text logon
//
// PASS password\r\n
//
// Arguments: const CHAR *: argument line
// DWORD: sizeof argument line
//
// Returns: BOOL: continue processing
//
//----------------------------------------------------------------
BOOL SMTP_CONNECTION::DoPASSCommand(const CHAR *InputLine, DWORD dwLineSize, unsigned char * OutputBuffer, DWORD * dwBytes, DWORD *ResponseCode, char * szECode)
{
BOOL fStatus = TRUE;
BUFFER BuffData;
DWORD DecodedLen = 0;
DWORD BuffLen = 0;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::DoPASSCommand");
*ResponseCode = SMTP_RESP_AUTHENTICATED;
if(!uudecode ((char *)InputLine, &BuffData, &DecodedLen, FALSE))
{
m_RecvdAuthCmd = FALSE;
m_fClearText = FALSE;
m_State = HELO;
*ResponseCode = SMTP_RESP_BAD_ARGS;
if ( ++m_dwUnsuccessfulLogons >= m_pInstance->GetMaxLogonFailures() )
{
ErrorTrace((LPARAM)this, "Logon failed");
DisconnectClient( ERROR_LOGON_FAILURE );
}
lstrcpy((char *)szECode, "5.7.3");
lstrcpy((char *) OutputBuffer, "Cannot decode password");
m_securityCtx.Reset();
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
OutputBuffer[0] = '\0';
fStatus = ProcessAuthInfo( AuthCommandPassword, (char *) BuffData.QueryPtr(), OutputBuffer, &BuffLen );
if (!fStatus)
{
ErrorTrace( (LPARAM)this, "Bad pswd %s", QueryClientUserName() );
*ResponseCode = SMTP_RESP_AUTH_REJECT;
lstrcpy((char *)szECode, "5.7.3");
lstrcpy((char *) OutputBuffer, "Authentication unsuccessful");
if ( ++m_dwUnsuccessfulLogons >= m_pInstance->GetMaxLogonFailures() )
{
ErrorTrace((LPARAM)this, "Logon failed");
DisconnectClient( ERROR_LOGON_FAILURE );
}
else
{
m_RecvdAuthCmd = FALSE;
m_fClearText = FALSE;
m_State = HELO;
}
}
*dwBytes = BuffLen;
TraceFunctLeaveEx((LPARAM)this);
return fStatus;
}
BOOL SMTP_CONNECTION::ProcessAuthInfo(AUTH_COMMAND Command, LPSTR Blob, unsigned char * OutBuff, DWORD * dwBytes)
{
DWORD nbytes = 0;
REPLY_LIST replyID;
BOOL f = TRUE;
//
// Set the IP address so the security log has the info
//
SecpSetIPAddress((PUCHAR)&m_saClient, sizeof(m_saClient));
m_pInstance->LockGenCrit();
f = m_securityCtx.ProcessAuthInfo(m_pInstance, Command, Blob,
OutBuff, &nbytes, &replyID);
m_pInstance->UnLockGenCrit();
*dwBytes = nbytes;
//
// if replyID == NULL we're conversing for challenge/response logon
//
if ( replyID == SecNull )
{
_ASSERT( nbytes != 0 );
}
if (m_securityCtx.IsAuthenticated())
{
f = TRUE;
}
if ( f == FALSE )
{
//
// if we fail for any reason reset the state to accept user/auth/apop
//
m_securityCtx.Reset();
}
return f;
}
//+---------------------------------------------------------------
//
// Function: SMTP_CONNECTION::DoAuthNegotiation
//
// Synopsis: process base64/uuendcoded blobs in AUTH_NEGOTIATE
//
// base64 text\r\n
//
// Arguments: const CHAR *: argument line
// DWORD: sizeof argument line
//
// Returns: BOOL: continue processing
//
//----------------------------------------------------------------
BOOL SMTP_CONNECTION::DoAuthNegotiation(const CHAR *InputLine, DWORD dwLineSize)
{
//The size of the output buffer should vary with the package being used.
//Currently we use a quickfix which should work for LOGIN and NTLM but will
//fail for other (new) packages if the response string > 25*255+1. Replace
//this by a CBuffer later. Size of the CBuffer should be the max token size
//for the package from CACHED_CREDENTIAL::GetCachedCredential.
//GPulla, 6/15/1999
unsigned char OutputBuff[MAX_REPLY_SIZE];
char szECode[25];
BOOL fAuthed = TRUE;
BUFFER BuffData;
DWORD ResponseCode;
DWORD dwBytes = 0;
BOOL fDoBase64 = FALSE;
char * pszSearch = NULL;
TraceFunctEnterEx((LPARAM)this, "DoAuthNegotiation");
if (m_cbParsable >= QueryMaxReadSize())
{
m_cbParsable = 0;
m_ProtocolErrors++;
}
pszSearch = IsLineComplete(InputLine,m_cbParsable);
if(pszSearch == NULL)
{
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
*pszSearch = '\0';
m_cbParsable = 0;
if(!lstrcmp(InputLine, "*"))
{
FormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n", "Auth command cancelled");
m_fDidUserCmd = FALSE;
m_RecvdAuthCmd = FALSE;
m_fClearText = FALSE;
m_State = HELO;
m_securityCtx.Reset();
SendSmtpResponse();
ProtocolLog(AUTH, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_ARGS, 0, 0);
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
if(m_fClearText)
{
if(m_fDidUserCmd)
{
if(DoPASSCommand(InputLine, dwLineSize, OutputBuff, &dwBytes, &ResponseCode, szECode))
{
m_State = HELO;
m_fAuthenticated = TRUE;
lstrcpy((char *)szECode, "2.7.0");
lstrcpy((char *)OutputBuff, "Authentication successful");
}
else
{
fAuthed = FALSE;
// lstrcpy((char *)OutputBuff, "5.7.3 Authentication unsuccessful");
}
}
else
{
if(DoUSERCommand(InputLine, dwLineSize, OutputBuff, &dwBytes, &ResponseCode, szECode))
{
lstrcpy((char *)OutputBuff, PasswordParam);
m_fDidUserCmd = TRUE;
fDoBase64 = TRUE;
}
else
{
fAuthed = FALSE;
}
}
if(fDoBase64)
{
if(!uuencode ((unsigned char *)OutputBuff, lstrlen((char *) OutputBuff), &BuffData, FALSE))
{
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
else
{
FormatSmtpMessage (ResponseCode,NULL," %s\r\n", BuffData.QueryPtr());
}
}
else
{
FormatSmtpMessage (ResponseCode,szECode," %s\r\n", OutputBuff);
}
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, ResponseCode, 0, 0);
}
else
{
fAuthed = ProcessAuthInfo( AuthCommandTransact, (LPSTR)InputLine, OutputBuff, &dwBytes );
if(fAuthed)
{
if(m_securityCtx.IsAuthenticated())
{
m_State = HELO;
m_fAuthenticated = TRUE;
fAuthed = TRUE;
PE_CdFormatSmtpMessage (SMTP_RESP_AUTHENTICATED, ESEC_SUCCESS," %s\r\n", "Authentication successful");
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_AUTHENTICATED, 0, 0);
}
else
{
FormatSmtpMessage (SMTP_RESP_AUTH1_PASSED,NULL," ");
FormatSmtpMessage(OutputBuff, dwBytes);
}
}
else
{
FormatSmtpMessage (SMTP_RESP_AUTH_REJECT, ENO_SECURITY, " %s\r\n", "Authentication unsuccessful");
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_AUTH_REJECT, 0, 0);
if ( ++m_dwUnsuccessfulLogons >= m_pInstance->GetMaxLogonFailures() )
{
ErrorTrace((LPARAM)this, "Logon failed");
SendSmtpResponse();
DisconnectClient( ERROR_LOGON_FAILURE );
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
}
}
if(!fAuthed)
{
m_State = HELO;
m_RecvdAuthCmd = FALSE;
m_fDidUserCmd= FALSE;
}
SendSmtpResponse();
TraceFunctLeaveEx((LPARAM)this);
return fAuthed;
}
/*++
Name :
SMTP_CONNECTION::DoAUTHCommand
Description:
This function performs authentication
for the SMTP service
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoAUTHCommand(const char * InputLine, DWORD ParameterSize)
{
BOOL fAuthPassed = TRUE;
char * pMechanism = NULL;
char * pInitialResponse = NULL;
DWORD dwConnectionStatus = 0;
//The size of the output buffer should vary with the package being used.
//Currently we use a quickfix which should work for LOGIN and NTLM but will
//fail for other (new) packages if the response string > 25*255+1. Replace
//this by a CBuffer later. Size of the CBuffer should be the max token size
//for the package from CACHED_CREDENTIAL::GetCachedCredential.
//GPulla, 6/15/1999
unsigned char OutputBuffer[MAX_REPLY_SIZE];
char szECode[16];
BUFFER BuffData;
DWORD DecodedLen = 0;
DWORD dwBytes = 0;
DWORD ResponseCode;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoAUTHCommand");
//Do we allow AUTH command
if(!m_pInstance->AllowAuth())
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_CMD, ENOT_IMPLEMENTED," %s\r\n", SMTP_BAD_CMD_STR);
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_BAD_CMD, 0, 0);
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//check if helo was sent
if(!m_pInstance->AllowMailFromNoHello() && !m_HelloSent)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n", "Send hello first" );
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
OutputBuffer[0] = '\0';
//disallow mail from more than once
if(m_RecvdAuthCmd)
{
++m_ProtocolErrors;
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Auth already specified" );
ProtocolLog(AUTH, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "DoAuthCommand - SMTP_RESP_BAD_SEQ, Sender already specified");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//
// Check syntax: one required parameter, and one optional parameter
//
pMechanism = strtok((char *) InputLine, WHITESPACE);
pInitialResponse = strtok(NULL, WHITESPACE);
if(pMechanism == NULL)
{
++m_ProtocolErrors;
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS, " %s\r\n","No mechanism" );
ProtocolLog(AUTH, (char *) InputLine, NO_ERROR, SMTP_RESP_BAD_SEQ, 0, 0);
ErrorTrace((LPARAM) this, "DoAuthCommand - SMTP_RESP_BAD_SEQ, Sender already specified");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
strncpy(m_szUsedAuthKeyword, pMechanism, sizeof(m_szUsedAuthKeyword)-1);
if(!lstrcmpi(pMechanism, "login"))
{
if(m_SecurePort)
dwConnectionStatus |= SMTP_IS_SSL_CONNECTION;
if(m_pInstance->AllowLogin(dwConnectionStatus))
{
m_fClearText = TRUE;
if(pInitialResponse)
{
if(DoUSERCommand((const char *) pInitialResponse, lstrlen(pInitialResponse), OutputBuffer, &dwBytes, &ResponseCode, szECode))
{
m_fDidUserCmd = TRUE;
}
else
{
PE_CdFormatSmtpMessage (ResponseCode, szECode," %s\r\n",OutputBuffer );
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_PARM_NOT_IMP, 0, 0);
fAuthPassed = FALSE;
}
}
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_PARM_NOT_IMP, ENO_SEC_PACKAGE, " %s \r\n","Unrecognized authentication type" );
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_PARM_NOT_IMP, 0, 0);
fAuthPassed = FALSE;
}
}
else
{
/*
//
// Switch over to using a large receive buffer, because a AUTH blob
// may be up to 32K big.
BOOL fStartSASL = SwitchToBigSSLBuffers();
if (fStartSASL) {
//PE_CdFormatSmtpMessage(SMTP_RESP_READY, EPROT_SUCCESS," %s\r\n", SMTP_READY_STR);
ProtocolLog(AUTH, (char *) InputLine, NO_ERROR, SMTP_RESP_READY, 0, 0);
} else {
PE_CdFormatSmtpMessage(SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n", SMTP_NO_MEMORY);
ProtocolLog(AUTH, (char *) InputLine, NO_ERROR, SMTP_RESP_NORESOURCES, 0, 0);
}
*/
//
// Register our principal names, if necessary
//
QuerySmtpInstance()->RegisterServicePrincipalNames(TRUE);
if(ProcessAuthInfo( AuthCommandTransact, pMechanism, OutputBuffer, &dwBytes ) == FALSE )
{
fAuthPassed = FALSE;
PE_CdFormatSmtpMessage (SMTP_RESP_PARM_NOT_IMP, ENO_SEC_PACKAGE, " %s \r\n", "Unrecognized authentication type" );
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_PARM_NOT_IMP, 0, 0);
}
else if(pInitialResponse)
{
if(ProcessAuthInfo( AuthCommandTransact, pInitialResponse, OutputBuffer, &dwBytes ) == FALSE )
{
PE_CdFormatSmtpMessage (SMTP_RESP_AUTH_REJECT, EINVALID_ARGS, " %s\r\n","Cannot authenticate parameter" );
ProtocolLog(AUTH, (char *) QueryClientUserName(), NO_ERROR, SMTP_RESP_AUTH_REJECT, 0, 0);
fAuthPassed = FALSE;
}
}
}
if(fAuthPassed)
{
m_RecvdAuthCmd = TRUE;
m_State = AUTH;
if(!pInitialResponse)
{
if(!m_fClearText)
{
PE_CdFormatSmtpMessage (SMTP_RESP_AUTH1_PASSED,NULL," %s supported\r\n", pMechanism);
}
else
{
if(!uuencode ((unsigned char *)UserParam, lstrlen(UserParam), &BuffData, FALSE))
{
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_AUTH1_PASSED,NULL," %s\r\n", BuffData.QueryPtr());
}
}
}
else
{
if(!m_fClearText)
{
PE_CdFormatSmtpMessage (SMTP_RESP_AUTH1_PASSED,NULL," ");
OutputBuffer[dwBytes] = '\0';
PE_FormatSmtpMessage("%s\r\n",OutputBuffer);
}
else
{
if(!uuencode ((unsigned char *)PasswordParam, lstrlen(PasswordParam), &BuffData, FALSE))
{
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
PE_CdFormatSmtpMessage (SMTP_RESP_AUTH1_PASSED,NULL," %s\r\n", BuffData.QueryPtr());
}
}
}
else
m_ProtocolErrors++; //even though we kick out the connection
//after MaxLogonFailures, count this as a
//protocol error
TraceFunctLeaveEx((LPARAM) this);
return(TRUE);
}
BOOL SMTP_CONNECTION::DoTURNCommand(const char * InputLine, DWORD parameterSize)
{
sockaddr_in AddrRemote;
SMTP_CONNOUT * SmtpConn = NULL;
DWORD Error = 0;
DWORD Options = 0;
char * pszUserName = "";
MULTISZ* pmsz = NULL;
TURN_DOMAIN_LIST TurnDomainList;
LPSTR pszAuthenticatedUserName = NULL;
const char * StartPtr = NULL;
BOOL Found = FALSE;
ISMTPConnection *pISMTPConnection = NULL;
char Domain[MAX_INTERNET_NAME];
Domain[0] = '\0';
DWORD DomainOptions = 0;
HRESULT hr = S_OK;
DomainInfo DomainParams;
ZeroMemory (&DomainParams, sizeof(DomainParams));
DomainParams.cbVersion = sizeof(DomainParams);
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoTurnCommand");
//check if helo was sent
if(!m_pInstance->AllowMailFromNoHello() && !m_HelloSent)
{
ErrorTrace((LPARAM) this, "In TURN - Hello not sent");
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR, " %s\r\n","Send hello first" );
++m_ProtocolErrors;
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(!m_fAuthenticated)
{
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", "Client was not authenticated");
ErrorTrace((LPARAM) this, "DoTURNCommand - SMTP_RESP_MUST_SECURE, user not authenticated");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
if(m_securityCtx.QueryUserName())
ErrorTrace((LPARAM) this, "Looking up user %s in TURN table", m_securityCtx.QueryUserName());
pmsz = new MULTISZ();
if(pmsz == NULL)
{
Error = GetLastError();
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_MEMORY );
FatalTrace((LPARAM) this, "SMTP_CONNOUT::CreateSmtpConnection failed for TURN");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
pmsz->Reset();
// Do we have a username from an AUTH sink? If not use anything from SMTP auth
pszAuthenticatedUserName =
m_szAuthenticatedUserNameFromSink[0] ?
m_szAuthenticatedUserNameFromSink : m_securityCtx.QueryUserName();
QuerySmtpInstance()->IsUserInTurnTable(pszAuthenticatedUserName, pmsz);
//QuerySmtpInstance()->IsUserInTurnTable("joe", &msz);
if(pmsz->IsEmpty())
{
delete pmsz;
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY," %s\r\n","This authenticated user is not allowed to issue TURN");
ErrorTrace((LPARAM) this, "DoTURNCommand - SMTP_RESP_MUST_SECURE, user not in turn table");
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//Determine the primary domain in the list of domains that are to be turned
//The primary domain is one that matches the domain name specified in the EHLO command
//NimishK : What if EHLO is not provided
//
for (StartPtr = pmsz->First();
( (StartPtr != NULL) && !QuerySmtpInstance()->IsShuttingDown());
StartPtr = pmsz->Next( StartPtr ))
{
ErrorTrace((LPARAM) this, "looking for %s in TURN domains", QueryClientUserName());
if(!lstrcmpi(QueryClientUserName(), StartPtr))
{
Found = TRUE;
break;
}
}
//If we can determine the primary domain - we get the ISMTPCONNECTION for that domain
//else we get the first domain in the list and get the ISMTPCONNECTION for it
BOOL fPrimaryDomain = FALSE;
if(!Found)
StartPtr = pmsz->First();
else
fPrimaryDomain = TRUE;
//We need to keep walking the list of domains that are to be turned
//till we get a valid ISMTPCONN or run out of domains
while(StartPtr && !QuerySmtpInstance()->IsShuttingDown())
{
hr = QuerySmtpInstance()->GetConnManPtr()->GetNamedConnection(lstrlen(StartPtr), (CHAR*)StartPtr, &pISMTPConnection);
if(FAILED(hr))
{
//Something bad happened on this call
//report to client
delete pmsz;
PE_CdFormatSmtpMessage (SMTP_ERROR_PROCESSING_CODE, ENO_RESOURCES," %s\r\n", "Error processing the command");
ErrorTrace((LPARAM) this, "DoTURNCommand - SMTP_ERROR_PROCESSING_CODE, GetNamedConnection failed %d",hr);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//If the link corresponding to this domain does not exist in AQ, we get a NULL
//ISMTPConnection at this point
//If we do there is nothing to TURN
if(pISMTPConnection)
break;
else
{
if(fPrimaryDomain)
{
StartPtr = pmsz->First();
fPrimaryDomain = FALSE;
}
else
{
StartPtr = pmsz->Next( StartPtr );
}
continue;
}
}
if(pISMTPConnection == NULL && StartPtr == NULL)
{
//We ran out of the domains and there is not a single link
PE_CdFormatSmtpMessage (250, EPROT_SUCCESS, " %s\r\n", "Server was turned");
PE_SendSmtpResponse();
PE_FormatSmtpMessage ("%s\r\n","QUIT");
PE_SendSmtpResponse();
//we will disconnect indirectly by returning false
//DisconnectClient();
return FALSE;
}
else
{
//leave quickly if we are shutting down
if(QuerySmtpInstance()->IsShuttingDown()
|| (QuerySmtpInstance()->QueryServerState( ) == MD_SERVER_STATE_STOPPED)
|| (QuerySmtpInstance()->QueryServerState( ) == MD_SERVER_STATE_INVALID))
{
if(pISMTPConnection)
{
//Ack the last connection
pISMTPConnection->AckConnection((eConnectionStatus)CONNECTION_STATUS_OK);
pISMTPConnection->Release();
pISMTPConnection = NULL;
}
delete pmsz;
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
DomainParams.szDomainName = Domain;
DomainParams.cbDomainNameLength = sizeof(Domain);
hr = pISMTPConnection->GetDomainInfo(&DomainParams);
TurnDomainList.pmsz = pmsz;
//If we just got the ISMTPCOnn for the primary domain then we probably
//jumped over a few domains in the domain list.
//Set the ptr to start of the domain list
//That way we will look at all the domains, once we are done with the
//current primary domain
if(fPrimaryDomain)
{
TurnDomainList.szCurrentDomain = pmsz->First();
fPrimaryDomain = FALSE;
}
else
{
//Looks like we failed to get primary domain
//so got to have started from the top - continue that
TurnDomainList.szCurrentDomain = StartPtr;
}
//If we could not determine a primary domain - use the base
//connection options
if(!Found)
DomainOptions = 0;
else
DomainOptions = DomainParams.dwDomainInfoFlags;
//set the remote IP address we connected to
AddrRemote.sin_addr.s_addr = 0;
//
// Create an outbound connection
// Note: The last parameter, m_pSSLVerificationName is NULL. This is the
// name used to match against the SSL certificate that the server gives
// us during an outbound session. Setting it to NULL skips certificate
// subject validation, which is fine in the case of TURN, since either
// the server is already authenticated through other means (if ATRN) or
// we don't care about authentication (if TURN is configured).
//
SmtpConn = SMTP_CONNOUT::CreateSmtpConnection(
QuerySmtpInstance(),
(SOCKET) m_pAtqContext->hAsyncIO,
(SOCKADDR_IN *)&AddrRemote,
(SOCKADDR_IN *)&AddrRemote,
NULL,
(PVOID)&TurnDomainList,
0,
DomainOptions,
NULL,
NULL);
if(SmtpConn == NULL)
{
delete pmsz;
Error = GetLastError();
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY );
FatalTrace((LPARAM) this, "SMTP_CONNOUT::CreateSmtpConnection failed for TURN");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
//from here on, the smtpout class is responsible for
//cleaning up the AtqContext
m_DoCleanup = FALSE;
SmtpConn->SetAtqContext(m_pAtqContext);
//copy the real domain we are connected to.
SmtpConn->SetConnectedDomain((char *) Domain);
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_COMPLETION, (DWORD_PTR) InternetCompletion);
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_COMPLETION_CONTEXT, (DWORD_PTR) SmtpConn);
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_TIMEOUT, m_pInstance->GetRemoteTimeOut());
//insert the outbound connection object into
//our list of outbound conection objects
if(!QuerySmtpInstance()->InsertNewOutboundConnection(SmtpConn, TRUE))
{
Error = GetLastError();
FatalTrace((LPARAM) this, "m_pInstance->InsertNewOutboundConnection failed for TURN");
SmtpConn->DisconnectClient();
delete SmtpConn;
SmtpConn = NULL;
SetLastError(Error);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
SmtpConn->SetCurrentObject(pISMTPConnection);
PE_CdFormatSmtpMessage (250, EPROT_SUCCESS, " %s\r\n", "Server was turned");
PE_SendSmtpResponse();
}
//start session will pend a read to pick
//up the servers signon banner
if(!SmtpConn->StartSession())
{
//get the error
Error = GetLastError();
FatalTrace((LPARAM) this, "SmtpConn->StartSession failed for TURN");
SmtpConn->DisconnectClient();
QuerySmtpInstance()->RemoveOutboundConnection(SmtpConn);
delete SmtpConn;
SmtpConn = NULL;
SetLastError (Error);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
m_State = TURN;
TraceFunctLeaveEx((LPARAM) this);
return(FALSE);
}
/*++
Name :
SMTP_CONNECTION::DoLASTCommand
Description:
This is our catch all error function.
It will determin what kind of error
made it execute and send an appropriate
message back to the client.
Arguments:
Are ignored
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
BOOL SMTP_CONNECTION::DoLASTCommand(const char * InputLine, DWORD parameterSize)
{
BOOL RetStatus = TRUE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoLASTCommand");
_ASSERT (m_pInstance != NULL);
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_CMD, ENOT_IMPLEMENTED," %s\r\n", SMTP_BAD_CMD_STR);
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
m_ProtocolErrors++;
PE_SendSmtpResponse();
TraceFunctLeaveEx((LPARAM) this);
return RetStatus;
}
/*++
Name :
SMTP_CONNECTION::VerifiyClient
Description:
This function compares the IP address the connection
was made on to the IP address of the name given with
the HELO or EHLO commands
Arguments:
ClientHostName - from HELO or EHLO command
KnownIpAddress - from accept
Returns:
TRUE if the connection should stay open.
FALSE if this object should be deleted.
--*/
DWORD SMTP_CONNECTION::VerifiyClient (const char * ClientHostName, const char * KnownIpAddress)
{
in_addr UNALIGNED * P_Addr = NULL;
PHOSTENT Hp = NULL;
DWORD KnownClientAddress = 0;
DWORD dwRet = SUCCESS;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::VerifiyClient");
Hp = gethostbyname (ClientHostName);
if (Hp == NULL)
{
DWORD dwErr = WSAGetLastError();
if(dwErr == WSANO_DATA)
dwRet = NO_MATCH;
else
dwRet = LOOKUP_FAILED;
TraceFunctLeaveEx((LPARAM) this);
return dwRet;
}
KnownClientAddress = inet_addr (KnownIpAddress);
if (KnownClientAddress == INADDR_NONE)
{
dwRet = LOOKUP_FAILED;
TraceFunctLeaveEx((LPARAM) this);
return dwRet;
}
while( (P_Addr = (in_addr UNALIGNED *)*Hp->h_addr_list++) != NULL)
{
if (P_Addr->s_addr == KnownClientAddress)
{
TraceFunctLeaveEx((LPARAM) this);
return dwRet;
}
}
dwRet = NO_MATCH;
TraceFunctLeaveEx((LPARAM) this);
return dwRet;
}
/*++
Name :
void SMTP_CONNECTION::HandleAddressError(char * InputLine)
Description:
common code to determine what error occurred
as a result of address validation/allocation failure failure
Arguments:
none
Returns:
none
--*/
void SMTP_CONNECTION::HandleAddressError(char * InputLine)
{
DWORD Error = GetLastError();
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::HandleAddressError");
if(Error == ERROR_NOT_ENOUGH_MEMORY)
{
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToNoCAddrObjects);
PE_CdFormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY );
m_CInboundContext.SetWin32Status(Error);
FatalTrace((LPARAM) this, "HandleAddressError - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY");
}
else if (Error == ERROR_INVALID_DATA)
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS, EINVALID_ARGS," %s\r\n",SMTP_INVALID_ADDR_MSG);
FatalTrace((LPARAM) this, "HandleAddressError - SMTP_RESP_BAD_ARGS, SMTP_INVALID_ADDR_MSG");
m_ProtocolErrors++;
}
else
{
PE_CdFormatSmtpMessage (SMTP_RESP_MBX_SYNTAX, ESYNTAX_ERROR," %s\r\n","Unknown Error");
m_CInboundContext.SetWin32Status(Error);
FatalTrace((LPARAM) this, "HandleAddressError - SMTP_RESP_MBX_SYNTAX, Unknown Error");
m_ProtocolErrors++;
}
TraceFunctLeaveEx((LPARAM) this);
}
/*++
Name :
void SMTP_CONNECTION::SkipWord
Description:
skips over words in a buffer and
returns pointer to next word
Arguments:
none
Returns:
none
--*/
char * SMTP_CONNECTION::SkipWord (char * Buffer, char * WordToSkip, DWORD WordLen)
{
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::SkipWord");
//find string
if (strncasecmp(Buffer, WordToSkip, WordLen))
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS , EINVALID_ARGS," %s %s\r\n", "Unrecognized parameter", Buffer);
ProtocolLog(USE_CURRENT, Buffer, NO_ERROR, SMTP_RESP_BAD_ARGS, 0, 0);
return NULL;
}
//skip past word
Buffer += WordLen;
//skip white spaces looking for the ":" character
while( (*Buffer != '\0') && (isspace ((UCHAR)*Buffer) || (*Buffer == '\t')))
Buffer++;
if( (*Buffer == '\0') || (*Buffer != ':'))
{
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_ARGS , EINVALID_ARGS," %s %s\r\n", "Unrecognized parameter", Buffer);
ProtocolLog(USE_CURRENT, Buffer, NO_ERROR, SMTP_RESP_BAD_ARGS, 0, 0);
return NULL;
}
//add one to skip the ":"
Buffer++;
TraceFunctLeaveEx((LPARAM) this);
return Buffer;
}
VOID SMTP_CONNECTION::ProtocolLog(DWORD dwCommand, LPCSTR pszParameters, DWORD dwWin32Error,
DWORD dwSmtpError, DWORD BytesSent, DWORD BytesRecv, LPSTR pszTarget)
{
LPCSTR pszCmd = "";
char szKeyword[100];
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::ProtocolLog");
_ASSERT (m_pInstance != NULL);
//
// verify if we should use the current command
//
if ( dwCommand == USE_CURRENT )
{
dwCommand = m_dwCurrentCommand;
}
if(dwCommand == SMTP_TIMEOUT)
{
strcpy(szKeyword, "TIMEOUT");
pszCmd = szKeyword;
}
else
{
pszCmd = (LPSTR)SmtpCommands[ dwCommand ];
if ( pszCmd == NULL )
{
// if this is a PE word then its the first word in the
// parameters
char *pszSpace = strchr(pszParameters, ' ');
if (pszSpace) {
DWORD_PTR cToCopy = (DWORD_PTR) pszSpace - (DWORD_PTR) pszParameters;
if (cToCopy >= sizeof(szKeyword)) cToCopy = sizeof(szKeyword) - 1;
strncpy(szKeyword, pszParameters, cToCopy);
szKeyword[cToCopy] = 0;
pszParameters += cToCopy;
pszCmd = szKeyword;
} else {
pszCmd = pszParameters;
pszParameters = NULL;
}
}
}
//
// filter so we only get the desired commands
//
DebugTrace( (LPARAM)this,
"Allow cmds: 0x%08X, cmd: 0x%08X",
m_pInstance->GetCmdLogFlags(),
(1<<dwCommand) );
if ( m_pInstance->GetCmdLogFlags() & (1<<dwCommand) )
{
TransactionLog(
pszCmd,
pszParameters,
pszTarget,
dwWin32Error,
dwSmtpError);
}
TraceFunctLeaveEx((LPARAM) this);
}
BOOL
SMTP_CONNECTION::BindInstanceAccessCheck(
)
/*++
Routine Description:
Bind IP/DNS access check for this request to instance data
Arguments:
None
Returns:
BOOL - TRUE if success, otherwise FALSE.
--*/
{
m_pInstance->LockGenCrit();
if ( m_rfAccessCheck.CopyFrom( m_pInstance->QueryMetaDataRefHandler() ) )
{
m_acAccessCheck.BindCheckList( (LPBYTE)m_rfAccessCheck.GetPtr(), m_rfAccessCheck.GetSize() );
m_pInstance->UnLockGenCrit();
return TRUE;
}
m_pInstance->UnLockGenCrit();
return FALSE;
}
VOID
SMTP_CONNECTION::UnbindInstanceAccessCheck()
/*++
Routine Description:
Unbind IP/DNS access check for this request to instance data
Arguments:
None
Returns:
Nothing
--*/
{
m_acAccessCheck.UnbindCheckList();
m_rfAccessCheck.Reset( (IMDCOM*) g_pInetSvc->QueryMDObject() );
}
/*++
Name :
void SMTP_CONNECTION::SwitchToBigReceiveBuffer
Description:
Helper routine to allocate a 32K buffer and use it for posting reads.
SSL fragments can be up to 32K large, and we need to accumulate an
entire fragment to be able to decrypt it.
Arguments:
none
Returns:
TRUE if the receive buffer was successfully allocated, FALSE otherwise
--*/
BOOL SMTP_CONNECTION::SwitchToBigSSLBuffers(void)
{
char *pTempBuffer;
pTempBuffer = new char [MAX_SSL_FRAGMENT_SIZE];
if (pTempBuffer != NULL) {
m_precvBuffer = pTempBuffer;
m_cbMaxRecvBuffer = MAX_SSL_FRAGMENT_SIZE;
pTempBuffer = new char [MAX_SSL_FRAGMENT_SIZE];
if (pTempBuffer != NULL) {
m_pOutputBuffer = pTempBuffer;
m_cbMaxOutputBuffer = MAX_SSL_FRAGMENT_SIZE;
return( TRUE );
}
}
return( FALSE );
}
/*++
Name :
void SMTP_CONNECTION::DecryptInputBuffer
Description:
Helper routine to decrypt the recieve buffer when session is SSL
encypted.
Arguments:
none
Returns:
TRUE if the receive buffer was successfully decrypted, FALSE otherwise
--*/
BOOL SMTP_CONNECTION::DecryptInputBuffer(void)
{
TraceFunctEnterEx( (LPARAM)this, "SMTP_CONNECTION::DecryptInputBuffer");
DWORD cbExpected;
DWORD cbReceived;
DWORD cbParsable;
DWORD dwError;
dwError = m_encryptCtx.DecryptInputBuffer(
(LPBYTE) QueryMRcvBuffer() + m_cbParsable,
m_cbReceived - m_cbParsable,
&cbReceived,
&cbParsable,
&cbExpected );
if ( dwError == NO_ERROR )
{
//
// new total received size is the residual from last processing
// and whatever is left in the current decrypted read buffer
//
m_cbReceived = m_cbParsable + cbReceived;
//
// new total parsable size is the residual from last processing
// and whatever was decrypted from this read io operation
//
m_cbParsable += cbParsable;
m_SessionSize += cbParsable;
}
else
{
//
// errors from this routine indicate that the stream has been
// tampered with or we have an internal error
//
ErrorTrace( (LPARAM)this,
"DecryptInputBuffer failed: 0x%08X",
dwError );
DisconnectClient( dwError );
}
return( dwError == NO_ERROR );
}
/*++
Name :
void SMTP_CONNECTION::IsClientSecureEnough
Description:
Finds out whether the client has negotiated the appropriate security
level for the server instance for which this connection was
created.
Arguments:
none
Returns:
TRUE if the client has negotiated appropriate level of security
--*/
BOOL SMTP_CONNECTION::IsClientSecureEnough(void)
{
BOOL fRet = TRUE;
if (QuerySmtpInstance()->RequiresSSL() && !m_SecurePort) {
m_CInboundContext.m_dwSmtpStatus = SMTP_RESP_MUST_SECURE;
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, E_TLSNEEDED, " %s\r\n", SMTP_MSG_MUST_SECURE);
fRet = FALSE;
}
else if (m_SecurePort &&
QuerySmtpInstance()->Requires128Bits() &&
m_encryptCtx.QueryKeySize() < 128) {
m_CInboundContext.m_dwSmtpStatus = SMTP_RESP_TRANS_FAILED;
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, E_TLSNEEDED, " %s\r\n", SMTP_MSG_NOT_SECURE_ENOUGH);
fRet = FALSE;
}
if(!fRet)
{
BUMP_COUNTER(QuerySmtpInstance(), NumProtocolErrs);
++m_ProtocolErrors;
}
return fRet;
}
/*++
Name :
BOOL SMTP_CONNECTION::OnEvent
Description:
Is invoked from GlueDispatch. Micro-manages sink firing scenarios.
Arguments:
char * InputLine null terminated chunk of inbound input buffer from beginning of cmd to CRLF
DWORD IntermediateSize length of the above
DWORD CmdSize length of command keyword
Returns:
TRUE if native handler did or by default
FALSE if native handler did
--*/
HRESULT SMTP_CONNECTION::OnEvent(
IUnknown * pIserver,
IUnknown * pISession,
IMailMsgProperties *pIMessage,
LPPE_COMMAND_NODE pCommandNode,
LPPE_BINDING_NODE pBindingNode,
char * szArgs
)
{
PMFI PointerToMemberFunction = SmtpDispatchTable[m_dwCurrentCommand];
HRESULT hr = S_OK;
BOOL fResult;
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::OnEvent");
_ASSERT(pCommandNode);
_ASSERT(pBindingNode);
m_CInboundContext.m_pCurrentBinding = pBindingNode;
// If this is not a native command
if (SmtpCommands[m_dwCurrentCommand] == NULL)
{
hr = m_pCInboundDispatcher->ChainSinks(
pIserver,
pISession,
pIMessage,
&m_CInboundContext,
PRIO_LOWEST,
pCommandNode,
&(m_CInboundContext.m_pCurrentBinding)
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
else
{
if (pBindingNode->dwPriority <= PRIO_DEFAULT)
{
if (pBindingNode->dwFlags & PEBN_DEFAULT)
{
// We are firing the default handler, skip the pre-loop
m_CInboundContext.m_pCurrentBinding = pBindingNode->pNext;
}
else
{
hr = m_pCInboundDispatcher->ChainSinks(
pIserver,
pISession,
pIMessage,
&m_CInboundContext,
PRIO_DEFAULT,
pCommandNode,
&(m_CInboundContext.m_pCurrentBinding)
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
if (FAILED(hr))
return hr;
if((hr != EXPE_S_CONSUMED) && (hr != S_FALSE)) {
fResult = (this->*PointerToMemberFunction)(szArgs,strlen(szArgs));
if (!fResult)
m_CInboundContext.SetCommandStatus(EXPE_DROP_SESSION);
else
m_CInboundContext.SetCommandStatus(EXPE_SUCCESS);
}
}
if ((m_CInboundContext.m_pCurrentBinding) &&
(hr != EXPE_S_CONSUMED) && (hr != S_FALSE))
{
hr = m_pCInboundDispatcher->ChainSinks(
pIserver,
pISession,
pIMessage,
&m_CInboundContext,
PRIO_LOWEST,
pCommandNode,
&(m_CInboundContext.m_pCurrentBinding)
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
}
TraceFunctLeaveEx((LPARAM)this);
return(hr);
AsyncCompletion:
DebugTrace((LPARAM)this, "Leaving because of S_PENDING");
TraceFunctLeaveEx((LPARAM)this);
return(hr);
}
HRESULT SMTP_CONNECTION::OnNotifyAsyncCompletion(
HRESULT hrResult
)
{
HRESULT hr = S_OK;
LPSTR pArgs = NULL;
CHAR chTerm = '\0';
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::OnNotifyAsyncCompletion");
// Make sure the sink did not call back with S_PENDING
if (hrResult == MAILTRANSPORT_S_PENDING)
hrResult = S_OK;
// See if we have to continue chaining
if (hrResult == S_OK)
{
LPPE_BINDING_NODE pNextBinding;
PE_BINDING_NODE bnDefault;
// If we have more bindings, or if we are before a native command, we have to
// go in again
_ASSERT(m_CInboundContext.m_pCurrentBinding);
pNextBinding = m_CInboundContext.m_pCurrentBinding->pNext;
// Now see if we have a native handler
if (SmtpDispatchTable[m_dwCurrentCommand] &&
(m_CInboundContext.m_pCurrentBinding->dwPriority <= PRIO_DEFAULT))
{
if (!pNextBinding || (pNextBinding->dwPriority > PRIO_DEFAULT))
{
bnDefault.dwPriority = PRIO_DEFAULT;
bnDefault.pNext = pNextBinding;
bnDefault.dwFlags = PEBN_DEFAULT;
pNextBinding = &bnDefault;
}
}
if (pNextBinding != NULL)
{
// Call the OnEvent to resume chaining ...
pArgs = strchr(m_CInboundContext.m_cabCommand.Buffer(), ' ');
if (!pArgs)
pArgs = &chTerm;
hrResult = OnEvent(
m_pInstance->GetInstancePropertyBag(),
GetSessionPropertyBag(),
m_pIMsg,
m_CInboundContext.m_pCurrentCommandContext,
pNextBinding,
pArgs
);
// We have scenarios:
// 1) S_OK, S_FALSE: We send the response and do the
// next command
// 2) ERROR: Drop the connection
// 3) S_PENDING: Just let the thread return
}
else
hrResult = S_OK;
}
if (hrResult != MAILTRANSPORT_S_PENDING)
{
// log this command and the response
if (m_State != DATA &&
m_State != BDAT &&
m_State != AUTH &&
m_dwCurrentCommand != DATA &&
m_dwCurrentCommand != BDAT &&
m_dwCurrentCommand != AUTH)
{
const char *pszCommand = SmtpCommands[m_dwCurrentCommand];
DWORD cCmd = (pszCommand) ? strlen(pszCommand) : 0;
ProtocolLog(m_dwCurrentCommand,
m_CInboundContext.m_cabCommand.Buffer() + cCmd,
m_CInboundContext.m_dwWin32Status,
m_CInboundContext.m_dwSmtpStatus,
0,
0);
}
// It's not another async operation
if (SUCCEEDED(hrResult))
{
// Send the response and process the next command
if (!ProcessAndSendResponse())
hrResult = E_FAIL;
// Disconnect client if needed
if (m_CInboundContext.m_dwCommandStatus & EXPE_DROP_SESSION)
{
DisconnectClient();
hrResult = E_FAIL;
}
// do things unique to handling the end of a message
if (m_fAsyncEOD) {
ReInitClassVariables();
}
}
if (SUCCEEDED(hrResult)) {
//
// ProcessClient usually posts an async ReadFile --
// This can be a problem since ntos actuall completes the
// read with the thread that issued it. If the sink
// writer has the thread exit before the read completes,
// we would get an error. To get around this, we call
// PostQueuedCompleteionStatus with the sink's thread and
// then post the next async read with an atq thread.
//
//ProcessClient(0, NO_ERROR,
//(LPOVERLAPPED)&m_CInboundContext);
m_fAsyncEventCompletion = TRUE;
if(
PostCompletionStatus(
1 // Post 1 byte (a zero byte completion means the
// remote host disconnected
) == FALSE) {
//
// We were unable to post completion status, fail
// below
//
hrResult = E_FAIL;
m_fAsyncEventCompletion = FALSE;
}
}
if(FAILED(hrResult))
ProcessClient(0, ERROR_OPERATION_ABORTED, NULL);
}
TraceFunctLeaveEx((LPARAM)this);
// We always keep the sink happy
return(S_OK);
}
BOOL SMTP_CONNECTION::ProcessAndSendResponse()
{
BOOL fResult = TRUE;
DWORD dwResponseSize = 0;
LPSTR pszResponse = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::ProcessAndSendResponse");
// See if we have a custom response from sinks
dwResponseSize = m_CInboundContext.m_cabResponse.Length();
pszResponse = m_CInboundContext.m_cabResponse.Buffer();
if (!dwResponseSize || !*pszResponse)
{
// Try the native buffer
dwResponseSize = m_CInboundContext.m_cabNativeResponse.Length();
pszResponse = m_CInboundContext.m_cabNativeResponse.Buffer();
// If the response buffer is NULL, we won't send any response.
// For example BDAT exhibits this behavior
}
if (dwResponseSize && *pszResponse)
PE_FastFormatSmtpMessage(pszResponse, dwResponseSize - 1);
// SendResponse if needed
if (!(m_CInboundContext.m_dwCommandStatus & EXPE_PIPELINED))
fResult = SendSmtpResponse();
TraceFunctLeaveEx((LPARAM)this);
return(fResult);
}
/*++
Name :
BOOL SMTP_CONNECTION::GlueDispatch
Description:
Is invoked from ProcessInputBuffer as if it were native handler for SMTP command.
Finds out if the command is native/non-native, and,if native, extended/non-extended.
Then, fires the corresponding mix of native handler and inbound sinks.
Arguments:
char * InputLine null terminated chunk of inbound input buffer from beginning of cmd to CRLF
DWORD IntermediateSize length of the above
DWORD CmdSize length of command keyword
Returns:
TRUE if native handler did or by default
FALSE if native handler did
--*/
BOOL SMTP_CONNECTION::GlueDispatch(char * InputLine, DWORD IntermediateSize, DWORD CmdSize, BOOL * pfAsyncOp)
{
HRESULT hr;
PMFI PointerToMemberFunction = SmtpDispatchTable[m_dwCurrentCommand];
BOOL fSinksInstalled = FALSE;
BOOL fResult = TRUE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::GlueDispatch");
_ASSERT(InputLine);
_ASSERT(m_pInstance);
_ASSERT(pfAsyncOp);
if (!InputLine || !m_pInstance || !pfAsyncOp)
return(FALSE);
// Default is no async operation
*pfAsyncOp = FALSE;
//
// See if we are secure enough for this command
//
switch (m_dwCurrentCommand) {
case HELO:
case EHLO:
case NOOP:
case STARTTLS:
case TLS:
case QUIT:
// These commands don't need to be done securely
break;
default:
if (!IsClientSecureEnough())
{
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_MUST_SECURE, Must do STARTTLS first");
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
}
if(m_pCInboundDispatcher == NULL) {
m_pIEventRouter = m_pInstance->GetRouter();
_ASSERT(m_pIEventRouter);
if (!m_pIEventRouter)
return(FALSE);
hr = m_pIEventRouter->GetDispatcherByClassFactory(
CLSID_CInboundDispatcher,
&g_cfInbound,
CATID_SMTP_ON_INBOUND_COMMAND,
IID_ISmtpInboundCommandDispatcher,
(IUnknown **)&m_pCInboundDispatcher);
if (!SUCCEEDED(hr)){
ErrorTrace((LPARAM) this, "Unable to get dispatcher by CLF on router");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
// pre-loading per command buffer into the context object...
m_CInboundContext.ResetInboundContext();
// null-terminating the command keyword...
char * szTemp;
char * szTemp2;
char * szArgs;
char chReplaced = '\0';
szTemp = strpbrk(InputLine, "\x09\x0a\x0b\x0c\x0d\x20");
if (szTemp == NULL)
{
szTemp = InputLine + strlen(InputLine);
_ASSERT(szTemp);
szArgs = szTemp;
}
else
{
chReplaced = *szTemp;
*szTemp='\0';
szArgs = szTemp;
}
szTemp2 = InputLine;
while (szTemp2 < szTemp)
{
*szTemp2 = (CHAR)tolower(*szTemp2);
szTemp2++;
}
// OK, we know we're dealing with native...
hr = m_pCInboundDispatcher->SinksInstalled(
InputLine,
&(m_CInboundContext.m_pCurrentCommandContext));
if (hr == S_OK)
fSinksInstalled = TRUE;
if (chReplaced != '\0')
*szTemp = chReplaced;
hr = m_CInboundContext.m_cabCommand.Append(
(char *)InputLine,
strlen(InputLine) + 1,
NULL);
if (FAILED(hr))
{
ErrorTrace((LPARAM) this, "Unable to set command buffer");
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
// Make sure IMsg is instantiated...if it's not, instantiate it !!!
if (m_dwCurrentCommand == MAIL)
{
BOOL fCreateIMsg = TRUE;
if (m_pIMsg != NULL)
{
char b;
// If we have an allocated IMailMsg but we don't have a valid
// sender address yet, we will release the object and re-allocate it.
// Otherwise, we will skip the creation of another message object.
hr = m_pIMsg->GetStringA(IMMPID_MP_SENDER_ADDRESS_SMTP, 1, &b);
if(hr == MAILMSG_E_PROPNOTFOUND)
ReleasImsg(TRUE);
else
fCreateIMsg = FALSE;
}
if (fCreateIMsg)
{
// Create a new MailMsg
hr = CoCreateInstance(CLSID_MsgImp,
NULL,
CLSCTX_INPROC_SERVER,
IID_IMailMsgProperties,
(LPVOID *)&m_pIMsg);
// Next, check if we are over the inbound cutoff limit. If so, we will release the message
// and not proceed.
if (SUCCEEDED(hr))
{
DWORD dwCreationFlags;
hr = m_pIMsg->GetDWORD(
IMMPID_MPV_MESSAGE_CREATION_FLAGS,
&dwCreationFlags);
if (FAILED(hr) ||
(dwCreationFlags & MPV_INBOUND_CUTOFF_EXCEEDED))
{
// If we fail to get this property of if the inbound cutoff
// exceeded flag is set, discard the message and return failure
if (SUCCEEDED(hr))
{
DebugTrace((LPARAM)this, "Failing because inbound cutoff reached");
hr = E_OUTOFMEMORY;
}
m_pIMsg->Release();
m_pIMsg = NULL;
}
}
if (SUCCEEDED(hr))
{
hr = m_pIMsg->QueryInterface(IID_IMailMsgRecipients, (void **) &m_pIMsgRecipsTemp);
if (SUCCEEDED(hr))
{
hr = m_pIMsg->QueryInterface(IID_IMailMsgBind, (void **)&m_pBindInterface);
if (SUCCEEDED(hr))
{
hr = m_pIMsgRecipsTemp->AllocNewList(&m_pIMsgRecips);
if (FAILED(hr))
{
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY);
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
fResult = FALSE;
goto ErrorCleanup;
}
hr = SetAvailableMailMsgProperties();
if(FAILED(hr))
{
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_STORAGE);
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
fResult = FALSE;
goto ErrorCleanup;
}
}
else
{
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY);
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
fResult = FALSE;
goto ErrorCleanup;
}
}
else
{
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY);
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
fResult = FALSE;
goto ErrorCleanup;
}
}
else
{
BUMP_COUNTER(QuerySmtpInstance(), MsgsRefusedDueToNoMailObjects);
FormatSmtpMessage (SMTP_RESP_NORESOURCES, ENO_RESOURCES," %s\r\n", SMTP_NO_MEMORY);
m_CInboundContext.SetWin32Status(ERROR_NOT_ENOUGH_MEMORY);
ErrorTrace((LPARAM) this, "GlueDispatch - SMTP_RESP_NORESOURCES, SMTP_NO_MEMORY - MailInfo = new MAILQ_ENTRY () failed");
fResult = FALSE;
goto ErrorCleanup;
}
}
}
// Mark the start fo protocol event processing
m_fIsPeUnderway = TRUE;
if (PointerToMemberFunction != NULL)
{
// This is native
if (fSinksInstalled)
{
LPPE_BINDING_NODE pBinding;
PE_BINDING_NODE bnDefault;
pBinding = m_CInboundContext.m_pCurrentCommandContext->pFirstBinding;
_ASSERT(pBinding);
// Now if the first sink is a post sink, we must create a sentinel
// so we know not to miss the native handler
if (pBinding->dwPriority > PRIO_DEFAULT)
{
bnDefault.dwPriority = PRIO_DEFAULT;
bnDefault.pNext = pBinding;
bnDefault.dwFlags = PEBN_DEFAULT;
pBinding = &bnDefault;
}
hr = OnEvent(
m_pInstance->GetInstancePropertyBag(),
GetSessionPropertyBag(),
m_pIMsg,
m_CInboundContext.m_pCurrentCommandContext,
pBinding,
szArgs
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
else
{
//OK, it's native, not extended command...
// So we just run the native handler on it
fResult = (this->*PointerToMemberFunction)(szArgs, strlen(szArgs));
// all changes got dumped into context automatically...
// the interpreter will see the default response nonempty
// and sink response empty, and it will flush just that...
// for conformity with onevent
hr = S_OK;
// however, we need to modify command status here to signify if
// we need to keep connection open
if (!fResult)
m_CInboundContext.SetCommandStatus(EXPE_DROP_SESSION);
else
m_CInboundContext.SetCommandStatus(EXPE_SUCCESS);
}
}
else
{
// This is not a native command
if (fSinksInstalled)
{
hr = OnEvent(
m_pInstance->GetInstancePropertyBag(),
GetSessionPropertyBag(),
m_pIMsg,
m_CInboundContext.m_pCurrentCommandContext,
m_CInboundContext.m_pCurrentCommandContext->pFirstBinding,
szArgs
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
// once again, all info now sits in the context
// the only thing left is just to check if any sinks were chained for this command,
// and, if not, run a chain of *-sinks on it. If they did not pick it up, either,
// we call on DoLASTCommand and that's all!
//
// jstamerj 1998/10/29 18:01:53: Check the command status code
// to see if we need to continue (in addition to smtp status)
//
if ((m_CInboundContext.m_dwSmtpStatus == 0) &&
(m_CInboundContext.m_dwCommandStatus == EXPE_UNHANDLED))
{
hr = m_pCInboundDispatcher->SinksInstalled(
"*",&(m_CInboundContext.m_pCurrentCommandContext));
if (hr == S_OK)
{
hr = OnEvent(
m_pInstance->GetInstancePropertyBag(),
GetSessionPropertyBag(),
m_pIMsg,
m_CInboundContext.m_pCurrentCommandContext,
m_CInboundContext.m_pCurrentCommandContext->pFirstBinding,
szArgs
);
if (hr == MAILTRANSPORT_S_PENDING)
goto AsyncCompletion;
}
if ((m_CInboundContext.m_dwSmtpStatus == 0) &&
(m_CInboundContext.m_dwCommandStatus == EXPE_UNHANDLED))
{
fResult=(this->DoLASTCommand)(szArgs, strlen(szArgs));
// the context at this point does not contain anything meaningful, so just return
if (!fResult)
m_CInboundContext.m_dwCommandStatus = EXPE_DROP_SESSION;
else
m_CInboundContext.m_dwCommandStatus = EXPE_SUCCESS;
hr = S_OK;
}
}
}
// first, we interpret the hr-logic
// if chaining was normal, proceed, otherwise...
if ((hr != S_OK) &&
(hr != EXPE_S_CONSUMED))
{
ErrorTrace((LPARAM) this, "Error occured during chaining of sinks (%08x)", hr);
}
if (SUCCEEDED(hr))
{
// Format the message if needed
fResult = ProcessAndSendResponse();
// Disconnect client if needed
if (m_CInboundContext.m_dwCommandStatus & EXPE_DROP_SESSION)
{
//Special case for TURN
//where we do not diconnect the connection but simply destroy smtpcli
if(m_DoCleanup)
DisconnectClient();
fResult = FALSE;
}
if ( ( m_CInboundContext.m_dwCommandStatus & EXPE_BLOB_READY) &&
( NULL != m_CInboundContext.m_pICallback))
{
m_fPeBlobReady = TRUE;
m_pPeBlobCallback = m_CInboundContext.m_pICallback;
}
// do things unique to handling the end of a message
if (m_fAsyncEOD) {
ReInitClassVariables();
}
}
else
fResult = FALSE;
// Final cleanup
m_fIsPeUnderway = FALSE;
TraceFunctLeaveEx((LPARAM)this);
return(fResult);
AsyncCompletion:
DebugTrace((LPARAM)this, "Leaving because of S_PENDING");
*pfAsyncOp = TRUE;
TraceFunctLeaveEx((LPARAM)this);
return(TRUE);
ErrorCleanup:
// Cleanup on error. This includes sending out all final
// responses
SendSmtpResponse();
m_fIsPeUnderway = FALSE;
TraceFunctLeaveEx((LPARAM)this);
return(fResult);
}
/*++
Name :
BOOL SMTP_CONNECTION::ProcessPeBlob
Description:
Calls the protocol extension sink callback with a blob buffer.
Arguments:
pbInputLine
cbSize
Returns:
BOOL : continue processing
--*/
BOOL SMTP_CONNECTION::ProcessPeBlob(const char * pbInputLine, DWORD cbSize)
{
BOOL fResult;
HRESULT hr;
BOOL fErrorMessageSent = FALSE;
TraceQuietEnter( "SMTP_CONNECTION::ProcessPeBlob");
_ASSERT( m_fPeBlobReady);
if ( NULL == m_pPeBlobCallback) {
ErrorTrace( ( LPARAM) this, "Sink provided no callback interface");
fResult = FALSE;
goto cleanup;
}
m_CInboundContext.ResetInboundContext();
m_CInboundContext.m_pbBlob = ( PBYTE) pbInputLine;
m_CInboundContext.m_cbBlob = cbSize;
hr = m_pPeBlobCallback->OnSmtpInCallback(
m_pInstance->GetInstancePropertyBag(),
GetSessionPropertyBag(),
m_pIMsg,
( ISmtpInCallbackContext *) &m_CInboundContext);
if ( FAILED( hr)) {
ErrorTrace( ( LPARAM) this, "Sink callback failed, hr=%x", hr);
fResult = FALSE;
goto cleanup;
}
fResult = ProcessAndSendResponse();
if ( FALSE == fResult) {
ErrorTrace( ( LPARAM) this, "ProcessAndSendResponse failed");
goto cleanup;
}
if (m_CInboundContext.m_dwCommandStatus & EXPE_DROP_SESSION) {
fResult = FALSE;
fErrorMessageSent = TRUE;
goto cleanup;
}
if ( m_CInboundContext.m_dwCommandStatus & EXPE_BLOB_DONE) {
m_fPeBlobReady = FALSE;
m_pPeBlobCallback->Release();
m_pPeBlobCallback = NULL;
}
cleanup:
if ( fResult == FALSE) {
m_fPeBlobReady = FALSE;
if ( NULL != m_pPeBlobCallback) {
m_pPeBlobCallback->Release();
m_pPeBlobCallback = NULL;
}
if (!fErrorMessageSent) {
FormatSmtpMessage( SMTP_RESP_ERROR, NULL, " %s\r\n", "Sink problem processing blob");
SendSmtpResponse();
}
}
return fResult;
}
/*++
Name :
BOOL SMTP_CONNECTION::PE_FormatSmtpMessage
Description:
If we are processing non-native or extended native command, caches response in
context object, otherwise passes it along to native FormatSmtpMessage.
Arguments:
As in FormatSmtpMessage.
Returns:
TRUE always
--*/
BOOL SMTP_CONNECTION::PE_FormatSmtpMessage(IN const char * Format, ...)
{
va_list arglist;
char Buffer[MAX_NATIVE_RESPONSE_SIZE];
int BytesWritten;
DWORD AvailableBytes = MAX_NATIVE_RESPONSE_SIZE;
va_start(arglist, Format);
BytesWritten = _vsnprintf (Buffer, AvailableBytes, Format, arglist);
va_end(arglist);
if (!m_fIsPeUnderway)
{
//pass in 0 for the code and NULL for the enhanced staus code
//
FormatSmtpMessage(0,NULL,"%s", Buffer);
}
else
{
m_CInboundContext.AppendNativeResponse(Buffer, strlen(Buffer) + 1);
}
return TRUE;
}
/*++
Name :
BOOL SMTP_CONNECTION::PE_CdFormatSmtpMessage
Description:
As PE_FormatSmtpMessage above, except intercepts the SMTP return code.
Arguments:
As in PE_FormatSmtpMessage above, except add'l slot for SMTP return code.
Returns:
TRUE always
--*/
BOOL SMTP_CONNECTION::PE_CdFormatSmtpMessage(DWORD dwCode, const char * szEnhancedCodes, IN const char * Format,...)
{
va_list arglist;
char Buffer[MAX_NATIVE_RESPONSE_SIZE];
int BytesWritten;
DWORD AvailableBytes = MAX_NATIVE_RESPONSE_SIZE;
char RealFormat[MAX_PATH];
if(m_pInstance->AllowEnhancedCodes() && szEnhancedCodes)
{
sprintf(RealFormat,"%d %s",dwCode,szEnhancedCodes);
}
else
sprintf(RealFormat,"%d",dwCode);
strcat(RealFormat,Format);
va_start(arglist, Format);
BytesWritten = _vsnprintf (Buffer, AvailableBytes, (const char * )RealFormat, arglist);
if(BytesWritten == -1) {
//
// If response is too long, forcibly truncate it
// This might mean that the human readable part of the response may be
// incomplete... but there's nothing we can do about that easily.
//
Buffer[MAX_NATIVE_RESPONSE_SIZE-3] = '\r';
Buffer[MAX_NATIVE_RESPONSE_SIZE-2] = '\n';
Buffer[MAX_NATIVE_RESPONSE_SIZE-1] = '\0';
}
if (m_fIsPeUnderway)
{
PE_FormatSmtpMessage("%s",Buffer);
m_CInboundContext.SetSmtpStatusCode(dwCode);
}
else
{
//pass in 0 for the code and NULL for the enhanced staus code
//
FormatSmtpMessage(0,NULL,"%s",Buffer);
}
va_end(arglist);
return TRUE;
}
/*++
Name :
BOOL SMTP_CONNECTION::PE_DisconnectClient
Description:
If we are processing non-native or extended native command, caches DisconnectClient
calls' occurences in context object, otherwise passes it along to native
DisconnectClient.
Arguments:
none
Returns:
TRUE always
--*/
BOOL SMTP_CONNECTION::PE_DisconnectClient()
{
if (m_fIsPeUnderway)
{
m_CInboundContext.m_dwCommandStatus = m_CInboundContext.m_dwCommandStatus | EXPE_DROP_SESSION;
}
else
{
DisconnectClient();
}
return TRUE;
}
/*++
Name :
BOOL SMTP_CONNECTION::PE_SendSmtpResponse
Description:
If we are processing non-native or extended native command, caches SendSmtpResponse
calls' occurences in context object, otherwise passes it along to native
SendSmtpResponse.
Arguments:
none
Returns:
TRUE always if we're called from GlueDispatch callee's
SendSmtpResponse return otherwise
--*/
BOOL SMTP_CONNECTION::PE_SendSmtpResponse()
{
if (m_fIsPeUnderway)
{
m_CInboundContext.m_dwCommandStatus = m_CInboundContext.m_dwCommandStatus & (~EXPE_PIPELINED);
return TRUE;
}
else
{
return SendSmtpResponse();
};
}
//////////////////////////////////////////////////////////////////////////////
//---[ SMTP_CONNECTION::GetAndPersistRFC822Headers ]--------------------------
//
//
// Description:
// Parses and RFC822 headers, and promotes them to the P2 if neccessary
// Parameters:
// IN InputLine String with start of link (processed by ChompHeader)
// IN psValueBuf String with value of header
// Returns:
// -
// History:
// 2/8/99 - MikeSwa Updated - moved received header parsing to this function
//
//-----------------------------------------------------------------------------
void SMTP_CONNECTION::GetAndPersistRFC822Headers(
char* InputLine,
char* pszValueBuf
)
{
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNECTION::GetAndPersistRFC822Headers");
HRESULT hr = S_OK;
//count the number of received lines for hop count
//analysis later
if(!strncasecmp(InputLine, "Received:", strlen("Received:")) ||
!strncasecmp(InputLine, "Received :", strlen("Received :")))
{
m_HopCount++;
CHAR szText[2024];
CHAR * pszTemp;
// Check if this string represents the local server - if it does we might be
// looping around and we need to keep track of how many times this server has
// seen the message
sprintf(szText,szFormatReceivedServer, m_pInstance->GetFQDomainName());
pszTemp = strstr(InputLine, szText);
if (pszTemp)
{
// we found the string, make sure we also find "with Microsoft SMTPSVC"
sprintf(szText,szFormatReceivedService);
pszTemp = strstr(InputLine, szText);
if (pszTemp)
{
// we found that string too - we've been here before,
// increment m_LocalHopCount
m_LocalHopCount++;
}
}
}
//
// Get the message ID and persist it
//
if( !m_fSeenRFC822MsgId &&
( !strncasecmp( InputLine, "Message-ID:", strlen("Message-ID:") ) ||
!strncasecmp( InputLine, "Message-ID :", strlen("Message-ID :") ) ) )
{
m_fSeenRFC822MsgId = TRUE;
if( pszValueBuf )
{
//
// Some MTAs fold Message-IDs. Embedded CRLFs in a Message-ID can cause trouble since
// we use it for message tracking, and in the "Queued" response, so we unfold the
// Message-ID prior to using it.
//
CHAR *pszUnfolded = NULL;
if(!UnfoldHeader(pszValueBuf, &pszUnfolded))
{
m_MailBodyError = E_OUTOFMEMORY;
TraceFunctLeaveEx((LPARAM) this);
return;
}
if(pszUnfolded)
pszValueBuf = pszUnfolded;
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_ID, pszValueBuf ) ) )
m_MailBodyError = hr;
if(pszUnfolded)
FreeUnfoldedHeader(pszUnfolded);
TraceFunctLeaveEx((LPARAM) this);
return;
}
}
//
// get the Subject: & persist it
//
if( !m_fSeenRFC822Subject &&
( !strncasecmp( InputLine, "Subject:", strlen("Subject:") ) ||
!strncasecmp( InputLine, "Subject :", strlen("Subject :") ) ) )
{
m_fSeenRFC822Subject = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_SUBJECT, pszValueBuf ) ) )
m_MailBodyError = hr;
}
}
//
// get the To: address & persist it
//
if( !m_fSeenRFC822ToAddress &&
( !strncasecmp( InputLine, "To:", strlen("To:") ) ||
!strncasecmp( InputLine, "To :", strlen("To :") ) ) )
{
m_fSeenRFC822ToAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_TO_ADDRESS, pszValueBuf ) ) )
m_MailBodyError = hr;
}
}
//
// get the Cc: address & persist it
//
if( !m_fSeenRFC822CcAddress &&
( !strncasecmp( InputLine, "Cc:", strlen("Cc:") ) ||
!strncasecmp( InputLine, "Cc :", strlen("Cc :") ) ) )
{
m_fSeenRFC822CcAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_CC_ADDRESS, pszValueBuf ) ) )
m_MailBodyError = hr;
}
}
//
// get the Bcc: address & persist it
//
if( !m_fSeenRFC822BccAddress &&
( !strncasecmp( InputLine, "Bcc:", strlen("Bcc:") ) ||
!strncasecmp( InputLine, "Bcc :", strlen("Bcc :") ) ) )
{
m_fSeenRFC822BccAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_BCC_ADDRESS, pszValueBuf ) ) )
m_MailBodyError = hr;
}
}
//
// get the From: address & persist it
//
if( !m_fSeenRFC822FromAddress &&
( !strncasecmp( InputLine, "From:", strlen("From:") ) ||
!strncasecmp( InputLine, "From :", strlen("From :") ) ) )
{
m_fSeenRFC822FromAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_RFC822_FROM_ADDRESS, pszValueBuf ) ) )
m_MailBodyError = hr;
char szSmtpFromAddress[MAX_INTERNET_NAME + 6] = "smtp:";
char *pszDomainOffset;
DWORD cAddr;
if (CAddr::ExtractCleanEmailName(szSmtpFromAddress + 5, &pszDomainOffset, &cAddr, pszValueBuf)) {
if (FAILED(hr = m_pIMsg->PutStringA(IMMPID_MP_FROM_ADDRESS, szSmtpFromAddress))) {
m_MailBodyError = hr;
}
}
}
}
if( !m_fSeenRFC822SenderAddress &&
( !strncasecmp( InputLine, "Sender:", strlen("Sender:") ) ||
!strncasecmp( InputLine, "Sender :", strlen("Sender :") ) ) )
{
m_fSeenRFC822SenderAddress = TRUE;
if( pszValueBuf )
{
char szSmtpSenderAddress[MAX_INTERNET_NAME + 6] = "smtp:";
char *pszDomainOffset;
DWORD cAddr;
if (CAddr::ExtractCleanEmailName(szSmtpSenderAddress + 5, &pszDomainOffset, &cAddr, pszValueBuf)) {
if (FAILED(hr = m_pIMsg->PutStringA(IMMPID_MP_SENDER_ADDRESS, szSmtpSenderAddress))) {
m_MailBodyError = hr;
}
}
}
}
//
// get the X-Priority & persist it
//
if( !m_fSeenXPriority &&
( !strncasecmp( InputLine, "X-Priority:", strlen("X-Priority:") ) ||
!strncasecmp( InputLine, "X-Priority :", strlen("X-Priority :") ) ) )
{
m_fSeenXPriority = TRUE;
if( pszValueBuf )
{
DWORD dwPri = (DWORD)atoi( pszValueBuf );
if( FAILED( hr = m_pIMsg->PutDWORD( IMMPID_MP_X_PRIORITY, dwPri ) ) )
m_MailBodyError = hr;
}
}
//
// get the X-OriginalArrivalTime & persist it
//
if( !m_fSeenXOriginalArrivalTime &&
( !strncasecmp( InputLine, "X-OriginalArrivalTime:", strlen("X-OriginalArrivalTime:") ) ||
!strncasecmp( InputLine, "X-OriginalArrivalTime :", strlen("X-OriginalArrivalTime :") ) ) )
{
m_fSeenXOriginalArrivalTime = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_ORIGINAL_ARRIVAL_TIME, pszValueBuf ) ) )
m_MailBodyError = hr;
}
}
//
// get the content type & persist it
//
if( !m_fSeenContentType &&
( !strncasecmp( InputLine, "Content-Type:", strlen("Content-Type:") ) ||
!strncasecmp( InputLine, "Content-Type :", strlen("Content-Type :") ) ) )
{
m_fSeenContentType = TRUE;
m_fSetContentType = TRUE;
DWORD dwContentType = 0;
if( pszValueBuf )
{
if( !strncasecmp( pszValueBuf, "multipart/signed", strlen("multipart/signed") ) )
{
dwContentType = 1;
}
else if( !strncasecmp( pszValueBuf, "application/x-pkcs7-mime", strlen("application/x-pkcs7-mime") ) ||
!strncasecmp( pszValueBuf, "application/pkcs7-mime", strlen("application/pkcs7-mime") ) )
{
dwContentType = 2;
}
if( FAILED( hr = m_pIMsg->PutStringA( IMMPID_MP_CONTENT_TYPE, pszValueBuf ) ) )
m_MailBodyError = hr;
}
if( FAILED( hr = m_pIMsg->PutDWORD( IMMPID_MP_ENCRYPTION_TYPE, dwContentType ) ) )
m_MailBodyError = hr;
}
if( !m_fSetContentType )
{
m_fSetContentType = TRUE;
if( FAILED( hr = m_pIMsg->PutDWORD( IMMPID_MP_ENCRYPTION_TYPE, 0 ) ) )
m_MailBodyError = hr;
}
TraceFunctLeaveEx((LPARAM) this);
}
//////////////////////////////////////////////////////////////////////////////
HRESULT SMTP_CONNECTION::SetAvailableMailMsgProperties()
{
//set IPaddress that is already available
HRESULT hr = m_pIMsg->PutStringA(IMMPID_MP_CONNECTION_IP_ADDRESS, QueryClientHostName());
if(FAILED(hr))
{
return( hr );
}
hr = m_pIMsg->PutStringA(IMMPID_MP_CONNECTION_SERVER_IP_ADDRESS, QueryLocalHostName());
if(FAILED(hr))
{
return( hr );
}
hr = m_pIMsg->PutStringA(IMMPID_MP_SERVER_NAME, g_ComputerName);
if(FAILED(hr))
{
return( hr );
}
hr = m_pIMsg->PutStringA(IMMPID_MP_SERVER_VERSION, g_VersionString);
if(FAILED(hr))
{
return( hr );
}
if (QueryLocalPortName())
{
DWORD dwPortNum = atoi(QueryLocalPortName());
hr = m_pIMsg->PutDWORD(IMMPID_MP_CONNECTION_SERVER_PORT, dwPortNum);
if (FAILED(hr))
return ( hr );
}
hr = m_pIMsg->PutStringA(IMMPID_MP_HELO_DOMAIN, QueryClientUserName());
if(FAILED(hr))
{
return hr;
}
if (m_fAuthenticated)
{
//Get username
if (m_securityCtx.QueryUserName())
{
hr = m_pIMsg->PutStringA(IMMPID_MP_CLIENT_AUTH_USER,
m_securityCtx.QueryUserName());
if (FAILED(hr))
return hr;
}
//Get type of authentication
if (m_szUsedAuthKeyword[0])
{
hr = m_pIMsg->PutStringA(IMMPID_MP_CLIENT_AUTH_TYPE, m_szUsedAuthKeyword);
if (FAILED(hr))
return hr;
}
}
return( hr );
}
//-----------------------------------------------------------------------------
// Description:
// If a failure occurs after a client issues the BDAT command, SMTP cannot
// respond with a failure code (since the RFC forbids a BDAT response). So
// SMTP calls this function which will read BDAT chunks from the socket
// and discard them. When the chunk has been received, and it is time to
// ACK the chunk, this function calls DoBDATErrorProcessing() to send the
// correct error response.
//
// Arguments:
// IN const char *InputLine - Ptr to data from client
// IN DWORD UndecryptedTailSize - # of undecrypted bytes in buffer (TLS)
//
// OUT BOOL *pfAsyncOp - If this function succeeded, this is set to TRUE
// if all the data in the input buffer was consumed and we pended a
// read to pick up more. If this is FALSE, and the function succeeded
// there is extra (pipelined) data in the input buffer, and it must
// be parsed as an SMTP command.
//
// Notes:
// If there is data left in the input buffer after this function is done,
// that data should be parsed as an SMTP command.
//
// Returns:
// TRUE - Keep connection alive.
// FALSE - Drop connection, there was a fatal error.
//
//-----------------------------------------------------------------------------
BOOL SMTP_CONNECTION::AcceptAndDiscardBDAT(
const char *InputLine,
DWORD UndecryptedTailSize,
BOOL *pfAsyncOp)
{
BOOL fReturn = FALSE;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::AcceptAndDiscardBDAT");
_ASSERT(m_MailBodyDiagnostic != ERR_NONE);
*pfAsyncOp = FALSE;
// Note: m_nBytesRemainingInChunk may be zero if "BDAT 0 LAST" is submitted.
// we should be able to handle this.
if((DWORD)m_nBytesRemainingInChunk <= m_cbParsable)
{
//
// Chunk completely received, discard it, do error processing.
//
DebugTrace((LPARAM) this, "Chunk completed");
MoveMemory((PVOID) InputLine, InputLine + m_nBytesRemainingInChunk,
m_cbReceived - m_nBytesRemainingInChunk);
m_cbParsable -= m_nBytesRemainingInChunk;
m_cbReceived -= m_nBytesRemainingInChunk;
m_nBytesRemainingInChunk = 0;
m_fIsChunkComplete = TRUE;
if(!MailBodyErrorProcessing()) {
fReturn = FALSE;
goto Exit;
}
//
// If we're done with all BDAT chunks, reset state. If this is NOT the last
// BDAT chunk, then either more BDAT commands/chunks are already buffered
// in the input buffer due to pipelining, or they're on their way. We need
// to accept and discard all of them. m_fIsLastChunk is set by DoBDATCommand.
//
if(m_fIsLastChunk)
{
DebugTrace((LPARAM) this, "Last chunk");
//
// Note: This doesn't flush the input buffer, so any pipelined data is
// still kept around. Thus the check for m_cbParsable below is valid.
//
ReInitClassVariables();
}
//
// If we got here, there is additional data left in the buffer. This must
// be pipelined data sent by the client, along with the just discarded
// chunk.
//
*pfAsyncOp = FALSE;
fReturn = TRUE;
}
else
{
//
// The complete chunk has not been received, discard whatever we got, update
// the counts of bytes received/expected and pend a read to pick up more.
//
DebugTrace((LPARAM) this, "Processing partial chunk");
MoveMemory((PVOID) InputLine, InputLine + m_cbParsable, m_cbReceived - m_cbParsable);
m_nBytesRemainingInChunk -= m_cbParsable;
m_cbReceived -= m_cbParsable;
m_cbParsable = 0;
_ASSERT(!m_fIsChunkComplete);
fReturn = PendReadIO(UndecryptedTailSize);
*pfAsyncOp = fReturn;
goto Exit;
}
Exit:
//
// If we succeeded, one of the following is true:
// (1) Either there wasn't enough data to complete the chunk and we pended a read.
// (2) There was enough data to complete the chunk, and the remaining bytes are
// to be interpreted as an SMTP command (m_nBytesRemainingInChunk == 0).
//
if(fReturn && !*pfAsyncOp)
_ASSERT(m_nBytesRemainingInChunk == 0);
TraceFunctLeaveEx((LPARAM) this);
return fReturn;
}
BOOL SMTP_CONNECTION::AcceptAndDiscardDATA(
const char *InputLine,
DWORD UndecryptedTailSize,
BOOL *pfAsyncOp)
{
DWORD IntermediateSize = 0;
BOOL fRet = FALSE;
char *pszSearch = NULL;
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::AcceptAndDiscardDATA");
_ASSERT(m_MailBodyDiagnostic != ERR_NONE);
*pfAsyncOp = FALSE;
//
// Discard data line by line until we hit an incomplete line. Then break
// out of loop and pend a read to pick up more data. If we hit a line that
// has only a "." in it, that is the end of the mailbody. Kick off error
// processing, reinit the state and return.
//
while(pszSearch = IsLineComplete(InputLine, m_cbParsable))
{
IntermediateSize = (DWORD) (pszSearch - InputLine);
if(IntermediateSize == 1 &&
InputLine[0] == '.' && InputLine[1] == '\r' && InputLine[2] == '\n')
{
m_cbReceived -= IntermediateSize + 2; // +2 for CRLF since pszSearch points->CR
m_cbParsable -= IntermediateSize + 2;
MoveMemory((PVOID *)InputLine, pszSearch + 2, m_cbReceived);
if(MailBodyErrorProcessing())
{
ReInitClassVariables();
fRet = TRUE;
}
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
m_cbReceived -= IntermediateSize + 2; // +2 for CRLF since pszSearch points->CR
m_cbParsable -= IntermediateSize + 2;
MoveMemory((PVOID *)InputLine, pszSearch + 2, m_cbReceived);
}
//
// Pend a read to pick up rest of the mail body.
//
fRet = PendReadIO(UndecryptedTailSize);
*pfAsyncOp = fRet;
TraceFunctLeaveEx((LPARAM) this);
return fRet;
}
//-----------------------------------------------------------------------------
// Description:
// Based on m_MailBodyDiagnostic, this function performs error processing for
// errors that occurred during BDAT. BDAT errors that occur when BDAT
// is issued are not processed as soon as the error occurs, but after
// SMTP has accepted the BDAT chunk (see AcceptAndDiscardBDAT()).
// Arguments:
// None.
// Returns:
// TRUE - Success, error response sent.
// FALSE - Drop connection. Either there was an error, or error processing
// requires dropping the connection (This is an RFC violation if there
// is pipelined data in the input buffer).
//-----------------------------------------------------------------------------
BOOL SMTP_CONNECTION::MailBodyErrorProcessing()
{
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNECTION::DoBDATErrorProcessing");
switch(m_MailBodyDiagnostic) {
case ERR_RETRY:
case ERR_OUT_OF_MEMORY:
PE_CdFormatSmtpMessage(SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_MEMORY);
break;
case ERR_MAX_MSG_SIZE:
PE_CdFormatSmtpMessage(SMTP_RESP_NOSTORAGE, ENO_RESOURCES, " %s\r\n", SMTP_MAX_MSG_SIZE_EXCEEDED_MSG );
break;
case ERR_AUTH_NEEDED:
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", "Client was not authenticated");
break;
case ERR_TLS_NEEDED:
PE_CdFormatSmtpMessage (SMTP_RESP_MUST_SECURE, ENO_SECURITY, " %s\r\n", SMTP_MSG_MUST_SECURE);
break;
case ERR_HELO_NEEDED:
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Send hello first" );
break;
case ERR_MAIL_NEEDED:
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Need mail command." );
break;
case ERR_RCPT_NEEDED:
PE_CdFormatSmtpMessage (SMTP_RESP_BAD_SEQ, ESYNTAX_ERROR," %s\r\n", "Need Rcpt command." );
break;
case ERR_NO_VALID_RCPTS:
PE_CdFormatSmtpMessage (SMTP_RESP_TRANS_FAILED, ESYNTAX_ERROR," %s\r\n", SMTP_NO_VALID_RECIPS );
break;
default:
_ASSERT(0 && "Bad err value");
PE_CdFormatSmtpMessage(SMTP_RESP_NORESOURCES, ENO_RESOURCES, " %s\r\n",SMTP_NO_MEMORY);
ErrorTrace((LPARAM) this, "BUG: bad value");
}
TraceFunctLeaveEx((LPARAM) this);
return SendSmtpResponse(); // Error responses are not pipelined
}
//////////////////////////////////////////////////////////////////////////////
BOOL SMTP_CONNECTION::WriteLine (char * TextToWrite, DWORD TextSize)
{
/*#if 0
char * SavedLine = TextToWrite;
char * EndOfLine = &SavedLine[TextSize];
DWORD LineSize = 0;
while( (LineSize = (EndOfLine - SavedLine)) > 78)
{
char * RealEndOfLine = &TextToWrite[78 - 2];
if(!WriteMailFile(TextToWrite, RealEndOfLine - SavedLine))
return FALSE;
m_TotalMsgSize += (RealEndOfLine - SavedLine);
if(!WriteMailFile("\r\n", 2))
return FALSE;
m_TotalMsgSize += 2;
if(!WriteMailFile("\t", 1))
return FALSE;
m_TotalMsgSize += 1;
SavedLine = RealEndOfLine;
}
if(LineSize > 0)
{
if(!WriteMailFile(TextToWrite, LineSize))
return FALSE;
m_TotalMsgSize += LineSize;
}
if(!WriteMailFile("\r\n", 2))
return FALSE;
m_TotalMsgSize += 2;
return TRUE;
#endif*/
return FALSE;
}
BOOL SMTP_CONNECTION::AddToField(void)
{
/*#if 0
char szWriteBuffer [1000];
char szNameBuf[MAX_INTERNET_NAME + 100];
int LineSize = 0;
int PrevLineSize = 0;
DWORD NumAddress = 0;
DWORD BuffOffSet = 0;
DWORD MaxLineSize = 78;
CAddr * pCAddr = NULL;
PLIST_ENTRY pentry = NULL;
char * HeadChar ="";
//write the "To: " first. This includes the space
BuffOffSet = (DWORD) wsprintf(szWriteBuffer, "To: ");
//get the first address
pCAddr = MailInfo->GetFirstAddress(&pentry);
while(pCAddr != NULL)
{
if(NumAddress)
{
HeadChar = ", ";
}
LineSize = wsprintf(szNameBuf, "%s<%s>", HeadChar, pCAddr->GetAddress());
if( (DWORD)(LineSize + PrevLineSize) < MaxLineSize)
{
CopyMemory(&szWriteBuffer[BuffOffSet], szNameBuf, LineSize);
PrevLineSize += LineSize;
BuffOffSet += LineSize;
}
else
{
szWriteBuffer[BuffOffSet++] = CR;
szWriteBuffer[BuffOffSet++] = LF;
if(!WriteMailFile(szWriteBuffer, BuffOffSet))
return FALSE;
m_TotalMsgSize += BuffOffSet;
szWriteBuffer[0] = '\t';
CopyMemory(&szWriteBuffer[1], szNameBuf, LineSize);
BuffOffSet = LineSize + 1;
PrevLineSize = BuffOffSet;
}
NumAddress++;
//get the first address
pCAddr = MailInfo->GetNextAddress(&pentry);
}
szWriteBuffer[BuffOffSet++] = CR;
szWriteBuffer[BuffOffSet++] = LF;
if(WriteMailFile(szWriteBuffer, BuffOffSet))
{
m_TotalMsgSize += BuffOffSet ;
return TRUE;
}
return FALSE;
#endif*/
return TRUE;
}
//---[ SMTP_CONNECTION::CopyIPAddressesToSession ]---------------------------
//
//
// Description:
// Copies the CLIENT_CONNECTION data into the session property bag used by
// inbound and outbound connections
// Parameters:
// -
// Returns:
// -
// History:
// 11/28/2001 - MikeSwa Created
//
//-----------------------------------------------------------------------------
VOID SMTP_CONNECTION::CopyIPAddressesToSession()
{
TraceFunctEnterEx((LPARAM) this,
"SMTP_CONNECTION::CopyIPAddressesToSession");
HRESULT hr = S_OK;
IMailMsgPropertyBag *pISessionProperties =
(IMailMsgPropertyBag *)GetSessionPropertyBag();
if (!pISessionProperties) {
ErrorTrace((LPARAM) this, "NULL ISession - bailing");
goto Exit;
}
hr = pISessionProperties->PutStringA(ISESSION_PID_LOCAL_IP_ADDRESS,
QueryLocalHostName());
if (FAILED(hr)) {
//Trace error... otherwise ignore.
ErrorTrace((LPARAM) this,
"Failed to write ISESSION_PID_LOCAL_IP_ADDRESS 0x%08X", hr);
}
hr = pISessionProperties->PutStringA(ISESSION_PID_REMOTE_IP_ADDRESS,
QueryClientHostName());
if (FAILED(hr)) {
//Trace error... otherwise ignore.
ErrorTrace((LPARAM) this,
"Failed to write ISESSION_PID_REMOTE_IP_ADDRESS 0x%08X", hr);
}
Exit:
TraceFunctLeave();
}
Reference in New Issue View Git Blame Copy Permalink