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