410 lines
11 KiB
C++
410 lines
11 KiB
C++
#ifndef __MAPISEND_H
|
|
#define __MAPISEND_H
|
|
|
|
/* File: mapisend.h
|
|
|
|
Description: Implements the most basic MAPI email client to send a message
|
|
to one or more recipients. All operations are done without UI.
|
|
|
|
classes: CMapiSession
|
|
CMapiMessage
|
|
CMapiMessageBody
|
|
CMapiRecipients
|
|
MAPI
|
|
|
|
Revision History:
|
|
|
|
Date Description Programmer
|
|
-------- --------------------------------------------------- ----------
|
|
06/18/97 Initial creation. BrianAu
|
|
06/22/97 Added class MAPI so clients can dynamically link BrianAu
|
|
to MAPI32.DLL.
|
|
*/
|
|
|
|
#ifndef _WINDOWS_
|
|
# include <windows.h>
|
|
#endif
|
|
|
|
#ifndef MAPIX_H
|
|
# include <mapix.h>
|
|
#endif
|
|
|
|
#ifndef _MAPIUTIL_H_
|
|
# include <mapiutil.h>
|
|
#endif
|
|
|
|
#ifndef MAPITAGS_H
|
|
# include <mapitags.h>
|
|
#endif
|
|
|
|
|
|
|
|
// MAPI
|
|
|
|
// This class allows a MAPI client to dynamically link to MAPI32.DLL instead
|
|
// of statically linking to it. This can help performance in that loading
|
|
// MAPI is explicitly controlled. The following example shows how to use
|
|
// the class.
|
|
|
|
// MAPI mapi;
|
|
// HRESULT hr;
|
|
|
|
// hr = mapi.Load(); // This calls LoadLibrary on MAPI32.DLL.
|
|
// if SUCCEEDED(hr))
|
|
// {
|
|
// hr = mapi.Initialize(NULL);
|
|
// if (SUCCEEDED(hr))
|
|
// {
|
|
// LPMAPISESSION pSession;
|
|
// hr = mapi.LogonEx(0, // Hwnd for any UI.
|
|
// NULL, // Profile name.
|
|
// NULL, // Password.
|
|
// dwLogonFlags, // Flags
|
|
// &pSession); // Session obj ptr (out).
|
|
// if (SUCCEEDED(hr))
|
|
// {
|
|
// //
|
|
// // Use MAPI interfaces.
|
|
// //
|
|
// }
|
|
// mapi.Uninitialize();
|
|
// }
|
|
// mapi.Unload(); // This calls FreeLibrary for MAPI32.DLL
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
// Function pointer typedefs for some MAPI functions.
|
|
// Used for defining function pointers in class MAPI.
|
|
|
|
|
|
// HrQueryAllRows
|
|
|
|
typedef HRESULT (STDMETHODCALLTYPE MAPIHRQUERYALLROWS)(
|
|
LPMAPITABLE lpTable,
|
|
LPSPropTagArray lpPropTags,
|
|
LPSRestriction lpRestriction,
|
|
LPSSortOrderSet lpSortOrderSet,
|
|
LONG crowsMax,
|
|
LPSRowSet FAR *lppRows);
|
|
|
|
typedef MAPIHRQUERYALLROWS FAR *LPMAPIHRQUERYALLROWS;
|
|
|
|
// FreePadrlist
|
|
|
|
typedef VOID (STDAPICALLTYPE MAPIFREEPADRLIST)(LPADRLIST lpAdrList);
|
|
typedef MAPIFREEPADRLIST FAR *LPMAPIFREEPADRLIST;
|
|
|
|
// FreeProws
|
|
|
|
typedef VOID (STDAPICALLTYPE MAPIFREEPROWS)(LPSRowSet lpRows);
|
|
typedef MAPIFREEPROWS FAR *LPMAPIFREEPROWS;
|
|
|
|
|
|
class MAPI
|
|
{
|
|
public:
|
|
MAPI(VOID);
|
|
~MAPI(VOID);
|
|
|
|
HRESULT Load(VOID);
|
|
VOID Unload(VOID);
|
|
|
|
HRESULT LogonEx(
|
|
ULONG ulUIParam,
|
|
LPTSTR lpszProfileName,
|
|
LPTSTR lpszPassword,
|
|
FLAGS flFlags,
|
|
LPMAPISESSION FAR * lppSession);
|
|
|
|
HRESULT Initialize(
|
|
LPVOID lpMapiInit);
|
|
|
|
VOID Uninitialize(VOID);
|
|
|
|
SCODE AllocateBuffer(
|
|
ULONG cbSize,
|
|
LPVOID FAR * lppBuffer);
|
|
|
|
SCODE AllocateMore(
|
|
ULONG cbSize,
|
|
LPVOID lpObject,
|
|
LPVOID FAR * lppBuffer);
|
|
|
|
ULONG FreeBuffer(
|
|
LPVOID lpBuffer);
|
|
|
|
HRESULT HrQueryAllRows(
|
|
LPMAPITABLE lpTable,
|
|
LPSPropTagArray lpPropTags,
|
|
LPSRestriction lpRestriction,
|
|
LPSSortOrderSet lpSortOrderSet,
|
|
LONG crowsMax,
|
|
LPSRowSet FAR *lppRows);
|
|
|
|
VOID FreePadrlist(LPADRLIST lpAdrlist);
|
|
|
|
VOID FreeProws(LPSRowSet lpRows);
|
|
|
|
private:
|
|
static LONG m_cLoadCount;
|
|
static HINSTANCE m_hmodMAPI;
|
|
static LPMAPIINITIALIZE m_pfnInitialize;
|
|
static LPMAPILOGONEX m_pfnLogonEx;
|
|
static LPMAPIUNINITIALIZE m_pfnUninitialize;
|
|
static LPMAPIALLOCATEBUFFER m_pfnAllocateBuffer;
|
|
static LPMAPIALLOCATEMORE m_pfnAllocateMore;
|
|
static LPMAPIFREEBUFFER m_pfnFreeBuffer;
|
|
static LPMAPIHRQUERYALLROWS m_pfnHrQueryAllRows;
|
|
static LPMAPIFREEPADRLIST m_pfnFreePadrlist;
|
|
static LPMAPIFREEPROWS m_pfnFreeProws;
|
|
|
|
|
|
// Prevent copy.
|
|
|
|
MAPI(const MAPI& rhs);
|
|
MAPI& operator = (const MAPI& rhs);
|
|
};
|
|
|
|
|
|
|
|
|
|
// CMapiRecipients
|
|
// Hides the grossness of adding entries and properties to a MAPI
|
|
// address list.
|
|
|
|
class CMapiRecipients
|
|
{
|
|
public:
|
|
CMapiRecipients(BOOL bUnicode = TRUE);
|
|
~CMapiRecipients(VOID);
|
|
|
|
CMapiRecipients(const CMapiRecipients& rhs);
|
|
CMapiRecipients& operator = (const CMapiRecipients& rhs);
|
|
|
|
|
|
// Does the address list contain unicode names?
|
|
|
|
BOOL IsUnicode(VOID)
|
|
{ return m_bUnicode; }
|
|
|
|
// Add a recipient to the address list.
|
|
|
|
HRESULT AddRecipient(LPCTSTR pszEmailName, DWORD dwType);
|
|
|
|
// Return a count of entries in the address list.
|
|
|
|
INT Count(VOID) const;
|
|
|
|
|
|
// Make it easy to use a CMapiRecipients object in calls to MAPI
|
|
// functions taking an LPADRLIST. Do note however that by
|
|
// giving a MAPI function direct access to the address list,
|
|
// you circumvent the automatic growth function built into this
|
|
// class. This conversion capability is generally intended for
|
|
// resolving names (which modifies the list but doesn't add entries)
|
|
// or for read access to the list.
|
|
|
|
operator LPADRLIST() const
|
|
{ return m_pal; }
|
|
|
|
private:
|
|
LPADRLIST m_pal; // Ptr to actual address list.
|
|
UINT m_cMaxEntries; // Size of list (max entries)
|
|
BOOL m_bUnicode; // Contains Ansi or Unicode names?
|
|
static UINT m_cGrowIncr; // How many entries we grow by each time.
|
|
|
|
HRESULT Grow(
|
|
UINT cEntries);
|
|
|
|
HRESULT CopyAdrListEntry(
|
|
ADRENTRY& Dest,
|
|
ADRENTRY& Src,
|
|
BOOL bConvertStrings);
|
|
|
|
HRESULT CopySPropVal(
|
|
LPVOID pvBaseAlloc,
|
|
SPropValue& Dest,
|
|
SPropValue& Src,
|
|
BOOL bConvertStrings);
|
|
|
|
HRESULT CopyVarLengthSPropVal(
|
|
LPVOID pvBaseAlloc,
|
|
LPVOID *ppvDest,
|
|
LPVOID pvSrc,
|
|
INT cb);
|
|
|
|
HRESULT CopySPropValString(
|
|
LPVOID pvBaseAlloc,
|
|
LPSTR *ppszDestA,
|
|
LPCWSTR pszSrcW);
|
|
|
|
HRESULT CopySPropValString(
|
|
LPVOID pvBaseAlloc,
|
|
LPWSTR *ppszDestW,
|
|
LPCSTR pszSrcA);
|
|
};
|
|
|
|
|
|
|
|
// CMapiMessageBody
|
|
// Encapsulates the addition of text into a MAPI message body.
|
|
// Maintains body text in an OLE stream so that we can easily append
|
|
// text as needed. Provides formatted text input through Append().
|
|
|
|
class CMapiMessageBody
|
|
{
|
|
public:
|
|
CMapiMessageBody(VOID);
|
|
~CMapiMessageBody(VOID);
|
|
|
|
CMapiMessageBody(const CMapiMessageBody& rhs);
|
|
CMapiMessageBody& operator = (const CMapiMessageBody& rhs);
|
|
|
|
|
|
// Append text to the stream.
|
|
|
|
HRESULT Append(LPCTSTR pszFmt, ...);
|
|
HRESULT Append(HINSTANCE hInst, UINT idFmt, ...);
|
|
HRESULT Append(LPCTSTR pszFmt, va_list *pargs);
|
|
HRESULT Append(HINSTANCE hInst, UINT idFmt, va_list *pargs);
|
|
|
|
BOOL IsValid(VOID)
|
|
{ return NULL != m_pStg && NULL != m_pStm; }
|
|
|
|
operator LPSTREAM()
|
|
{ return m_pStm; }
|
|
|
|
operator LPSTORAGE()
|
|
{ return m_pStg; }
|
|
|
|
private:
|
|
LPSTORAGE m_pStg;
|
|
LPSTREAM m_pStm;
|
|
|
|
HRESULT CommonConstruct(VOID);
|
|
};
|
|
|
|
|
|
|
|
// CMapiMessage
|
|
|
|
class CMapiMessage
|
|
{
|
|
public:
|
|
CMapiMessage(LPMAPIFOLDER pFolder);
|
|
CMapiMessage(LPMAPIFOLDER pFolder, CMapiMessageBody& body, LPCTSTR pszSubject = NULL);
|
|
~CMapiMessage(VOID);
|
|
|
|
|
|
// Set the message's subject line.
|
|
|
|
HRESULT SetSubject(LPCTSTR pszSubject);
|
|
|
|
// Append a line of text to the message body.
|
|
|
|
HRESULT Append(LPCTSTR pszFmt, ...);
|
|
HRESULT Append(HINSTANCE hInst, UINT idFmt, ...);
|
|
|
|
// Set the message's recipient list.
|
|
|
|
HRESULT SetRecipients(LPADRLIST pAdrList);
|
|
|
|
// Set props on a message.
|
|
|
|
HRESULT SetProps(ULONG cValues,
|
|
LPSPropValue lpPropArray,
|
|
LPSPropProblemArray *lppProblems);
|
|
|
|
// Save property changes.
|
|
|
|
HRESULT SaveChanges(ULONG ulFlags);
|
|
|
|
// Send the message.
|
|
// Assumes address list is completely resolved.
|
|
|
|
HRESULT Send(LPADRLIST pAdrList = NULL);
|
|
|
|
private:
|
|
LPMESSAGE m_pMsg;
|
|
CMapiMessageBody m_body;
|
|
|
|
HRESULT CommonConstruct(LPMAPIFOLDER pFolder);
|
|
|
|
|
|
// Prevent copy.
|
|
|
|
CMapiMessage(const CMapiMessage& rhs);
|
|
CMapiMessage& operator = (const CMapiMessage& rhs);
|
|
};
|
|
|
|
|
|
|
|
// CMapiSession
|
|
// Encapsulates a basic MAPI session for sending very simple text
|
|
// messages.
|
|
|
|
class CMapiSession
|
|
{
|
|
public:
|
|
CMapiSession(VOID);
|
|
~CMapiSession(VOID);
|
|
|
|
|
|
// Log on to MAPI, open the default store and open the outbox.
|
|
// If this succeeds, you're ready to send messages. The dtor
|
|
// will close everything down.
|
|
|
|
HRESULT Initialize(VOID);
|
|
|
|
// Send a message to a list of recipients.
|
|
|
|
HRESULT Send(LPADRLIST pAdrList, LPCTSTR pszSubject, LPCTSTR pszMsg);
|
|
HRESULT Send(LPADRLIST pAdrList, LPCTSTR pszSubject, CMapiMessageBody& body);
|
|
HRESULT Send(LPADRLIST pAdrList, CMapiMessage& msg);
|
|
|
|
// Get pointer to the address book.
|
|
|
|
HRESULT GetAddressBook(LPADRBOOK *ppAdrBook);
|
|
|
|
// Get pointer to outbox folder.
|
|
|
|
HRESULT GetOutBoxFolder(LPMAPIFOLDER *ppOutBoxFolder);
|
|
|
|
// Resolve a list of adresses.
|
|
|
|
HRESULT ResolveAddresses(LPADRLIST pAdrList);
|
|
|
|
// Get name of current session user.
|
|
|
|
HRESULT GetSessionUser(LPSPropValue *ppProps, ULONG *pcbProps);
|
|
|
|
// Report MAPI errors returned by some MAPI API calls.
|
|
// The error information is returned in a MAPIERROR
|
|
// structure.
|
|
|
|
VOID ReportErrorsReturned(HRESULT hr, BOOL bLogEvent = FALSE);
|
|
|
|
|
|
private:
|
|
LPMAPISESSION m_pSession; // Ptr to MAPI session object.
|
|
LPMDB m_pDefMsgStore; // Ptr to MAPI default msg store obj.
|
|
LPMAPIFOLDER m_pOutBoxFolder; // Ptr to MAPI outbox folder object.
|
|
BOOL m_bMapiInitialized; // Has MAPI been initialized?
|
|
|
|
HRESULT OpenDefMsgStore(VOID);
|
|
HRESULT OpenOutBoxFolder(VOID);
|
|
|
|
|
|
// Prevent copy.
|
|
|
|
CMapiSession(const CMapiSession& rhs);
|
|
CMapiSession& operator = (const CMapiSession& rhs);
|
|
};
|
|
|
|
|
|
|
|
#endif //__MAPISEND_H
|