开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
OCEMessaging.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：47k
源码类别：

多媒体编程

开发平台：

Visual C++

OCEMessaging.h：源码内容
  1. /*
  2.      File:       OCEMessaging.h
  3.  
  4.      Contains:   Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology: AOCE Toolbox 1.02
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1994-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __OCEMESSAGING__
  18. #define __OCEMESSAGING__
  20. #ifndef __FILES__
  21. #include "Files.h"
  22. #endif
  24. #ifndef __MACTYPES__
  25. #include "MacTypes.h"
  26. #endif
  29. #ifndef __DIGITALSIGNATURE__
  30. #include "DigitalSignature.h"
  31. #endif
  33. #ifndef __OCE__
  34. #include "OCE.h"
  35. #endif
  37. #ifndef __OCEAUTHDIR__
  38. #include "OCEAuthDir.h"
  39. #endif
  44. #if PRAGMA_ONCE
  45. #pragma once
  46. #endif
  48. #ifdef __cplusplus
  49. extern "C" {
  50. #endif
  52. #if PRAGMA_IMPORT
  53. #pragma import on
  54. #endif
  56. #if PRAGMA_STRUCT_ALIGN
  57.     #pragma options align=mac68k
  58. #elif PRAGMA_STRUCT_PACKPUSH
  59.     #pragma pack(push, 2)
  60. #elif PRAGMA_STRUCT_PACK
  61.     #pragma pack(2)
  62. #endif
  64. /******************************************************************************/
  65. /* Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  66. message ids and priorities, etc. */
  68. /* Values of IPMPriority */
  69. enum {
  70.     kIPMAnyPriority             = 0,                            /* FOR FILTER ONLY */
  71.     kIPMNormalPriority          = 1,
  72.     kIPMLowPriority             = 2,
  73.     kIPMHighPriority            = 3
  74. };
  76. typedef Byte                            IPMPriority;
  77. /* Values of IPMAccessMode */
  78. enum {
  79.     kIPMAtMark                  = 0,
  80.     kIPMFromStart               = 1,
  81.     kIPMFromLEOM                = 2,
  82.     kIPMFromMark                = 3
  83. };
  85. typedef unsigned short                  IPMAccessMode;
  86. enum {
  87.     kIPMUpdateMsgBit            = 4,
  88.     kIPMNewMsgBit               = 5,
  89.     kIPMDeleteMsgBit            = 6
  90. };
  92. /* Values of IPMNotificationType */
  93. enum {
  94.     kIPMUpdateMsgMask           = 1 << kIPMUpdateMsgBit,
  95.     kIPMNewMsgMask              = 1 << kIPMNewMsgBit,
  96.     kIPMDeleteMsgMask           = 1 << kIPMDeleteMsgBit
  97. };
  99. typedef Byte                            IPMNotificationType;
  100. /* Values of IPMSenderTag */
  101. enum {
  102.     kIPMSenderRStringTag        = 0,
  103.     kIPMSenderRecordIDTag       = 1
  104. };
  106. typedef unsigned short                  IPMSenderTag;
  107. enum {
  108.     kIPMFromDistListBit         = 0,
  109.     kIPMDummyRecBit             = 1,
  110.     kIPMFeedbackRecBit          = 2,                            /* should be redirected to feedback queue */
  111.     kIPMReporterRecBit          = 3,                            /* should be redirected to reporter original queue */
  112.     kIPMBCCRecBit               = 4                             /* this recipient is blind to all recipients of message */
  113. };
  115. /* Values of OCERecipientOffsetFlags */
  116. enum {
  117.     kIPMFromDistListMask        = 1 << kIPMFromDistListBit,
  118.     kIPMDummyRecMask            = 1 << kIPMDummyRecBit,
  119.     kIPMFeedbackRecMask         = 1 << kIPMFeedbackRecBit,
  120.     kIPMReporterRecMask         = 1 << kIPMReporterRecBit,
  121.     kIPMBCCRecMask              = 1 << kIPMBCCRecBit
  122. };
  124. typedef Byte                            OCERecipientOffsetFlags;
  126. struct OCECreatorType {
  127.     OSType                          msgCreator;
  128.     OSType                          msgType;
  129. };
  130. typedef struct OCECreatorType           OCECreatorType;
  131. enum {
  132.     kIPMTypeWildCard            = FOUR_CHAR_CODE('ipmw'),
  133.     kIPMFamilyUnspecified       = 0,
  134.     kIPMFamilyWildCard          = 0x3F3F3F3F,                   /* '????' * well known signature */
  135.     kIPMSignature               = FOUR_CHAR_CODE('ipms'),       /* base type * well known message types */
  136.     kIPMReportNotify            = FOUR_CHAR_CODE('rptn'),       /* routing feedback * well known message block types */
  137.     kIPMEnclosedMsgType         = FOUR_CHAR_CODE('emsg'),       /* enclosed (nested) message */
  138.     kIPMReportInfo              = FOUR_CHAR_CODE('rpti'),       /* recipient information */
  139.     kIPMDigitalSignature        = FOUR_CHAR_CODE('dsig')        /* digital signature */
  140. };
  142. /* Values of IPMMsgFormat */
  143. enum {
  144.     kIPMOSFormatType            = 1,
  145.     kIPMStringFormatType        = 2
  146. };
  149. typedef unsigned short                  IPMMsgFormat;
  150. typedef Str32                           IPMStringMsgType;
  152. union TheType {
  153.     OCECreatorType                  msgOSType;
  154.     IPMStringMsgType                msgStrType;
  155. };
  156. typedef union TheType                   TheType;
  158. struct IPMMsgType {
  159.     IPMMsgFormat                    format;                     /* IPMMsgFormat*/
  160.     TheType                         theType;
  161. };
  162. typedef struct IPMMsgType               IPMMsgType;
  163. /*
  164. Following are the known extension values for IPM addresses handled by Apple.
  165. We define the definition of the entn extension below.
  166. */
  167. enum {
  168.     kOCEalanXtn                 = FOUR_CHAR_CODE('alan'),
  169.     kOCEentnXtn                 = FOUR_CHAR_CODE('entn'),       /* entn = entity name (aka DSSpec) */
  170.     kOCEaphnXtn                 = FOUR_CHAR_CODE('aphn')
  171. };
  173. /*
  174. Following are the specific definitions for the extension for the standard
  175. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  176. IPMEntityNameExtension.]
  177. */
  178. /* entn extension forms */
  179. enum {
  180.     kOCEAddrXtn                 = FOUR_CHAR_CODE('addr'),
  181.     kOCEQnamXtn                 = FOUR_CHAR_CODE('qnam'),
  182.     kOCEAttrXtn                 = FOUR_CHAR_CODE('attr'),       /* an attribute specification */
  183.     kOCESpAtXtn                 = FOUR_CHAR_CODE('spat')        /* specific attribute */
  184. };
  186. /*
  187. Following are the specific definitions for standard
  188. OCEMail 'aphn' extension value.  
  190. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  191. if length odd, then a pad byte (zero) should be introduced before the next field).
  193. The extension value is in the packed form of the following structure:
  194.     RString     phoneNumber;
  195.     RString     modemType;
  196.     Str32       queueuName;
  198. The body of phoneNumber compound RString is in the packed form of the following structure:
  199.     short       subType;
  200.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  201.     RString     areaCode;                   // used when subType == kOCEUseHandyDial
  202.     RString     phone;                      // used when subType == kOCEUseHandyDial
  203.     RString     postFix;                    // used when subType == kOCEUseHandyDial
  204.     RString     nonHandyDialString;         // used when subType == kOCEDontUseHandyDial
  205. */
  206. /* phoneNumber sub type constants */
  207. enum {
  208.     kOCEUseHandyDial            = 1,
  209.     kOCEDontUseHandyDial        = 2
  210. };
  212. /* FORMAT OF A PACKED FORM RECIPIENT */
  214. struct ProtoOCEPackedRecipient {
  215.     unsigned short                  dataLength;
  216. };
  217. typedef struct ProtoOCEPackedRecipient  ProtoOCEPackedRecipient;
  218. enum {
  219.     kOCEPackedRecipientMaxBytes = (4096 - sizeof(ProtoOCEPackedRecipient))
  220. };
  223. struct OCEPackedRecipient {
  224.     unsigned short                  dataLength;
  225.     Byte                            data[4094];
  226. };
  227. typedef struct OCEPackedRecipient       OCEPackedRecipient;
  229. struct IPMEntnQueueExtension {
  230.     Str32                           queueName;
  231. };
  232. typedef struct IPMEntnQueueExtension    IPMEntnQueueExtension;
  233. /* kOCEAttrXtn */
  235. struct IPMEntnAttributeExtension {
  236.     AttributeType                   attributeName;
  237. };
  238. typedef struct IPMEntnAttributeExtension IPMEntnAttributeExtension;
  239. /* kOCESpAtXtn */
  241. struct IPMEntnSpecificAttributeExtension {
  242.     AttributeCreationID             attributeCreationID;
  243.     AttributeType                   attributeName;
  244. };
  245. typedef struct IPMEntnSpecificAttributeExtension IPMEntnSpecificAttributeExtension;
  246. /* All IPM entn extensions fit within the following */
  248. struct IPMEntityNameExtension {
  249.     OSType                          subExtensionType;
  250.     union {
  251.         IPMEntnSpecificAttributeExtension  specificAttribute;
  252.         IPMEntnAttributeExtension       attribute;
  253.         IPMEntnQueueExtension           queue;
  254.     }                                 u;
  255. };
  256. typedef struct IPMEntityNameExtension   IPMEntityNameExtension;
  257. /* addresses with kIPMNBPXtn should specify this nbp type */
  258. #define kIPMWSReceiverNBPType "pMsgReceiver" 
  260. struct IPMMsgID {
  261.     unsigned long                   id[4];
  262. };
  263. typedef struct IPMMsgID                 IPMMsgID;
  265. /* Values of IPMHeaderSelector */
  266. enum {
  267.     kIPMTOC                     = 0,
  268.     kIPMSender                  = 1,
  269.     kIPMProcessHint             = 2,
  270.     kIPMMessageTitle            = 3,
  271.     kIPMMessageType             = 4,
  272.     kIPMFixedInfo               = 7
  273. };
  276. typedef Byte                            IPMHeaderSelector;
  278. union TheSender {
  279.     RString                         rString;
  280.     PackedRecordID                  rid;
  281. };
  282. typedef union TheSender                 TheSender;
  284. struct IPMSender {
  285.     IPMSenderTag                    sendTag;
  286.     TheSender                       theSender;
  287. };
  288. typedef struct IPMSender                IPMSender;
  289. /******************************************************************************/
  290. /* Definitions specific to OCEMessaging */
  292. typedef unsigned long                   IPMContextRef;
  293. typedef unsigned long                   IPMQueueRef;
  294. typedef unsigned long                   IPMMsgRef;
  295. typedef unsigned long                   IPMSeqNum;
  296. typedef Str32                           IPMProcHint;
  297. typedef Str32                           IPMQueueName;
  298. typedef CALLBACK_API( void , IPMNoteProcPtr )(IPMQueueRef queue, IPMSeqNum seqNum, IPMNotificationType notificationType, unsigned long userData);
  299. typedef STACK_UPP_TYPE(IPMNoteProcPtr)                          IPMNoteUPP;
  300. #if OPAQUE_UPP_TYPES
  301. #if CALL_NOT_IN_CARBON
  302.     EXTERN_API(IPMNoteUPP)
  303.     NewIPMNoteUPP                  (IPMNoteProcPtr          userRoutine);
  305.     EXTERN_API(void)
  306.     DisposeIPMNoteUPP              (IPMNoteUPP              userUPP);
  308.     EXTERN_API(void)
  309.     InvokeIPMNoteUPP               (IPMQueueRef             queue,
  310.                                     IPMSeqNum               seqNum,
  311.                                     IPMNotificationType     notificationType,
  312.                                     unsigned long           userData,
  313.                                     IPMNoteUPP              userUPP);
  315. #endif  /* CALL_NOT_IN_CARBON */
  317. #else
  318.     enum { uppIPMNoteProcInfo = 0x000037C0 };                       /* pascal no_return_value Func(4_bytes, 4_bytes, 1_byte, 4_bytes) */
  319.     #define NewIPMNoteUPP(userRoutine)                              (IPMNoteUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMNoteProcInfo, GetCurrentArchitecture())
  320.     #define DisposeIPMNoteUPP(userUPP)                              DisposeRoutineDescriptor(userUPP)
  321.     #define InvokeIPMNoteUPP(queue, seqNum, notificationType, userData, userUPP)  CALL_FOUR_PARAMETER_UPP((userUPP), uppIPMNoteProcInfo, (queue), (seqNum), (notificationType), (userData))
  322. #endif
  323. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  324. #define NewIPMNoteProc(userRoutine)                             NewIPMNoteUPP(userRoutine)
  325. #define CallIPMNoteProc(userRoutine, queue, seqNum, notificationType, userData) InvokeIPMNoteUPP(queue, seqNum, notificationType, userData, userRoutine)
  327. struct IPMFixedHdrInfo {
  328.     unsigned short                  version;
  329.     Boolean                         authenticated;
  330.     Boolean                         signatureEnclosed;          /*  digital signature enclosed */
  331.     unsigned long                   msgSize;
  332.     IPMNotificationType             notification;
  333.     IPMPriority                     priority;
  334.     unsigned short                  blockCount;
  335.     unsigned short                  originalRcptCount;          /*       original number of recipients */
  336.     unsigned long                   refCon;                     /*       Client defined data */
  337.     unsigned short                  reserved;
  338.     UTCTime                         creationTime;               /*       Time when it was created */
  339.     IPMMsgID                        msgID;
  340.     OSType                          family;                     /* family this msg belongs (e.g. mail) */
  341. };
  342. typedef struct IPMFixedHdrInfo          IPMFixedHdrInfo;
  343. enum {
  344.     kIPMDeliveryNotificationBit = 0,
  345.     kIPMNonDeliveryNotificationBit = 1,
  346.     kIPMEncloseOriginalBit      = 2,
  347.     kIPMSummaryReportBit        = 3,                            /* modify enclose original to only on error */
  348.     kIPMOriginalOnlyOnErrorBit  = 4
  349. };
  351. enum {
  352.     kIPMNoNotificationMask      = 0x00,
  353.     kIPMDeliveryNotificationMask = 1 << kIPMDeliveryNotificationBit,
  354.     kIPMNonDeliveryNotificationMask = 1 << kIPMNonDeliveryNotificationBit,
  355.     kIPMDontEncloseOriginalMask = 0x00,
  356.     kIPMEncloseOriginalMask     = 1 << kIPMEncloseOriginalBit,
  357.     kIPMImmediateReportMask     = 0x00,
  358.     kIPMSummaryReportMask       = 1 << kIPMSummaryReportBit,
  359.     kIPMOriginalOnlyOnErrorMask = 1 << kIPMOriginalOnlyOnErrorBit,
  360.     kIPMEncloseOriginalOnErrorMask = (kIPMOriginalOnlyOnErrorMask | kIPMEncloseOriginalMask)
  361. };
  363. /* standard Non delivery codes */
  364. enum {
  365.     kIPMNoSuchRecipient         = 0x0001,
  366.     kIPMRecipientMalformed      = 0x0002,
  367.     kIPMRecipientAmbiguous      = 0x0003,
  368.     kIPMRecipientAccessDenied   = 0x0004,
  369.     kIPMGroupExpansionProblem   = 0x0005,
  370.     kIPMMsgUnreadable           = 0x0006,
  371.     kIPMMsgExpired              = 0x0007,
  372.     kIPMMsgNoTranslatableContent = 0x0008,
  373.     kIPMRecipientReqStdCont     = 0x0009,
  374.     kIPMRecipientReqSnapShot    = 0x000A,
  375.     kIPMNoTransferDiskFull      = 0x000B,
  376.     kIPMNoTransferMsgRejectedbyDest = 0x000C,
  377.     kIPMNoTransferMsgTooLarge   = 0x000D
  378. };
  380. /*************************************************************************/
  381. /*
  382. This is the structure that will be returned by enumerate and getmsginfo
  383. This definition is just to give you a template, the position of msgType
  384. is variable since this is a packed structure.  procHint and msgType are
  385. packed and even length padded.
  387. * master message info */
  389. struct IPMMsgInfo {
  390.     IPMSeqNum                       sequenceNum;
  391.     unsigned long                   userData;
  392.     unsigned short                  respIndex;
  393.     SInt8                           padByte;
  394.     IPMPriority                     priority;
  395.     unsigned long                   msgSize;
  396.     unsigned short                  originalRcptCount;
  397.     unsigned short                  reserved;
  398.     UTCTime                         creationTime;
  399.     IPMMsgID                        msgID;
  400.     OSType                          family;                     /* family this msg belongs (e.g. mail) */
  401.     IPMProcHint                     procHint;
  402.     SInt8                           filler2;
  403.     IPMMsgType                      msgType;
  404. };
  405. typedef struct IPMMsgInfo               IPMMsgInfo;
  407. typedef OCECreatorType                  IPMBlockType;
  409. struct IPMTOC {
  410.     IPMBlockType                    blockType;
  411.     long                            blockOffset;
  412.     unsigned long                   blockSize;
  413.     unsigned long                   blockRefCon;
  414. };
  415. typedef struct IPMTOC                   IPMTOC;
  416. /*
  417. The following structure is just to describe the layout of the SingleFilter.
  418. Each field should be packed and word aligned when passed to the IPM ToolBox.
  419. */
  421. struct IPMSingleFilter {
  422.     IPMPriority                     priority;
  423.     SInt8                           padByte;
  424.     OSType                          family;                     /* family this msg belongs (e.g. mail), '????' for all */
  425.     ScriptCode                      script;                     /* Language Identifier */
  426.     IPMProcHint                     hint;
  427.     SInt8                           filler2;
  428.     IPMMsgType                      msgType;
  429. };
  430. typedef struct IPMSingleFilter          IPMSingleFilter;
  432. struct IPMFilter {
  433.     unsigned short                  count;
  434.     IPMSingleFilter                 sFilters[1];
  435. };
  436. typedef struct IPMFilter                IPMFilter;
  437. /*************************************************************************
  438. Following structures define the "start" of a recipient report block and the
  439. elements of the array respectively.
  440. */
  442. struct IPMReportBlockHeader {
  443.     IPMMsgID                        msgID;                      /* message id of the original */
  444.     UTCTime                         creationTime;               /* creation time of the report */
  445. };
  446. typedef struct IPMReportBlockHeader     IPMReportBlockHeader;
  448. struct OCERecipientReport {
  449.     unsigned short                  rcptIndex;                  /* index of recipient in original message */
  450.     OSErr                           result;                     /* result of sending letter to this recipient*/
  451. };
  452. typedef struct OCERecipientReport       OCERecipientReport;
  453. /*************************************************************************/
  454. typedef union IPMParamBlock             IPMParamBlock;
  456. typedef IPMParamBlock *                 IPMParamBlockPtr;
  457. typedef CALLBACK_API( void , IPMIOCompletionProcPtr )(IPMParamBlockPtr paramBlock);
  458. /*
  459.     WARNING: IPMIOCompletionProcPtr uses register based parameters under classic 68k
  460.              and cannot be written in a high-level language without 
  461.              the help of mixed mode or assembly glue.
  462. */
  463. typedef REGISTER_UPP_TYPE(IPMIOCompletionProcPtr)               IPMIOCompletionUPP;
  465. struct IPMOpenContextPB {
  466.     void *                          qLink;
  467.     long                            reservedH1;
  468.     long                            reservedH2;
  469.     IPMIOCompletionUPP              ioCompletion;
  470.     OSErr                           ioResult;
  471.     long                            saveA5;
  472.     short                           reqCode;
  473.     IPMContextRef                   contextRef;                 /* <--  Context reference to be used in further calls*/
  474. };
  475. typedef struct IPMOpenContextPB         IPMOpenContextPB;
  477. typedef IPMOpenContextPB                IPMCloseContextPB;
  479. struct IPMCreateQueuePB {
  480.     void *                          qLink;
  481.     long                            reservedH1;
  482.     long                            reservedH2;
  483.     IPMIOCompletionUPP              ioCompletion;
  484.     OSErr                           ioResult;
  485.     long                            saveA5;
  486.     short                           reqCode;
  487.     long                            filler1;
  488.     OCERecipient *                  queue;
  489.     AuthIdentity                    identity;                   /* used only if queue is remote */
  490.     PackedRecordID *                owner;                      /* used only if queue is remote */
  491. };
  492. typedef struct IPMCreateQueuePB         IPMCreateQueuePB;
  493. /* For createqueue and deletequeue only queue and identity are used */
  495. typedef IPMCreateQueuePB                IPMDeleteQueuePB;
  497. struct IPMOpenQueuePB {
  498.     void *                          qLink;
  499.     long                            reservedH1;
  500.     long                            reservedH2;
  501.     IPMIOCompletionUPP              ioCompletion;
  502.     OSErr                           ioResult;
  503.     long                            saveA5;
  504.     short                           reqCode;
  505.     IPMContextRef                   contextRef;
  506.     OCERecipient *                  queue;
  507.     AuthIdentity                    identity;
  508.     IPMFilter *                     filter;
  509.     IPMQueueRef                     newQueueRef;
  510.     IPMNoteUPP                      notificationProc;
  511.     unsigned long                   userData;
  512.     IPMNotificationType             noteType;
  513.     Byte                            padByte;
  514.     long                            reserved;
  515.     long                            reserved2;
  516. };
  517. typedef struct IPMOpenQueuePB           IPMOpenQueuePB;
  519. struct IPMCloseQueuePB {
  520.     void *                          qLink;
  521.     long                            reservedH1;
  522.     long                            reservedH2;
  523.     IPMIOCompletionUPP              ioCompletion;
  524.     OSErr                           ioResult;
  525.     long                            saveA5;
  526.     short                           reqCode;
  527.     IPMQueueRef                     queueRef;
  528. };
  529. typedef struct IPMCloseQueuePB          IPMCloseQueuePB;
  531. struct IPMEnumerateQueuePB {
  532.     void *                          qLink;
  533.     long                            reservedH1;
  534.     long                            reservedH2;
  535.     IPMIOCompletionUPP              ioCompletion;
  536.     OSErr                           ioResult;
  537.     long                            saveA5;
  538.     short                           reqCode;
  539.     IPMQueueRef                     queueRef;
  540.     IPMSeqNum                       startSeqNum;
  541.     Boolean                         getProcHint;
  542.     Boolean                         getMsgType;
  543.     short                           filler;
  544.     IPMFilter *                     filter;
  545.     unsigned short                  numToGet;
  546.     unsigned short                  numGotten;
  547.     unsigned long                   enumCount;
  548.     void *                          enumBuffer;                 /* will be packed array of IPMMsgInfo */
  549.     unsigned long                   actEnumCount;
  550. };
  551. typedef struct IPMEnumerateQueuePB      IPMEnumerateQueuePB;
  553. typedef IPMEnumerateQueuePB             IPMChangeQueueFilterPB;
  555. struct IPMDeleteMsgRangePB {
  556.     void *                          qLink;
  557.     long                            reservedH1;
  558.     long                            reservedH2;
  559.     IPMIOCompletionUPP              ioCompletion;
  560.     OSErr                           ioResult;
  561.     long                            saveA5;
  562.     short                           reqCode;
  563.     IPMQueueRef                     queueRef;
  564.     IPMSeqNum                       startSeqNum;
  565.     IPMSeqNum                       endSeqNum;
  566.     IPMSeqNum                       lastSeqNum;
  567. };
  568. typedef struct IPMDeleteMsgRangePB      IPMDeleteMsgRangePB;
  571. struct IPMOpenMsgPB {
  572.     void *                          qLink;
  573.     long                            reservedH1;
  574.     long                            reservedH2;
  575.     IPMIOCompletionUPP              ioCompletion;
  576.     OSErr                           ioResult;
  577.     long                            saveA5;
  578.     short                           reqCode;
  579.     IPMQueueRef                     queueRef;
  580.     IPMSeqNum                       sequenceNum;
  581.     IPMMsgRef                       newMsgRef;
  582.     IPMSeqNum                       actualSeqNum;
  583.     Boolean                         exactMatch;
  584.     Byte                            padByte;
  585.     long                            reserved;
  586. };
  587. typedef struct IPMOpenMsgPB             IPMOpenMsgPB;
  590. struct IPMOpenHFSMsgPB {
  591.     void *                          qLink;
  592.     long                            reservedH1;
  593.     long                            reservedH2;
  594.     IPMIOCompletionUPP              ioCompletion;
  595.     OSErr                           ioResult;
  596.     long                            saveA5;
  597.     short                           reqCode;
  598.     FSSpec *                        hfsPath;
  599.     long                            filler;
  600.     IPMMsgRef                       newMsgRef;
  601.     long                            filler2;
  602.     Byte                            filler3;
  603.     Boolean                         filler4;
  604.     long                            reserved;
  605. };
  606. typedef struct IPMOpenHFSMsgPB          IPMOpenHFSMsgPB;
  609. struct IPMOpenBlockAsMsgPB {
  610.     void *                          qLink;
  611.     long                            reservedH1;
  612.     long                            reservedH2;
  613.     IPMIOCompletionUPP              ioCompletion;
  614.     OSErr                           ioResult;
  615.     long                            saveA5;
  616.     short                           reqCode;
  617.     IPMMsgRef                       msgRef;
  618.     unsigned long                   filler;
  619.     IPMMsgRef                       newMsgRef;
  620.     unsigned short                  filler2[7];
  621.     unsigned short                  blockIndex;
  622. };
  623. typedef struct IPMOpenBlockAsMsgPB      IPMOpenBlockAsMsgPB;
  626. struct IPMCloseMsgPB {
  627.     void *                          qLink;
  628.     long                            reservedH1;
  629.     long                            reservedH2;
  630.     IPMIOCompletionUPP              ioCompletion;
  631.     OSErr                           ioResult;
  632.     long                            saveA5;
  633.     short                           reqCode;
  634.     IPMMsgRef                       msgRef;
  635.     Boolean                         deleteMsg;
  636.     Boolean                         filler1;
  637. };
  638. typedef struct IPMCloseMsgPB            IPMCloseMsgPB;
  641. struct IPMGetMsgInfoPB {
  642.     void *                          qLink;
  643.     long                            reservedH1;
  644.     long                            reservedH2;
  645.     IPMIOCompletionUPP              ioCompletion;
  646.     OSErr                           ioResult;
  647.     long                            saveA5;
  648.     short                           reqCode;
  649.     IPMMsgRef                       msgRef;
  650.     IPMMsgInfo *                    info;
  651. };
  652. typedef struct IPMGetMsgInfoPB          IPMGetMsgInfoPB;
  655. struct IPMReadHeaderPB {
  656.     void *                          qLink;
  657.     long                            reservedH1;
  658.     long                            reservedH2;
  659.     IPMIOCompletionUPP              ioCompletion;
  660.     OSErr                           ioResult;
  661.     long                            saveA5;
  662.     short                           reqCode;
  663.     IPMMsgRef                       msgRef;
  664.     unsigned short                  fieldSelector;
  665.     long                            offset;
  666.     unsigned long                   count;
  667.     void *                          buffer;
  668.     unsigned long                   actualCount;
  669.     unsigned short                  filler;
  670.     unsigned long                   remaining;
  671. };
  672. typedef struct IPMReadHeaderPB          IPMReadHeaderPB;
  675. struct IPMReadRecipientPB {
  676.     void *                          qLink;
  677.     long                            reservedH1;
  678.     long                            reservedH2;
  679.     IPMIOCompletionUPP              ioCompletion;
  680.     OSErr                           ioResult;
  681.     long                            saveA5;
  682.     short                           reqCode;
  683.     IPMMsgRef                       msgRef;
  684.     unsigned short                  rcptIndex;
  685.     long                            offset;
  686.     unsigned long                   count;
  687.     void *                          buffer;
  688.     unsigned long                   actualCount;
  689.     short                           reserved;                   /* must be zero */
  690.     unsigned long                   remaining;
  691.     unsigned short                  originalIndex;
  692.     OCERecipientOffsetFlags         recipientOffsetFlags;
  693.     Boolean                         filler1;
  694. };
  695. typedef struct IPMReadRecipientPB       IPMReadRecipientPB;
  697. /*
  698. replyQueue works like recipient. [can no longer read it via ReadHeader]
  699. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  700. currently none defined.
  701. */
  703. typedef IPMReadRecipientPB              IPMReadReplyQueuePB;
  705. struct IPMGetBlkIndexPB {
  706.     void *                          qLink;
  707.     long                            reservedH1;
  708.     long                            reservedH2;
  709.     IPMIOCompletionUPP              ioCompletion;
  710.     OSErr                           ioResult;
  711.     long                            saveA5;
  712.     short                           reqCode;
  713.     IPMMsgRef                       msgRef;
  714.     IPMBlockType                    blockType;
  715.     unsigned short                  index;
  716.     unsigned short                  startingFrom;
  717.     IPMBlockType                    actualBlockType;
  718.     unsigned short                  actualBlockIndex;
  719. };
  720. typedef struct IPMGetBlkIndexPB         IPMGetBlkIndexPB;
  723. struct IPMReadMsgPB {
  724.     void *                          qLink;
  725.     long                            reservedH1;
  726.     long                            reservedH2;
  727.     IPMIOCompletionUPP              ioCompletion;
  728.     OSErr                           ioResult;
  729.     long                            saveA5;
  730.     short                           reqCode;
  731.     IPMMsgRef                       msgRef;
  732.     IPMAccessMode                   mode;
  733.     long                            offset;
  734.     unsigned long                   count;
  735.     void *                          buffer;
  736.     unsigned long                   actualCount;
  737.     unsigned short                  blockIndex;
  738.     unsigned long                   remaining;
  739. };
  740. typedef struct IPMReadMsgPB             IPMReadMsgPB;
  742. struct IPMVerifySignaturePB {
  743.     void *                          qLink;
  744.     long                            reservedH1;
  745.     long                            reservedH2;
  746.     IPMIOCompletionUPP              ioCompletion;
  747.     OSErr                           ioResult;
  748.     long                            saveA5;
  749.     short                           reqCode;
  750.     IPMMsgRef                       msgRef;
  751.     SIGContextPtr                   signatureContext;
  752. };
  753. typedef struct IPMVerifySignaturePB     IPMVerifySignaturePB;
  755. struct IPMNewMsgPB {
  756.     void *                          qLink;
  757.     long                            reservedH1;
  758.     long                            reservedH2;
  759.     IPMIOCompletionUPP              ioCompletion;
  760.     OSErr                           ioResult;
  761.     long                            saveA5;
  762.     short                           reqCode;
  763.     unsigned long                   filler;
  764.     OCERecipient *                  recipient;
  765.     OCERecipient *                  replyQueue;
  766.     StringPtr                       procHint;
  767.     unsigned short                  filler2;
  768.     IPMMsgType *                    msgType;
  769.     unsigned long                   refCon;
  770.     IPMMsgRef                       newMsgRef;
  771.     unsigned short                  filler3;
  772.     long                            filler4;
  773.     AuthIdentity                    identity;
  774.     IPMSender *                     sender;
  775.     unsigned long                   internalUse;
  776.     unsigned long                   internalUse2;
  777. };
  778. typedef struct IPMNewMsgPB              IPMNewMsgPB;
  780. struct IPMNewHFSMsgPB {
  781.     void *                          qLink;
  782.     long                            reservedH1;
  783.     long                            reservedH2;
  784.     IPMIOCompletionUPP              ioCompletion;
  785.     OSErr                           ioResult;
  786.     long                            saveA5;
  787.     short                           reqCode;
  788.     FSSpec *                        hfsPath;
  789.     OCERecipient *                  recipient;
  790.     OCERecipient *                  replyQueue;
  791.     StringPtr                       procHint;
  792.     unsigned short                  filler2;
  793.     IPMMsgType *                    msgType;
  794.     unsigned long                   refCon;
  795.     IPMMsgRef                       newMsgRef;
  796.     unsigned short                  filler3;
  797.     long                            filler4;
  798.     AuthIdentity                    identity;
  799.     IPMSender *                     sender;
  800.     unsigned long                   internalUse;
  801.     unsigned long                   internalUse2;
  802. };
  803. typedef struct IPMNewHFSMsgPB           IPMNewHFSMsgPB;
  805. struct IPMNestMsgPB {
  806.     void *                          qLink;
  807.     long                            reservedH1;
  808.     long                            reservedH2;
  809.     IPMIOCompletionUPP              ioCompletion;
  810.     OSErr                           ioResult;
  811.     long                            saveA5;
  812.     short                           reqCode;
  813.     IPMMsgRef                       msgRef;
  814.     unsigned short                  filler[9];
  815.     unsigned long                   refCon;
  816.     IPMMsgRef                       msgToNest;
  817.     unsigned short                  filler2;
  818.     long                            startingOffset;
  819. };
  820. typedef struct IPMNestMsgPB             IPMNestMsgPB;
  823. struct IPMNewNestedMsgBlockPB {
  824.     void *                          qLink;
  825.     long                            reservedH1;
  826.     long                            reservedH2;
  827.     IPMIOCompletionUPP              ioCompletion;
  828.     OSErr                           ioResult;
  829.     long                            saveA5;
  830.     short                           reqCode;
  831.     IPMMsgRef                       msgRef;
  832.     OCERecipient *                  recipient;
  833.     OCERecipient *                  replyQueue;
  834.     StringPtr                       procHint;
  835.     unsigned short                  filler1;
  836.     IPMMsgType *                    msgType;
  837.     unsigned long                   refCon;
  838.     IPMMsgRef                       newMsgRef;
  839.     unsigned short                  filler2;
  840.     long                            startingOffset;
  841.     AuthIdentity                    identity;
  842.     IPMSender *                     sender;
  843.     unsigned long                   internalUse;
  844.     unsigned long                   internalUse2;
  845. };
  846. typedef struct IPMNewNestedMsgBlockPB   IPMNewNestedMsgBlockPB;
  849. struct IPMEndMsgPB {
  850.     void *                          qLink;
  851.     long                            reservedH1;
  852.     long                            reservedH2;
  853.     IPMIOCompletionUPP              ioCompletion;
  854.     OSErr                           ioResult;
  855.     long                            saveA5;
  856.     short                           reqCode;
  857.     IPMMsgRef                       msgRef;
  858.     IPMMsgID                        msgID;
  859.     RString *                       msgTitle;
  860.     IPMNotificationType             deliveryNotification;
  861.     IPMPriority                     priority;
  862.     Boolean                         cancel;
  863.     Byte                            padByte;
  864.     long                            reserved;
  865.     SIGSignaturePtr                 signature;
  866.     Size                            signatureSize;
  867.     SIGContextPtr                   signatureContext;
  868.                                                                 /* family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default */
  869.     OSType                          family;
  870. };
  871. typedef struct IPMEndMsgPB              IPMEndMsgPB;
  874. struct IPMAddRecipientPB {
  875.     void *                          qLink;
  876.     long                            reservedH1;
  877.     long                            reservedH2;
  878.     IPMIOCompletionUPP              ioCompletion;
  879.     OSErr                           ioResult;
  880.     long                            saveA5;
  881.     short                           reqCode;
  882.     IPMMsgRef                       msgRef;
  883.     OCERecipient *                  recipient;
  884.     long                            reserved;
  885. };
  886. typedef struct IPMAddRecipientPB        IPMAddRecipientPB;
  889. struct IPMAddReplyQueuePB {
  890.     void *                          qLink;
  891.     long                            reservedH1;
  892.     long                            reservedH2;
  893.     IPMIOCompletionUPP              ioCompletion;
  894.     OSErr                           ioResult;
  895.     long                            saveA5;
  896.     short                           reqCode;
  897.     IPMMsgRef                       msgRef;
  898.     long                            filler;
  899.     OCERecipient *                  replyQueue;
  900. };
  901. typedef struct IPMAddReplyQueuePB       IPMAddReplyQueuePB;
  904. struct IPMNewBlockPB {
  905.     void *                          qLink;
  906.     long                            reservedH1;
  907.     long                            reservedH2;
  908.     IPMIOCompletionUPP              ioCompletion;
  909.     OSErr                           ioResult;
  910.     long                            saveA5;
  911.     short                           reqCode;
  912.     IPMMsgRef                       msgRef;
  913.     IPMBlockType                    blockType;
  914.     unsigned short                  filler[5];
  915.     unsigned long                   refCon;
  916.     unsigned short                  filler2[3];
  917.     long                            startingOffset;
  918. };
  919. typedef struct IPMNewBlockPB            IPMNewBlockPB;
  922. struct IPMWriteMsgPB {
  923.     void *                          qLink;
  924.     long                            reservedH1;
  925.     long                            reservedH2;
  926.     IPMIOCompletionUPP              ioCompletion;
  927.     OSErr                           ioResult;
  928.     long                            saveA5;
  929.     short                           reqCode;
  930.     IPMMsgRef                       msgRef;
  931.     IPMAccessMode                   mode;
  932.     long                            offset;
  933.     unsigned long                   count;
  934.     void *                          buffer;
  935.     unsigned long                   actualCount;
  936.     Boolean                         currentBlock;
  937.     Boolean                         filler1;
  938. };
  939. typedef struct IPMWriteMsgPB            IPMWriteMsgPB;
  943. union IPMParamBlock {
  944.     struct {
  945.         void *                          qLink;
  946.         long                            reservedH1;
  947.         long                            reservedH2;
  948.         IPMIOCompletionUPP              ioCompletion;
  949.         OSErr                           ioResult;
  950.         long                            saveA5;
  951.         short                           reqCode;
  952.     }                                 header;
  953.     IPMOpenContextPB                openContextPB;
  954.     IPMCloseContextPB               closeContextPB;
  955.     IPMCreateQueuePB                createQueuePB;
  956.     IPMDeleteQueuePB                deleteQueuePB;
  957.     IPMOpenQueuePB                  openQueuePB;
  958.     IPMCloseQueuePB                 closeQueuePB;
  959.     IPMEnumerateQueuePB             enumerateQueuePB;
  960.     IPMChangeQueueFilterPB          changeQueueFilterPB;
  961.     IPMDeleteMsgRangePB             deleteMsgRangePB;
  962.     IPMOpenMsgPB                    openMsgPB;
  963.     IPMOpenHFSMsgPB                 openHFSMsgPB;
  964.     IPMOpenBlockAsMsgPB             openBlockAsMsgPB;
  965.     IPMCloseMsgPB                   closeMsgPB;
  966.     IPMGetMsgInfoPB                 getMsgInfoPB;
  967.     IPMReadHeaderPB                 readHeaderPB;
  968.     IPMReadRecipientPB              readRecipientPB;
  969.     IPMReadReplyQueuePB             readReplyQueuePB;
  970.     IPMGetBlkIndexPB                getBlkIndexPB;
  971.     IPMReadMsgPB                    readMsgPB;
  972.     IPMVerifySignaturePB            verifySignaturePB;
  973.     IPMNewMsgPB                     newMsgPB;
  974.     IPMNewHFSMsgPB                  newHFSMsgPB;
  975.     IPMNestMsgPB                    nestMsgPB;
  976.     IPMNewNestedMsgBlockPB          newNestedMsgBlockPB;
  977.     IPMEndMsgPB                     endMsgPB;
  978.     IPMAddRecipientPB               addRecipientPB;
  979.     IPMAddReplyQueuePB              addReplyQueuePB;
  980.     IPMNewBlockPB                   newBlockPB;
  981.     IPMWriteMsgPB                   writeMsgPB;
  982. };
  984. #if OPAQUE_UPP_TYPES
  985. #if CALL_NOT_IN_CARBON
  986.     EXTERN_API(IPMIOCompletionUPP)
  987.     NewIPMIOCompletionUPP          (IPMIOCompletionProcPtr  userRoutine);
  989.     EXTERN_API(void)
  990.     DisposeIPMIOCompletionUPP      (IPMIOCompletionUPP      userUPP);
  992.     EXTERN_API(void)
  993.     InvokeIPMIOCompletionUPP       (IPMParamBlockPtr        paramBlock,
  994.                                     IPMIOCompletionUPP      userUPP);
  996. #endif  /* CALL_NOT_IN_CARBON */
  998. #else
  999.     enum { uppIPMIOCompletionProcInfo = 0x00009802 };               /* register no_return_value Func(4_bytes:A0) */
  1000.     #define NewIPMIOCompletionUPP(userRoutine)                      (IPMIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMIOCompletionProcInfo, GetCurrentArchitecture())
  1001.     #define DisposeIPMIOCompletionUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
  1002.     #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  1003.     #pragma parameter InvokeIPMIOCompletionUPP(__A0, __A1)
  1004.     void InvokeIPMIOCompletionUPP(IPMParamBlockPtr paramBlock, IPMIOCompletionUPP userUPP) = 0x4E91;
  1005.     #else
  1006.         #define InvokeIPMIOCompletionUPP(paramBlock, userUPP)           CALL_ONE_PARAMETER_UPP((userUPP), uppIPMIOCompletionProcInfo, (paramBlock))
  1007.     #endif
  1008. #endif
  1009. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  1010. #define NewIPMIOCompletionProc(userRoutine)                     NewIPMIOCompletionUPP(userRoutine)
  1011. #define CallIPMIOCompletionProc(userRoutine, paramBlock)        InvokeIPMIOCompletionUPP(paramBlock, userRoutine)
  1012. #if CALL_NOT_IN_CARBON
  1013. EXTERN_API( OSErr )
  1014. IPMOpenContext                  (IPMParamBlockPtr       paramBlock,
  1015.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0400, 0xAA5E);
  1017. EXTERN_API( OSErr )
  1018. IPMCloseContext                 (IPMParamBlockPtr       paramBlock,
  1019.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0401, 0xAA5E);
  1021. EXTERN_API( OSErr )
  1022. IPMNewMsg                       (IPMParamBlockPtr       paramBlock,
  1023.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0402, 0xAA5E);
  1025. EXTERN_API( OSErr )
  1026. IPMNewBlock                     (IPMParamBlockPtr       paramBlock,
  1027.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0404, 0xAA5E);
  1029. EXTERN_API( OSErr )
  1030. IPMNewNestedMsgBlock            (IPMParamBlockPtr       paramBlock,
  1031.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0405, 0xAA5E);
  1033. EXTERN_API( OSErr )
  1034. IPMNestMsg                      (IPMParamBlockPtr       paramBlock,
  1035.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0406, 0xAA5E);
  1037. EXTERN_API( OSErr )
  1038. IPMWriteMsg                     (IPMParamBlockPtr       paramBlock,
  1039.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0407, 0xAA5E);
  1041. EXTERN_API( OSErr )
  1042. IPMEndMsg                       (IPMParamBlockPtr       paramBlock,
  1043.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0408, 0xAA5E);
  1045. EXTERN_API( OSErr )
  1046. IPMOpenQueue                    (IPMParamBlockPtr       paramBlock,
  1047.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0409, 0xAA5E);
  1049. EXTERN_API( OSErr )
  1050. IPMCloseQueue                   (IPMParamBlockPtr       paramBlock,
  1051.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040A, 0xAA5E);
  1053. /* Always synchronous */
  1054. EXTERN_API( OSErr )
  1055. IPMVerifySignature              (IPMParamBlockPtr       paramBlock)                         FIVEWORDINLINE(0x7000, 0x1F00, 0x3F3C, 0x0422, 0xAA5E);
  1057. EXTERN_API( OSErr )
  1058. IPMOpenMsg                      (IPMParamBlockPtr       paramBlock,
  1059.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040B, 0xAA5E);
  1061. EXTERN_API( OSErr )
  1062. IPMCloseMsg                     (IPMParamBlockPtr       paramBlock,
  1063.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040C, 0xAA5E);
  1065. EXTERN_API( OSErr )
  1066. IPMReadMsg                      (IPMParamBlockPtr       paramBlock,
  1067.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040D, 0xAA5E);
  1069. EXTERN_API( OSErr )
  1070. IPMReadHeader                   (IPMParamBlockPtr       paramBlock,
  1071.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040E, 0xAA5E);
  1073. EXTERN_API( OSErr )
  1074. IPMOpenBlockAsMsg               (IPMParamBlockPtr       paramBlock,
  1075.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x040F, 0xAA5E);
  1077. EXTERN_API( OSErr )
  1078. IPMNewHFSMsg                    (IPMParamBlockPtr       paramBlock,
  1079.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x041E, 0xAA5E);
  1081. EXTERN_API( OSErr )
  1082. IPMReadRecipient                (IPMParamBlockPtr       paramBlock,
  1083.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0410, 0xAA5E);
  1085. EXTERN_API( OSErr )
  1086. IPMReadReplyQueue               (IPMParamBlockPtr       paramBlock,
  1087.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0421, 0xAA5E);
  1089. EXTERN_API( OSErr )
  1090. IPMCreateQueue                  (IPMParamBlockPtr       paramBlock,
  1091.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0411, 0xAA5E);
  1093. EXTERN_API( OSErr )
  1094. IPMDeleteQueue                  (IPMParamBlockPtr       paramBlock,
  1095.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0412, 0xAA5E);
  1097. EXTERN_API( OSErr )
  1098. IPMEnumerateQueue               (IPMParamBlockPtr       paramBlock,
  1099.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0413, 0xAA5E);
  1101. EXTERN_API( OSErr )
  1102. IPMChangeQueueFilter            (IPMParamBlockPtr       paramBlock,
  1103.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0414, 0xAA5E);
  1105. EXTERN_API( OSErr )
  1106. IPMDeleteMsgRange               (IPMParamBlockPtr       paramBlock,
  1107.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0415, 0xAA5E);
  1109. EXTERN_API( OSErr )
  1110. IPMAddRecipient                 (IPMParamBlockPtr       paramBlock,
  1111.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0403, 0xAA5E);
  1113. EXTERN_API( OSErr )
  1114. IPMAddReplyQueue                (IPMParamBlockPtr       paramBlock,
  1115.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x041D, 0xAA5E);
  1117. EXTERN_API( OSErr )
  1118. IPMOpenHFSMsg                   (IPMParamBlockPtr       paramBlock,
  1119.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0417, 0xAA5E);
  1121. EXTERN_API( OSErr )
  1122. IPMGetBlkIndex                  (IPMParamBlockPtr       paramBlock,
  1123.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0418, 0xAA5E);
  1125. EXTERN_API( OSErr )
  1126. IPMGetMsgInfo                   (IPMParamBlockPtr       paramBlock,
  1127.                                  Boolean                async)                              THREEWORDINLINE(0x3F3C, 0x0419, 0xAA5E);
  1131. #endif  /* CALL_NOT_IN_CARBON */
  1134. #if PRAGMA_STRUCT_ALIGN
  1135.     #pragma options align=reset
  1136. #elif PRAGMA_STRUCT_PACKPUSH
  1137.     #pragma pack(pop)
  1138. #elif PRAGMA_STRUCT_PACK
  1139.     #pragma pack()
  1140. #endif
  1142. #ifdef PRAGMA_IMPORT_OFF
  1143. #pragma import off
  1144. #elif PRAGMA_IMPORT
  1145. #pragma import reset
  1146. #endif
  1148. #ifdef __cplusplus
  1149. }
  1150. #endif
  1152. #endif /* __OCEMESSAGING__ */