archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/inetsrv/iis/svcs/smtp/server/dirnot.cxx

2913 lines
88 KiB
Raw Permalink Blame History

#define INCL_INETSRV_INCS
#include "smtpinc.h"
#include "dirnot.hxx"
#include "headers.hxx"
#include "timeconv.h"
#include "smtpcli.hxx"
//
// ProgID for IMsg - this needs to be published in an SDK
//
#define TIMEOUT_INTERVAL 30
#define DIRNOT_IP_ADDRESS "127.0.0.1"
#define IMSG_PROGID L"Exchange.IMsg"
#define MAILMSG_PROGID L"Exchange.MailMsg"
extern void GenerateMessageId (char * Buffer, DWORD BuffLen);
extern DWORD GetIncreasingMsgId();
extern BOOL FindNextUnquotedOccurrence(char *lpszString,DWORD dwStringLength, char cSearch,char **ppszLocation);
static char * Daynames[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
//Event used make write files blocking
HANDLE g_hFileWriteEvent;
//
// provide memory for static declared in SMTP_DIRNOT
//
CPool CIoBuffer::Pool( DIRNOT_BUFFER_SIGNATURE );
CPool CBuffer::Pool( DIRNOT_IO_BUFFER_SIGNATURE );
int strcasecmp(char *s1, char *s2);
int strncasecmp(char *s1, char *s2, int n);
//+---------------------------------------------------------------
//
// Function: CBuffer
//
// Synopsis: constructor
//
// Arguments: void
//
// Returns: void
//
//----------------------------------------------------------------
CBuffer::CBuffer( BOOL bEncrypted ) :
m_dwSignature( DIRNOT_BUFFER_SIGNATURE ),
m_bEncrypted( bEncrypted )
{
TraceFunctEnterEx( (LPARAM)this, "CBuffer::CBuffer" );
//
// allocate the IO Buffer for this CBuffer
// allocator needs to call GetData to ensure m_pIoBuffer is not NULL
//
ZeroMemory (&m_Overlapped, sizeof(m_Overlapped));
m_pIoBuffer = new CIoBuffer;
m_Overlapped.pBuffer = this;
m_cCount = 0;
}
//+---------------------------------------------------------------
//
// Function: CBuffer::~CBuffer
//
// Synopsis: frees associated IO buffer
//
// Arguments: void
//
// Returns: void
//
//----------------------------------------------------------------
CBuffer::~CBuffer( void )
{
TraceFunctEnterEx( (LPARAM)this, "CBuffer::~CBuffer" );
//
// delete the IO Buffer for this CBuffer
//
if ( m_pIoBuffer != NULL )
{
delete m_pIoBuffer;
m_pIoBuffer = NULL;
}
TraceFunctLeaveEx((LPARAM)this);
}
/*++
Name:
SMTP_DIRNOT::SMTP_DIRNOT
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.
--*/
SMTP_DIRNOT::SMTP_DIRNOT(SMTP_SERVER_INSTANCE * pInstance)
{
TraceFunctEnterEx( (LPARAM)this, "SMTP_DIRNOT::SMTP_DIRNOT" );
_ASSERT(pInstance != NULL);
m_hDir = INVALID_HANDLE_VALUE;
m_pAtqContext = NULL;
m_cPendingIoCount = 0;
m_cDirChangeIoCount = 0;
m_cActiveThreads = 0;
m_pInstance = pInstance;
//m_pRetryQ = NULL;
m_Signature = SMTP_DIRNOT_SIGNATURE_VALID;
InitializeCriticalSection (&m_CritFindLock);
g_hFileWriteEvent = INVALID_HANDLE_VALUE;
m_FindThreads = 0;
m_FindFirstHandle = INVALID_HANDLE_VALUE;
m_bDelayedFind = FALSE;
TraceFunctLeaveEx((LPARAM)this);
}
SMTP_DIRNOT::~SMTP_DIRNOT (void)
{
PATQ_CONTEXT pAtqContext = NULL;
HANDLE hTemp = INVALID_HANDLE_VALUE;
TraceFunctEnterEx( (LPARAM)this, "SMTP_DIRNOT::~SMTP_DIRNOT" );
_ASSERT(GetThreadCount() == 0);
//release the context from Atq
pAtqContext = (PATQ_CONTEXT)InterlockedExchangePointer( (PVOID *)&m_pAtqContext, (PVOID) NULL);
if ( pAtqContext != NULL )
{
pAtqContext->hAsyncIO = NULL;
AtqFreeContext( pAtqContext, TRUE );
}
// Invalidate the signature. since this connection is trashed.
m_Signature = SMTP_DIRNOT_SIGNATURE_FREE;
hTemp = (HANDLE)InterlockedExchangePointer( (PVOID *)&g_hFileWriteEvent, (PVOID) INVALID_HANDLE_VALUE);
if ( hTemp != INVALID_HANDLE_VALUE )
{
CloseHandle(hTemp);
}
DeleteCriticalSection (&m_CritFindLock);
TraceFunctLeaveEx((LPARAM)this);
}
void SMTP_DIRNOT::SetPickupRetryQueueEvent(void)
{
TraceFunctEnterEx((LPARAM)this, "SMTP_SERVER_INSTANCE::SetPickupRetryQueueEvent");
//if(m_pRetryQ)
//{
// m_pRetryQ->SetQueueEvent();
//}
TraceFunctLeaveEx((LPARAM)this);
}
BOOL SMTP_DIRNOT::InitializeObject (char *DirPickupName, ATQ_COMPLETION pfnCompletion)
{
DWORD error = 0;
//PATQ_CONT pContext;
HANDLE StopHandle;
DWORD i;
TraceFunctEnterEx( (LPARAM)this, "SMTP_DIRNOT::InitializeObject" );
_ASSERT(m_pInstance != NULL);
//open the directory
m_hDir = CreateFile (DirPickupName, FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
NULL);
if(m_hDir == INVALID_HANDLE_VALUE)
{
ErrorTrace((LPARAM) this, "CreateFile on %s failed with error %d ", DirPickupName, GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
g_hFileWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if(g_hFileWriteEvent == INVALID_HANDLE_VALUE)
{
ErrorTrace((LPARAM) this, "CreateEvent() failed for FileWriteEvent with error %d ", GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
StopHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
if(StopHandle == NULL)
{
ErrorTrace((LPARAM) this, "CreateEvent() failed with error %d ", GetLastError());
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
//add it to our Gibraltar interface
if(!AtqAddAsyncHandle( &m_pAtqContext, NULL, this, pfnCompletion,
INFINITE, m_hDir))
{
error = GetLastError();
ErrorTrace((LPARAM) this, "AtqAddAsyncHandle on %s failed with error %d ", DirPickupName, GetLastError());
CloseHandle (m_hDir);
CloseHandle (StopHandle);
m_hDir = INVALID_HANDLE_VALUE;
StopHandle = NULL;
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
QuerySmtpInstance()->SetDirnotStopHandle(StopHandle);
//
// pend a set of outstanding directory change notifications, at all times, we want
// at least one notification outstanding, so pend 3 or 4
//
for (i = 0; i < OUTSTANDING_NOTIFICATIONS; i++)
{
if(!PendDirChangeNotification ())
{
ErrorTrace((LPARAM) this, "PendDirChangeNotification on failed with error %d ", GetLastError());
ErrorTrace((LPARAM) this, "Setting stop handle because PendDirChangeNotification () failed");
SetEvent(StopHandle);
TraceFunctLeaveEx((LPARAM) this);
return FALSE;
}
}
TraceFunctLeaveEx((LPARAM) this);
return TRUE;
}
void SMTP_DIRNOT::CloseDirHandle (void)
{
HANDLE hDir = NULL;
int i = 0;
int Count = 0;
int AfterSleepCount = 0;
DWORD dwLastAllocCount = 0;
DWORD dwAllocCount = 0;
DWORD dwStopHint = 2;
DWORD dwTickCount = 0;
TraceFunctEnterEx( (LPARAM)this, "SMTP_DIRNOT::CloseDirHandle" );
_ASSERT(m_pInstance != NULL);
hDir = (HANDLE) InterlockedExchangePointer((PVOID *) &m_hDir, NULL);
if(hDir != NULL)
{
CloseHandle (hDir);
}
//
// need to check Pool.GetAllocCount instead of InUseList.Empty
// because alloc goes to zero during the delete operator
// instead of during the destructor
//
//
dwTickCount = GetTickCount();
for( i = 0; i < 240; i++ )
{
dwAllocCount = (DWORD) QuerySmtpInstance()->GetCBufferAllocCount ();
if ( dwAllocCount == 0)
{
DebugTrace((LPARAM)this, "All pickup CBuffers are gone!");
break;
}
Sleep( 1000 );
// Update the stop hint checkpoint when we get within 1 second (1000 ms), of the timeout...
if ((SERVICE_STOP_WAIT_HINT - 1000) < (GetTickCount() - dwTickCount) && g_pInetSvc &&
(g_pInetSvc->QueryCurrentServiceState() == SERVICE_STOP_PENDING))
{
DebugTrace((LPARAM)this, "Updating stop hint in pickup, checkpoint = %u", dwStopHint);
g_pInetSvc->UpdateServiceStatus(SERVICE_STOP_PENDING, NO_ERROR, dwStopHint,
SERVICE_STOP_WAIT_HINT ) ;
dwStopHint++ ;
dwTickCount = GetTickCount();
}
DebugTrace((LPARAM)this, "Alloc counts: current = %u, last = %u;",
dwAllocCount, dwLastAllocCount);
if (dwAllocCount < dwLastAllocCount)
{
DebugTrace((LPARAM)this, "Pickup CBuffers are going away, reseting i");
i = 0;
}
dwLastAllocCount = dwAllocCount;
}
DebugTrace((LPARAM)this, "Waiting for QuerySmtpInstance()->GetDirnotStopHandle()!");
WaitForSingleObject(QuerySmtpInstance()->GetDirnotStopHandle(), INFINITE);
DebugTrace((LPARAM)this, "End waiting for QuerySmtpInstance()->GetDirnotStopHandle()!");
QuerySmtpInstance()->SetStopHint(2);
TraceFunctLeaveEx((LPARAM)this);
}
/*++
Name :
SMTP_DIRNOT::CreateSmtpDirNotification
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:
Returns:
A pointer to an SMTP_DIRNOT class or NULL
--*/
SMTP_DIRNOT * SMTP_DIRNOT::CreateSmtpDirNotification (char * DirPickupName,
ATQ_COMPLETION pfnCompletion,
SMTP_SERVER_INSTANCE * pInstance)
{
SMTP_DIRNOT * pSmtpDirNotObj;
TraceFunctEnterEx((LPARAM) 0, "SMTP_CONNOUT::CreateSmtpConnection");
pSmtpDirNotObj = new SMTP_DIRNOT (pInstance);
if(pSmtpDirNotObj == NULL)
{
ErrorTrace(0, "new SMTP_DIRNOT () failed");
TraceFunctLeaveEx((LPARAM)NULL);
return NULL;
}
if(!pSmtpDirNotObj->InitializeObject(pSmtpDirNotObj->QuerySmtpInstance()->GetMailPickupDir(), SMTP_DIRNOT::ReadDirectoryCompletion))
{
TraceFunctLeaveEx((LPARAM)NULL);
return NULL;
}
TraceFunctLeaveEx((LPARAM)NULL);
return pSmtpDirNotObj;
}
BOOL SMTP_DIRNOT::DoFindFirstFile(BOOL bIISThread)
{
//
// re-entrent FindFirst... the first thread does the FindFirst, all other threads up to
// MAXFIND_THREADS do the FindNext.
//
char Buffer [MAX_PATH + 1];
HANDLE hFindFile = INVALID_HANDLE_VALUE;
DWORD BytesRead = 0;
DWORD NumFiles = 0;
WIN32_FIND_DATA find;
BOOL bClosed;
PSMTP_IIS_SERVICE pService;
TraceFunctEnterEx((LPARAM)this, "DoFindFirstFile");
_ASSERT(m_pInstance != NULL);
if (!QuerySmtpInstance()->GetAcceptConnBool())
{
return TRUE;
}
pService = (PSMTP_IIS_SERVICE) g_pInetSvc;
//
// ensure only one thread gets in here at a time. we can only have one thread either setting
// the find first at a time.
//
LockFind();
hFindFile = GetFindFirstHandle();
if (hFindFile == INVALID_HANDLE_VALUE)
{
//make up the file spec we want to find
lstrcpy(Buffer, QuerySmtpInstance()->GetMailPickupDir());
lstrcat(Buffer, "*.*");
hFindFile = FindFirstFile(Buffer, &find);
if (hFindFile == INVALID_HANDLE_VALUE)
{
// should not fail as we look for *.* and the directory root should be there.
// setting the flag will make sure that next drop posts a findfirst.
SetDelayedFindNotification(TRUE);
ErrorTrace((LPARAM) this, "FindFirst failed for %s. Error %d", Buffer, GetLastError());
UnLockFind();
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
else
{
IncFindThreads(); // there should be not find threads running at this point.
//
// We have no IIS threads available for the single findfirst... we must create a thread.
// hopefull this will happen seldom.
SetFindFirstHandle(hFindFile);
SetDelayedFindNotification(FALSE);
}
}
else
{
SetDelayedFindNotification(TRUE);
if (!IncFindThreads())
{
UnLockFind();
DebugTrace((LPARAM)this, "Have hit the max num Find Threads.");
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
if (!FindNextFile(hFindFile, &find))
{
if (GetLastError() != ERROR_NO_MORE_FILES)
{
SetDelayedFindNotification(TRUE);
ErrorTrace((LPARAM) this,"FindNextFile() failed with error %d", GetLastError());
}
CloseFindHandle(); // will DecFindThreads.
//
// In the case below, it is possible that some files were missed by FindFirst.
// Create an ATQ thread for a final findfirst iteration to make sure.
//
if ((GetNumFindThreads() == 0) && GetDelayedFindNotification())
{
IncPendingIoCount();
// AtqContext with buffer size of zero to get a FindFirst Going.
if(!AtqPostCompletionStatus(QueryAtqContext(), 0))
{
DecPendingIoCount();
ErrorTrace((LPARAM) this,"AtqPostCompletionStatus() failed with error %d", GetLastError());
}
}
UnLockFind();
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
}
UnLockFind();
bClosed = FALSE;
do
{
//format the name of the stream and then open the file.
BytesRead = wsprintf(Buffer, "%s%s",QuerySmtpInstance()->GetMailPickupDir(), find.cFileName);
if (!(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
HRESULT hr = S_OK;
IMailMsgProperties *pIMsg = NULL;
hr = CoCreateInstance(CLSID_MsgImp, NULL, CLSCTX_INPROC_SERVER,
IID_IMailMsgProperties, (LPVOID *)&pIMsg);
// Next, check if we are over the inbound cutoff limit. If so, we will release the message
// and not proceed.
if (SUCCEEDED(hr))
{
DWORD dwCreationFlags;
hr = pIMsg->GetDWORD(
IMMPID_MPV_MESSAGE_CREATION_FLAGS,
&dwCreationFlags);
if (FAILED(hr) ||
(dwCreationFlags & MPV_INBOUND_CUTOFF_EXCEEDED))
{
// If we fail to get this property of if the inbound cutoff
// exceeded flag is set, discard the message and return failure
if (SUCCEEDED(hr))
{
DebugTrace((LPARAM)this, "Failing because inbound cutoff reached");
hr = E_OUTOFMEMORY;
}
pIMsg->Release();
pIMsg = NULL;
}
}
DebugTrace((LPARAM)this,"Found file %s", find.cFileName);
if ((pIMsg == NULL) || FAILED(hr))
{
// We are out of resources, there is absolutely nothing
// we can do: can't NDR, can't retry ...
ErrorTrace((LPARAM) this, "new MAILQ_ENTRY failed for file: %s",
find.cFileName);
//
// Will want to run a findfirst when things free up a little. Flag the post-processing findfirst.
//
SetDelayedFindNotification(TRUE);
IncPendingIoCount ();
AtqContextSetInfo(QueryAtqContext(), ATQ_INFO_TIMEOUT, TIMEOUT_INTERVAL); //retry after a while
ErrorTrace((LPARAM)this, "Failed to create message will retry later.");
break;
}
else
{
// We are in faith that upon delivery, the allocated
// MailQEntry structure will be freed
NumFiles++;
pIMsg->PutStringA(IMMPID_MP_PICKUP_FILE_NAME, find.cFileName);
if(!ProcessFile(pIMsg))
{
// will be mail left in pickup. queue a findfirst to take care of it.
SetDelayedFindNotification(TRUE);
}
}
}
LockFind();
if (!FindNextFile(hFindFile, &find))
{
if (GetLastError() != ERROR_NO_MORE_FILES)
{
SetDelayedFindNotification(TRUE);
ErrorTrace((LPARAM) this,"FindNextFile() failed with error %d", GetLastError());
}
CloseFindHandle();
//
// In the case below, it is possible that some files were missed by FindFirst.
// Create an ATQ thread for a final findfirst iteration to make sure.
//
if ((GetNumFindThreads() == 0) && GetDelayedFindNotification())
{
IncPendingIoCount();
// AtqContext with buffer size of zero to get a FindFirst Going.
if(!AtqPostCompletionStatus(QueryAtqContext(), 0))
{
DecPendingIoCount();
ErrorTrace((LPARAM) this,"AtqPostCompletionStatus() failed with error %d", GetLastError());
}
}
UnLockFind();
bClosed = TRUE;
break;
}
UnLockFind();
}
while ((!QuerySmtpInstance()->IsShuttingDown())
&& (QuerySmtpInstance()->QueryServerState( ) != MD_SERVER_STATE_STOPPED)
&& (QuerySmtpInstance()->QueryServerState( ) != MD_SERVER_STATE_INVALID));
if (!bClosed) // termination by the while condition above.
{
LockFind();
CloseFindHandle();
UnLockFind();
}
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
DWORD WINAPI SMTP_DIRNOT::CreateNonIISFindThread(void * ClassPtr)
{
//
// Called by a CreateThread when we have run out of IIS threads.
//
SMTP_DIRNOT * ThisPtr = (SMTP_DIRNOT *) ClassPtr;
TraceFunctEnterEx((LPARAM) ThisPtr,"CreateNonIISFindThread");
_ASSERT(ThisPtr != NULL);
_ASSERT(ThisPtr->QuerySmtpInstance() != NULL);
//
// Build the initial list - THE FLAG bIISThread IS SET TO FALSE.
// We IncCBufferAllocCount and DecCBufferAllocCount to make sure that we clean up properly in CloseDirHandle.
// We don't want to destroy the Dirnot Object before this thread finishes.
//
ThisPtr->QuerySmtpInstance()->IncCBufferObjs();
ThisPtr->DoFindFirstFile(FALSE);
ThisPtr->QuerySmtpInstance()->DecCBufferObjs();
TraceFunctLeaveEx((LPARAM)ThisPtr);
return TRUE;
}
DWORD WINAPI SMTP_DIRNOT::PickupInitialFiles(void * ClassPtr)
{
SMTP_DIRNOT * ThisPtr = (SMTP_DIRNOT *) ClassPtr;
TraceFunctEnterEx((LPARAM) ThisPtr,"PickupInitialFiles");
_ASSERT(ThisPtr != NULL);
_ASSERT(ThisPtr->QuerySmtpInstance() != NULL);
// Just quit if we are suhtting down already
if (ThisPtr->QuerySmtpInstance()->IsShuttingDown())
return TRUE;
// Build the initial list
ThisPtr->DoFindFirstFile();
TraceFunctLeaveEx((LPARAM)ThisPtr);
return TRUE;
}
#define PRIVATE_OPTIMAL_BUFFER_SIZE 4096
#define PRIVATE_LINE_BUFFER_SIZE 1024
#define IS_SPACE_OR_TAB(ch) (((ch) == ' ') || ((ch) == '\t'))
#define IS_WHITESPACE_OR_CRLF(ch) (((ch) == ' ') || ((ch) == '\t') || ((ch) == '\n') || ((ch) == '\r'))
static void pReplaceCrLfWithSpaces(CHAR *szIn, CHAR *szOut)
{
while (*szIn)
{
if ((*szIn == '\r') || (*szIn == '\n'))
*szOut++ = ' ';
else
*szOut++ = *szIn;
szIn++;
}
*szOut = '\0';
}
BOOL SMTP_DIRNOT::CreateToList (char *AddrsList, IMailMsgRecipientsAdd *pIMsgRecips, IMailMsgProperties *pIMsgProps)
{
char *p = NULL; //points to the ',' or '\0'
char * StartOfAddress = NULL; //start of recipient address
char * EndOfAddress = NULL; // end of recipient address
char * ThisAddress = NULL;
CAddr * NewAddress = NULL; //new CAddr to add to our list
char szAddress[MAX_INTERNET_NAME + 1], *pszAddress = szAddress;
DWORD dwPropId = IMMPID_RP_ADDRESS_SMTP;
DWORD dwNewRecipIndex = 0;
HRESULT hr = S_OK;
BOOL fNotFound = FALSE;
TraceFunctEnterEx((LPARAM) this, "SMTP_DIRNOT::CreateToList");
_ASSERT(m_pInstance != NULL);
//start at the top of the list
p = AddrsList;
//get rid of leading white space, newlines, and commas
while ((*p == ',') || IS_WHITESPACE_OR_CRLF(*p))
p++;
while((p != NULL) && (*p != '\0'))
{
char LastChar;
StartOfAddress = p;
// Find the ending delimiter of the address
//while((*p != '\0') && (*p != ','))
// p++;
// The first unquoted comma indicates the end of the address
if(!FindNextUnquotedOccurrence(p,strlen(p),',',&EndOfAddress))
{
SetLastError(ERROR_INVALID_DATA);
NewAddress = NULL;
ErrorTrace((LPARAM) this, "Failed to parse out the address");
return FALSE;
}
else if(!EndOfAddress)
EndOfAddress = p + strlen(p);
p = EndOfAddress;
_ASSERT(EndOfAddress != NULL);
// We don't like trailing spaces either, so walk backwards
// to get rid of them
//EndOfAddress = p;
while (EndOfAddress > StartOfAddress)
{
EndOfAddress--;
if (!IS_WHITESPACE_OR_CRLF(*EndOfAddress))
{
EndOfAddress++;
break;
}
}
// Save the character we are about to overrite
LastChar = *EndOfAddress;
// NULL terminate the address
*EndOfAddress = '\0';
if(lstrlen(StartOfAddress) > (MAX_INTERNET_NAME + 1))
{
SetLastError(ERROR_INVALID_DATA);
NewAddress = NULL;
ErrorTrace((LPARAM) this, "Address too long : %d bytes",lstrlen(StartOfAddress));
return FALSE;
}
pReplaceCrLfWithSpaces(StartOfAddress, szAddress);
DebugTrace((LPARAM) this, "found address [%s]", szAddress);
//
// Run it through the addr821 library
//
NewAddress = CAddr::CreateAddress(szAddress);
BOOL fValidAddress = FALSE;
if(NewAddress)
{
if(!NewAddress->IsDomainOffset())
{
CAddr * TempAddress = NULL;
TempAddress = QuerySmtpInstance()->AppendLocalDomain (NewAddress);
if (TempAddress)
{
delete NewAddress;
NewAddress = TempAddress;
TempAddress = NULL;
} else if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
ErrorTrace((LPARAM) this, "CAddr::CreateAddress (StartOfAddress) failed . err: %u", ERROR_NOT_ENOUGH_MEMORY);
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
}
DebugTrace((LPARAM) this, "CreateAddress returned %s", NewAddress->GetAddress());
ThisAddress = NewAddress->GetAddress();
DWORD dwLen = strlen(ThisAddress);
if(Validate821Address(
ThisAddress,
dwLen)) {
LPSTR pszDomain;
if(Get821AddressDomain(
ThisAddress,
dwLen,
&pszDomain) && pszDomain)
{
DWORD dwDomain = strlen(pszDomain);
if (Validate821Domain(pszDomain, dwDomain)) {
// everything is valid
fValidAddress = TRUE;
}
} else {
ErrorTrace((LPARAM)0, "Detected legal address without a domain: %s",
ThisAddress);
}
} else {
ErrorTrace((LPARAM)0, "Detected ILLEGAL address: %s",
ThisAddress);
}
} else {
if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
ErrorTrace((LPARAM) this, "CAddr::CreateAddress (StartOfAddress) failed . err: %u", ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
ThisAddress = szAddress;
fValidAddress = FALSE;
}
hr = pIMsgRecips->AddPrimary(1, (LPCTSTR *) &ThisAddress, &dwPropId, &dwNewRecipIndex, NULL, 0);
if (FAILED(hr)) {
SetLastError(hr);
return FALSE;
}
if (NewAddress) delete NewAddress;
if (!fValidAddress) {
// AQ will look for this special domain and won't add it to the
// DMT. This stops us from putting corrupted domains into the
// DMT
hr = pIMsgRecips->PutStringA(dwNewRecipIndex,
IMMPID_RP_DOMAIN,
"==NDR==");
if (FAILED(hr)) {
DebugTrace((LPARAM) 0, "PutString(RP_DOMAIN) failed 0x%x", hr);
SetLastError(hr);
return FALSE;
}
// set the recipient to NDR
hr = pIMsgRecips->PutDWORD(dwNewRecipIndex,
IMMPID_RP_RECIPIENT_FLAGS,
(RP_ERROR_CONTEXT_CAT | RP_UNRESOLVED));
if (FAILED(hr)) {
DebugTrace((LPARAM) 0, "PutDWORD(RP_FLAGS) failed 0x%x", hr);
SetLastError(hr);
return FALSE;
}
// tell AQ why it is NDRing
hr = pIMsgRecips->PutDWORD(dwNewRecipIndex,
IMMPID_RP_ERROR_CODE,
CAT_E_ILLEGAL_ADDRESS);
if (FAILED(hr)) {
DebugTrace((LPARAM) 0, "PutDWORD(RP_ERROR) failed 0x%x", hr);
SetLastError(hr);
return FALSE;
}
// tell AQ that some recips are NDRing
hr = pIMsgProps->PutDWORD(IMMPID_MP_HR_CAT_STATUS,
CAT_W_SOME_UNDELIVERABLE_MSGS);
if (FAILED(hr)) {
DebugTrace((LPARAM) 0, "SetMailMsgCatStatus failed 0x%x", hr);
SetLastError(hr);
return FALSE;
}
}
// Go find the start of the next address
*EndOfAddress = LastChar;
if(*p == ',')
{
p++;
while(IS_WHITESPACE_OR_CRLF(*p))
p++;
}
}
TraceFunctLeave();
return (TRUE);
}
static HANDLE pOpenPickupFile(LPSTR szFileName)
{
DWORD dwError;
HANDLE hFile;
TraceFunctEnterEx((LPARAM)NULL, "pOpenPickupFile");
// Open the file
hFile = CreateFile(szFileName,
GENERIC_READ,
FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
NULL );
if (hFile == INVALID_HANDLE_VALUE)
{
dwError = GetLastError();
ErrorTrace((LPARAM)NULL,
"Error: Can't open source file %s (err=%d)...skipping it",
szFileName, dwError);
}
TraceFunctLeaveEx((LPARAM)NULL);
return(hFile);
}
static inline BOOL pFetchFileBuffer( HANDLE hFile,
CHAR *lpBuffer,
LPDWORD lpdwSize)
{
BOOL fRet = TRUE;
DWORD Error = 0;
fRet = ReadFile(hFile, lpBuffer, *lpdwSize, lpdwSize, NULL);
if(!fRet)
{
Error = GetLastError();
if(Error == 998)
{
_ASSERT(FALSE);
}
}
return fRet;
}
static CHAR *pGetLineBuffer(CHAR *lpOldBuffer,
DWORD *lpdwLength)
{
DWORD dwLength = *lpdwLength;
CHAR *lpBuffer;
if (lpOldBuffer)
{
// We have an old buffer, we double the size of the old buffer
_ASSERT(lpdwLength);
dwLength <<= 1;
}
else
dwLength = PRIVATE_LINE_BUFFER_SIZE;
// Allocate the new buffer
lpBuffer = (CHAR *)HeapAlloc(GetProcessHeap(), 0, dwLength);
if (!lpBuffer)
return(NULL);
if (lpOldBuffer)
{
// Copy the info over and free the old buffer
CopyMemory((LPVOID)lpBuffer, (LPVOID)lpOldBuffer, *lpdwLength);
_VERIFY( HeapFree(GetProcessHeap(), 0, lpOldBuffer) );
}
*lpdwLength = dwLength;
return(lpBuffer);
}
static BOOL pFreeLineBuffer(CHAR *lpBuffer)
{
return( HeapFree(GetProcessHeap(), 0, lpBuffer) );
}
static CHAR *pGetValueFromHeader(CHAR *szHeader)
{
while (*szHeader && (*szHeader++ != ':'))
;
while (*szHeader)
{
if (!IS_SPACE_OR_TAB(*szHeader))
return(szHeader);
else
szHeader++;
}
return(NULL);
}
static CHAR *pReadNextLineFromBuffer( HANDLE hFile,
CHAR *lpBuffer,
LPDWORD lpdwSize,
CHAR *lpStart,
LPSTR *ppszLine,
DWORD *lpdwMaxLineLen,
LPSTR *ppOriginalBuffer,
DWORD *lpdwOriginalBufferLen)
{
DWORD dwLineLen = 0;
DWORD dwMaxLineLen = *lpdwMaxLineLen;
BOOL fThisIsCR = FALSE;
BOOL fLastIsCR = FALSE;
BOOL fThisIsLF = FALSE;
BOOL fLastIsLF = FALSE;
CHAR *lpEnd;
CHAR *lpszLine = *ppszLine;
CHAR ch;
BOOL bEndOfFile;
TraceFunctEnter("pReadNextLineFromBuffer");
_ASSERT(hFile != INVALID_HANDLE_VALUE);
_ASSERT(!IsBadWritePtr(lpdwSize, sizeof(DWORD)));
_ASSERT(!IsBadWritePtr(lpBuffer, *lpdwSize));
_ASSERT(!IsBadWritePtr(*ppszLine, *lpdwMaxLineLen));
// raid 181922/88855 - replace recusive loop with while loop.
do {
dwLineLen = 0;
dwMaxLineLen = *lpdwMaxLineLen;
fThisIsCR = FALSE;
fLastIsCR = FALSE;
fThisIsLF = FALSE;
fLastIsLF = FALSE;
bEndOfFile = FALSE;
// Now, make sure the supplied start pointer is within
// buffer supplied (We allow it to be one byte past the
// end of the buffer, but we will never dereference it).
if ((lpStart < lpBuffer) || (lpStart > (lpBuffer + *lpdwSize)))
{
_ASSERT(0);
return(NULL);
}
// Now, keep copying until we hit one of the following scenarios:
// i) We hit CRLF
// ii) We hit the end of the buffer, which we reload more data
// or if it is the end of the mail, we postpend a CRLF.
lpEnd = lpBuffer + *lpdwSize;
do
{
// See if this is past the buffer
if (lpStart == lpEnd)
{
DWORD dwNewLength;
dwNewLength = *lpdwSize;
if (!pFetchFileBuffer(hFile, lpBuffer, &dwNewLength))
{
return(NULL);
}
// Done!
if (!dwNewLength)
{
bEndOfFile = TRUE;
break;
}
// Get the new buffer length
*lpdwSize = dwNewLength;
// Reset the start and end pointers
lpStart = lpBuffer;
lpEnd = lpBuffer + *lpdwSize;
}
ch = *lpszLine++ = *lpStart++;
// Too long?
if (++dwLineLen >= dwMaxLineLen)
{
CHAR *lpTemp;
DWORD dwUsedPortion = (DWORD)(lpszLine - *ppOriginalBuffer);
// Yep, get a bigger buffer, all the existing stuff is copied over
DebugTrace((LPARAM)*ppOriginalBuffer, "Growing buffer at %u bytes", *lpdwOriginalBufferLen);
lpTemp = pGetLineBuffer(*ppOriginalBuffer, lpdwOriginalBufferLen);
if (!lpTemp)
{
DebugTrace((LPARAM)NULL, "Failed to obtain buffer (%u)", GetLastError());
TraceFunctLeave();
return(NULL);
}
// Got it, adjust all associated pointers and lengths
DebugTrace((LPARAM)lpTemp, "Obtained buffer at %u bytes", *lpdwOriginalBufferLen);
// New beginning of line buffer
*ppOriginalBuffer = lpTemp;
// New beginning of line
*ppszLine = lpTemp;
// New pointer to next character
lpszLine = lpTemp + dwUsedPortion;
// New maximum length for current string before re-growing
dwMaxLineLen = *lpdwOriginalBufferLen - dwUsedPortion;
}
fLastIsCR = fThisIsCR;
if (ch == '\r')
fThisIsCR = TRUE;
else
fThisIsCR = FALSE;
fLastIsLF = fThisIsLF;
if (ch == '\n')
fThisIsLF = TRUE;
else
fThisIsLF = FALSE;
// If we have CRLF or LFCR we leave
if ((fLastIsCR && fThisIsLF) || (fLastIsLF && fThisIsCR))
break;
} while (1);
*lpszLine = '\0';
// Calculate remaining buffer size
*lpdwMaxLineLen = dwMaxLineLen - dwLineLen;
// raid 178234 - If we have CRLF or LFCR and no more continue line we leave
if (((fLastIsCR && fThisIsLF) || (fLastIsLF && fThisIsCR)) && !IS_SPACE_OR_TAB(*lpStart))
{
// raid 166777 - Make sure we do leave if we find a line.
break;
}
} while (!bEndOfFile && (IS_SPACE_OR_TAB(*lpStart) || (lpStart == lpEnd)));
// We always return the start of line to be the start of our buffer
// Note that the buffer could have changed during recursion due to growth
*ppszLine = *ppOriginalBuffer;
TraceFunctLeave();
return(lpStart);
}
BOOL inline WriteToSpooledFile(PFIO_CONTEXT hDstFile, CHAR *lpszLine, DWORD &DestOffset)
{
DWORD dwBytesToWrite;
DWORD dwBytesWritten;
BOOL fResult = FALSE;
FH_OVERLAPPED ov;
DWORD err = NO_ERROR;
HANDLE HackedHandle = NULL;
BOOL fRet = FALSE;
ZeroMemory(&ov, sizeof(ov));
ov.Offset = DestOffset;
dwBytesToWrite = lstrlen(lpszLine);
if (!dwBytesToWrite)
{
fRet = TRUE; //This is not really a failure
goto Exit;
}
//HackedHandle = ((DWORD)g_hFileWriteEvent | 1);
HackedHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
if(HackedHandle == NULL)
{
return FALSE;
}
ov.hEvent = (HANDLE) ((ULONG_PTR) HackedHandle | 1);
//ov.hEvent = (HANDLE)HackedHandle;
fResult = FIOWriteFile(hDstFile, lpszLine, dwBytesToWrite, &ov);
if (!fResult) err = GetLastError();
if((err == ERROR_IO_PENDING) || (((DWORD)STATUS_PENDING == ov.Internal) && ( err == NO_ERROR )))
{
// 12/16/98 - MikeSwa Modified
// OK... this is the theory... we are getting random AV, from what
// looks like async completion to I/O. It looks like
// GetOverlappedResult cannot be called to wait for a hacked handle,
// and it will not use the first argument unless the event in the
// overlapped structure is NULL. The solution is to call WaitForSingleObject
// if we detect that the IO is still pending
WaitForSingleObject(HackedHandle, INFINITE);
_ASSERT((DWORD)STATUS_PENDING != ov.Internal);
}
else if (NO_ERROR != err)
{
SetLastError (err); //preserve the last error
if(err == 998)
{
_ASSERT(FALSE);
}
goto Exit;
}
DestOffset += dwBytesToWrite;
fRet = TRUE;
Exit:
if(HackedHandle)
{
CloseHandle(HackedHandle);
}
//TraceFunctLeaveEx((LPARAM)NULL);
return fRet;
}
BOOL CopyRestOfMessage(HANDLE hSrcFile, PFIO_CONTEXT hDstFile, DWORD &DestOffset)
{
CHAR acBuffer[PRIVATE_OPTIMAL_BUFFER_SIZE];
DWORD dwBytesRead;
DWORD dwBytesWritten;
DWORD dwTotalBytes = 0;
DWORD err = NO_ERROR;
BOOL fResult = FALSE;
BOOL fRet = FALSE;
HANDLE HackedHandle;
FH_OVERLAPPED ov;
CHAR acCrLfDotCrLf[5] = { '\r', '\n', '.', '\r', '\n' };
CHAR acLastBytes[5] = { '\0', '\0', '\0', '\0', '\0' };
// Copies from the current file pointer to the end of hSrcFile
// and appends to the current file pointer of hDstFile.
_ASSERT(hSrcFile != INVALID_HANDLE_VALUE);
_ASSERT(hDstFile != NULL);
ZeroMemory(&ov, sizeof(ov));
HackedHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
if(HackedHandle == NULL)
{
return FALSE;
}
ov.hEvent = (HANDLE) ((ULONG_PTR) HackedHandle | 1);
do
{
if (!ReadFile(hSrcFile, acBuffer,
PRIVATE_OPTIMAL_BUFFER_SIZE,
&dwBytesRead,
NULL))
{
err = GetLastError();
if(err == 998)
{
_ASSERT(FALSE);
}
goto Exit;
}
if (dwBytesRead)
{
ov.Offset = DestOffset;
//
// Save the last two bytes ever read/written. the buffer after
// writing could be modified due to dot-stripping.
//
if (dwBytesRead > 4)
{
CopyMemory(acLastBytes, &acBuffer[dwBytesRead-5], 5);
}
else
{
MoveMemory(acLastBytes, &acLastBytes[dwBytesRead], 5-dwBytesRead);
CopyMemory(&acLastBytes[5-dwBytesRead], acBuffer, dwBytesRead);
}
fResult = FIOWriteFile(hDstFile, acBuffer, dwBytesRead, &ov);
if (!fResult) err = GetLastError();
if((err == ERROR_IO_PENDING) || (((DWORD)STATUS_PENDING == ov.Internal) && ( err == NO_ERROR )))
{
// 12/16/98 - MikeSwa Modified
// OK... this is the theory... we are getting random AV, from what
// looks like async completion to I/O. It looks like
// GetOverlappedResult cannot be called to wait for a hacked handle,
// and it will not use the first argument unless the event in the
// overlapped structure is NULL. The solution is to call
// WaitForSingleObject and pass in the un-munged handle (only if
// we know that IO is still pending).
WaitForSingleObject(HackedHandle, INFINITE);
_ASSERT((DWORD)STATUS_PENDING != ov.Internal);
}
else if (NO_ERROR != err)
{
SetLastError (err); //preserve the last error
if(err == 998)
{
_ASSERT(FALSE);
}
goto Exit;
}
//
// this is because Fcache keeps track of the offset were we need
// to write. So we update dwBytesWritten to what we actually read.
//
dwBytesWritten = dwBytesRead;
}
else
{
dwBytesWritten = 0;
}
if (dwBytesWritten)
{
dwTotalBytes += dwBytesWritten;
DestOffset += 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 (!WriteToSpooledFile(hDstFile, "\r\n", DestOffset))
{
goto Exit;
}
dwTotalBytes+=2;
}
//If file ends with CRLF.CRLF, remove the trailing .CRLF
//NimishK ** : this was decided per the bug 63394
if ((dwTotalBytes > 4) && !memcmp(acLastBytes, acCrLfDotCrLf, 5))
{
DWORD dwFileSizeHigh = 0;
DWORD dwFileSizeLow = GetFileSizeFromContext( hDstFile, &dwFileSizeHigh );
DWORD Offset = SetFilePointer(hDstFile->m_hFile, dwFileSizeLow, NULL, FILE_BEGIN);
// Remove the trailing CRLF only as the <DOT> would have been removed by
// dot-stripping by file handle cache.
if ((SetFilePointer(hDstFile->m_hFile, -2, NULL, FILE_CURRENT) == 0xffffffff) ||
!SetEndOfFile(hDstFile->m_hFile))
{
_ASSERT(0 && "SetFilePointerFailed");
goto Exit;
}
}
fRet = TRUE;
Exit:
if(HackedHandle)
{
CloseHandle(HackedHandle);
}
return fRet;
}
BOOL SMTP_DIRNOT::ProcessFile(IMailMsgProperties *pIMsg)
{
LONGLONG LastAccessTime = (LONGLONG) 0;
CHAR* acCrLf = "\r\n";
DWORD AbOffset = 0;
DWORD DestWriteOffset = 0;
DWORD HeaderFlags = 0;
DWORD dwPickupFileSize = 0;
BOOL fIsStartOfFile = TRUE;
BOOL fIsXSenderRead = FALSE;
BOOL fAreXRcptsRead = FALSE;
BOOL fIsSenderSeen = FALSE;
BOOL fInvalidAddresses = FALSE;
BOOL fDateExists = FALSE;
BOOL fMessageIdExists = FALSE;
BOOL fXOriginalArrivalTime = FALSE;
BOOL fFromSeen = FALSE;
BOOL fRcptSeen = FALSE;
BOOL fSeenRFC822FromAddress = FALSE;
BOOL fSeenRFC822ToAddress = FALSE;
BOOL fSeenRFC822CcAddress = FALSE;
BOOL fSeenRFC822BccAddress = FALSE;
BOOL fSeenRFC822Subject = FALSE;
BOOL fSeenRFC822SenderAddress = FALSE;
BOOL fSeenXPriority = FALSE;
BOOL fSeenContentType = FALSE;
BOOL fSetContentType = FALSE;
HANDLE hSource = INVALID_HANDLE_VALUE;
PFIO_CONTEXT hDest = NULL;
SYSTEMTIME SysTime;
DWORD dwLineBufferSize = 0;
DWORD dwMaxLineSize = 0;
CHAR* szLineBuffer = NULL;
CHAR* szLine = NULL;
CHAR* szValue = NULL;
CHAR szScratch[512];
CHAR szMsgId[512];
CHAR acReadBuffer[PRIVATE_OPTIMAL_BUFFER_SIZE];
CHAR szPickupFilePath[MAX_PATH + 1];
CHAR szDateBuf [cMaxArpaDate];
DWORD dwBufferSize = 0;
CHAR FileName[MAX_PATH + 1];
CHAR* lpStart = NULL;
CHAR* lpXMarker = NULL;
DWORD dwBytesToRewind = 0;
LONG lOffset = 0;
CAddr* Sender = NULL;
PSMTP_IIS_SERVICE pService = NULL;
IMailMsgRecipientsAdd* pIMsgRecips = NULL;
IMailMsgRecipients* pIMsgOrigRecips = NULL;
IMailMsgBind* pBindInterface = NULL;
HRESULT hr = S_OK;
DWORD dwTotalRecips = 0;
SMTP_ALLOC_PARAMS AllocParams;
BOOL fResult = FALSE;
BOOL DeleteIMsg = TRUE;
TraceFunctEnterEx((LPARAM) this, "SMTP_DIRNOT::ProcessFile" );
_ASSERT(m_pInstance != NULL);
_ASSERT(pIMsg);
if (!pIMsg)
{
ErrorTrace((LPARAM)this, "Internal error: pIMsg is NULL.");
SetLastError(ERROR_INVALID_PARAMETER);
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
// Compose the pickup path
hr = pIMsg->GetStringA(IMMPID_MP_PICKUP_FILE_NAME, sizeof(FileName), FileName);
if (FAILED(hr))
{
ErrorTrace((LPARAM)this, "MailQEntry->GetFileName() is NULL.");
goto RetryPickup;
}
hr = pIMsg->QueryInterface(IID_IMailMsgBind, (void **)&pBindInterface);
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "IMsg->QueryInterface(IID_IMailMsgBindATQ) failed.");
goto RetryPickup;
}
//Get recipient list
hr = pIMsg->QueryInterface(IID_IMailMsgRecipients, (void **) &pIMsgOrigRecips);
if (FAILED(hr))
{
ErrorTrace((LPARAM)this, "IMsg->QueryInterface(IID_IMailMsgRecipients) failed.");
goto RetryPickup;
}
hr = pIMsgOrigRecips->AllocNewList(&pIMsgRecips);
if (FAILED(hr))
{
ErrorTrace((LPARAM)this, "pIMsgOrigRecips->AllocNewList");
goto RetryPickup;
}
lstrcpy(szPickupFilePath, QuerySmtpInstance()->GetMailPickupDir());
lstrcat(szPickupFilePath, FileName);
// Open the pickup file, if this failsas a sharing violation,
// we would like to retry it ...
hSource = pOpenPickupFile(szPickupFilePath);
if (hSource == INVALID_HANDLE_VALUE)
{ //
// this is probably caused by the file still being written, wait a small amount of time
// we manage our IO compl. threads to ensure that there are enough, so this shouldn't be
// a big problem. It avoids the retry queue.
//
WaitForSingleObject(QuerySmtpInstance()->GetQStopEvent(), g_PickupWait);
hSource = pOpenPickupFile(szPickupFilePath);
if (hSource == INVALID_HANDLE_VALUE)
{
if (GetLastError() == ERROR_FILE_NOT_FOUND)
{
//delete MailQEntry;
ErrorTrace((LPARAM)this, "File %s is deleted from pickup dir", szPickupFilePath);
goto RetryPickup;
}
// Schedule pickup mail for retry ...
goto RetryPickup;
}
}
AllocParams.BindInterfacePtr = (PVOID) pBindInterface;
AllocParams.IMsgPtr = (PVOID)pIMsg;
AllocParams.hContent = NULL;
AllocParams.pAtqClientContext = QuerySmtpInstance();
AllocParams.m_pNotify = NULL;
fResult = QuerySmtpInstance()->AllocNewMessage (&AllocParams);
//Get the context and the atq context
hDest = AllocParams.hContent;
if((!fResult) || (hDest == NULL))
{
goto RetryPickup;
}
// Get the handle of the spooled file
_ASSERT(hDest != NULL);
//
// Winse:13699 and X5:174038
// Remove Dot stuffing based on the metabase key.
// Default behavior is that pickup directory messages are dot stuffed.
// If the metabase key DisablePickupDotStuff is set then the pickup directory
// messages should not be dot stuffed.
//
if( !SetDotStuffingOnWrites( hDest, !m_pInstance->DisablePickupDotStuff(), TRUE ) )
{
ErrorTrace((LPARAM)this, "SetDotStuffingonWrites failed" );
goto RetryPickup;
}
// Spit a Received: line to the spooled file
GetArpaDate(szDateBuf);
GetLocalTime(&SysTime);
// Allocate the needed line buffer
szLineBuffer = pGetLineBuffer(NULL, &dwLineBufferSize);
if (!szLineBuffer)
{
// Schedule pickup mail for retry ...
ErrorTrace((LPARAM)this, "Unable to allocate line buffer (%u)", GetLastError());
goto RetryPickup;
}
DebugTrace((LPARAM)this, "Allocated line buffer at %p, %u bytes", szLineBuffer, dwLineBufferSize);
// Set up the line pointers
szLine = szLineBuffer;
dwMaxLineSize = dwLineBufferSize;
// Prefetch a buffer-full of text
dwBufferSize = PRIVATE_OPTIMAL_BUFFER_SIZE;
if (!pFetchFileBuffer(hSource, acReadBuffer, &dwBufferSize))
{
// Schedule pickup mail for retry ...
ErrorTrace((LPARAM)this, "Retrying because cannot fetch file buffer (%u)",GetLastError());
goto RetryPickup;
}
m_pInstance->LockGenCrit();
wsprintf( szScratch,
"Received: from mail pickup service by %s with Microsoft SMTPSVC;\r\n\t %s, %s\r\n",
QuerySmtpInstance()->GetFQDomainName(),
Daynames[SysTime.wDayOfWeek],
szDateBuf);
m_pInstance->UnLockGenCrit();
//We will copy out to the temp out buffer
//NK** : This is a safe assumption that this will not result in IO
#if 0
if ((SetFilePointer(hDest, 0, NULL, FILE_BEGIN) == 0xffffffff) ||
!WriteToSpooledFile(hDest, szScratch, DestWriteOffset))
#else
if (!WriteToSpooledFile(hDest, szScratch, DestWriteOffset))
#endif
goto RetryPickup;
lpStart = acReadBuffer;
while (1)
{
HeaderFlags = 0;
// The X marker is used to mark the start of the
// non-X-headers if X-headers are used
if (fIsStartOfFile)
lpXMarker = lpStart;
// This function will read a complete header line,
// into a single NULL-terminated string.
// Raid 181922 - The function no longer unfolds the line.
if (!(lpStart = pReadNextLineFromBuffer( hSource,
acReadBuffer,
&dwBufferSize,
lpStart,
&szLine,
&dwMaxLineSize,
&szLineBuffer,
&dwLineBufferSize)))
{
// We failed a file operation, we will retry later
goto RetryPickup;
}
// See if we are still in the header portion of the body
if (!IsHeader(szLine))
break;
// Get the set of headers that we know about.
ChompHeader(szLine, HeaderFlags);
szValue = pGetValueFromHeader(szLine);
if(!szValue)
{
continue;
}
// Strip away the CRLF at the end of the value string
lOffset = lstrlen(szValue);
if (lOffset >= 2)
{
if (((szValue[lOffset-2] == '\r') && (szValue[lOffset-1] == '\n')) ||
((szValue[lOffset-2] == '\n') && (szValue[lOffset-1] == '\r')))
szValue[lOffset-2] = '\0';
}
hr = GetAndPersistRFC822Headers( szLine,
szValue,
pIMsg,
fSeenRFC822FromAddress,
fSeenRFC822ToAddress,
fSeenRFC822BccAddress,
fSeenRFC822CcAddress,
fSeenRFC822Subject,
fSeenRFC822SenderAddress,
fSeenXPriority,
fSeenContentType,
fSetContentType );
if( FAILED( hr ) )
{
ErrorTrace((LPARAM)this, "Retrying because cannot getAndPersistRFC822 headers(%x)", hr);
goto RetryPickup;
}
// Check for leading X-Sender and X-Receiver header lines ...
if (fIsStartOfFile)
{
if (HeaderFlags & H_X_SENDER)
{
// NOTE: if we have more than one sender,
// we always use the first one encountered
// Yes, we found an X-header
fIsXSenderRead = TRUE;
}
else if (HeaderFlags & H_X_RECEIVER)
{
// We don't check for sender here, since if we don't
// have one, we will barf downstream
// Yes, we found an X-header
fAreXRcptsRead = TRUE;
}
else
{
// We are done with our X-headers, now we have
// normal headers!
fIsStartOfFile = FALSE;
}
}
if (HeaderFlags & H_FROM)
{
fFromSeen = TRUE;
}
if (HeaderFlags & H_RCPT)
{
fRcptSeen = TRUE;
}
// Handle senders and recipients
if (!fIsSenderSeen && ((HeaderFlags & H_X_SENDER) || (HeaderFlags & H_FROM)))
{
// Selectively do so
if (fIsStartOfFile || !fIsXSenderRead)
{
char *Address = NULL;
DWORD cbText = 0;
DWORD dwlen = strlen(szValue);
_ASSERT(dwlen < 512 );
Sender = CAddr::CreateAddress (szValue, FROMADDR);
if (Sender)
{
Address = Sender->GetAddress();
if(!Sender->IsDomainOffset() && !ISNULLADDRESS(Address))
{
CAddr * TempAddress = NULL;
TempAddress = QuerySmtpInstance()->AppendLocalDomain (Sender);
delete Sender;
if (TempAddress)
{
Sender = TempAddress;
Address = Sender->GetAddress();
TempAddress = NULL;
}
else
{
ErrorTrace((LPARAM) this,"Retrying because cannot to append local domain (%u)",GetLastError());
goto RetryPickup;
}
}
// Set the size of the FromName so that we can
// read it out of the queue file if we need it.
//cbText = lstrlen(Address) + 1;
//MailQEntry->SetFromNameSize (cbText);
//MailQEntry->SetSenderToStream(Address);
hr = pIMsg->PutStringA(IMMPID_MP_SENDER_ADDRESS_SMTP, Address);
fIsSenderSeen = TRUE;
}
else
{
// Undo the flag
if (fIsXSenderRead)
fIsXSenderRead = FALSE;
// If the sender is not invalid, it is likely to be a
// resource constraint, so we go and retry it
if (GetLastError() != ERROR_INVALID_DATA)
{
ErrorTrace((LPARAM)this, "Retrying because cannot allocate sender (%u)", GetLastError());
goto RetryPickup;
}
}
}
}
else if ((HeaderFlags & H_X_RECEIVER) || (HeaderFlags & H_RCPT))
{
// Selectively do so
if (fIsStartOfFile || !fAreXRcptsRead)
{
DebugTrace((LPARAM)szLine, "To: line read <%s>", szValue);
if (!CreateToList(szValue, pIMsgRecips, pIMsg))
{
// If we're out of memory, we retry.
// If it is an invalid address, we remember the fact and
// remember to throw a copy into badmail
if (GetLastError() == ERROR_NOT_ENOUGH_MEMORY)
{
ErrorTrace((LPARAM)this, "Retrying because cannot allocate recipient (%u)", GetLastError());
goto RetryPickup;
}
else
fInvalidAddresses = TRUE;
}
if (fIsStartOfFile)
{
// X-headers!
lpXMarker = lpStart;
}
}
}
else if (HeaderFlags & H_MID)
{
// Message-ID already exists
fMessageIdExists = TRUE;
hr = pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_ID , szValue );
if (FAILED(hr))
{
ErrorTrace((LPARAM) this, "PutStringA of IMMPID_MP_RFC822_MSG_ID failed - hr 0x%08X", hr);
goto RetryPickup;
}
}
else if (HeaderFlags & H_DATE)
{
// Date line already exists
fDateExists = TRUE;
}
// 10/15/98 - MikeSwa Added supersedes functionality
else if (HeaderFlags & H_X_MSGGUID)
{
hr = pIMsg->PutStringA(IMMPID_MP_MSG_GUID, szValue);
if (FAILED(hr))
{
ErrorTrace((LPARAM) this, "PutStringA of MSG_GUID failed - hr 0x%08X", hr);
goto RetryPickup;
}
}
else if (HeaderFlags & H_X_SUPERSEDES_MSGGUID)
{
hr = pIMsg->PutStringA(IMMPID_MP_SUPERSEDES_MSG_GUID, szValue);
if (FAILED(hr))
{
ErrorTrace((LPARAM) this, "PutStringA of SUPERSEDES_MSG_GUID failed - hr 0x%08X", hr);
goto RetryPickup;
}
}
else if( HeaderFlags & H_X_ORIGINAL_ARRIVAL_TIME )
{
fXOriginalArrivalTime = TRUE;
hr = pIMsg->PutStringA(IMMPID_MP_ORIGINAL_ARRIVAL_TIME, szValue);
if (FAILED(hr))
{
ErrorTrace((LPARAM) this, "PutStringA of ORIGINAL_ARRIVAL_TIME failed - hr 0x%08X", hr);
goto RetryPickup;
}
}
// If this is an ordinary header, we will dump this to
// the spooled file
if (!fIsStartOfFile)
{
// Non-x-header; dump the line!
lstrcat(szLine, acCrLf);
if (!WriteToSpooledFile(hDest, szLine, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
}
hr = pIMsg->PutStringA(IMMPID_MP_HELO_DOMAIN, m_pInstance->GetDefaultDomain());
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "Retrying because pIMsg->PutString(helo domain) failed (%x)", hr);
goto RetryPickup;
}
hr = pIMsg->PutStringA(IMMPID_MP_CONNECTION_IP_ADDRESS, DIRNOT_IP_ADDRESS);
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "Retrying because pIMsg->PutString(IP address) failed (%x)", hr);
goto RetryPickup;
}
hr = SetAvailableMailMsgProperties( pIMsg );
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "Retrying because pIMsg->PutString( for all available props) failed (%x)", hr);
goto RetryPickup;
}
wsprintf( szScratch,
"%s, %s",
Daynames[SysTime.wDayOfWeek],
szDateBuf);
hr = pIMsg->PutStringA(IMMPID_MP_ARRIVAL_TIME, szScratch);
if( FAILED( hr ) )
{
ErrorTrace((LPARAM)this,"Retrying because cannot putString IMPPID_MP_ARRIVAL_TIME (%x)", hr);
goto RetryPickup;
}
// Now, before we go on and waste time on copying the rest of the message, etc.
// we want to make sure we saw the sender and at least one valid recipient.
// If not, we will just move the message to bad mail and be done with it.
hr = pIMsgRecips->Count(&dwTotalRecips);
if (!fIsSenderSeen || FAILED(hr) || (dwTotalRecips == 0))
{
// If no recipients but sender is seen, we must not leak the sender
// object
if (fIsSenderSeen)
{
delete Sender;
Sender = NULL;
}
_VERIFY( pFreeLineBuffer(szLineBuffer) );
szLineBuffer = NULL;
if (hSource != INVALID_HANDLE_VALUE)
{
_VERIFY( CloseHandle(hSource) );
hSource = INVALID_HANDLE_VALUE;
}
if(FAILED(hr))
{
goto RetryPickup;
}
else
{
// No choice but move to bad mail directory
if( !QuerySmtpInstance()->MoveToBadMail( pIMsg, FALSE, FileName, QuerySmtpInstance()->GetMailPickupDir()) )
{
if (!DeleteFile(szPickupFilePath))
{
DWORD dwError = GetLastError();
ErrorTrace((LPARAM)this, "Error deleting file %s (%u)", szPickupFilePath, dwError);
}
}
goto RetryPickup;
}
}
hr = pIMsg->PutDWORD( IMMPID_MP_NUM_RECIPIENTS, dwTotalRecips );
if( FAILED( hr ) )
{
ErrorTrace((LPARAM)this,"Retrying because cannot putDWORD IMPPID_MP_NUM_RECIPIENTS (%x)", hr);
goto RetryPickup;
}
// if we did not read a From Line, create a From: line from the xSender.
// if we did not read a To, CC, BCC line, create a To: line from the xReceiver.
if (!fFromSeen)
{
char *Address = NULL;
char szUserName[MAX_INTERNET_NAME + 5];
Address = Sender->GetAddress();
if (!Address)
{
_VERIFY( pFreeLineBuffer(szLineBuffer) );
szLineBuffer = NULL;
if (hSource != INVALID_HANDLE_VALUE)
{
_VERIFY( CloseHandle(hSource) );
hSource = INVALID_HANDLE_VALUE;
}
// No choice but move to bad mail directory
if( !QuerySmtpInstance()->MoveToBadMail( pIMsg, FALSE, FileName, QuerySmtpInstance()->GetMailPickupDir()) )
{
if (!DeleteFile(szPickupFilePath))
{
DWORD dwError = GetLastError();
ErrorTrace((LPARAM)this, "Error deleting file %s (%u)", szPickupFilePath, dwError);
}
}
goto RetryPickup;
}
wsprintf(szUserName, "From: %s\r\n", Address);
if (!WriteToSpooledFile(hDest, szUserName, DestWriteOffset))
{
ErrorTrace((LPARAM)this,"Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
if (!fRcptSeen)
{
//
// fix for bug: 78275
// add an emty Bcc line:
//
static char * endRcpt = "Bcc:\r\n";
if (!WriteToSpooledFile(hDest, endRcpt, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
if (fIsSenderSeen)
{
delete Sender;
}
// We still have to dump the current line to the spool
// file, then we copy the rest over.
// Since we use buffered read, the current file position
// really doesn't mean much. So we calculate how many bytes
// we have to rewind
dwBytesToRewind = dwBufferSize - (DWORD)(lpStart - acReadBuffer);
// Negative, since we are going backwards
_ASSERT(dwBytesToRewind <= PRIVATE_OPTIMAL_BUFFER_SIZE);
lOffset = -(long)dwBytesToRewind;
if (SetFilePointer(hSource, lOffset, NULL, FILE_CURRENT)
== 0xffffffff)
{
ErrorTrace((LPARAM)this,
"Retrying because cannot move file pointer (%u)",
GetLastError());
goto RetryPickup;
}
// See if we have to add a Date: or Message-ID: line
if (!fMessageIdExists)
{
char MessageId[MAX_PATH];
MessageId[0] = '\0';
GenerateMessageId (MessageId, sizeof(MessageId));
m_pInstance->LockGenCrit();
wsprintf( szMsgId, "<%s%8.8x@%s>", MessageId, GetIncreasingMsgId(),QuerySmtpInstance()->GetFQDomainName());
m_pInstance->UnLockGenCrit();
wsprintf(szScratch, "Message-ID: %s\r\n",szMsgId );
hr = pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_ID, szMsgId );
if( FAILED( hr ) )
{
ErrorTrace((LPARAM)this, "Retrying because Put string of IMMPID_MP_RFC822 failed (%x)", hr );
goto RetryPickup;
}
if (!WriteToSpooledFile(hDest, szScratch, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
//
// see if we have to add Original Arrival time
//
if (!fXOriginalArrivalTime )
{
char szOriginalArrivalTime[64];
szOriginalArrivalTime[0] = '\0';
GetSysAndFileTimeAsString( szOriginalArrivalTime );
wsprintf(szScratch, "X-OriginalArrivalTime: %s\r\n",szOriginalArrivalTime );
hr = pIMsg->PutStringA( IMMPID_MP_ORIGINAL_ARRIVAL_TIME, szOriginalArrivalTime );
if( FAILED( hr ) )
{
ErrorTrace((LPARAM)this, "Retrying because Put string of IMMPID_MP_ORIGINAL_ARRIVAL_TIME failed (%x)", hr );
goto RetryPickup;
}
if (!WriteToSpooledFile(hDest, szScratch, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
//
// see if we have to add the date
//
if (!fDateExists)
{
lstrcpy(szScratch, "Date: ");
lstrcat(szScratch, szDateBuf);
lstrcat(szScratch, acCrLf);
if (!WriteToSpooledFile(hDest, szScratch, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
}
// Write out the currently buffered line, then copy the
// pickup file to the spooler
if (!WriteToSpooledFile(hDest, szLine, DestWriteOffset) ||
!CopyRestOfMessage(hSource, hDest, DestWriteOffset))
{
ErrorTrace((LPARAM)this, "Retrying because cannot write to file (%u)", GetLastError());
goto RetryPickup;
}
// We will no longer read headers at this point, so we free our
// line buffer here ...
DebugTrace((LPARAM)this, "Freeing line buffer at %p, %u bytes", szLineBuffer, dwLineBufferSize);
_VERIFY( pFreeLineBuffer(szLineBuffer) );
szLineBuffer = NULL;
// Get the size of the spooled file before we close it
DWORD dwFileSizeHigh;
dwPickupFileSize = GetFileSizeFromContext(hDest, &dwFileSizeHigh);
_ASSERT(dwFileSizeHigh == 0); // why??
if (dwPickupFileSize == 0xffffffff)
{
dwPickupFileSize = 0;
}
pIMsg->PutDWORD( IMMPID_MP_MSG_SIZE_HINT, dwPickupFileSize );
// Now, we see if there are any invalid addresses; if so, we will
// throw a copy og the original message into the badmail directory
if (fInvalidAddresses)
{
// Close the pickup file
if (hSource != INVALID_HANDLE_VALUE)
{
_VERIFY( CloseHandle(hSource) );
hSource = INVALID_HANDLE_VALUE;
}
// Move it to badmail instead of deleting it
DebugTrace((LPARAM)this, "Saving a copy in badmail due to bad recipients");
// No choice but move to bad mail directory
if( !QuerySmtpInstance()->MoveToBadMail( pIMsg, FALSE, FileName, QuerySmtpInstance()->GetMailPickupDir() ) )
{
if (!DeleteFile(szPickupFilePath))
{
DWORD dwError = GetLastError();
ErrorTrace((LPARAM)this, "Error deleting file %s (%u)", szPickupFilePath, dwError);
}
}
}
else
{
// Delete the file
if (!DeleteFile(szPickupFilePath))
{
DWORD dwError = GetLastError();
ErrorTrace((LPARAM)this, "Error deleting file %s (%u)", szPickupFilePath, dwError);
}
// Close the pickup file
if (hSource != INVALID_HANDLE_VALUE)
{
_VERIFY( CloseHandle(hSource) );
hSource = INVALID_HANDLE_VALUE;
}
}
//
// put the file into the local queue.
//
pService = (PSMTP_IIS_SERVICE) g_pInetSvc;
hr = pIMsgOrigRecips->WriteList(pIMsgRecips);
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "Retrying because pIMsgOrigRecips->WriteList failed (%x)", hr);
goto RetryPickup;
}
//
// we scan for dots & strip them away while storing, so set these two properties
// so we can get the dot stuffed context while sending it out.
//
pIMsg->PutDWORD( IMMPID_MP_SCANNED_FOR_CRLF_DOT_CRLF, TRUE );
pIMsg->PutDWORD( IMMPID_MP_FOUND_EMBEDDED_CRLF_DOT_CRLF, TRUE );
CompleteDotStuffingOnWrites( hDest, TRUE );
hr = pIMsg->Commit(NULL);
if(FAILED(hr))
{
ErrorTrace((LPARAM)this, "Retrying because pIMsg->Commit(NULL) failed (%u)",
hr);
goto RetryPickup;
}
pIMsgRecips->Release();
pIMsgOrigRecips->Release();
pIMsgRecips = NULL;
pIMsgOrigRecips = NULL;
if(m_pInstance->InsertIntoQueue(pIMsg))
{
DeleteIMsg = FALSE;
// Up the msgs received and avg bytes per message counters
ADD_BIGCOUNTER(QuerySmtpInstance(), BytesRcvdMsg, (dwPickupFileSize));
BUMP_COUNTER(QuerySmtpInstance(), NumMsgsForwarded);
}
RetryPickup:
IMailMsgQueueMgmt * pMgmt = NULL;
if(pBindInterface)
{
pBindInterface->Release();
}
if(pIMsgRecips)
{
pIMsgRecips->Release();
pIMsgRecips = NULL;
}
if(pIMsgOrigRecips)
{
pIMsgOrigRecips->Release();
pIMsgOrigRecips = NULL;
}
if(DeleteIMsg)
{
hr = pIMsg->QueryInterface(IID_IMailMsgQueueMgmt, (void **)&pMgmt);
if(!FAILED(hr))
{
pMgmt->Delete(NULL);
pMgmt->Release();
}
}
if(pIMsg)
{
pIMsg->Release();
pIMsg = NULL;
}
// Retry message
if (szLineBuffer)
{
_VERIFY( pFreeLineBuffer(szLineBuffer) );
szLineBuffer = NULL;
}
if (hSource != INVALID_HANDLE_VALUE)
{
_VERIFY( CloseHandle( hSource ) );
hSource = INVALID_HANDLE_VALUE;
}
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////
HRESULT SMTP_DIRNOT::GetAndPersistRFC822Headers(
char* InputLine,
char* pszValueBuf,
IMailMsgProperties* pIMsg,
BOOL & fSeenRFC822FromAddress,
BOOL & fSeenRFC822ToAddress,
BOOL & fSeenRFC822BccAddress,
BOOL & fSeenRFC822CcAddress,
BOOL & fSeenRFC822Subject,
BOOL & fSeenRFC822SenderAddress,
BOOL & fSeenXPriority,
BOOL & fSeenContentType,
BOOL & fSetContentType
)
{
HRESULT hr = S_OK;
//
// get the Subject: & persist it
//
if( !fSeenRFC822Subject &&
( !strncasecmp( InputLine, "Subject:", strlen("Subject:") ) ||
!strncasecmp( InputLine, "Subject :", strlen("Subject :") ) ) )
{
fSeenRFC822Subject = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_RFC822_MSG_SUBJECT, pszValueBuf ) ) )
{
return( hr );
}
}
}
//
// get the To: address & persist it
//
if( !fSeenRFC822ToAddress &&
( !strncasecmp( InputLine, "To:", strlen("To:") ) ||
!strncasecmp( InputLine, "To :", strlen("To :") ) ) )
{
fSeenRFC822ToAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_RFC822_TO_ADDRESS, pszValueBuf ) ) )
{
return( hr );
}
}
}
//
// get the Cc: address & persist it
//
if( !fSeenRFC822CcAddress &&
( !strncasecmp( InputLine, "Cc:", strlen("Cc:") ) ||
!strncasecmp( InputLine, "Cc :", strlen("Cc :") ) ) )
{
fSeenRFC822CcAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_RFC822_CC_ADDRESS, pszValueBuf ) ) )
{
return( hr );
}
}
}
//
// get the Bcc: address & persist it
//
if( !fSeenRFC822BccAddress &&
( !strncasecmp( InputLine, "Bcc:", strlen("Bcc:") ) ||
!strncasecmp( InputLine, "Bcc :", strlen("Bcc :") ) ) )
{
fSeenRFC822BccAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_RFC822_BCC_ADDRESS, pszValueBuf ) ) )
{
return( hr );
}
}
}
//
// get the From: address & persist it
//
if( !fSeenRFC822FromAddress &&
( !strncasecmp( InputLine, "From:", strlen("From:") ) ||
!strncasecmp( InputLine, "From :", strlen("From :") ) ) )
{
fSeenRFC822FromAddress = TRUE;
if( pszValueBuf )
{
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_RFC822_FROM_ADDRESS, pszValueBuf ) ) )
{
return( hr );
}
}
char szSmtpFromAddress[MAX_INTERNET_NAME + 6] = "smtp:";
char *pszDomainOffset;
DWORD cAddr;
if (CAddr::ExtractCleanEmailName(szSmtpFromAddress + 5, &pszDomainOffset, &cAddr, pszValueBuf)) {
if (FAILED(hr = pIMsg->PutStringA(IMMPID_MP_FROM_ADDRESS, szSmtpFromAddress))) {
return hr;
}
}
}
if( !fSeenRFC822SenderAddress &&
( !strncasecmp( InputLine, "Sender:", strlen("Sender:") ) ||
!strncasecmp( InputLine, "Sender :", strlen("Sender :") ) ) )
{
fSeenRFC822SenderAddress = TRUE;
if( pszValueBuf )
{
char szSmtpSenderAddress[MAX_INTERNET_NAME + 6] = "smtp:";
char *pszDomainOffset;
DWORD cAddr;
if (CAddr::ExtractCleanEmailName(szSmtpSenderAddress + 5, &pszDomainOffset, &cAddr, pszValueBuf)) {
if (FAILED(hr = pIMsg->PutStringA(IMMPID_MP_SENDER_ADDRESS, szSmtpSenderAddress))) {
return hr;
}
}
}
}
//
// get the X-Priority & persist it
//
if( !fSeenXPriority &&
( !strncasecmp( InputLine, "X-Priority:", strlen("X-Priority:") ) ||
!strncasecmp( InputLine, "X-Priority :", strlen("X-Priority :") ) ) )
{
fSeenXPriority = TRUE;
if( pszValueBuf )
{
DWORD dwPri = (DWORD)atoi( pszValueBuf );
if( FAILED( hr = pIMsg->PutDWORD( IMMPID_MP_X_PRIORITY, dwPri ) ) )
{
return( hr );
}
}
}
//
// get the content type & persist it
//
if( !fSeenContentType &&
( !strncasecmp( InputLine, "Content-Type:", strlen("Content-Type:") ) ||
!strncasecmp( InputLine, "Content-Type :", strlen("Content-Type :") ) ) )
{
fSeenContentType = TRUE;
fSetContentType = TRUE;
DWORD dwContentType = 0;
if( pszValueBuf )
{
if( !strncasecmp( pszValueBuf, "multipart/signed", strlen("multipart/signed") ) )
{
dwContentType = 1;
}
else if( !strncasecmp( pszValueBuf, "application/x-pkcs7-mime", strlen("application/x-pkcs7-mime") ) ||
!strncasecmp( pszValueBuf, "application/pkcs7-mime", strlen("application/pkcs7-mime") ) )
{
dwContentType = 2;
}
if( FAILED( hr = pIMsg->PutStringA( IMMPID_MP_CONTENT_TYPE, pszValueBuf ) ) )
{
return( hr );
}
}
if( FAILED( hr = pIMsg->PutDWORD( IMMPID_MP_ENCRYPTION_TYPE, dwContentType ) ) )
{
return( hr );
}
}
if( !fSetContentType )
{
fSetContentType = TRUE;
if( FAILED( hr = pIMsg->PutDWORD( IMMPID_MP_ENCRYPTION_TYPE, 0 ) ) )
{
return( hr );
}
}
return( hr );
}
//////////////////////////////////////////////////////////////////////////////
HRESULT SMTP_DIRNOT::SetAvailableMailMsgProperties( IMailMsgProperties *pIMsg )
{
//set IPaddress that is already available
HRESULT hr = S_OK;
hr = pIMsg->PutStringA(IMMPID_MP_CONNECTION_SERVER_IP_ADDRESS, DIRNOT_IP_ADDRESS);
if(FAILED(hr))
{
return( hr );
}
hr = pIMsg->PutStringA(IMMPID_MP_SERVER_NAME, g_ComputerName);
if(FAILED(hr))
{
return( hr );
}
hr = pIMsg->PutStringA(IMMPID_MP_SERVER_VERSION, g_VersionString);
if(FAILED(hr))
{
return( hr );
}
return( hr );
}
//////////////////////////////////////////////////////////////////////////////
void SMTP_DIRNOT::CreateLocalDeliveryThread (void)
{
TraceFunctEnterEx((LPARAM)this, "SMTP_DIRNOT::CreateLocalDeliveryThread");
//
// Add a delivery thread with the ATQPorts Overlapped structure. For the dir notifications,
// our overlapped structure is used... this is how we tell the difference in Process Client.
//
IncPendingIoCount();
if(!AtqPostCompletionStatus(QueryAtqContext(), 50))
{
DecPendingIoCount();
ErrorTrace((LPARAM) this,"AtqPostCompletionStatus() failed with error %d", GetLastError());
}
TraceFunctLeaveEx((LPARAM)this);
}
//////////////////////////////////////////////////////////////////////////////
BOOL SMTP_DIRNOT::PendDirChangeNotification (void)
{
CBuffer * pBuffer = NULL;
DWORD nBytes = 0;
DWORD Error = 0;
TraceFunctEnterEx((LPARAM) this, "SMTP_DIRNOT::PendDirChangeNotification" );
_ASSERT(m_pInstance != NULL);
_ASSERT(m_hDir != INVALID_HANDLE_VALUE);
//get a new buffer
pBuffer = new CBuffer();
if(pBuffer == NULL)
{
ErrorTrace((LPARAM) this, "pBuffer = new CBuffer()failed . err: %u", ERROR_NOT_ENOUGH_MEMORY);
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
if(pBuffer->GetData() == NULL)
{
ErrorTrace((LPARAM) this, "pBuffer = new CBuffer()->GetData failed . err: %u", ERROR_NOT_ENOUGH_MEMORY);
delete pBuffer;
SetLastError (ERROR_NOT_ENOUGH_MEMORY);
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
QuerySmtpInstance()->IncCBufferObjs ();
IncPendingIoCount();
IncDirChangeIoCount();
if(!AtqReadDirChanges(QueryAtqContext(),pBuffer->GetData(),QuerySmtpInstance()->GetDirBufferSize(),
FALSE,FILE_NOTIFY_CHANGE_FILE_NAME,
(OVERLAPPED *) &pBuffer->m_Overlapped.SeoOverlapped.Overlapped))
{
Error = GetLastError();
ErrorTrace((LPARAM) this, "ReadDirectoryChangesW failed . err: %u", Error);
delete pBuffer;
QuerySmtpInstance()->DecCBufferObjs ();
//decrement over all I/O count
DecPendingIoCount();
DecDirChangeIoCount();
TraceFunctLeaveEx((LPARAM)this);
return FALSE;
}
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
BOOL SMTP_DIRNOT::ProcessDirNotification( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
{
CHAR FileName[MAX_PATH + 1];
PFILE_NOTIFY_INFORMATION Info = NULL;
DWORD FileNameLength = 0;
DWORD ServerState;
CBuffer* pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
HRESULT hr;
TraceFunctEnterEx((LPARAM)this, "SMTP_DIRNOT::ProcessDirNotification" );
_ASSERT(m_pInstance != NULL);
//
// pend a new notification to replace the one we are currently using... there will still be
// a couple outstanding unless we are shutting down.
//
if (!PendDirChangeNotification())
ErrorTrace((LPARAM)this, "PendDirChangeNotification() failed");
if (!QuerySmtpInstance()->GetAcceptConnBool())
{
delete pBuffer;
QuerySmtpInstance()->DecCBufferObjs ();
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
if(dwCompletionStatus != NO_ERROR)
{
ErrorTrace((LPARAM) this, "SMTP_DIRNOT::ProcessDirNotification received error %d", dwCompletionStatus);
delete pBuffer;
QuerySmtpInstance()->DecCBufferObjs ();
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
ServerState = QuerySmtpInstance()->QueryServerState( );
//if we are not running, just delete
if( (ServerState == MD_SERVER_STATE_STOPPED ) || (ServerState == MD_SERVER_STATE_INVALID))
{
delete pBuffer;
QuerySmtpInstance()->DecCBufferObjs ();
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
if(InputBufferLen)
{
Info = (PFILE_NOTIFY_INFORMATION) pBuffer->GetData();
while (1)
{
//we only care about files added to this
//directory
//if(Info->Action == FILE_ACTION_MODIFIED)
if(Info->Action == FILE_ACTION_ADDED)
{
IMailMsgProperties *pIMsg = NULL;
//convert the name to ascii
FileNameLength = WideCharToMultiByte(CP_ACP, 0, &Info->FileName[0], Info->FileNameLength,
FileName, sizeof(FileName), NULL, NULL);
FileName[FileNameLength/2] = '\0';
DebugTrace((LPARAM) this, "File %s was detected", FileName);
hr = CoCreateInstance(CLSID_MsgImp, NULL, CLSCTX_INPROC_SERVER,
IID_IMailMsgProperties, (LPVOID *)&pIMsg);
// Next, check if we are over the inbound cutoff limit. If so, we will release the message
// and not proceed.
if (SUCCEEDED(hr))
{
DWORD dwCreationFlags;
hr = pIMsg->GetDWORD(
IMMPID_MPV_MESSAGE_CREATION_FLAGS,
&dwCreationFlags);
if (FAILED(hr) ||
(dwCreationFlags & MPV_INBOUND_CUTOFF_EXCEEDED))
{
// If we fail to get this property of if the inbound cutoff
// exceeded flag is set, discard the message and return failure
if (SUCCEEDED(hr))
{
DebugTrace((LPARAM)this, "Failing because inbound cutoff reached");
hr = E_OUTOFMEMORY;
}
pIMsg->Release();
pIMsg = NULL;
}
}
if( (pIMsg == NULL) || FAILED(hr))
{
// We are out of resources, there is absolutely nothing
// we can do: can't NDR, can't retry ...
// Just go on with the next mail ...
ErrorTrace((LPARAM) this, "new MAILQ_ENTRY failed for file: %s",
FileName);
// will be mail left in pickup. queue a findfirst to take care of it.
SetDelayedFindNotification(TRUE);
IncPendingIoCount ();
AtqContextSetInfo(QueryAtqContext(), ATQ_INFO_TIMEOUT, TIMEOUT_INTERVAL); //retry after a while
ErrorTrace((LPARAM)this, "Failed to create message will retry later.");
goto Exit;
}
else
{
pIMsg->PutStringA(IMMPID_MP_PICKUP_FILE_NAME, FileName);
if(!ProcessFile(pIMsg))
{
// will be mail left in pickup. queue a findfirst to take care of it.
SetDelayedFindNotification(TRUE);
}
}
}
if(Info->NextEntryOffset == 0)
{
DebugTrace((LPARAM) this, "No more entries in this notification");
break;
}
//get the next entry in the list to process
Info = (PFILE_NOTIFY_INFORMATION)( (PCHAR)Info + Info->NextEntryOffset);
}
if (GetDelayedFindNotification())
{
DebugTrace((LPARAM) this, "Doing FindFirstFile because max mail objects was hit in notification");
DoFindFirstFile();
}
}
else
{
DebugTrace((LPARAM) this, "Doing FindFirstFile because InputBufferLen == 0");
DoFindFirstFile();
}
Exit:
if(pBuffer)
{
delete pBuffer;
pBuffer = NULL;
QuerySmtpInstance()->DecCBufferObjs ();
}
TraceFunctLeaveEx((LPARAM)this);
return TRUE;
}
/*++
Name :
SMTP_DIRNOT::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_DIRNOT::ProcessClient( IN DWORD InputBufferLen, IN DWORD dwCompletionStatus, IN OUT OVERLAPPED * lpo)
{
PFILE_NOTIFY_INFORMATION Info = NULL;
DWORD FileNameLength = 0;
BOOL fRet;
PSMTP_IIS_SERVICE pService;
TraceFunctEnterEx((LPARAM) this, "SMTP_DIRNOT::ProcessClient" );
_ASSERT(m_pInstance != NULL);
//
// increment the number of threads processing this client
//
IncThreadCount();
if(!QuerySmtpInstance()->IsShuttingDown())
{
//
// dhowell - if a gilbraltar thread, and size > 0 then it is a delivery thread we have created
// the SMTP_CONNECTION code will ensure that only the correct number run.
//
if (lpo == &(QueryAtqContext()->Overlapped) || dwCompletionStatus == ERROR_SEM_TIMEOUT)
{
if(InputBufferLen == 0)
{
DebugTrace( (LPARAM)this,"FindFirst called internally.");
//reset timeout to infinity in anticipation of having memory; DoFindFirstFile
//will set it to TIMEOUT_INTERVAL if it runs out of memory
AtqContextSetInfo(QueryAtqContext(), ATQ_INFO_TIMEOUT, INFINITE);
DoFindFirstFile();
//since this was a timeout completion, the atq context has been "disabled" from
//further IO processing. Restart the timeout processing.
AtqContextSetInfo(QueryAtqContext(), ATQ_INFO_RESUME_IO, 1);
}
}
//
// A legit notification .
//
else
{
DecDirChangeIoCount();
DebugTrace( (LPARAM)this,"ReadDirectoryChange Notification");
fRet = ProcessDirNotification(InputBufferLen, dwCompletionStatus, lpo);
}
}
else
{
if (lpo != &(QueryAtqContext()->Overlapped))
{
//just cleanup up shop if we are shutting down.
CBuffer* pBuffer = ((DIRNOT_OVERLAPPED*)lpo)->pBuffer;
delete pBuffer;
pBuffer = NULL;
QuerySmtpInstance()->DecCBufferObjs ();
DecDirChangeIoCount();
}
//
// only applies to shutdown case
// these will not be decremented via SMTP_CONNECTION::ProcessMailQIO so we have to do it here.
//
if ((lpo == &(QueryAtqContext()->Overlapped)) && InputBufferLen)
{
pService = (PSMTP_IIS_SERVICE) g_pInetSvc;
QuerySmtpInstance()->DecRoutingThreads();
pService->DecSystemRoutingThreads();
}
}
//
// decrement the number of threads processing this client
//
DecThreadCount();
if ( DecPendingIoCount() == 0 )
{
DebugTrace( (LPARAM)this,"SMTP_DIRNOT::ProcessClient() shutting down - Pending IOs: %d",m_cPendingIoCount);
DebugTrace( (LPARAM)this,"SMTP_DIRNOT::ProcessClient() shutting down - ActiveThreads: %d",m_cActiveThreads);
_ASSERT( m_cActiveThreads == 0 );
fRet = FALSE;
}
else
{
DebugTrace( (LPARAM)this,"SMTP_DIRNOT::ProcessClient() - Pending IOs: %d",m_cPendingIoCount);
DebugTrace( (LPARAM)this,"SMTP_DIRNOT::ProcessClient() - ActiveThreads: %d",m_cActiveThreads);
fRet = TRUE;
}
TraceFunctLeaveEx((LPARAM)this);
return fRet;
}
/*++
Name :
ReadDirectoryCompletion
Description:
Handles a completed I/O for ReadDirectoryChanges
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 SMTP_DIRNOT::ReadDirectoryCompletion(PVOID pvContext, DWORD cbWritten,
DWORD dwCompletionStatus, OVERLAPPED * lpo)
{
BOOL WasProcessed;
SMTP_DIRNOT *pCC = (SMTP_DIRNOT *) pvContext;
TraceFunctEnterEx((LPARAM) pCC, "SMTP_DIRNOT::ReadDirectoryCompletion");
_ASSERT(pCC);
_ASSERT(pCC->IsValid());
_ASSERT(pCC->QuerySmtpInstance() != NULL);
if (dwCompletionStatus != NO_ERROR && dwCompletionStatus != ERROR_SEM_TIMEOUT)
ErrorTrace((LPARAM)pCC, "Error in Atq operation: %d\r\n", dwCompletionStatus);
WasProcessed = pCC->ProcessClient(cbWritten, dwCompletionStatus, lpo);
if(!WasProcessed)
{
SetEvent(pCC->QuerySmtpInstance()->GetDirnotStopHandle());
}
TraceFunctLeaveEx((LPARAM) pCC);
}