mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5392 lines
174 KiB
5392 lines
174 KiB
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
smtpout.cxx
|
|
|
|
Abstract:
|
|
|
|
This module defines the functions for derived class of connections
|
|
for Internet Services ( class SMTP_CONNOUT)
|
|
|
|
Author:
|
|
|
|
Rohan Phillips ( Rohanp ) 02-Feb-1996
|
|
|
|
Project:
|
|
|
|
SMTP Server DLL
|
|
|
|
Functions Exported:
|
|
|
|
SMTP_CONNOUT::~SMTP_CONNOUT()
|
|
BOOL SMTP_CONNOUT::ProcessClient( IN DWORD cbWritten,
|
|
IN DWORD dwCompletionStatus,
|
|
IN BOOL fIOCompletion)
|
|
|
|
BOOL SMTP_CONNOUT::StartupSession( VOID)
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
/************************************************************
|
|
* Include Headers
|
|
************************************************************/
|
|
|
|
|
|
#define INCL_INETSRV_INCS
|
|
#include "smtpinc.h"
|
|
#include "remoteq.hxx"
|
|
#include "smtpmsg.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 "smtpcli.hxx"
|
|
#include "smtpout.hxx"
|
|
#include <smtpevent.h>
|
|
#include <smtpguid.h>
|
|
|
|
//
|
|
// Dispatcher implementation
|
|
//
|
|
#include "pe_dispi.hxx"
|
|
|
|
|
|
int strcasecmp(char *s1, char *s2);
|
|
int strncasecmp(char *s1, char *s2, int n);
|
|
|
|
extern CHAR g_VersionString[];
|
|
|
|
static char * IsLineCompleteBW(IN OUT char * pchRecvd, IN DWORD cbRecvd, IN DWORD cbMaxRecvBuffer);
|
|
|
|
#define SMTP_DUMMY_FAILURE (0x1000 | SMTP_ACTION_ABORTED_CODE)
|
|
#define SMTPOUT_CONTENT_FILE_IO_TIMEOUT 2*60*1000
|
|
|
|
static const char * TO_MANY_RCPTS_ERROR = "552 Too many recipients";
|
|
|
|
#define KNOWN_AUTH_FLAGS ((DWORD)(DOMAIN_INFO_USE_NTLM | DOMAIN_INFO_USE_PLAINTEXT | DOMAIN_INFO_USE_DPA \
|
|
| DOMAIN_INFO_USE_KERBEROS))
|
|
|
|
#define INVALID_RCPT_IDX_VALUE 0xFFFFFFFF
|
|
|
|
// provide memory for static declared in SMTP_CONNOUT
|
|
CPool SMTP_CONNOUT::Pool(CLIENT_CONNECTION_SIGNATURE_VALID);
|
|
|
|
//
|
|
// Statics for outbound protocol events
|
|
//
|
|
CInboundDispatcherClassFactory g_cfInbound;
|
|
COutboundDispatcherClassFactory g_cfOutbound;
|
|
CResponseDispatcherClassFactory g_cfResponse;
|
|
|
|
/************************************************************
|
|
* Functions
|
|
************************************************************/
|
|
|
|
#define MAX_LOG_ERROR_LEN (500)
|
|
|
|
extern void DeleteDnsRec(PSMTPDNS_RECS pDnsRec);
|
|
|
|
VOID
|
|
SmtpCompletion(
|
|
PVOID pvContext,
|
|
DWORD cbWritten,
|
|
DWORD dwCompletionStatus,
|
|
OVERLAPPED * lpo
|
|
);
|
|
|
|
/*++
|
|
Name :
|
|
InternetCompletion
|
|
|
|
Description:
|
|
|
|
Handles a completed I/O for outbound connections.
|
|
|
|
Arguments:
|
|
|
|
pvContext: the context pointer specified in the initial IO
|
|
cbWritten: the number of bytes sent
|
|
dwCompletionStatus: the status of the completion (usually NO_ERROR)
|
|
lpo: the overlapped structure associated with the IO
|
|
|
|
Returns:
|
|
|
|
nothing.
|
|
|
|
--*/
|
|
VOID InternetCompletion(PVOID pvContext, DWORD cbWritten,
|
|
DWORD dwCompletionStatus, OVERLAPPED * lpo)
|
|
{
|
|
BOOL WasProcessed;
|
|
SMTP_CONNOUT *pCC = (SMTP_CONNOUT *) pvContext;
|
|
|
|
_ASSERT(pCC);
|
|
_ASSERT(pCC->IsValid());
|
|
_ASSERT(pCC->QuerySmtpInstance() != NULL);
|
|
|
|
TraceFunctEnterEx((LPARAM) pCC, "InternetCompletion");
|
|
|
|
// if we could not process a command, or we were
|
|
// told to destroy this object, close the connection.
|
|
WasProcessed = pCC->ProcessClient(cbWritten, dwCompletionStatus, lpo);
|
|
if (!WasProcessed) {
|
|
pCC->DisconnectClient();
|
|
pCC->QuerySmtpInstance()->RemoveOutboundConnection(pCC);
|
|
delete pCC;
|
|
pCC = NULL;
|
|
}
|
|
|
|
//TraceFunctLeaveEx((LPARAM)pCC);
|
|
}
|
|
|
|
VOID FIOInternetCompletion(PFIO_CONTEXT pFIOContext,
|
|
PFH_OVERLAPPED lpo,
|
|
DWORD cbWritten,
|
|
DWORD dwCompletionStatus)
|
|
{
|
|
BOOL WasProcessed;
|
|
SMTP_CONNOUT *pCC = (SMTP_CONNOUT *) (((SERVEREVENT_OVERLAPPED *) lpo)->ThisPtr);
|
|
|
|
_ASSERT(pCC);
|
|
_ASSERT(pCC->IsValid());
|
|
_ASSERT(pCC->QuerySmtpInstance() != NULL);
|
|
|
|
TraceFunctEnterEx((LPARAM) pCC, "InternetCompletion");
|
|
|
|
// if we could not process a command, or we were
|
|
// told to destroy this object, close the connection.
|
|
WasProcessed = pCC->ProcessClient(cbWritten, dwCompletionStatus, (OVERLAPPED *) lpo);
|
|
|
|
if (!WasProcessed) {
|
|
pCC->DisconnectClient();
|
|
pCC->QuerySmtpInstance()->RemoveOutboundConnection(pCC);
|
|
delete pCC;
|
|
pCC = NULL;
|
|
}
|
|
|
|
//TraceFunctLeaveEx((LPARAM)pCC);
|
|
}
|
|
|
|
void SMTP_CONNOUT::ProtocolLogCommand(LPSTR pszCommand,
|
|
DWORD cParameters,
|
|
LPCSTR pszIpAddress,
|
|
FORMAT_SMTP_MESSAGE_LOGLEVEL eLogLevel)
|
|
{
|
|
char *pszCR = NULL, *pszParameters = NULL, *pszSpace = NULL;
|
|
DWORD cBytesSent;
|
|
|
|
if (eLogLevel == FSM_LOG_NONE) return;
|
|
|
|
if (pszCR = strchr(pszCommand, '\r')) *pszCR = 0;
|
|
|
|
if (pszSpace = strchr(pszCommand, ' ')) {
|
|
*pszSpace = 0;
|
|
pszParameters = (eLogLevel == FSM_LOG_ALL) ? pszSpace + 1 : NULL;
|
|
}
|
|
|
|
cBytesSent = strlen(pszCommand);
|
|
|
|
LogRemoteDeliveryTransaction(
|
|
pszCommand,
|
|
NULL,
|
|
pszParameters,
|
|
pszIpAddress,
|
|
0,
|
|
0,
|
|
cBytesSent,
|
|
0,
|
|
FALSE);
|
|
|
|
if (pszCR) *pszCR = '\r';
|
|
if (pszSpace) *pszSpace = ' ';
|
|
}
|
|
|
|
void SMTP_CONNOUT::ProtocolLogResponse(LPSTR pszResponse,
|
|
DWORD cParameters,
|
|
LPCSTR pszIpAddress)
|
|
{
|
|
char *pszCR = NULL;
|
|
DWORD cBytesReceived;
|
|
|
|
if (pszCR = strchr(pszResponse, '\r')) *pszCR = 0;
|
|
cBytesReceived = strlen(pszResponse);
|
|
|
|
LogRemoteDeliveryTransaction(
|
|
NULL,
|
|
NULL,
|
|
pszResponse,
|
|
pszIpAddress,
|
|
0,
|
|
0,
|
|
cBytesReceived,
|
|
0,
|
|
TRUE);
|
|
|
|
if (pszCR) *pszCR = '\r';
|
|
}
|
|
|
|
void SMTP_CONNOUT::LogRemoteDeliveryTransaction(
|
|
LPCSTR pszOperation,
|
|
LPCSTR pszTarget,
|
|
LPCSTR pszParameters,
|
|
LPCSTR pszIpAddress,
|
|
DWORD dwWin32Error,
|
|
DWORD dwServiceSpecificStatus,
|
|
DWORD dwBytesSent,
|
|
DWORD dwBytesReceived,
|
|
BOOL fResponse
|
|
)
|
|
{
|
|
INETLOG_INFORMATION translog;
|
|
DWORD dwLog;
|
|
LPSTR lpNull = "";
|
|
DWORD cchError = MAX_LOG_ERROR_LEN;
|
|
char VersionString[] = "SMTP";
|
|
char szClientUserNameCommand[] = "OutboundConnectionCommand";
|
|
char szClientUserNameResponse[] = "OutboundConnectionResponse";
|
|
|
|
//Buffers to prevent overwrite by IIS logging
|
|
//which does evil things like change '<sp>' to '+'
|
|
// 6/23/99 - MikeSwa
|
|
char szOperationBuffer[20] = ""; //This is the protocol verb
|
|
char szTargetBuffer[20] = ""; //Currently unused by all callers
|
|
char szParametersBuffer[1024] = ""; //Data portion of buffer information
|
|
|
|
ZeroMemory(&translog, sizeof(translog));
|
|
|
|
if (pszParameters == NULL)
|
|
pszParameters = lpNull;
|
|
|
|
if (pszIpAddress == NULL)
|
|
pszIpAddress = lpNull;
|
|
|
|
translog.pszVersion = VersionString;
|
|
translog.msTimeForProcessing = QueryProcessingTime();;
|
|
if (fResponse) {
|
|
translog.pszClientUserName = szClientUserNameResponse;
|
|
} else {
|
|
translog.pszClientUserName = szClientUserNameCommand;
|
|
}
|
|
|
|
translog.pszClientHostName = m_ConnectedDomain;
|
|
translog.cbClientHostName = lstrlen(m_ConnectedDomain);
|
|
|
|
//Make sure we log the correct port number
|
|
if (IsSecure()) {
|
|
translog.dwPort = QuerySmtpInstance()->GetRemoteSmtpSecurePort();
|
|
} else {
|
|
translog.dwPort = QuerySmtpInstance()->GetRemoteSmtpPort();
|
|
}
|
|
|
|
//Copy buffers
|
|
if (pszOperation) {
|
|
lstrcpyn(szOperationBuffer, pszOperation, sizeof(szOperationBuffer)-sizeof(CHAR));
|
|
translog.pszOperation = szOperationBuffer;
|
|
translog.cbOperation = lstrlen(szOperationBuffer);
|
|
} else {
|
|
translog.pszOperation = "";
|
|
translog.cbOperation = 0;
|
|
}
|
|
|
|
if (pszTarget) {
|
|
lstrcpyn(szTargetBuffer, pszTarget, sizeof(szTargetBuffer)-sizeof(CHAR));
|
|
translog.pszTarget = szTargetBuffer;
|
|
translog.cbTarget = lstrlen(szTargetBuffer);
|
|
} else {
|
|
translog.pszTarget = "";
|
|
translog.cbTarget = 0;
|
|
}
|
|
|
|
if (pszParameters) {
|
|
lstrcpyn(szParametersBuffer, pszParameters, sizeof(szParametersBuffer)-sizeof(CHAR));
|
|
translog.pszParameters = szParametersBuffer;
|
|
} else {
|
|
translog.pszParameters = "";
|
|
}
|
|
|
|
//Detect if usage drastically changes... but don't check parameters, because
|
|
//we don't care about logging more than 1K per command
|
|
_ASSERT(sizeof(szOperationBuffer) > lstrlen(pszOperation));
|
|
_ASSERT(sizeof(szTargetBuffer) > lstrlen(pszTarget));
|
|
|
|
translog.dwBytesSent = dwBytesSent;
|
|
translog.dwBytesRecvd = dwBytesReceived;
|
|
translog.dwWin32Status = dwWin32Error;
|
|
translog.dwProtocolStatus = dwServiceSpecificStatus;
|
|
|
|
dwLog = QuerySmtpInstance()->m_Logging.LogInformation( &translog);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name:
|
|
|
|
SMTP_CONNOUT::SMTP_CONNOUT
|
|
|
|
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_CONNOUT::SMTP_CONNOUT(
|
|
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( TRUE ),
|
|
m_securityCtx(pInstance,
|
|
TCPAUTH_CLIENT| TCPAUTH_UUENCODE,
|
|
((PSMTP_SERVER_INSTANCE)pInstance)->QueryAuthentication()),
|
|
CLIENT_CONNECTION ( sClient, psockAddrRemote,
|
|
psockAddrRemote, pAtqContext,
|
|
pvInitialRequest, cbInitialData )
|
|
{
|
|
|
|
_ASSERT(pInstance != NULL);
|
|
|
|
m_cActiveThreads = 0;
|
|
m_cPendingIoCount = 0;
|
|
m_MsgOptions = 0;
|
|
m_AuthToUse = 0;
|
|
m_pInstance = pInstance;
|
|
m_UsingSSL = FALSE;
|
|
m_fCanTurn = TRUE;
|
|
m_pIMsg = NULL;
|
|
m_pIMsgRecips = NULL;
|
|
m_pISMTPConnection = NULL;
|
|
m_AdvContext = NULL;
|
|
m_pDnsRec = NULL;
|
|
m_EhloSent = FALSE;
|
|
|
|
pInstance->IncConnOutObjs();
|
|
|
|
//
|
|
// By default, we use the smallish receive buffer inherited from
|
|
// the base CLIENT_CONNECTION object and a smallish output buffer defined in
|
|
// SMTP_CONNOUT
|
|
//
|
|
m_precvBuffer = m_recvBuffer;
|
|
m_cbMaxRecvBuffer = sizeof(m_recvBuffer);
|
|
m_pOutputBuffer = m_OutputBuffer;
|
|
m_cbMaxOutputBuffer = sizeof(m_OutputBuffer);
|
|
|
|
m_OutboundContext.m_cabNativeCommand.SetBuffer(
|
|
m_NativeCommandBuffer,
|
|
SMTP_MAX_COMMAND_LENGTH);
|
|
|
|
m_pmszTurnList = NULL;
|
|
m_szCurrentTURNDomain = NULL;
|
|
m_IMsgDotStuffedFileHandle = NULL;
|
|
|
|
m_ConnectedDomain [0] = '\0';
|
|
|
|
m_pBindInterface = NULL;
|
|
|
|
m_SeoOverlapped.ThisPtr = (PVOID) this;
|
|
m_SeoOverlapped.pfnCompletion = InternetCompletion;
|
|
//initialize this error in case the connection gets
|
|
//broken early.
|
|
m_Error = ERROR_BROKEN_PIPE;
|
|
|
|
m_fNeedRelayedDSN = FALSE;
|
|
m_fHadHardError = FALSE;
|
|
m_fHadTempError = FALSE;
|
|
m_fHadSuccessfulDelivery = FALSE;
|
|
|
|
|
|
//
|
|
// Protocol Events
|
|
//
|
|
m_fNativeHandlerFired = FALSE;
|
|
m_pOutboundDispatcher = NULL;
|
|
m_pResponseDispatcher = NULL;
|
|
|
|
//
|
|
// Diagnostic Information
|
|
//
|
|
m_hrDiagnosticError = S_OK;
|
|
m_szDiagnosticVerb = NULL;
|
|
m_szDiagnosticResponse[0]= '\0';
|
|
|
|
m_szCurrentETRNDomain = NULL;
|
|
m_pszSSLVerificationName = NULL;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::~SMTP_CONNOUT (void)
|
|
|
|
Description:
|
|
|
|
Destructor for outbound connection object.
|
|
This routine checks to see if there was a
|
|
current mail object that was being processed
|
|
before this destructor was called and does
|
|
whatever is necessary to clean up its' memory.
|
|
Then it checks the mailbag and cleans up any
|
|
mail objects it finds in there.
|
|
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Returns:
|
|
|
|
none
|
|
|
|
--*/
|
|
|
|
SMTP_CONNOUT::~SMTP_CONNOUT (void)
|
|
{
|
|
PSMTP_SERVER_INSTANCE pInstance = NULL;
|
|
HRESULT hrDiagnostic = S_OK;
|
|
char * pTempBuffer = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::~SMTP_CONNOUT (void)");
|
|
|
|
//We need to call our cleanup function... so that the ATQ context will be
|
|
//freed. We do this first, because a message ack or connection ack may
|
|
//trigger DSN generation, which may take long enough to cause the context
|
|
//to time out and complete on us (causing one thread to AV).
|
|
Cleanup();
|
|
|
|
//catch all message ack call
|
|
//NK** : Need to substitute it with an HRESULT based on the actual internal error
|
|
//mikeswa - 9/11/98 - Add check recips to flags
|
|
|
|
HandleCompletedMailObj(MESSAGE_STATUS_RETRY_ALL | MESSAGE_STATUS_CHECK_RECIPS, "451 Remote host dropped connection", 0);
|
|
|
|
|
|
//if we were doing a TLS transmission that got interrupted, we need to
|
|
//destroy the AtqContext we created for reading from the mail file.
|
|
//FreeAtqFileContext();
|
|
|
|
if (m_pISMTPConnection) {
|
|
//Ack the connection
|
|
m_pISMTPConnection->AckConnection((eConnectionStatus)m_dwConnectionStatus);
|
|
|
|
if (FAILED(m_hrDiagnosticError))
|
|
{
|
|
m_pISMTPConnection->SetDiagnosticInfo(m_hrDiagnosticError,
|
|
m_szDiagnosticVerb, m_szDiagnosticResponse);
|
|
}
|
|
else if (CONNECTION_STATUS_OK != m_dwConnectionStatus)
|
|
{
|
|
//Report appropriate diagnostic information if we don't have specific failures
|
|
switch (m_dwConnectionStatus)
|
|
{
|
|
case CONNECTION_STATUS_DROPPED:
|
|
hrDiagnostic = AQUEUE_E_CONNECTION_DROPPED;
|
|
break;
|
|
case CONNECTION_STATUS_FAILED:
|
|
hrDiagnostic = AQUEUE_E_CONNECTION_FAILED;
|
|
break;
|
|
default:
|
|
hrDiagnostic = E_FAIL;
|
|
}
|
|
m_pISMTPConnection->SetDiagnosticInfo(hrDiagnostic, NULL, NULL);
|
|
}
|
|
|
|
m_pISMTPConnection->Release();
|
|
m_pISMTPConnection = NULL;
|
|
}
|
|
|
|
//If we had a TURN list free it up
|
|
if (m_pmszTurnList) {
|
|
delete m_pmszTurnList;
|
|
m_pmszTurnList = NULL;
|
|
m_szCurrentTURNDomain = NULL;
|
|
}
|
|
|
|
pInstance = (PSMTP_SERVER_INSTANCE ) InterlockedExchangePointer((PVOID *) &m_pInstance, (PVOID) NULL);
|
|
if (pInstance != NULL) {
|
|
pInstance->DecConnOutObjs();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// Protocol events: Release the dispatchers
|
|
if (m_pOutboundDispatcher)
|
|
m_pOutboundDispatcher->Release();
|
|
|
|
if (m_pResponseDispatcher)
|
|
m_pResponseDispatcher->Release();
|
|
|
|
if (m_pDnsRec) {
|
|
DeleteDnsRec(m_pDnsRec);
|
|
m_pDnsRec = NULL;
|
|
}
|
|
|
|
if (m_pszSSLVerificationName) {
|
|
delete [] m_pszSSLVerificationName;
|
|
m_pszSSLVerificationName;
|
|
}
|
|
|
|
DebugTrace((LPARAM) this,"%X was deleted", this);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DisconnectClient(DWORD dwErrorCode)
|
|
|
|
Description:
|
|
|
|
Disconnects from the remote server. It first calls
|
|
CLIENT_CONNECTION::DisconnectClient, and then shuts down any mail-file
|
|
read handles we may be pending reads on.
|
|
|
|
Arguments:
|
|
|
|
dwErrorCode -- Passed through to CLIENT_CONNECTION::Disconnect
|
|
|
|
Returns:
|
|
|
|
nothing
|
|
|
|
--*/
|
|
|
|
VOID SMTP_CONNOUT::DisconnectClient(DWORD dwErrorCode)
|
|
{
|
|
TraceFunctEnter("SMTP_CONNOUT::DisconnectClient");
|
|
|
|
if (m_DoCleanup)
|
|
CLIENT_CONNECTION::DisconnectClient();
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::HandleCompletedMailObj
|
|
|
|
|
|
Description:
|
|
|
|
This routinr gets called after the mail file
|
|
has been sent. It will either requeue the object
|
|
in the outbound queue, retry queue, BadMail,etc.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Returns:
|
|
|
|
none
|
|
|
|
--*/
|
|
void SMTP_CONNOUT::HandleCompletedMailObj(DWORD MsgStatus, char * szExtendedStatus, DWORD cbExtendedStatus)
|
|
{
|
|
MessageAck MsgAck;
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::HandleCompletedMailObj");
|
|
|
|
_ASSERT(IsValid());
|
|
|
|
if (m_pISMTPConnection) {
|
|
if (m_pIMsgRecips) {
|
|
//Uncheck all marked recipients if the connection has been dropped
|
|
if (((m_dwConnectionStatus != CONNECTION_STATUS_OK) || (szExtendedStatus[0] != SMTP_COMPLETE_SUCCESS)) &&
|
|
m_NumRcptSentSaved) {
|
|
UnMarkHandledRcpts();
|
|
}
|
|
m_pIMsgRecips->Release();
|
|
m_pIMsgRecips = NULL;
|
|
|
|
}
|
|
|
|
if (m_pIMsg) {
|
|
MsgAck.pvMsgContext = (DWORD *) m_AdvContext;
|
|
MsgAck.pIMailMsgProperties = m_pIMsg;
|
|
|
|
if ( (MsgStatus & MESSAGE_STATUS_RETRY_ALL) ||
|
|
(MsgStatus & MESSAGE_STATUS_NDR_ALL)) {
|
|
//DebugTrace((LPARAM) this,"CompObj:file %s going to %s was retryed", FileName, m_ConnectedDomain);
|
|
|
|
} else {
|
|
//DebugTrace((LPARAM) this,"CompObj:file %s going to %s was delivered", FileName, m_ConnectedDomain);
|
|
|
|
}
|
|
|
|
MsgAck.dwMsgStatus = MsgStatus;
|
|
MsgAck.dwStatusCode = 0;
|
|
|
|
//We will have an extended status string to go along with the Status code
|
|
//in case of some major failure that makes us fail the complete message
|
|
if (MsgStatus & MESSAGE_STATUS_EXTENDED_STATUS_CODES ) {
|
|
MsgAck.cbExtendedStatus = cbExtendedStatus;
|
|
MsgAck.szExtendedStatus = szExtendedStatus;
|
|
}
|
|
|
|
if (m_pBindInterface) {
|
|
m_pBindInterface->ReleaseContext();
|
|
m_pBindInterface->Release();
|
|
m_pBindInterface = NULL;
|
|
|
|
if( NULL != m_IMsgDotStuffedFileHandle )
|
|
{
|
|
ReleaseContext( m_IMsgDotStuffedFileHandle );
|
|
m_IMsgDotStuffedFileHandle = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Do Message Tracking
|
|
//
|
|
|
|
MSG_TRACK_INFO msgTrackInfo;
|
|
ZeroMemory( &msgTrackInfo, sizeof( msgTrackInfo ) );
|
|
|
|
msgTrackInfo.dwEventId = MTE_END_OUTBOUND_TRANSFER;
|
|
msgTrackInfo.pszPartnerName = m_ConnectedDomain;
|
|
if( MsgStatus & MESSAGE_STATUS_RETRY_ALL )
|
|
{
|
|
msgTrackInfo.dwRcptReportStatus = MP_STATUS_RETRY;
|
|
}
|
|
else if( MsgStatus & MESSAGE_STATUS_NDR_ALL )
|
|
{
|
|
msgTrackInfo.dwEventId = MTE_NDR_ALL;
|
|
msgTrackInfo.pszPartnerName = NULL;
|
|
msgTrackInfo.dwRcptReportStatus = MP_STATUS_ABORT_DELIVERY;
|
|
}
|
|
|
|
m_pInstance->WriteLog( &msgTrackInfo, m_pIMsg, NULL, NULL );
|
|
|
|
m_pISMTPConnection->AckMessage(&MsgAck);
|
|
m_pIMsg->Release();
|
|
m_pIMsg = NULL;
|
|
}
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::UnMarkHandledRcpts
|
|
|
|
|
|
Description:
|
|
|
|
When we send out recipients we assumptively mark the recipients as
|
|
delivered or failed based on the responses. Later if it turns out that we
|
|
could never completely send the message. we need to rset the status of
|
|
successful recipients. However, if we have a hard per-recipient error,
|
|
we should leave the error code intact (otherwise the sender may receive
|
|
a DELAY DSN with a 500-level status code).
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Returns:
|
|
|
|
none
|
|
|
|
--*/
|
|
|
|
BOOL SMTP_CONNOUT::UnMarkHandledRcpts(void)
|
|
{
|
|
DWORD i;
|
|
HRESULT hr = S_OK;
|
|
DWORD dwRecipientFlags;
|
|
DWORD dwRcptsSaved = m_NumRcptSentSaved;
|
|
|
|
//
|
|
// It is possible for this to be called after HandleCompletedMailObj (after
|
|
// a 421 response to a DATA command for example). We should bail if we
|
|
// do not have a mailmsg ptr.
|
|
//
|
|
if (!m_pIMsgRecips)
|
|
return (TRUE);
|
|
|
|
for (i = m_FirstAddressinCurrentMail; (i < m_NumRcpts) && dwRcptsSaved;i++) {
|
|
//Get to the next rcpt that we send out this time
|
|
if (m_RcptIndexList[i] != INVALID_RCPT_IDX_VALUE) {
|
|
//
|
|
// The ideal way to handle this situation is to use the
|
|
// RP_VOLATILE_FLAGS_MASK bits in the recipient flags a tmp
|
|
// storage and then "commit" the handled bit after a successful
|
|
// connection. Given how mailmsg works, this is not a problem
|
|
// - While we are processing the message... it is not possible
|
|
// for it to be saved to disk until we are done with it.
|
|
// - If we can write a property once before committing... we
|
|
// can always rewrite a property of the same size (since
|
|
// the required portion of the property stream is already
|
|
// in memory.
|
|
// I have added the ASSERT(SUCEEDED(hr)) below
|
|
// - mikeswa 9/11/98 (updated 10/05/2000)
|
|
dwRecipientFlags = 0;
|
|
hr = m_pIMsgRecips->GetDWORD(m_RcptIndexList[i], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return (FALSE);
|
|
}
|
|
|
|
//Check to see if we marked it as delivered... and unmark it if we did
|
|
if (RP_DELIVERED == (dwRecipientFlags & RP_DELIVERED)) {
|
|
dwRecipientFlags &= ~RP_DELIVERED;
|
|
|
|
hr = m_pIMsgRecips->PutDWORD(m_RcptIndexList[i], IMMPID_RP_RECIPIENT_FLAGS,dwRecipientFlags);
|
|
if (FAILED(hr)) {
|
|
//
|
|
// We need to understand how this can fail... mailmsg
|
|
// is designed so this should not happen.
|
|
//
|
|
ASSERT(FALSE && "Potential loss of recipient");
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return (FALSE);
|
|
}
|
|
}
|
|
dwRcptsSaved--;
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::InitializeObject
|
|
|
|
Description:
|
|
Initializes all member variables and pre-allocates
|
|
a mail context class
|
|
|
|
Arguments:
|
|
Options - SSL etc.
|
|
pszSSLVerificationName - Subject name to look for in server certificate
|
|
if using SSL
|
|
Returns:
|
|
|
|
TRUE if memory can be allocated.
|
|
FALSE if no memory can be allocated
|
|
--*/
|
|
BOOL SMTP_CONNOUT::InitializeObject (
|
|
DWORD Options,
|
|
LPSTR pszSSLVerificationName)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::InitializeObject");
|
|
|
|
m_szCurrentETRNDomain = NULL;
|
|
m_cbReceived = 0;
|
|
m_cbParsable = 0;
|
|
m_OutputBufferSize = 0;
|
|
m_NumRcptSent = 0;
|
|
m_FirstAddressinCurrentMail = 0;
|
|
m_NumRcptSentSaved = 0;
|
|
m_SizeOptionSize = 0;
|
|
m_Flags = 0;
|
|
m_NumFailedAddrs = 0;
|
|
m_cActiveThreads = 0;
|
|
m_cPendingIoCount = 0;
|
|
m_FileSize = 0;
|
|
|
|
m_NextAddress = 0;
|
|
m_FirstPipelinedAddress = 0;
|
|
m_First552Address = -1;
|
|
m_NextState = NULL;
|
|
m_HeloSent = FALSE;
|
|
m_EhloFailed = FALSE;
|
|
m_FirstRcpt = FALSE;
|
|
m_SendAgain = FALSE;
|
|
m_Active = TRUE;
|
|
m_HaveDataResponse = FALSE;
|
|
|
|
m_SecurePort = FALSE;
|
|
m_fNegotiatingSSL = FALSE;
|
|
|
|
m_MsgOptions = Options;
|
|
m_dwConnectionStatus = CONNECTION_STATUS_OK;
|
|
|
|
m_fUseBDAT = FALSE;
|
|
|
|
m_fNeedRelayedDSN = FALSE;
|
|
m_fHadHardError = FALSE;
|
|
m_fHadTempError = FALSE;
|
|
m_fHadSuccessfulDelivery = FALSE;
|
|
|
|
if (Options & KNOWN_AUTH_FLAGS) {
|
|
m_pInstance->LockGenCrit();
|
|
|
|
// Initialize Security Context
|
|
//
|
|
if (!m_securityCtx.SetInstanceAuthPackageNames(
|
|
m_pInstance->GetProviderPackagesCount(),
|
|
m_pInstance->GetProviderNames(),
|
|
m_pInstance->GetProviderPackages())) {
|
|
m_Error = GetLastError();
|
|
ErrorTrace((LPARAM)this, "SetInstanceAuthPackageNames FAILED <Err=%u>",
|
|
m_Error);
|
|
fRet = FALSE;
|
|
}
|
|
|
|
//
|
|
// 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 "".
|
|
//
|
|
|
|
if (fRet) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
m_pInstance->UnLockGenCrit();
|
|
}
|
|
|
|
m_pmszTurnList = NULL;
|
|
m_szCurrentTURNDomain = NULL;
|
|
|
|
m_UsingSSL = (Options & DOMAIN_INFO_USE_SSL);
|
|
m_TlsState = (Options & DOMAIN_INFO_USE_SSL) ? MUST_DO_TLS : DONT_DO_TLS;
|
|
|
|
m_TransmitTailBuffer[0] = '.';
|
|
m_TransmitTailBuffer[1] = '\r';
|
|
m_TransmitTailBuffer[2] = '\n';
|
|
|
|
m_TransmitBuffers.Head = NULL;
|
|
m_TransmitBuffers.HeadLength = 0;
|
|
m_TransmitBuffers.Tail = m_TransmitTailBuffer;
|
|
m_TransmitBuffers.TailLength = 3;
|
|
|
|
//
|
|
// Protocol events: get the response dispatcher for the session
|
|
//
|
|
m_pIEventRouter = m_pInstance->GetRouter();
|
|
if (m_pIEventRouter) {
|
|
HRESULT hr = m_pIEventRouter->GetDispatcherByClassFactory(
|
|
CLSID_CResponseDispatcher,
|
|
&g_cfResponse,
|
|
CATID_SMTP_ON_SERVER_RESPONSE,
|
|
IID_ISmtpServerResponseDispatcher,
|
|
(IUnknown **)&m_pResponseDispatcher);
|
|
if (!SUCCEEDED(hr)) {
|
|
// If we fail, we don't process protocol events
|
|
m_pResponseDispatcher = NULL;
|
|
ErrorTrace((LPARAM) this,
|
|
"Unable to get response dispatcher from router (%08x)", hr);
|
|
}
|
|
}
|
|
|
|
if (pszSSLVerificationName) {
|
|
m_pszSSLVerificationName = new char [lstrlen (pszSSLVerificationName) + 1];
|
|
if (!m_pszSSLVerificationName) {
|
|
fRet = FALSE;
|
|
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
|
|
goto Exit;
|
|
}
|
|
|
|
lstrcpy (m_pszSSLVerificationName, pszSSLVerificationName);
|
|
}
|
|
StartProcessingTimer();
|
|
|
|
Exit:
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return fRet;
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::GoToWaitForConnectResponseState(void)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::GoToWaitForConnectResponseState( void)");
|
|
|
|
SetNextState (&SMTP_CONNOUT::WaitForConnectResponse);
|
|
|
|
m_Error = NO_ERROR;
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
IncPendingIoCount();
|
|
fRet = ReadFile(QueryMRcvBuffer(), m_cbMaxRecvBuffer);
|
|
if (!fRet) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::WaitForConnectResponseState - ReadFile failed with error %d", m_Error);
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
SetLastError(m_Error);
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::GetNextTURNConnection(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::GetNextTURNConnection( void)");
|
|
//We are on a TURNed connection and need to start the queue for next
|
|
//domain in the turn list if it exists
|
|
//Before getting the next connection release the current one.
|
|
//
|
|
if (m_pISMTPConnection) {
|
|
//Ack the last connection
|
|
m_dwConnectionStatus = CONNECTION_STATUS_OK;
|
|
m_pISMTPConnection->AckConnection((eConnectionStatus)m_dwConnectionStatus);
|
|
m_pISMTPConnection->Release();
|
|
m_pISMTPConnection = NULL;
|
|
}
|
|
|
|
m_szCurrentTURNDomain = m_pmszTurnList->Next( m_szCurrentTURNDomain );
|
|
while (m_szCurrentTURNDomain && !QuerySmtpInstance()->IsShuttingDown()) {
|
|
//We have another domain to start
|
|
hr = QuerySmtpInstance()->GetConnManPtr()->GetNamedConnection(lstrlen(m_szCurrentTURNDomain), (CHAR*)m_szCurrentTURNDomain, &m_pISMTPConnection);
|
|
if (FAILED(hr)) {
|
|
//Something bad happened on this call
|
|
ErrorTrace((LPARAM) this, "StartSession - SMTP_ERROR_PROCESSING_CODE, GetNamedConnection failed %d",hr);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
//If the link corresponding to this domain does not exist in AQ, we get a NULL
|
|
//ISMTPConnection at this point
|
|
if (m_pISMTPConnection)
|
|
break;
|
|
else {
|
|
m_szCurrentTURNDomain = m_pmszTurnList->Next( m_szCurrentTURNDomain );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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_CONNOUT::StartSession( void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::StartSession( void)");
|
|
|
|
_ASSERT(IsValid());
|
|
|
|
//We do not do s restart if the connection is a tunr connection
|
|
if (!m_pmszTurnList || !m_szCurrentTURNDomain) {
|
|
if (m_pDnsRec->pMailMsgObj) {
|
|
fRet = ReStartSession();
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return fRet;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We are either not doing SSL or are done establishing an SSL session.
|
|
// Lets do the real work of starting a session with a remote SMTP server.
|
|
//
|
|
|
|
m_IMsgFileHandle = NULL;
|
|
m_IMsgDotStuffedFileHandle = NULL;
|
|
|
|
//get the next object to send
|
|
//This is in loop because - we might have to pickup a new connection in case
|
|
//we are handling a TURN list
|
|
while (1) {
|
|
// we can't call into GetNextMessage if we are on a TURN-only
|
|
// connection. if we did and a message queued up between the
|
|
// last time we were in StartSession and now then we would
|
|
// get back into the waitforconnect state, which would be really
|
|
// bad. so if we see the m_Flags set to TURN_ONLY_OPTION then we
|
|
// know that this is an empty TURN and we just pretend that there
|
|
// is no message to pick up.
|
|
if (!(m_Flags & TURN_ONLY_OPTION)) {
|
|
hr = m_pISMTPConnection->GetNextMessage(&m_pIMsg, (DWORD **) &m_AdvContext, &m_NumRcpts, &m_RcptIndexList);
|
|
} else {
|
|
m_pIMsg = NULL;
|
|
hr = HRESULT_FROM_WIN32(ERROR_EMPTY);
|
|
}
|
|
if(FAILED(hr) || (m_pIMsg == NULL))
|
|
{
|
|
m_fCanTurn = FALSE;
|
|
|
|
if (m_pmszTurnList && m_szCurrentTURNDomain) {
|
|
//We have valid TURN list - Try and get the connetion for next domain to TURN
|
|
if (GetNextTURNConnection()) {
|
|
//We loop back if we got a valid connection. Otherwise we drop thru
|
|
if (m_pISMTPConnection)
|
|
continue;
|
|
} else { //some error happened
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (m_MsgOptions & DOMAIN_INFO_SEND_TURN) {
|
|
if (m_HeloSent || m_EhloSent) {
|
|
// we will fall into this if we have already sent
|
|
// the helo
|
|
FormatSmtpMessage(FSM_LOG_ALL, "TURN\r\n");
|
|
|
|
m_cbReceived = 0;
|
|
m_cbParsable = 0;
|
|
m_pmszTurnList = NULL;
|
|
m_szCurrentTURNDomain = NULL;
|
|
|
|
SendSmtpResponse();
|
|
SetNextState (&SMTP_CONNOUT::DoTURNCommand);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
} else {
|
|
// we fall into this if we are sending TURN on an
|
|
// otherwise empty connection. At this point we have
|
|
// not yet sent EHLO, so it is not safe to send TURN.
|
|
m_Flags |= TURN_ONLY_OPTION;
|
|
return GoToWaitForConnectResponseState();
|
|
}
|
|
} else if ((m_MsgOptions & DOMAIN_INFO_SEND_ETRN) &&
|
|
(m_NextState == NULL) &&
|
|
!IsOptionSet(ETRN_SENT)) {
|
|
m_Flags |= ETRN_ONLY_OPTION;
|
|
return GoToWaitForConnectResponseState();
|
|
} else if (!(m_EhloSent)) {
|
|
// This is an empty connection
|
|
m_MsgOptions |= EMPTY_CONNECTION_OPTION;
|
|
return GoToWaitForConnectResponseState();
|
|
} else {
|
|
// 1/11/99 - MikeSwa
|
|
//There just happened to be no mail at this time. Could
|
|
//have been serviced by another connection, or just link
|
|
//state detection
|
|
if (HRESULT_FROM_WIN32(ERROR_EMPTY) == hr)
|
|
SetLastError(ERROR_EMPTY); //AQueue does not setlast error
|
|
else
|
|
{
|
|
SetDiagnosticInfo(hr, NULL, NULL);
|
|
}
|
|
|
|
DebugTrace((LPARAM) this,"Mailbag empty - returning FALSE");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The actual file may have been deleted from the queue. If so, we
|
|
// need to ack the message and get the next one.
|
|
//
|
|
|
|
hr = m_pIMsg->QueryInterface(IID_IMailMsgBind, (void **)&m_pBindInterface);
|
|
if (FAILED(hr))
|
|
{
|
|
MessageAck MsgAck;
|
|
|
|
ErrorTrace((LPARAM)this, "Unable to Queryinterface message, going on to next one.");
|
|
|
|
m_IMsgFileHandle = NULL;
|
|
|
|
MsgAck.pvMsgContext = (DWORD *) m_AdvContext;
|
|
MsgAck.pIMailMsgProperties = m_pIMsg;
|
|
MsgAck.dwMsgStatus = MESSAGE_STATUS_RETRY;
|
|
MsgAck.dwStatusCode = 0;
|
|
|
|
m_pISMTPConnection->AckMessage(&MsgAck);
|
|
SetDiagnosticInfo(AQUEUE_E_BIND_ERROR, NULL, NULL);
|
|
|
|
m_pIMsg->Release();
|
|
m_pIMsg = NULL;
|
|
continue;
|
|
}
|
|
|
|
hr = m_pBindInterface->GetBinding(&m_IMsgFileHandle, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
MSG_TRACK_INFO msgTrackInfo;
|
|
ZeroMemory( &msgTrackInfo, sizeof( msgTrackInfo ) );
|
|
msgTrackInfo.pszServerName = g_ComputerName;
|
|
msgTrackInfo.dwEventId = MTE_BEGIN_OUTBOUND_TRANSFER;
|
|
m_pInstance->WriteLog( &msgTrackInfo, m_pIMsg, NULL, NULL );
|
|
break;
|
|
}
|
|
else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
|
|
{
|
|
|
|
MessageAck MsgAck;
|
|
|
|
DebugTrace(NULL,
|
|
"Message from queue has been deleted - ignoring it");
|
|
|
|
m_pBindInterface->Release();
|
|
m_IMsgFileHandle = NULL;
|
|
|
|
MsgAck.pvMsgContext = (DWORD *) m_AdvContext;
|
|
MsgAck.pIMailMsgProperties = m_pIMsg;
|
|
MsgAck.dwMsgStatus = MESSAGE_STATUS_ALL_DELIVERED;
|
|
MsgAck.dwStatusCode = 0;
|
|
|
|
m_pISMTPConnection->AckMessage(&MsgAck);
|
|
m_pIMsg->Release();
|
|
m_pIMsg = NULL;
|
|
|
|
}
|
|
else
|
|
{
|
|
ASSERT(FAILED(hr));
|
|
MessageAck MsgAck;
|
|
|
|
ErrorTrace((LPARAM)this, "Unable to Bind message, going on to next one.");
|
|
|
|
m_pBindInterface->Release();
|
|
m_IMsgFileHandle = NULL;
|
|
|
|
MsgAck.pvMsgContext = (DWORD *) m_AdvContext;
|
|
MsgAck.pIMailMsgProperties = m_pIMsg;
|
|
MsgAck.dwMsgStatus = MESSAGE_STATUS_RETRY;
|
|
MsgAck.dwStatusCode = 0;
|
|
|
|
m_pISMTPConnection->AckMessage(&MsgAck);
|
|
SetDiagnosticInfo(AQUEUE_E_BIND_ERROR, NULL, NULL);
|
|
|
|
m_pIMsg->Release();
|
|
m_pIMsg = NULL;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bump both the remote and total recipient counters
|
|
ADD_COUNTER (QuerySmtpInstance(), NumRcptsRecvdRemote, m_NumRcpts);
|
|
ADD_COUNTER (QuerySmtpInstance(), NumRcptsRecvd, m_NumRcpts);
|
|
|
|
hr = m_pIMsg->QueryInterface(IID_IMailMsgRecipients, (void **) &m_pIMsgRecips);
|
|
if (FAILED(hr)) {
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
m_FirstPipelinedAddress = 0;
|
|
|
|
//Nk** I moved this here from PerRcptEvent
|
|
m_NextAddress = 0;
|
|
|
|
|
|
//if m_NextState is NULL, this is the
|
|
//first time this routine has been called
|
|
//as a result of a connection. If m_NextState
|
|
//is not NULL, this means we just finished
|
|
//sending mail and we are about to send another
|
|
//mail message
|
|
if (m_NextState == NULL) {
|
|
m_Error = NO_ERROR;
|
|
DebugTrace((LPARAM) this,"start session called because of new connection");
|
|
|
|
m_FirstPipelinedAddress = 0;
|
|
|
|
SetNextState (&SMTP_CONNOUT::WaitForConnectResponse);
|
|
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
IncPendingIoCount();
|
|
|
|
fRet = ReadFile(QueryMRcvBuffer(), m_cbMaxRecvBuffer);
|
|
if (!fRet) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::StartSession - ReadFile failed with error %d", m_Error);
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
SetLastError(m_Error);
|
|
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
}
|
|
} else {
|
|
DebugTrace((LPARAM) this,"start session called because item was found in mailbag");
|
|
|
|
m_cbReceived = 0;
|
|
m_cbParsable = 0;
|
|
m_OutputBufferSize = 0;
|
|
m_Error = NO_ERROR;
|
|
m_NumRcptSent = 0;
|
|
m_FirstAddressinCurrentMail = 0;
|
|
m_NumRcptSentSaved = 0;
|
|
m_NumFailedAddrs = 0;
|
|
m_SendAgain = FALSE;
|
|
m_HaveDataResponse = FALSE;
|
|
m_FirstPipelinedAddress = 0;
|
|
|
|
m_FirstRcpt = FALSE;
|
|
|
|
m_TransmitTailBuffer[0] = '.';
|
|
m_TransmitTailBuffer[1] = '\r';
|
|
m_TransmitTailBuffer[2] = '\n';
|
|
|
|
m_TransmitBuffers.Head = NULL;
|
|
m_TransmitBuffers.HeadLength = 0;
|
|
m_TransmitBuffers.Tail = m_TransmitTailBuffer;
|
|
m_TransmitBuffers.TailLength = 3;
|
|
|
|
//send a reset
|
|
m_fNativeHandlerFired = FALSE;
|
|
m_RsetReasonCode = BETWEEN_MSG;
|
|
fRet = DoRSETCommand(NULL, 0, 0);
|
|
if (!fRet) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this,"reset command failed in StartSession");
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
// WaitForRSETResponse is smart and will raise the message
|
|
// start event
|
|
SetNextState (&SMTP_CONNOUT::WaitForRSETResponse);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return fRet;
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::DecPendingIoCountEx(void)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::DecPendingIoCountEx");
|
|
|
|
_ASSERT(IsValid());
|
|
|
|
if (InterlockedDecrement( &m_cPendingIoCount ) == 0) {
|
|
DebugTrace((LPARAM) this, "DecPendingIoCountEx deleting Smtp_Connout");
|
|
fRet = TRUE;
|
|
DisconnectClient();
|
|
QuerySmtpInstance()->RemoveOutboundConnection(this);
|
|
delete this;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return fRet;
|
|
}
|
|
|
|
|
|
BOOL SMTP_CONNOUT::ConnectToNextIpAddress(void)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
REMOTE_QUEUE * pRemoteQ = NULL;
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
ISMTPConnection * pISMTPConnection = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::ConnectToNextIpAddress( void)");
|
|
|
|
if (m_pmszTurnList && m_szCurrentTURNDomain) {
|
|
ErrorTrace((LPARAM) this, "Failing ConnectToNextIpAddress because of TURN");
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!m_fCanTurn) {
|
|
ErrorTrace((LPARAM) this, "Failing ConnectToNextIpAddress because of m_fCanTurn");
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pDnsRec == NULL) {
|
|
ErrorTrace((LPARAM) this, "Failing ConnectToNextIpAddress becuase m_pDnsRec is NULL");
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pDnsRec->StartRecord > m_pDnsRec->NumRecords) {
|
|
ErrorTrace((LPARAM) this, "Failing ConnectToNextIpAddress because StartRecord > NumRecords");
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pDnsRec->StartRecord == m_pDnsRec->NumRecords) {
|
|
if (IsListEmpty(&m_pDnsRec->DnsArray[m_pDnsRec->NumRecords - 1]->IpListHead)) {
|
|
ErrorTrace((LPARAM) this, "Failing ConnectToNextIpAddress because list is empty");
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
m_pDnsRec->StartRecord = m_pDnsRec->NumRecords - 1;
|
|
} else if (IsListEmpty(&m_pDnsRec->DnsArray[m_pDnsRec->StartRecord]->IpListHead)) {
|
|
m_pDnsRec->StartRecord++;
|
|
|
|
if (m_pDnsRec->StartRecord > m_pDnsRec->NumRecords) {
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pDnsRec->StartRecord == m_pDnsRec->NumRecords) {
|
|
if (IsListEmpty(&m_pDnsRec->DnsArray[m_pDnsRec->NumRecords - 1]->IpListHead)) {
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
m_pDnsRec->StartRecord = m_pDnsRec->NumRecords - 1;
|
|
}
|
|
|
|
}
|
|
|
|
if (m_NumRcptSentSaved) {
|
|
UnMarkHandledRcpts();
|
|
}
|
|
|
|
m_pDnsRec->pMailMsgObj = (PVOID) m_pIMsg;
|
|
m_pDnsRec->pAdvQContext = m_AdvContext;
|
|
m_pDnsRec->pRcptIdxList = (PVOID) m_RcptIndexList;
|
|
m_pDnsRec->dwNumRcpts = m_NumRcpts;
|
|
|
|
pDnsRec = m_pDnsRec;
|
|
m_pDnsRec = NULL;
|
|
|
|
pISMTPConnection = m_pISMTPConnection;
|
|
|
|
if (m_pIMsgRecips) {
|
|
m_pIMsgRecips->Release();
|
|
m_pIMsgRecips = NULL;
|
|
}
|
|
|
|
if (m_pBindInterface) {
|
|
m_pBindInterface->ReleaseContext();
|
|
m_pBindInterface->Release();
|
|
m_pBindInterface = NULL;
|
|
|
|
if( NULL != m_IMsgDotStuffedFileHandle )
|
|
{
|
|
ReleaseContext( m_IMsgDotStuffedFileHandle );
|
|
m_IMsgDotStuffedFileHandle = NULL;
|
|
}
|
|
}
|
|
|
|
pRemoteQ = (REMOTE_QUEUE *) QuerySmtpInstance()->QueryRemoteQObj();
|
|
fRet = pRemoteQ->ReStartAsyncConnections(
|
|
pDnsRec,
|
|
pISMTPConnection,
|
|
m_MsgOptions,
|
|
m_pszSSLVerificationName);
|
|
if (fRet) {
|
|
m_pISMTPConnection = NULL;
|
|
ErrorTrace((LPARAM)this, "RestartAsyncConnections failed.");
|
|
|
|
//close the socket
|
|
DisconnectClient();
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return fRet;
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::ReStartSession(void)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::ReStartSession( void)");
|
|
|
|
DebugTrace((LPARAM) this,"restart session called because of new connection");
|
|
|
|
m_cbReceived = 0;
|
|
m_cbParsable = 0;
|
|
m_OutputBufferSize = 0;
|
|
m_Error = NO_ERROR;
|
|
m_NumRcptSent = 0;
|
|
m_NumRcptSentSaved = 0;
|
|
m_NumFailedAddrs = 0;
|
|
m_SendAgain = FALSE;
|
|
m_HaveDataResponse = FALSE;
|
|
m_FirstPipelinedAddress = 0;
|
|
|
|
m_FirstRcpt = FALSE;
|
|
|
|
m_TransmitTailBuffer[0] = '.';
|
|
m_TransmitTailBuffer[1] = '\r';
|
|
m_TransmitTailBuffer[2] = '\n';
|
|
|
|
m_TransmitBuffers.Head = NULL;
|
|
m_TransmitBuffers.HeadLength = 0;
|
|
m_TransmitBuffers.Tail = m_TransmitTailBuffer;
|
|
m_TransmitBuffers.TailLength = 3;
|
|
|
|
SetNextState (&SMTP_CONNOUT::WaitForConnectResponse);
|
|
|
|
m_pIMsg = (IMailMsgProperties *) m_pDnsRec->pMailMsgObj;
|
|
m_AdvContext = m_pDnsRec->pAdvQContext;
|
|
m_RcptIndexList = (DWORD *) m_pDnsRec->pRcptIdxList;
|
|
m_NumRcpts = m_pDnsRec->dwNumRcpts;
|
|
|
|
m_pDnsRec->pMailMsgObj = NULL;
|
|
m_pDnsRec->pAdvQContext = NULL;
|
|
m_pDnsRec->pRcptIdxList = NULL;
|
|
m_pDnsRec->dwNumRcpts = 0;
|
|
|
|
// Bump both the remote and total recipient counters
|
|
ADD_COUNTER (QuerySmtpInstance(), NumRcptsRecvdRemote, m_NumRcpts);
|
|
ADD_COUNTER (QuerySmtpInstance(), NumRcptsRecvd, m_NumRcpts);
|
|
|
|
hr = m_pIMsg->QueryInterface(IID_IMailMsgRecipients, (void **) &m_pIMsgRecips);
|
|
if (FAILED(hr)) {
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
hr = m_pIMsg->QueryInterface(IID_IMailMsgBind, (void **)&m_pBindInterface);
|
|
if (FAILED(hr)) {
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
hr = m_pBindInterface->GetBinding(&m_IMsgFileHandle, NULL);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD fFoundEmbeddedCrlfDot = FALSE;
|
|
DWORD fScanned = FALSE;
|
|
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
IncPendingIoCount();
|
|
fRet = ReadFile(QueryMRcvBuffer(), m_cbMaxRecvBuffer);
|
|
if (!fRet) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::StartSession - ReadFile failed with error %d", m_Error);
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
SetLastError(m_Error);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::CreateSmtpConnection
|
|
|
|
Description:
|
|
This is the static member function than is the only
|
|
entity that is allowed to create an SMTP_CONNOUT
|
|
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.
|
|
fUseSSL Indiates whether the connection is to use SSL
|
|
|
|
|
|
Returns:
|
|
|
|
A pointer to an SMTP_CONNOUT class or NULL
|
|
--*/
|
|
SMTP_CONNOUT * SMTP_CONNOUT::CreateSmtpConnection (
|
|
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 pTurnList/* = NULL*/ ,
|
|
IN DWORD cbInitialData /* = 0 */,
|
|
IN DWORD Options /* = 0 */,
|
|
IN LPSTR pszSSLVerificationName)
|
|
{
|
|
SMTP_CONNOUT * pSmtpObj;
|
|
|
|
TraceFunctEnter("SMTP_CONNOUT::CreateSmtpConnection");
|
|
|
|
pSmtpObj = new SMTP_CONNOUT (pInstance, sClient, psockAddrRemote, psockAddrLocal, pAtqContext,
|
|
pTurnList, cbInitialData);
|
|
if (pSmtpObj == NULL) {
|
|
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
|
|
FatalTrace(NULL, "new SMTP_CONNOUT failed (err=%d)", GetLastError());
|
|
TraceFunctLeave();
|
|
return NULL;
|
|
}
|
|
|
|
if (!pSmtpObj->InitializeObject(Options, pszSSLVerificationName)) {
|
|
ErrorTrace(NULL, "InitializeObject failed (err=%d)", GetLastError());
|
|
delete pSmtpObj;
|
|
TraceFunctLeave();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
if (pTurnList) {
|
|
//Set the TURN domainlist
|
|
pSmtpObj->SetTurnList((PTURN_DOMAIN_LIST)pTurnList);
|
|
}
|
|
|
|
TraceFunctLeave();
|
|
return pSmtpObj;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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 is the string was sent. False otherwise
|
|
--*/
|
|
BOOL SMTP_CONNOUT::SendSmtpResponse(BOOL SyncSend)
|
|
{
|
|
BOOL RetStatus = TRUE;
|
|
DWORD cbMessage = m_OutputBufferSize;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::SendSmtpResponse");
|
|
|
|
//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) {
|
|
char *Buffer = &m_pOutputBuffer[m_encryptCtx.GetSealHeaderSize()];
|
|
|
|
RetStatus = m_encryptCtx.SealMessage(
|
|
(UCHAR *) Buffer,
|
|
m_OutputBufferSize,
|
|
(UCHAR *) m_pOutputBuffer,
|
|
&cbMessage);
|
|
if (!RetStatus)
|
|
{
|
|
ErrorTrace ((LPARAM)this, "Sealmessage failed");
|
|
SetLastError(AQUEUE_E_SSL_ERROR);
|
|
}
|
|
}
|
|
|
|
if (RetStatus) {
|
|
RetStatus = CLIENT_CONNECTION::WriteFile(m_pOutputBuffer, cbMessage);
|
|
}
|
|
|
|
if (RetStatus) {
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentTotal, m_OutputBufferSize);
|
|
} else {
|
|
DebugTrace((LPARAM) this, "WriteFile failed with error %d", GetLastError());
|
|
}
|
|
|
|
m_OutputBufferSize = 0;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
|
|
return ( RetStatus );
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::FormatSmtpMessage( IN const char * Format, ...)
|
|
|
|
Description:
|
|
This function operates likes sprintf, printf, etc. It
|
|
just places it's data in the output buffer.
|
|
|
|
Arguments:
|
|
Format - Data to place in the buffer
|
|
|
|
Returns:
|
|
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::FormatSmtpMessage( FORMAT_SMTP_MESSAGE_LOGLEVEL eLogLevel, 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);
|
|
|
|
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, Format, 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);
|
|
|
|
// log this transaction
|
|
ProtocolLogCommand(Buffer, BytesWritten, QueryClientHostName(), eLogLevel);
|
|
|
|
m_OutputBufferSize += (DWORD) BytesWritten;
|
|
|
|
//m_OutputBufferSize += vsprintf (&m_OutputBuffer[m_OutputBufferSize], Format, arglist);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::FormatBinaryBlob(IN PBYTE pbBlob, IN DWORD cbSize)
|
|
|
|
Description:
|
|
Places pbBlob of size cbSize into buffer
|
|
|
|
Arguments:
|
|
pbBlob - blob to place in the buffer
|
|
cbSize - blob size
|
|
|
|
Returns:
|
|
BOOL
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::FormatBinaryBlob( IN PBYTE pbBlob, IN DWORD cbSize)
|
|
{
|
|
char *Buffer;
|
|
DWORD AvailableBytes;
|
|
|
|
TraceQuietEnter( "SMTP_CONNOUT::FormatBinaryBlob");
|
|
|
|
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;
|
|
|
|
while ( AvailableBytes < cbSize) {
|
|
memcpy( Buffer, pbBlob, AvailableBytes);
|
|
pbBlob += AvailableBytes;
|
|
cbSize -= AvailableBytes;
|
|
m_OutputBufferSize += AvailableBytes;
|
|
SendSmtpResponse();
|
|
_ASSERT ( m_OutputBufferSize == 0);
|
|
Buffer = &m_pOutputBuffer[ HeaderOffset];
|
|
AvailableBytes = m_cbMaxOutputBuffer - SealOverhead;
|
|
}
|
|
|
|
memcpy( Buffer, pbBlob, cbSize);
|
|
m_OutputBufferSize += cbSize;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::ProcessWriteIO
|
|
|
|
Description:
|
|
Handles an async write completion event.
|
|
|
|
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 object should continue to survive
|
|
FALSE if the object should be deleted
|
|
--*/
|
|
BOOL SMTP_CONNOUT::ProcessWriteIO ( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
|
|
{
|
|
CBuffer* pBuffer;
|
|
|
|
TraceQuietEnter("SMTP_CONNOUT::ProcessWriteIO");
|
|
|
|
_ASSERT(IsValid());
|
|
_ASSERT(lpo);
|
|
pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
|
|
|
|
|
|
//
|
|
// check for partial completions or errors
|
|
//
|
|
if ( pBuffer->GetSize() != InputBufferLen || dwCompletionStatus != NO_ERROR ) {
|
|
ErrorTrace( (LPARAM)this,
|
|
"WriteFile error: %d, bytes %d, expected: %d, lpo: 0x%08X",
|
|
dwCompletionStatus,
|
|
InputBufferLen,
|
|
pBuffer->GetSize(),
|
|
lpo );
|
|
|
|
m_Error = dwCompletionStatus;
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(dwCompletionStatus), NULL, NULL);
|
|
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
return ( FALSE );
|
|
} else {
|
|
DebugTrace( (LPARAM)this,
|
|
"WriteFile complete. bytes %d, lpo: 0x%08X",
|
|
InputBufferLen, lpo );
|
|
}
|
|
|
|
//
|
|
// free up IO buffer
|
|
//
|
|
delete pBuffer;
|
|
|
|
//
|
|
// increment only after write completes
|
|
//
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentMsg, InputBufferLen);
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentTotal, InputBufferLen);
|
|
|
|
DebugTrace( (LPARAM)this, "m_bComplete: %s",
|
|
m_bComplete ? "TRUE" : "FALSE" );
|
|
|
|
return ( TRUE );
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::ProcessTransmitFileIO
|
|
|
|
Description:
|
|
processes the return from TransmitFile.
|
|
Right not it just posts a read.
|
|
|
|
Arguments:
|
|
|
|
Returns:
|
|
|
|
TRUE
|
|
--*/
|
|
|
|
BOOL SMTP_CONNOUT::ProcessTransmitFileIO ( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::ProcessTransmitFileIO");
|
|
|
|
_ASSERT(IsValid());
|
|
|
|
//we need to set this outside of the if statement,
|
|
//because we will always have a read pended
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
|
|
if (dwCompletionStatus != NO_ERROR) {
|
|
m_Error = dwCompletionStatus;
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DebugTrace((LPARAM) this, "TranmitFile in ProcessTransmitFileIO failed with error %d !!!!", dwCompletionStatus);
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
TraceFunctLeave();
|
|
return FALSE;
|
|
}
|
|
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentMsg, InputBufferLen);
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesSentTotal, InputBufferLen);
|
|
|
|
//pend an IO to pickup the "250 XXXX queued for delivery response"
|
|
IncPendingIoCount();
|
|
fRet = ReadFile(QueryMRcvBuffer(), m_cbMaxRecvBuffer);
|
|
if (!fRet) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "ReadFile in ProcessTransmitFileIO failed with error %d !!!!", m_Error);
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
}
|
|
|
|
TraceFunctLeave();
|
|
return fRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::WaitForConnectResponse
|
|
|
|
Description:
|
|
This function gets called when the SMTP
|
|
server sends it's opening response
|
|
|
|
Arguments:
|
|
InputLine - Buffer containing opening response
|
|
ParameterSize - Size of opening response
|
|
|
|
Returns:
|
|
|
|
TRUE if Object is not to be destroyed
|
|
FALSE if Object is to be destroyed
|
|
--*/
|
|
BOOL SMTP_CONNOUT::WaitForConnectResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
char * pszSearch = NULL;
|
|
DWORD IntermediateSize = 0;
|
|
BOOL IsNextLine;
|
|
DWORD Error;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::WaitForConnectResponse");
|
|
|
|
//get rid of all continuation lines
|
|
while ((pszSearch = IsLineComplete(InputLine, ParameterSize))) {
|
|
*pszSearch = '\0';
|
|
|
|
//check to see if there is a continuation line
|
|
IsNextLine = (InputLine[3] == '-');
|
|
|
|
//calculate the length of the line, with the CRLF
|
|
IntermediateSize = (DWORD)((pszSearch - InputLine) + 2);
|
|
ShrinkBuffer(
|
|
pszSearch + 2,
|
|
ParameterSize - IntermediateSize + UndecryptedTailSize);
|
|
ParameterSize -= IntermediateSize;
|
|
}
|
|
|
|
//If ParameterSize is > 0 but pszSearch == NULL, this means
|
|
//there is data in the buffer, but it does not have a CRLF
|
|
//to delimit it, therefore, we need more data to continue.
|
|
//set m_cbReceived equal to where in our input buffer we
|
|
//should pend another read and then return TRUE to pend
|
|
//that read.
|
|
|
|
if (ParameterSize != 0) {
|
|
//if we need more data, move the remaining data to the
|
|
//front of the buffer
|
|
|
|
MoveMemory(
|
|
(void *)QueryMRcvBuffer(),
|
|
InputLine,
|
|
ParameterSize + UndecryptedTailSize);
|
|
m_cbParsable = ParameterSize;
|
|
m_cbReceived = ParameterSize + UndecryptedTailSize;
|
|
return (TRUE);
|
|
} else if (IsNextLine) {
|
|
m_cbParsable = 0;
|
|
m_cbReceived = UndecryptedTailSize;
|
|
return (TRUE);
|
|
} else {
|
|
BOOL fResult = TRUE;
|
|
|
|
//we got a line that is not a continuation line.
|
|
// Process the connect response
|
|
switch (InputLine [0]) {
|
|
case SMTP_COMPLETE_FAILURE:
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, NULL, NULL);
|
|
DisconnectClient();
|
|
InputLine [3] = '\0';
|
|
Error = atoi (InputLine);
|
|
InputLine [3] = ' ';
|
|
SaveToErrorFile(InputLine, ParameterSize);
|
|
SaveToErrorFile("\r\n", 2);
|
|
fResult = FALSE;
|
|
break;
|
|
|
|
case SMTP_COMPLETE_SUCCESS: {
|
|
//If the domain has been specified to use only HELO then we
|
|
//fake it such that EHLO has been already sentand failed
|
|
if (m_MsgOptions & DOMAIN_INFO_USE_HELO )
|
|
m_EhloFailed = TRUE;
|
|
|
|
// copy the domain name from the ehlo banner
|
|
strncpy(m_ConnectedDomain, &InputLine[4], sizeof(m_ConnectedDomain)-1);
|
|
// trunc at the first space
|
|
char *pszSpace = strchr(m_ConnectedDomain, ' ');
|
|
if (pszSpace) *pszSpace = 0;
|
|
|
|
fResult = DoSessionStartEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
DebugTrace( (LPARAM) this,
|
|
"SMTP_CONNOUT::WaitForConnectResponse executing quit command err = %c%c%c",
|
|
InputLine [0],
|
|
InputLine [1],
|
|
InputLine [2]);
|
|
fResult = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
break;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fResult;
|
|
}
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::ProcessReadIO
|
|
|
|
Description:
|
|
This function gets a buffer from ATQ, parses the buffer to
|
|
find out what command the client sent, then executes that
|
|
command.
|
|
|
|
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_CONNOUT::ProcessReadIO ( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
char * InputLine = NULL;
|
|
char * pszSearch = NULL;
|
|
DWORD IntermediateSize = 0;
|
|
DWORD UndecryptedTailSize = 0;
|
|
PMFI PreviousState = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::ProcessReadIO");
|
|
|
|
//make sure the next state is not NULL
|
|
_ASSERT(m_NextState != NULL || m_fNegotiatingSSL);
|
|
_ASSERT(IsValid());
|
|
|
|
//get a pointer to our buffer
|
|
InputLine = (char *) QueryMRcvBuffer();
|
|
|
|
//add up the number of bytes we received thus far
|
|
m_cbReceived += InputBufferLen;
|
|
|
|
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesRcvdTotal, InputBufferLen);
|
|
|
|
//if we are in the middle of negotiating a SSL session, handle it now.
|
|
if (m_fNegotiatingSSL) {
|
|
|
|
fReturn = DoSSLNegotiation(QueryMRcvBuffer(),InputBufferLen, 0);
|
|
|
|
if (!fReturn) {
|
|
m_Error = GetLastError();
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
}
|
|
|
|
return ( fReturn );
|
|
}
|
|
|
|
//if we are using the secure port, decrypt the input buffer now.
|
|
if (m_SecurePort) {
|
|
|
|
fReturn = DecryptInputBuffer();
|
|
|
|
if (!fReturn) {
|
|
m_Error = GetLastError();
|
|
SetDiagnosticInfo(AQUEUE_E_SSL_ERROR, NULL, NULL);
|
|
return ( fReturn );
|
|
}
|
|
} else {
|
|
m_cbParsable = m_cbReceived;
|
|
}
|
|
|
|
|
|
//we only process lines that have CRLFs at the end, so if
|
|
//we don't find the CRLF pair, pend another read. Note
|
|
//that we start at the end of the buffer looking for the
|
|
//CRLF pair. We just need to know if atleast one line
|
|
//has a CRLF to continue.
|
|
if ((pszSearch = IsLineCompleteBW(InputLine,m_cbParsable, m_cbMaxRecvBuffer)) == NULL) {
|
|
if (m_cbReceived >= m_cbMaxRecvBuffer)
|
|
m_cbReceived = 0;
|
|
|
|
IncPendingIoCount();
|
|
fReturn = ReadFile(QueryMRcvBuffer() + m_cbReceived, m_cbMaxRecvBuffer - m_cbReceived);
|
|
if (!fReturn) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessReadIO - ReadFile # 1 failed with error %d", m_Error);
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fReturn;
|
|
}
|
|
|
|
//save the number of bytes that we received,
|
|
//so we can pass it to the function call below.
|
|
//we set m_cbReceived = 0, because other functions
|
|
//will set it the offset in the buffer where we
|
|
//should pend the next read.
|
|
IntermediateSize = m_cbParsable;
|
|
UndecryptedTailSize = m_cbReceived - m_cbParsable;
|
|
m_cbParsable = 0;
|
|
m_cbReceived = 0;
|
|
|
|
//save the previous state
|
|
PreviousState = m_NextState;
|
|
|
|
ProtocolLogResponse(InputLine, IntermediateSize, QueryClientHostName());
|
|
|
|
//execute the next state
|
|
fReturn = (this->*m_NextState)(InputLine, IntermediateSize, UndecryptedTailSize);
|
|
if (fReturn) {
|
|
//if we are in STARTTLS state, don't pend a read since
|
|
//DoSSLNegotiation would have pended a read
|
|
if ((m_NextState == &SMTP_CONNOUT::DoSTARTTLSCommand) &&
|
|
(m_TlsState == SSL_NEG)) {
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessReadIO - leaving because we are in middle of SSL negotiation");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fReturn;
|
|
}
|
|
|
|
//do't pend a read if the previous state was
|
|
//DoDataCommandEx. We want either the transmitfile
|
|
//or the read to fail. Not both. Later, we will fix
|
|
//it right for both to complete concurrently.
|
|
if (PreviousState == &SMTP_CONNOUT::DoDATACommandEx) {
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessReadIO - leaving because we did a transmitfile");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fReturn;
|
|
} else if (m_fUseBDAT) {
|
|
//We also don't want to pend a read if we did BDAT processing
|
|
//It is a special case, because of the fact that DoBDATCommand synchronously
|
|
//calls DoDATACommandEx without pending a read. So we never come thru here and get
|
|
//chance to set PreviousState = DoDATACommandEx
|
|
//So I have to hack it
|
|
|
|
if ((m_NextState == &SMTP_CONNOUT::DoContentResponse) ||
|
|
(m_SendAgain && (m_NextState == &SMTP_CONNOUT::DoMessageStartEvent))) {
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessReadIO - leaving because we did a transmitfile");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fReturn;
|
|
}
|
|
}
|
|
|
|
if (m_cbReceived >= m_cbMaxRecvBuffer)
|
|
m_cbReceived = 0;
|
|
|
|
IncPendingIoCount();
|
|
fReturn = ReadFile(QueryMRcvBuffer() + m_cbReceived, m_cbMaxRecvBuffer - m_cbReceived);
|
|
if (!fReturn) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessReadIO - ReadFile # 2 failed with error %d", m_Error);
|
|
}
|
|
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fReturn;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::ProcessFileIO
|
|
|
|
Description:
|
|
Handles completion of an async read issued against a message file by
|
|
MessageReadFile
|
|
|
|
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_CONNOUT::ProcessFileIO(
|
|
IN DWORD BytesRead,
|
|
IN DWORD dwCompletionStatus,
|
|
IN OUT OVERLAPPED *lpo
|
|
)
|
|
{
|
|
CBuffer* pBuffer;
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "SMTP_CONNOUT::ProcessFileIO");
|
|
|
|
_ASSERT(lpo);
|
|
pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
|
|
|
|
//
|
|
// check for partial completions or errors
|
|
//
|
|
if ( BytesRead != pBuffer->GetSize() || dwCompletionStatus != NO_ERROR ) {
|
|
ErrorTrace( (LPARAM)this,
|
|
"Message ReadFile error: %d, bytes %d, expected %d",
|
|
dwCompletionStatus,
|
|
BytesRead,
|
|
pBuffer->GetSize() );
|
|
|
|
m_Error = dwCompletionStatus;
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_dwConnectionStatus), NULL, NULL);
|
|
return ( FALSE );
|
|
} else {
|
|
DebugTrace( (LPARAM)this,
|
|
"ReadFile complete. bytes %d, lpo: 0x%08X",
|
|
BytesRead, lpo );
|
|
}
|
|
|
|
m_bComplete = (m_dwFileOffset + BytesRead) >= m_FileSize;
|
|
|
|
m_dwFileOffset += BytesRead;
|
|
|
|
//
|
|
// If anything to write to the client
|
|
//
|
|
if ( BytesRead > 0 ) {
|
|
//
|
|
// set buffer specific IO state
|
|
//
|
|
pBuffer->SetIoState( CLIENT_WRITE );
|
|
pBuffer->SetSize( BytesRead );
|
|
|
|
ZeroMemory( (void*)&pBuffer->m_Overlapped.SeoOverlapped, sizeof(OVERLAPPED) );
|
|
|
|
DebugTrace( (LPARAM)this, "WriteFile 0x%08X, len: %d, LPO: 0x%08X",
|
|
pBuffer->GetData(),
|
|
BytesRead,
|
|
&pBuffer->m_Overlapped.SeoOverlapped.Overlapped );
|
|
|
|
//
|
|
// If we're on the SSL port, encrypt the data.
|
|
//
|
|
if ( m_SecurePort ) {
|
|
//
|
|
// Seal the message in place as we've already reserved room
|
|
// for both the header and trailer
|
|
//
|
|
if ( m_encryptCtx.SealMessage( pBuffer->GetData() +
|
|
m_encryptCtx.GetSealHeaderSize(),
|
|
BytesRead,
|
|
pBuffer->GetData(),
|
|
&BytesRead ) == FALSE ) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
ErrorTrace( (LPARAM)this, "SealMessage failed. err: %d", m_Error);
|
|
SetDiagnosticInfo(AQUEUE_E_SSL_ERROR, NULL, NULL);
|
|
DisconnectClient();
|
|
} else {
|
|
//
|
|
// adjust the byte count to include header and trailer
|
|
//
|
|
_ASSERT(BytesRead == pBuffer->GetSize() +
|
|
m_encryptCtx.GetSealHeaderSize() +
|
|
m_encryptCtx.GetSealTrailerSize() );
|
|
|
|
pBuffer->SetSize( BytesRead );
|
|
}
|
|
}
|
|
|
|
IncPendingIoCount();
|
|
if ( WriteFile( pBuffer->GetData(),
|
|
BytesRead,
|
|
(LPOVERLAPPED)&pBuffer->m_Overlapped ) == FALSE ) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
//
|
|
// reset the bytes read so we drop out
|
|
//
|
|
BytesRead = 0;
|
|
ErrorTrace( (LPARAM)this, "WriteFile failed (err=%d)", m_Error );
|
|
delete pBuffer;
|
|
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
|
|
//
|
|
// treat as fatal error
|
|
//
|
|
DisconnectClient( );
|
|
//
|
|
// cleanup after write failure
|
|
//
|
|
DecPendingIoCount();
|
|
|
|
}
|
|
}
|
|
|
|
if ( m_bComplete ) {
|
|
BOOL fRet = TRUE;
|
|
|
|
//FreeAtqFileContext();
|
|
|
|
//We do not have any trailers to write if we are processing BDAT
|
|
//
|
|
if (!m_fUseBDAT) {
|
|
if (m_SecurePort) {
|
|
//Nimishk : Is this right ***
|
|
m_OutputBufferSize = m_cbMaxOutputBuffer;
|
|
|
|
fRet = m_encryptCtx.SealMessage(
|
|
(LPBYTE) m_TransmitBuffers.Tail,
|
|
m_TransmitBuffers.TailLength,
|
|
(LPBYTE) m_pOutputBuffer,
|
|
&m_OutputBufferSize);
|
|
|
|
if (fRet)
|
|
fRet = WriteFile(m_pOutputBuffer, m_OutputBufferSize);
|
|
} else {
|
|
fRet = WriteFile(
|
|
(LPVOID)m_TransmitBuffers.Tail,
|
|
m_TransmitBuffers.TailLength );
|
|
}
|
|
}
|
|
m_OutputBufferSize = 0;
|
|
|
|
IncPendingIoCount();
|
|
if (fRet) {
|
|
//pend an IO to pickup the "250 XXXX queued for delivery response"
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
fRet = ReadFile(QueryMRcvBuffer(), m_cbMaxRecvBuffer);
|
|
}
|
|
if (!fRet) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "Error %d sending tail or posting read", m_Error);
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
}
|
|
return ( fRet );
|
|
} else {
|
|
return (MessageReadFile());
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::ProcessClient( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
|
|
{
|
|
BOOL RetStatus;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::ProcessClient");
|
|
|
|
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
|
|
//
|
|
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT), NULL, NULL);
|
|
IncPendingIoCount();
|
|
|
|
m_Error = dwCompletionStatus;
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessClient: - Timing out");
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
|
|
DisconnectClient();
|
|
} else if ((InputBufferLen == 0) || (dwCompletionStatus != NO_ERROR)) {
|
|
//if InputBufferLen == 0, then the connection was closed.
|
|
if (m_Error == NO_ERROR)
|
|
m_Error = ERROR_BROKEN_PIPE;
|
|
|
|
SetDiagnosticInfo(AQUEUE_E_CONNECTION_DROPPED, NULL, NULL);
|
|
|
|
//
|
|
// If the lpo points to an IO buffer allocated for SSL IO, delete it
|
|
//
|
|
|
|
if (lpo != NULL &&
|
|
lpo != &m_Overlapped &&
|
|
lpo != &QueryAtqContext()->Overlapped) {
|
|
CBuffer* pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
|
|
|
|
delete pBuffer;
|
|
}
|
|
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::ProcessClient: InputBufferLen = %d dwCompletionStatus = %d - Closing connection", InputBufferLen, dwCompletionStatus);
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
} else if (lpo == &m_Overlapped || lpo == &QueryAtqContext()->Overlapped
|
|
|| lpo == (OVERLAPPED *) &m_SeoOverlapped) {
|
|
|
|
switch (m_LastClientIo) {
|
|
case SMTP_CONNOUT::READIO:
|
|
RetStatus = ProcessReadIO (InputBufferLen, dwCompletionStatus, lpo);
|
|
break;
|
|
case SMTP_CONNOUT::TRANSFILEIO:
|
|
RetStatus = ProcessTransmitFileIO (InputBufferLen, dwCompletionStatus, lpo);
|
|
break;
|
|
default:
|
|
_ASSERT (FALSE);
|
|
RetStatus = FALSE;
|
|
break;
|
|
}
|
|
} else {
|
|
//
|
|
// This lpo belongs to a CBuffer allocated for message transfers using
|
|
// async reads and writes.
|
|
//
|
|
|
|
CBuffer* pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
|
|
|
|
if (pBuffer->GetIoState() == MESSAGE_READ) {
|
|
RetStatus = ProcessFileIO(InputBufferLen, dwCompletionStatus, lpo);
|
|
} else {
|
|
_ASSERT( pBuffer->GetIoState() == CLIENT_WRITE );
|
|
RetStatus = ProcessWriteIO(InputBufferLen, dwCompletionStatus, lpo);
|
|
}
|
|
|
|
}
|
|
|
|
DecThreadCount();
|
|
|
|
//
|
|
// decrement the overall pending IO count for this session
|
|
// tracing and ASSERTs if we're going down.
|
|
//
|
|
if ( DecPendingIoCount() == 0 ) {
|
|
if (m_dwConnectionStatus == CONNECTION_STATUS_DROPPED) {
|
|
if (!QuerySmtpInstance()->IsShuttingDown())
|
|
ConnectToNextIpAddress();
|
|
}
|
|
|
|
DebugTrace( (LPARAM)this,"Num Threads: %d",m_cActiveThreads);
|
|
_ASSERT( m_cActiveThreads == 0 );
|
|
m_Active = FALSE;
|
|
RetStatus = FALSE;
|
|
} else {
|
|
DebugTrace( (LPARAM)this,"SMTP_CONNOUT::ProcessClient Pending IOs: %d",m_cPendingIoCount);
|
|
DebugTrace( (LPARAM)this,"SMTP_CONNOUT::ProcessClient Num Threads: %d",m_cActiveThreads);
|
|
RetStatus = TRUE;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return RetStatus;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoSSLNegotiation
|
|
|
|
Description:
|
|
Does the SSL Handshake with a remote SMTP server.
|
|
|
|
Arguments:
|
|
|
|
Returns:
|
|
TRUE if successful so far
|
|
FALSE if this object should be deleted
|
|
|
|
--*/
|
|
|
|
BOOL SMTP_CONNOUT::DoSSLNegotiation(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE, fMore, fPostRead;
|
|
DWORD dwErr;
|
|
HRESULT hr = S_OK;
|
|
ULONG cbExtra = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::DoSSLNegotiations");
|
|
|
|
m_OutputBufferSize = m_cbMaxOutputBuffer;
|
|
|
|
dwErr = m_encryptCtx.Converse(
|
|
QueryMRcvBuffer(),
|
|
m_cbReceived,
|
|
(LPBYTE) m_pOutputBuffer,
|
|
&m_OutputBufferSize,
|
|
&fMore,
|
|
(LPSTR) QueryLocalHostName(),
|
|
(LPSTR) QueryLocalPortName(),
|
|
(LPVOID) QuerySmtpInstance(),
|
|
QuerySmtpInstance()->QueryInstanceId(),
|
|
&cbExtra
|
|
);
|
|
|
|
if (dwErr == NO_ERROR) {
|
|
|
|
//
|
|
// reset the receive buffer
|
|
//
|
|
if (cbExtra)
|
|
MoveMemory (QueryMRcvBuffer(), QueryMRcvBuffer() + (m_cbReceived - cbExtra), cbExtra);
|
|
m_cbReceived = cbExtra;
|
|
|
|
if (m_OutputBufferSize != 0) {
|
|
// Send the last negotiation blob to the server and start with Encrypting.
|
|
// Reset the output buffer size
|
|
fRet = WriteFile(m_pOutputBuffer, m_OutputBufferSize);
|
|
m_OutputBufferSize = 0;
|
|
}
|
|
|
|
if (fMore) {
|
|
fPostRead = TRUE;
|
|
} else {
|
|
m_fNegotiatingSSL = FALSE;
|
|
|
|
if (ValidateSSLCertificate ()) {
|
|
m_TlsState = CHANNEL_SECURE;
|
|
|
|
//If we negotiated because of STARTTLS, we need to send EHLO and get the
|
|
//options all over again. According to jump_thru_hoops draft
|
|
if (IsOptionSet(STARTTLS)) {
|
|
//Do ehlo again - this to get the response
|
|
_ASSERT(m_EhloFailed == FALSE);
|
|
char szInput[25];
|
|
strcpy(szInput,"220 OK");
|
|
fRet = DoSessionStartEvent(szInput, strlen(szInput), 0);
|
|
|
|
} else if (!(m_MsgOptions & KNOWN_AUTH_FLAGS)) {
|
|
if (m_MsgOptions & EMPTY_CONNECTION_OPTION) {
|
|
fRet = DoSessionEndEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else {
|
|
fRet = DoMessageStartEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
} else {
|
|
fRet = DoSASLCommand(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
|
|
fPostRead = fRet;
|
|
} else {
|
|
fPostRead = fRet = FALSE;
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_RESP_BAD_CMD;
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
(char *)SMTP_REMOTE_HOST_REJECTED_SSL,
|
|
strlen(SMTP_REMOTE_HOST_REJECTED_SSL),
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
if (fPostRead) {
|
|
//
|
|
// The negotiation is going well so far, but there is still more
|
|
// negotiation to do. So post a read to receive the next leg of
|
|
// the negotiation.
|
|
//
|
|
|
|
DebugTrace((LPARAM) this,"StartSession negotiating SSL");
|
|
|
|
IncPendingIoCount();
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
fRet = ReadFile(QueryMRcvBuffer() + cbExtra, m_cbMaxRecvBuffer - cbExtra);
|
|
if (!fRet) {
|
|
dwErr = GetLastError();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSSLNegotiation failed %d", m_Error);
|
|
DecPendingIoCount();
|
|
SetLastError(dwErr);
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(dwErr), NULL, NULL);
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
}
|
|
}
|
|
|
|
} else {
|
|
fRet = FALSE;
|
|
SetLastError(ERROR_NO_SECURITY_ON_OBJECT);
|
|
SetDiagnosticInfo(AQUEUE_E_TLS_NOT_SUPPORTED_ERROR, NULL, NULL);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return ( fRet );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Description:
|
|
// Check to see if the SSL cert is valid:
|
|
// (1) Always check if it has expired.
|
|
// (2) If configured, check if the issuer is trusted.
|
|
// (3) If configured, check if the subject matches who we are sending to. This
|
|
// is not simply the server-fqdn we are connected to. Since the server-fqdn
|
|
// may have been obtained via DNS (through MX or CNAME indirection), and
|
|
// since DNS is an insecure protocol, we cannot trust that for the subject.
|
|
// Instead we will use the domain we were passed in prior to DNS... the
|
|
// one passed into the REMOTE_QUEUE. This domain name is passed into
|
|
// SMTP_CONNOUT when it is created as m_pszSSLVerificationDomain. We will
|
|
// do some wildcard matching as well if the certificate subject has the
|
|
// '*' character in it (see simssl.cpp). m_pszSSLVerificationName may be
|
|
// NULL if there is no target hostname --- such as in the case of a literal
|
|
// IP address. In this case, subject verification is skipped.
|
|
// Returns:
|
|
// TRUE - success, certificate verified
|
|
// FALSE - failure, stick queue into retry
|
|
//----------------------------------------------------------------------------------
|
|
BOOL SMTP_CONNOUT::ValidateSSLCertificate ()
|
|
{
|
|
BOOL fRet = FALSE;
|
|
DWORD dwAQDiagnostic = 0;
|
|
|
|
TraceFunctEnterEx ((LPARAM) this, "SMTP_CONNECTION::ValidateCertificate");
|
|
|
|
fRet = m_encryptCtx.CheckCertificateExpired();
|
|
if (!fRet) {
|
|
ErrorTrace ((LPARAM) this, "SSL Certificate Expired");
|
|
dwAQDiagnostic = AQUEUE_E_SSL_CERT_EXPIRED;
|
|
goto Exit;
|
|
}
|
|
|
|
if (m_pInstance->RequiresSSLCertVerifyIssuer()) {
|
|
|
|
DebugTrace ((LPARAM) this, "Verifying certificate issuing authority");
|
|
|
|
//
|
|
// Failure in these checks could occur due to temporary conditions (like
|
|
// out of memory). So the AQueue diagnostic is not 100% accurate, but it's
|
|
// OK as we don't NDR message. Anyway we DID fail during cert validation.
|
|
//
|
|
|
|
fRet = m_encryptCtx.CheckCertificateTrust();
|
|
if (!fRet) {
|
|
ErrorTrace ((LPARAM) this, "SSL Certificate trust verification failure");
|
|
dwAQDiagnostic = AQUEUE_E_SSL_CERT_ISSUER_UNTRUSTED;
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if (!m_pszSSLVerificationName) {
|
|
DebugTrace ((LPARAM) this,
|
|
"Skipping certificate subject validation, no name to validate against");
|
|
goto Exit;
|
|
}
|
|
|
|
DebugTrace ((LPARAM) this,
|
|
"Validating certificate subject against: %s", m_pszSSLVerificationName);
|
|
|
|
fRet = m_encryptCtx.CheckCertificateSubjectName (m_pszSSLVerificationName);
|
|
if (!fRet) {
|
|
ErrorTrace ((LPARAM) this, "SSL certificate subject verification failure");
|
|
dwAQDiagnostic = AQUEUE_E_SSL_CERT_SUBJECT_MISMATCH;
|
|
}
|
|
Exit:
|
|
if (!fRet && dwAQDiagnostic)
|
|
SetDiagnosticInfo(dwAQDiagnostic, NULL, NULL);
|
|
|
|
TraceFunctLeaveEx ((LPARAM) this);
|
|
return fRet;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
void SMTP_CONNECTION::SkipWord
|
|
|
|
Description:
|
|
skips over words in a buffer and
|
|
returns pointer to next word
|
|
|
|
Arguments:
|
|
none
|
|
|
|
Returns:
|
|
TRUE if the receive buffer was successfully decrypted, FALSE otherwise
|
|
|
|
--*/
|
|
|
|
BOOL SMTP_CONNOUT::DecryptInputBuffer(void)
|
|
{
|
|
TraceFunctEnterEx( (LPARAM)this, "SMTP_CONNOUT::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;
|
|
} 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 );
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
|
|
DisconnectClient( dwError );
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( dwError == NO_ERROR );
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::DoSASLNegotiation(char *InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BUFFER BuffOut;
|
|
DWORD BytesRet = 0;
|
|
BOOL fMoreData = FALSE;
|
|
BOOL fRet = TRUE;
|
|
BOOL fReturn = TRUE;
|
|
DomainInfo DomainParams;
|
|
LPSTR szClearTextPassword = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoSASLNegotiation");
|
|
|
|
//we need to receive a 354 from the server to go on
|
|
if (InputLine[0] == SMTP_INTERMEDIATE_SUCCESS) {
|
|
|
|
if (m_AuthToUse & SMTP_AUTH_NTLM || m_AuthToUse & SMTP_AUTH_KERBEROS) {
|
|
|
|
if (m_securityCtx.ClientConverse(
|
|
InputLine + 4, ParameterSize - 4, &BuffOut, &BytesRet,
|
|
&fMoreData, &AuthInfoStruct, m_szAuthPackage,
|
|
NULL, NULL, (PIIS_SERVER_INSTANCE) m_pInstance)) {
|
|
|
|
if (BytesRet) {
|
|
FormatSmtpMessage(FSM_LOG_NONE, "%s\r\n", BuffOut.QueryPtr());
|
|
SendSmtpResponse();
|
|
}
|
|
|
|
} else {
|
|
|
|
DebugTrace((LPARAM) this, "m_securityCtx.Converse failed - %d",
|
|
GetLastError());
|
|
|
|
m_Error = ERROR_LOGON_FAILURE;
|
|
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_RESP_BAD_CMD;
|
|
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
(char *)SMTP_REMOTE_HOST_REJECTED_AUTH,
|
|
strlen(SMTP_REMOTE_HOST_REJECTED_AUTH),
|
|
NULL);
|
|
|
|
fRet = FALSE;
|
|
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_REJECTED, NULL, NULL);
|
|
}
|
|
} else {
|
|
|
|
ZeroMemory (&DomainParams, sizeof(DomainParams));
|
|
|
|
DomainParams.cbVersion = sizeof(DomainParams);
|
|
|
|
hr = m_pISMTPConnection->GetDomainInfo(&DomainParams);
|
|
|
|
if (FAILED(hr)) {
|
|
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_LOGON_FAILURE);
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_REJECTED, NULL, NULL);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
szClearTextPassword = DomainParams.szPassword;
|
|
if (!szClearTextPassword) szClearTextPassword = "";
|
|
|
|
fReturn = uuencode ((unsigned char *)szClearTextPassword,
|
|
lstrlen(szClearTextPassword), &BuffOut, FALSE);
|
|
|
|
if (fReturn) {
|
|
|
|
FormatSmtpMessage(FSM_LOG_NONE, "%s\r\n", BuffOut.QueryPtr());
|
|
SendSmtpResponse();
|
|
|
|
} else {
|
|
|
|
m_Error = GetLastError();
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
fRet = FALSE;
|
|
|
|
}
|
|
}
|
|
} else if (InputLine[0] == SMTP_COMPLETE_SUCCESS) {
|
|
|
|
if (m_MsgOptions & EMPTY_CONNECTION_OPTION) {
|
|
fRet = DoSessionEndEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else {
|
|
fRet = DoMessageStartEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
|
|
} else {
|
|
|
|
fRet = FALSE;
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = ERROR_LOGON_FAILURE;
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_REJECTED, NULL, NULL);
|
|
DisconnectClient();
|
|
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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_CONNOUT::DoEHLOCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoEHLOCommand");
|
|
|
|
if (m_EhloFailed)
|
|
{
|
|
//server did not understand EHLO command, so
|
|
//just send the HELO command
|
|
m_HeloSent = TRUE;
|
|
QuerySmtpInstance()->LockGenCrit();
|
|
PE_FormatSmtpMessage("HELO %s\r\n", QuerySmtpInstance()->GetFQDomainName());
|
|
QuerySmtpInstance()->UnLockGenCrit();
|
|
} else {
|
|
QuerySmtpInstance()->LockGenCrit();
|
|
PE_FormatSmtpMessage("EHLO %s\r\n", QuerySmtpInstance()->GetFQDomainName());
|
|
QuerySmtpInstance()->UnLockGenCrit();
|
|
}
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_SUCCESS;
|
|
m_EhloSent = TRUE;
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoEHLOResponse
|
|
|
|
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_CONNOUT::DoEHLOResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fGotAllOptions;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoEHLOResponse");
|
|
char chInputGood = 0;
|
|
BOOL fEndSession = FALSE;
|
|
|
|
if ( isdigit( (UCHAR)InputLine[1] ) && isdigit( (UCHAR)InputLine[2] ) && ( ( InputLine[3] == ' ' ) || ( InputLine[3] == '-' ) ) ) {
|
|
chInputGood = InputLine[0];
|
|
} else {
|
|
chInputGood = SMTP_COMPLETE_FAILURE;
|
|
fEndSession = TRUE;
|
|
}
|
|
|
|
|
|
//get the response
|
|
switch ( chInputGood ) {
|
|
case SMTP_COMPLETE_SUCCESS:
|
|
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_SUCCESS;
|
|
fGotAllOptions = GetEhloOptions(
|
|
InputLine,
|
|
ParameterSize,
|
|
UndecryptedTailSize,
|
|
m_HeloSent);
|
|
_ASSERT(fGotAllOptions);
|
|
if (IsOptionSet(ETRN_ONLY_OPTION) && !IsOptionSet(ETRN_OPTION)) {
|
|
//We have no messages to send... only ETRN, but ETRN is not
|
|
//supported by the remote server, we should send quit
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_CHANGE_STATE;
|
|
m_ResponseContext.m_dwNextState = PE_STATE_SESSION_END;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
}
|
|
|
|
break;
|
|
|
|
case SMTP_COMPLETE_FAILURE:
|
|
|
|
//if the HELO was sent and we got a 55X reply,
|
|
//just quit. This server is hosed.
|
|
if ( m_HeloSent || fEndSession ) {
|
|
DebugTrace((LPARAM) this,
|
|
"SMTP_CONNOUT::DoEHLOCommand executing quit command err from client = %c%c%c",
|
|
InputLine [0],InputLine [1],InputLine [2]);
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_CHANGE_STATE;
|
|
m_ResponseContext.m_dwNextState = PE_STATE_SESSION_END;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, m_HeloSent ? "HELO" : "EHLO", InputLine);
|
|
} else {
|
|
//server did not understand EHLO command, so
|
|
//just send the HELO command
|
|
m_EhloFailed = TRUE;
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_REPEAT_COMMAND;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DebugTrace((LPARAM) this,
|
|
"SMTP_CONNOUT::DoEHLOCommand executing quit command err = %c%c%c",
|
|
InputLine [0],InputLine [1],InputLine [2]);
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_CHANGE_STATE;
|
|
m_ResponseContext.m_dwNextState = PE_STATE_SESSION_END;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, m_HeloSent ? "HELO" : "EHLO", InputLine);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
|
|
SMTP_CONNOUT::GetEhloOptions(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
|
|
Description:
|
|
|
|
Parses the response from the EHLO command
|
|
|
|
Arguments:
|
|
Line containing the response and line size
|
|
|
|
Returns:
|
|
TRUE if it parses all data
|
|
FALSE if it needs more data to continue parsing
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::GetEhloOptions(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize, BOOL fIsHelo)
|
|
{
|
|
register char * pszValue = NULL;
|
|
register char * pszSearch = NULL;
|
|
DWORD IntermediateSize = 0;
|
|
BOOL IsNextLine = FALSE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::GetEhloOptions");
|
|
|
|
//get each line and parse the commands
|
|
while ((pszSearch = IsLineComplete(InputLine, ParameterSize)) != NULL) {
|
|
//Null terminate the end of the option
|
|
*pszSearch = '\0';
|
|
|
|
//check to see if there is a continuation line
|
|
IsNextLine = (InputLine[3] == '-');
|
|
|
|
IntermediateSize= (DWORD)((pszSearch - InputLine) + 2); //+2 for CRLF
|
|
|
|
|
|
// Only process if it is an EHLO command, otherwise, just
|
|
// eat up all the response data.
|
|
if (!fIsHelo) {
|
|
//skip over code and space
|
|
//look for a space in the line.
|
|
//options that have paramters
|
|
//need to have a space after
|
|
//their name
|
|
pszValue = strchr(InputLine + 4, ' ');
|
|
|
|
//does the server support the SIZE option ???
|
|
if (strncasecmp(InputLine + 4, (char * )"SIZE", 4) == 0) {
|
|
//yes sireee bob. If the server advertised
|
|
//a maximum file size, get it while we are
|
|
//here.
|
|
m_Flags |= SIZE_OPTION;
|
|
if (pszValue != NULL)
|
|
m_SizeOptionSize = atoi (pszValue);
|
|
} else if (strcasecmp(InputLine + 4, (char * )"PIPELINING") == 0) {
|
|
m_Flags |= PIPELINE_OPTION;
|
|
} else if (strcasecmp(InputLine + 4, (char * )"8bitmime") == 0) {
|
|
m_Flags |= EBITMIME_OPTION;
|
|
} else if (strcasecmp(InputLine + 4, (char * )"dsn") == 0) {
|
|
m_Flags |= DSN_OPTION;
|
|
} else if (strncasecmp(InputLine + 4, (char *)"TLS", 3) == 0) {
|
|
m_Flags |= TLS_OPTION;
|
|
} else if (strncasecmp(InputLine + 4, (char *)"STARTTLS", 8) == 0) {
|
|
m_Flags |= STARTTLS_OPTION;
|
|
} else if (strncasecmp(InputLine + 4, (char *)"ETRN", 4) == 0) {
|
|
m_Flags |= ETRN_OPTION;
|
|
} else if (strcasecmp(InputLine + 4, (char *)"CHUNKING") == 0) {
|
|
m_Flags |= CHUNKING_OPTION;
|
|
} else if (strcasecmp(InputLine + 4, (char *)"BINARYMIME") == 0) {
|
|
m_Flags |= BINMIME_OPTION;
|
|
} else if (strcasecmp(InputLine + 4, (char *)"ENHANCEDSTATUSCODES") == 0) {
|
|
m_Flags |= ENHANCEDSTATUSCODE_OPTION;
|
|
} else if (strncasecmp(InputLine + 4, (char *)"AUTH", 4) == 0) {
|
|
pszValue = strchr(InputLine + 4, '=');
|
|
|
|
if (pszValue == NULL)
|
|
pszValue = strchr(InputLine + 4, ' ');
|
|
|
|
while (pszValue != NULL) {
|
|
if (strncasecmp(pszValue + 1, (char *)"NTLM", 4) == 0) {
|
|
m_Flags |= AUTH_NTLM;
|
|
|
|
} else if (strncasecmp(pszValue + 1, (char *)"LOGIN", 5) == 0) {
|
|
m_Flags |= AUTH_CLEARTEXT;
|
|
|
|
} else if (strncasecmp(pszValue + 1, (char *)"DPA", 3) == 0) {
|
|
m_Flags |= AUTH_NTLM;
|
|
|
|
} else if (strncasecmp(pszValue + 1, (char *)"GSSAPI", 6) == 0) {
|
|
m_Flags |= AUTH_GSSAPI;
|
|
}
|
|
|
|
pszValue = strchr(pszValue + 1, ' ');
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
InputLine += IntermediateSize;
|
|
ParameterSize -= IntermediateSize;
|
|
}
|
|
|
|
// We don't want to bail out for weird responses, but we want to
|
|
// note such occurrences.
|
|
if ((ParameterSize > 1) ||
|
|
(!ParameterSize) ||
|
|
(*InputLine)) {
|
|
ErrorTrace((LPARAM)this, "Weird response tail <%*s>",
|
|
ParameterSize, InputLine);
|
|
_ASSERT(FALSE);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::DoSASLCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
BOOL fMoreData = TRUE;
|
|
BUFFER BuffOut;
|
|
DWORD BytesRet = 0;
|
|
DomainInfo DomainParams;
|
|
LPSTR szUserName = NULL;
|
|
LPSTR szPassword = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoSASLCommand");
|
|
|
|
ZeroMemory (&DomainParams, sizeof(DomainParams));
|
|
|
|
if ((m_MsgOptions & DOMAIN_INFO_USE_NTLM ||
|
|
m_MsgOptions & DOMAIN_INFO_USE_KERBEROS)) {
|
|
if (!IsOptionSet(AUTH_NTLM) && !(IsOptionSet(AUTH_GSSAPI))) {
|
|
//
|
|
// We were told to do secure connection, but the remote server doesn't
|
|
// support any form of login authentication! We have to drop this connection now.
|
|
//
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSASLCommand: ERROR! Remote server does not support AUTH!");
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SUCH_PACKAGE);
|
|
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_REJECTED, "AUTH", InputLine);
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
}
|
|
|
|
if (m_MsgOptions & DOMAIN_INFO_USE_PLAINTEXT) {
|
|
if (!IsOptionSet(AUTH_CLEARTEXT)) {
|
|
//
|
|
// We were told to do secure connection, but the remote server doesn't
|
|
// support any form of login authentication! We have to drop this connection now.
|
|
//
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSASLCommand: ERROR! Remote server does not support AUTH!");
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SUCH_PACKAGE);
|
|
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_REJECTED, "AUTH", InputLine);
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
}
|
|
|
|
//set the next state
|
|
SetNextState (&SMTP_CONNOUT::DoSASLNegotiation);
|
|
|
|
ZeroMemory (&DomainParams, sizeof(DomainParams));
|
|
DomainParams.cbVersion = sizeof(DomainParams);
|
|
hr = m_pISMTPConnection->GetDomainInfo(&DomainParams);
|
|
|
|
if (FAILED(hr)) {
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_LOGON_FAILURE);
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_LOGON_FAILURE, "AUTH", InputLine);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
szUserName = DomainParams.szUserName;
|
|
szPassword = DomainParams.szPassword;
|
|
|
|
//If a username is specified, but NULL password, IIS will attempt
|
|
//anonymous logon. Force "" password so the correct user is
|
|
//used.
|
|
if (szUserName && !szPassword)
|
|
szPassword = "";
|
|
|
|
if (m_MsgOptions & DOMAIN_INFO_USE_NTLM ||
|
|
m_MsgOptions & DOMAIN_INFO_USE_KERBEROS) {
|
|
|
|
m_szAuthPackage[0] = '\0';
|
|
BOOL fReturn = FALSE;
|
|
char szTarget[MAX_INTERNET_NAME + 1];
|
|
|
|
if ((m_MsgOptions & DOMAIN_INFO_USE_KERBEROS) && (IsOptionSet(AUTH_GSSAPI))) {
|
|
m_AuthToUse = SMTP_AUTH_KERBEROS;
|
|
strcpy(m_szAuthPackage,"GSSAPI");
|
|
|
|
//
|
|
// For Kerberos, we need to set the target server SPN, for which we
|
|
// pickup info from m_pDnsRec
|
|
//
|
|
MX_NAMES *pmx;
|
|
|
|
_ASSERT( m_pDnsRec != NULL );
|
|
_ASSERT( m_pDnsRec->StartRecord < m_pDnsRec->NumRecords );
|
|
|
|
pmx = m_pDnsRec->DnsArray[m_pDnsRec->StartRecord];
|
|
_ASSERT( pmx != NULL );
|
|
_ASSERT( pmx->DnsName != NULL );
|
|
|
|
m_securityCtx.SetTargetPrincipalName(
|
|
SMTP_SERVICE_PRINCIPAL_PREFIX,pmx->DnsName);
|
|
|
|
DebugTrace((LPARAM) this, "Setting Target Server SPN to %s",
|
|
pmx->DnsName);
|
|
|
|
} else {
|
|
m_AuthToUse = SMTP_AUTH_NTLM;
|
|
strcpy(m_szAuthPackage,"NTLM");
|
|
}
|
|
|
|
DebugTrace((LPARAM) this, "Using NTLM/KERBEROS for user %s",
|
|
DomainParams.szUserName);
|
|
|
|
fReturn = m_securityCtx.ClientConverse(
|
|
NULL, 0, &BuffOut, &BytesRet,
|
|
&fMoreData, &AuthInfoStruct,
|
|
m_szAuthPackage,
|
|
(char *) szUserName,
|
|
(char *) szPassword,
|
|
(PIIS_SERVER_INSTANCE) m_pInstance);
|
|
|
|
if (fReturn) {
|
|
if (BytesRet) {
|
|
FormatSmtpMessage(FSM_LOG_ALL, "AUTH %s %s\r\n", m_szAuthPackage,
|
|
BuffOut.QueryPtr());
|
|
}
|
|
|
|
if (!fMoreData && (m_MsgOptions & DOMAIN_INFO_USE_NTLM)) {
|
|
fRet = FALSE;
|
|
}
|
|
} else {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "m_securityCtx.Converse for user %s - %d",
|
|
szUserName, m_Error);
|
|
DisconnectClient();
|
|
m_Error = ERROR_LOGON_FAILURE;
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_LOGON_FAILURE, "AUTH", NULL); //Should not pass param Inputline: encrypted
|
|
fRet = FALSE;
|
|
}
|
|
} else {
|
|
BOOL fReturn = FALSE;
|
|
m_AuthToUse = SMTP_AUTH_CLEARTEXT;
|
|
|
|
if (!szUserName) szUserName = "";
|
|
if (!szPassword) szPassword = "";
|
|
|
|
DebugTrace((LPARAM) this, "Using ClearText for user %s",
|
|
szUserName);
|
|
fReturn = uuencode ((unsigned char *)szUserName,
|
|
lstrlen(szUserName), &BuffOut, FALSE);
|
|
|
|
if (fReturn) {
|
|
FormatSmtpMessage(FSM_LOG_VERB_ONLY, "AUTH LOGIN %s\r\n", (char *)
|
|
BuffOut.QueryPtr());
|
|
BytesRet = lstrlen((char *) BuffOut.QueryPtr());
|
|
} else {
|
|
DisconnectClient();
|
|
m_Error = ERROR_LOGON_FAILURE;
|
|
SetDiagnosticInfo(AQUEUE_E_SASL_LOGON_FAILURE, "AUTH", NULL); //Should not pass param Inputline: uuencoded
|
|
fRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if (fRet && BytesRet) {
|
|
SendSmtpResponse();
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoSTARTTLSCommand
|
|
|
|
Description:
|
|
|
|
Negotiates use of SSL via the STARTTLS command
|
|
|
|
Arguments:
|
|
InputLine -- Indicates response of remote server
|
|
ParameterSize -- Size of Inputline
|
|
UndecryptedTailSize -- The part of the received buffer that could not
|
|
be decrypted.
|
|
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoSTARTTLSCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoSTARTTLSCommand");
|
|
|
|
if (m_TlsState == MUST_DO_TLS) {
|
|
if (IsOptionSet(TLS_OPTION) || IsOptionSet(STARTTLS_OPTION)) {
|
|
FormatSmtpMessage(FSM_LOG_ALL, "STARTTLS\r\n");
|
|
SendSmtpResponse();
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: STARTTLS command sent");
|
|
m_TlsState = STARTTLS_SENT;
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( TRUE );
|
|
} else {
|
|
//
|
|
// We were told to do secure connection, but the remote server doesn't
|
|
// support TLS! We have to drop this connection now.
|
|
//
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: ERROR! Remote server does not support TLS!");
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
SetDiagnosticInfo(AQUEUE_E_TLS_NOT_SUPPORTED_ERROR, "STARTTLS", InputLine);
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SECURITY_ON_OBJECT);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
} else {
|
|
//
|
|
// We sent the STARTTLS command, and InputLine has the server's response
|
|
// Handle the server's response
|
|
//
|
|
_ASSERT(m_TlsState == STARTTLS_SENT);
|
|
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: Server response to STARTTLS is \"%s\"", InputLine);
|
|
switch (InputLine[0]) {
|
|
case SMTP_COMPLETE_FAILURE:
|
|
{
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: Server returned error");
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
SetDiagnosticInfo(AQUEUE_E_TLS_ERROR, "STARTTLS", InputLine);
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SECURITY_ON_OBJECT);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
break;
|
|
|
|
case SMTP_COMPLETE_SUCCESS:
|
|
{
|
|
m_SecurePort = TRUE;
|
|
m_fNegotiatingSSL = TRUE;
|
|
m_TlsState = SSL_NEG;
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: Server accepted, beginning SSL handshake");
|
|
|
|
//
|
|
// Switch over to using a large receive buffer, because a SSL fragment
|
|
// may be up to 32K big.
|
|
|
|
if (!SwitchToBigSSLBuffers()) {
|
|
DebugTrace((LPARAM) this,
|
|
"SMTP_CONNOUT::DoSTARTTLSCommand: Failed to allocate Big SSL buffers %d\n",
|
|
GetLastError());
|
|
DisconnectClient();
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
|
|
if (!DoSSLNegotiation(NULL, 0, 0)) {
|
|
DebugTrace(
|
|
(LPARAM) this,
|
|
"SMTP_CONNOUT::DoSTARTTLSCommand: SSL Client Hello failed %d!\n",
|
|
GetLastError());
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SECURITY_ON_OBJECT);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
DebugTrace((LPARAM) this, "SMTP_CONNOUT::DoSTARTTLSCommand: Server sent malformed response to STARTTLS");
|
|
SetDiagnosticInfo(AQUEUE_E_TLS_ERROR, "STARTTLS", InputLine);
|
|
DisconnectClient();
|
|
SetLastError(m_Error = ERROR_NO_SECURITY_ON_OBJECT);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return ( FALSE );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoRSETCommand
|
|
|
|
Description:
|
|
|
|
Sends the SMTP RSET command.
|
|
|
|
Arguments:
|
|
Are ignored
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoRSETCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
FormatSmtpMessage(FSM_LOG_ALL, "RSET\r\n");
|
|
|
|
m_cbReceived = 0;
|
|
m_cbParsable = 0;
|
|
m_fUseBDAT = FALSE;
|
|
|
|
//If we are issuing rset during the Per rcpt event due to some problem
|
|
//we need to preserve the state till we handle the
|
|
//this message and ack it
|
|
if (m_RsetReasonCode != ALL_RCPTS_FAILED) {
|
|
m_fNeedRelayedDSN = FALSE;
|
|
m_fHadHardError = FALSE;
|
|
m_fHadTempError = FALSE;
|
|
}
|
|
|
|
return SendSmtpResponse();
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::SendRemainingRecipients
|
|
|
|
Description:
|
|
|
|
SendRemainingRecipients
|
|
gets called when we get a 552 error during the
|
|
RCPT to command. This means that the server we connected
|
|
to has a fixed max amount of rcpts that it accepts, and we
|
|
went over that limit. Therefore, we send the mail file to
|
|
the recipients that it accepted and then start over sending
|
|
the mail to the remaining recipients. However, before doing
|
|
this, check the response to see if the server took the previous
|
|
mail O.K.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Returns:
|
|
nothing
|
|
|
|
--*/
|
|
void SMTP_CONNOUT::SendRemainingRecipients (void)
|
|
{
|
|
#if 0
|
|
CAddr * pwalk = NULL;
|
|
PLIST_ENTRY pListTemp = NULL;
|
|
|
|
//increment our counter
|
|
BUMP_COUNTER(QuerySmtpInstance(), NumMsgsSent);
|
|
|
|
//yea, baby. Save the start address
|
|
//so we can walk the list deleting
|
|
//any addresses that were successfully
|
|
//sent.
|
|
pwalk = m_StartAddress;
|
|
pListTemp = m_StartAddressLink;
|
|
|
|
_ASSERT (pwalk != NULL);
|
|
|
|
//set the start address to NULL, so
|
|
//that we can set it to a known good
|
|
//address below. See the other comment
|
|
//below.
|
|
m_StartAddress = NULL;
|
|
m_StartAddressLink = NULL;
|
|
|
|
//step through all the previously sent addresses.
|
|
//If they have an error code of 250, then they
|
|
//were received correctly. An error code of
|
|
//552 means that we sent too many, so we are
|
|
//going to attempt to send the remaining recipients.
|
|
//We will not attempt to send a rcpt that has any
|
|
//other error code.
|
|
while (pwalk && (pwalk->GetErrorCode() != SMTP_DUMMY_FAILURE)) {
|
|
if ((pwalk->GetErrorCode() == SMTP_OK_CODE) ||
|
|
(pwalk->GetErrorCode() == SMTP_USER_NOT_LOCAL_CODE)) {
|
|
MailInfo->RemoveAddress(pwalk);
|
|
delete pwalk;
|
|
}
|
|
|
|
//get the next address
|
|
pwalk = MailInfo->GetNextAddress(&pListTemp);
|
|
}
|
|
|
|
_ASSERT (pwalk != NULL);
|
|
_ASSERT (pwalk->GetErrorCode() == SMTP_DUMMY_FAILURE);
|
|
|
|
m_StartAddress = pwalk;
|
|
m_StartAddressLink = pListTemp;
|
|
|
|
_ASSERT (m_StartAddress != NULL);
|
|
_ASSERT (m_StartAddressLink != NULL);
|
|
|
|
//update the queue file to reflect the remaining
|
|
//recipients, if any
|
|
MailInfo->UpdateQueueFile(REMOTE_NAME);
|
|
|
|
//save the current RCPT address
|
|
m_NextAddress = pwalk;
|
|
m_NextAddressLink = pListTemp;
|
|
#endif
|
|
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::DoETRNCommand(void)
|
|
{
|
|
DWORD WaitRes = WAIT_TIMEOUT;
|
|
DWORD TimeToWait = 0;
|
|
HRESULT hr = S_OK;
|
|
DomainInfo DomainParams;
|
|
char szETRNDomainBuffer[MAX_PATH+1];
|
|
char *szNextETRNDomain = NULL;
|
|
const char *szETRNDomain = szETRNDomainBuffer;
|
|
DWORD cbETRNDomain = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoETRNCommand");
|
|
|
|
ZeroMemory(&DomainParams, sizeof(DomainParams));
|
|
|
|
ZeroMemory (&DomainParams, sizeof(DomainParams));
|
|
DomainParams.cbVersion = sizeof(DomainParams);
|
|
hr = m_pISMTPConnection->GetDomainInfo(&DomainParams);
|
|
if (FAILED(hr) || (DomainParams.szETRNDomainName == NULL)) {
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!m_szCurrentETRNDomain) {
|
|
m_szCurrentETRNDomain = DomainParams.szETRNDomainName;
|
|
}
|
|
|
|
//Find next in comma-delimited list of domains
|
|
szNextETRNDomain = strchr(m_szCurrentETRNDomain, ',');
|
|
|
|
if (!szNextETRNDomain) {
|
|
//We are done... this is the last domain
|
|
szETRNDomain = m_szCurrentETRNDomain;
|
|
m_Flags |= ETRN_SENT;
|
|
} else {
|
|
//There are more domains left... we need to copy the domain
|
|
//to our buffer where we can NULL terminate it.
|
|
cbETRNDomain = (DWORD) (sizeof(char)*(szNextETRNDomain-m_szCurrentETRNDomain));
|
|
if ((cbETRNDomain >= sizeof(szETRNDomainBuffer)) ||
|
|
(cbETRNDomain > DomainParams.cbETRNDomainNameLength)) {
|
|
//There is not enough room for this domain
|
|
ErrorTrace((LPARAM) this, "Domain configured for ETRN is greater than MAX_PATH");
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
memcpy(szETRNDomainBuffer, m_szCurrentETRNDomain, cbETRNDomain);
|
|
szETRNDomainBuffer[cbETRNDomain/sizeof(char)] = '\0';
|
|
|
|
//Skip to beginning of next domain
|
|
m_szCurrentETRNDomain = szNextETRNDomain;
|
|
while (isspace((UCHAR)*m_szCurrentETRNDomain) || *m_szCurrentETRNDomain == ',') {
|
|
if (!(*m_szCurrentETRNDomain)) {
|
|
//End of string... we're done
|
|
m_Flags |= ETRN_SENT;
|
|
break;
|
|
}
|
|
m_szCurrentETRNDomain++;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
TimeToWait = m_pHashEntry->GetEtrnWaitTime() * 60 * 1000; //time in milliseconds
|
|
|
|
if (TimeToWait) {
|
|
WaitRes = WaitForSingleObject(QuerySmtpInstance()->GetQStopEvent(), m_pHashEntry->GetEtrnWaitTime());
|
|
}
|
|
|
|
if (WaitRes == WAIT_OBJECT_0) {
|
|
DisconnectClient();
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
FormatSmtpMessage(FSM_LOG_ALL, "ETRN %s\r\n", szETRNDomain);
|
|
|
|
SendSmtpResponse();
|
|
|
|
//Keep on sending ETRNs until we are out of domains.
|
|
if (!IsOptionSet(ETRN_ONLY_OPTION) || !(m_Flags & ETRN_SENT)) {
|
|
SetNextState (&SMTP_CONNOUT::DoMessageStartEvent);
|
|
} else {
|
|
SetNextState (&SMTP_CONNOUT::DoCompletedMessage);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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_CONNOUT::DoMAILCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
char Options[1024] = "";
|
|
char BodySize[32];
|
|
char Address[MAX_INTERNET_NAME];
|
|
DWORD MsgOption = 0;
|
|
HRESULT hr = S_OK;
|
|
BOOL fFailedDueToBMIME = FALSE;
|
|
_ASSERT(m_pIMsg);
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoMAILCommand");
|
|
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_SUCCESS;
|
|
|
|
//clear the options
|
|
Options[0] = '\0';
|
|
|
|
//If the message has 8bitmime, make sure the
|
|
//server also supports it.
|
|
|
|
hr = m_pIMsg->GetDWORD(IMMPID_MP_EIGHTBIT_MIME_OPTION, &MsgOption);
|
|
if (MsgOption) {
|
|
if (IsOptionSet(EBITMIME_OPTION)) {
|
|
lstrcat(Options, " BODY=8bitmime");
|
|
} else {
|
|
// SetLastError(SMTP_OPTION_NOT_SUPPORTED_8BIT);
|
|
DebugTrace((LPARAM) this, "Message has 8bitmime but server does not support it");
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_COMPLETE_FAILURE;
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_RESP_BAD_CMD;
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
(char *)SMTP_REMOTE_HOST_REJECTED_FOR_TYPE,
|
|
strlen(SMTP_REMOTE_HOST_REJECTED_FOR_TYPE),
|
|
NULL);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
} else {
|
|
MsgOption = 0;
|
|
hr = m_pIMsg->GetDWORD(IMMPID_MP_BINARYMIME_OPTION, &MsgOption);
|
|
if (MsgOption) {
|
|
//Check if we allow BINARYMIME outbound at domain level
|
|
if (m_MsgOptions & DOMAIN_INFO_DISABLE_BMIME) {
|
|
fFailedDueToBMIME = TRUE;
|
|
} else {
|
|
//Do we disallow it globally
|
|
if (QuerySmtpInstance()->AllowOutboundBMIME()) {
|
|
if (IsOptionSet(BINMIME_OPTION) && IsOptionSet(CHUNKING_OPTION)) {
|
|
lstrcat(Options, " BODY=BINARYMIME");
|
|
m_fUseBDAT = TRUE;
|
|
} else {
|
|
fFailedDueToBMIME = TRUE;
|
|
}
|
|
} else {
|
|
fFailedDueToBMIME = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (fFailedDueToBMIME) {
|
|
// SetLastError(SMTP_OPTION_NOT_SUPPORTED_BMIME);
|
|
DebugTrace((LPARAM) this, "Message has BINARYMIME but server does not support it");
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_COMPLETE_FAILURE;
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_RESP_BAD_CMD;
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
(char *)SMTP_REMOTE_HOST_REJECTED_FOR_TYPE,
|
|
strlen(SMTP_REMOTE_HOST_REJECTED_FOR_TYPE),
|
|
NULL);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
//See if CHUNKING is preferred on this connection
|
|
//If it is and the remote site advertised chunking then we set the UseBDAT flag
|
|
else if (!m_fUseBDAT) {
|
|
//Does the remote server advertises chunking
|
|
if (IsOptionSet(CHUNKING_OPTION)) {
|
|
//Do we disallow chunking at domain level
|
|
if (m_MsgOptions & DOMAIN_INFO_DISABLE_CHUNKING) {
|
|
DebugTrace((LPARAM) this, "We disable chunking for this domain");
|
|
|
|
} else if ((m_MsgOptions & DOMAIN_INFO_USE_CHUNKING) || QuerySmtpInstance()->ShouldChunkOut()) {
|
|
m_fUseBDAT = TRUE;
|
|
}
|
|
} else if (m_MsgOptions & DOMAIN_INFO_USE_CHUNKING)
|
|
DebugTrace((LPARAM) this, "Remote server does not advertise chunking");
|
|
}
|
|
|
|
// produce a dot-stuffed handle if we aren't using bdat
|
|
if (!m_fUseBDAT) {
|
|
DWORD fFoundEmbeddedCrlfDot = FALSE;
|
|
DWORD fScanned = FALSE;
|
|
|
|
//
|
|
// get the properties to see if we have scanned for crlf.crlf, and
|
|
// to see if the message contained crlf.crlf when it was scanned.
|
|
// if either of these lookups fail then we will set fScanned to
|
|
// FALSE
|
|
//
|
|
if (FAILED(m_pIMsg->GetDWORD(IMMPID_MP_SCANNED_FOR_CRLF_DOT_CRLF,
|
|
&fScanned)) ||
|
|
FAILED(m_pIMsg->GetDWORD(IMMPID_MP_FOUND_EMBEDDED_CRLF_DOT_CRLF,
|
|
&fFoundEmbeddedCrlfDot)))
|
|
{
|
|
fScanned = FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// if we didn't scan, or if we found an embedded crlf.crlf then
|
|
// produce a dot stuff context
|
|
//
|
|
if (!fScanned || fFoundEmbeddedCrlfDot) {
|
|
if (!m_IMsgDotStuffedFileHandle) {
|
|
m_IMsgDotStuffedFileHandle = ProduceDotStuffedContext(
|
|
m_IMsgFileHandle,
|
|
NULL,
|
|
TRUE );
|
|
if (NULL == m_IMsgDotStuffedFileHandle)
|
|
{
|
|
SetDiagnosticInfo(AQUEUE_E_BIND_ERROR , NULL, NULL);
|
|
ErrorTrace((LPARAM) this, "Failed to get dot stuffed context");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//get the size of the file
|
|
DWORD dwSizeHigh;
|
|
m_FileSize = GetFileSizeFromContext( (m_IMsgDotStuffedFileHandle && !m_fUseBDAT) ? m_IMsgDotStuffedFileHandle : m_IMsgFileHandle, &dwSizeHigh);
|
|
_ASSERT(dwSizeHigh == 0);
|
|
|
|
//if the server supports the size command
|
|
// give him the size of the file
|
|
if (IsOptionSet(SIZE_OPTION) && (m_SizeOptionSize > 0)) {
|
|
if ((m_FileSize != 0XFFFFFFFF) && (m_FileSize <= m_SizeOptionSize))
|
|
{
|
|
wsprintf(BodySize, " SIZE=%d", m_FileSize);
|
|
lstrcat(Options, BodySize);
|
|
}
|
|
else {
|
|
// SetLastError(SMTP_MSG_LARGER_THAN_SIZE);
|
|
DebugTrace((LPARAM) this, "(m_FileSize != 0XFFFFFFFF) && (m_FileSize <= m_SizeOptionSize) failed");
|
|
DebugTrace((LPARAM) this, "m_FileSize = %d, m_SizeOptionSize = %d - quiting", m_FileSize, m_SizeOptionSize );
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_COMPLETE_FAILURE;
|
|
|
|
//Fill in the response context buffer so as to generate the right response
|
|
// Get the error code
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_RESP_BAD_CMD;
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
(char *)SMTP_REMOTE_HOST_REJECTED_FOR_SIZE,
|
|
strlen(SMTP_REMOTE_HOST_REJECTED_FOR_SIZE),
|
|
NULL);
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
}
|
|
|
|
if (IsOptionSet(DSN_OPTION)) {
|
|
char RetDsnValue[200];
|
|
BOOL fDSNDisallowed = TRUE;
|
|
|
|
//Do we disallow DSN at domain level
|
|
if (m_MsgOptions & DOMAIN_INFO_DISABLE_DSN) {
|
|
DebugTrace((LPARAM) this, "We disable DSN for this domain");
|
|
} else if (QuerySmtpInstance()->AllowOutboundDSN()) {
|
|
fDSNDisallowed = FALSE;
|
|
}
|
|
|
|
lstrcpy(RetDsnValue, " RET=");
|
|
hr = m_pIMsg->GetStringA(IMMPID_MP_DSN_RET_VALUE, sizeof(RetDsnValue) - lstrlen(RetDsnValue), RetDsnValue + lstrlen(RetDsnValue));
|
|
if (!FAILED(hr) && !fDSNDisallowed) {
|
|
lstrcat(Options, RetDsnValue);
|
|
}
|
|
|
|
lstrcpy(RetDsnValue, " ENVID=");
|
|
hr = m_pIMsg->GetStringA(IMMPID_MP_DSN_ENVID_VALUE, sizeof(RetDsnValue) - lstrlen(RetDsnValue), RetDsnValue + lstrlen(RetDsnValue));
|
|
if (!FAILED(hr) && !fDSNDisallowed) {
|
|
lstrcat(Options, RetDsnValue);
|
|
}
|
|
}
|
|
|
|
hr = m_pIMsg->GetStringA(IMMPID_MP_SENDER_ADDRESS_SMTP, sizeof(Address), Address);
|
|
if (!FAILED(hr)) {
|
|
//format the MAIL FROM command, with SIZE extension if necessary.
|
|
if ( (Address[0] == '<') && (Address[1] == '>'))
|
|
PE_FormatSmtpMessage("MAIL FROM:<>%s\r\n", Options);
|
|
else
|
|
PE_FormatSmtpMessage("MAIL FROM:<%s>%s\r\n", Address, Options);
|
|
} else {
|
|
DebugTrace((LPARAM) this, "Could not get Sender Address %x", hr);
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_COMPLETE_FAILURE;
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoMAILResponse
|
|
|
|
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_CONNOUT::DoMAILResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoMAILResponse");
|
|
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_SUCCESS;
|
|
|
|
char chInputGood = 0;
|
|
|
|
if ( isdigit( (UCHAR)InputLine[1] ) && isdigit( (UCHAR)InputLine[2] ) && ( ( InputLine[3] == ' ' ) || ( InputLine[3] == '-' ) ) ) {
|
|
chInputGood = InputLine[0];
|
|
} else {
|
|
chInputGood = SMTP_COMPLETE_FAILURE;
|
|
}
|
|
|
|
//the MAIL FROM: was rejected
|
|
if ( chInputGood != SMTP_COMPLETE_SUCCESS) {
|
|
// We expect either a 4xx or 5xx response. If it's 4xx we return
|
|
// a transient, all others will become a complete failure.
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "MAIL", InputLine);
|
|
if ( chInputGood == SMTP_TRANSIENT_FAILURE) {
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_TRANSIENT_FAILURE;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
} else {
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_COMPLETE_FAILURE;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
DebugTrace((LPARAM) this,
|
|
"SMTP_CONNOUT::DoMAILResponse executing quit command err = %c%c%c",
|
|
InputLine [0],InputLine [1],InputLine [2]);
|
|
}
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::AddRcptsDsns(DWORD NotifyOptions, char * OrcptVal, char * AddrBuf, int& AddrSize)
|
|
{
|
|
BOOL FirstOption = TRUE;
|
|
|
|
if (NotifyOptions & ~(RP_DSN_NOTIFY_NEVER | RP_DSN_NOTIFY_SUCCESS | RP_DSN_NOTIFY_FAILURE | RP_DSN_NOTIFY_DELAY)) {
|
|
NotifyOptions = 0;
|
|
}
|
|
|
|
if (NotifyOptions) {
|
|
lstrcat(AddrBuf, " NOTIFY=");
|
|
AddrSize += 8;
|
|
|
|
if (NotifyOptions & RP_DSN_NOTIFY_SUCCESS) {
|
|
lstrcat(AddrBuf, "SUCCESS");
|
|
AddrSize += 7;
|
|
FirstOption = FALSE;
|
|
}
|
|
|
|
if (NotifyOptions & RP_DSN_NOTIFY_FAILURE) {
|
|
if (!FirstOption) {
|
|
lstrcat(AddrBuf, ",");
|
|
AddrSize += 1;
|
|
}
|
|
|
|
lstrcat(AddrBuf, "FAILURE");
|
|
AddrSize += 7;
|
|
FirstOption = FALSE;
|
|
}
|
|
|
|
if (NotifyOptions & RP_DSN_NOTIFY_DELAY) {
|
|
if (!FirstOption) {
|
|
lstrcat(AddrBuf, ",");
|
|
AddrSize += 1;
|
|
}
|
|
|
|
lstrcat(AddrBuf, "DELAY");
|
|
AddrSize += 5;
|
|
FirstOption = FALSE;
|
|
}
|
|
|
|
if (FirstOption) {
|
|
lstrcat(AddrBuf, "NEVER");
|
|
AddrSize += 5;
|
|
}
|
|
}
|
|
|
|
if (*OrcptVal != '\0') {
|
|
lstrcat(AddrBuf, " ORCPT=");
|
|
AddrSize += 7;
|
|
|
|
lstrcat(AddrBuf, OrcptVal);
|
|
AddrSize += lstrlen(OrcptVal);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::SaveToErrorFile
|
|
|
|
Description:
|
|
|
|
This function saves all errors to
|
|
a file so the NDR thread can send
|
|
a transcript of what tranpired back
|
|
to the original user
|
|
|
|
Arguments:
|
|
|
|
Buffer with recipient data, size of buffer,
|
|
|
|
Returns:
|
|
|
|
TRUE if we were able to open and write to the file
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::SaveToErrorFile(char * Buffer, DWORD BufSize)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoRCPTCommand
|
|
|
|
Description:
|
|
|
|
This function sends the SMTP RCPT command.
|
|
Arguments:
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoRCPTCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
char AddrBuf [MAX_INTERNET_NAME + 2024];
|
|
char szRecipName[MAX_INTERNET_NAME];
|
|
char szOrcptVal[501];
|
|
BOOL fOrcptSpecified;
|
|
BOOL fFoundUnhandledRcpt = FALSE;
|
|
int AddrSize = 0;
|
|
HRESULT hr = S_OK;
|
|
DWORD NextAddress = 0;
|
|
|
|
_ASSERT(QuerySmtpInstance() != NULL);
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoRCPTCommand");
|
|
|
|
//MessageTrace((LPARAM) this, (LPBYTE) InputLine, ParameterSize);
|
|
|
|
// We report success
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_SUCCESS;
|
|
|
|
//format as much of the recipients that could fit into
|
|
//the output buffer
|
|
NextAddress = m_NextAddress;
|
|
while (NextAddress < m_NumRcpts) {
|
|
DWORD dwRecipientFlags = 0;
|
|
hr = m_pIMsgRecips->GetDWORD(m_RcptIndexList[NextAddress], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
if (FAILED(hr) && hr != MAILMSG_E_PROPNOTFOUND) {
|
|
//Problemmo
|
|
// Get property shouldn't fail since we've come this far
|
|
//_ASSERT(FALSE);
|
|
goto RcptError;
|
|
}
|
|
|
|
//NK** : I am moving this out as it breaks us when the first recipient is a handled recipient
|
|
// Default is pipelined
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_PIPELINED | EXPE_REPEAT_COMMAND;
|
|
|
|
//check to see if this recipient needs to be looked at
|
|
if ((dwRecipientFlags & RP_HANDLED) ) {
|
|
//This recipient can be skipped over
|
|
//Mark it inaccesible so that when we sweep the tried recipient
|
|
//in case of connection drop we do not touch the guys we did not send
|
|
//We need to get atleast one guy each time we come in.
|
|
m_RcptIndexList[NextAddress] = INVALID_RCPT_IDX_VALUE;
|
|
m_NextAddress = NextAddress + 1;
|
|
NextAddress ++;
|
|
continue;
|
|
} else {
|
|
hr = m_pIMsgRecips->GetStringA(m_RcptIndexList[NextAddress], IMMPID_RP_ADDRESS_SMTP, sizeof(szRecipName), szRecipName);
|
|
if (!FAILED(hr)) {
|
|
//Format the first recipient
|
|
AddrSize = wsprintf (AddrBuf, "RCPT TO:<%s>", szRecipName);
|
|
|
|
fOrcptSpecified = FALSE;
|
|
hr = m_pIMsgRecips->GetStringA(m_RcptIndexList[NextAddress], IMMPID_RP_DSN_ORCPT_VALUE, sizeof(szOrcptVal), szOrcptVal);
|
|
if (!FAILED(hr) && (szOrcptVal[0] != '\0')) {
|
|
fOrcptSpecified = TRUE;
|
|
|
|
} else if (FAILED(hr) && hr != MAILMSG_E_PROPNOTFOUND) {
|
|
//Problemmo
|
|
// Get property shouldn't fail since we've come this far
|
|
//_ASSERT(FALSE);
|
|
goto RcptError;
|
|
} else {
|
|
szOrcptVal[0] = '\0';
|
|
}
|
|
|
|
//If some DSN property is set then
|
|
if ((dwRecipientFlags & RP_DSN_NOTIFY_MASK) || fOrcptSpecified) {
|
|
BOOL fAllowDSN = FALSE;
|
|
|
|
//Do we disallow DSN at domain level
|
|
if (m_MsgOptions & DOMAIN_INFO_DISABLE_DSN) {
|
|
DebugTrace((LPARAM) this, "We disable DSN for this domain");
|
|
} else if (QuerySmtpInstance()->AllowOutboundDSN()) {
|
|
fAllowDSN = TRUE;
|
|
}
|
|
|
|
if (IsOptionSet(DSN_OPTION) && fAllowDSN) {
|
|
AddRcptsDsns(dwRecipientFlags, szOrcptVal, AddrBuf, AddrSize);
|
|
m_fNeedRelayedDSN = FALSE;
|
|
} else {
|
|
//let AQ know that the remote server did not advertise DSN
|
|
m_fNeedRelayedDSN = TRUE;
|
|
dwRecipientFlags |= RP_REMOTE_MTA_NO_DSN;
|
|
hr = m_pIMsgRecips->PutDWORD(m_RcptIndexList[NextAddress],
|
|
IMMPID_RP_RECIPIENT_FLAGS,dwRecipientFlags);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
goto RcptError;
|
|
}
|
|
}
|
|
}
|
|
|
|
lstrcat(AddrBuf, "\r\n");
|
|
AddrSize += 2;
|
|
|
|
if (PE_FormatSmtpMessage("%s", AddrBuf)) {
|
|
DebugTrace((LPARAM) this,"Sending %s", szRecipName);
|
|
m_NumRcptSent++;
|
|
m_NextAddress = NextAddress + 1;
|
|
|
|
if (!IsOptionSet(PIPELINE_OPTION))
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_NOT_PIPELINED;
|
|
} else {
|
|
//no more space in the buffer, send what we have;
|
|
//_ASSERT(FALSE);
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_NOT_PIPELINED;
|
|
return (TRUE);
|
|
}
|
|
} else {
|
|
//Problemmo
|
|
// Get property shouldn't fail since we've come this far
|
|
//_ASSERT(FALSE);
|
|
goto RcptError;
|
|
}
|
|
}
|
|
NextAddress ++;
|
|
break;
|
|
}
|
|
|
|
// If we are done, we will not pipeline further, this will save a loop
|
|
if (m_NumRcpts == NextAddress)
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_NOT_PIPELINED;
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
|
|
RcptError:
|
|
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_TRANSIENT_FAILURE;
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoRCPTResponse
|
|
|
|
Description:
|
|
|
|
This function handles the SMTP RCPT response.
|
|
Arguments:
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoRCPTResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD NextAddress = 0;
|
|
DWORD dwRecipientFlags;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoRCPTResponse");
|
|
|
|
_ASSERT(QuerySmtpInstance() != NULL);
|
|
|
|
//MessageTrace((LPARAM) this, (LPBYTE) InputLine, ParameterSize);
|
|
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_SUCCESS;
|
|
|
|
//start at the beginning of the last
|
|
//pipelined address
|
|
NextAddress = m_FirstPipelinedAddress;
|
|
|
|
DebugTrace((LPARAM)this, "Response: %*s", ParameterSize, InputLine);
|
|
|
|
//step through the returned recipients and check
|
|
//their error code.
|
|
if (m_NumRcptSent) {
|
|
//Get to the next rcpt that we send out this time
|
|
while ((NextAddress < m_NumRcpts) && (m_RcptIndexList[NextAddress] == INVALID_RCPT_IDX_VALUE))
|
|
NextAddress++;
|
|
|
|
_ASSERT(NextAddress < m_NumRcpts);
|
|
if (NextAddress >= m_NumRcpts) {
|
|
//Problemo
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
dwRecipientFlags = 0;
|
|
|
|
hr = m_pIMsgRecips->GetDWORD(m_RcptIndexList[NextAddress], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
|
|
if (FAILED(hr) && hr != MAILMSG_E_PROPNOTFOUND) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
m_NumRcptSent--;
|
|
|
|
//Once we get 552 Too many recipients error .. we do not bother to look at the real responses
|
|
//Logically they will all be 552 as well
|
|
if (m_SendAgain)
|
|
m_ResponseContext.m_dwSmtpStatus = SMTP_ACTION_ABORTED_CODE;
|
|
|
|
// If we have no response status code set, we will abort action
|
|
if (m_ResponseContext.m_dwSmtpStatus == 0) {
|
|
m_NumFailedAddrs++;
|
|
m_NumRcptSentSaved ++;
|
|
hr = m_pIMsgRecips->PutDWORD(m_RcptIndexList[NextAddress], IMMPID_RP_ERROR_CODE, SMTP_ACTION_ABORTED_CODE);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
//Create the temp error string
|
|
char sztemp[100];
|
|
sprintf(sztemp,"%d %s",SMTP_ACTION_ABORTED_CODE, "Invalid recipient response");
|
|
hr = m_pIMsgRecips->PutStringA(m_RcptIndexList[NextAddress], IMMPID_RP_SMTP_STATUS_STRING,sztemp);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
//real bad error. SCuttle this message
|
|
MessageTrace((LPARAM) this, (LPBYTE) InputLine, ParameterSize);
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_TRANSIENT_FAILURE;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "RCPT", InputLine);
|
|
return (TRUE);
|
|
} else {
|
|
//save the number of recipients sent so that
|
|
//we can compare this number to the number of
|
|
//failed recipients.
|
|
m_NumRcptSentSaved ++;
|
|
|
|
BUMP_COUNTER(QuerySmtpInstance(), NumRcptsSent);
|
|
|
|
// Save the error code (if there was an error)
|
|
// We do not want to save "250 OK" or "251 OK" responses because
|
|
// it wastes increases the memory footprint of messages in
|
|
// the queue
|
|
if ((SMTP_OK_CODE != m_ResponseContext.m_dwSmtpStatus) &&
|
|
(SMTP_USER_NOT_LOCAL_CODE != m_ResponseContext.m_dwSmtpStatus)) {
|
|
|
|
ErrorTrace((LPARAM)this,
|
|
"Saving rcpt error code %u - %s",
|
|
m_ResponseContext.m_dwSmtpStatus, InputLine);
|
|
|
|
hr = m_pIMsgRecips->PutDWORD(
|
|
m_RcptIndexList[NextAddress],
|
|
IMMPID_RP_ERROR_CODE,
|
|
m_ResponseContext.m_dwSmtpStatus);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
//Set the ful response as error string
|
|
hr = m_pIMsgRecips->PutStringA(m_RcptIndexList[NextAddress], IMMPID_RP_SMTP_STATUS_STRING, InputLine);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
} else {
|
|
//Recipient successful... trace it
|
|
DebugTrace((LPARAM) this,
|
|
"Recipient %d OK with response %s",
|
|
NextAddress, InputLine);
|
|
}
|
|
|
|
switch (m_ResponseContext.m_dwSmtpStatus) {
|
|
//4XX level code will lead to retry
|
|
case SMTP_ERROR_PROCESSING_CODE:
|
|
case SMTP_MBOX_BUSY_CODE:
|
|
case SMTP_SERVICE_UNAVAILABLE_CODE:
|
|
//Buffer[3] = ' '; put back the space character
|
|
m_fHadTempError = TRUE;
|
|
dwRecipientFlags |= (RP_ERROR_CONTEXT_MTA);
|
|
m_NumFailedAddrs++;
|
|
break;
|
|
|
|
case SMTP_ACTION_ABORTED_CODE:
|
|
//this means we sent too many recipients.
|
|
//set the m_SendAgain flag which tells us
|
|
//to send whatever we have now, then start
|
|
//sending to the other recipients afterwards.
|
|
//We have to switch the error code because 552
|
|
//means different things depending on what operation
|
|
//we are doing.
|
|
|
|
if (!m_SendAgain) {
|
|
if (m_fHadSuccessfulDelivery) {
|
|
m_NumFailedAddrs++;
|
|
m_SendAgain = TRUE;
|
|
|
|
if( m_NumFailedAddrs >= m_NumRcptSentSaved )
|
|
{
|
|
m_fHadHardError = TRUE;
|
|
}
|
|
|
|
if (m_First552Address == -1)
|
|
m_First552Address = NextAddress;
|
|
break;
|
|
}
|
|
} else {
|
|
m_NumFailedAddrs++;
|
|
break;
|
|
}
|
|
//A 552 response is treated as failure if we did not even send
|
|
//a single recipient
|
|
//fall thru
|
|
|
|
//5XX level codes will lead to NDR for the rcpt
|
|
case SMTP_UNRECOG_COMMAND_CODE:
|
|
case SMTP_SYNTAX_ERROR_CODE:
|
|
case SMTP_NOT_IMPLEMENTED_CODE:
|
|
case SMTP_BAD_SEQUENCE_CODE :
|
|
case SMTP_PARAM_NOT_IMPLEMENTED_CODE:
|
|
case SMTP_MBOX_NOTFOUND_CODE:
|
|
case SMTP_USERNOTLOCAL_CODE:
|
|
case SMTP_ACTION_NOT_TAKEN_CODE:
|
|
case SMTP_TRANSACT_FAILED_CODE:
|
|
|
|
// Buffer[3] = ' '; //put back the space character
|
|
//SaveToErrorFile(Buffer, IntermediateSize);
|
|
// DebugTrace((LPARAM) this, "User %s failed because of %d", pwalk->GetAddress(), Error);
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "RCPT", InputLine);
|
|
m_fHadHardError = TRUE;
|
|
dwRecipientFlags |= (RP_FAILED | RP_ERROR_CONTEXT_MTA);
|
|
m_NumFailedAddrs++;
|
|
break;
|
|
case SMTP_OK_CODE:
|
|
case SMTP_USER_NOT_LOCAL_CODE:
|
|
m_fHadSuccessfulDelivery = TRUE;
|
|
BUMP_COUNTER(QuerySmtpInstance(), NumRcptsSent);
|
|
dwRecipientFlags |= (RP_DELIVERED | RP_ERROR_CONTEXT_MTA);
|
|
break;
|
|
case SMTP_SERVICE_CLOSE_CODE:
|
|
case SMTP_INSUFF_STORAGE_CODE:
|
|
//fall through. This is deliberate.
|
|
//we don't want to continue if we get
|
|
//these errors
|
|
default:
|
|
//real bad error. Copy this error to the
|
|
//front of the input buffer, because this
|
|
//buffer will be passed to DoCompletedMessage
|
|
//to do the right thing.
|
|
{
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "RCPT", InputLine);
|
|
char chInputGood = 0;
|
|
|
|
if ( isdigit( (UCHAR)InputLine[1] ) &&
|
|
isdigit( (UCHAR)InputLine[2] ) &&
|
|
( ( InputLine[3] == ' ' ) || ( InputLine[3] == '-' ) ) ) {
|
|
chInputGood = InputLine[0];
|
|
} else {
|
|
chInputGood = SMTP_COMPLETE_FAILURE;
|
|
}
|
|
|
|
|
|
MessageTrace((LPARAM) this, (LPBYTE) InputLine, ParameterSize);
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
if ( chInputGood == SMTP_TRANSIENT_FAILURE) {
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_TRANSIENT_FAILURE;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
} else {
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_COMPLETE_FAILURE;
|
|
m_OutboundContext.m_pCurrentCommandContext = NULL;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Set the flags back
|
|
hr = m_pIMsgRecips->PutDWORD(m_RcptIndexList[NextAddress], IMMPID_RP_RECIPIENT_FLAGS,dwRecipientFlags);
|
|
if (FAILED(hr)) {
|
|
//Problemmo
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
|
|
NextAddress++;
|
|
}
|
|
|
|
// Mark where we should pick up next time ...
|
|
m_FirstPipelinedAddress = NextAddress;
|
|
|
|
// No more unprocessed recipients, we are either done or we have to
|
|
// issue more RCPT commands
|
|
if ((NextAddress < m_NumRcpts) && !m_SendAgain)
|
|
m_ResponseContext.m_dwResponseStatus = EXPE_REPEAT_COMMAND;
|
|
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::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_CONNOUT::DoDATACommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
_ASSERT(QuerySmtpInstance() != NULL);
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoDATACommand");
|
|
|
|
SetNextState (&SMTP_CONNOUT::DoDATACommandEx);
|
|
|
|
FormatSmtpMessage(FSM_LOG_ALL, "DATA\r\n");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return SendSmtpResponse();
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoBDATCommand
|
|
|
|
Description:
|
|
|
|
Send out the SMTP BDAT 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_CONNOUT::DoBDATCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
_ASSERT(QuerySmtpInstance() != NULL);
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoBDATCommand");
|
|
|
|
SetNextState (&SMTP_CONNOUT::DoDATACommandEx);
|
|
|
|
//We send the whole mesage file as a single BDAT chunk
|
|
//Verify if the CHUNK size should be FileSize or +2 for trailing CRLF
|
|
//
|
|
FormatSmtpMessage(FSM_LOG_ALL, "BDAT %d LAST\r\n", m_FileSize);
|
|
if (!SendSmtpResponse()) {
|
|
//BDAT command failed for some reason
|
|
DebugTrace((LPARAM) this, "Failed to send BDAT command");
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return DoDATACommandEx(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoDATACommandEx
|
|
|
|
Description:
|
|
|
|
This funcion sends the message body to remote server
|
|
after the DATA or BDAT command
|
|
Arguments:
|
|
|
|
InputLine - Buffer received from remote Server
|
|
paramterSize - amount of data in buffer
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoDATACommandEx(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
LARGE_INTEGER LSize = {0,0};
|
|
BOOL fRet = TRUE;
|
|
HRESULT hr = S_OK;
|
|
char szResponse[] = "123";
|
|
LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoDATACommandEx");
|
|
|
|
//we need to receive a 354 from the server to go on in case of DATA command
|
|
// In case of BDAT, the remote server never responds and so ignore the input line
|
|
//
|
|
if (InputLine[0] == SMTP_INTERMEDIATE_SUCCESS || m_fUseBDAT) {
|
|
SetNextState (&SMTP_CONNOUT::DoContentResponse);
|
|
|
|
LSize.HighPart = 0;
|
|
LSize.LowPart = m_FileSize;
|
|
m_LastClientIo = SMTP_CONNOUT::TRANSFILEIO;
|
|
//use the trailer buffers only for DATA command
|
|
lpTransmitBuffers = (m_fUseBDAT) ? NULL : &m_TransmitBuffers;
|
|
|
|
fRet = TransmitFileEx ((!m_fUseBDAT && m_IMsgDotStuffedFileHandle) ? m_IMsgDotStuffedFileHandle->m_hFile : m_IMsgFileHandle->m_hFile,
|
|
LSize,
|
|
0,
|
|
lpTransmitBuffers);
|
|
if (!fRet) {
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "TranmitFile in DoDATACommandEx failed with error %d !!!!", m_Error);
|
|
DisconnectClient();
|
|
return FALSE;
|
|
}
|
|
|
|
//need to reset the ATQ timeout thread since we pended two
|
|
//I/Os back to back.
|
|
AtqContextSetInfo(QueryAtqContext(), ATQ_INFO_RESUME_IO, 0);
|
|
|
|
} else { //quit if we don't get the 354 response
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "DATA", InputLine);
|
|
ErrorTrace((LPARAM) this, "DoDATACommandEx executing quit command err = %c%c%c", InputLine [0],InputLine [1],InputLine [2]);
|
|
|
|
if (InputLine[0] == SMTP_COMPLETE_SUCCESS) {
|
|
CopyMemory(InputLine, "599", 3);
|
|
DebugTrace((LPARAM) this, "DoDATACommandEx executing quit command err = %c%c%c", InputLine [0],InputLine [1],InputLine [2]);
|
|
}
|
|
|
|
//DoCompletedMessage uses the m_ResponseContext to get the error
|
|
if ((ParameterSize > 3) &&
|
|
((InputLine[3] == ' ') || (InputLine[3] == CR))) {
|
|
//Try to get error from 3 digit code on input line
|
|
//In some cases (DoDataCommandEx), the m_ResponseContext is not
|
|
//used
|
|
memcpy(szResponse, InputLine, sizeof(szResponse)-sizeof(char));
|
|
m_ResponseContext.m_dwSmtpStatus = atoi(szResponse);
|
|
hr = m_ResponseContext.m_cabResponse.Append(
|
|
InputLine + sizeof(szResponse)/sizeof(char),
|
|
ParameterSize-sizeof(szResponse),
|
|
NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
ErrorTrace((LPARAM) this,
|
|
"Unable to append Input line to Response Context", hr);
|
|
|
|
//Really nothing we can do about this... DoCompletedMailObj
|
|
//will send RSET and try again
|
|
}
|
|
}
|
|
|
|
fRet = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
|
|
//If DoCompletedMessage returns TRUE... then we must post a read for the
|
|
//response. Functions that call into this function expect it to handle
|
|
//the IO state if it returns TRUE.
|
|
if (fRet)
|
|
{
|
|
if (m_cbReceived >= m_cbMaxRecvBuffer)
|
|
m_cbReceived = 0;
|
|
|
|
IncPendingIoCount();
|
|
m_LastClientIo = SMTP_CONNOUT::READIO;
|
|
fRet = ReadFile(QueryMRcvBuffer() + m_cbReceived,
|
|
m_cbMaxRecvBuffer - m_cbReceived);
|
|
if (!fRet) {
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Error = GetLastError();
|
|
SetDiagnosticInfo(HRESULT_FROM_WIN32(m_Error), NULL, NULL);
|
|
DisconnectClient();
|
|
DecPendingIoCount();
|
|
DebugTrace((LPARAM) this, "ReadFile in DoDataCommandEx failed with error %d", m_Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoContentResponse
|
|
|
|
Description:
|
|
|
|
This function catches the final response after transmitting
|
|
the message content
|
|
|
|
Arguments:
|
|
|
|
InputLine - Buffer received from remote Server
|
|
paramterSize - amount of data in buffer
|
|
Returns:
|
|
|
|
TRUE if the connection should stay open.
|
|
FALSE if this object should be deleted.
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoContentResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoContentResponse");
|
|
|
|
//send again gets sent when we get a 552 error during the
|
|
//RCPT to command. This means that the server we connected
|
|
//to has a fixed max amount of rcpts that it accepts, and we
|
|
//went over that limit. Therefore, we send the mail file to
|
|
//the recipients that it accepted and then start over sending
|
|
//the mail to the remaining recipients. However, before doing
|
|
//this, check the response to see if the server took the previous
|
|
//mail O.K.
|
|
if (m_SendAgain) {
|
|
m_cbReceived = 0;
|
|
m_OutputBufferSize = 0;
|
|
m_Error = NO_ERROR;
|
|
m_NumRcptSent = 0;
|
|
m_NumRcptSentSaved = 0;
|
|
m_NumFailedAddrs = 0;
|
|
|
|
//NK** : I am moving this down as the check below seems
|
|
//meaningless with this in here
|
|
//m_SendAgain = FALSE;
|
|
m_FirstRcpt = FALSE;
|
|
|
|
_ASSERT(m_First552Address != -1);
|
|
|
|
//NK** : I am not sure what we are trying to do here by setting pipelined addr to 552addr.
|
|
//I am going to leave this in - but also assign this value to NextAddr which decides
|
|
//from where we should really start
|
|
m_FirstPipelinedAddress = (DWORD) m_First552Address;
|
|
m_NextAddress = (DWORD) m_First552Address;
|
|
m_FirstAddressinCurrentMail = (DWORD) m_First552Address;
|
|
|
|
m_First552Address = -1;
|
|
|
|
m_TransmitTailBuffer[0] = '.';
|
|
m_TransmitTailBuffer[1] = '\r';
|
|
m_TransmitTailBuffer[2] = '\n';
|
|
|
|
m_TransmitBuffers.Head = NULL;
|
|
m_TransmitBuffers.HeadLength = 0;
|
|
m_TransmitBuffers.Tail = m_TransmitTailBuffer;
|
|
m_TransmitBuffers.TailLength = 3;
|
|
|
|
BUMP_COUNTER(QuerySmtpInstance(), NumMsgsSent);
|
|
|
|
//reset the file pointer to the beginning
|
|
if (SetFilePointer(m_IMsgDotStuffedFileHandle ? m_IMsgDotStuffedFileHandle->m_hFile: m_IMsgFileHandle->m_hFile, 0, NULL, FILE_BEGIN) == 0xFFFFFFFF)
|
|
{
|
|
m_Error = GetLastError();
|
|
DebugTrace((LPARAM) this, "SetFilePointer failed--err = %d", m_Error);
|
|
m_SendAgain = FALSE;
|
|
} else if (InputLine [0] != SMTP_COMPLETE_SUCCESS) {
|
|
//something went wrong before, so let's quit
|
|
DebugTrace((LPARAM) this,
|
|
"SMTP_CONNOUT::DoMAILCommand executing quit command err = %c%c%c",
|
|
InputLine [0],InputLine [1],InputLine [2]);
|
|
m_SendAgain = FALSE;
|
|
}
|
|
}
|
|
|
|
// Note the if clause above might change this flag so a simple
|
|
// else won't cut it
|
|
if (!m_SendAgain) {
|
|
fRet = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else {
|
|
m_SendAgain = FALSE;
|
|
fRet = DoMessageStartEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (fRet);
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::TransmitFileEx (HANDLE hFile, LARGE_INTEGER &liSize,
|
|
DWORD Offset, LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers)
|
|
|
|
{
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::TransmitFileEx");
|
|
|
|
BOOL fRet;
|
|
|
|
_ASSERT(hFile != INVALID_HANDLE_VALUE);
|
|
_ASSERT(liSize.QuadPart > 0);
|
|
|
|
QueryAtqContext()->Overlapped.Offset = Offset;
|
|
|
|
if (!m_SecurePort) {
|
|
DebugTrace((LPARAM) this, "Calling AtqTransmitFile");
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
|
|
IncPendingIoCount();
|
|
|
|
fRet = AtqTransmitFile(
|
|
QueryAtqContext(), // Atq context
|
|
hFile, // file data comes fro
|
|
liSize.LowPart, // Bytes To Send
|
|
lpTransmitBuffers, // header/tail buffers
|
|
0
|
|
);
|
|
|
|
if (!fRet) {
|
|
DecPendingIoCount();
|
|
}
|
|
|
|
return ( fRet );
|
|
|
|
} else {
|
|
|
|
//
|
|
// If we are connected over an SSL port, we cannot use TransmitFile,
|
|
// since the data has to be encrypted first.
|
|
//
|
|
|
|
DebugTrace((LPARAM)this, "Doing async reads and writes on handle %x", hFile);
|
|
|
|
DebugTrace( (DWORD_PTR)this, "hfile %x", hFile );
|
|
|
|
//
|
|
// Send the transmit buffer header synchronously
|
|
//
|
|
|
|
fRet = TRUE;
|
|
|
|
//We have no headers or Trailers if we are doing BDAT processing
|
|
if (lpTransmitBuffers && m_TransmitBuffers.HeadLength > 0) {
|
|
m_OutputBufferSize = m_cbMaxOutputBuffer;
|
|
|
|
//NimishK : We look for Head length and then send Tail
|
|
//Dosn't seem right.
|
|
fRet = m_encryptCtx.SealMessage(
|
|
(LPBYTE) m_TransmitBuffers.Tail,
|
|
m_TransmitBuffers.TailLength,
|
|
(LPBYTE) m_pOutputBuffer,
|
|
&m_OutputBufferSize);
|
|
|
|
if (fRet)
|
|
fRet = WriteFile(m_pOutputBuffer, m_OutputBufferSize);
|
|
else
|
|
SetLastError(AQUEUE_E_SSL_ERROR);
|
|
}
|
|
|
|
if (fRet) {
|
|
//
|
|
// issue the first async read against the file
|
|
//
|
|
m_dwFileOffset = 0;
|
|
m_bComplete = FALSE;
|
|
|
|
if ( MessageReadFile() ) {
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// WriteFile\MessageReadFile will teardown the connection on errors
|
|
//
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Name:
|
|
SMTP_CONNOUT::MessageReadFile
|
|
|
|
Description:
|
|
When TransmitFile cannot be used to transfer a message (for example,
|
|
when using SSL), the message is transferred in chunks using
|
|
MessageReadFile to retrieve chunks of the file and issueing
|
|
corresponding asynchronous WriteFiles to the remote server.
|
|
|
|
Arguments:
|
|
None.
|
|
|
|
Returns:
|
|
TRUE if successfully read the next chunk of the file, FALSE otherwise
|
|
|
|
--*/
|
|
|
|
BOOL SMTP_CONNOUT::MessageReadFile( void )
|
|
{
|
|
TraceFunctEnterEx( (LPARAM)this, "SMTP_CONNOUT::MessageReadFile");
|
|
|
|
//
|
|
// Main line code path
|
|
//
|
|
CBuffer* pBuffer = new CBuffer();
|
|
if ( pBuffer != NULL ) {
|
|
LPBYTE lpData = pBuffer->GetData();
|
|
if ( lpData != NULL ) {
|
|
DWORD cbBufSize = CIoBuffer::Pool.GetInstanceSize();
|
|
// we never want to make SSL data > 16k
|
|
if (cbBufSize > 16*1024) cbBufSize = 16*1024;
|
|
DWORD cb = cbBufSize -
|
|
m_encryptCtx.GetSealHeaderSize() -
|
|
m_encryptCtx.GetSealTrailerSize();
|
|
|
|
lpData += m_encryptCtx.GetSealHeaderSize();
|
|
|
|
cb = min( cb, m_FileSize - m_dwFileOffset );
|
|
|
|
//
|
|
// set buffer specific IO state
|
|
//
|
|
pBuffer->SetIoState( MESSAGE_READ );
|
|
pBuffer->SetSize( cb );
|
|
|
|
DebugTrace( (LPARAM)this, "ReadFile 0x%08X, len: %d, LPO: 0x%08X",
|
|
lpData,
|
|
cb,
|
|
&pBuffer->m_Overlapped.SeoOverlapped.Overlapped );
|
|
|
|
ZeroMemory( (void*)&pBuffer->m_Overlapped.SeoOverlapped, sizeof(OVERLAPPED) );
|
|
pBuffer->m_Overlapped.SeoOverlapped.Overlapped.Offset = m_dwFileOffset;
|
|
|
|
pBuffer->m_Overlapped.SeoOverlapped.Overlapped.pfnCompletion = FIOInternetCompletion;
|
|
pBuffer->m_Overlapped.SeoOverlapped.ThisPtr = this;
|
|
|
|
// pBuffer->m_Overlapped.m_pIoBuffer = (LPBYTE)InputLine;
|
|
|
|
//
|
|
// increment the overall pending io count for this session
|
|
//
|
|
IncPendingIoCount();
|
|
|
|
if ( FIOReadFile(m_IMsgDotStuffedFileHandle ? m_IMsgDotStuffedFileHandle : m_IMsgFileHandle,
|
|
lpData,
|
|
cb,
|
|
&pBuffer->m_Overlapped.SeoOverlapped.Overlapped ) == FALSE ) {
|
|
DecPendingIoCount();
|
|
ErrorTrace( (LPARAM)this, "AtqReadFile failed.");
|
|
} else {
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
}
|
|
}
|
|
delete pBuffer;
|
|
}
|
|
|
|
m_Error = GetLastError();
|
|
|
|
ErrorTrace( (LPARAM)this, "MessageReadFile failed. err: %d", m_Error );
|
|
DisconnectClient();
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::FreeAtqFileContext
|
|
|
|
Description :
|
|
Frees AtqContext associated with message files transfered using
|
|
async reads and writes.
|
|
|
|
Arguments :
|
|
None. Operates on m_pAtqFileContext
|
|
|
|
Returns :
|
|
Nothing
|
|
|
|
--*/
|
|
|
|
void SMTP_CONNOUT::FreeAtqFileContext( void )
|
|
{
|
|
PATQ_CONTEXT pAtq;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "SMTP_CONNOUT::FreeAtqFileContext");
|
|
|
|
#if 0
|
|
pAtq = (PATQ_CONTEXT)InterlockedExchangePointer( (PVOID *)&m_pAtqFileContext, (PVOID) NULL );
|
|
if ( pAtq != NULL ) {
|
|
DebugTrace((LPARAM) this, "Freeing AtqFileContext!");
|
|
pAtq->hAsyncIO = NULL;
|
|
AtqFreeContext( pAtq, FALSE );
|
|
}
|
|
#endif
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoCompletedMessage
|
|
|
|
Description:
|
|
|
|
Sends 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_CONNOUT::DoCompletedMessage(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
DWORD MsgStatus = 0;
|
|
DWORD Error = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoCompletedMessage");
|
|
|
|
//see if the response received has some bad code
|
|
if (InputLine[0] != SMTP_COMPLETE_SUCCESS) {
|
|
// NimishK :
|
|
//Assumption : If I get 5XX response that leads to DOQUIT it means something real bad happened.
|
|
//We will consider this as a permanent error and NDR all recipients
|
|
//If the code is 4XX we will Retry all recipients
|
|
if (InputLine[0] == SMTP_COMPLETE_FAILURE) {
|
|
MsgStatus = MESSAGE_STATUS_NDR_ALL | MESSAGE_STATUS_EXTENDED_STATUS_CODES;
|
|
} else {
|
|
MsgStatus = MESSAGE_STATUS_RETRY_ALL | MESSAGE_STATUS_EXTENDED_STATUS_CODES;
|
|
if (m_fHadHardError) {
|
|
MsgStatus |= MESSAGE_STATUS_CHECK_RECIPS;
|
|
}
|
|
}
|
|
if (m_ResponseContext.m_cabResponse.Length() > 1) {
|
|
InputLine = m_ResponseContext.m_cabResponse.Buffer();
|
|
ParameterSize = m_ResponseContext.m_cabResponse.Length();
|
|
Error = m_ResponseContext.m_dwSmtpStatus;
|
|
}
|
|
|
|
} else if (m_Error == NO_ERROR) {
|
|
//if the message was delivered successfully
|
|
//then bump up our counter
|
|
BUMP_COUNTER(QuerySmtpInstance(), NumMsgsSent);
|
|
|
|
if (!IsOptionSet(DSN_OPTION)) {
|
|
MsgStatus |= MESSAGE_STATUS_DSN_NOT_SUPPORTED;
|
|
}
|
|
|
|
//If we have generate DELAY DSN or NDR DSN we need to tell
|
|
//AQ to look at the recipients
|
|
if (m_fNeedRelayedDSN || m_fHadHardError) {
|
|
MsgStatus |= MESSAGE_STATUS_CHECK_RECIPS;
|
|
}
|
|
|
|
//If we had no failures we can set this special status for optimization
|
|
//if only error we had was a hard error - there is no reason to report anything
|
|
if (!m_fHadTempError && !m_fHadHardError )
|
|
MsgStatus |= MESSAGE_STATUS_ALL_DELIVERED;
|
|
else if (m_fHadTempError)
|
|
MsgStatus |= MESSAGE_STATUS_RETRY_ALL;
|
|
|
|
} else {
|
|
//The remote server did not have a problem, but we had internal
|
|
//problem
|
|
//NimishK : Add an extended Status
|
|
MsgStatus = MESSAGE_STATUS_RETRY_ALL;
|
|
}
|
|
|
|
//figure out what to do with the completed
|
|
//message(e.g. send to retryq, remoteq, badmail,
|
|
//etc.)
|
|
|
|
//Includes per recipient 4xx level errors
|
|
if (InputLine[0] == SMTP_TRANSIENT_FAILURE) {
|
|
//If we cannot connect to the next IpAddress, then ack the message as is
|
|
if (ConnectToNextIpAddress()) {
|
|
//$$REVIEW - mikeswa 9/11/98
|
|
//In this case we will attempt to connect to another IP address.
|
|
//Most of the state is reset at this point (except for recipient
|
|
//failures and status strings). What happens if we fail to connect?
|
|
//Do we:
|
|
// - Ack the message as RETRY (current implementation)
|
|
// - Attempt to ack the message with CHECK_RECIPS as well and
|
|
// let the per-recip flags be enought detail for the DSN code?
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
HandleCompletedMailObj(MsgStatus, InputLine, ParameterSize);
|
|
|
|
if ((Error == SMTP_SERVICE_UNAVAILABLE_CODE)
|
|
|| (Error == SMTP_INSUFF_STORAGE_CODE)|| (Error == SMTP_SERVICE_CLOSE_CODE)
|
|
|| QuerySmtpInstance()->IsShuttingDown()) {
|
|
//No point in continuing with other messages in this connection
|
|
//Set the connection ack status to DROPPED - AQ will look at my last
|
|
//Msg Ack and determine what to do with remaining messages
|
|
m_dwConnectionStatus = CONNECTION_STATUS_DROPPED;
|
|
m_Active = FALSE;
|
|
|
|
DebugTrace( (LPARAM)this, "got this error %u on response, calling DoSessionEndEvent", Error );
|
|
fRet = DoSessionEndEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else {
|
|
fRet = StartSession();
|
|
if (!fRet) {
|
|
//Set the connection Ack status
|
|
m_dwConnectionStatus = CONNECTION_STATUS_OK;
|
|
DebugTrace( (LPARAM)this, "StartSession failed, calling DoSessionEndEvent", Error );
|
|
fRet = DoSessionEndEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (fRet);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::DoQUITCommand
|
|
|
|
Description:
|
|
|
|
Just generates a QUIT command
|
|
|
|
Arguments:
|
|
Are ignored
|
|
Returns:
|
|
|
|
Always return FALSE
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::DoQUITCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoQUITCommand");
|
|
|
|
m_OutboundContext.m_dwCommandStatus = EXPE_SUCCESS;
|
|
|
|
fRet = PE_FormatSmtpMessage("QUIT\r\n");
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return (fRet);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::WaitForRSETResponse
|
|
|
|
Description:
|
|
Waits for the response to the quit command
|
|
|
|
Arguments:
|
|
Are ignored
|
|
|
|
Returns:
|
|
|
|
FALSE always
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::WaitForRSETResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::WaitForRSETResponse");
|
|
|
|
_ASSERT (QuerySmtpInstance() != NULL);
|
|
|
|
if (m_RsetReasonCode == BETWEEN_MSG)
|
|
fRet = DoMessageStartEvent(InputLine, ParameterSize, UndecryptedTailSize);
|
|
else if (m_RsetReasonCode == ALL_RCPTS_FAILED) {
|
|
DebugTrace( (LPARAM)this, "m_RsetReasonCode = ALL_RCPTS_FAILED calling DoCompletedMessage" );
|
|
|
|
//Check to see if all of the failures were hard (and not transient)
|
|
//If so, set the error code to '5' instead of '4'
|
|
if (!m_fHadTempError) { //no temp errors
|
|
_ASSERT(m_fHadHardError); //therefore all errors must have been 5xx
|
|
|
|
//Must have had as many failures as processed RCPT TO's
|
|
_ASSERT(m_NumFailedAddrs >= m_NumRcptSentSaved);
|
|
InputLine[0] = SMTP_COMPLETE_FAILURE;
|
|
} else {
|
|
InputLine[0] = SMTP_TRANSIENT_FAILURE;
|
|
}
|
|
fRet = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else if (m_RsetReasonCode == NO_RCPTS_SENT) {
|
|
DebugTrace( (LPARAM)this, "m_RsetReasonCode = NO_RCPTS_SENT calling DoCompletedMessage" );
|
|
InputLine[0] = '2';
|
|
fRet = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
} else if (m_RsetReasonCode == FATAL_ERROR) {
|
|
DebugTrace( (LPARAM)this, "m_RsetReasonCode = FATAL_ERROR calling DoCompletedMessage" );
|
|
//make sure the quit code does not think everything is O.K.
|
|
InputLine[0] = '4';
|
|
fRet = DoCompletedMessage(InputLine, ParameterSize, UndecryptedTailSize);
|
|
}
|
|
return (fRet);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::WaitForQuitResponse
|
|
|
|
Description:
|
|
Waits for the response to the quit command
|
|
|
|
Arguments:
|
|
Are ignored
|
|
|
|
Returns:
|
|
|
|
FALSE always
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::WaitForQuitResponse(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
_ASSERT (QuerySmtpInstance() != NULL);
|
|
DisconnectClient();
|
|
return (FALSE);
|
|
}
|
|
|
|
BOOL SMTP_CONNOUT::DoTURNCommand(char * InputLine, DWORD ParameterSize, DWORD UndecryptedTailSize)
|
|
{
|
|
CLIENT_CONN_PARAMS clientParams;
|
|
SMTP_CONNECTION * SmtpConnIn = NULL;
|
|
DWORD Error = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) this,"SMTP_CONNOUT::DoTURNCommand");
|
|
|
|
if (InputLine[0] != SMTP_COMPLETE_SUCCESS) {
|
|
SetDiagnosticInfo(AQUEUE_E_SMTP_PROTOCOL_ERROR, "TURN", InputLine);
|
|
FormatSmtpMessage(FSM_LOG_ALL, "QUIT\r\n");
|
|
SendSmtpResponse();
|
|
DisconnectClient();
|
|
return FALSE;
|
|
}
|
|
|
|
SOCKADDR_IN sockAddr;
|
|
int cbAddr = sizeof( sockAddr);
|
|
|
|
if ( getsockname((SOCKET) m_pAtqContext->hAsyncIO,
|
|
(struct sockaddr *) &sockAddr,
|
|
&cbAddr )) {
|
|
|
|
}
|
|
|
|
clientParams.sClient = (SOCKET) m_pAtqContext->hAsyncIO;
|
|
clientParams.pAtqContext = m_pAtqContext;
|
|
clientParams.pAddrLocal = (PSOCKADDR) NULL;
|
|
clientParams.pAddrRemote = (PSOCKADDR)&sockAddr;
|
|
clientParams.pvInitialBuff = NULL;
|
|
clientParams.cbInitialBuff = 0 ;
|
|
clientParams.pEndpoint = (PIIS_ENDPOINT)NULL;
|
|
|
|
QuerySmtpInstance()->Reference();
|
|
QuerySmtpInstance()->IncrementCurrentConnections();
|
|
|
|
SmtpConnIn = (SMTP_CONNECTION *) QuerySmtpInstance()->CreateNewConnection( &clientParams);
|
|
if (SmtpConnIn == NULL) {
|
|
Error = GetLastError();
|
|
SendSmtpResponse();
|
|
DisconnectClient();
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
//from here on, the smtpout class is responsible for
|
|
//cleaning up the AtqContext
|
|
m_DoCleanup = FALSE;
|
|
|
|
//copy the real domain we are connected to.
|
|
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_COMPLETION, (DWORD_PTR) InternetCompletion);
|
|
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_COMPLETION_CONTEXT, (DWORD_PTR) SmtpConnIn);
|
|
AtqContextSetInfo(m_pAtqContext, ATQ_INFO_TIMEOUT, QuerySmtpInstance()->GetRemoteTimeOut());
|
|
|
|
if (SmtpConnIn->StartSession()) {
|
|
|
|
}
|
|
|
|
return ( FALSE );
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
BOOL SMTP_CONNOUT::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_CONNOUT::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 :
|
|
char * IsLineCompleteBW
|
|
|
|
Description:
|
|
|
|
Looks for a CRLF starting at the back
|
|
of the buffer. This is from some Gibraltar
|
|
code.
|
|
|
|
Arguments:
|
|
|
|
pchRecv - The buffer to be scanned
|
|
cbRecvd - size of data in the buffer
|
|
Returns:
|
|
|
|
A pointer where the CR is if both CRLF is found,
|
|
or NULL
|
|
|
|
--*/
|
|
char * IsLineCompleteBW(IN OUT char * pchRecvd, IN DWORD cbRecvd, IN DWORD cbMaxRecvBuffer)
|
|
{
|
|
register int Loop;
|
|
|
|
_ASSERT( pchRecvd != NULL);
|
|
|
|
if (cbRecvd == 0)
|
|
return NULL;
|
|
|
|
if (cbRecvd > cbMaxRecvBuffer)
|
|
return NULL;
|
|
//
|
|
// Scan the entire buffer ( from back) looking for pattern <cr><lf>
|
|
//
|
|
for ( Loop = (int) (cbRecvd - 2); Loop >= 0; Loop-- ) {
|
|
//
|
|
// Check if consecutive characters are <cr> <lf>
|
|
//
|
|
|
|
if ( ( pchRecvd[Loop] == '\r') &&
|
|
( pchRecvd[Loop + 1]== '\n')) {
|
|
//return where the CR is in the buffer
|
|
return &pchRecvd[Loop];
|
|
}
|
|
|
|
} // for
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
/*++
|
|
|
|
Name :
|
|
SMTP_CONNOUT::PE_FormatSmtpMessage( IN const char * Format, ...)
|
|
|
|
Description:
|
|
This function operates likes sprintf, printf, etc. It
|
|
just places it's data in the native command output buffer.
|
|
|
|
Arguments:
|
|
Format - Data to place in the buffer
|
|
|
|
Returns:
|
|
|
|
|
|
--*/
|
|
BOOL SMTP_CONNOUT::PE_FormatSmtpMessage( IN const char * Format, ...)
|
|
{
|
|
int BytesWritten;
|
|
va_list arglist;
|
|
|
|
//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);
|
|
|
|
_ASSERT(m_OutboundContext.m_cabNativeCommand.Buffer());
|
|
BytesWritten = _vsnprintf(
|
|
(char *)m_OutboundContext.m_cabNativeCommand.Buffer(),
|
|
m_OutboundContext.m_cabNativeCommand.MaxLength(),
|
|
Format,
|
|
arglist);
|
|
va_end(arglist);
|
|
if (BytesWritten < 0)
|
|
return (FALSE);
|
|
|
|
m_OutboundContext.m_cabNativeCommand.SetLength(BytesWritten);
|
|
return (TRUE);
|
|
}
|
|
|
|
//---[ SMTP_CONNOUT::SetDiagnosticInfo ]---------------------------------------
|
|
//
|
|
//
|
|
// Description:
|
|
// Sets member diagnostic information that is later Ack'd back to AQueue
|
|
// Parameters:
|
|
// IN hrDiagnosticError Error code... if SUCCESS we thow away
|
|
// the rest of the information
|
|
// IN szDiagnosticVerb Constant String pointing to the SMTP
|
|
// verb that caused the failure or NULL
|
|
// if it was not a protocol failure.
|
|
// IN szDiagnosticResponse String that contains the remote
|
|
// servers response or NULL if the
|
|
// failure was not a protocol failure.
|
|
// Returns:
|
|
// -
|
|
// History:
|
|
// 2/18/99 - MikeSwa Created
|
|
// 7/12/99 - GPulla Modified
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void SMTP_CONNOUT::SetDiagnosticInfo(IN HRESULT hrDiagnosticError,
|
|
IN LPCSTR szDiagnosticVerb,
|
|
IN LPCSTR szDiagnosticResponse)
|
|
{
|
|
m_hrDiagnosticError = hrDiagnosticError;
|
|
m_szDiagnosticVerb = szDiagnosticVerb; //this should be a constant
|
|
|
|
ZeroMemory(&m_szDiagnosticResponse, sizeof(m_szDiagnosticResponse));
|
|
|
|
//Force terminating NULL
|
|
m_szDiagnosticResponse[sizeof(m_szDiagnosticResponse)-1] = '\0';
|
|
|
|
//Not an SMTP protocol failure
|
|
if(!szDiagnosticResponse) return;
|
|
|
|
//copy buffers
|
|
strncpy(m_szDiagnosticResponse, szDiagnosticResponse,
|
|
sizeof(m_szDiagnosticResponse)-1);
|
|
|
|
}
|
|
|
|
/************************ End of File ***********************/
|