652 lines
14 KiB
C++
652 lines
14 KiB
C++
// SendMail.cpp: implementation of the CSendMail class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "amisafe.h"
|
|
#include "SendMail.h"
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CSendMail::CSendMail(CInitMapi &_mapi) : pmsg(NULL), pmapi(_mapi)
|
|
{
|
|
}
|
|
|
|
CSendMail::~CSendMail()
|
|
{
|
|
if (pmsg != NULL)
|
|
UlRelease(pmsg);
|
|
}
|
|
|
|
|
|
//
|
|
// Create an outbound message, put data in it.
|
|
//
|
|
HRESULT CSendMail::CreateMail(LPSTR szSubject)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = HrCreateOutMessage(pmapi.pfldOutBox, &pmsg);
|
|
if(hr)
|
|
return hr;
|
|
|
|
hr = HrInitMsg(pmsg, pmapi.pvalSentMailEID, szSubject);
|
|
if(HR_FAILED(hr)) {
|
|
UlRelease(pmsg);
|
|
return hr;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CSendMail::Transmit()
|
|
{
|
|
HRESULT hr;
|
|
if (pmsg != NULL)
|
|
hr = pmsg->SubmitMessage(0);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Create a message in the outbox
|
|
//
|
|
HRESULT CSendMail::HrCreateOutMessage(LPMAPIFOLDER pfldOutBox, LPMESSAGE FAR * ppmM)
|
|
{
|
|
|
|
LPMESSAGE lpmResM = NULL;
|
|
HRESULT hr;
|
|
|
|
Assert(pfldOutBox);
|
|
|
|
hr = pfldOutBox->CreateMessage(NULL, MAPI_DEFERRED_ERRORS, &lpmResM);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
*ppmM = lpmResM;
|
|
|
|
return hrSuccess;
|
|
}
|
|
|
|
//
|
|
// Put the data from globals in the message
|
|
//
|
|
HRESULT CSendMail::HrInitMsg(LPMESSAGE pmsg, LPSPropValue pvalSentMailEID, LPSTR szSubject)
|
|
{
|
|
HRESULT hr;
|
|
enum {iSubj, iSentMail, iConvTopic, iConvIdx, iMsgClass, cProps};
|
|
// PR_SUBJECT, PR_SENTMAIL_ENTRYID,
|
|
// PR_CONVERSATION_TOPIC, PR_COVERSATION_INDEX
|
|
|
|
SPropValue props[cProps];
|
|
ULONG cbConvIdx = 0;
|
|
LPBYTE lpbConvIdx = NULL;
|
|
|
|
//subject and conversation topic
|
|
if(szSubject)
|
|
{
|
|
props[iSubj].ulPropTag = PR_SUBJECT;
|
|
props[iSubj].Value.LPSZ = szSubject;
|
|
|
|
props[iConvTopic].ulPropTag = PR_CONVERSATION_TOPIC;
|
|
props[iConvTopic].Value.LPSZ = szSubject;
|
|
}
|
|
else
|
|
{
|
|
props[iSubj].ulPropTag = PR_NULL;
|
|
props[iConvTopic].ulPropTag = PR_NULL;
|
|
}
|
|
|
|
// conversaton index
|
|
//if(!ScAddConversationIndex(0, NULL, &cbConvIdx, &lpbConvIdx))
|
|
//{
|
|
// props[iConvIdx].ulPropTag = PR_CONVERSATION_INDEX;
|
|
// props[iConvIdx].Value.bin.lpb = lpbConvIdx;
|
|
// props[iConvIdx].Value.bin.cb = cbConvIdx;
|
|
//}
|
|
//else
|
|
//{
|
|
props[iConvIdx].ulPropTag = PR_NULL;
|
|
//}
|
|
|
|
// sent mail entry id (we want to leave a copy in the "Sent Items" folder)
|
|
props[iSentMail] = *pvalSentMailEID;
|
|
|
|
props[iMsgClass].ulPropTag = PR_MESSAGE_CLASS;
|
|
props[iMsgClass].Value.lpszA = "IPM.Note";
|
|
|
|
hr = pmsg->SetProps(cProps, (LPSPropValue)&props, NULL);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
err:
|
|
if (lpbConvIdx != NULL)
|
|
MAPIFreeBuffer(lpbConvIdx);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
HRESULT CSendMail::SetRecipients(LPSTR szRecipients)
|
|
{
|
|
LPADRLIST pal = NULL;
|
|
HRESULT hr;
|
|
|
|
//recipients
|
|
hr = HrCreateAddrList(pmapi.pabAddrB, &pal, szRecipients);
|
|
if(HR_FAILED(hr))
|
|
goto err;
|
|
|
|
Assert(pal);
|
|
|
|
hr = pmsg->ModifyRecipients(0, pal);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
err:
|
|
FreePadrlist(pal);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Create an adrlist with resolved recipients
|
|
//
|
|
HRESULT CSendMail::HrCreateAddrList(LPADRBOOK pabAddrB, LPADRLIST * ppal, LPSTR szToRecips)
|
|
{
|
|
|
|
HRESULT hr;
|
|
LPADRLIST pal = NULL;
|
|
int ind;
|
|
#define chDELIMITER ';'
|
|
|
|
|
|
int nToRecips = 1;
|
|
LPSTR strToken = szToRecips;
|
|
while (strToken = strchr(strToken, chDELIMITER))
|
|
{
|
|
++strToken;
|
|
++nToRecips;
|
|
}
|
|
|
|
int cb = CbNewADRLIST(nToRecips);
|
|
|
|
hr = MAPIAllocateBuffer(cb, (LPVOID FAR *) &pal);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
ZeroMemory(pal, cb);
|
|
|
|
hr = MAPIAllocateBuffer(2 * sizeof(SPropValue),
|
|
(LPVOID FAR *)&pal->aEntries[0].rgPropVals);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
pal->aEntries[0].rgPropVals[0].ulPropTag = PR_DISPLAY_NAME;
|
|
pal->aEntries[0].rgPropVals[0].Value.LPSZ = szToRecips;
|
|
pal->aEntries[0].rgPropVals[1].ulPropTag = PR_RECIPIENT_TYPE;
|
|
pal->aEntries[0].rgPropVals[1].Value.l= MAPI_TO;
|
|
pal->aEntries[0].cValues = 2;
|
|
|
|
strToken = szToRecips;
|
|
|
|
for(ind = 1; ind < nToRecips; ++ind)
|
|
{
|
|
LPADRENTRY pae = &pal->aEntries[ind];
|
|
|
|
hr = MAPIAllocateBuffer(2 * sizeof(SPropValue),
|
|
(LPVOID FAR *)&pae->rgPropVals);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
strToken = strchr(strToken, chDELIMITER);
|
|
Assert(strToken);
|
|
|
|
*strToken++ = '\0';
|
|
|
|
pae->rgPropVals[0].ulPropTag = PR_DISPLAY_NAME;
|
|
pae->rgPropVals[0].Value.LPSZ = strToken;
|
|
pae->rgPropVals[1].ulPropTag = PR_RECIPIENT_TYPE;
|
|
pae->rgPropVals[1].Value.l = MAPI_TO;
|
|
pae->cValues = 2;
|
|
}
|
|
|
|
pal->cEntries = nToRecips;
|
|
hr = pabAddrB->ResolveName(0, 0, NULL, pal);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
*ppal = pal;
|
|
|
|
return hrSuccess;
|
|
|
|
err:
|
|
|
|
FreePadrlist(pal);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// CInitMapi Class
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CInitMapi::CInitMapi() : fMAPIInited(FALSE), pabAddrB(NULL),
|
|
pfldOutBox(NULL), pmdb(NULL), pses(NULL), pvalSentMailEID(NULL)
|
|
{
|
|
|
|
}
|
|
|
|
CInitMapi::~CInitMapi()
|
|
{
|
|
DeInitMapi();
|
|
}
|
|
|
|
|
|
//
|
|
// Init MAPI. Open address book, default message store, outbox
|
|
//
|
|
HRESULT CInitMapi::InitMapi(void)
|
|
{
|
|
|
|
HRESULT hr;
|
|
|
|
hr = MAPIInitialize(NULL);
|
|
if(hr)
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
fMAPIInited = TRUE;
|
|
|
|
hr = MAPILogonEx( NULL, NULL /* szProfile */ , NULL /* szPassword */,
|
|
MAPI_EXTENDED | MAPI_NEW_SESSION | MAPI_USE_DEFAULT,
|
|
&pses);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
hr = HrOpenDefaultStore(pses, &pmdb);
|
|
if(HR_FAILED(hr))
|
|
goto err;
|
|
|
|
hr = HrOpenAddressBook(pses, &pabAddrB);
|
|
if(HR_FAILED(hr))
|
|
goto err;
|
|
|
|
hr = HrOpenOutFolder(pses, pmdb, &pfldOutBox);
|
|
if(HR_FAILED(hr))
|
|
goto err;
|
|
|
|
/* retrieve the EntryID of the sentmail folder and change the property tag
|
|
so that it is ready to use on a message*/
|
|
hr = HrGetOneProp((LPMAPIPROP)pmdb, PR_IPM_SENTMAIL_ENTRYID, &pvalSentMailEID);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
pvalSentMailEID->ulPropTag = PR_SENTMAIL_ENTRYID;
|
|
|
|
return hrSuccess;
|
|
|
|
err:
|
|
DeInitMapi();
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Release MAPI interfaces and logoff
|
|
//
|
|
void CInitMapi::DeInitMapi(void)
|
|
{
|
|
if (pfldOutBox != NULL)
|
|
{
|
|
UlRelease(pfldOutBox);
|
|
pfldOutBox = NULL;
|
|
}
|
|
|
|
if(pmdb != NULL)
|
|
{
|
|
//get our message out of the outbox
|
|
ULONG ulFlags = LOGOFF_PURGE;
|
|
HRESULT hr;
|
|
|
|
hr = pmdb->StoreLogoff(&ulFlags);
|
|
|
|
UlRelease(pmdb);
|
|
pmdb = NULL;
|
|
}
|
|
|
|
if (pabAddrB != NULL) {
|
|
UlRelease(pabAddrB);
|
|
pabAddrB = NULL;
|
|
}
|
|
|
|
if (pvalSentMailEID != NULL) {
|
|
MAPIFreeBuffer(pvalSentMailEID);
|
|
pvalSentMailEID = NULL;
|
|
}
|
|
|
|
if(pses != NULL)
|
|
{
|
|
pses->Logoff(0, 0, 0);
|
|
UlRelease(pses);
|
|
pses = NULL;
|
|
}
|
|
|
|
if(fMAPIInited)
|
|
{
|
|
MAPIUninitialize();
|
|
fMAPIInited = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Open the default message store. (The one that has PR_DEFAULT_STORE set to
|
|
// TRUE in the message store table.
|
|
//
|
|
HRESULT CInitMapi::HrOpenDefaultStore(LPMAPISESSION pses, LPMDB * ppmdb)
|
|
{
|
|
HRESULT hr;
|
|
LPMDB lpmdb = NULL;
|
|
LPMAPITABLE ptable = NULL;
|
|
LPSRowSet prows = NULL;
|
|
LPSPropValue pvalProp = NULL;
|
|
static SizedSPropTagArray(2, columns) =
|
|
{ 2, { PR_DEFAULT_STORE, PR_ENTRYID} };
|
|
SPropValue valDefStore;
|
|
SRestriction restDefStore;
|
|
|
|
|
|
valDefStore.ulPropTag = PR_DEFAULT_STORE;
|
|
valDefStore.dwAlignPad = 0;
|
|
valDefStore.Value.b = TRUE;
|
|
|
|
restDefStore.rt = RES_PROPERTY;
|
|
restDefStore.res.resProperty.relop = RELOP_EQ;
|
|
restDefStore.res.resProperty.ulPropTag = PR_DEFAULT_STORE;
|
|
restDefStore.res.resProperty.lpProp = &valDefStore;
|
|
|
|
Assert(pses);
|
|
|
|
hr = pses->GetMsgStoresTable(0, &ptable);
|
|
if (HR_FAILED(hr))
|
|
{
|
|
goto ret;
|
|
}
|
|
|
|
|
|
hr = HrQueryAllRows(ptable, (LPSPropTagArray) &columns, &restDefStore, NULL, 0, &prows);
|
|
if (HR_FAILED(hr))
|
|
{
|
|
goto ret;
|
|
}
|
|
|
|
if (prows == NULL || prows->cRows == 0
|
|
|| prows->aRow[0].lpProps[1].ulPropTag != PR_ENTRYID)
|
|
{
|
|
::MessageBox(NULL, "No default store", NULL, MB_OK);
|
|
goto ret;
|
|
}
|
|
|
|
Assert(prows->cRows == 1);
|
|
|
|
hr = pses->OpenMsgStore(0,
|
|
prows->aRow[0].lpProps[1].Value.bin.cb,
|
|
(LPENTRYID)prows->aRow[0].lpProps[1].Value.bin.lpb,
|
|
NULL, MDB_WRITE | MAPI_DEFERRED_ERRORS, &lpmdb);
|
|
if (HR_FAILED(hr))
|
|
{
|
|
//if (GetScode(hr) != MAPI_E_USER_CANCEL)
|
|
// TraceFnResult(OpenMsgStore, hr);
|
|
goto ret;
|
|
}
|
|
|
|
#if 0
|
|
if(hr) /*if we have a warning, display it and succeed */
|
|
{
|
|
LPMAPIERROR perr = NULL;
|
|
|
|
pses->lpVtbl->GetLastError(pses, hr, 0, &perr);
|
|
MakeMessageBox(hWnd, GetScode(hr), IDS_OPENSTOREWARN, perr, MBS_ERROR);
|
|
MAPIFreeBuffer(perr);
|
|
}
|
|
|
|
#endif
|
|
|
|
Assert(lpmdb != NULL);
|
|
|
|
*ppmdb = lpmdb;
|
|
|
|
|
|
|
|
ret:
|
|
FreeProws(prows);
|
|
UlRelease(ptable);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Open MAPI address book
|
|
//
|
|
HRESULT CInitMapi::HrOpenAddressBook(LPMAPISESSION pses, LPADRBOOK * ppAddrBook)
|
|
{
|
|
HRESULT hr;
|
|
LPADRBOOK pabAddrBook = NULL;
|
|
|
|
Assert(pses);
|
|
|
|
hr = pses->OpenAddressBook(0, NULL, 0, &pabAddrBook);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
#if 0
|
|
if(hr) /*if we have a warning*/
|
|
{
|
|
LPMAPIERROR perr = NULL;
|
|
|
|
pses->lpVtbl->GetLastError(pses, hr, 0, &perr);
|
|
MakeMessageBox(hwnd, GetScode(hr), IDS_OPENABWARN, perr, MBS_ERROR);
|
|
MAPIFreeBuffer(perr);
|
|
}
|
|
#endif
|
|
|
|
*ppAddrBook = pabAddrBook;
|
|
|
|
return hrSuccess;
|
|
}
|
|
|
|
//
|
|
// Open the outbox of the default store.
|
|
// Assumes the default message store has been opened.
|
|
//
|
|
HRESULT CInitMapi::HrOpenOutFolder(LPMAPISESSION pses, LPMDB pmdb, LPMAPIFOLDER FAR * lppF)
|
|
{
|
|
LPMAPIFOLDER lpfOutF = NULL;
|
|
HRESULT hr;
|
|
LPSPropValue lpspvFEID = NULL;
|
|
ULONG ulObjType = 0;
|
|
|
|
Assert(pmdb);
|
|
|
|
*lppF = NULL;
|
|
hr = HrGetOneProp((LPMAPIPROP) pmdb, PR_IPM_OUTBOX_ENTRYID, &lpspvFEID);
|
|
if(hr)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
Assert(lpspvFEID->ulPropTag == PR_IPM_OUTBOX_ENTRYID);
|
|
|
|
hr = pmdb->OpenEntry(lpspvFEID->Value.bin.cb,
|
|
(LPENTRYID)lpspvFEID->Value.bin.lpb, NULL,
|
|
MAPI_MODIFY | MAPI_DEFERRED_ERRORS,
|
|
&ulObjType, (LPUNKNOWN FAR *) &lpfOutF);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
*lppF = lpfOutF;
|
|
|
|
|
|
err:
|
|
MAPIFreeBuffer(lpspvFEID);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// CAddressEnum Class
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CAddressEnum::CAddressEnum(CInitMapi &_mapi): pmapi(_mapi)
|
|
{
|
|
|
|
}
|
|
|
|
CAddressEnum::~CAddressEnum()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
HRESULT CAddressEnum::HrLookupSingleAddr(LPADRBOOK pabAddrB,
|
|
LPSTR szInputName,
|
|
LPSTR szResultBuffer, DWORD dwBufferSize)
|
|
{
|
|
HRESULT hr;
|
|
LPADRLIST pal = NULL;
|
|
|
|
int cb = CbNewADRLIST(1);
|
|
|
|
hr = MAPIAllocateBuffer(cb, (LPVOID FAR *) &pal);
|
|
if(hr) {
|
|
goto err;
|
|
}
|
|
ZeroMemory(pal, cb);
|
|
|
|
hr = MAPIAllocateBuffer(2 * sizeof(SPropValue),
|
|
(LPVOID FAR *)&pal->aEntries[0].rgPropVals);
|
|
if(hr) {
|
|
goto err;
|
|
}
|
|
|
|
pal->aEntries[0].rgPropVals[0].ulPropTag = PR_DISPLAY_NAME;
|
|
pal->aEntries[0].rgPropVals[0].Value.lpszA = szInputName;
|
|
pal->aEntries[0].rgPropVals[1].ulPropTag = PR_RECIPIENT_TYPE;
|
|
pal->aEntries[0].rgPropVals[1].Value.l= MAPI_TO;
|
|
pal->aEntries[0].cValues = 2;
|
|
pal->cEntries = 1;
|
|
|
|
hr = pabAddrB->ResolveName(0, 0, NULL, pal);
|
|
if(HR_FAILED(hr)) {
|
|
goto err;
|
|
}
|
|
|
|
for (int ind = 0; ind < (int) pal->cEntries; ind++) {
|
|
for (int prop = 0; prop < (int) pal->aEntries[ind].cValues; prop++) {
|
|
if (pal->aEntries[ind].rgPropVals[prop].ulPropTag == PR_DISPLAY_NAME ||
|
|
pal->aEntries[ind].rgPropVals[prop].ulPropTag == PR_EMAIL_ADDRESS) {
|
|
strncpy(szResultBuffer,
|
|
pal->aEntries[ind].rgPropVals[prop].Value.lpszA,
|
|
dwBufferSize);
|
|
szResultBuffer[dwBufferSize - 1] = '\0';
|
|
hr = S_OK;
|
|
goto err;
|
|
}
|
|
}
|
|
}
|
|
hr = MAPI_E_NOT_FOUND;
|
|
|
|
err:
|
|
|
|
FreePadrlist(pal);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CAddressEnum::LookupAddress(LPSTR szInputName, LPSTR szResultBuffer, DWORD dwBufferSize)
|
|
{
|
|
return HrLookupSingleAddr(pmapi.pabAddrB, szInputName, szResultBuffer, dwBufferSize);
|
|
}
|
|
|
|
|
|
#if 0
|
|
HRESULT hr;
|
|
LPABCONT pabRootCont; // IABContainer
|
|
LPMAPITABLE pMapiTable;
|
|
|
|
// LPADRBOOK IAddrBook
|
|
|
|
// Open the address book's root container
|
|
hr = pmapi.pabAddrB->OpenEntry(0, NULL, IABContainer, MAPI_BEST_ACCESS,
|
|
NULL, (LPUNKNOWN FAR *) &pabRootCont);
|
|
if (HR_FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
hr = pabRootCont->GetContentsTable(0, &pMapiTable);
|
|
if (HR_FAILED(hr)) {
|
|
UlRelease(pabRootCont);
|
|
return hr;
|
|
}
|
|
|
|
hr = HrQueryAllRows(pMapiTable,
|
|
LPSPropTagArray ptaga,
|
|
LPSRestriction pres,
|
|
NULL, // sort order
|
|
10, // maximum records to return
|
|
LPSRowSet FAR * pprows
|
|
);
|
|
|
|
GetContentsTable
|
|
IMAPITable::SortTable,
|
|
IMAPITable::QueryRows
|
|
#endif
|