2396 lines
78 KiB
C++
2396 lines
78 KiB
C++
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
remoteq.cxx
|
|
|
|
Abstract:
|
|
Implements a derivation of the generic queue
|
|
for internet mail delivery
|
|
|
|
Author:
|
|
|
|
Rohan Phillips ( Rohanp ) 24-JAN-1995
|
|
|
|
Project:
|
|
|
|
SMTP Server DLL
|
|
|
|
Functions Exported:
|
|
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
/************************************************************
|
|
* Include Headers
|
|
************************************************************/
|
|
#define INCL_INETSRV_INCS
|
|
#include "smtpinc.h"
|
|
#include "dropdir.hxx"
|
|
#include "remoteq.hxx"
|
|
#include "smtpout.hxx"
|
|
#include <cdns.h>
|
|
#include "smtpdns.hxx"
|
|
#define INVALID_RCPT_IDX_VALUE 0xFFFFFFFF
|
|
extern char * MyStrChr(char *Line, unsigned char Val, DWORD LineSize);
|
|
extern void DeleteDnsRec(PSMTPDNS_RECS pDnsRec);
|
|
extern CTcpRegIpList g_TcpRegIpList;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
#if 0
|
|
REMOTE_QUEUE::REMOTE_QUEUE(SMTP_SERVER_INSTANCE * pSmtpInst)
|
|
: PERSIST_QUEUE(pSmtpInst)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
DWORD g_dwFileCounter = 0;
|
|
|
|
#define MIN(a,b) ( (a) > (b) ? (b) : (a) )
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
/*++
|
|
|
|
Name :
|
|
REMOTE_QUEUE::ProcessQueueEvents
|
|
|
|
Description:
|
|
|
|
This function takes a pointer to a QUEUE_ENTRY,
|
|
which contains all the information needed to
|
|
deliver local mail, and delivers the mail to the
|
|
remote site.
|
|
|
|
Arguments:
|
|
|
|
a pointer to a QUEUE_ENTRY class
|
|
|
|
Returns:
|
|
|
|
|
|
--*/
|
|
BOOL REMOTE_QUEUE::ProcessQueueEvents(ISMTPConnection *pISMTPConnection)
|
|
{
|
|
DWORD Error = 0;
|
|
char * FileName = NULL;
|
|
DWORD IpAddress = 0;
|
|
DWORD TransmitOptions = 0;
|
|
HRESULT hr = S_OK;
|
|
BOOL AsyncConnectStarted = FALSE;
|
|
DomainInfo DomainParams;
|
|
char * ConnectedDomain = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "REMOTE_QUEUE::ProcessQueueEvents(PQUEUE_ENTRY pEntry)");
|
|
|
|
_ASSERT(pISMTPConnection != NULL);
|
|
|
|
ZeroMemory (&DomainParams, sizeof(DomainParams));
|
|
|
|
if(pISMTPConnection == NULL)
|
|
{
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
//leave quickly if we are shutting down
|
|
if(GetParentInst()->IsShuttingDown()
|
|
|| (GetParentInst()->QueryServerState( ) == MD_SERVER_STATE_STOPPED)
|
|
|| (GetParentInst()->QueryServerState( ) == MD_SERVER_STATE_INVALID))
|
|
{
|
|
HandleFailedConnection(pISMTPConnection);
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return FALSE;
|
|
}
|
|
|
|
ZeroMemory(&DomainParams, sizeof(DomainParams));
|
|
DomainParams.cbVersion = sizeof(DomainParams);
|
|
hr = pISMTPConnection->GetDomainInfo(&DomainParams);
|
|
if(!FAILED(hr))
|
|
{
|
|
if(DomainParams.dwDomainInfoFlags & DOMAIN_INFO_LOCAL_DROP)
|
|
{
|
|
AsyncCopyMailToDropDir(pISMTPConnection, DomainParams.szDropDirectory, GetParentInst());
|
|
pISMTPConnection->Release();
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return TRUE;
|
|
}
|
|
|
|
ConnectedDomain = DomainParams.szDomainName;
|
|
|
|
if(DomainParams.szSmartHostDomainName != NULL)
|
|
{
|
|
ConnectedDomain = DomainParams.szSmartHostDomainName;
|
|
}
|
|
|
|
AsyncConnectStarted = StartAsyncConnect( (const char *)ConnectedDomain,
|
|
pISMTPConnection,
|
|
DomainParams.dwDomainInfoFlags,
|
|
GetParentInst()->UseSmartHostAfterFail());
|
|
if(AsyncConnectStarted)
|
|
{
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
HandleFailedConnection(pISMTPConnection);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Name :
|
|
void HandleFailedConnection (PMAIL_ENTRY MailQEntry)
|
|
|
|
Description:
|
|
|
|
This function takes a pointer to a PMAIL_ENTRY,
|
|
and either places it in the retry queue or the
|
|
bad mail directory.
|
|
|
|
Arguments:
|
|
|
|
a pointer to a PMAIL_ENTRY class
|
|
dwConnectionStatus... the status passed back to AQ
|
|
dwConnectedIPAddress IP Adress string (passed back to AQ)
|
|
|
|
|
|
11/11/98 - MikeSwa Added dwConnectionStatus
|
|
11/29/2001 - MikeSwa Added dwConnectedIPAddress
|
|
|
|
--*/
|
|
void REMOTE_QUEUE::HandleFailedConnection (ISMTPConnection *pISMTPConnection,
|
|
DWORD dwConnectionStatus,
|
|
DWORD dwConnectedIPAddress)
|
|
{
|
|
HRESULT hrConnectionFailure = AQUEUE_E_HOST_NOT_RESPONDING;
|
|
if(pISMTPConnection != NULL)
|
|
{
|
|
//We know the connection failed... lets add some additional diagnostic
|
|
//information
|
|
if (CONNECTION_STATUS_FAILED_LOOPBACK == dwConnectionStatus)
|
|
hrConnectionFailure = AQUEUE_E_LOOPBACK_DETECTED;
|
|
|
|
pISMTPConnection->SetDiagnosticInfo(hrConnectionFailure, NULL, NULL);
|
|
pISMTPConnection->AckConnection(dwConnectionStatus);
|
|
|
|
if (dwConnectedIPAddress)
|
|
ReportConnectedIPAddress(pISMTPConnection, dwConnectedIPAddress);
|
|
|
|
pISMTPConnection->Release();
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Name :
|
|
void ReportConnectedIPAddress
|
|
|
|
Description:
|
|
|
|
Reports IP address that the protocol attempted to connect to back
|
|
to Queuing.
|
|
|
|
Arguments:
|
|
ISMTPConnection AQ connection object
|
|
dwConnectedIPAddress IP Adress string (passed back to AQ)
|
|
|
|
11/29/2001 - MikeSwa Created
|
|
|
|
--*/
|
|
void REMOTE_QUEUE::ReportConnectedIPAddress(ISMTPConnection *pISMTPConnection,
|
|
DWORD dwConnectedIPAddress)
|
|
{
|
|
CHAR szConnectedIPAddress[46] = "";
|
|
DWORD IPAddress = dwConnectedIPAddress;
|
|
CMailMsgPropertyBag SessionPropertyBag;
|
|
|
|
if (!IPAddress || !pISMTPConnection)
|
|
return;
|
|
|
|
//
|
|
// Convert connected IP address to string form
|
|
//
|
|
szConnectedIPAddress[sizeof(szConnectedIPAddress) - 1] = '\0';
|
|
InetNtoa(*(struct in_addr *) &IPAddress,
|
|
(CHAR *) &szConnectedIPAddress);
|
|
|
|
_ASSERT(strlen(szConnectedIPAddress) < sizeof(szConnectedIPAddress));
|
|
|
|
if (szConnectedIPAddress[0])
|
|
{
|
|
SessionPropertyBag.PutStringA(ISESSION_PID_REMOTE_IP_ADDRESS,
|
|
szConnectedIPAddress);
|
|
|
|
SMTP_CONNOUT::PromoteSessionPropertiesToAQ(
|
|
(IUnknown *) ((IMailMsgPropertyBag *) &SessionPropertyBag),
|
|
pISMTPConnection);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
DWORD QueueDeleteFunction(PVOID ThisPtr)
|
|
{
|
|
CAsyncMx * ThisQueue = (CAsyncMx *) ThisPtr;
|
|
|
|
if(ThisQueue)
|
|
{
|
|
delete ThisQueue;
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// QueueCallBackFunction :
|
|
//
|
|
//Return TRUE - when we want the asyncmx object to be kept around
|
|
//Return FALSE - to delete the object when the thread exits
|
|
//
|
|
|
|
BOOL QueueCallBackFunction(PVOID ThisPtr, BOOLEAN fTimedOut)
|
|
{
|
|
CAsyncMx * ThisQueue = (CAsyncMx *) ThisPtr;
|
|
REMOTE_QUEUE * pRemoteQ = NULL;
|
|
BOOL fSuccessfullConnect = TRUE;
|
|
BOOL fAtqConnect = TRUE;
|
|
char * NextMxPtr = NULL;
|
|
SMTPDNS_RECS * pDnsRec = NULL;
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD = NULL;
|
|
char szSmartHost[MAX_PATH + 1];
|
|
char Scratch[256];
|
|
DWORD Error = 0;
|
|
DWORD dwFailedConnectionStatus = CONNECTION_STATUS_FAILED;
|
|
int NumRecords = 0;
|
|
DWORD IpAddress = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) ThisQueue, "QueueCallBackFunction");
|
|
|
|
Scratch[0] = '\0';
|
|
|
|
if(ThisQueue->GetParentInst()->IsShuttingDown())
|
|
{
|
|
//takes care of the case where we are shutting down, but
|
|
//a successful connection came in at the same time
|
|
ThisQueue->SetCloseSocketFlag(TRUE);
|
|
ThisQueue->CloseAsyncSocket();
|
|
ThisQueue->AckMessage();
|
|
pRemoteQ = (REMOTE_QUEUE *) ThisQueue->GetParentInst()->QueryRemoteQObj();
|
|
_ASSERT(pRemoteQ != NULL);
|
|
pRemoteQ->HandleFailedConnection(ThisQueue->GetSmtpConnectionObj());
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!ThisQueue->GetDnsRec())
|
|
{
|
|
//See bug X5:120720 - This means that another thread has called back
|
|
//on this object. The call to OnConnect below will AV. We do not
|
|
//have a repro scenario for this, and see if only once every few
|
|
//months. MilanS has recommended this non-intrusive check to
|
|
//add additional protection against a double callback
|
|
_ASSERT(0 && "Multiple threads calling back on CAsyncMx");
|
|
|
|
//Return TRUE because first thread will handle deleting object
|
|
return TRUE;
|
|
}
|
|
|
|
//get a pointer to the remote queue
|
|
pRemoteQ = (REMOTE_QUEUE *) ThisQueue->GetParentInst()->QueryRemoteQObj();
|
|
_ASSERT(pRemoteQ != NULL);
|
|
|
|
IpAddress = ThisQueue->GetConnectedIpAddress();
|
|
InetNtoa(*(struct in_addr *) &IpAddress, Scratch);
|
|
|
|
//See if the connect was successful
|
|
fSuccessfullConnect = ThisQueue->AsyncConnectSuccessfull();
|
|
|
|
//Call record the state of this connection
|
|
ThisQueue->OnConnect(fSuccessfullConnect);
|
|
|
|
//Test the connect value
|
|
if(fSuccessfullConnect)
|
|
{
|
|
DebugTrace((LPARAM)ThisQueue, "QueueCallBack called with successful connect!");
|
|
|
|
pDnsRec = ThisQueue->GetDnsRec();
|
|
pDNS_RESOLVER_RECORD = ThisQueue->GetDnsResolverRecord();
|
|
ThisQueue->SetDnsRecToNull();
|
|
ThisQueue->SetDnsResolverRecord(NULL);
|
|
|
|
|
|
fAtqConnect = pRemoteQ->MakeATQConnection( pDnsRec,
|
|
ThisQueue->GetSockethandle(),
|
|
ThisQueue->GetConnectedIpAddress(),
|
|
ThisQueue->GetSmtpConnectionObj(),
|
|
ThisQueue->GetDomainOptions(),
|
|
ThisQueue->GetSSLVerificationName(),
|
|
pDNS_RESOLVER_RECORD);
|
|
if(!fAtqConnect)
|
|
{
|
|
ErrorTrace((LPARAM)ThisQueue, "FAILED pRemoteQ->MakeATQConnection!!!");
|
|
|
|
ThisQueue->AckMessage();
|
|
|
|
if (ThisQueue->WasLoopback())
|
|
dwFailedConnectionStatus = CONNECTION_STATUS_FAILED_LOOPBACK;
|
|
|
|
pRemoteQ->HandleFailedConnection(ThisQueue->GetSmtpConnectionObj(),
|
|
dwFailedConnectionStatus,
|
|
ThisQueue->GetConnectedIpAddress());
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return FALSE;
|
|
|
|
} else if (ThisQueue->WasLoopback()) {
|
|
|
|
dwFailedConnectionStatus = CONNECTION_STATUS_FAILED_LOOPBACK;
|
|
ThisQueue->GetSmtpConnectionObj()->SetDiagnosticInfo(AQUEUE_E_LOOPBACK_DETECTED, NULL, NULL);
|
|
|
|
//
|
|
// Make sure we have the IP address for diagnostic purposes
|
|
//
|
|
pRemoteQ->ReportConnectedIPAddress(ThisQueue->GetSmtpConnectionObj(),
|
|
ThisQueue->GetConnectedIpAddress());
|
|
}
|
|
|
|
ErrorTrace((LPARAM)ThisPtr,"connection to %s failed", Scratch);
|
|
|
|
BUMP_COUNTER (ThisQueue->GetParentInst(), NumConnOutRefused);
|
|
|
|
IpAddress = ThisQueue->GetNextIpAddress();
|
|
|
|
//
|
|
// A connect will cause QueueCallBack to be called again through a
|
|
// completion event posted on FD_CONNECT. On each call to ConnectToHost
|
|
// we try a new IP address till all the IP addresses for this MX host
|
|
// are exhausted.
|
|
//
|
|
if((IpAddress != INADDR_NONE) && ThisQueue->ConnectToHost(IpAddress))
|
|
{
|
|
DebugTrace((LPARAM)ThisQueue, "Connecting to MX host: %08x", IpAddress);
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return TRUE;
|
|
}
|
|
|
|
ThisQueue->CloseAsyncSocket();
|
|
|
|
DebugTrace((LPARAM) ThisQueue, "Ran out of IP addresses for MX host");
|
|
//
|
|
// If we failed to connect to any of the IP addresses for the (current)
|
|
// MX host, try connecting to the next MX host for this destination.
|
|
//
|
|
while(!ThisQueue->GetParentInst()->IsShuttingDown())
|
|
{
|
|
if(ThisQueue->ConnectToNextMxHost())
|
|
{
|
|
DebugTrace((LPARAM)ThisQueue, "Trying ConnectToNextMxHost");
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
Error = GetLastError();
|
|
ThisQueue->CloseAsyncSocket();
|
|
if(Error == ERROR_NO_MORE_ITEMS)
|
|
{
|
|
DebugTrace((LPARAM)ThisQueue, "Failed ConnectToNextMxHost with ERROR_NO_MORE_ITEMS");
|
|
}
|
|
else
|
|
{
|
|
ErrorTrace((LPARAM)ThisQueue, "Failed ConnectToNextMxHost: Host not responding");
|
|
ThisQueue->GetSmtpConnectionObj()->SetDiagnosticInfo(AQUEUE_E_HOST_NOT_RESPONDING, NULL, NULL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
ThisQueue->CloseAsyncSocket();
|
|
DebugTrace((LPARAM)ThisQueue, "Ran out of MX hosts for destination. Trying new destination.");
|
|
|
|
//
|
|
// If we failed to connect to any MX host for the destination server
|
|
// we need to try an alternate destination. ConnectToNextResolverHost
|
|
// uses the DNS_RESOLVER_RECORD (member of CAsyncMx *ThisQueue) to get
|
|
// the name of an alternative host and resolve it (get the MX records
|
|
// for it).
|
|
//
|
|
while(!ThisQueue->GetParentInst()->IsShuttingDown())
|
|
{
|
|
if(pRemoteQ->ConnectToNextResolverHost( ThisQueue ))
|
|
{
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
Error = GetLastError();
|
|
ThisQueue->CloseAsyncSocket();
|
|
if(Error == ERROR_NO_MORE_ITEMS)
|
|
{
|
|
DebugTrace((LPARAM)ThisQueue, "Failed ConnectToNextResolverHost : ERROR_NO_MORE_ITEMS");
|
|
}
|
|
else
|
|
{
|
|
ErrorTrace((LPARAM)ThisQueue, "Failed ConnectToNextResolverHost. Error = %08x", Error);
|
|
ThisQueue->GetSmtpConnectionObj()->SetDiagnosticInfo(AQUEUE_E_DNS_FAILURE, NULL, NULL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
ThisQueue->CloseAsyncSocket();
|
|
|
|
|
|
|
|
|
|
//So we have tried all we could for the real destination
|
|
//check if we have a fallback smarthost and that we have not already tried it
|
|
if( pRemoteQ->GetParentInst()->UseSmartHostAfterFail() &&
|
|
pRemoteQ->GetParentInst()->GetSmartHost(szSmartHost) &&
|
|
!ThisQueue->GetTriedOnFailHost())
|
|
{
|
|
|
|
if(pRemoteQ->StartAsyncConnect(szSmartHost, ThisQueue->GetSmtpConnectionObj(), ThisQueue->GetDomainOptions(), FALSE))
|
|
{
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
ThisQueue->AckMessage();
|
|
|
|
pRemoteQ->HandleFailedConnection(ThisQueue->GetSmtpConnectionObj(),
|
|
dwFailedConnectionStatus,
|
|
ThisQueue->GetConnectedIpAddress());
|
|
|
|
TraceFunctLeaveEx((LPARAM) ThisPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
PSMTPDNS_RECS GetDnsRecordsFromHostFile(const char * HostName)
|
|
{
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
MXIPLIST_ENTRY * pEntry = NULL;
|
|
struct hostent *hp = NULL;
|
|
BOOL fRet = TRUE;
|
|
DWORD Error = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) NULL, "GetDnsRecordsFromHostFile");
|
|
|
|
DebugTrace((LPARAM)NULL,"Using gethostbyname for hostname resolution - %s", HostName);
|
|
|
|
hp = gethostbyname (HostName);
|
|
if(hp == NULL)
|
|
{
|
|
Error = WSAGetLastError();
|
|
ErrorTrace((LPARAM)NULL,"struct hostent *hp is NULL for %s - %x", HostName, Error);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pDnsRec = new SMTPDNS_RECS;
|
|
if(pDnsRec == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"pDnsRec = new SMTPDNS_RECS failed for %s", HostName);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
ZeroMemory(pDnsRec, sizeof(SMTPDNS_RECS));
|
|
|
|
pDnsRec->DnsArray[0] = new MX_NAMES;
|
|
if(pDnsRec->DnsArray[0] == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new MX_NAMES failed for %s", HostName);
|
|
delete pDnsRec;
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pDnsRec->NumRecords = 1;
|
|
pDnsRec->DnsArray[0]->NumEntries = 0;
|
|
|
|
InitializeListHead(&pDnsRec->DnsArray[0]->IpListHead);
|
|
lstrcpyn(pDnsRec->DnsArray[0]->DnsName, HostName, sizeof(pDnsRec->DnsArray[0]->DnsName));
|
|
|
|
for (DWORD Loop = 0; (hp->h_addr_list[Loop] != NULL); Loop++)
|
|
{
|
|
pEntry = new MXIPLIST_ENTRY;
|
|
if(pEntry != NULL)
|
|
{
|
|
pDnsRec->DnsArray[0]->NumEntries++;
|
|
CopyMemory(&pEntry->IpAddress, hp->h_addr_list[Loop], 4);
|
|
InsertTailList(&pDnsRec->DnsArray[0]->IpListHead, &pEntry->ListEntry);
|
|
}
|
|
else
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new MXIPLIST_ENTRY failed for %s", HostName);
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(fRet)
|
|
{
|
|
return pDnsRec;
|
|
}
|
|
else
|
|
{
|
|
DeleteDnsRec(pDnsRec);
|
|
pDnsRec = NULL;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return pDnsRec;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
PSMTPDNS_RECS GetDnsRecordsFromLiteral(const char * HostName)
|
|
{
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
MXIPLIST_ENTRY * pEntry = NULL;
|
|
BOOL fRet = TRUE;
|
|
DWORD Error = 0;
|
|
unsigned long InetAddr = 0;
|
|
char * pEndIp = NULL;
|
|
char * pRealHost = NULL;
|
|
char OldChar = '\0';
|
|
|
|
TraceFunctEnterEx((LPARAM) NULL, "GetDnsRecordsFromLiteral");
|
|
|
|
pRealHost = (char *) HostName;
|
|
|
|
//see if this is a domain literal
|
|
if(pRealHost[0] == '[')
|
|
{
|
|
pEndIp = strchr(pRealHost, ']');
|
|
if(pEndIp == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"Didn't find ] in literal for %s", HostName);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
//save the old character
|
|
OldChar = *pEndIp;
|
|
|
|
//null terminate the string
|
|
*pEndIp = '\0';
|
|
pRealHost++;
|
|
|
|
//Is this an ip address
|
|
InetAddr = inet_addr( (char *) pRealHost );
|
|
}
|
|
|
|
//put back the old character
|
|
if (pEndIp)
|
|
*pEndIp = OldChar;
|
|
|
|
if((InetAddr == INADDR_NONE) || (InetAddr == 0))
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"InetAddr is invalid for %s", HostName);
|
|
return NULL;
|
|
}
|
|
|
|
pDnsRec = new SMTPDNS_RECS;
|
|
if(pDnsRec == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new SMTPDNS_RECS2 failed for", HostName);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
ZeroMemory(pDnsRec, sizeof(SMTPDNS_RECS));
|
|
|
|
pDnsRec->DnsArray[0] = new MX_NAMES;
|
|
if(pDnsRec->DnsArray[0] == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new MX_NAMES2 failed for %s", HostName);
|
|
delete pDnsRec;
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pEntry = new MXIPLIST_ENTRY;
|
|
if(pEntry == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"MXIPLIST_ENTRY2 failed for %s", HostName);
|
|
DeleteDnsRec(pDnsRec);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pDnsRec->NumRecords = 1;
|
|
pDnsRec->DnsArray[0]->NumEntries = 1;
|
|
|
|
pEntry->IpAddress = InetAddr;
|
|
|
|
InitializeListHead(&pDnsRec->DnsArray[0]->IpListHead);
|
|
lstrcpyn(pDnsRec->DnsArray[0]->DnsName, HostName, sizeof(pDnsRec->DnsArray[0]->DnsName));
|
|
InsertTailList(&pDnsRec->DnsArray[0]->IpListHead, &pEntry->ListEntry);
|
|
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return pDnsRec;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
PSMTPDNS_RECS GetDnsRecordsFromResolverInfo(const char * HostName, DWORD dwAddr)
|
|
{
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
MXIPLIST_ENTRY * pEntry = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) NULL, "GetDnsRecordsFromResolverInfo");
|
|
|
|
|
|
pDnsRec = new SMTPDNS_RECS;
|
|
if(pDnsRec == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new SMTPDNS_RECS2 failed for", HostName);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
ZeroMemory(pDnsRec, sizeof(SMTPDNS_RECS));
|
|
|
|
pDnsRec->DnsArray[0] = new MX_NAMES;
|
|
if(pDnsRec->DnsArray[0] == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"new MX_NAMES2 failed for %s", HostName);
|
|
delete pDnsRec;
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pEntry = new MXIPLIST_ENTRY;
|
|
if(pEntry == NULL)
|
|
{
|
|
ErrorTrace((LPARAM)NULL,"MXIPLIST_ENTRY2 failed for %s", HostName);
|
|
DeleteDnsRec(pDnsRec);
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return NULL;
|
|
}
|
|
|
|
pDnsRec->NumRecords = 1;
|
|
pDnsRec->DnsArray[0]->NumEntries = 1;
|
|
|
|
pEntry->IpAddress = dwAddr;
|
|
|
|
InitializeListHead(&pDnsRec->DnsArray[0]->IpListHead);
|
|
lstrcpyn(pDnsRec->DnsArray[0]->DnsName, HostName, sizeof(pDnsRec->DnsArray[0]->DnsName));
|
|
InsertTailList(&pDnsRec->DnsArray[0]->IpListHead, &pEntry->ListEntry);
|
|
|
|
TraceFunctLeaveEx((LPARAM) NULL);
|
|
return pDnsRec;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Decription:
|
|
// This function is called when we have exhausted all the MX hosts for a
|
|
// particular destination server. The only option is to see if there are
|
|
// any alternative destinations to which the mail may be forwarded. A list
|
|
// of alternative hosts is maintained in the DNS resolver record (if it is
|
|
// available. So we need to kick off a resolve for the next alternate host
|
|
// if it exists.
|
|
// Arguments:
|
|
// Returns:
|
|
// History:
|
|
//-----------------------------------------------------------------------------
|
|
BOOL REMOTE_QUEUE::ConnectToNextResolverHost( CAsyncMx * pThisQ )
|
|
{
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD;
|
|
BOOL fRet;
|
|
|
|
// We embedded the resolver record into the MX records object
|
|
pDNS_RESOLVER_RECORD = pThisQ->GetDnsResolverRecord();
|
|
|
|
// We will handle deletion of pDNS_RESOLVER_RECORD from now on
|
|
pThisQ->SetDnsResolverRecord(NULL);
|
|
|
|
// No alternate hosts.
|
|
if(pDNS_RESOLVER_RECORD == NULL || pDNS_RESOLVER_RECORD->GetDnsResolverRecord() == NULL)
|
|
{
|
|
if(pDNS_RESOLVER_RECORD)
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
return( FALSE );
|
|
}
|
|
|
|
char MyFQDNName[MAX_PATH + 1];
|
|
|
|
GetParentInst()->LockGenCrit();
|
|
lstrcpyn(MyFQDNName,GetParentInst()->GetFQDomainName(),MAX_PATH);
|
|
GetParentInst()->UnLockGenCrit();
|
|
|
|
CrashOnInvalidSMTPConn(pThisQ->GetSmtpConnectionObj());
|
|
|
|
fRet = ConnectToResolverHost( pThisQ->GetSSLVerificationName(),
|
|
MyFQDNName,
|
|
pThisQ->GetSmtpConnectionObj(),
|
|
pThisQ->GetDomainOptions(),
|
|
FALSE,
|
|
pDNS_RESOLVER_RECORD,
|
|
pThisQ->GetDnsRec() );
|
|
return fRet;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Basically this function tries to resolve one of the hosts in the DNS
|
|
// resolver record (supplied by the sink) so that SMTP can send to that.
|
|
// To do this it is called repeatedly, and each time around it tries a
|
|
// different host till it succeeds in resolving it. If no DNS resolver
|
|
// record is available (NULL) we try to resolve the HostName directly.
|
|
// If DNS resolution is not needed --- ie if the resolution information
|
|
// is available locally or from the resolver record, then this function
|
|
// will kick off an async connect to the first MX host.
|
|
// Arguments:
|
|
// [IN] const char * HostName - Hostname to resolve
|
|
// [IN] LPSTR MyFQDNName -
|
|
// [IN] ISMTPConnection *pISMTPConnection -
|
|
// [IN] DWORD DomainOptions - Bitmask of options
|
|
// [IN] BOOL fUseSmartHostAfterFail -
|
|
// [IN] DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD - This object must always
|
|
// be associated with the current remote queue, till we succeed in
|
|
// connecting to the remote SMTP server. If this function fails,
|
|
// the DNS_RESOLVER_RECORD will be deleted. The caller no longer
|
|
// has responsibility for this after calling this function.
|
|
// [IN] PSMTP_DNSRECS pDnsRec - This is NULL unless the call to Connect...
|
|
// is a "failover call". It encapsulates the parameters for the failed
|
|
// message in such a case. These parameters are copied when an async
|
|
// connection/DNS-query are kicked off and will be acked by the async
|
|
// connect/DNS-query code. If this function succeeds, these parameters
|
|
// should not be acked by the caller and they are set to NULL by this
|
|
// function, within the pDnsRetryRec.
|
|
// Returns:
|
|
// TRUE on success.
|
|
// FALSE on all errors.
|
|
// History:
|
|
// GPulla modified.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL REMOTE_QUEUE::ConnectToResolverHost( const char * HostName,
|
|
LPSTR MyFQDNName,
|
|
ISMTPConnection *pISMTPConnection,
|
|
DWORD DomainOptions,
|
|
BOOL fUseSmartHostAfterFail,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD,
|
|
PSMTPDNS_RECS pDnsRetryRec )
|
|
{
|
|
DWORD dwAddr = 0;
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
BOOL fRet = FALSE;
|
|
BOOL fUseDns = TRUE;
|
|
BOOL fIsLiteral = FALSE;
|
|
DWORD dwDnsFlags = 0;
|
|
LPSTR pszRealHostName = NULL;
|
|
BOOL fFreeHostName = FALSE;
|
|
HRESULT hr = S_OK;
|
|
LPSTR pszSSLVerificationName = NULL;
|
|
BOOL fSSLSubjectDisabled = FALSE;
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "ConnectToResolverHost (const char * HostName)");
|
|
|
|
DebugTrace((LPARAM) this,"Finding MX records for %s with options %x", HostName, DomainOptions);
|
|
|
|
if (HostName)
|
|
{
|
|
fIsLiteral = (HostName[0] == '[');
|
|
}
|
|
|
|
if(GetParentInst()->UseGetHostByName() || fIsLiteral)
|
|
{
|
|
fUseDns = FALSE;
|
|
|
|
DebugTrace((LPARAM) this,"Not using DNS for resolution - literal, or GHBN");
|
|
}
|
|
else if(g_TcpRegIpList.GetCount() == 0)
|
|
{
|
|
fUseDns = FALSE;
|
|
|
|
DebugTrace((LPARAM) this,"Not using DNS for resolution - No DNS servers");
|
|
}
|
|
|
|
if (!(DomainOptions | MUST_DO_TLS) || !GetParentInst()->RequiresSSLCertVerifySubject())
|
|
fSSLSubjectDisabled = TRUE;
|
|
|
|
dwDnsFlags = GetParentInst()->GetDnsFlags();
|
|
|
|
pszRealHostName = (LPSTR)HostName;
|
|
|
|
//
|
|
// If there is a DNS resolver record from the DNS sink, retrieve the (next)
|
|
// possible destination host from it for resolution.
|
|
//
|
|
if( pDNS_RESOLVER_RECORD && pDNS_RESOLVER_RECORD->GetDnsResolverRecord() )
|
|
{
|
|
DWORD dwAddr = 0;
|
|
LPSTR pszTmpHostName = NULL;
|
|
|
|
DebugTrace((LPARAM) this, "Trying to get next host from DNS resolver record");
|
|
if( FAILED( hr = pDNS_RESOLVER_RECORD->HrGetNextDestinationHost(&pszTmpHostName, &dwAddr) ) )
|
|
{
|
|
if( HRESULT_FROM_WIN32( ERROR_NO_MORE_ITEMS ) != hr )
|
|
{
|
|
ErrorTrace((LPARAM) this,"m_pIDnsResolverRecord->GetItem() failed hr = 0x%x failed", hr);
|
|
}
|
|
else
|
|
{
|
|
DebugTrace((LPARAM) this, "Tried all possible destination hosts. Failing ConnectToResolverHost.\n");
|
|
SetLastError( ERROR_NO_MORE_ITEMS );
|
|
}
|
|
|
|
fRet = FALSE;
|
|
goto Exit;
|
|
}
|
|
else
|
|
{
|
|
fFreeHostName = TRUE;
|
|
pszRealHostName = pszTmpHostName;
|
|
DebugTrace((LPARAM) this, "ConnectToResolverHost trying destination host : %s", pszRealHostName);
|
|
|
|
if( dwAddr != 0 )
|
|
{
|
|
//
|
|
// this means we don't have to call DNS or GetHostByName to get the Ip addres
|
|
//
|
|
|
|
DebugTrace((LPARAM) this, "DNS records available, not calling DNS");
|
|
pDnsRec = GetDnsRecordsFromResolverInfo( pszRealHostName, dwAddr );
|
|
|
|
if(pDnsRec)
|
|
{
|
|
|
|
//
|
|
// This causes SMTP to successively try an connect to each of the MX hosts
|
|
// for the destination host in turn till a connection succeeds. pDnsRec has
|
|
// the MX hosts info.
|
|
//
|
|
DebugTrace((LPARAM) this, "Initializing async connect to MX hosts...");
|
|
|
|
if(pDnsRetryRec)
|
|
{
|
|
pDnsRec->pMailMsgObj = pDnsRetryRec->pMailMsgObj;
|
|
pDnsRec->pAdvQContext = pDnsRetryRec->pAdvQContext;
|
|
pDnsRec->pRcptIdxList = pDnsRetryRec->pRcptIdxList;
|
|
pDnsRec->dwNumRcpts = pDnsRetryRec->dwNumRcpts;
|
|
}
|
|
|
|
if (fSSLSubjectDisabled) {
|
|
|
|
pszSSLVerificationName = NULL;
|
|
|
|
} else if (ERROR_SUCCESS == DnsValidateName (HostName, DnsNameDomain)) {
|
|
|
|
DebugTrace ((LPARAM) this, "%s is a DNS name", HostName);
|
|
pszSSLVerificationName = (LPSTR) HostName;
|
|
|
|
} else {
|
|
|
|
DebugTrace ((LPARAM) this, "%s is not a DNS name", HostName);
|
|
pszSSLVerificationName = pszTmpHostName;
|
|
}
|
|
|
|
//
|
|
// if HostName is not a DNS name --- its a special name (like a
|
|
// GUID for an Exchange connector, and we need to use pszTmpHostName,
|
|
// the name returned by DNS sink as the SSL verification Name.
|
|
//
|
|
// if HostName is a DNS name --- the the DNS sink resolved it to an
|
|
// IP and pszTmpHostName was obtained by DNS indirection (MX record
|
|
// or CNAME record). This is insecure and cannot be used for SSL subject
|
|
// verification, so we use HostName instead.
|
|
//
|
|
fRet = BeginInitializeAsyncConnect(
|
|
pDnsRec,
|
|
pISMTPConnection,
|
|
DomainOptions,
|
|
pDNS_RESOLVER_RECORD,
|
|
pszSSLVerificationName);
|
|
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibillity to BeginInitializeAsyncConnect
|
|
|
|
if(!fRet)
|
|
{
|
|
ErrorTrace((LPARAM) this, "Failed BeginInitializeAsyncConnect.");
|
|
DeleteDnsRec(pDnsRec);
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree( pszRealHostName );
|
|
pszRealHostName = NULL;
|
|
goto Exit;
|
|
}
|
|
//
|
|
// else go thru DNS or gethostbyname to get the address
|
|
//
|
|
DebugTrace((LPARAM) this, "Querying DNS");
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
_ASSERT( HostName );
|
|
}
|
|
|
|
if(fUseDns)
|
|
{
|
|
DebugTrace((LPARAM) this, "ConnectToResolverHost querying DNS to resolve host: %s", pszRealHostName);
|
|
|
|
if (fSSLSubjectDisabled) {
|
|
|
|
pszSSLVerificationName = NULL;
|
|
|
|
} else {
|
|
|
|
pszSSLVerificationName = (LPSTR) pszRealHostName;
|
|
}
|
|
//
|
|
// Using DNS to resolve destination host.
|
|
//
|
|
fRet = BeginInitializeAsyncDnsQuery( pszRealHostName,
|
|
MyFQDNName,
|
|
pISMTPConnection,
|
|
dwDnsFlags,
|
|
DomainOptions,
|
|
fUseSmartHostAfterFail,
|
|
pDNS_RESOLVER_RECORD,
|
|
pszSSLVerificationName,
|
|
pDnsRetryRec );
|
|
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibility to BeginInitializeAsyncDnsQuery
|
|
DebugTrace((LPARAM) this, "BeginInitializeAsyncDnsQuery returned %s", fRet ? "TRUE" : "FALSE");
|
|
}
|
|
else
|
|
{
|
|
if(!fIsLiteral)
|
|
pDnsRec = GetDnsRecordsFromHostFile(HostName);
|
|
else
|
|
pDnsRec = GetDnsRecordsFromLiteral(HostName);
|
|
|
|
if(pDnsRec)
|
|
{
|
|
DebugTrace((LPARAM) this, "ConnectToResolverHost resolved %s locally", pszRealHostName);
|
|
|
|
//
|
|
// The target host (before DNS) to which this server is connecting to... used by SSL
|
|
// If this is a literal, pass in NULL, as there is no hostname
|
|
//
|
|
pszSSLVerificationName = NULL;
|
|
|
|
|
|
if (fSSLSubjectDisabled) {
|
|
|
|
pszSSLVerificationName = NULL;
|
|
|
|
} else if (fIsLiteral) {
|
|
|
|
pszSSLVerificationName = NULL;
|
|
|
|
} else {
|
|
|
|
pszSSLVerificationName = (LPSTR) HostName;
|
|
}
|
|
|
|
if(pDnsRetryRec)
|
|
{
|
|
pDnsRec->pMailMsgObj = pDnsRetryRec->pMailMsgObj;
|
|
pDnsRec->pAdvQContext = pDnsRetryRec->pAdvQContext;
|
|
pDnsRec->pRcptIdxList = pDnsRetryRec->pRcptIdxList;
|
|
pDnsRec->dwNumRcpts = pDnsRetryRec->dwNumRcpts;
|
|
}
|
|
|
|
fRet = BeginInitializeAsyncConnect(
|
|
pDnsRec,
|
|
pISMTPConnection,
|
|
DomainOptions,
|
|
pDNS_RESOLVER_RECORD,
|
|
pszSSLVerificationName);
|
|
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibility to BeginInitializeAsyncConnect
|
|
|
|
if(!fRet)
|
|
{
|
|
ErrorTrace((LPARAM) this, "Failed BeginInitializeAsyncConnect");
|
|
DeleteDnsRec(pDnsRec);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( fFreeHostName )
|
|
{
|
|
CoTaskMemFree( pszRealHostName );
|
|
}
|
|
|
|
Exit:
|
|
if(pDNS_RESOLVER_RECORD) // Non NULL => delete responsibility is still this function's
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
if(fRet && pDnsRetryRec && pDnsRetryRec->pMailMsgObj)
|
|
{
|
|
//
|
|
// Defensive: make sure caller doesn't mistakenly ack a failover message
|
|
// if this function has succeeded
|
|
//
|
|
|
|
pDnsRetryRec->pMailMsgObj = NULL;
|
|
pDnsRetryRec->pAdvQContext = NULL;
|
|
pDnsRetryRec->pRcptIdxList = NULL;
|
|
pDnsRetryRec->dwNumRcpts = 0;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Name :
|
|
StartAsyncConnect
|
|
|
|
Description:
|
|
|
|
This function either does a straight gethostbyname(),
|
|
or performs an MX record lookup to get the hostname/ip
|
|
address to connect to.
|
|
|
|
Arguments:
|
|
|
|
char * SmartHost - This is either an IP address,
|
|
or a hostname
|
|
|
|
Returns:
|
|
TRUE if an Async connection was started
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
BOOL REMOTE_QUEUE::StartAsyncConnect(
|
|
const char *HostName,
|
|
ISMTPConnection *pISMTPConnection,
|
|
DWORD DomainOptions,
|
|
BOOL fUseSmartHostAfterFail )
|
|
{
|
|
|
|
DWORD dwVirtualServerId = 0;
|
|
HRESULT hr = S_OK;
|
|
char MyFQDNName[MAX_PATH + 1];
|
|
BOOL fRet;
|
|
IDnsResolverRecord *pIDnsResolverRecord = NULL;
|
|
IDnsStatus *pIDnsStatus = NULL;
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD = NULL;
|
|
DNS_SERVER_INFO *pDnsServerInfo = NULL;
|
|
CTcpRegIpList *pTcpRegIpList = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "StartAysncConnect (const char * HostName)");
|
|
|
|
CrashOnInvalidSMTPConn(pISMTPConnection);
|
|
|
|
DebugTrace((LPARAM) this,"Finding MX records for %s with options %x", HostName, DomainOptions);
|
|
|
|
GetParentInst()->LockGenCrit();
|
|
lstrcpyn(MyFQDNName,GetParentInst()->GetFQDomainName(),MAX_PATH);
|
|
dwVirtualServerId = GetParentInst()->QueryInstanceId();
|
|
GetParentInst()->UnLockGenCrit();
|
|
|
|
//
|
|
// The DNS resolver event is fired every time we connect to a domain.
|
|
// It enables a sink to return information that modifies how we resolve
|
|
// or connect to the target host "HostName".
|
|
//
|
|
// Two pieces of information may be returned by the DNS sink:
|
|
//
|
|
// (1) pDnsServerInfo - Designed for use on a multihomed server which
|
|
// acts as a bridge relaying mail between different networks. The
|
|
// DNS sink determines if HostName is on a different network than
|
|
// the "default" network for SMTP. Target hosts in the default
|
|
// network are resolved using the default DNS servers on this box.
|
|
// The DNS sink may return an alternate set of DNS servers for hosts
|
|
// on a different network in pDnsServerInfo.
|
|
//
|
|
// (2) pIDnsResolverRecord - This is a list of <hostname, ipaddress>
|
|
// pairs. The DNS sink may return this to indicate that mail
|
|
// directed to "HostName" should instead be delivered to the
|
|
// hosts in pIDnsResolverRecord. If multiple records are returned
|
|
// in pIDnsResolverRecord we will use them for failover. The
|
|
// "ipaddress" portion may be missing for a given record in
|
|
// pIDnsResolverRecord, in which case, the "hostname" must be
|
|
// resolved by SMTP using the appropriate DNS servers.
|
|
//
|
|
|
|
GetParentInst()->TriggerDnsResolverEvent( (LPSTR)HostName,
|
|
MyFQDNName,
|
|
dwVirtualServerId,
|
|
&pDnsServerInfo,
|
|
&pIDnsResolverRecord );
|
|
|
|
if(pDnsServerInfo)
|
|
{
|
|
//
|
|
// Since we use our connection history with a DNS server for the
|
|
// purposes of our DNS server state tracking logic (CTcpRegIpList)
|
|
// we must remember the serverlist returned from pDnsServerInfo
|
|
// and tabulate the successes/failures for them. This means that
|
|
// the list is kept stored in SMTP_SERVER_INSTANCE and we constantly
|
|
// update the connection history as we try resolves against the
|
|
// servers.
|
|
//
|
|
// Since a DNS sink may return different lists of DNS servers for
|
|
// different networks, we need to differentiate between when the
|
|
// serverlist is being returned for a different network and the
|
|
// serverlist for a certain network has itself changed. For this
|
|
// reason, pDnsServerInfo also includes a GUID that uniquely
|
|
// identifies the network associated with the serverlist.
|
|
//
|
|
|
|
pTcpRegIpList = GetParentInst()->UpdateDnsServerInfo(pDnsServerInfo);
|
|
if(!pTcpRegIpList)
|
|
{
|
|
ErrorTrace((LPARAM)this, "Unable to update server info");
|
|
fRet = FALSE;
|
|
goto Exit;
|
|
}
|
|
|
|
pDNS_RESOLVER_RECORD = new DNS_RESOLVER_RECORD;
|
|
if(!pDNS_RESOLVER_RECORD)
|
|
{
|
|
ErrorTrace((LPARAM)this, "Out of memory creating DNS_RESOLVER_RECORD");
|
|
goto Exit;
|
|
}
|
|
|
|
pDNS_RESOLVER_RECORD->SetDnsList(pTcpRegIpList);
|
|
}
|
|
|
|
if(pIDnsResolverRecord)
|
|
{
|
|
//
|
|
// IDnsStatus is an optional interface exposed by the DNS resolver record
|
|
// object that contains additional information if something failed in the
|
|
// DNS resolver. If resolution fails, we use it to check if the failure is
|
|
// authoritative, and therefore we should NDR the messages.
|
|
//
|
|
|
|
hr = pIDnsResolverRecord->QueryInterface(IID_IDnsStatus, (PVOID *) &pIDnsStatus);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
DWORD dwAck = 0;
|
|
DWORD dwDiagnostic = 0;
|
|
|
|
hr = pIDnsStatus->GetDnsStatus();
|
|
if(HRESULT_FROM_WIN32(DNS_ERROR_RCODE_NAME_ERROR) == hr)
|
|
{
|
|
dwDiagnostic = AQUEUE_E_AUTHORITATIVE_HOST_NOT_FOUND;
|
|
dwAck = CONNECTION_STATUS_FAILED_NDR_UNDELIVERED;
|
|
}
|
|
else if(FAILED(hr))
|
|
{
|
|
dwDiagnostic = AQUEUE_E_HOST_NOT_FOUND;
|
|
dwAck = CONNECTION_STATUS_FAILED;
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
pISMTPConnection->SetDiagnosticInfo(dwDiagnostic, NULL, NULL);
|
|
pISMTPConnection->AckConnection(dwAck);
|
|
pISMTPConnection->Release();
|
|
|
|
fRet = TRUE;
|
|
pIDnsStatus->Release();
|
|
pIDnsResolverRecord->Release();
|
|
goto Exit;
|
|
}
|
|
pIDnsStatus->Release();
|
|
}
|
|
|
|
DebugTrace((LPARAM) this, "DNS resolver sink returned pIDnsResolverRecord");
|
|
|
|
if(!pDNS_RESOLVER_RECORD)
|
|
pDNS_RESOLVER_RECORD = new DNS_RESOLVER_RECORD;
|
|
|
|
if(!pDNS_RESOLVER_RECORD )
|
|
{
|
|
ErrorTrace((LPARAM) this, "Cannot allocate pDNS_RESOLVER_RECORD. Out of memory.");
|
|
pIDnsResolverRecord->Release();
|
|
fRet = FALSE;
|
|
goto Exit;
|
|
}
|
|
pDNS_RESOLVER_RECORD->SetDnsResolverRecord(pIDnsResolverRecord);
|
|
}
|
|
|
|
fRet = ConnectToResolverHost( HostName,
|
|
MyFQDNName,
|
|
pISMTPConnection,
|
|
DomainOptions,
|
|
fUseSmartHostAfterFail,
|
|
pDNS_RESOLVER_RECORD,
|
|
NULL );
|
|
|
|
pDNS_RESOLVER_RECORD = NULL;
|
|
|
|
Exit:
|
|
if(pDNS_RESOLVER_RECORD)
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
if(pDnsServerInfo)
|
|
CoTaskMemFree(pDnsServerInfo);
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Wrapper for DnsQueryAsync (exists only to BUMP REMOTE_QUEUE counters).
|
|
// Arguments:
|
|
// These are simply passed in to DnsQueryAsync... see documentation of
|
|
// DnsQueryAsync for details.
|
|
// Returns:
|
|
// TRUE if query was successfully started.
|
|
// FALSE on errors.
|
|
// History:
|
|
// GPulla modified.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL REMOTE_QUEUE::BeginInitializeAsyncDnsQuery( LPSTR pszHostName,
|
|
LPSTR pszFQDN,
|
|
ISMTPConnection *pISMTPConnection,
|
|
DWORD dwDnsFlags,
|
|
DWORD DomainOptions,
|
|
BOOL fUseSmartHostAfterFail,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD,
|
|
const char * pszSSLVerificationName,
|
|
PSMTPDNS_RECS pDnsRetryRec )
|
|
{
|
|
BOOL fRet = FALSE;
|
|
DWORD fUdp = TRUE;
|
|
RETRYPARAMS retryParams;
|
|
RETRYPARAMS *pRetryParams = NULL;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "REMOTE_QUEUE::BeginInitializeAsyncDnsQuery");
|
|
|
|
if(dwDnsFlags & DNS_FLAGS_TCP_ONLY)
|
|
fUdp = FALSE;
|
|
|
|
if(pDnsRetryRec) {
|
|
retryParams.m_pIMsg = (IMailMsgProperties *) pDnsRetryRec->pMailMsgObj;
|
|
retryParams.m_pAdvQContext = pDnsRetryRec->pAdvQContext;
|
|
retryParams.m_pRcptIdxList = (PDWORD) pDnsRetryRec->pRcptIdxList;
|
|
retryParams.m_dwNumRcpts = pDnsRetryRec->dwNumRcpts;
|
|
pRetryParams = &retryParams;
|
|
}
|
|
|
|
fRet = DnsQueryAsync(
|
|
GetParentInst(),
|
|
pszHostName,
|
|
pszFQDN,
|
|
pISMTPConnection,
|
|
dwDnsFlags,
|
|
DomainOptions,
|
|
fUseSmartHostAfterFail,
|
|
pDNS_RESOLVER_RECORD,
|
|
pszSSLVerificationName,
|
|
pRetryParams,
|
|
fUdp);
|
|
|
|
if(fRet)
|
|
BUMP_COUNTER(GetParentInst(), NumDnsQueries);
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return fRet;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Kicks off an async query to DNS to resolve pszHostName (ie get the MX
|
|
// records for it). When the query is complete, and the MX records have
|
|
// been retrieved, the completion thread will try to connect to the MX
|
|
// hosts by posting a callback to QueueCallBackFunction().
|
|
// Arguments:
|
|
// [IN] pServiceInstance - PTR to ISMTPServerInstance for this queue
|
|
//
|
|
// [IN] pszHostName - Host we're trying to lookup (this is copied over)
|
|
//
|
|
// [IN] pszFQDN - My FQDN (this is copied over)
|
|
//
|
|
// [IN] pISMTPConnection - Connection to ACK, get messages from. After
|
|
// this is passed in, this funtion will handle acking and releasing it
|
|
// if TRUE is returned. If FALSE is returned, the pISMTPConnection
|
|
// is not touched and the caller must ACK and release it.
|
|
//
|
|
// [IN] dwDnsFlags - DNS configuration flags.
|
|
//
|
|
// [IN] DomainOptions - Use SSL, Verify SSL cert, etc. Various outbound options.
|
|
//
|
|
// [IN] fUseSmartHostAfterFail - DUH
|
|
//
|
|
// [IN] DNS_RESOLVER_RECORD * - Set of possible next hop destinations
|
|
// returned by the DNS sink (may be NULL). If we fail DNS resolution
|
|
// for pszHostName (which is the first next hop in pDNS_RESOLVER_RECORD),
|
|
// the others are tried in turn. After this is passed in... this function
|
|
// handles deleting it (irrespective of whether TRUE or FALSE is returned).
|
|
//
|
|
// [IN] pszSSLVerificationName - Target host which we are trying to
|
|
// resolve/connect. Could be NULL if there isn't a target host (such as
|
|
// in the case of a literal IP address) (this is copied over).
|
|
//
|
|
// [IN] pRetryParams - On a failover path (i.e. if a temporary error occurred
|
|
// while delivering to an SMTP target, we will attempt delivery to an
|
|
// alternate host (like an alternate MX host). The failed message
|
|
// parameters are encapsulated in this.
|
|
//
|
|
// [IN] fUdp - Issue query over UDP or TCP?
|
|
//-----------------------------------------------------------------------------
|
|
BOOL DnsQueryAsync(
|
|
SMTP_SERVER_INSTANCE *pServiceInstance,
|
|
LPSTR pszHostName,
|
|
LPSTR pszFQDN,
|
|
ISMTPConnection *pISMTPConnection,
|
|
DWORD dwDnsFlags,
|
|
DWORD DomainOptions,
|
|
BOOL fUseSmartHostAfterFail,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD,
|
|
const char * pszSSLVerificationName,
|
|
RETRYPARAMS *pRetryParams,
|
|
BOOL fUdp)
|
|
{
|
|
PSMTPDNS_RECS pDnsRec = NULL;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
BOOL fRet = FALSE;
|
|
CTcpRegIpList *pDnsList = &g_TcpRegIpList;
|
|
BOOL fGlobalDnsList = TRUE;
|
|
|
|
TraceFunctEnterEx((LPARAM)NULL, "REMOTE_QUEUE::BeginInitializeAsyncDnsQuery");
|
|
|
|
CAsyncSmtpDns *pAsyncDns = new CAsyncSmtpDns(pServiceInstance, pISMTPConnection,
|
|
pRetryParams, pszFQDN);
|
|
|
|
if(!pAsyncDns)
|
|
{
|
|
DebugTrace((LPARAM) NULL, "Unable to allocate CAsyncSmtpDns object. Out of Memory");
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// From now on pAsyncDns will handle the deletion of pDNS_RESOLVER_RECORD and
|
|
// the pISmtpConnection ack... initiation of the async DNS query has succeeded
|
|
// as far as the caller is concerned.
|
|
//
|
|
fRet = TRUE;
|
|
|
|
pAsyncDns->SetDnsResolverRecord(pDNS_RESOLVER_RECORD);
|
|
|
|
//
|
|
// If the DNS sink specified an alternate set of servers to be used, set them
|
|
// on the async DNS object.
|
|
//
|
|
if(pDNS_RESOLVER_RECORD && pDNS_RESOLVER_RECORD->GetDnsList())
|
|
{
|
|
DebugTrace((LPARAM)NULL, "Using sink returned DNS list for %s", pszHostName);
|
|
pDnsList = pDNS_RESOLVER_RECORD->GetDnsList();
|
|
fGlobalDnsList = FALSE;
|
|
}
|
|
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibility to pAsyncDns object
|
|
pISMTPConnection = NULL; // Passed on delete responsibility to pAsyncDns object
|
|
|
|
pAsyncDns->SetDomainOptions(DomainOptions);
|
|
pAsyncDns->SetSmartHostOption(fUseSmartHostAfterFail);
|
|
|
|
if (!pAsyncDns->Init((LPSTR) pszSSLVerificationName))
|
|
{
|
|
delete pAsyncDns;
|
|
goto Exit;
|
|
}
|
|
|
|
DebugTrace((LPARAM) NULL, "Issuing DNS query for pAsyncDns = 0x%08x", pAsyncDns);
|
|
dwStatus = pAsyncDns->Dns_QueryLib(
|
|
pszHostName,
|
|
DNS_TYPE_MX,
|
|
dwDnsFlags,
|
|
fUdp,
|
|
pDnsList,
|
|
fGlobalDnsList);
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
ErrorTrace((LPARAM)NULL, "Failed to issue DNS query for pAsyncDns = 0x%08x", pAsyncDns);
|
|
delete pAsyncDns;
|
|
}
|
|
else
|
|
{
|
|
DebugTrace((LPARAM) NULL, "DNS query outstanding on object pAsyncDns = 0x%08x", pAsyncDns);
|
|
}
|
|
|
|
Exit:
|
|
if(pDNS_RESOLVER_RECORD) // Non NULL => delete responsibility is still this function's
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
TraceFunctLeaveEx((LPARAM)NULL);
|
|
return( fRet );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// This function kicks off a connection to the first of the MX hosts
|
|
// (from pDnsRec). It calls InitializeAsyncConnect() which will call
|
|
// back to QueueCallbackFunction() immediately.
|
|
// Arguments:
|
|
// Returns:
|
|
// History:
|
|
//-----------------------------------------------------------------------------
|
|
BOOL REMOTE_QUEUE::BeginInitializeAsyncConnect( PSMTPDNS_RECS pDnsRec,
|
|
ISMTPConnection *pISMTPConnection,
|
|
DWORD DomainOptions,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD,
|
|
const char *pszSSLVerificationName )
|
|
{
|
|
MXPARAMS Params;
|
|
BOOL fRet = FALSE;
|
|
CHAR szPostDnsSmartHost[IP_ADDRESS_STRING_LENGTH + 3];
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "REMOTE_QUEUE::BeginInitializeAsyncConnect");
|
|
|
|
//
|
|
// The post-DNS smart host is useful for testing DNS. It allows us
|
|
// to exercise the DNS resolution codepath and yet send to a smarthost.
|
|
// If a smarthost is specified, we will allocate a new TempList struct
|
|
// and fill it in with the IP address.
|
|
//
|
|
|
|
if(GetParentInst()->GetPostDnsSmartHost(
|
|
szPostDnsSmartHost, sizeof(szPostDnsSmartHost)))
|
|
|
|
{
|
|
DeleteDnsRec(pDnsRec);
|
|
|
|
// Note: Literal IP must be enclosed in brackets: []
|
|
pDnsRec = GetDnsRecordsFromLiteral(szPostDnsSmartHost);
|
|
if(!pDnsRec)
|
|
{
|
|
ErrorTrace((LPARAM) this, "Can't convert %s to IP", szPostDnsSmartHost);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
Params.HostName = pDnsRec->DnsArray[0]->DnsName;
|
|
Params.PortNum = GetParentInst()->GetRemoteSmtpPort();
|
|
Params.TimeOut = INFINITE;
|
|
Params.CallBack = QueueCallBackFunction;
|
|
Params.pISMTPConnection = pISMTPConnection;
|
|
Params.pInstance = GetParentInst();
|
|
Params.pDnsRec = pDnsRec;
|
|
Params.pDNS_RESOLVER_RECORD = pDNS_RESOLVER_RECORD;
|
|
|
|
CrashOnInvalidSMTPConn(pISMTPConnection);
|
|
|
|
CAsyncMx* pAsyncIo = new CAsyncMx (&Params);
|
|
|
|
if(pAsyncIo)
|
|
{
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibility to pAsyncIo
|
|
pAsyncIo->SetDomainOptions(DomainOptions);
|
|
|
|
if(!pAsyncIo->Init((LPSTR) pszSSLVerificationName))
|
|
{
|
|
delete pAsyncIo;
|
|
}
|
|
else if(!pAsyncIo->InitializeAsyncConnect())
|
|
{
|
|
delete pAsyncIo;
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
if(pDNS_RESOLVER_RECORD) // Non NULL => delete responsibility is still this function's
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
BOOL REMOTE_QUEUE::ReStartAsyncConnections(
|
|
SMTPDNS_RECS * pDnsRec,
|
|
ISMTPConnection * pISMTPConnection,
|
|
DWORD DomainOptions,
|
|
LPSTR pszSSLVerificationName,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD )
|
|
{
|
|
CAsyncMx * pAsyncIo = NULL;
|
|
MXPARAMS Params;
|
|
BOOL fRet = FALSE;
|
|
char szMyFQDNName[MAX_PATH + 1];
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "ReStartAsyncConnections");
|
|
|
|
//
|
|
// If we're out of MX records to connect to, check to see if there are
|
|
// alternate hosts (returned by the DNS sink in pDNS_RESOLVER_RECORD)
|
|
// Kick off a DNS resolve/connect to the next alternate host.
|
|
//
|
|
|
|
if(pDnsRec->StartRecord >= pDnsRec->NumRecords)
|
|
{
|
|
_ASSERT(pDNS_RESOLVER_RECORD && pDNS_RESOLVER_RECORD->GetDnsResolverRecord()
|
|
&& "Need more MX info or alternate hosts from DNS sink");
|
|
|
|
GetParentInst()->LockGenCrit();
|
|
lstrcpyn(szMyFQDNName,GetParentInst()->GetFQDomainName(),MAX_PATH);
|
|
GetParentInst()->UnLockGenCrit();
|
|
|
|
fRet = ConnectToResolverHost(
|
|
pszSSLVerificationName,
|
|
szMyFQDNName,
|
|
pISMTPConnection,
|
|
DomainOptions,
|
|
GetParentInst()->UseSmartHostAfterFail(),
|
|
pDNS_RESOLVER_RECORD,
|
|
pDnsRec);
|
|
|
|
if(!fRet)
|
|
ErrorTrace((LPARAM) this, "Failed connect to DNS sink returned host");
|
|
|
|
pDNS_RESOLVER_RECORD = NULL;
|
|
|
|
if(pDnsRec)
|
|
DeleteDnsRec(pDnsRec);
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// Connect to the next MX record in pDnsRec
|
|
//
|
|
Params.HostName = pDnsRec->DnsArray[pDnsRec->StartRecord]->DnsName;
|
|
Params.PortNum = GetParentInst()->GetRemoteSmtpPort();
|
|
Params.TimeOut = INFINITE;
|
|
Params.CallBack = QueueCallBackFunction;
|
|
Params.pISMTPConnection = pISMTPConnection;
|
|
Params.pInstance = GetParentInst();
|
|
Params.pDnsRec = pDnsRec;
|
|
Params.pDNS_RESOLVER_RECORD = pDNS_RESOLVER_RECORD;
|
|
|
|
pAsyncIo = new CAsyncMx (&Params);
|
|
if(pAsyncIo)
|
|
{
|
|
pDNS_RESOLVER_RECORD = NULL; // Passed on delete responsibility to pAsyncIo
|
|
if (!pAsyncIo->Init(pszSSLVerificationName))
|
|
{
|
|
ErrorTrace ((LPARAM) this, "pAsyncIo->Init() failed");
|
|
delete pAsyncIo;
|
|
goto Exit;
|
|
}
|
|
|
|
pAsyncIo->SetDomainOptions(DomainOptions);
|
|
|
|
if(!pAsyncIo->InitializeAsyncConnect())
|
|
{
|
|
ErrorTrace((LPARAM) this,"pAsyncIo->InitializeAsyncConnect()for %s failed", Params.HostName);
|
|
delete pAsyncIo;
|
|
}
|
|
else
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
Exit:
|
|
if(pDNS_RESOLVER_RECORD) // Non NULL => delete responsibility is still this function's
|
|
delete pDNS_RESOLVER_RECORD;
|
|
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return fRet;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
BOOL REMOTE_QUEUE::MakeATQConnection(
|
|
SMTPDNS_RECS* pDnsRec,
|
|
SOCKET Socket,
|
|
DWORD IpAddress,
|
|
ISMTPConnection* pISMTPConnection,
|
|
DWORD Options,
|
|
LPSTR pszSSLVerificationName,
|
|
DNS_RESOLVER_RECORD *pDNS_RESOLVER_RECORD)
|
|
{
|
|
sockaddr_in AddrRemote;
|
|
SMTP_CONNOUT * SmtpConn = NULL;
|
|
DWORD Error = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM) this, "REMOTE_QUEUE::MakeATQConnection");
|
|
|
|
_ASSERT (Socket != INVALID_SOCKET);
|
|
_ASSERT (GetParentInst() != NULL);
|
|
//_ASSERT (IpAddress != 0);
|
|
|
|
if(IpAddress == 0)
|
|
{
|
|
if(Socket != INVALID_SOCKET)
|
|
closesocket(Socket);
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
//set the remote IP address we connected to
|
|
AddrRemote.sin_addr.s_addr = IpAddress;
|
|
|
|
//create an outbound connection
|
|
SmtpConn = SMTP_CONNOUT::CreateSmtpConnection(
|
|
GetParentInst(),
|
|
Socket,
|
|
(SOCKADDR_IN *)&AddrRemote,
|
|
(SOCKADDR_IN *)&AddrRemote,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
Options,
|
|
pszSSLVerificationName,
|
|
pDNS_RESOLVER_RECORD);
|
|
if(SmtpConn == NULL)
|
|
{
|
|
Error = GetLastError();
|
|
pISMTPConnection->SetDiagnosticInfo(HRESULT_FROM_WIN32(Error), NULL, NULL);
|
|
closesocket(Socket);
|
|
DeleteDnsRec(pDnsRec);
|
|
delete pDNS_RESOLVER_RECORD;
|
|
FatalTrace((LPARAM) this, "SMTP_CONNOUT::CreateSmtpConnection failed, error =%i", Error);
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
SmtpConn->SetDnsRec(pDnsRec);
|
|
|
|
DebugTrace((LPARAM) this, "alloced SMTPOUT pointer %X", SmtpConn);
|
|
|
|
//add this connection object to the ATQ infrastructure
|
|
if(!SmtpConn->AddToAtqHandles((HANDLE)Socket, NULL, GetParentInst()->GetRemoteTimeOut(), InternetCompletion))
|
|
{
|
|
Error = GetLastError();
|
|
pISMTPConnection->SetDiagnosticInfo(HRESULT_FROM_WIN32(Error), NULL, NULL);
|
|
closesocket(Socket);
|
|
FatalTrace((LPARAM) this, "SmtpConn->AddToAtqHandles failed, error =%d", Error);
|
|
SmtpConn->SetConnectionStatus(CONNECTION_STATUS_FAILED);
|
|
delete SmtpConn;
|
|
SmtpConn = NULL;
|
|
SetLastError(Error);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
//insert the outbound connection object into
|
|
//our list of outbound conection objects
|
|
if(!GetParentInst()->InsertNewOutboundConnection(SmtpConn))
|
|
{
|
|
Error = GetLastError();
|
|
pISMTPConnection->SetDiagnosticInfo(HRESULT_FROM_WIN32(Error), NULL, NULL);
|
|
FatalTrace((LPARAM) this, "GetParentInst()->InsertNewOutboundConnection failed, error =%d", Error);
|
|
SmtpConn->DisconnectClient();
|
|
SmtpConn->SetConnectionStatus(CONNECTION_STATUS_FAILED);
|
|
delete SmtpConn;
|
|
SmtpConn = NULL;
|
|
SetLastError(Error);
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return FALSE;
|
|
}
|
|
|
|
SmtpConn->SetCurrentObject(pISMTPConnection);
|
|
|
|
//start session will pend a read to pick
|
|
//up the servers signon banner
|
|
if(!SmtpConn->StartSession())
|
|
{
|
|
//get the error
|
|
Error = GetLastError();
|
|
|
|
//SmtpConn->SetCurrentObjectToNull();
|
|
FatalTrace((LPARAM) this, "SmtpConn->StartSession failed, error =%d", Error);
|
|
SmtpConn->DisconnectClient();
|
|
GetParentInst()->RemoveOutboundConnection(SmtpConn);
|
|
|
|
//An empty queue at this point is really not an error
|
|
if (ERROR_EMPTY == Error)
|
|
SmtpConn->SetConnectionStatus(CONNECTION_STATUS_OK);
|
|
else
|
|
SmtpConn->SetConnectionStatus(CONNECTION_STATUS_FAILED);
|
|
|
|
delete SmtpConn;
|
|
SmtpConn = NULL;
|
|
SetLastError (Error);
|
|
|
|
//TraceFunctLeaveEx((LPARAM) this);
|
|
//return FALSE;
|
|
}
|
|
|
|
TraceFunctLeaveEx((LPARAM) this);
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
#define PRIVATE_OPTIMAL_BUFFER_SIZE 64 * 1024
|
|
#define PRIVATE_LINE_BUFFER_SIZE 1024
|
|
///////////////////////////////////////////////////////////////////////////
|
|
static BOOL CopyMessage(PFIO_CONTEXT hSrcFile, HANDLE hDstFile, HANDLE dwEventHandle)
|
|
{
|
|
CHAR acBuffer[PRIVATE_OPTIMAL_BUFFER_SIZE];
|
|
DWORD dwBytesRead;
|
|
DWORD dwBytesWritten;
|
|
DWORD dwTotalBytes = 0;
|
|
|
|
CHAR acCrLfDotCrLf[5] = { '\r', '\n', '.', '\r', '\n' };
|
|
CHAR acLastBytes[5] = { '\0', '\0', '\0', '\0', '\0' };
|
|
|
|
FH_OVERLAPPED Ov;
|
|
BOOL fResult = TRUE;
|
|
DWORD err = 0;
|
|
|
|
ZeroMemory (&Ov, sizeof(Ov));
|
|
Ov.hEvent = (HANDLE) ((ULONG_PTR) dwEventHandle | 1);
|
|
|
|
// Copies from the current file pointer to the end of hSrcFile
|
|
// and appends to the current file pointer of hDstFile.
|
|
_ASSERT(hSrcFile != NULL);
|
|
_ASSERT(hDstFile != INVALID_HANDLE_VALUE);
|
|
|
|
do
|
|
{
|
|
fResult = FIOReadFile(hSrcFile, acBuffer,
|
|
PRIVATE_OPTIMAL_BUFFER_SIZE,
|
|
&Ov);
|
|
|
|
// if this returned TRUE then we want to go down the path which calls
|
|
// GetOverlappedResult just so that we can get dwBytesRead.
|
|
if (fResult) err = ERROR_IO_PENDING;
|
|
else err = GetLastError();
|
|
|
|
if(err == ERROR_IO_PENDING)
|
|
{
|
|
if(GetOverlappedResult(dwEventHandle, (OVERLAPPED *) &Ov, &dwBytesRead, INFINITE))
|
|
{
|
|
Ov.Offset += dwBytesRead;
|
|
ResetEvent(dwEventHandle);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
//SmtpLogEventEx(SMTP_EVENT_CANNOT_WRITE_FILE, MailF
|
|
SetLastError (err); //preserve the last error
|
|
if(err == ERROR_HANDLE_EOF)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
if (dwBytesRead)
|
|
{
|
|
if (!WriteFile(hDstFile, acBuffer,
|
|
dwBytesRead,
|
|
&dwBytesWritten,
|
|
NULL))
|
|
return(FALSE);
|
|
|
|
// See if read equals written
|
|
if (dwBytesRead != dwBytesWritten)
|
|
return(FALSE);
|
|
}
|
|
else
|
|
{
|
|
dwBytesWritten = 0;
|
|
}
|
|
|
|
if (dwBytesWritten)
|
|
{
|
|
dwTotalBytes += dwBytesWritten;
|
|
|
|
// Save the last two bytes ever written
|
|
if (dwBytesWritten > 4)
|
|
{
|
|
CopyMemory(acLastBytes, &acBuffer[dwBytesWritten-5], 5);
|
|
}
|
|
else
|
|
{
|
|
MoveMemory(acLastBytes, &acLastBytes[dwBytesWritten], 5-dwBytesWritten);
|
|
CopyMemory(&acLastBytes[5-dwBytesWritten], acBuffer, dwBytesWritten);
|
|
}
|
|
}
|
|
|
|
} while (dwBytesRead);
|
|
|
|
// Now, see if the file ends with a CRLF, if not, add it
|
|
if ((dwTotalBytes > 1) && memcmp(&acLastBytes[3], &acCrLfDotCrLf[3], 2))
|
|
{
|
|
// Add the trailing CRLF
|
|
if (!WriteFile(hDstFile, acCrLfDotCrLf,
|
|
2,
|
|
&dwBytesWritten,
|
|
NULL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
if (dwBytesWritten != 2)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
dwTotalBytes+=2;
|
|
|
|
}
|
|
|
|
//If file ends with CRLF.CRLF, remove the trailing CRLF.CRLF
|
|
//R.P - On 1/12/98 we decided to remove the CRLF.CRLF because
|
|
//of a bug/feature in IMAP. POP3 will add the CRLF.CRLF when
|
|
//retrieving the mail.
|
|
if ((dwTotalBytes > 4) && !memcmp(acLastBytes, acCrLfDotCrLf, 5))
|
|
{
|
|
// Remove the trailing CRLF.CRLF
|
|
if ((SetFilePointer(hDstFile, -5, NULL, FILE_CURRENT) == 0xffffffff) ||
|
|
!SetEndOfFile(hDstFile))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Remove the trailing CRLF
|
|
if ((SetFilePointer(hDstFile, -2, NULL, FILE_CURRENT) == 0xffffffff) ||
|
|
!SetEndOfFile(hDstFile))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
BOOL CreateXHeaders(
|
|
IMailMsgProperties *pIMsg,
|
|
IMailMsgRecipients *pIMsgRecips ,
|
|
DWORD cRcpts,
|
|
DWORD *rgRcptIndex,
|
|
HANDLE hDrop)
|
|
{
|
|
TraceFunctEnter("CreateXHeaders");
|
|
|
|
#define X_SENDER_HEADER "x-sender: "
|
|
#define X_RECEIVER_HEADER "x-receiver: "
|
|
#define X_HEADER_EOLN "\r\n"
|
|
|
|
#define MAX_HEADER_SIZE (sizeof(X_RECEIVER_HEADER))
|
|
|
|
BOOL fRet = FALSE;
|
|
HRESULT hr;
|
|
DWORD i, cBytes;
|
|
BOOL fContinue = TRUE;
|
|
char szBuffer[
|
|
MAX_HEADER_SIZE +
|
|
MAX_INTERNET_NAME +
|
|
1 + 2 + 1]; // Closing ">", CRLF, and NULL
|
|
|
|
strcpy( szBuffer, X_SENDER_HEADER );
|
|
|
|
hr = pIMsg->GetStringA(
|
|
IMMPID_MP_SENDER_ADDRESS_SMTP,
|
|
MAX_INTERNET_NAME,
|
|
&szBuffer[ sizeof(X_SENDER_HEADER) - 1] );
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
strcat(szBuffer, X_HEADER_EOLN);
|
|
|
|
if (!WriteFile(hDrop, szBuffer, strlen(szBuffer), &cBytes, NULL) ) {
|
|
|
|
ErrorTrace(0, "Error %d writing x-sender line %s",
|
|
GetLastError(), szBuffer);
|
|
|
|
goto Cleanup;
|
|
|
|
} else {
|
|
|
|
_ASSERT( cBytes == strlen(szBuffer) );
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DebugTrace(0, "Could not get Sender Address %x", hr);
|
|
|
|
SetLastError( ERROR_INVALID_DATA );
|
|
|
|
goto Cleanup;
|
|
|
|
}
|
|
|
|
strcpy( szBuffer, X_RECEIVER_HEADER );
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < cRcpts && fContinue; i++)
|
|
{
|
|
|
|
DWORD dwRecipientFlags = 0;
|
|
hr = pIMsgRecips->GetDWORD(rgRcptIndex[i], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
if( RP_HANDLED != ( dwRecipientFlags & RP_HANDLED ) )
|
|
{
|
|
|
|
hr = pIMsgRecips->GetStringA(
|
|
rgRcptIndex[i],
|
|
IMMPID_RP_ADDRESS_SMTP,
|
|
MAX_INTERNET_NAME,
|
|
&szBuffer[ sizeof(X_RECEIVER_HEADER) - 1 ]);
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
|
|
strcat(szBuffer, X_HEADER_EOLN);
|
|
|
|
if (!WriteFile(hDrop, szBuffer, strlen(szBuffer), &cBytes, NULL)) {
|
|
|
|
ErrorTrace(0, "Error %d writing recipient x-header %s",
|
|
GetLastError(), szBuffer);
|
|
|
|
fContinue = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
SetLastError( ERROR_INVALID_DATA );
|
|
fContinue = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// If we got all recipients without error, we were successful
|
|
|
|
if (i == cRcpts)
|
|
fRet = TRUE;
|
|
|
|
|
|
|
|
Cleanup:
|
|
|
|
TraceFunctLeave();
|
|
|
|
return( fRet );
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
HANDLE REMOTE_QUEUE::CreateDropFile(const char * DropDir, char * szDropFile)
|
|
{
|
|
HANDLE FileHandle = INVALID_HANDLE_VALUE;
|
|
DWORD dwStrLen;
|
|
FILETIME ftTime;
|
|
DWORD Error = 0;
|
|
|
|
TraceFunctEnterEx((LPARAM)this, "REMOTE_QUEUE::CreateDropFile");
|
|
|
|
dwStrLen = lstrlen(DropDir);
|
|
lstrcpy(szDropFile, DropDir);
|
|
|
|
do
|
|
{
|
|
GetSystemTimeAsFileTime(&ftTime);
|
|
wsprintf(&szDropFile[dwStrLen],
|
|
"%08x%08x%08x%s",
|
|
ftTime.dwLowDateTime,
|
|
ftTime.dwHighDateTime,
|
|
InterlockedIncrement((PLONG)&g_dwFileCounter),
|
|
".eml");
|
|
|
|
FileHandle = CreateFile(szDropFile, GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_NEW,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL);
|
|
if (FileHandle != INVALID_HANDLE_VALUE)
|
|
break;
|
|
|
|
if((Error = GetLastError()) != ERROR_FILE_EXISTS)
|
|
{
|
|
TraceFunctLeaveEx((LPARAM)this);
|
|
return(INVALID_HANDLE_VALUE);
|
|
}
|
|
|
|
} while( (FileHandle == INVALID_HANDLE_VALUE) && !GetParentInst()->IsShuttingDown());
|
|
|
|
return FileHandle;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Name :
|
|
CopyMailToDropDir()
|
|
|
|
Description:
|
|
|
|
This function copies a spooled file to the drop directory
|
|
The drop file will be of the same name as the spooled file.
|
|
This funciton translates the sender and recipient informaiton
|
|
from the mail envelope into x-headers in the drop file.
|
|
Both the message file and the stream file are assumed to be
|
|
opened upstream.
|
|
|
|
Arguments:
|
|
|
|
PMAIL_ENTRY lpMailEntry - Queue entry of the spooled file
|
|
|
|
Returns:
|
|
|
|
TRUE if the message was written successfully to the drop dir.
|
|
FALSE in all other cases.
|
|
|
|
--*/
|
|
BOOL REMOTE_QUEUE::CopyMailToDropDir(ISMTPConnection *pISMTPConnection, const char * DropDirectory)
|
|
{
|
|
DWORD dwError = NO_ERROR;
|
|
DWORD dwBytesWritten = 0;
|
|
DWORD NumRcpts = 0;
|
|
HANDLE hDrop = INVALID_HANDLE_VALUE;
|
|
PFIO_CONTEXT hMail = NULL;
|
|
HRESULT hr = S_OK;
|
|
PVOID AdvContext = NULL;
|
|
DWORD *RcptIndexList = NULL;
|
|
IMailMsgProperties * pIMsg = NULL;
|
|
IMailMsgBind * pBindInterface = NULL;
|
|
BOOL fRet = FALSE;
|
|
MessageAck MsgAck;
|
|
HANDLE hFileReadEvent = NULL;
|
|
IMailMsgRecipients *pIMsgRecips = NULL;
|
|
char szDropFile[MAX_PATH +1];
|
|
|
|
TraceFunctEnterEx(NULL, "CopyMailToDropDir");
|
|
|
|
hFileReadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
if(hFileReadEvent == INVALID_HANDLE_VALUE)
|
|
{
|
|
ErrorTrace((LPARAM) this, "CreateEvent() failed for FileWriteFileEvent");
|
|
goto ErrorExit;
|
|
}
|
|
|
|
while (!GetParentInst()->IsShuttingDown())
|
|
{
|
|
|
|
pBindInterface = NULL;
|
|
AdvContext = NULL;
|
|
RcptIndexList = NULL;
|
|
pIMsg = NULL;
|
|
|
|
fRet = FALSE;
|
|
|
|
hr = pISMTPConnection->GetNextMessage(&pIMsg, (DWORD **)&AdvContext, &NumRcpts, &RcptIndexList);
|
|
if(FAILED(hr))
|
|
{
|
|
fRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( NumRcpts == 0 )
|
|
{
|
|
fRet = TRUE;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
hr = pIMsg->QueryInterface( IID_IMailMsgRecipients, (PVOID *) &pIMsgRecips);
|
|
if( FAILED( hr ) )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if( CheckIfAllRcptsHandled( pIMsgRecips, RcptIndexList, NumRcpts ) )
|
|
{
|
|
fRet = TRUE;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
|
|
hr = pIMsg->QueryInterface(IID_IMailMsgBind, (void **)&pBindInterface);
|
|
if(FAILED(hr))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
hr = pBindInterface->GetBinding(&hMail, NULL);
|
|
if(FAILED(hr))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
DebugTrace((LPARAM)NULL, "Dropping file to: %s", DropDirectory);
|
|
|
|
hDrop = CreateDropFile(DropDirectory, szDropFile);
|
|
if (hDrop == INVALID_HANDLE_VALUE)
|
|
{
|
|
dwError = GetLastError();
|
|
ErrorTrace(NULL, "Unable to create drop directory (%s) : %u",
|
|
DropDirectory,
|
|
dwError);
|
|
SetLastError(dwError);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
// Output the x-headers
|
|
|
|
if (!CreateXHeaders(pIMsg, pIMsgRecips, NumRcpts, RcptIndexList, hDrop)) {
|
|
dwError = GetLastError();
|
|
ErrorTrace(NULL, "Error %d while creating x-headers", dwError);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
ResetEvent(hFileReadEvent);
|
|
|
|
// Copy the mail file over
|
|
if (!CopyMessage(hMail, hDrop, hFileReadEvent))
|
|
{
|
|
dwError = GetLastError();
|
|
ErrorTrace(NULL, "Unable to copy mail file into drop directory : %u",
|
|
dwError);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
|
|
if( FAILED( hr = SetAllRcptsHandled( pIMsgRecips, RcptIndexList, NumRcpts ) ) )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
fRet = TRUE;
|
|
|
|
ErrorExit:
|
|
|
|
if( pIMsgRecips )
|
|
{
|
|
pIMsgRecips->Release();
|
|
pIMsgRecips = NULL;
|
|
}
|
|
if(pBindInterface)
|
|
{
|
|
pBindInterface->ReleaseContext();
|
|
pBindInterface->Release();
|
|
pBindInterface = NULL;
|
|
}
|
|
|
|
MsgAck.pIMailMsgProperties = pIMsg;
|
|
MsgAck.pvMsgContext = (DWORD *) AdvContext;
|
|
|
|
if(fRet)
|
|
{
|
|
MsgAck.dwMsgStatus = MESSAGE_STATUS_ALL_DELIVERED;
|
|
}
|
|
else
|
|
{
|
|
MsgAck.dwMsgStatus = MESSAGE_STATUS_RETRY_ALL;
|
|
}
|
|
|
|
MsgAck.dwStatusCode = 0;
|
|
pISMTPConnection->AckMessage(&MsgAck);
|
|
pIMsg->Release();
|
|
pIMsg = NULL;
|
|
|
|
if(hDrop != INVALID_HANDLE_VALUE)
|
|
{
|
|
_VERIFY(CloseHandle(hDrop));
|
|
hDrop = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if(fRet)
|
|
BUMP_COUNTER(GetParentInst(), DirectoryDrops);
|
|
|
|
}
|
|
|
|
if(fRet)
|
|
{
|
|
pISMTPConnection->AckConnection(CONNECTION_STATUS_OK);
|
|
}
|
|
else
|
|
{
|
|
DeleteFile(szDropFile);
|
|
SetLastError(dwError);
|
|
pISMTPConnection->AckConnection(CONNECTION_STATUS_FAILED);
|
|
}
|
|
|
|
if(hFileReadEvent != NULL)
|
|
{
|
|
CloseHandle(hFileReadEvent);
|
|
}
|
|
|
|
TraceFunctLeave();
|
|
return(fRet);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
BOOL REMOTE_QUEUE::CheckIfAllRcptsHandled(
|
|
IMailMsgRecipients *pIMsgRecips,
|
|
DWORD *RcptIndexList,
|
|
DWORD NumRcpts )
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
for( DWORD i = 0; i < NumRcpts; i++ )
|
|
{
|
|
if (RcptIndexList[i] != INVALID_RCPT_IDX_VALUE)
|
|
{
|
|
DWORD dwRecipientFlags = 0;
|
|
HRESULT hr = pIMsgRecips->GetDWORD(RcptIndexList[i], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
if (FAILED(hr))
|
|
{
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
if( RP_HANDLED != ( dwRecipientFlags & RP_HANDLED ) )
|
|
{
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return( fRet );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT REMOTE_QUEUE::SetAllRcptsHandled(
|
|
IMailMsgRecipients *pIMsgRecips,
|
|
DWORD *RcptIndexList,
|
|
DWORD NumRcpts )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
for( DWORD i = 0; i < NumRcpts; i++ )
|
|
{
|
|
if (RcptIndexList[i] != INVALID_RCPT_IDX_VALUE)
|
|
{
|
|
DWORD dwRecipientFlags = 0;
|
|
hr = pIMsgRecips->GetDWORD(RcptIndexList[i], IMMPID_RP_RECIPIENT_FLAGS,&dwRecipientFlags);
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( RP_HANDLED != ( dwRecipientFlags & RP_HANDLED ) )
|
|
{
|
|
dwRecipientFlags |= RP_DELIVERED;
|
|
|
|
|
|
hr = pIMsgRecips->PutDWORD(RcptIndexList[i], IMMPID_RP_RECIPIENT_FLAGS,dwRecipientFlags);
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return( hr );
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
ABSTRACT:
|
|
|
|
This function Creates a CDropDir object which is associated with a MailMsg object.
|
|
The job of the CDropDir object is to asynchronously write the Mail to the drop dir.
|
|
|
|
Called by
|
|
ProcessQueueEvents()
|
|
CDropDir::~CDropDir().
|
|
|
|
--*/
|
|
|
|
BOOL AsyncCopyMailToDropDir(
|
|
ISMTPConnection *pISMTPConnection,
|
|
const char * DropDirectory,
|
|
SMTP_SERVER_INSTANCE *pParentInst
|
|
)
|
|
{
|
|
PVOID AdvContext = NULL;
|
|
IMailMsgProperties *pIMsg = NULL;
|
|
DWORD NumRcpts = 0;
|
|
DWORD *RcptIndexList = NULL;
|
|
CDropDir *pDropDir = NULL;
|
|
BOOL fRet = TRUE;
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceFunctEnterEx(NULL, "newCopyMailToDropDir");
|
|
|
|
if (!pParentInst->IsShuttingDown())
|
|
{
|
|
|
|
AdvContext = NULL;
|
|
fRet = FALSE;
|
|
|
|
hr = pISMTPConnection->GetNextMessage(&pIMsg, (DWORD **)&AdvContext, &NumRcpts, &RcptIndexList);
|
|
if(FAILED(hr))
|
|
{
|
|
fRet = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
pDropDir = new CDropDir();
|
|
|
|
if( NULL == pDropDir )
|
|
{
|
|
fRet = FALSE;
|
|
goto Exit;
|
|
}
|
|
|
|
if( FAILED( hr = pDropDir->CopyMailToDropDir( pISMTPConnection,
|
|
DropDirectory,
|
|
pIMsg,
|
|
AdvContext,
|
|
NumRcpts,
|
|
RcptIndexList,
|
|
pParentInst) ) )
|
|
{
|
|
fRet = FALSE;
|
|
goto Exit;
|
|
}
|
|
|
|
SAFE_RELEASE(pDropDir);
|
|
SAFE_RELEASE(pIMsg );
|
|
|
|
fRet = TRUE;
|
|
}
|
|
|
|
Exit:
|
|
SAFE_RELEASE(pDropDir);
|
|
SAFE_RELEASE(pIMsg );
|
|
TraceFunctLeave();
|
|
return(fRet);
|
|
}
|