home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / mapispi.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  46.3 KB  |  930 lines
  1. /*
  2.  *  M A P I S P I . H
  3.  *
  4.  *  Defines the calls and structures exchanged between MAPI or the spooler
  5.  *  and the MAPI service providers
  6.  *
  7.  *  Copyright 1986-1996 Microsoft Corporation. All Rights Reserved.
  8.  */
  9.  
  10. #ifndef MAPISPI_H
  11. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  12. #define MAPISPI_H
  13. /* Include common MAPI header files if they haven't been already. */
  14. #ifndef MAPIDEFS_H
  15. #include <mapidefs.h>
  16. #endif
  17. #ifndef MAPICODE_H
  18. #include <mapicode.h>
  19. #endif
  20. #ifndef MAPIGUID_H
  21. #include <mapiguid.h>
  22. #endif
  23. #ifndef MAPITAGS_H
  24. #include <mapitags.h>
  25. #endif
  26.  
  27. #if defined (WIN16) || defined (DOS) || defined (DOS16)
  28. #include <storage.h>
  29. #endif
  30.  
  31. #ifndef BEGIN_INTERFACE
  32. #define BEGIN_INTERFACE
  33. #endif
  34.  
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif
  38.  
  39. /*  The MAPI SPI has a version number.  MAPIX.DLL knows and supports
  40.  *  one or more versions of the SPI.  Each provider supports one or
  41.  *  more versions of the SPI.  Checks are performed in both MAPIX.DLL
  42.  *  and in the provider to ensure that they agree to use exactly one
  43.  *  version of the MAPI SPI.
  44.  *
  45.  *  The SPI version number is composed of a major (8-bit) version,
  46.  *  minor (8-bit) version, and micro (16-bit) version.  The first
  47.  *  retail ship of MAPI 1.0 is expected to be version 1.0.0.
  48.  *  The major version number changes rarely.
  49.  *  The minor version number changes opon each retail ship of
  50.  *  MAPI if the SPI has been modified.
  51.  *  The micro version number changes internally at Microsoft
  52.  *  during development of MAPI.
  53.  *
  54.  *  The version of the SPI documented by this set of header files
  55.  *  is ALWAYS known as "CURRENT_SPI_VERSION".  If you write a
  56.  *  service provider, and get a new set of header files, and update
  57.  *  your code to the new interface, you'll be at the "current" version.
  58.  */
  59. #define CURRENT_SPI_VERSION 0x00010010L
  60.  
  61. /*  Here are some well-known SPI version numbers:
  62.  *  (These will eventually be useful for provider-writers who
  63.  *  might choose to make provider DLLs that support more than
  64.  *  one version of the MAPI SPI.
  65.  */
  66. #define PDK1_SPI_VERSION    0x00010000L /* 0.1.0  MAPI PDK1 Spring 1993 */
  67.  
  68. #define PDK2_SPI_VERSION    0x00010008L /* 0.1.8  MAPI PDK2 Spring 1994 */
  69.  
  70. #define PDK3_SPI_VERSION    0x00010010L /* 0.1.16 MAPI PDK3 Fall 1994   */
  71.  
  72. /*
  73.  * Forward declaration of interface pointers specific to the service
  74.  * provider interface.
  75.  */
  76. DECLARE_MAPI_INTERFACE_PTR(IMAPISupport, LPMAPISUP);
  77.  
  78. /* IMAPISupport Interface -------------------------------------------------- */
  79.  
  80. /* Notification key structure for the MAPI notification engine */
  81.  
  82. typedef struct
  83. {
  84.     ULONG       cb;             /* How big the key is */
  85.     BYTE        ab[MAPI_DIM];   /* Key contents */
  86. } NOTIFKEY, FAR * LPNOTIFKEY;
  87.  
  88. #define CbNewNOTIFKEY(_cb)      (offsetof(NOTIFKEY,ab) + (_cb))
  89. #define CbNOTIFKEY(_lpkey)      (offsetof(NOTIFKEY,ab) + (_lpkey)->cb)
  90. #define SizedNOTIFKEY(_cb, _name) \
  91.     struct _NOTIFKEY_ ## _name \
  92. { \
  93.     ULONG       cb; \
  94.     BYTE        ab[_cb]; \
  95. } _name
  96.  
  97.  
  98. /* For Subscribe() */
  99.  
  100. #define NOTIFY_SYNC             ((ULONG) 0x40000000)
  101.  
  102. /* For Notify() */
  103.  
  104. #define NOTIFY_CANCELED         ((ULONG) 0x80000000)
  105.  
  106.  
  107. /* From the Notification Callback function (well, this is really a ulResult) */
  108.  
  109. #define CALLBACK_DISCONTINUE    ((ULONG) 0x80000000)
  110.  
  111. /* For Transport's SpoolerNotify() */
  112.  
  113. #define NOTIFY_NEWMAIL          ((ULONG) 0x00000001)
  114. #define NOTIFY_READYTOSEND      ((ULONG) 0x00000002)
  115. #define NOTIFY_SENTDEFERRED     ((ULONG) 0x00000004)
  116. #define NOTIFY_CRITSEC          ((ULONG) 0x00001000)
  117. #define NOTIFY_NONCRIT          ((ULONG) 0x00002000)
  118. #define NOTIFY_CONFIG_CHANGE    ((ULONG) 0x00004000)
  119. #define NOTIFY_CRITICAL_ERROR   ((ULONG) 0x10000000)
  120.  
  121. /* For Message Store's SpoolerNotify() */
  122.  
  123. #define NOTIFY_NEWMAIL_RECEIVED ((ULONG) 0x20000000)
  124.  
  125. /* For ModifyStatusRow() */
  126.  
  127. #define STATUSROW_UPDATE        ((ULONG) 0x10000000)
  128.  
  129. /* For IStorageFromStream() */
  130.  
  131. #define STGSTRM_RESET           ((ULONG) 0x00000000)
  132. #define STGSTRM_CURRENT         ((ULONG) 0x10000000)
  133. #define STGSTRM_MODIFY          ((ULONG) 0x00000002)
  134. #define STGSTRM_CREATE          ((ULONG) 0x00001000)
  135.  
  136. /* For GetOneOffTable() */
  137. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  138.  
  139. /* For CreateOneOff() */
  140. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  141. /****** MAPI_SEND_NO_RICH_INFO  ((ULONG) 0x00010000) */
  142.  
  143. /* For ReadReceipt() */
  144. #define MAPI_NON_READ           ((ULONG) 0x00000001)
  145.  
  146. /* For DoConfigPropSheet() */
  147. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  148.  
  149. /* Preprocessor calls: */
  150.  
  151. /* PreprocessMessage, first ordinal in RegisterPreprocessor(). */
  152.  
  153. typedef HRESULT (STDMETHODCALLTYPE PREPROCESSMESSAGE)(
  154.                     LPVOID lpvSession,
  155.                     LPMESSAGE lpMessage,
  156.                     LPADRBOOK lpAdrBook,
  157.                     LPMAPIFOLDER lpFolder,
  158.                     LPALLOCATEBUFFER AllocateBuffer,
  159.                     LPALLOCATEMORE AllocateMore,
  160.                     LPFREEBUFFER FreeBuffer,
  161.                     ULONG FAR *lpcOutbound,
  162.                     LPMESSAGE FAR * FAR *lpppMessage,
  163.                     LPADRLIST FAR *lppRecipList);
  164.  
  165. /* RemovePreprocessInfo, second ordinal in RegisterPreprocessor(). */
  166.  
  167. typedef HRESULT (STDMETHODCALLTYPE REMOVEPREPROCESSINFO)(LPMESSAGE lpMessage);
  168.  
  169. /* Function pointer for GetReleaseInfo */
  170.  
  171. #define MAPI_IMAPISUPPORT_METHODS1(IPURE)                               \
  172.     MAPIMETHOD(GetLastError)                                            \
  173.         (THIS_  HRESULT                     hResult,                    \
  174.                 ULONG                       ulFlags,                    \
  175.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  176.     MAPIMETHOD(GetMemAllocRoutines)                                     \
  177.         (THIS_  LPALLOCATEBUFFER FAR *      lpAllocateBuffer,           \
  178.                 LPALLOCATEMORE FAR *        lpAllocateMore,             \
  179.                 LPFREEBUFFER FAR *          lpFreeBuffer) IPURE;        \
  180.     MAPIMETHOD(Subscribe)                                               \
  181.         (THIS_  LPNOTIFKEY                  lpKey,                      \
  182.                 ULONG                       ulEventMask,                \
  183.                 ULONG                       ulFlags,                    \
  184.                 LPMAPIADVISESINK            lpAdviseSink,               \
  185.                 ULONG FAR *                 lpulConnection) IPURE;      \
  186.     MAPIMETHOD(Unsubscribe)                                             \
  187.         (THIS_  ULONG                       ulConnection) IPURE;        \
  188.     MAPIMETHOD(Notify)                                                  \
  189.         (THIS_  LPNOTIFKEY                  lpKey,                      \
  190.                 ULONG                       cNotification,              \
  191.                 LPNOTIFICATION              lpNotifications,            \
  192.                 ULONG FAR *                 lpulFlags) IPURE;           \
  193.     MAPIMETHOD(ModifyStatusRow)                                         \
  194.         (THIS_  ULONG                       cValues,                    \
  195.                 LPSPropValue                lpColumnVals,               \
  196.                 ULONG                       ulFlags) IPURE;             \
  197.     MAPIMETHOD(OpenProfileSection)                                      \
  198.         (THIS_  LPMAPIUID                   lpUid,                      \
  199.                 ULONG                       ulFlags,                    \
  200.                 LPPROFSECT FAR *            lppProfileObj) IPURE;       \
  201.     MAPIMETHOD(RegisterPreprocessor)                                    \
  202.         (THIS_  LPMAPIUID                   lpMuid,                     \
  203.                 LPTSTR                      lpszAdrType,                \
  204.                 LPTSTR                      lpszDLLName,                \
  205.                 LPSTR   /* String8! */      lpszPreprocess,             \
  206.                 LPSTR   /* String8! */      lpszRemovePreprocessInfo,   \
  207.                 ULONG                       ulFlags) IPURE;             \
  208.     MAPIMETHOD(NewUID)                                                  \
  209.         (THIS_  LPMAPIUID                   lpMuid) IPURE;              \
  210.     MAPIMETHOD(MakeInvalid)                                             \
  211.         (THIS_  ULONG                       ulFlags,                    \
  212.                 LPVOID                      lpObject,                   \
  213.                 ULONG                       ulRefCount,                 \
  214.                 ULONG                       cMethods) IPURE;            \
  215.  
  216. #define MAPI_IMAPISUPPORT_METHODS2(IPURE)                               \
  217.     MAPIMETHOD(SpoolerYield)                                            \
  218.         (THIS_  ULONG                       ulFlags) IPURE;             \
  219.     MAPIMETHOD(SpoolerNotify)                                           \
  220.         (THIS_  ULONG                       ulFlags,                    \
  221.                 LPVOID                      lpvData) IPURE;             \
  222.     MAPIMETHOD(CreateOneOff)                                            \
  223.         (THIS_  LPTSTR                      lpszName,                   \
  224.                 LPTSTR                      lpszAdrType,                \
  225.                 LPTSTR                      lpszAddress,                \
  226.                 ULONG                       ulFlags,                    \
  227.                 ULONG FAR *                 lpcbEntryID,                \
  228.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  229.     MAPIMETHOD(SetProviderUID)                                          \
  230.         (THIS_  LPMAPIUID                   lpProviderID,               \
  231.                 ULONG                       ulFlags) IPURE;             \
  232.     MAPIMETHOD(CompareEntryIDs)                                         \
  233.         (THIS_  ULONG                       cbEntry1,                   \
  234.                 LPENTRYID                   lpEntry1,                   \
  235.                 ULONG                       cbEntry2,                   \
  236.                 LPENTRYID                   lpEntry2,                   \
  237.                 ULONG                       ulCompareFlags,             \
  238.                 ULONG FAR *                 lpulResult) IPURE;          \
  239.     MAPIMETHOD(OpenTemplateID)                                          \
  240.         (THIS_  ULONG                       cbTemplateID,               \
  241.                 LPENTRYID                   lpTemplateID,               \
  242.                 ULONG                       ulTemplateFlags,            \
  243.                 LPMAPIPROP                  lpMAPIPropData,             \
  244.                 LPCIID                      lpInterface,                \
  245.                 LPMAPIPROP FAR *            lppMAPIPropNew,             \
  246.                 LPMAPIPROP                  lpMAPIPropSibling) IPURE;   \
  247.     MAPIMETHOD(OpenEntry)                                               \
  248.         (THIS_  ULONG                       cbEntryID,                  \
  249.                 LPENTRYID                   lpEntryID,                  \
  250.                 LPCIID                      lpInterface,                \
  251.                 ULONG                       ulOpenFlags,                \
  252.                 ULONG FAR *                 lpulObjType,                \
  253.                 LPUNKNOWN FAR *             lppUnk) IPURE;              \
  254.     MAPIMETHOD(GetOneOffTable)                                          \
  255.         (THIS_  ULONG                       ulFlags,                    \
  256.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  257.     MAPIMETHOD(Address)                                                 \
  258.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  259.                 LPADRPARM                   lpAdrParms,                 \
  260.                 LPADRLIST FAR *             lppAdrList) IPURE;          \
  261.     MAPIMETHOD(Details)                                                 \
  262.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  263.                 LPFNDISMISS                 lpfnDismiss,                \
  264.                 LPVOID                      lpvDismissContext,          \
  265.                 ULONG                       cbEntryID,                  \
  266.                 LPENTRYID                   lpEntryID,                  \
  267.                 LPFNBUTTON                  lpfButtonCallback,          \
  268.                 LPVOID                      lpvButtonContext,           \
  269.                 LPTSTR                      lpszButtonText,             \
  270.                 ULONG                       ulFlags) IPURE;             \
  271.     MAPIMETHOD(NewEntry)                                                \
  272.         (THIS_  ULONG                       ulUIParam,                  \
  273.                 ULONG                       ulFlags,                    \
  274.                 ULONG                       cbEIDContainer,             \
  275.                 LPENTRYID                   lpEIDContainer,             \
  276.                 ULONG                       cbEIDNewEntryTpl,           \
  277.                 LPENTRYID                   lpEIDNewEntryTpl,           \
  278.                 ULONG FAR *                 lpcbEIDNewEntry,            \
  279.                 LPENTRYID FAR *             lppEIDNewEntry) IPURE;      \
  280.     MAPIMETHOD(DoConfigPropsheet)                                       \
  281.         (THIS_  ULONG                       ulUIParam,                  \
  282.                 ULONG                       ulFlags,                    \
  283.                 LPTSTR                      lpszTitle,                  \
  284.                 LPMAPITABLE                 lpDisplayTable,             \
  285.                 LPMAPIPROP                  lpCOnfigData,               \
  286.                 ULONG                       ulTopPage) IPURE;           \
  287.     MAPIMETHOD(CopyMessages)                                            \
  288.         (THIS_  LPCIID                      lpSrcInterface,             \
  289.                 LPVOID                      lpSrcFolder,                \
  290.                 LPENTRYLIST                 lpMsgList,                  \
  291.                 LPCIID                      lpDestInterface,            \
  292.                 LPVOID                      lpDestFolder,               \
  293.                 ULONG                       ulUIParam,                  \
  294.                 LPMAPIPROGRESS              lpProgress,                 \
  295.                 ULONG                       ulFlags) IPURE;             \
  296.     MAPIMETHOD(CopyFolder)                                              \
  297.         (THIS_  LPCIID                      lpSrcInterface,             \
  298.                 LPVOID                      lpSrcFolder,                \
  299.                 ULONG                       cbEntryID,                  \
  300.                 LPENTRYID                   lpEntryID,                  \
  301.                 LPCIID                      lpDestInterface,            \
  302.                 LPVOID                      lpDestFolder,               \
  303.                 LPTSTR                      lszNewFolderName,           \
  304.                 ULONG                       ulUIParam,                  \
  305.                 LPMAPIPROGRESS              lpProgress,                 \
  306.                 ULONG                       ulFlags) IPURE;             \
  307.  
  308. #define MAPI_IMAPISUPPORT_METHODS3(IPURE)                               \
  309.     MAPIMETHOD(DoCopyTo)                                                \
  310.         (THIS_  LPCIID                      lpSrcInterface,             \
  311.                 LPVOID                      lpSrcObj,                   \
  312.                 ULONG                       ciidExclude,                \
  313.                 LPCIID                      rgiidExclude,               \
  314.                 LPSPropTagArray             lpExcludeProps,             \
  315.                 ULONG                       ulUIParam,                  \
  316.                 LPMAPIPROGRESS              lpProgress,                 \
  317.                 LPCIID                      lpDestInterface,            \
  318.                 LPVOID                      lpDestObj,                  \
  319.                 ULONG                       ulFlags,                    \
  320.                 LPSPropProblemArray FAR *   lppProblems) IPURE;         \
  321.     MAPIMETHOD(DoCopyProps)                                             \
  322.         (THIS_  LPCIID                      lpSrcInterface,             \
  323.                 LPVOID                      lpSrcObj,                   \
  324.                 LPSPropTagArray             lpIncludeProps,             \
  325.                 ULONG                       ulUIParam,                  \
  326.                 LPMAPIPROGRESS              lpProgress,                 \
  327.                 LPCIID                      lpDestInterface,            \
  328.                 LPVOID                      lpDestObj,                  \
  329.                 ULONG                       ulFlags,                    \
  330.                 LPSPropProblemArray FAR *   lppProblems) IPURE;         \
  331.     MAPIMETHOD(DoProgressDialog)                                        \
  332.         (THIS_  ULONG                       ulUIParam,                  \
  333.                 ULONG                       ulFlags,                    \
  334.                 LPMAPIPROGRESS FAR *        lppProgress) IPURE;         \
  335.     MAPIMETHOD(ReadReceipt)                                             \
  336.         (THIS_  ULONG                       ulFlags,                    \
  337.                 LPMESSAGE                   lpReadMessage,              \
  338.                 LPMESSAGE FAR *             lppEmptyMessage) IPURE;     \
  339.     MAPIMETHOD(PrepareSubmit)                                           \
  340.         (THIS_  LPMESSAGE                   lpMessage,                  \
  341.                 ULONG FAR *                 lpulFlags) IPURE;           \
  342.     MAPIMETHOD(ExpandRecips)                                            \
  343.         (THIS_  LPMESSAGE                   lpMessage,                  \
  344.                 ULONG FAR *                 lpulFlags) IPURE;           \
  345.     MAPIMETHOD(UpdatePAB)                                               \
  346.         (THIS_  ULONG                       ulFlags,                    \
  347.                 LPMESSAGE                   lpMessage) IPURE;           \
  348.     MAPIMETHOD(DoSentMail)                                              \
  349.         (THIS_  ULONG                       ulFlags,                    \
  350.                 LPMESSAGE                   lpMessage) IPURE;           \
  351.     MAPIMETHOD(OpenAddressBook)                                         \
  352.         (THIS_  LPCIID                      lpInterface,                \
  353.                 ULONG                       ulFlags,                    \
  354.                 LPADRBOOK FAR *             lppAdrBook) IPURE;          \
  355.     MAPIMETHOD(Preprocess)                                              \
  356.         (THIS_  ULONG                       ulFlags,                    \
  357.                 ULONG                       cbEntryID,                  \
  358.                 LPENTRYID                   lpEntryID) IPURE;           \
  359.     MAPIMETHOD(CompleteMsg)                                             \
  360.         (THIS_  ULONG                       ulFlags,                    \
  361.                 ULONG                       cbEntryID,                  \
  362.                 LPENTRYID                   lpEntryID) IPURE;           \
  363.     MAPIMETHOD(StoreLogoffTransports)                                   \
  364.         (THIS_  ULONG FAR *                 lpulFlags) IPURE;           \
  365.     MAPIMETHOD(StatusRecips)                                            \
  366.         (THIS_  LPMESSAGE                   lpMessage,                  \
  367.                 LPADRLIST                   lpRecipList) IPURE;         \
  368.     MAPIMETHOD(WrapStoreEntryID)                                        \
  369.         (THIS_  ULONG                       cbOrigEntry,                \
  370.                 LPENTRYID                   lpOrigEntry,                \
  371.                 ULONG FAR *                 lpcbWrappedEntry,           \
  372.                 LPENTRYID FAR *             lppWrappedEntry) IPURE;     \
  373.     MAPIMETHOD(ModifyProfile)                                           \
  374.         (THIS_  ULONG                       ulFlags) IPURE;             \
  375.     MAPIMETHOD(IStorageFromStream)                                      \
  376.         (THIS_  LPUNKNOWN                   lpUnkIn,                    \
  377.                 LPCIID                      lpInterface,                \
  378.                 ULONG                       ulFlags,                    \
  379.                 LPSTORAGE FAR *             lppStorageOut) IPURE;       \
  380.     MAPIMETHOD(GetSvcConfigSupportObj)                                  \
  381.         (THIS_  ULONG                       ulFlags,                    \
  382.                 LPMAPISUP FAR *             lppSvcSupport) IPURE;       \
  383.  
  384. #undef       INTERFACE
  385. #define      INTERFACE  IMAPISupport
  386. DECLARE_MAPI_INTERFACE_(IMAPISupport, IUnknown)
  387. {
  388.     BEGIN_INTERFACE
  389.     MAPI_IUNKNOWN_METHODS(PURE)
  390.     MAPI_IMAPISUPPORT_METHODS1(PURE)
  391.     MAPI_IMAPISUPPORT_METHODS2(PURE)
  392.     MAPI_IMAPISUPPORT_METHODS3(PURE)
  393. };
  394.  
  395.  
  396. /********************************************************************/
  397. /*                                                                  */
  398. /*                          ADDRESS BOOK SPI                        */
  399. /*                                                                  */
  400. /********************************************************************/
  401.  
  402. /* Address Book Provider ------------------------------------------------- */
  403.  
  404. /* OpenTemplateID() */
  405. #define FILL_ENTRY              ((ULONG) 0x00000001)
  406.  
  407. /* For Logon() */
  408.  
  409. /*#define AB_NO_DIALOG          ((ULONG) 0x00000001) in mapidefs.h */
  410. /*#define MAPI_UNICODE          ((ULONG) 0x80000000) in mapidefs.h */
  411.  
  412.  
  413.  
  414. DECLARE_MAPI_INTERFACE_PTR(IABProvider, LPABPROVIDER);
  415. DECLARE_MAPI_INTERFACE_PTR(IABLogon,    LPABLOGON);
  416.  
  417. #define MAPI_IABPROVIDER_METHODS(IPURE)                                 \
  418.     MAPIMETHOD(Shutdown)                                                \
  419.         (THIS_  ULONG FAR *                 lpulFlags) IPURE;           \
  420.     MAPIMETHOD(Logon)                                                   \
  421.         (THIS_  LPMAPISUP                   lpMAPISup,                  \
  422.                 ULONG                       ulUIParam,                  \
  423.                 LPTSTR                      lpszProfileName,            \
  424.                 ULONG                       ulFlags,                    \
  425.                 ULONG FAR *                 lpulpcbSecurity,            \
  426.                 LPBYTE FAR *                lppbSecurity,               \
  427.                 LPMAPIERROR FAR *           lppMAPIError,               \
  428.                 LPABLOGON FAR *             lppABLogon) IPURE;          \
  429.  
  430. #undef       INTERFACE
  431. #define      INTERFACE  IABProvider
  432. DECLARE_MAPI_INTERFACE_(IABProvider, IUnknown)
  433. {
  434.     BEGIN_INTERFACE
  435.     MAPI_IUNKNOWN_METHODS(PURE)
  436.     MAPI_IABPROVIDER_METHODS(PURE)
  437. };
  438.  
  439. /* For GetOneOffTable() */
  440. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  441.  
  442. #define MAPI_IABLOGON_METHODS(IPURE)                                    \
  443.     MAPIMETHOD(GetLastError)                                            \
  444.         (THIS_  HRESULT                     hResult,                    \
  445.                 ULONG                       ulFlags,                    \
  446.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  447.     MAPIMETHOD(Logoff)                                                  \
  448.         (THIS_  ULONG                       ulFlags) IPURE;             \
  449.     MAPIMETHOD(OpenEntry)                                               \
  450.         (THIS_  ULONG                       cbEntryID,                  \
  451.                 LPENTRYID                   lpEntryID,                  \
  452.                 LPCIID                      lpInterface,                \
  453.                 ULONG                       ulFlags,                    \
  454.                 ULONG FAR *                 lpulObjType,                \
  455.                 LPUNKNOWN FAR *             lppUnk) IPURE;              \
  456.     MAPIMETHOD(CompareEntryIDs)                                         \
  457.         (THIS_  ULONG                       cbEntryID1,                 \
  458.                 LPENTRYID                   lpEntryID1,                 \
  459.                 ULONG                       cbEntryID2,                 \
  460.                 LPENTRYID                   lpEntryID2,                 \
  461.                 ULONG                       ulFlags,                    \
  462.                 ULONG FAR *                 lpulResult) IPURE;          \
  463.     MAPIMETHOD(Advise)                                                  \
  464.         (THIS_  ULONG                       cbEntryID,                  \
  465.                 LPENTRYID                   lpEntryID,                  \
  466.                 ULONG                       ulEventMask,                \
  467.                 LPMAPIADVISESINK            lpAdviseSink,               \
  468.                 ULONG FAR *                 lpulConnection) IPURE;      \
  469.     MAPIMETHOD(Unadvise)                                                \
  470.         (THIS_  ULONG                       ulConnection) IPURE;        \
  471.     MAPIMETHOD(OpenStatusEntry)                                         \
  472.         (THIS_  LPCIID                       lpInterface,                \
  473.                 ULONG                       ulFlags,                    \
  474.                 ULONG FAR *                 lpulObjType,                \
  475.                 LPMAPISTATUS FAR *          lppEntry) IPURE;            \
  476.     MAPIMETHOD(OpenTemplateID)                                          \
  477.         (THIS_  ULONG                       cbTemplateID,               \
  478.                 LPENTRYID                   lpTemplateID,               \
  479.                 ULONG                       ulTemplateFlags,            \
  480.                 LPMAPIPROP                  lpMAPIPropData,             \
  481.                 LPCIID                       lpInterface,                \
  482.                 LPMAPIPROP FAR *            lppMAPIPropNew,             \
  483.                 LPMAPIPROP                  lpMAPIPropSibling) IPURE;   \
  484.     MAPIMETHOD(GetOneOffTable)                                          \
  485.         (THIS_  ULONG                       ulFlags,                    \
  486.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  487.     MAPIMETHOD(PrepareRecips)                                           \
  488.         (THIS_  ULONG                       ulFlags,                    \
  489.                 LPSPropTagArray             lpPropTagArray,             \
  490.                 LPADRLIST                   lpRecipList) IPURE;         \
  491.  
  492. #undef       INTERFACE
  493. #define      INTERFACE  IABLogon
  494. DECLARE_MAPI_INTERFACE_(IABLogon, IUnknown)
  495. {
  496.     BEGIN_INTERFACE
  497.     MAPI_IUNKNOWN_METHODS(PURE)
  498.     MAPI_IABLOGON_METHODS(PURE)
  499. };
  500.  
  501. typedef HRESULT (STDMAPIINITCALLTYPE ABPROVIDERINIT)(
  502.     HINSTANCE           hInstance,
  503.     LPMALLOC            lpMalloc,
  504.     LPALLOCATEBUFFER    lpAllocateBuffer,
  505.     LPALLOCATEMORE      lpAllocateMore,
  506.     LPFREEBUFFER        lpFreeBuffer,
  507.     ULONG               ulFlags,
  508.     ULONG               ulMAPIVer,
  509.     ULONG FAR *         lpulProviderVer,
  510.     LPABPROVIDER FAR *  lppABProvider
  511. );
  512.  
  513. ABPROVIDERINIT ABProviderInit;
  514.  
  515.  
  516.  
  517. /********************************************************************/
  518. /*                                                                  */
  519. /*                          TRANSPORT SPI                           */
  520. /*                                                                  */
  521. /********************************************************************/
  522.  
  523. /* For DeinitTransport */
  524.  
  525. #define DEINIT_NORMAL               ((ULONG) 0x00000001)
  526. #define DEINIT_HURRY                ((ULONG) 0x80000000)
  527.  
  528. /* For TransportLogon */
  529.  
  530. /* Flags that the Spooler may pass to the transport: */
  531.  
  532. #define LOGON_NO_DIALOG             ((ULONG) 0x00000001)
  533. #define LOGON_NO_CONNECT            ((ULONG) 0x00000004)
  534. #define LOGON_NO_INBOUND            ((ULONG) 0x00000008)
  535. #define LOGON_NO_OUTBOUND           ((ULONG) 0x00000010)
  536. /*#define MAPI_UNICODE              ((ULONG) 0x80000000) in mapidefs.h */
  537.  
  538. /* Flags that the transport may pass to the Spooler: */
  539.  
  540. #define LOGON_SP_IDLE               ((ULONG) 0x00010000)
  541. #define LOGON_SP_POLL               ((ULONG) 0x00020000)
  542. #define LOGON_SP_RESOLVE            ((ULONG) 0x00040000)
  543.  
  544.  
  545. DECLARE_MAPI_INTERFACE_PTR(IXPProvider, LPXPPROVIDER);
  546. DECLARE_MAPI_INTERFACE_PTR(IXPLogon, LPXPLOGON);
  547.  
  548. #define MAPI_IXPPROVIDER_METHODS(IPURE)                                 \
  549.     MAPIMETHOD(Shutdown)                                                \
  550.         (THIS_  ULONG FAR *                 lpulFlags) IPURE;           \
  551.     MAPIMETHOD(TransportLogon)                                          \
  552.         (THIS_  LPMAPISUP                   lpMAPISup,                  \
  553.                 ULONG                       ulUIParam,                  \
  554.                 LPTSTR                      lpszProfileName,            \
  555.                 ULONG FAR *                 lpulFlags,                  \
  556.                 LPMAPIERROR FAR *           lppMAPIError,               \
  557.                 LPXPLOGON FAR *             lppXPLogon) IPURE;          \
  558.  
  559. #undef       INTERFACE
  560. #define      INTERFACE  IXPProvider
  561. DECLARE_MAPI_INTERFACE_(IXPProvider, IUnknown)
  562. {
  563.     BEGIN_INTERFACE 
  564.     MAPI_IUNKNOWN_METHODS(PURE)
  565.     MAPI_IXPPROVIDER_METHODS(PURE)
  566. };
  567.  
  568. /* OptionData returned from call to RegisterOptions */
  569.  
  570. #define OPTION_TYPE_RECIPIENT       ((ULONG) 0x00000001)
  571. #define OPTION_TYPE_MESSAGE         ((ULONG) 0x00000002)
  572.  
  573. typedef struct _OPTIONDATA
  574. {
  575.     ULONG           ulFlags;        /* MAPI_RECIPIENT, MAPI_MESSAGE */
  576.     LPGUID          lpRecipGUID;    /* Same as returned by AddressTypes() */
  577.     LPTSTR          lpszAdrType;    /* Same as returned by AddressTypes() */
  578.     LPTSTR          lpszDLLName;    /* Options DLL */
  579.     ULONG           ulOrdinal;      /* Ordinal in that DLL */
  580.     ULONG           cbOptionsData;  /* Count of bytes in lpbOptionsData */
  581.     LPBYTE          lpbOptionsData; /* Providers per [recip|message] option data */
  582.     ULONG           cOptionsProps;  /* Count of Options default prop values */
  583.     LPSPropValue    lpOptionsProps; /* Default Options property values */
  584. } OPTIONDATA, FAR *LPOPTIONDATA;
  585.  
  586. typedef SCODE (STDMAPIINITCALLTYPE OPTIONCALLBACK)(
  587.             HINSTANCE           hInst,
  588.             LPMALLOC            lpMalloc,
  589.             ULONG               ulFlags,
  590.             ULONG               cbOptionData,
  591.             LPBYTE              lpbOptionData,
  592.             LPMAPISUP           lpMAPISup,
  593.             LPMAPIPROP          lpDataSource,
  594.             LPMAPIPROP FAR *    lppWrappedSource,
  595.             LPMAPIERROR FAR *   lppMAPIError);
  596.  
  597. /* For XP_AddressTypes */
  598.  
  599. /*#define MAPI_UNICODE              ((ULONG) 0x80000000) in mapidefs.h */
  600.  
  601. /* For XP_RegisterRecipOptions */
  602.  
  603. /*#define MAPI_UNICODE              ((ULONG) 0x80000000) in mapidefs.h */
  604.  
  605. /* For XP_RegisterMessageOptions */
  606.  
  607. /*#define MAPI_UNICODE              ((ULONG) 0x80000000) in mapidefs.h */
  608.  
  609. /* For TransportNotify */
  610.  
  611. #define NOTIFY_ABORT_DEFERRED       ((ULONG) 0x40000000)
  612. #define NOTIFY_CANCEL_MESSAGE       ((ULONG) 0x80000000)
  613. #define NOTIFY_BEGIN_INBOUND        ((ULONG) 0x00000001)
  614. #define NOTIFY_END_INBOUND          ((ULONG) 0x00010000)
  615. #define NOTIFY_BEGIN_OUTBOUND       ((ULONG) 0x00000002)
  616. #define NOTIFY_END_OUTBOUND         ((ULONG) 0x00020000)
  617. #define NOTIFY_BEGIN_INBOUND_FLUSH  ((ULONG) 0x00000004)
  618. #define NOTIFY_END_INBOUND_FLUSH    ((ULONG) 0x00040000)
  619. #define NOTIFY_BEGIN_OUTBOUND_FLUSH ((ULONG) 0x00000008)
  620. #define NOTIFY_END_OUTBOUND_FLUSH   ((ULONG) 0x00080000)
  621.  
  622. /* For TransportLogoff */
  623.  
  624. #define LOGOFF_NORMAL               ((ULONG) 0x00000001)
  625. #define LOGOFF_HURRY                ((ULONG) 0x80000000)
  626.  
  627. /* For SubmitMessage */
  628.  
  629. #define BEGIN_DEFERRED              ((ULONG) 0x00000001)
  630.  
  631. /* For EndMessage */
  632.  
  633. /* Flags that the Spooler may pass to the Transport: */
  634.  
  635. /* Flags that the transport may pass to the Spooler: */
  636.  
  637. #define END_RESEND_NOW              ((ULONG) 0x00010000)
  638. #define END_RESEND_LATER            ((ULONG) 0x00020000)
  639. #define END_DONT_RESEND             ((ULONG) 0x00040000)
  640.  
  641. #define MAPI_IXPLOGON_METHODS(IPURE)                                    \
  642.     MAPIMETHOD(AddressTypes)                                            \
  643.         (THIS_  ULONG FAR *                 lpulFlags,                  \
  644.                 ULONG FAR *                 lpcAdrType,                 \
  645.                 LPTSTR FAR * FAR *          lpppAdrTypeArray,           \
  646.                 ULONG FAR *                 lpcMAPIUID,                 \
  647.                 LPMAPIUID FAR * FAR *       lpppUIDArray) IPURE;        \
  648.     MAPIMETHOD(RegisterOptions)                                         \
  649.         (THIS_  ULONG FAR *                 lpulFlags,                  \
  650.                 ULONG FAR *                 lpcOptions,                 \
  651.                 LPOPTIONDATA FAR *          lppOptions) IPURE;          \
  652.     MAPIMETHOD(TransportNotify)                                         \
  653.         (THIS_  ULONG FAR *                 lpulFlags,                  \
  654.                 LPVOID FAR *                lppvData) IPURE;            \
  655.     MAPIMETHOD(Idle)                                                    \
  656.         (THIS_  ULONG                       ulFlags) IPURE;             \
  657.     MAPIMETHOD(TransportLogoff)                                         \
  658.         (THIS_  ULONG                       ulFlags) IPURE;             \
  659.     MAPIMETHOD(SubmitMessage)                                           \
  660.         (THIS_  ULONG                       ulFlags,                    \
  661.                 LPMESSAGE                   lpMessage,                  \
  662.                 ULONG FAR *                 lpulMsgRef,                 \
  663.                 ULONG FAR *                 lpulReturnParm) IPURE;      \
  664.     MAPIMETHOD(EndMessage)                                              \
  665.         (THIS_  ULONG                       ulMsgRef,                   \
  666.                 ULONG FAR *                 lpulFlags) IPURE;           \
  667.     MAPIMETHOD(Poll)                                                    \
  668.         (THIS_  ULONG FAR *                 lpulIncoming) IPURE;        \
  669.     MAPIMETHOD(StartMessage)                                            \
  670.         (THIS_  ULONG                       ulFlags,                    \
  671.                 LPMESSAGE                   lpMessage,                  \
  672.                 ULONG FAR *                 lpulMsgRef) IPURE;          \
  673.     MAPIMETHOD(OpenStatusEntry)                                         \
  674.         (THIS_  LPCIID                      lpInterface,                \
  675.                 ULONG                       ulFlags,                    \
  676.                 ULONG FAR *                 lpulObjType,                \
  677.                 LPMAPISTATUS FAR *          lppEntry) IPURE;            \
  678.     MAPIMETHOD(ValidateState)                                           \
  679.         (THIS_  ULONG                       ulUIParam,                  \
  680.                 ULONG                       ulFlags) IPURE;             \
  681.     MAPIMETHOD(FlushQueues)                                             \
  682.         (THIS_  ULONG                       ulUIParam,                  \
  683.                 ULONG                       cbTargetTransport,          \
  684.                 LPENTRYID                   lpTargetTransport,          \
  685.                 ULONG                       ulFlags) IPURE;             \
  686.  
  687. #undef       INTERFACE
  688. #define      INTERFACE  IXPLogon
  689. DECLARE_MAPI_INTERFACE_(IXPLogon, IUnknown)
  690. {
  691.     BEGIN_INTERFACE 
  692.     MAPI_IUNKNOWN_METHODS(PURE)
  693.     MAPI_IXPLOGON_METHODS(PURE)
  694. };
  695.  
  696.  
  697. /* Transport Provider Entry Point */
  698.  
  699. typedef HRESULT (STDMAPIINITCALLTYPE XPPROVIDERINIT)(
  700.     HINSTANCE           hInstance,
  701.     LPMALLOC            lpMalloc,
  702.     LPALLOCATEBUFFER    lpAllocateBuffer,
  703.     LPALLOCATEMORE      lpAllocateMore,
  704.     LPFREEBUFFER        lpFreeBuffer,
  705.     ULONG               ulFlags,
  706.     ULONG               ulMAPIVer,
  707.     ULONG FAR *         lpulProviderVer,
  708.     LPXPPROVIDER FAR *  lppXPProvider);
  709.  
  710. XPPROVIDERINIT XPProviderInit;
  711.  
  712. /********************************************************************/
  713. /*                                                                  */
  714. /*                          MESSAGE STORE SPI                       */
  715. /*                                                                  */
  716. /********************************************************************/
  717.  
  718. /* Flags and enums */
  719.  
  720. /* For Logon() */
  721.  
  722. /*#define MAPI_UNICODE          ((ULONG) 0x80000000) in mapidefs.h */
  723. /*#define MDB_NO_DIALOG         ((ULONG) 0x00000001) in mapidefs.h */
  724. /*#define MDB_WRITE             ((ULONG) 0x00000004) in mapidefs.h */
  725. /*#define MAPI_DEFERRED_ERRORS  ((ULONG) 0x00000008) in mapidefs.h */
  726. /*#define MDB_TEMPORARY         ((ULONG) 0x00000020) in mapidefs.h */
  727. /*#define MDB_NO_MAIL           ((ULONG) 0x00000080) in mapidefs.h */
  728.  
  729. /* For SpoolerLogon() */
  730.  
  731. /*#define MAPI_UNICODE          ((ULONG) 0x80000000) in mapidefs.h */
  732. /*#define MDB_NO_DIALOG         ((ULONG) 0x00000001) in mapidefs.h */
  733. /*#define MDB_WRITE             ((ULONG) 0x00000004) in mapidefs.h */
  734. /*#define MAPI_DEFERRED_ERRORS  ((ULONG) 0x00000008) in mapidefs.h */
  735.  
  736. /* GetCredentials, SetCredentials */
  737.  
  738. #define LOGON_SP_TRANSPORT      ((ULONG) 0x00000001)
  739. #define LOGON_SP_PROMPT         ((ULONG) 0x00000002)
  740. #define LOGON_SP_NEWPW          ((ULONG) 0x00000004)
  741. #define LOGON_CHANGED           ((ULONG) 0x00000008)
  742.  
  743. /* DoMCDialog */
  744.  
  745. #define DIALOG_FOLDER           ((ULONG) 0x00000001)
  746. #define DIALOG_MESSAGE          ((ULONG) 0x00000002)
  747. #define DIALOG_PROP             ((ULONG) 0x00000004)
  748. #define DIALOG_ATTACH           ((ULONG) 0x00000008)
  749.  
  750. #define DIALOG_MOVE             ((ULONG) 0x00000010)
  751. #define DIALOG_COPY             ((ULONG) 0x00000020)
  752. #define DIALOG_DELETE           ((ULONG) 0x00000040)
  753.  
  754. #define DIALOG_ALLOW_CANCEL     ((ULONG) 0x00000080)
  755. #define DIALOG_CONFIRM_CANCEL   ((ULONG) 0x00000100)
  756.  
  757. /* ExpandRecips */
  758.  
  759. #define NEEDS_PREPROCESSING     ((ULONG) 0x00000001)
  760. #define NEEDS_SPOOLER           ((ULONG) 0x00000002)
  761.  
  762. /* PrepareSubmit */
  763.  
  764. #define CHECK_SENDER            ((ULONG) 0x00000001)
  765. #define NON_STANDARD            ((ULONG) 0x00010000)
  766.  
  767.  
  768. DECLARE_MAPI_INTERFACE_PTR(IMSLogon, LPMSLOGON);
  769. DECLARE_MAPI_INTERFACE_PTR(IMSProvider, LPMSPROVIDER);
  770.  
  771. /* Message Store Provider Interface (IMSPROVIDER) */
  772.  
  773. #define MAPI_IMSPROVIDER_METHODS(IPURE)                                 \
  774.     MAPIMETHOD(Shutdown)                                                \
  775.         (THIS_  ULONG FAR *                 lpulFlags) IPURE;           \
  776.     MAPIMETHOD(Logon)                                                   \
  777.         (THIS_  LPMAPISUP                   lpMAPISup,                  \
  778.                 ULONG                       ulUIParam,                  \
  779.                 LPTSTR                      lpszProfileName,            \
  780.                 ULONG                       cbEntryID,                  \
  781.                 LPENTRYID                   lpEntryID,                  \
  782.                 ULONG                       ulFlags,                    \
  783.                 LPCIID                      lpInterface,                \
  784.                 ULONG FAR *                 lpcbSpoolSecurity,          \
  785.                 LPBYTE FAR *                lppbSpoolSecurity,          \
  786.                 LPMAPIERROR FAR *           lppMAPIError,               \
  787.                 LPMSLOGON FAR *             lppMSLogon,                 \
  788.                 LPMDB FAR *                 lppMDB) IPURE;              \
  789.     MAPIMETHOD(SpoolerLogon)                                            \
  790.         (THIS_  LPMAPISUP                   lpMAPISup,                  \
  791.                 ULONG                       ulUIParam,                  \
  792.                 LPTSTR                      lpszProfileName,            \
  793.                 ULONG                       cbEntryID,                  \
  794.                 LPENTRYID                   lpEntryID,                  \
  795.                 ULONG                       ulFlags,                    \
  796.                 LPCIID                      lpInterface,                \
  797.                 ULONG                       cbSpoolSecurity,            \
  798.                 LPBYTE                      lpbSpoolSecurity,           \
  799.                 LPMAPIERROR FAR *           lppMAPIError,               \
  800.                 LPMSLOGON FAR *             lppMSLogon,                 \
  801.                 LPMDB FAR *                 lppMDB) IPURE;              \
  802.     MAPIMETHOD(CompareStoreIDs)                                         \
  803.         (THIS_  ULONG                       cbEntryID1,                 \
  804.                 LPENTRYID                   lpEntryID1,                 \
  805.                 ULONG                       cbEntryID2,                 \
  806.                 LPENTRYID                   lpEntryID2,                 \
  807.                 ULONG                       ulFlags,                    \
  808.                 ULONG FAR *                 lpulResult) IPURE;          \
  809.  
  810. #undef       INTERFACE
  811. #define      INTERFACE  IMSProvider
  812. DECLARE_MAPI_INTERFACE_(IMSProvider, IUnknown)
  813. {
  814.     BEGIN_INTERFACE 
  815.     MAPI_IUNKNOWN_METHODS(PURE)
  816.     MAPI_IMSPROVIDER_METHODS(PURE)
  817. };
  818.  
  819. /* The MSLOGON object is returned by the Logon() method of the
  820.  * MSPROVIDER interface.  This object is for use by MAPIX.DLL.
  821.  */
  822. #define MAPI_IMSLOGON_METHODS(IPURE)                                    \
  823.     MAPIMETHOD(GetLastError)                                            \
  824.         (THIS_  HRESULT                     hResult,                    \
  825.                 ULONG                       ulFlags,                    \
  826.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  827.     MAPIMETHOD(Logoff)                                                  \
  828.         (THIS_  ULONG FAR *                 lpulFlags) IPURE;           \
  829.     MAPIMETHOD(OpenEntry)                                               \
  830.         (THIS_  ULONG                       cbEntryID,                  \
  831.                 LPENTRYID                   lpEntryID,                  \
  832.                 LPCIID                      lpInterface,                \
  833.                 ULONG                       ulFlags,                    \
  834.                 ULONG FAR *                 lpulObjType,                \
  835.                 LPUNKNOWN FAR *             lppUnk) IPURE;              \
  836.     MAPIMETHOD(CompareEntryIDs)                                         \
  837.         (THIS_  ULONG                       cbEntryID1,                 \
  838.                 LPENTRYID                   lpEntryID1,                 \
  839.                 ULONG                       cbEntryID2,                 \
  840.                 LPENTRYID                   lpEntryID2,                 \
  841.                 ULONG                       ulFlags,                    \
  842.                 ULONG FAR *                 lpulResult) IPURE;          \
  843.     MAPIMETHOD(Advise)                                                  \
  844.         (THIS_  ULONG                       cbEntryID,                  \
  845.                 LPENTRYID                   lpEntryID,                  \
  846.                 ULONG                       ulEventMask,                \
  847.                 LPMAPIADVISESINK            lpAdviseSink,               \
  848.                 ULONG FAR *                 lpulConnection) IPURE;      \
  849.     MAPIMETHOD(Unadvise)                                                \
  850.         (THIS_  ULONG                       ulConnection) IPURE;        \
  851.     MAPIMETHOD(OpenStatusEntry)                                         \
  852.         (THIS_  LPCIID                      lpInterface,                \
  853.                 ULONG                       ulFlags,                    \
  854.                 ULONG FAR *                 lpulObjType,                \
  855.                 LPVOID FAR *                lppEntry) IPURE;            \
  856.  
  857. #undef       INTERFACE
  858. #define      INTERFACE  IMSLogon
  859. DECLARE_MAPI_INTERFACE_(IMSLogon, IUnknown)
  860. {
  861.     BEGIN_INTERFACE 
  862.     MAPI_IUNKNOWN_METHODS(PURE)
  863.     MAPI_IMSLOGON_METHODS(PURE)
  864. };
  865.  
  866. /* Message Store Provider Entry Point */
  867.  
  868. typedef HRESULT (STDMAPIINITCALLTYPE MSPROVIDERINIT)(
  869.     HINSTANCE               hInstance,
  870.     LPMALLOC                lpMalloc,           /* AddRef() if you keep it */
  871.     LPALLOCATEBUFFER        lpAllocateBuffer,   /* -> AllocateBuffer */
  872.     LPALLOCATEMORE          lpAllocateMore,     /* -> AllocateMore   */
  873.     LPFREEBUFFER            lpFreeBuffer,       /* -> FreeBuffer     */
  874.     ULONG                   ulFlags,
  875.     ULONG                   ulMAPIVer,
  876.     ULONG FAR *             lpulProviderVer,
  877.     LPMSPROVIDER FAR *      lppMSProvider
  878. );
  879.  
  880. MSPROVIDERINIT MSProviderInit;
  881.  
  882.  
  883. /********************************************************************/
  884. /*                                                                  */
  885. /*                    MESSAGE SERVICE CONFIGURATION                 */
  886. /*                                                                  */
  887. /********************************************************************/
  888.  
  889. /* Flags for service configuration entry point */
  890.  
  891. /* #define MAPI_UNICODE              0x80000000 */
  892. /* #define SERVICE_UI_ALWAYS         0x00000002 */
  893. /* #define SERVICE_UI_ALLOWED        0x00000010 */
  894. #define MSG_SERVICE_UI_READ_ONLY     0x00000008 /* display parameters only */
  895. #define SERVICE_LOGON_FAILED         0x00000020 /* reconfigure provider */
  896.  
  897. /* Contexts for service configuration entry point */
  898.  
  899. #define MSG_SERVICE_INSTALL         0x00000001
  900. #define MSG_SERVICE_CREATE          0x00000002
  901. #define MSG_SERVICE_CONFIGURE       0x00000003
  902. #define MSG_SERVICE_DELETE          0x00000004
  903. #define MSG_SERVICE_UNINSTALL       0x00000005
  904. #define MSG_SERVICE_PROVIDER_CREATE 0x00000006
  905. #define MSG_SERVICE_PROVIDER_DELETE 0x00000007
  906.  
  907. /* Prototype for service configuration entry point */
  908.  
  909. typedef HRESULT (STDAPICALLTYPE MSGSERVICEENTRY)(
  910.     HINSTANCE       hInstance,
  911.     LPMALLOC        lpMalloc,
  912.     LPMAPISUP       lpMAPISup,
  913.     ULONG           ulUIParam,
  914.     ULONG           ulFlags,
  915.     ULONG           ulContext,
  916.     ULONG           cValues,
  917.     LPSPropValue    lpProps,
  918.     LPPROVIDERADMIN lpProviderAdmin,
  919.     LPMAPIERROR FAR *lppMapiError
  920. );
  921. typedef MSGSERVICEENTRY FAR *LPMSGSERVICEENTRY;
  922.  
  923.  
  924. #ifdef __cplusplus
  925. }
  926. #endif
  927.  
  928. #pragma option pop /*P_O_Pop*/
  929. #endif /* MAPISPI_H */
  930.