home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: OtherApp / OtherApp.zip / aping.zip / cpic.h < prev    next >
C/C++ Source or Header  |  1993-02-09  |  47KB  |  1,068 lines
  1. /*
  2.  * NOTE:
  3.  * Before you use this file, you must set a supported operating
  4.  * system constant.  Search on SYSTEM to find the list of supported
  5.  * constants and how to set the appropriate one.
  6.  */
  7.  
  8.  
  9. /*
  10.  * This file is organized as follows:
  11.  *  - product specific preprocessor directives that must be before all
  12.  *    other declarations
  13.  *  - Base CPI-C constants and type definitions
  14.  *  - Base CPI-C function prototypes
  15.  *  - Product specific constants and type definitions (enclosed in #if/#endif)
  16.  *  - Product specific function prototypes (enclosed in #if/#endif)
  17.  */
  18.  
  19. #ifndef _cpic_h
  20. #define _cpic_h
  21.  
  22. /*
  23.  * SYSTEM should be changed in the following #define
  24.  * to an appropriate value for your platform.
  25.  * The following values are handled by this file:
  26.  *    CM_AIX
  27.  *    CM_DOS
  28.  *    CM_MVS
  29.  *    CM_OS2
  30.  *    CM_OS400
  31.  *    CM_VM
  32.  *
  33.  * This is necessary for the proper setting of
  34.  * CM_ENTRY and CM_PTR below.
  35.  */
  36.  
  37.  
  38. #if ! ( defined(CM_AIX) || defined(CM_DOS) || defined(CM_MVS) || \
  39.         defined(CM_OS2) || defined(CM_OS400) || defined(CM_VM)   \
  40.       )
  41. /*
  42.  * Define the system ONLY if no system has been defined by the program.
  43.  * This avoids duplicate macro definition warnings and allows this
  44.  * include file to be moved to other platforms more easily.
  45.  *
  46.  * If you choose to move this include file to another platform,
  47.  * we recommend that you define the CM_ constant for that platform
  48.  * externally on the compiler command line.
  49.  */
  50.  
  51. #define SYSTEM
  52.  
  53. #endif
  54.  
  55.  
  56. /*
  57.  * CPI Communications Enumerated Constants
  58.  */
  59.  
  60. /*
  61.  * CM_INT32 should be a 32-bit, signed integer.  The following #define
  62.  * is system dependent and may need to be changed on systems where
  63.  * signed long int does not define a 32-bit, signed integer.
  64.  */
  65.  
  66. #define CM_INT32 signed long int
  67.  
  68.  
  69.  
  70.  
  71.  
  72. #ifdef   CM_OS2
  73. #ifdef   __32BIT__
  74. #ifndef  ES32TO16
  75. #define  ES32TO16
  76. #endif
  77. #endif
  78. #endif
  79.  
  80.  
  81.  
  82. #if   defined( CM_DOS ) || defined( CM_OS2 )
  83.  
  84. #     define CM_ENTRY extern void pascal far _loadds
  85. #     define CM_PTR far *
  86.  
  87. #elif defined( CM_MVS ) || defined( CM_OS400 ) || \
  88.       defined( CM_VM ) || defined(AIX)
  89.  
  90. #     define CM_ENTRY extern void
  91. #     define CM_PTR *
  92.  
  93. #else
  94.  
  95. /*
  96.  * If we have gotten this far, a supported system constant has not
  97.  * been defined.  We will produce a syntax error on the next line
  98.  * that should help the user identify the problem.
  99.  *
  100.  * To correct this problem, a system constant should be defined
  101.  * either above in this file, or externally with a compiler option.
  102.  */
  103. INTENTIONAL_SYNTAX_ERROR define_a_system_in_cpic_h();
  104.  
  105. #endif
  106.  
  107.  
  108.  
  109. #ifdef ES32TO16
  110.  
  111. /*
  112.  * The IBM C Set/2 32 bit compiler for OS/2 2.0 requires different
  113.  * definitions for entry points, pointers, and structures.
  114.  * These definitions help the compiler perform the translations from
  115.  * 32bit addresses to segmented addresses.
  116.  */
  117.  
  118. #   ifdef CM_PTR
  119. #      undef CM_PTR
  120. #   endif
  121. #   ifdef CM_ENTRY
  122. #      undef CM_ENTRY
  123. #   endif
  124. #   ifdef CM_INT32
  125. #      undef CM_INT32
  126. #   endif
  127. # define CM_PTR * _Seg16
  128. # define CM_ENTRY extern void
  129. # define CM_INT32 signed int
  130.  
  131. # define STRUCT16 _Packed struct
  132. # pragma seg16(SIDE_INFO)
  133. #else
  134. # define STRUCT16 struct
  135. #endif
  136.  
  137. #if defined(CM_OS400) || defined(CM_MVS)
  138. #define cmacci CMACCI
  139. #define cmaccp CMACCP
  140. #define cmallc CMALLC
  141. #define cmcanc CMCANC
  142. #define cmcfm  CMCFM
  143. #define cmcfmd CMCFMD
  144. #define cmcnvi CMCNVI
  145. #define cmcnvo CMCNVO
  146. #define cmdeal CMDEAL
  147. #define cmecs  CMECS
  148. #define cmect  CMECT
  149. #define cmectx CMECTX
  150. #define cmembs CMEMBS
  151. #define cmemn  CMEMN
  152. #define cmepln CMEPLN
  153. #define cmesl  CMESL
  154. #define cmesui CMESUI
  155. #define cmetpn CMETPN
  156. #define cmflus CMFLUS
  157. #define cminic CMINIC
  158. #define cminit CMINIT
  159. #define cminit CMINIT
  160. #define cmptr  CMPTR
  161. #define cmrcv  CMRCV
  162. #define cmrltp CMRLTP
  163. #define cmrts  CMRTS
  164. #define cmscsp CMSCSP
  165. #define cmscst CMSCST
  166. #define cmscsu CMSCSU
  167. #define cmsct  CMSCT
  168. #define cmsdt  CMSDT
  169. #define cmsed  CMSED
  170. #define cmsend CMSEND
  171. #define cmserr CMSERR
  172. #define cmsf   CMSF
  173. #define cmsld  CMSLD
  174. #define cmsltp CMSLTP
  175. #define cmsmn  CMSMN
  176. #define cmspln CMSPLN
  177. #define cmspm  CMSPM
  178. #define cmsptr CMSPTR
  179. #define cmsrc  CMSRC
  180. #define cmsrt  CMSRT
  181. #define cmssl  CMSSL
  182. #define cmsst  CMSST
  183. #define cmstpn CMSTPN
  184. #define cmtrts CMTRTS
  185. #define cmwait CMWAIT
  186. #endif
  187.  
  188.  
  189.  
  190. /*
  191.  *  - Base CPI-C constants and type definitions
  192.  */
  193.  
  194. /* conversation ID */
  195. typedef char CONVERSATION_ID [8];
  196. typedef char CONTEXT_ID [32];
  197. typedef char SECURITY_PASSWORD [10];
  198. typedef char SECURITY_USER_ID [10];
  199.  
  200. typedef CM_INT32 CM_BUFFER_LENGTH;
  201. typedef CM_INT32 CM_CONTEXT_ID_LENGTH;
  202. typedef CM_INT32 CM_CONVERSATION_RETURN_CODE;
  203. typedef CM_INT32 CM_SECURITY_PASSWORD_LENGTH;
  204. typedef CM_INT32 CM_CONVERSATION_SECURITY_TYPE;
  205. typedef CM_INT32 CM_SECURITY_USER_ID_LENGTH;
  206. typedef CM_INT32 CM_CONVERSATION_STATE;
  207. typedef CM_INT32 CM_CONVERSATION_TYPE;
  208. typedef CM_INT32 CM_DATA_RECEIVED_TYPE;
  209. typedef CM_INT32 CM_DEALLOCATE_TYPE;
  210. typedef CM_INT32 CM_ERROR_DIRECTION;
  211. typedef CM_INT32 CM_FILL;
  212. typedef CM_INT32 CM_MAXIMUM_BUFFER_SIZE;
  213. typedef CM_INT32 CM_PREPARE_TO_RECEIVE_TYPE;
  214. typedef CM_INT32 CM_RECEIVE_TYPE;
  215. typedef CM_INT32 CM_REQUEST_TO_SEND_RECEIVED;
  216. typedef CM_INT32 CM_RETURN_CODE;
  217. typedef CM_INT32 CM_RETURN_CONTROL;
  218. typedef CM_INT32 CM_SEND_TYPE;
  219. typedef CM_INT32 CM_STATUS_RECEIVED;
  220. typedef CM_INT32 CM_SYNC_LEVEL;
  221. typedef CM_INT32 CM_PROCESSING_MODE;
  222.  
  223. /* X/open typedefs for compatibilty  */
  224. typedef CM_INT32 CONVERSATION_STATE;
  225. typedef CM_INT32 CONVERSATION_TYPE;
  226. typedef CM_INT32 CONVERSATION_SECURITY_TYPE;
  227. typedef CM_INT32 DATA_RECEIVED_TYPE;
  228. typedef CM_INT32 DEALLOCATE_TYPE;
  229. typedef CM_INT32 ERROR_DIRECTION;
  230. typedef CM_INT32 FILL;
  231. typedef CM_INT32 PREPARE_TO_RECEIVE_TYPE;
  232. typedef CM_INT32 RECEIVE_TYPE;
  233. typedef CM_INT32 REQUEST_TO_SEND_RECEIVED;
  234. typedef CM_INT32 CM_RETCODE;
  235. typedef CM_INT32 RETURN_CONTROL;
  236. typedef CM_INT32 SEND_TYPE;
  237. typedef CM_INT32 STATUS_RECEIVED;
  238. typedef CM_INT32 SYNC_LEVEL;
  239. typedef CM_INT32 PROCESSING_MODE;
  240.  
  241. /*
  242.  * Enumerated data types (enum) have not been used for the
  243.  * constant values because the default type for an enum
  244.  * is 'int'.  This causes type conflicts on compilers where
  245.  * int is not the same size as CM_INT32.
  246.  */
  247.  
  248. /*  conversation_state values  */
  249.  
  250. #define CM_INITIALIZE_STATE              (CM_CONVERSATION_STATE) 2
  251. #define CM_SEND_STATE                    (CM_CONVERSATION_STATE) 3
  252. #define CM_RECEIVE_STATE                 (CM_CONVERSATION_STATE) 4
  253. #define CM_SEND_PENDING_STATE            (CM_CONVERSATION_STATE) 5
  254. #define CM_CONFIRM_STATE                 (CM_CONVERSATION_STATE) 6
  255. #define CM_CONFIRM_SEND_STATE            (CM_CONVERSATION_STATE) 7
  256. #define CM_CONFIRM_DEALLOCATE_STATE      (CM_CONVERSATION_STATE) 8
  257. #define CM_DEFER_RECEIVE_STATE           (CM_CONVERSATION_STATE) 9
  258. #define CM_DEFER_DEALLOCATE_STATE        (CM_CONVERSATION_STATE) 10
  259. #define CM_SYNC_POINT_STATE              (CM_CONVERSATION_STATE) 11
  260. #define CM_SYNC_POINT_SEND_STATE         (CM_CONVERSATION_STATE) 12
  261. #define CM_SYNC_POINT_DEALLOCATE_STATE   (CM_CONVERSATION_STATE) 13
  262. #define CM_INITIALIZE_INCOMING_STATE     (CM_CONVERSATION_STATE) 14
  263.  
  264.  
  265. /*  conversation_type values  */
  266.  
  267. #define CM_BASIC_CONVERSATION            (CM_CONVERSATION_TYPE) 0
  268. #define CM_MAPPED_CONVERSATION           (CM_CONVERSATION_TYPE) 1
  269.  
  270.  
  271. /*  data_received values  */
  272.  
  273. #define CM_NO_DATA_RECEIVED              (CM_DATA_RECEIVED_TYPE) 0
  274. #define CM_DATA_RECEIVED                 (CM_DATA_RECEIVED_TYPE) 1
  275. #define CM_COMPLETE_DATA_RECEIVED        (CM_DATA_RECEIVED_TYPE) 2
  276. #define CM_INCOMPLETE_DATA_RECEIVED      (CM_DATA_RECEIVED_TYPE) 3
  277.  
  278.  
  279. /*  deallocate_type values  */
  280.  
  281. #define CM_DEALLOCATE_SYNC_LEVEL         (CM_DEALLOCATE_TYPE) 0
  282. #define CM_DEALLOCATE_FLUSH              (CM_DEALLOCATE_TYPE) 1
  283. #define CM_DEALLOCATE_CONFIRM            (CM_DEALLOCATE_TYPE) 2
  284. #define CM_DEALLOCATE_ABEND              (CM_DEALLOCATE_TYPE) 3
  285.  
  286.  
  287. /*  error_direction values  */
  288.  
  289. #define CM_RECEIVE_ERROR                 (CM_ERROR_DIRECTION) 0
  290. #define CM_SEND_ERROR                    (CM_ERROR_DIRECTION) 1
  291.  
  292.  
  293. /*  fill values  */
  294.  
  295. #define CM_FILL_LL                       (CM_FILL) 0
  296. #define CM_FILL_BUFFER                   (CM_FILL) 1
  297.  
  298.  
  299. /*  prepare_to_receive_type values  */
  300.  
  301. #define CM_PREP_TO_RECEIVE_SYNC_LEVEL    (CM_PREPARE_TO_RECEIVE_TYPE) 0
  302. #define CM_PREP_TO_RECEIVE_FLUSH         (CM_PREPARE_TO_RECEIVE_TYPE) 1
  303. #define CM_PREP_TO_RECEIVE_CONFIRM       (CM_PREPARE_TO_RECEIVE_TYPE) 2
  304.  
  305.  
  306. /*  processing_mode values  */
  307.  
  308. #define CM_BLOCKING                      (CM_PROCESSING_MODE) 0
  309. #define CM_NON_BLOCKING                  (CM_PROCESSING_MODE) 1
  310.  
  311.  
  312. /*  receive_type values  */
  313.  
  314. #define CM_RECEIVE_AND_WAIT              (CM_RECEIVE_TYPE) 0
  315. #define CM_RECEIVE_IMMEDIATE             (CM_RECEIVE_TYPE) 1
  316.  
  317.  
  318. /*  request_to_send_received values  */
  319.  
  320. #define CM_REQ_TO_SEND_NOT_RECEIVED      (CM_REQUEST_TO_SEND_RECEIVED) 0
  321. #define CM_REQ_TO_SEND_RECEIVED          (CM_REQUEST_TO_SEND_RECEIVED) 1
  322.  
  323.  
  324. /*  return_code values  */
  325.  
  326. #define CM_OK                            (CM_RETURN_CODE) 0
  327. #define CM_ALLOCATE_FAILURE_NO_RETRY     (CM_RETURN_CODE) 1
  328. #define CM_ALLOCATE_FAILURE_RETRY        (CM_RETURN_CODE) 2
  329. #define CM_CONVERSATION_TYPE_MISMATCH    (CM_RETURN_CODE) 3
  330. #define CM_PIP_NOT_SPECIFIED_CORRECTLY   (CM_RETURN_CODE) 5
  331. #define CM_SECURITY_NOT_VALID            (CM_RETURN_CODE) 6
  332. #define CM_SYNC_LVL_NOT_SUPPORTED_LU     (CM_RETURN_CODE) 7
  333. #define CM_SYNC_LVL_NOT_SUPPORTED_PGM    (CM_RETURN_CODE) 8
  334. #define CM_TPN_NOT_RECOGNIZED            (CM_RETURN_CODE) 9
  335. #define CM_TP_NOT_AVAILABLE_NO_RETRY     (CM_RETURN_CODE) 10
  336. #define CM_TP_NOT_AVAILABLE_RETRY        (CM_RETURN_CODE) 11
  337. #define CM_DEALLOCATED_ABEND             (CM_RETURN_CODE) 17
  338. #define CM_DEALLOCATED_NORMAL            (CM_RETURN_CODE) 18
  339. #define CM_PARAMETER_ERROR               (CM_RETURN_CODE) 19
  340. #define CM_PRODUCT_SPECIFIC_ERROR        (CM_RETURN_CODE) 20
  341. #define CM_PROGRAM_ERROR_NO_TRUNC        (CM_RETURN_CODE) 21
  342. #define CM_PROGRAM_ERROR_PURGING         (CM_RETURN_CODE) 22
  343. #define CM_PROGRAM_ERROR_TRUNC           (CM_RETURN_CODE) 23
  344. #define CM_PROGRAM_PARAMETER_CHECK       (CM_RETURN_CODE) 24
  345. #define CM_PROGRAM_STATE_CHECK           (CM_RETURN_CODE) 25
  346. #define CM_RESOURCE_FAILURE_NO_RETRY     (CM_RETURN_CODE) 26
  347. #define CM_RESOURCE_FAILURE_RETRY        (CM_RETURN_CODE) 27
  348. #define CM_UNSUCCESSFUL                  (CM_RETURN_CODE) 28
  349. #define CM_DEALLOCATED_ABEND_SVC         (CM_RETURN_CODE) 30
  350. #define CM_DEALLOCATED_ABEND_TIMER       (CM_RETURN_CODE) 31
  351. #define CM_SVC_ERROR_NO_TRUNC            (CM_RETURN_CODE) 32
  352. #define CM_SVC_ERROR_PURGING             (CM_RETURN_CODE) 33
  353. #define CM_SVC_ERROR_TRUNC               (CM_RETURN_CODE) 34
  354. #define CM_OPERATION_INCOMPLETE          (CM_RETURN_CODE) 35   /* CPIC 1.2 */
  355. #define CM_SYSTEM_EVENT                  (CM_RETURN_CODE) 36   /* CPIC 1.2 */
  356. #define CM_OPERATION_NOT_ACCEPTED        (CM_RETURN_CODE) 37   /* CPIC 1.2 */
  357. #define CM_TAKE_BACKOUT                  (CM_RETURN_CODE) 100
  358. #define CM_DEALLOCATED_ABEND_BO          (CM_RETURN_CODE) 130
  359. #define CM_DEALLOCATED_ABEND_SVC_BO      (CM_RETURN_CODE) 131
  360. #define CM_DEALLOCATED_ABEND_TIMER_BO    (CM_RETURN_CODE) 132
  361. #define CM_RESOURCE_FAIL_NO_RETRY_BO     (CM_RETURN_CODE) 133
  362. #define CM_RESOURCE_FAILURE_RETRY_BO     (CM_RETURN_CODE) 134
  363. #define CM_DEALLOCATED_NORMAL_BO         (CM_RETURN_CODE) 135
  364.  
  365.  
  366. /*  return_control values  */
  367.  
  368. #define CM_WHEN_SESSION_ALLOCATED        (CM_RETURN_CONTROL) 0
  369. #define CM_IMMEDIATE                     (CM_RETURN_CONTROL) 1
  370.  
  371.  
  372. /*  send_type values  */
  373.  
  374. #define CM_BUFFER_DATA                   (CM_SEND_TYPE) 0
  375. #define CM_SEND_AND_FLUSH                (CM_SEND_TYPE) 1
  376. #define CM_SEND_AND_CONFIRM              (CM_SEND_TYPE) 2
  377. #define CM_SEND_AND_PREP_TO_RECEIVE      (CM_SEND_TYPE) 3
  378. #define CM_SEND_AND_DEALLOCATE           (CM_SEND_TYPE) 4
  379.  
  380.  
  381. /*  status_received values  */
  382.  
  383. #define CM_NO_STATUS_RECEIVED            (CM_STATUS_RECEIVED) 0
  384. #define CM_SEND_RECEIVED                 (CM_STATUS_RECEIVED) 1
  385. #define CM_CONFIRM_RECEIVED              (CM_STATUS_RECEIVED) 2
  386. #define CM_CONFIRM_SEND_RECEIVED         (CM_STATUS_RECEIVED) 3
  387. #define CM_CONFIRM_DEALLOC_RECEIVED      (CM_STATUS_RECEIVED) 4
  388. #define CM_TAKE_COMMIT                   (CM_STATUS_RECEIVED) 5
  389. #define CM_TAKE_COMMIT_SEND              (CM_STATUS_RECEIVED) 6
  390. #define CM_TAKE_COMMIT_DEALLOCATE        (CM_STATUS_RECEIVED) 7
  391.  
  392.  
  393. /* sync_level values  */
  394.  
  395. #define CM_NONE                          (CM_SYNC_LEVEL) 0
  396. #define CM_CONFIRM                       (CM_SYNC_LEVEL) 1
  397. #define CM_SYNC_POINT                    (CM_SYNC_LEVEL) 2
  398.  
  399. /* conversation_security_type values */
  400.  
  401. #define CM_SECURITY_NONE                 (CM_CONVERSATION_SECURITY_TYPE) 0
  402. #define CM_SECURITY_SAME                 (CM_CONVERSATION_SECURITY_TYPE) 1
  403. #define CM_SECURITY_PROGRAM              (CM_CONVERSATION_SECURITY_TYPE) 2
  404.  
  405. /* processing mode of conversation */
  406. #define CM_BLOCKING                      (CM_PROCESSING_MODE) 0
  407. #define CM_NON_BLOCKING                  (CM_PROCESSING_MODE) 1
  408.  
  409.  
  410. /*
  411.  *  - Base CPI-C function prototypes
  412.  */
  413.  
  414. #ifdef __cplusplus
  415. extern "C" {
  416. #endif /* __cplusplus */
  417.  
  418. CM_ENTRY cmacci(unsigned char CM_PTR,              /* conversation_ID        */
  419.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  420. CM_ENTRY cmaccp(unsigned char CM_PTR,              /* conversation_ID        */
  421.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  422. CM_ENTRY cmallc(unsigned char CM_PTR,              /* conversation_ID        */
  423.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  424. CM_ENTRY cmcanc(unsigned char CM_PTR,              /* conversation_ID        */
  425.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  426. CM_ENTRY cmcfm( unsigned char CM_PTR,              /* conversation_ID        */
  427.                 CM_REQUEST_TO_SEND_RECEIVED CM_PTR,/*request_to_send_received*/
  428.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  429. CM_ENTRY cmcfmd(unsigned char CM_PTR,              /* conversation_ID        */
  430.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  431. CM_ENTRY cmcnvi(unsigned char CM_PTR,              /* buffer                 */
  432.                 CM_INT32 CM_PTR,                   /* buffer_length          */
  433.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  434. CM_ENTRY cmcnvo(unsigned char CM_PTR,              /* buffer                 */
  435.                 CM_INT32 CM_PTR,                   /* buffer_length          */
  436.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  437. CM_ENTRY cmdeal(unsigned char CM_PTR,              /* conversation_ID        */
  438.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  439. /* Extract_Conversation_State is not supported on AS/400 or MVS */
  440. #if !(defined(CM_OS400) || defined(CM_MVS))
  441. CM_ENTRY cmecs( unsigned char CM_PTR,              /* conversation_ID        */
  442.                 CM_CONVERSATION_STATE CM_PTR,      /* conversation_state     */
  443.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  444. #endif
  445.  
  446. CM_ENTRY cmect( unsigned char CM_PTR,              /* conversation_ID        */
  447.                 CM_CONVERSATION_TYPE CM_PTR,       /* conversation_type      */
  448.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  449. CM_ENTRY cmectx(unsigned char CM_PTR,              /* conversation_ID        */
  450.                 unsigned char CM_PTR,              /* context_ID             */
  451.                 CM_INT32 CM_PTR,                   /* context_ID_length      */
  452.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  453. CM_ENTRY cmembs(CM_INT32 CM_PTR,                   /* maximum_buffer_size    */
  454.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  455. CM_ENTRY cmemn( unsigned char CM_PTR,              /* conversation_ID        */
  456.                 unsigned char CM_PTR,              /* mode_name              */
  457.                 CM_INT32 CM_PTR,                   /* mode_name_length       */
  458.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  459. CM_ENTRY cmepln(unsigned char CM_PTR,              /* conversation_ID        */
  460.                 unsigned char CM_PTR,              /* partner_LU_name        */
  461.                 CM_INT32 CM_PTR,                   /* partner_LU_name_length */
  462.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  463. CM_ENTRY cmesl( unsigned char CM_PTR,              /* conversation_ID        */
  464.                 CM_SYNC_LEVEL CM_PTR,              /* sync_level             */
  465.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  466. CM_ENTRY cmesui(unsigned char  CM_PTR,             /* conversation_ID        */
  467.                 unsigned char  CM_PTR,             /* user_ID                */
  468.                 CM_INT32 CM_PTR,                   /* user_ID_length         */
  469.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  470. CM_ENTRY cmetpn(unsigned char CM_PTR,              /* conversation_ID        */
  471.                 unsigned char CM_PTR,              /* TP_name                */
  472.                 CM_INT32 CM_PTR,                   /* TP_name_length         */
  473.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  474. CM_ENTRY cmflus(unsigned char CM_PTR,              /* conversation_ID        */
  475.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  476. CM_ENTRY cminic(unsigned char CM_PTR,              /* conversation_ID        */
  477.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  478. CM_ENTRY cminit(unsigned char CM_PTR,              /* conversation_ID        */
  479.                 unsigned char CM_PTR,              /* sym_dest_name          */
  480.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  481. CM_ENTRY cmptr( unsigned char CM_PTR,              /* conversation_ID        */
  482.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  483. CM_ENTRY cmrcv( unsigned char CM_PTR,              /* conversation_ID        */
  484.                 unsigned char CM_PTR,              /* buffer                 */
  485.                 CM_INT32 CM_PTR,                   /* requested_length       */
  486.                 CM_DATA_RECEIVED_TYPE CM_PTR,      /* data_received          */
  487.                 CM_INT32 CM_PTR,                   /* received_length        */
  488.                 CM_STATUS_RECEIVED CM_PTR,         /* status_received        */
  489.                 CM_REQUEST_TO_SEND_RECEIVED CM_PTR,/*request_to_send_received*/
  490.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  491. CM_ENTRY cmrltp(unsigned char CM_PTR,              /* TP_name                */
  492.                 CM_INT32 CM_PTR,                   /* TP_name_length         */
  493.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  494. CM_ENTRY cmrts( unsigned char CM_PTR,              /* conversation_ID        */
  495.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  496. CM_ENTRY cmscsp(unsigned char  CM_PTR,             /* conversation_ID        */
  497.                 unsigned char  CM_PTR,             /* password               */
  498.                 CM_INT32 CM_PTR,                   /* password_length        */
  499.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  500. CM_ENTRY cmscst(unsigned char  CM_PTR,             /* conversation_ID        */
  501.                 CM_INT32 CM_PTR,                   /* conv_security_type     */
  502.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  503. CM_ENTRY cmscsu(unsigned char  CM_PTR,             /* conversation_ID        */
  504.                 unsigned char  CM_PTR,             /* user_ID                */
  505.                 CM_INT32 CM_PTR,                   /* user_ID_length         */
  506.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  507. CM_ENTRY cmsct( unsigned char CM_PTR,              /* conversation_ID        */
  508.                 CM_CONVERSATION_TYPE CM_PTR,       /* conversation_type      */
  509.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  510. CM_ENTRY cmsdt( unsigned char CM_PTR,              /* conversation_ID        */
  511.                 CM_DEALLOCATE_TYPE CM_PTR,         /* deallocate_type        */
  512.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  513. CM_ENTRY cmsed( unsigned char CM_PTR,              /* conversation_ID        */
  514.                 CM_ERROR_DIRECTION CM_PTR,         /* error_direction        */
  515.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  516. CM_ENTRY cmsend(unsigned char CM_PTR,              /* conversation_ID        */
  517.                 unsigned char CM_PTR,              /* buffer                 */
  518.                 CM_INT32 CM_PTR,                   /* send_length            */
  519.                 CM_REQUEST_TO_SEND_RECEIVED CM_PTR,/*request_to_send_received*/
  520.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  521. CM_ENTRY cmserr(unsigned char CM_PTR,              /* conversation_ID        */
  522.                 CM_REQUEST_TO_SEND_RECEIVED CM_PTR,/*request_to_send_received*/
  523.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  524. CM_ENTRY cmsf(  unsigned char CM_PTR,              /* conversation_ID        */
  525.                 CM_FILL CM_PTR,                    /* fill                   */
  526.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  527. CM_ENTRY cmsld( unsigned char CM_PTR,              /* conversation_ID        */
  528.                 unsigned char CM_PTR,              /* log_data               */
  529.                 CM_INT32 CM_PTR,                   /* log_data_length        */
  530.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  531. CM_ENTRY cmsltp(unsigned char CM_PTR,              /* TP_name                */
  532.                 CM_INT32 CM_PTR,                   /* TP_name_length         */
  533.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  534. CM_ENTRY cmsmn( unsigned char CM_PTR,              /* conversation_ID        */
  535.                 unsigned char CM_PTR,              /* mode_name              */
  536.                 CM_INT32 CM_PTR,                   /* mode_name_length       */
  537.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  538. CM_ENTRY cmspln(unsigned char CM_PTR,              /* conversation_ID        */
  539.                 unsigned char CM_PTR,              /* partner_LU_name        */
  540.                 CM_INT32 CM_PTR,                   /* partner_LU_name_length */
  541.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  542. CM_ENTRY cmspm( unsigned char CM_PTR,              /* conversation_ID        */
  543.                 CM_PROCESSING_MODE CM_PTR,         /* processing_mode        */
  544.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  545. CM_ENTRY cmsptr(unsigned char CM_PTR,              /* conversation_ID        */
  546.                 CM_PREPARE_TO_RECEIVE_TYPE CM_PTR, /* prepare_to_receive_type*/
  547.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  548. CM_ENTRY cmsrc( unsigned char CM_PTR,              /* conversation_ID        */
  549.                 CM_RETURN_CONTROL CM_PTR,          /* return_control         */
  550.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  551. CM_ENTRY cmsrt( unsigned char CM_PTR,              /* conversation_ID        */
  552.                 CM_RECEIVE_TYPE CM_PTR,            /* receive_type           */
  553.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  554. CM_ENTRY cmssl( unsigned char CM_PTR,              /* conversation_ID        */
  555.                 CM_INT32 CM_PTR,                   /* sync_level             */
  556.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  557. CM_ENTRY cmsst( unsigned char CM_PTR,              /* conversation_ID        */
  558.                 CM_SEND_TYPE CM_PTR,               /* send_type              */
  559.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  560. CM_ENTRY cmstpn(unsigned char CM_PTR,              /* conversation_ID        */
  561.                 unsigned char CM_PTR,              /* TP_name                */
  562.                 CM_INT32 CM_PTR,                   /* TP_name_length         */
  563.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  564. CM_ENTRY cmtrts(unsigned char CM_PTR,              /* conversation_ID        */
  565.                 CM_REQUEST_TO_SEND_RECEIVED CM_PTR,/*request_to_send_received*/
  566.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  567. CM_ENTRY cmwait(unsigned char CM_PTR,              /* conversation_ID        */
  568.                 CM_RETURN_CODE CM_PTR,             /* conversation_ret_code  */
  569.                 CM_RETURN_CODE CM_PTR);            /* return_code            */
  570.  
  571.  
  572.  
  573.  
  574. /*
  575.  * X/Open provides security calls in the base.
  576.  * Since some SAA platforms already support the security calls through
  577.  * product specific extensions, we'll provide macros here to help in
  578.  * porting X/Open applications to these platforms.
  579.  */
  580. #if defined(CM_OS2) || defined(CM_VM) || defined(CM_DOS) || defined(CM_AIX)
  581. #define cmscsu(v1,v2,v3,v4) xcscsu(v1,v2,v3,v4)
  582. #define cmscsp(v1,v2,v3,v4) xcscsp(v1,v2,v3,v4)
  583. #define cmscst(v1,v2,v3)    xcscst(v1,v2,v3)
  584. #if !defined(CM_DOS)
  585. /*
  586.  * Networking Services/DOS does not provide extract security calls.
  587.  */
  588. #define cmecsu(v1,v2,v3,v4) xcecsu(v1,v2,v3,v4)
  589. #endif
  590. #endif
  591.  
  592.  
  593.  
  594.  
  595. #ifdef __cplusplus
  596. }
  597. #endif /* __cplusplus */
  598.  
  599. /*
  600.  *  - Product specific constants and type definitions
  601.  */
  602.  
  603. /*
  604.  *    #pragma linkage directives
  605.  *
  606.  * Note: For OS/400, routine names must be all uppercase.
  607.  */
  608. #if defined(CM_VM)
  609. #     pragma linkage (cmacci, OS)
  610. #     pragma linkage (cmaccp, OS)
  611. #     pragma linkage (cmallc, OS)
  612. #     pragma linkage (cmcanc, OS)
  613. #     pragma linkage (cmcfm,  OS)
  614. #     pragma linkage (cmcfmd, OS)
  615. #     pragma linkage (cmcnvi, OS)
  616. #     pragma linkage (cmcnvo, OS)
  617. #     pragma linkage (cmdeal, OS)
  618. #     pragma linkage (cmecs,  OS)
  619. #     pragma linkage (cmect,  OS)
  620. #     pragma linkage (cmectx, OS)
  621. #     pragma linkage (cmembs, OS)
  622. #     pragma linkage (cmemn,  OS)
  623. #     pragma linkage (cmepln, OS)
  624. #     pragma linkage (cmesl,  OS)
  625. #     pragma linkage (cmesui, OS)
  626. #     pragma linkage (cmetpn, OS)
  627. #     pragma linkage (cmflus, OS)
  628. #     pragma linkage (cminic, OS)
  629. #     pragma linkage (cminit, OS)
  630. #     pragma linkage (cmptr,  OS)
  631. #     pragma linkage (cmrcv,  OS)
  632. #     pragma linkage (cmrltp, OS)
  633. #     pragma linkage (cmrts,  OS)
  634. #     pragma linkage (cmscsp, OS)
  635. #     pragma linkage (cmscst, OS)
  636. #     pragma linkage (cmscsu, OS)
  637. #     pragma linkage (cmsct,  OS)
  638. #     pragma linkage (cmsdt,  OS)
  639. #     pragma linkage (cmsed,  OS)
  640. #     pragma linkage (cmsend, OS)
  641. #     pragma linkage (cmserr, OS)
  642. #     pragma linkage (cmsf,   OS)
  643. #     pragma linkage (cmsld,  OS)
  644. #     pragma linkage (cmsltp, OS)
  645. #     pragma linkage (cmsmn,  OS)
  646. #     pragma linkage (cmspln, OS)
  647. #     pragma linkage (cmspm , OS)
  648. #     pragma linkage (cmsptr, OS)
  649. #     pragma linkage (cmsrc,  OS)
  650. #     pragma linkage (cmsrt,  OS)
  651. #     pragma linkage (cmssl,  OS)
  652. #     pragma linkage (cmsst,  OS)
  653. #     pragma linkage (cmstpn, OS)
  654. #     pragma linkage (cmtrts, OS)
  655. #     pragma linkage (cmwait, OS)
  656. #endif
  657.  
  658. #if defined(CM_OS400) || defined(CM_MVS)
  659. #     pragma linkage (CMACCI, OS)
  660. #     pragma linkage (CMACCP, OS)
  661. #     pragma linkage (CMALLC, OS)
  662. #     pragma linkage (CMCANC, OS)
  663. #     pragma linkage (CMCFM,  OS)
  664. #     pragma linkage (CMCFMD, OS)
  665. #     pragma linkage (CMCNVI, OS)
  666. #     pragma linkage (CMCNVO, OS)
  667. #     pragma linkage (CMDEAL, OS)
  668. #     pragma linkage (CMECS,  OS)
  669. #     pragma linkage (CMECT,  OS)
  670. #     pragma linkage (CMECTX, OS)
  671. #     pragma linkage (CMEMBS, OS)
  672. #     pragma linkage (CMEMN,  OS)
  673. #     pragma linkage (CMEPLN, OS)
  674. #     pragma linkage (CMESL,  OS)
  675. #     pragma linkage (CMESUI, OS)
  676. #     pragma linkage (CMETPN, OS)
  677. #     pragma linkage (CMFLUS, OS)
  678. #     pragma linkage (CMINIC, OS)
  679. #     pragma linkage (CMINIT, OS)
  680. #     pragma linkage (CMPTR,  OS)
  681. #     pragma linkage (CMRCV,  OS)
  682. #     pragma linkage (CMRLTP, OS)
  683. #     pragma linkage (CMRTS,  OS)
  684. #     pragma linkage (CMSCSP, OS)
  685. #     pragma linkage (CMSCST, OS)
  686. #     pragma linkage (CMSCSU, OS)
  687. #     pragma linkage (CMSCT,  OS)
  688. #     pragma linkage (CMSDT,  OS)
  689. #     pragma linkage (CMSED,  OS)
  690. #     pragma linkage (CMSEND, OS)
  691. #     pragma linkage (CMSERR, OS)
  692. #     pragma linkage (CMSF,   OS)
  693. #     pragma linkage (CMSLD,  OS)
  694. #     pragma linkage (CMSLTP, OS)
  695. #     pragma linkage (CMSMN,  OS)
  696. #     pragma linkage (CMSPLN, OS)
  697. #     pragma linkage (CMSPM , OS)
  698. #     pragma linkage (CMSPTR, OS)
  699. #     pragma linkage (CMSRC,  OS)
  700. #     pragma linkage (CMSRT,  OS)
  701. #     pragma linkage (CMSSL,  OS)
  702. #     pragma linkage (CMSST,  OS)
  703. #     pragma linkage (CMSTPN, OS)
  704. #     pragma linkage (CMTRTS, OS)
  705. #     pragma linkage (CMWAIT, OS)
  706. #endif
  707.  
  708. /*
  709.  *    #pragma linkage directives - use on OS/2 32 bit only
  710.  */
  711. #if defined(ES32TO16)
  712. #     pragma linkage (cmacci, far16 pascal)
  713. #     pragma linkage (cmaccp, far16 pascal)
  714. #     pragma linkage (cmallc, far16 pascal)
  715. #     pragma linkage (cmcanc, far16 pascal)
  716. #     pragma linkage (cmcfm,  far16 pascal)
  717. #     pragma linkage (cmcfmd, far16 pascal)
  718. #     pragma linkage (cmcnvi, far16 pascal)
  719. #     pragma linkage (cmcnvo, far16 pascal)
  720. #     pragma linkage (cmdeal, far16 pascal)
  721. #     pragma linkage (cmecs,  far16 pascal)
  722. #     pragma linkage (cmect,  far16 pascal)
  723. #     pragma linkage (cmectx, far16 pascal)
  724. #     pragma linkage (cmembs, far16 pascal)
  725. #     pragma linkage (cmemn,  far16 pascal)
  726. #     pragma linkage (cmepln, far16 pascal)
  727. #     pragma linkage (cmesl,  far16 pascal)
  728. #     pragma linkage (cmesui, far16 pascal)
  729. #     pragma linkage (cmetpn, far16 pascal)
  730. #     pragma linkage (cmflus, far16 pascal)
  731. #     pragma linkage (cminic, far16 pascal)
  732. #     pragma linkage (cminit, far16 pascal)
  733. #     pragma linkage (cmptr,  far16 pascal)
  734. #     pragma linkage (cmrcv,  far16 pascal)
  735. #     pragma linkage (cmrltp, far16 pascal)
  736. #     pragma linkage (cmrts,  far16 pascal)
  737. #     pragma linkage (cmscsp, far16 pascal)
  738. #     pragma linkage (cmscst, far16 pascal)
  739. #     pragma linkage (cmscsu, far16 pascal)
  740. #     pragma linkage (cmsct,  far16 pascal)
  741. #     pragma linkage (cmsdt,  far16 pascal)
  742. #     pragma linkage (cmsed,  far16 pascal)
  743. #     pragma linkage (cmsend, far16 pascal)
  744. #     pragma linkage (cmserr, far16 pascal)
  745. #     pragma linkage (cmsf,   far16 pascal)
  746. #     pragma linkage (cmsld,  far16 pascal)
  747. #     pragma linkage (cmsltp, far16 pascal)
  748. #     pragma linkage (cmsmn,  far16 pascal)
  749. #     pragma linkage (cmspln, far16 pascal)
  750. #     pragma linkage (cmspm , far16 pascal)
  751. #     pragma linkage (cmsptr, far16 pascal)
  752. #     pragma linkage (cmsrc,  far16 pascal)
  753. #     pragma linkage (cmsrt,  far16 pascal)
  754. #     pragma linkage (cmssl,  far16 pascal)
  755. #     pragma linkage (cmsst,  far16 pascal)
  756. #     pragma linkage (cmstpn, far16 pascal)
  757. #     pragma linkage (cmtrts, far16 pascal)
  758. #     pragma linkage (cmwait, far16 pascal)
  759. #     pragma linkage (xcecst, far16 pascal)
  760. #     pragma linkage (xcecsu, far16 pascal)
  761. #     pragma linkage (xcmdsi, far16 pascal)
  762. #     pragma linkage (xcmesi, far16 pascal)
  763. #     pragma linkage (xcmssi, far16 pascal)
  764. #     pragma linkage (xcscsp, far16 pascal)
  765. #     pragma linkage (xcscst, far16 pascal)
  766. #     pragma linkage (xcscsu, far16 pascal)
  767. #endif
  768.  
  769.  
  770.  
  771. #if defined(CM_OS2) || defined(CM_DOS) || defined(CM_AIX)
  772.  
  773. /*
  774.  * Conversation security extensions
  775.  */
  776.  
  777. typedef CM_INT32 XC_CONVERSATION_SECURITY_TYPE;
  778.  
  779. /* conversation_security_type values */
  780.  
  781. #define XC_SECURITY_NONE                 (XC_CONVERSATION_SECURITY_TYPE) 0
  782. #define XC_SECURITY_SAME                 (XC_CONVERSATION_SECURITY_TYPE) 1
  783. #define XC_SECURITY_PROGRAM              (XC_CONVERSATION_SECURITY_TYPE) 2
  784.  
  785. #ifdef __cplusplus
  786. extern "C" {
  787. #endif /* __cplusplus */
  788.  
  789. #if !defined(CM_DOS) /* extract calls are not supported in DOS */
  790.  
  791.  
  792. /* Extract_Conversation_Security_Type */
  793. CM_ENTRY xcecst(unsigned char  CM_PTR,   /* conversation_ID                 */
  794.                 CM_INT32 CM_PTR,         /* conversation_security_type      */
  795.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  796.  
  797. /* Extract_Conversation_Security_User_ID */
  798. CM_ENTRY xcecsu(unsigned char  CM_PTR,   /* conversation_ID                 */
  799.                 unsigned char  CM_PTR,   /* user_ID                         */
  800.                 CM_INT32 CM_PTR,         /* user_ID_length                  */
  801.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  802. #endif
  803.  
  804. /* Set_Conversation_Security_Password */
  805. CM_ENTRY xcscsp(unsigned char  CM_PTR,   /* conversation_ID                 */
  806.                 unsigned char  CM_PTR,   /* password                        */
  807.                 CM_INT32 CM_PTR,         /* password_length                 */
  808.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  809.  
  810. /* Set_Conversation_Security_Type */
  811. CM_ENTRY xcscst(unsigned char  CM_PTR,   /* conversation_ID                 */
  812.                 CM_INT32 CM_PTR,         /* conversation_security_type      */
  813.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  814.  
  815. /* Set_Conversation_Security_User_ID */
  816. CM_ENTRY xcscsu(unsigned char  CM_PTR,   /* conversation_ID                 */
  817.                 unsigned char  CM_PTR,   /* user_ID                         */
  818.                 CM_INT32 CM_PTR,         /* user_ID_length                  */
  819.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  820.  
  821. #ifdef __cplusplus
  822. }
  823. #endif /* __cplusplus */
  824.  
  825. #endif
  826.  
  827.  
  828. #if defined(CM_OS2)
  829. /*
  830.  * Constants and prototypes for OS/2 side information calls
  831.  */
  832.  
  833. typedef CM_INT32 XC_TP_NAME_TYPE;
  834. /* TP_name_type values */
  835. #define XC_APPLICATION_TP        (XC_TP_NAME_TYPE) 0
  836. #define XC_SNA_SERVICE_TP        (XC_TP_NAME_TYPE) 1
  837.  
  838. /* side info structure used by xcmssi to define side info */
  839. typedef struct side_info_entry {
  840.     unsigned char    sym_dest_name[8];    /* symbolic destination name    */
  841.     unsigned char    partner_LU_name[17];
  842.     unsigned char    reserved[3];         /* currently not used           */
  843.     XC_TP_NAME_TYPE  TP_name_type;        /* set to XC_APPLICATION_TP     */
  844.                                           /*     or XC_SNA_SERVICE_TP     */
  845.     unsigned char    TP_name[64];
  846.     unsigned char    mode_name[8];
  847.     XC_CONVERSATION_SECURITY_TYPE
  848.                      conversation_security_type;
  849.                                           /* set to XC_SECURITY_NONE      */
  850.                                           /*   or   XC_SECURITY_SAME      */
  851.                                           /*   or   XC_SECURITY_PROGRAM   */
  852.     unsigned char    security_user_ID[8];
  853.     unsigned char    security_password[8];
  854. } SIDE_INFO;
  855.  
  856. #ifdef __cplusplus
  857. extern "C" {
  858. #endif /* __cplusplus */
  859.  
  860. /* Set_CPIC_Side_Information */
  861. CM_ENTRY xcmssi(unsigned char CM_PTR,  /* key lock                          */
  862.                 SIDE_INFO CM_PTR,      /* side info_entry (see struct above)*/
  863.                 CM_INT32 CM_PTR,       /* side_info length                  */
  864.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  865.  
  866. /* Extract_CPIC_Side_Information */
  867. CM_ENTRY xcmesi(CM_INT32 CM_PTR,       /* entry_number                      */
  868.                 unsigned char CM_PTR,  /* symbolic destination name 8 chars */
  869.                 SIDE_INFO CM_PTR,      /* side_info_entry (see struct above)*/
  870.                 CM_INT32 CM_PTR,       /* side_info_length                  */
  871.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  872.  
  873. /* Delete_CPIC_Side_Information */
  874. CM_ENTRY xcmdsi(unsigned char CM_PTR,  /* key_lock                          */
  875.                 unsigned char CM_PTR,  /* symbolic destination name 8 chars */
  876.                 CM_RETURN_CODE CM_PTR);  /* return_code                     */
  877. #ifdef __cplusplus
  878. }
  879. #endif /* __cplusplus */
  880. #endif
  881.  
  882. #ifdef CM_VM
  883.  
  884. /*
  885.  * XC_INT32 should be a 32-bit, signed integer.  The following #define is
  886.  * system dependent and may need to be changed on systems where signed long
  887.  * int does not define a 32-bit, signed integer.
  888.  */
  889.  
  890. #define XC_INT32 signed long int
  891. #define XC_ENTRY extern void
  892. #define XC_PTR *
  893.  
  894.  
  895. typedef XC_INT32 CMINT;
  896. typedef CMINT *PCMINT;
  897. typedef unsigned char CMCHAR;
  898. typedef CMCHAR *PCMCHAR;
  899.  
  900.  
  901. typedef XC_INT32 XC_RESOURCE_MANAGER_TYPE;
  902. /*  resource_manager_type values  */
  903. #define XC_PRIVATE                    (XC_RESOURCE_MANAGER_TYPE) 0
  904. #define XC_LOCAL                      (XC_RESOURCE_MANAGER_TYPE) 1
  905. #define XC_GLOBAL                     (XC_RESOURCE_MANAGER_TYPE) 2
  906. #define XC_SYSTEM                     (XC_RESOURCE_MANAGER_TYPE) 3
  907.  
  908. typedef XC_INT32 XC_SERVICE_MODE;
  909. /*  service_mode values  */
  910. #define XC_SINGLE                     (XC_SERVICE_MODE) 0
  911. #define XC_SEQUENTIAL                 (XC_SERVICE_MODE) 1
  912. #define XC_MULTIPLE                   (XC_SERVICE_MODE) 2
  913.  
  914. typedef XC_INT32 XC_SECURITY_LEVEL_FLAG;
  915. /*  security_level_flag values  */
  916. #define XC_REJECT_SECURITY_NONE       (XC_SECURITY_LEVEL_FLAG) 0
  917. #define XC_ACCEPT_SECURITY_NONE       (XC_SECURITY_LEVEL_FLAG) 1
  918.  
  919. typedef XC_INT32 XC_CONVERSATION_SECURITY_TYPE;
  920. /*  conversation_security_type values  */
  921. #define XC_SECURITY_NONE              (XC_CONVERSATION_SECURITY_TYPE) 0
  922. #define XC_SECURITY_SAME              (XC_CONVERSATION_SECURITY_TYPE) 1
  923. #define XC_SECURITY_PROGRAM           (XC_CONVERSATION_SECURITY_TYPE) 2
  924.  
  925. typedef XC_INT32 XC_EVENT_TYPE;
  926. /*  event_type values  */
  927. #define XC_ALLOCATION_REQUEST         (XC_EVENT_TYPE) 1
  928. #define XC_INFORMATION_INPUT          (XC_EVENT_TYPE) 2
  929. #define XC_RESOURCE_REVOKED           (XC_EVENT_TYPE) 3
  930. #define XC_CONSOLE_INPUT              (XC_EVENT_TYPE) 4
  931. #define XC_REQUEST_ID                 (XC_EVENT_TYPE) 5
  932. #define XC_USER_EVENT                 (XC_EVENT_TYPE) 6
  933.  
  934. CM_ENTRY xcecl( unsigned char CM_PTR,   /* conversation_ID          */
  935.                 unsigned char CM_PTR,   /* luwid                    */
  936.                 CM_INT32 CM_PTR,        /* luwid_length             */
  937.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  938. CM_ENTRY xcecsu(unsigned char CM_PTR,   /* conversation_ID          */
  939.                 unsigned char CM_PTR,   /* security_user_ID         */
  940.                 CM_INT32 CM_PTR,        /* security_user_ID_length  */
  941.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  942. CM_ENTRY xcecwu(unsigned char CM_PTR,   /* conversation_ID          */
  943.                 CM_INT32 CM_PTR,        /* workunitid               */
  944.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  945. CM_ENTRY xcelfq(unsigned char CM_PTR,   /* conversation_ID          */
  946.                 unsigned char CM_PTR,   /* local_fq_LU_name         */
  947.                 CM_INT32 CM_PTR,        /* local_fq_LU_name_length  */
  948.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  949. CM_ENTRY xcerfq(unsigned char CM_PTR,   /* conversation_ID          */
  950.                 unsigned char CM_PTR,   /* remote_fq_LU_name        */
  951.                 CM_INT32 CM_PTR,        /* remote_fq_LU_name_length */
  952.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  953. CM_ENTRY xcetpn(unsigned char CM_PTR,   /* conversation_ID          */
  954.                 unsigned char CM_PTR,   /* TP_name                  */
  955.                 CM_INT32 CM_PTR,        /* TP_name_length           */
  956.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  957. CM_ENTRY xcidrm(unsigned char CM_PTR,   /* resource_ID              */
  958.                 CM_INT32 CM_PTR,        /* resource_manager_type    */
  959.                 CM_INT32 CM_PTR,        /* service_mode             */
  960.                 CM_INT32 CM_PTR,        /* security_level_flag      */
  961.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  962. CM_ENTRY xcscsp(unsigned char CM_PTR,   /* conversation_ID          */
  963.                 unsigned char CM_PTR,   /* security_password        */
  964.                 CM_INT32 CM_PTR,        /* security_password_length */
  965.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  966. CM_ENTRY xcscst(unsigned char CM_PTR,   /* conversation_ID          */
  967.                 CM_INT32 CM_PTR,        /* conv_security_type       */
  968.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  969. CM_ENTRY xcscsu(unsigned char CM_PTR,   /* conversation_ID          */
  970.                 unsigned char CM_PTR,   /* security_user_ID         */
  971.                 CM_INT32 CM_PTR,        /* security_user_ID_length  */
  972.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  973. CM_ENTRY xcscui(unsigned char CM_PTR,   /* conversation_ID          */
  974.                 unsigned char CM_PTR,   /* client_user_ID           */
  975.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  976. CM_ENTRY xcsue( unsigned char CM_PTR,   /* event_ID                 */
  977.                 unsigned char CM_PTR,   /* user_data                */
  978.                 CM_INT32 CM_PTR,        /* user_data_length         */
  979.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  980. CM_ENTRY xctrrm(unsigned char CM_PTR,   /* resource_ID              */
  981.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  982. CM_ENTRY xcwoe( unsigned char CM_PTR,   /* resource_ID              */
  983.                 unsigned char CM_PTR,   /* conversation_ID          */
  984.                 CM_INT32 CM_PTR,        /* event_type               */
  985.                 CM_INT32 CM_PTR,        /* info_input_length        */
  986.                 unsigned char CM_PTR,   /* console_input_buffer     */
  987.                 CM_RETURN_CODE CM_PTR); /* return_code              */
  988.  
  989. #     pragma linkage (xcecl,  OS)
  990. #     pragma linkage (xcecsu, OS)
  991. #     pragma linkage (xcecwu, OS)
  992. #     pragma linkage (xcelfq, OS)
  993. #     pragma linkage (xcerfq, OS)
  994. #     pragma linkage (xcetpn, OS)
  995. #     pragma linkage (xcidrm, OS)
  996. #     pragma linkage (xcscsp, OS)
  997. #     pragma linkage (xcscst, OS)
  998. #     pragma linkage (xcscsu, OS)
  999. #     pragma linkage (xcscui, OS)
  1000. #     pragma linkage (xcsue,  OS)
  1001. #     pragma linkage (xctrrm, OS)
  1002. #     pragma linkage (xcwoe,  OS)
  1003.  
  1004. #endif
  1005.  
  1006.  
  1007. /*
  1008.  * These macros allow you to write programs that are easier to read, since
  1009.  * you can use the full name of the CPI-C call rather than its 6 character
  1010.  * entry point.
  1011.  *
  1012.  * When porting code that uses these macros, you will have to ensure that
  1013.  * the macros are defined on the target platform.
  1014.  */
  1015.  
  1016. #ifdef READABLE_MACROS
  1017. #define Accept_Conversation(v1,v2)            cmaccp(v1,v2)
  1018. #define Accept_Incoming(v1, v2)               cmacci(v1,v2)
  1019. #define Allocate(v1,v2)                       cmallc(v1,v2)
  1020. #define Cancel_Conversation(v1,v2)            cmcanc(v1,v2)
  1021. #define Confirm(v1,v2,v3)                     cmcfm(v1,v2,v3)
  1022. #define Confirmed(v1,v2)                      cmcfmd(v1,v2)
  1023. #define Convert_Incoming(v1,v2,v3)            cmcnvi(v1,v2,v3)
  1024. #define Convert_Outgoing(v1,v2,v3)            cmcnvo(v1,v2,v3)
  1025. #define Deallocate(v1,v2)                     cmdeal(v1,v2)
  1026. #define Extract_Conversation_Context(v1,v2,v3,v4) cmectx(v1,v2,v3,v4)
  1027. #define Extract_Maximum_Buffer_Size(v1,v2)    cmembs(v1,v2)
  1028. #define Extract_Mode_Name(v1,v2,v3,v4)        cmemn(v1,v2,v3,v4)
  1029. #define Extract_Partner_LU_Name(v1,v2,v3,v4)  cmepln(v1,v2,v3,v4)
  1030. #define Extract_Security_User_ID(v1,v2,v3,v4) cmesui(v1,v2,v3,v4)
  1031. #define Extract_Sync_Level(v1,v2,v3)          cmesl(v1,v2,v3)
  1032. #define Extract_TP_Name(v1,v2,v3,v4)          cmetpn(v1,v2,v3,v4)
  1033. #define Flush(v1,v2)                          cmflus(v1,v2)
  1034. #define Initialize_Conversation(v1,v2,v3)     cminit(v1,v2,v3)
  1035. #define Initialize_For_Incoming(v1,v2)        cminic(v1,v2)
  1036. #define Prepare_To_Receive(v1,v2)             cmptr(v1,v2)
  1037. #define Receive(v1,v2,v3,v4,v5,v6,v7,v8)      cmrcv(v1,v2,v3,v4,v5,v6,v7,v8)
  1038. #define Release_Local_TP_Name(v1,v2,v3)       cmrltp(v1,v2,v3)
  1039. #define Request_To_Send(v1,v2)                cmrts(v1,v2)
  1040. #define Send_Data(v1,v2,v3,v4,v5)             cmsend(v1,v2,v3,v4,v5)
  1041. #define Send_Error(v1,v2,v3)                  cmserr(v1,v2,v3)
  1042. #define Set_Conversation_Security_Password(v1,v2,v3,v4) cmscsp(v1,v2,v3,v4)
  1043. #define Set_Conversation_Security_Type(v1,v2,v3) cmscst(v1,v2,v3)
  1044. #define Set_Conversation_Security_User_ID(v1,v2,v3,v4) cmscsu(v1,v2,v3,v4)
  1045. #define Set_Conversation_Type(v1,v2,v3)       cmsct(v1,v2,v3)
  1046. #define Set_Deallocate_Type(v1,v2,v3)         cmsdt(v1,v2,v3)
  1047. #define Set_Error_Direction(v1,v2,v3)         cmsed(v1,v2,v3)
  1048. #define Set_Fill(v1,v2,v3)                    cmsf(v1,v2,v3)
  1049. #define Set_Log_Data(v1,v2,v3,v4)             cmsld(v1,v2,v3,v4)
  1050. #define Set_Mode_Name(v1,v2,v3,v4)            cmsmn(v1,v2,v3,v4)
  1051. #define Set_Partner_LU_Name(v1,v2,v3,v4)      cmspln(v1,v2,v3,v4)
  1052. #define Set_Prepare_To_Receive_Type(v1,v2,v3) cmsptr(v1,v2,v3)
  1053. #define Set_Processing_Mode(v1,v2,v3)         cmspm(v1,v2,v3)
  1054. #define Set_Processing_Mode(v1,v2,v3)         cmspm(v1,v2,v3)
  1055. #define Set_Receive_Type(v1,v2,v3)            cmsrt(v1,v2,v3)
  1056. #define Set_Return_Control(v1,v2,v3)          cmsrc(v1,v2,v3)
  1057. #define Set_Send_Type(v1,v2,v3)               cmsst(v1,v2,v3)
  1058. #define Set_Sync_Level(v1,v2,v3)              cmssl(v1,v2,v3)
  1059. #define Set_TP_Name(v1,v2,v3,v4)              cmstpn(v1,v2,v3,v4)
  1060. #define Specify_Local_TP_Name(v1,v2,v3)       cmsltp(v1,v2,v3)
  1061. #define Test_Request_To_Send_Received(v1,v2,v3) cmtrts(v1,v2,v3)
  1062. #define Wait_For_Conversation(v1,v2,v3)       cmwait(v1,v2,v3)
  1063.  
  1064. #endif
  1065.  
  1066.  
  1067. #endif
  1068.