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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
xdrwtx.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：64k
源码类别：

VxWorks

开发平台：

C/C++

xdrwtx.c：源码内容
  1. /* xdrwtx.c  - xdr routines for Wind River Tool eXchange protocol */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03b,03apr02,c_c  Changed xdr_wrapstring to xdr_string to workaround a xdr
  10.                  limitation on the target (SPR #74773).
  11. 03a,15jun01,pch  Add new WTX_TS_INFO_GET_V2 service to handle WTX_RT_INFO
  12.                  change (from BOOL32 hasFpp to UINT32 hasCoprocessor) without
  13.                  breaking existing clients.
  14. 02z,10may01,dtr  Changing coprocessor flags into one word.
  15. 02y,06feb01,dtr  Adding probe for Altivec registers.
  16. 02x,18aug98,pcn  Re-use WTX_MSG_EVTPT_LIST_2.
  17. 02w,20jul98,pcn  Added evtptNum and toolId in the wtxEventpointListGet return
  18.                  list.
  19. 02v,19jun98,pcn  Changed xdr_WTX_MSG_FILE_LOAD_DESC to accept new fields.
  20. 02u,26may98,pcn  Changed WTX_MSG_EVTPT_LIST_2 in WTX_MSG_EVTPT_LIST_GET.
  21. 02t,26mar98,pcn  Updated history.
  22. 02s,23mar98,pcn  WTX 2: added test in xdr_WTX_MSG_FILE_LOAD_DESC to take care 
  23.  of different behaviors of wtxObjModuleLoad_2.
  24. 02r,02mar98,pcn  WTX 2: added xdr_MEM_WIDTH_COPY_ALLOC,
  25.                  xdr_WTX_MSG_MEM_WIDTH_READ_DESC,
  26.                  xdr_WTX_MSG_MEM_WIDTH_COPY_DESC, xdr_WTX_EVENT_NODE,
  27.                  xdr_MSG_EVENT_LIST, xdr_WTX_MSG_FILE_LOAD_DESC,
  28.                  xdr_WTX_LD_M_FILE_DESC, xdr_WTX_EVENT_2, xdr_WTX_EVTPT_2,
  29.                  xdr_WTX_MSG_EVTPT_DESC_2, xdr_WTX_MSG_EVTPT_LIST_2. Changed
  30.                  xdr_WTX_MSG_EVTPT_LIST, xdr_WTX_EVENT_DESC.
  31. 02q,13feb98,c_c  Fixed a memory leak in xdr_WTX_MSG_CONTEXT_DESC
  32. 02p,29aug97,fle  Adding the WTX_MEM_DISASSEMBLE service
  33. 02o,30sep96,elp  put in share, adapted to be compiled on target side
  34.  (SPR# 6775).
  35. 02n,28jun96,c_s  subvert prototypes in AIX's <rpc/xdr.h> to temporarily
  36.                  work around problems with XDR arguments that change
  37.                  signedness.
  38. 02m,17jun96,p_m  changed flags type in xdr_WTX_MSG_OPEN_DESC() (SPR# 4941).
  39. 02l,10jun96,elp  re-installed 02j (fix SPR# 6502 without protocol change).
  40. 02k,20may96,elp  updated xdr_WTX_MSG_SYM_TBL_INFO to new WTX_MSG_SYM_TBL_INFO
  41.  type (SPR# 6205).
  42. 02j,31aug95,p_m  added free() in xdr_WTX_MSG_VIO_COPY_DESC() (SPR# 4804).
  43. 02i,06jun95,p_m  took care of WTX_MSG_SYM_MATCH_DESC changes in
  44.  xdr_WTX_MSG_SYM_MATCH_DESC().
  45. 02h,01jun95,p_m  removed WTX_MSG_CALL_PARAM and modified WTX_MSG_CONTEXT_DESC.
  46. 02g,30may95,p_m  completed WTX_MEM_SCAN and WTX_MEM_MOVE implementation.
  47. 02f,26may95,p_m  added match field in WTX_MSG_MEM_SCAN_DESC.
  48. 02e,23may95,p_m  made missing name changes.
  49. 02d,22may95,jcf  name revision.
  50. 02c,19may95,p_m  got rid of DETECTION related stuff.
  51. 02b,16may95,p_m  added xdr_WTX_MSG_KILL_DESC.
  52. 02a,14may95,c_s  fixed memory leak in xdr_WTX_MEM_XFER; fixed free-memory 
  53.                    fault in xdr_WTX_SYM_LIST.
  54. 01z,10may95,pad  modified xdr_WTX_MSG_SYM_LIST and xdr_WTX_MSG_SYM_MATCH_DESC.
  55. 01y,09may95,p_m  re-implemented wtxregd related XDR procedures. Added Target 
  56.  Server version in WTX_MSG_TS_INFO.
  57. 01x,05may95,p_m  added protVersion in xdr_WTX_CORE.
  58. 01w,02may95,pad  xdr_WTX_MSG_MODULE_INFO now handles format field as char *
  59. 01v,30mar95,p_m  changed xdr_CONTEXT_ID_T() to xdr_WTX_CONTEXT_ID_T().
  60. 01u,20mar95,c_s  updated GOPHER structure filters.
  61. 01t,16mar95,p_m  added xdr_WTX_MSG_VIO_FILE_LIST().
  62. 01s,10mar95,p_m  changed endian field to u_long.
  63. 01r,03mar95,p_m  merged with wtxxdr.c.
  64.  added gopher routines.
  65. 01q,27feb95,p_m  cleanup up xdr_WTX_MSG_MEM_SCAN_DESC.
  66.  added symTblId to xdr_WTX_MSG_SYM_TBL_INFO.
  67.  simplified WTX_WDB_SERVICE_DESC.
  68. 01p,25feb95,jcf  extended xdr_WTX_TS_INFO.
  69. 01o,21feb95,pad  added xdr_WTX_WTX_SERVICE_DESC() and modified
  70.  xdr_WTX_MSG_SERVICE_DESC().
  71. 01n,08feb95,p_m  added loadFlag in WTX_MODULE_INFO.
  72.  changed to xdr_WTX_MSG... for more coherency.
  73.  added many filters now that WTX and WDB are separated.
  74. 01m,30jan95,p_m  added additional routines objects and name to 
  75.  xdr_SERVICE_DESC().
  76.  added xdr_WTX_MEM_XFER(), xdr_WTX_REG_WRITE()
  77.  and  xdr_WTX_MEM_SET_DESC().
  78. 01l,23jan95,p_m  updated xdr_TOOL_DESC and xdr_WTX_TS_INFO.
  79.  replaced #include "wdb/xdrwdb.h" with #include "xdrwdb.h".
  80.  replace rtnName by initRtnName in xdr_SERVICE_DESC().
  81. 01k,21jan95,jcf  updated include files.
  82. 01j,13dec94,p_m  updated to use files generated from wtx.x.
  83.  added xdr_WTX_MEM_INFO().
  84.  added WTX_SYM_LIST to LD_M_FILE to return undefined symbols.
  85.  changed xdr_WTX_WRAP_STRING() to xdr_WRAPSTRING().
  86.  added addlDataLen and addData fields to WTX_EVENT.
  87. 01i,17nov94,p_m  added symFlag to xdr_LD_M_FILE(). changed all routine 
  88.  pointers to routine names in SERVICE_DESC.
  89. 01h,14nov94,p_m  renamed VIO_OPEN_DESC to OPEN_DESC and added channel to 
  90.  OPEN_DESC.
  91. 01g,11nov94,p_m  removed xdr_WTX_GOPHER_TAPE.
  92. 01f,28oct94,p_m  added returnType field in WTX_CALL_PARAMS.
  93.  added pEvtpt field management in EVTPT_LIST.
  94.  added xdr_SYM_TAB_INFO() and xdr_SYM_TAB_LIST().
  95.  changed xdr_SYM_TAB_PARAM() to xdr_SYM_TBL_PARAM().
  96.  added xdr object file names in xdr_SERVICE_DESC.
  97.  added display in xdr_CONSOLE_DESC.
  98. 01e,27oct94,p_m  added exactName field in WTX_SYMBOL.
  99. 01d,24oct94,p_m  added xdr_WTX_WRAP_STRING() and xdr_SYM_MATCH_DESC. 
  100.    changed xdr_WTX_CALL_PARAMS().
  101.  added moduleId handling in xdr_LD_M_FILE().
  102.  added xdr_WTX_SYM_LIST().
  103. 01c,20oct94,p_m  added xdr_MEM_COPY_ALLOC() and xdr_WTX_SYMBOL(). Added 
  104.  moduleId handling in xdr_WTX_MODULE_INFO. Added null
  105.  pointer handling in xdr_MOD_NAME_OR_ID.
  106. 01b,19oct94,p_m  added xdr_pointers in xdr_WTX_TS_INFO.
  107. 01a,04oct94,p_m  written.
  108. */
  110. /*
  111. DESCRIPTION
  112. This module contains the eXternal Data Representation (XDR) routines
  113. for the WTX protocol.
  114. */
  116. #if defined (RS6000_AIX4)
  117. /* AIX is extremely picky about the signedness of arguments passed to 
  118.    stock xdr rouintes.  This hack ends that debate. */
  119. #define _NO_PROTO
  120. #endif /* !RS6000_AIX4 */
  121. #include <stdlib.h>
  123. #include "rpc/rpc.h"
  124. #include "wtx.h"
  125. #include "wtxmsg.h"
  126. #include "wtxxdr.h"
  128. #define LASTUNSIGNED      ((u_int) 0-1) /* taken from SUN xdr.c file */
  130. /*******************************************************************************
  131. *
  132. * xdr_WRAPSTRING - possibly NULL string pointer
  133. *
  134. */
  136. bool_t xdr_WRAPSTRING 
  137.     (
  138.     XDR * xdrs,
  139.     char ** string
  140.     )
  141.     {
  142.     BOOL moreData;
  144.     moreData = (*string != NULL); /* string is a NULL pointer ?*/
  145.     if (!xdr_bool(xdrs, &moreData)) /* code/decode test result */
  146. return (FALSE);
  147.     if (!moreData)
  148. *string = NULL; /* YES: string is NULL */
  149.     else  /* NO: code/decode the string */
  150. {
  151. if (xdrs->x_op == XDR_DECODE)
  152.     *string = NULL;
  153.      if (!xdr_string (xdrs, string, LASTUNSIGNED))
  154.     return (FALSE);
  155. }
  156.     return (TRUE);
  157.     }
  159. #ifdef HOST
  160. /*******************************************************************************
  161. *
  162. * xdr_TGT_ADDR_T - WTX
  163. *
  164. */
  166. bool_t xdr_TGT_ADDR_T 
  167.     (
  168.     XDR *           xdrs,
  169.     TGT_ADDR_T * objp
  170.     )
  171.     {
  172.     if (!xdr_u_long (xdrs, objp))
  173. return (FALSE);
  175.     return (TRUE);
  176.     }
  177. #endif
  179. /*******************************************************************************
  180. *
  181. * xdr_TGT_ARG_T - WTX
  182. *
  183. */
  185. bool_t xdr_TGT_ARG_T 
  186.     (
  187.     XDR *       xdrs,
  188.     TGT_ARG_T * objp
  189.     )
  190.     {
  191.     if (!xdr_u_long (xdrs, objp))
  192. return (FALSE);
  194.     return (TRUE);
  195.     }
  197. /*******************************************************************************
  198. *
  199. * xdr_WTX_CONTEXT_ID_T - WTX
  200. *
  201. */
  203. bool_t xdr_WTX_CONTEXT_ID_T 
  204.     (
  205.     XDR *         xdrs,
  206.     WTX_CONTEXT_ID_T * objp
  207.     )
  208.     {
  209.     if (!xdr_u_long (xdrs, (u_long *)objp))
  210. return (FALSE);
  212.     return (TRUE);
  213.     }
  215. /*******************************************************************************
  216. *
  217. * xdr_WTX_VALUE - WTX
  218. *
  219. */
  221. bool_t xdr_WTX_VALUE
  222.     (
  223.     XDR *xdrs,
  224.     WTX_VALUE *objp
  225.     )
  226.     {
  227. if (!xdr_enum(xdrs, (enum_t *)&objp->valueType)) {
  228. return (FALSE);
  229. }
  230. switch (objp->valueType) {
  231. case 0:
  232. if (!xdr_char(xdrs, &objp->value_u.v_int8)) {
  233. return (FALSE);
  234. }
  235. break;
  236. case 1:
  237. if (!xdr_short(xdrs, &objp->value_u.v_int16)) {
  238. return (FALSE);
  239. }
  240. break;
  241. case 2:
  242. if (!xdr_long(xdrs, (long *)&objp->value_u.v_int32)) {
  243. return (FALSE);
  244. }
  245. break;
  246. case 3:
  247. if (!xdr_u_char(xdrs, &objp->value_u.v_uint8)) {
  248. return (FALSE);
  249. }
  250. break;
  251. case 4:
  252. if (!xdr_u_short(xdrs, &objp->value_u.v_uint16)) {
  253. return (FALSE);
  254. }
  255. break;
  256. case 5:
  257. if (!xdr_u_long(xdrs, (u_long *)&objp->value_u.v_uint32)) {
  258. return (FALSE);
  259. }
  260. break;
  261. case 6:
  262. if (!xdr_double(xdrs, &objp->value_u.v_double)) {
  263. return (FALSE);
  264. }
  265. break;
  266. case 7:
  267. if (!xdr_long(xdrs, (long *)&objp->value_u.v_bool32)) {
  268. return (FALSE);
  269. }
  270. break;
  271. case 8:
  272. if (!xdr_WRAPSTRING(xdrs, &objp->value_u.v_pchar)) {
  273. return (FALSE);
  274. }
  275. break;
  277. /* XXX p_m treat void * as a long for now */
  279. case 9:
  280. if (!xdr_long(xdrs, (long *)&objp->value_u.v_pvoid)) {
  281. return (FALSE);
  282. }
  283. break;
  284. case 10:
  285. if (!xdr_TGT_ADDR_T(xdrs, &objp->value_u.v_tgt_addr)) {
  286. return (FALSE);
  287. }
  288. break;
  289. case 11:
  290. if (!xdr_TGT_ARG_T(xdrs, &objp->value_u.v_tgt_arg)) {
  291. return (FALSE);
  292. }
  293. break;
  294. }
  295. return (TRUE);
  296.     }
  298. /*******************************************************************************
  299. *
  300. * xdr_WTX_MSG_RESULT - WTX
  301. *
  302. */
  304. bool_t xdr_WTX_MSG_RESULT 
  305.     (
  306.     XDR *           xdrs,
  307.     WTX_MSG_RESULT * objp
  308.     )
  309.     {
  310.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  311. return (FALSE);
  312.     if (!xdr_WTX_VALUE (xdrs, &objp->val))
  313. return (FALSE);
  315.     return (TRUE);
  316.     }
  318. /*******************************************************************************
  319. *
  320. * xdr_WTX_MSG_PARAM - WTX
  321. *
  322. */
  324. bool_t xdr_WTX_MSG_PARAM 
  325.     (
  326.     XDR *           xdrs,
  327.     WTX_MSG_PARAM * objp
  328.     )
  329.     {
  330.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  331. return (FALSE);
  332.     if (!xdr_WTX_VALUE (xdrs, &objp->param))
  333. return (FALSE);
  335.     return (TRUE);
  336.     }
  338. /*******************************************************************************
  339. *
  340. * xdr_WTX_MEM_REGION - WTX
  341. *
  342. */
  344. bool_t xdr_WTX_MEM_REGION 
  345.     (
  346.     XDR *           xdrs,
  347.     WTX_MEM_REGION * objp
  348.     )
  349.     {
  350.     if (!xdr_TGT_ADDR_T (xdrs, &objp->baseAddr))
  351. return (FALSE);
  352.     if (!xdr_u_long (xdrs, (u_long *)&objp->size))
  353. return (FALSE);
  354.     if (!xdr_u_long (xdrs, (u_long *)&objp->attribute))
  355. return (FALSE);
  357.     return (TRUE);
  358.     }
  360. /*******************************************************************************
  361. *
  362. * xdr_WTX_TGT_LINK_DESC - target link descriptor
  363. *
  364. */
  366. bool_t xdr_WTX_TGT_LINK_DESC 
  367.     (
  368.     XDR *     xdrs,
  369.     WTX_TGT_LINK_DESC * objp
  370.     )
  371.     {
  372.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  373. return (FALSE);
  374.     if (!xdr_u_long (xdrs, (u_long *)&objp->type))
  375. return (FALSE);
  376.     if (!xdr_u_long (xdrs, (u_long *)&objp->speed))
  377. return (FALSE);
  379.     return (TRUE);
  380.     }
  382. /*******************************************************************************
  383. *
  384. * xdr_WTX_RT_INFO - 
  385. *
  386. */
  388. LOCAL bool_t xdr_WTX_RT_INFO
  389.     (
  390.     XDR * xdrs,
  391.     WTX_RT_INFO * objp,
  392.     int msgVersion
  393.     )
  394.     {
  395. if (!xdr_u_long(xdrs, (u_long *)&objp->rtType)) {
  396. return (FALSE);
  397. }
  398. if (!xdr_WRAPSTRING(xdrs, &objp->rtVersion)) {
  399. return (FALSE);
  400. }
  401. if (!xdr_u_long(xdrs, (u_long *)&objp->cpuType)) {
  402. return (FALSE);
  403. }
  404. if (msgVersion == 1) {
  405.     /*
  406.      * The BOOL32 field named hasFpp has been replaced by a
  407.      * bit-significant UINT32 named hasCoprocessor.  For a
  408.      * v1 inquiry, report only the FPP bit (as a BOOL32).
  409.      */
  410.     BOOL32 bTemp = objp->hasCoprocessor & WTX_FPP_MASK;
  411.     if (!xdr_bool(xdrs, (bool_t *)&bTemp)) {
  412. return (FALSE);
  413.     }
  414. }
  415. else {
  416.     if (!xdr_u_long(xdrs, (u_long *)&objp->hasCoprocessor)) {
  417. return (FALSE);
  418.     }
  419. }
  420. if (!xdr_bool(xdrs, (bool_t *)&objp->hasWriteProtect)) {
  421. return (FALSE);
  422. }
  423. if (!xdr_u_long(xdrs, (u_long *)&objp->pageSize)) {
  424. return (FALSE);
  425. }
  426. if (!xdr_u_long(xdrs, (u_long *)&objp->endian)) {
  427. return (FALSE);
  428. }
  429. if (!xdr_WRAPSTRING(xdrs, &objp->bspName)) {
  430. return (FALSE);
  431. }
  432. if (!xdr_WRAPSTRING(xdrs, &objp->bootline)) {
  433. return (FALSE);
  434. }
  435. if (!xdr_TGT_ADDR_T(xdrs, &objp->memBase)) {
  436. return (FALSE);
  437. }
  438. if (!xdr_u_long(xdrs, (u_long *)&objp->memSize)) {
  439. return (FALSE);
  440. }
  441. if (!xdr_u_long(xdrs, (u_long *)&objp->numRegions)) {
  442. return (FALSE);
  443. }
  444. if (!xdr_pointer(xdrs, (char **)&objp->memRegion, 
  445. sizeof(WTX_MEM_REGION), xdr_WTX_MEM_REGION)) {
  446. return (FALSE);
  447. }
  448. if (!xdr_TGT_ADDR_T(xdrs, &objp->hostPoolBase)) {
  449. return (FALSE);
  450. }
  451. if (!xdr_u_long(xdrs, (u_long *)&objp->hostPoolSize)) {
  452. return (FALSE);
  453. }
  454.     return (TRUE);
  455.     }
  457. /*******************************************************************************
  458. *
  459. * xdr_WTX_AGENT_INFO - 
  460. *
  461. */
  463. bool_t xdr_WTX_AGENT_INFO
  464.     (
  465.     XDR * xdrs,
  466.     WTX_AGENT_INFO * objp
  467.     )
  468.     {
  469. if (!xdr_WRAPSTRING(xdrs, &objp->agentVersion)) {
  470. return (FALSE);
  471. }
  472. if (!xdr_u_long(xdrs, (u_long *)&objp->mtu)) {
  473. return (FALSE);
  474. }
  475. if (!xdr_u_long(xdrs, (u_long *)&objp->mode)) {
  476. return (FALSE);
  477. }
  478.     return (TRUE);
  479.     }
  481. /*******************************************************************************
  482. *
  483. * xdr_WTX_TGT_INFO - WTX
  484. *
  485. */
  487. LOCAL bool_t xdr_WTX_TGT_INFO 
  488.     (
  489.     XDR * xdrs,
  490.     WTX_TGT_INFO * objp,
  491.     int msgVersion
  492.     )
  493.     {
  494.     if (!xdr_WTX_AGENT_INFO (xdrs, &objp->agentInfo))
  495. return (FALSE);
  496.     if (!xdr_WTX_RT_INFO (xdrs, &objp->rtInfo, msgVersion))
  497. return (FALSE);
  499.     return (TRUE);
  500.     }
  502. /*******************************************************************************
  503. *
  504. * xdr_WTX_TOOL_DESC - host tool descriptor
  505. *
  506. */
  508. bool_t xdr_WTX_TOOL_DESC 
  509.     (
  510.     XDR *       xdrs,
  511.     WTX_TOOL_DESC * objp
  512.     )
  513.     {
  514.     if (!xdr_u_long (xdrs, (u_long *)&objp->id))
  515. return (FALSE);
  516.     if (!xdr_WRAPSTRING (xdrs, &objp->toolName))
  517. return (FALSE);
  518.     if (!xdr_WRAPSTRING (xdrs, &objp->toolArgv))
  519. return (FALSE);
  520.     if (!xdr_WRAPSTRING (xdrs, &objp->toolArgv))
  521. return (FALSE);
  522.     if (!xdr_WRAPSTRING (xdrs, &objp->userName))
  523. return (FALSE);
  524.     if (!xdr_pointer (xdrs, (char **) &objp->next, 
  525. sizeof(WTX_TOOL_DESC), xdr_WTX_TOOL_DESC))
  526. return (FALSE);
  528.     return (TRUE);
  529.     }
  531. /*******************************************************************************
  532. *
  533. * xdr_WTX_MSG_TOOL_DESC - WTX host tool descriptor
  534. *
  535. */
  537. bool_t xdr_WTX_MSG_TOOL_DESC 
  538.     (
  539.     XDR *           xdrs,
  540.     WTX_MSG_TOOL_DESC * objp
  541.     )
  542.     {
  543.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  544. return (FALSE);
  545.     if (!xdr_WTX_TOOL_DESC (xdrs, &objp->wtxToolDesc))
  546. return (FALSE);
  548.     return (TRUE);
  549.     }
  551. /*******************************************************************************
  552. *
  553. * xdr_WTX_MSG_TS_INFO - target server information
  554. *
  555. */
  557. LOCAL bool_t xdr_WTX_MSG_TS_INFO 
  558.     (
  559.     XDR * xdrs,
  560.     WTX_MSG_TS_INFO * objp,
  561.     int msgVersion
  562.     )
  563.     {
  564.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  565. return (FALSE);
  566.     if (!xdr_WTX_TGT_LINK_DESC (xdrs, &objp->tgtLinkDesc))
  567. return (FALSE);
  568.     if (!xdr_WTX_TGT_INFO (xdrs, &objp->tgtInfo, msgVersion))
  569. return (FALSE);
  570.     if (!xdr_pointer (xdrs, (char **)&objp->pWtxToolDesc, 
  571.       sizeof (WTX_TOOL_DESC), xdr_WTX_TOOL_DESC))
  572. return (FALSE);
  573.     if (!xdr_WRAPSTRING (xdrs, &objp->version))
  574. return (FALSE);
  575.     if (!xdr_WRAPSTRING (xdrs, &objp->userName))
  576. return (FALSE);
  577.     if (!xdr_WRAPSTRING (xdrs, &objp->startTime))
  578. return (FALSE);
  579.     if (!xdr_WRAPSTRING (xdrs, &objp->accessTime))
  580. return (FALSE);
  581.     if (!xdr_WRAPSTRING (xdrs, &objp->lockMsg))
  582. return (FALSE);
  584.     return (TRUE);
  585.     }
  587. /*******************************************************************************
  588. *
  589. * xdr_WTX_MSG_TS_INFO_V1 - target server information
  590. *
  591. */
  593. bool_t xdr_WTX_MSG_TS_INFO_V1
  594.     (
  595.     XDR * xdrs,
  596.     WTX_MSG_TS_INFO * objp
  597.     )
  598.     {
  599.     return xdr_WTX_MSG_TS_INFO (xdrs, objp, 1);
  600.     }
  602. /*******************************************************************************
  603. *
  604. * xdr_WTX_MSG_TS_INFO_V2 - target server information
  605. *
  606. */
  608. bool_t xdr_WTX_MSG_TS_INFO_V2
  609.     (
  610.     XDR * xdrs,
  611.     WTX_MSG_TS_INFO * objp
  612.     )
  613.     {
  614.     return xdr_WTX_MSG_TS_INFO (xdrs, objp, 2);
  615.     }
  617. /*******************************************************************************
  618. *
  619. * xdr_WTX_MSG_TS_LOCK - lock target server
  620. *
  621. */
  623. bool_t xdr_WTX_MSG_TS_LOCK 
  624.     (
  625.     XDR *   xdrs,
  626.     WTX_MSG_TS_LOCK * objp
  627.     )
  628.     {
  629.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  630. return (FALSE);
  631.     if (!xdr_u_long (xdrs, (u_long *)&objp->lockType))
  632. return (FALSE);
  634.     return (TRUE);
  635.     }
  637. /*******************************************************************************
  638. *
  639. * xdr_WTX_MSG_TS_UNLOCK - unlock target server
  640. *
  641. */
  643. bool_t xdr_WTX_MSG_TS_UNLOCK 
  644.     (
  645.     XDR *   xdrs,
  646.     WTX_MSG_TS_UNLOCK * objp
  647.     )
  648.     {
  649.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  650. return (FALSE);
  651.     if (!xdr_bool (xdrs, (bool_t *)&objp->force))
  652. return (FALSE);
  654.     return (TRUE);
  655.     }
  657. /*******************************************************************************
  658. *
  659. * xdr_MEM_COPY_ALLOC - allocate space and decode a MEM_COPY stucture
  660. *
  661. * This function decodes or frees the MEM_COPY structure protocol and
  662. * allocate space to copy the data area referenced by the MEM_COPY
  663. * structure.  The start address is handled by the source field and the size
  664. * by numBytes. At the decoding time, the data are decoded and saved in a
  665. * memory area allocated.  This function is needed to hanlde WTX_MEM_WRITE
  666. * requests that use a target address as the destination pointer. In this
  667. * case we must first copy the data into the target server before forwarding
  668. * them to the target.
  669. * 
  670. * RETURNS:  TRUE if it succeeds, FALSE otherwise.
  671. */
  673. bool_t xdr_MEM_COPY_ALLOC
  674.     (
  675.     XDR * xdrs,
  676.     WTX_MSG_MEM_COPY_DESC * objp
  677.     )
  678.     {
  679.     char * buff; /* buffer where to decode data */
  681.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  682. return (FALSE);
  683.     if (!xdr_u_long (xdrs, (u_long *)&objp->source))
  684. return (FALSE);
  685.     if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
  686. return (FALSE);
  687.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  688. return (FALSE);
  690.     switch (xdrs->x_op) 
  691. {
  692.      case XDR_DECODE:
  693.             {  /* export block */
  694.     if ((buff = (char *)malloc (objp->numBytes)) == NULL)
  695.         return (FALSE);
  697.     if (!xdr_opaque (xdrs, (char *)buff, objp->numBytes))
  698.         return (FALSE);
  700.             /* 
  701.      * Save the allocated buffer address in objp->source for
  702.      * later use by the target server.
  703.      */
  704.     objp->source = (u_int) buff;
  706.     return (TRUE);
  707.     }
  709.      case XDR_ENCODE:
  710.     return (FALSE); /* encoding not supported */
  712.      case XDR_FREE: /* free memory */
  713.     return (TRUE);
  714. }
  716.     return (FALSE);
  717.     }
  719. /*******************************************************************************
  720. *
  721. * xdr_MEM_WIDTH_COPY_ALLOC - allocate space and decode a MEM_COPY stucture
  722. *
  723. * This function decodes or frees the MEM_COPY structure protocol and
  724. * allocate space to copy the data area referenced by the MEM_COPY
  725. * structure.  The start address is handled by the source field and the size
  726. * by numBytes. At the decoding time, the data are decoded and saved in a
  727. * memory area allocated.  This function is needed to hanlde WTX_MEM_WRITE
  728. * requests that use a target address as the destination pointer. In this
  729. * case we must first copy the data into the target server before forwarding
  730. * them to the target.
  731. *
  732. * RETURNS:  TRUE if it succeeds, FALSE otherwise.
  733. */
  735. bool_t xdr_MEM_WIDTH_COPY_ALLOC
  736.     (
  737.     XDR *                             xdrs,
  738.     WTX_MSG_MEM_WIDTH_COPY_DESC *     objp
  739.     )
  740.     {
  741.     char * buff;        /* buffer where to decode data */
  743.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  744.         return (FALSE);
  745.     if (!xdr_u_long (xdrs, (u_long *)&objp->source))
  746.         return (FALSE);
  747.     if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
  748.         return (FALSE);
  749.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  750.         return (FALSE);
  751.     if (!xdr_u_char (xdrs, &objp->width))
  752.         return (FALSE);
  754.     switch (xdrs->x_op)
  755.         {
  756.         case XDR_DECODE:
  757.             {                                            /* export block */
  758.             if ((buff = (char *)malloc (objp->numBytes)) == NULL)
  759.                 return (FALSE);
  761.             if (!xdr_opaque (xdrs, (char *)buff, objp->numBytes))
  762.                 return (FALSE);
  764.             /*
  765.              * Save the allocated buffer address in objp->source for
  766.              * later use by the target server.
  767.              */
  768.             objp->source = (u_int) buff;
  770.             return (TRUE);
  771.             }
  773.         case XDR_ENCODE:
  774.             return (FALSE);                     /* encoding not supported */
  776.         case XDR_FREE:                          /* free memory */
  777.             return (TRUE);
  778.         }
  780.     return (FALSE);
  781.     }
  783. /*******************************************************************************
  784. *
  785. * xdr_WTX_MSG_TOOL_ID - WTX tool identifier
  786. *
  787. */
  789. bool_t xdr_WTX_MSG_TOOL_ID 
  790.     (
  791.     XDR *         xdrs,
  792.     WTX_MSG_TOOL_ID * objp
  793.     )
  794.     {
  795.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  796. return (FALSE);
  798.     return (TRUE);
  799.     }
  801. /*******************************************************************************
  802. *
  803. * xdr_WTX_MSG_KILL_DESC - WTX kill operation descriptor
  804. *
  805. */
  807. bool_t xdr_WTX_MSG_KILL_DESC 
  808.     (
  809.     XDR *         xdrs,
  810.     WTX_MSG_KILL_DESC * objp
  811.     )
  812.     {
  813.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  814. return (FALSE);
  816.     if (!xdr_u_long (xdrs, (u_long *)&objp->request))
  817. return (FALSE);
  818.     if (!xdr_WTX_VALUE (xdrs, &objp->arg))
  819. return (FALSE);
  821.     return (TRUE);
  822.     }
  824. /*******************************************************************************
  825. *
  826. * xdr_WTX_EVENT - WTX
  827. *
  828. */
  830. bool_t xdr_WTX_EVENT 
  831.     (
  832.     XDR *        xdrs,
  833.     WTX_EVENT * objp
  834.     )
  835.     {
  836.     if (!xdr_enum (xdrs, (enum_t *)&objp->eventType))
  837. return (FALSE);
  838.     if (!xdr_TGT_ARG_T (xdrs, &objp->eventArg))
  839. return (FALSE);
  841.     return (TRUE);
  842.     }
  844. /*******************************************************************************
  845. *
  846. * xdr_WTX_ACTION - WTX
  847. *
  848. */
  850. bool_t xdr_WTX_ACTION 
  851.     (
  852.     XDR *        xdrs,
  853.     WTX_ACTION * objp
  854.     )
  855.     {
  856.     if (!xdr_enum (xdrs, (enum_t *)&objp->actionType))
  857. return (FALSE);
  858.     if (!xdr_u_long (xdrs, (u_long *)&objp->actionArg))
  859. return (FALSE);
  860.     if (!xdr_TGT_ADDR_T (xdrs, &objp->callRtn))
  861. return (FALSE);
  862.     if (!xdr_TGT_ARG_T (xdrs, &objp->callArg))
  863. return (FALSE);
  865.     return (TRUE);
  866.     }
  868. /*******************************************************************************
  869. *
  870. * xdr_WTX_CONTEXT - WTX context
  871. *
  872. */
  874. bool_t xdr_WTX_CONTEXT 
  875.     (
  876.     XDR *        xdrs,
  877.     WTX_CONTEXT * objp
  878.     )
  879.     {
  880.     if (!xdr_enum (xdrs, (enum_t *)&objp->contextType))
  881. return (FALSE);
  882.     if (!xdr_WTX_CONTEXT_ID_T (xdrs, &objp->contextId))
  883. return (FALSE);
  885.     return (TRUE);
  886.     }
  888. /*******************************************************************************
  889. *
  890. * xdr_WTX_MSG_CONTEXT - WTX context message
  891. *
  892. */
  894. bool_t xdr_WTX_MSG_CONTEXT 
  895.     (
  896.     XDR *        xdrs,
  897.     WTX_MSG_CONTEXT * objp
  898.     )
  899.     {
  900.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  901. return (FALSE);
  902.     if (!xdr_enum (xdrs, (enum_t *)&objp->contextType))
  903. return (FALSE);
  904.     if (!xdr_WTX_CONTEXT_ID_T (xdrs, &objp->contextId))
  905. return (FALSE);
  907.     return (TRUE);
  908.     }
  910. /*******************************************************************************
  911. *
  912. * xdr_WTX_EVTPT - WTX
  913. *
  914. */
  916. bool_t xdr_WTX_EVTPT 
  917.     (
  918.     XDR *        xdrs,
  919.     WTX_EVTPT * objp
  920.     )
  921.     {
  922.     if (!xdr_WTX_EVENT (xdrs, &objp->event))
  923. return (FALSE);
  924.     if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
  925. return (FALSE);
  926.     if (!xdr_WTX_ACTION (xdrs, &objp->action))
  927. return (FALSE);
  929.     return (TRUE);
  930.     }
  932. /*******************************************************************************
  933. *
  934. * xdr_WTX_MSG_EVTPT_DESC - WTX
  935. *
  936. */
  938. bool_t xdr_WTX_MSG_EVTPT_DESC 
  939.     (
  940.     XDR *        xdrs,
  941.     WTX_MSG_EVTPT_DESC * objp
  942.     )
  943.     {
  944.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  945. return (FALSE);
  946.     if (!xdr_WTX_EVTPT (xdrs, &objp->wtxEvtpt))
  947. return (FALSE);
  949.     return (TRUE);
  950.     }
  952. /*******************************************************************************
  953. *
  954. * xdr_WTX_MSG_EVTPT_LIST - eventpoint list
  955. *
  956. */
  958. bool_t xdr_WTX_MSG_EVTPT_LIST 
  959.     (
  960.     XDR *        xdrs,
  961.     WTX_MSG_EVTPT_LIST * objp
  962.     )
  963.     {
  964.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  965. return (FALSE);
  966.     if (!xdr_u_long (xdrs, (u_long *)&objp->nEvtpt))
  967. return (FALSE);
  968.     if (!xdr_array (xdrs, (char **)&objp->pEvtpt, (u_int *)&objp->nEvtpt, 
  969.     ~0, sizeof (WTX_EVTPT), xdr_WTX_EVTPT))
  971. return (FALSE);
  973.     return (TRUE);
  974.     }
  976. /*******************************************************************************
  977. *
  978. * xdr_WTX_MEM_XFER - allocate space and decode a WTX_MEM_XFER stucture
  979. *
  980. * This function decodes or frees the WTX_MEM_XFER structure and
  981. * allocate space to copy the data area referenced by the WTX_MEM_XFER
  982. * structure.  The start address is handled by the source field and the size
  983. * by numBytes. At the decoding time, the data are decoded and saved in a
  984. * memory area allocated.  
  985. * 
  986. * RETURNS:  TRUE if it succeeds, FALSE otherwise.
  987. */
  989. bool_t xdr_WTX_MEM_XFER
  990.     (
  991.     XDR * xdrs,
  992.     WTX_MEM_XFER * objp
  993.     )
  994.     {
  995.     char * buff; /* buffer where to decode data */
  997.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  998. return (FALSE);
  999.     if (!xdr_u_long (xdrs, (u_long *)&objp->source))
  1000. return (FALSE);
  1001.     if (!xdr_u_long (xdrs, (u_long *)&objp->destination))
  1002. return (FALSE);
  1004.     switch (xdrs->x_op) 
  1005. {
  1006.      case XDR_DECODE:
  1007.             {  /* export block */
  1008.     if ((buff = (char *) malloc (objp->numBytes)) == NULL)
  1009.         return (FALSE);
  1011.     if (!xdr_opaque (xdrs, (char *) buff, objp->numBytes))
  1012.         return (FALSE);
  1014.             /* 
  1015.      * Save the allocated buffer address in objp->destination for
  1016.      * later use by the client.
  1017.      */
  1019.     objp->source = (char *) buff;
  1021.     return (TRUE);
  1022.     }
  1024.      case XDR_ENCODE:
  1025.     if (!xdr_opaque (xdrs, (char *) objp->source, objp->numBytes))
  1026.         return (FALSE);
  1027.     else
  1028. return (TRUE);
  1030.      case XDR_FREE: /* free memory */
  1031.     {
  1032.     free (objp->source);
  1033.     return (TRUE);
  1034.     }
  1035. }
  1037.     return (FALSE);
  1038.     }
  1040. /*******************************************************************************
  1041. *
  1042. * xdr_WTX_MSG_MEM_XFER_DESC - memory set descriptor
  1043. *
  1044. */
  1046. bool_t xdr_WTX_MSG_MEM_XFER_DESC 
  1047.     (
  1048.     XDR *          xdrs,
  1049.     WTX_MSG_MEM_XFER_DESC * objp
  1050.     )
  1051.     {
  1052.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1053. return (FALSE);
  1054.     if (!xdr_WTX_MEM_XFER (xdrs, &objp->memXfer))
  1055. return (FALSE);
  1057.     return (TRUE);
  1058.     }
  1060. /*******************************************************************************
  1061. *
  1062. * xdr_WTX_MSG_REG_WRITE - code, decode or free the WTX_MSG_REG_WRITE structure. 
  1063. *
  1064. * This function codes, decodes or frees the WTX_MSG_REG_WRITE structure.
  1065. *
  1066. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1067. */
  1069. bool_t xdr_WTX_MSG_REG_WRITE
  1070.     (
  1071.     XDR * xdrs,
  1072.     WTX_MSG_REG_WRITE * objp
  1073.     )
  1074.     {
  1075.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1076. return (FALSE);
  1077.     if (!xdr_enum (xdrs, (enum_t *)&objp->regSetType))
  1078. return (FALSE);
  1080.     if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
  1081. return (FALSE);
  1083.     if (!xdr_WTX_MEM_XFER (xdrs, &objp->memXfer))
  1084. return (FALSE);
  1086.     return (TRUE);
  1087.     }
  1089. /*******************************************************************************
  1090. *
  1091. * xdr_WTX_MSG_REG_READ - code, decode or free the WTX_MSG_REG_READ structure. 
  1092. *
  1093. * This function codes, decodes or frees the WTX_MSG_REG_READ structure.
  1094. *
  1095. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1096. */
  1098. bool_t xdr_WTX_MSG_REG_READ
  1099.     (
  1100.     XDR * xdrs,
  1101.     WTX_MSG_REG_READ * objp
  1102.     )
  1103.     {
  1104.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1105. return (FALSE);
  1106.     if (!xdr_enum (xdrs, (enum_t *)&objp->regSetType))
  1107. return (FALSE);
  1109.     if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
  1110. return (FALSE);
  1112.     if (!xdr_WTX_MEM_REGION (xdrs, &objp->memRegion))
  1113. return (FALSE);
  1115.     return (TRUE);
  1116.     }
  1118. /*******************************************************************************
  1119. *
  1120. * xdr_WTX_MSG_MEM_BLOCK_DESC - WTX
  1121. *
  1122. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1123. */
  1125. bool_t xdr_WTX_MSG_MEM_BLOCK_DESC
  1126.     (
  1127.     XDR *       xdrs, /* xdr handle */
  1128.     WTX_MSG_MEM_BLOCK_DESC * objp
  1129.     )
  1130.     {
  1131.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1132. return (FALSE);
  1133.     if (!xdr_TGT_ADDR_T (xdrs, &objp->startAddr))
  1134. return (FALSE);
  1136.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1137. return (FALSE);
  1139.     return (TRUE);
  1140.     }
  1142. /*******************************************************************************
  1143. *
  1144. * xdr_WTX_MSG_MEM_READ_DESC - WTX
  1145. *
  1146. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1147. */
  1149. bool_t xdr_WTX_MSG_MEM_READ_DESC
  1150.     (
  1151.     XDR * xdrs,
  1152.     WTX_MSG_MEM_READ_DESC * objp
  1153.     )
  1154.     {
  1155.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1156. return (FALSE);
  1157.     if (!xdr_TGT_ADDR_T (xdrs, &objp->source))
  1158. return (FALSE);
  1160.     if (!xdr_u_long (xdrs, (u_long *)&objp->destination))
  1161. return (FALSE);
  1163.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1164. return (FALSE);
  1166.     return (TRUE);
  1167.     }
  1169. /*******************************************************************************
  1170. *
  1171. * xdr_WTX_MSG_MEM_WIDTH_READ_DESC - WTX
  1172. *
  1173. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1174. */
  1176. bool_t xdr_WTX_MSG_MEM_WIDTH_READ_DESC
  1177.     (
  1178.     XDR *       xdrs,
  1179.     WTX_MSG_MEM_WIDTH_READ_DESC *     objp
  1180.     )
  1181.     {
  1182.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1183.         return (FALSE);
  1184.     if (!xdr_TGT_ADDR_T (xdrs, &objp->source))
  1185.         return (FALSE);
  1186.     if (!xdr_u_long (xdrs, (u_long *)&objp->destination))
  1187.         return (FALSE);
  1188.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1189.         return (FALSE);
  1190.     if (!xdr_u_char (xdrs, &objp->width))
  1191.         return (FALSE);
  1193.     return (TRUE);
  1194.     }
  1196. /*******************************************************************************
  1197. *
  1198. * xdr_WTX_MSG_MEM_COPY_DESC - WTX
  1199. *
  1200. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1201. */
  1203. bool_t xdr_WTX_MSG_MEM_COPY_DESC
  1204.     (
  1205.     XDR * xdrs,
  1206.     WTX_MSG_MEM_COPY_DESC * objp
  1207.     )
  1208.     {
  1209.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1210. return (FALSE);
  1211.     if (!xdr_u_long (xdrs, (u_long *)&objp->source))
  1212. return (FALSE);
  1213.     if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
  1214. return (FALSE);
  1215.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1216. return (FALSE);
  1218.     if (xdrs->x_op == XDR_ENCODE)
  1219.         {                                                /* export block */
  1220.         if (!xdr_opaque (xdrs, (char *)objp->source, objp->numBytes))
  1221.             return (FALSE);
  1222.         }
  1223.     else if (xdrs->x_op == XDR_DECODE)                  /* import block */
  1224.         {
  1225.         if (!xdr_opaque (xdrs, (char *)objp->destination, objp->numBytes))
  1226.             return (FALSE);
  1227. }
  1229.     return (TRUE);
  1230.     }
  1232. /*******************************************************************************
  1233. *
  1234. * xdr_WTX_MSG_MEM_WIDTH_COPY_DESC - WTX
  1235. *
  1236. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1237. */
  1239. bool_t xdr_WTX_MSG_MEM_WIDTH_COPY_DESC
  1240.     (
  1241.     XDR *       xdrs,
  1242.     WTX_MSG_MEM_WIDTH_COPY_DESC *     objp
  1243.     )
  1244.     {
  1245.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1246.         return (FALSE);
  1247.     if (!xdr_u_long (xdrs, (u_long *)&objp->source))
  1248.         return (FALSE);
  1249.     if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
  1250.         return (FALSE);
  1251.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1252.         return (FALSE);
  1253.     if (!xdr_u_char (xdrs, &objp->width))
  1254.         return (FALSE);
  1256.     if (xdrs->x_op == XDR_ENCODE)
  1257.         {                                                /* export block */
  1258.         if (!xdr_opaque (xdrs, (char *)objp->source, objp->numBytes))
  1259.             return (FALSE);
  1260.         }
  1261.     else if (xdrs->x_op == XDR_DECODE)                  /* import block */
  1262.         {
  1263.         if (!xdr_opaque (xdrs, (char *)objp->destination, objp->numBytes))
  1264.             return (FALSE);
  1265.         }
  1267.     return (TRUE);
  1268.     }
  1270. /*******************************************************************************
  1271. *
  1272. * xdr_WTX_MSG_MEM_SCAN_DESC - WTX
  1273. *
  1274. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1275. */
  1277. bool_t xdr_WTX_MSG_MEM_SCAN_DESC
  1278.     (
  1279.     XDR * xdrs,
  1280.     WTX_MSG_MEM_SCAN_DESC * objp
  1281.     )
  1282.     {
  1283.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1284. return (FALSE);
  1286.     if (!xdr_u_long (xdrs, (u_long *)&objp->match))
  1287. return (FALSE);
  1288.     if (!xdr_TGT_ADDR_T (xdrs, &objp->startAddr))
  1289. return (FALSE);
  1290.     if (!xdr_TGT_ADDR_T (xdrs, &objp->endAddr))
  1291. return (FALSE);
  1293.     if (!xdr_bytes (xdrs, (char **)&objp->pattern, (u_int *)&objp->numBytes,
  1294.     WTX_MAX_PATTERN_LEN))
  1295. return (FALSE);
  1297.     return (TRUE);
  1298.     }
  1300. /*******************************************************************************
  1301. *
  1302. * xdr_WTX_MSG_MEM_MOVE_DESC - WTX
  1303. *
  1304. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1305. */
  1307. bool_t xdr_WTX_MSG_MEM_MOVE_DESC
  1308.     (
  1309.     XDR * xdrs,
  1310.     WTX_MSG_MEM_MOVE_DESC * objp
  1311.     )
  1312.     {
  1313.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1314. return (FALSE);
  1316.     if (!xdr_TGT_ADDR_T (xdrs, &objp->source))
  1317. return (FALSE);
  1318.     if (!xdr_TGT_ADDR_T (xdrs, &objp->destination))
  1319. return (FALSE);
  1320.     if (!xdr_u_long (xdrs, (u_long *)&objp->numBytes))
  1321. return (FALSE);
  1323.     return (TRUE);
  1324.     }
  1326. /*******************************************************************************
  1327. *
  1328. * xdr_WTX_MSG_MEM_SET_DESC - WTX
  1329. *
  1330. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1331. */
  1333. bool_t xdr_WTX_MSG_MEM_SET_DESC
  1334.     (
  1335.     XDR * xdrs,
  1336.     WTX_MSG_MEM_SET_DESC * objp
  1337.     )
  1338.     {
  1339.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1340. return (FALSE);
  1341.     if (!xdr_u_long (xdrs, (u_long *)&objp->value))
  1342. return (FALSE);
  1343.     if (!xdr_u_char (xdrs, &objp->width))
  1344. return (FALSE);
  1345.     if (!xdr_TGT_ADDR_T (xdrs, &objp->startAddr))
  1346. return (FALSE);
  1347.     if (!xdr_u_long (xdrs, (u_long *)&objp->numItems))
  1348. return (FALSE);
  1350.     return (TRUE);
  1351.     }
  1353. /*******************************************************************************
  1354. *
  1355. * xdr_WTX_MSG_CONTEXT_DESC - WTX
  1356. *
  1357. * RETURNS:  TRUE if it succeeds, FALSE otherwise.
  1358. */
  1360. bool_t xdr_WTX_MSG_CONTEXT_DESC
  1361.     (
  1362.     XDR * xdrs, /* xdr handle */
  1363.     WTX_MSG_CONTEXT_DESC * objp
  1364.     )
  1365.     {
  1366.     u_int  argNum = WTX_MAX_ARG_CNT;
  1367.     TGT_ADDR_T * pArgs = (TGT_ADDR_T *)objp->args;/* argument table pointer */
  1369.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1370. return (FALSE);
  1372.     if (!xdr_enum (xdrs, (enum_t *)&objp->contextType))
  1373. return (FALSE);
  1374.     if (!xdr_u_long (xdrs, (u_long *)&objp->returnType))
  1375. return (FALSE);
  1376.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  1377. return (FALSE);
  1378.     if (!xdr_u_long (xdrs, (u_long *)&objp->priority))
  1379. return (FALSE);
  1380.     if (!xdr_u_long (xdrs, (u_long *)&objp->options))
  1381. return (FALSE);
  1382.     if (!xdr_TGT_ADDR_T (xdrs, &objp->stackBase))
  1383. return (FALSE);
  1384.     if (!xdr_u_long (xdrs, (u_long *)&objp->stackSize))
  1385. return (FALSE);
  1386.     if (!xdr_TGT_ADDR_T (xdrs, &objp->entry))
  1387. return (FALSE);
  1388.     if (!xdr_long (xdrs, (long *)&objp->redirIn))
  1389. return (FALSE);
  1390.     if (!xdr_long (xdrs, (long *)&objp->redirOut))
  1391. return (FALSE);
  1393.     /*
  1394.      * The arg array is not dynamically allocated. So when freeing memory, 
  1395.      * xdr_array *MUST NOT* free this array.
  1396.      */
  1397.     if (xdrs->x_op == XDR_FREE)
  1398. {
  1399. char * ptr = NULL; /* dummy array */
  1401. if (!xdr_array (xdrs, (caddr_t *)&ptr, &argNum, ~0, 
  1402.     sizeof (TGT_ARG_T), xdr_TGT_ARG_T))
  1403. return (FALSE);
  1404. }
  1405.     else
  1406.      {
  1407. if (!xdr_array (xdrs, (caddr_t *)&pArgs, &argNum, ~0, 
  1408.     sizeof (TGT_ARG_T), xdr_TGT_ARG_T))
  1409. return (FALSE);
  1410. }
  1412.     return (TRUE);
  1413.     }
  1415. /*******************************************************************************
  1416. *
  1417. * xdr_WTX_MSG_CONTEXT_STEP_DESC - WTX
  1418. *
  1419. * RETURNS: TRUE if it succeeds, FALSE otherwise.
  1420. */
  1422. bool_t xdr_WTX_MSG_CONTEXT_STEP_DESC
  1423.     (
  1424.     XDR * xdrs,
  1425.     WTX_MSG_CONTEXT_STEP_DESC * objp
  1426.     )
  1427.     {
  1428.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1429. return (FALSE);
  1430.     if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
  1431. return (FALSE);
  1432.     if (!xdr_TGT_ADDR_T (xdrs, &objp->startAddr))
  1433. return (FALSE);
  1434.     if (!xdr_TGT_ADDR_T (xdrs, &objp->endAddr))
  1435. return (FALSE);
  1437.     return (TRUE);
  1438.     }
  1440. /*******************************************************************************
  1441. *
  1442. * xdr_WTX_MSG_OPEN_DESC - virtual I/O descriptor  
  1443. *
  1444. */
  1446. bool_t xdr_WTX_MSG_OPEN_DESC
  1447.     (
  1448.     XDR * xdrs,
  1449.     WTX_MSG_OPEN_DESC * objp
  1450.     )
  1451.     {
  1452.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1453. return (FALSE);
  1454.     if (!xdr_WRAPSTRING (xdrs, &objp->filename))
  1455. return (FALSE);
  1456.     if (!xdr_enum (xdrs, (enum_t *)&objp->flags))
  1457. return (FALSE);
  1458.     if (!xdr_int (xdrs, &objp->mode))
  1459. return (FALSE);
  1460.     if (!xdr_int (xdrs, &objp->channel))
  1461. return (FALSE);
  1463.     return (TRUE);
  1464.     }
  1466. /*******************************************************************************
  1467. *
  1468. * xdr_WTX_MSG_VIO_CTL_DESC - virtual I/O control descriptor
  1469. *
  1470. */
  1472. bool_t xdr_WTX_MSG_VIO_CTL_DESC
  1473.     (
  1474.     XDR *          xdrs,
  1475.     WTX_MSG_VIO_CTL_DESC * objp
  1476.     )
  1477.     {
  1478.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1479. return (FALSE);
  1480.     if (!xdr_u_long (xdrs, (u_long *)&objp->channel))
  1481. return (FALSE);
  1482.     if (!xdr_u_long (xdrs, (u_long *)&objp->request))
  1483. return (FALSE);
  1484.     if (!xdr_u_long (xdrs, (u_long *)&objp->arg))
  1485. return (FALSE);
  1487.     return (TRUE);
  1488.     }
  1490. /*******************************************************************************
  1491. *
  1492. * xdr_WTX_MSG_VIO_COPY_DESC - 
  1493. *
  1494. * This function codes, decodes or frees the VIO_COPY structure and copies the
  1495. * data buffer of a specific virtual I/O channel. If the VIO_COPY baseAddr field
  1496. * is a NULL pointer no data are copied, otherwise the data are coded. The
  1497. * number of bytes to encode are handled by the maxBytes field. When the data
  1498. * are decoded their values are saved in a memory area allocted by the
  1499. * xdr_opaque function. 
  1500. *
  1501. * RETURNS:  TRUE if it succeeds, FALSE otherwise.
  1502. */
  1504. bool_t xdr_WTX_MSG_VIO_COPY_DESC
  1505.     (
  1506.     XDR * xdrs,
  1507.     WTX_MSG_VIO_COPY_DESC * objp
  1508.     )
  1509.     {
  1510.     bool_t moreData; /* NULL pointer flag */
  1512.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1513. return (FALSE);
  1515.     if (!xdr_u_long (xdrs, (u_long *)&objp->channel))
  1516. return (FALSE);
  1518.     if (!xdr_u_long (xdrs, (u_long *)&objp->maxBytes))
  1519. return (FALSE);
  1521.     moreData = (objp->baseAddr != NULL); /*  NULL pointer ? */
  1522.     if (! xdr_bool(xdrs, (bool_t *)&moreData)) /* code/decode test result */
  1523. return (FALSE);
  1524.     if (! moreData)
  1525. objp->baseAddr  = NULL; /* YES: return a NULL pointer */
  1526.     else /* NO: code/decode the data */
  1527. {
  1528. if (xdrs->x_op == XDR_DECODE) /* if decode force mem alloc */
  1529.     objp->baseAddr  = (void *) malloc (objp->maxBytes);
  1531. if (xdrs->x_op == XDR_FREE) /* if free de-alloc memory */
  1532.     free (objp->baseAddr);
  1534. if (! xdr_opaque (xdrs, (char *) objp->baseAddr, objp->maxBytes))
  1535.     return (FALSE);
  1536. }
  1538.     return (TRUE);
  1539.     }
  1541. /*******************************************************************************
  1542. *
  1543. * xdr_WTX_VIO_FILE_DESC - WTX VIO file descriptor
  1544. *
  1545. */
  1547. bool_t xdr_WTX_VIO_FILE_DESC 
  1548.     (
  1549.     XDR *          xdrs,
  1550.     WTX_VIO_FILE_DESC * objp
  1551.     )
  1552.     {
  1553.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  1554. return (FALSE);
  1555.     if (!xdr_long (xdrs, (long *)&objp->fd))
  1556. return (FALSE);
  1557.     if (!xdr_long (xdrs, (long *)&objp->channel))
  1558. return (FALSE);
  1559.     if (!xdr_long (xdrs, (long *)&objp->fp))
  1560. return (FALSE);
  1561.     if (!xdr_long (xdrs, (long *)&objp->type))
  1562. return (FALSE);
  1563.     if (!xdr_long (xdrs, (long *)&objp->mode))
  1564. return (FALSE);
  1565.     if (!xdr_long (xdrs, (long *)&objp->status))
  1566. return (FALSE);
  1567.     if (!xdr_long (xdrs, (long *)&objp->addlInfo))
  1568. return (FALSE);
  1569.     if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (WTX_VIO_FILE_DESC),
  1570.       xdr_WTX_VIO_FILE_DESC))
  1571. return (FALSE);
  1573.     return (TRUE);
  1574.     }
  1576. /*******************************************************************************
  1577. *
  1578. * xdr_WTX_MSG_VIO_FILE_LIST - WTX VIO files list message
  1579. *
  1580. */
  1582. bool_t xdr_WTX_MSG_VIO_FILE_LIST 
  1583.     (
  1584.     XDR *           xdrs,
  1585.     WTX_MSG_VIO_FILE_LIST * objp
  1586.     )
  1587.     {
  1588.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1589. return (FALSE);
  1591.     if (!xdr_pointer (xdrs, (char **)&objp->pVioFileList, 
  1592.       sizeof (WTX_VIO_FILE_DESC), xdr_WTX_VIO_FILE_DESC))
  1593. return (FALSE);
  1595.     return (TRUE);
  1596.     }
  1598. /*******************************************************************************
  1599. *
  1600. * xdr_WTX_SYMBOL - symbol information
  1601. *
  1602. */
  1604. bool_t xdr_WTX_SYMBOL 
  1605.     (
  1606.     XDR *        xdrs,
  1607.     WTX_SYMBOL *  objp
  1608.     )
  1609.     {
  1610.     if (!xdr_u_long (xdrs, (u_long *)&objp->status))
  1611. return (FALSE);
  1612.     if (!xdr_u_long (xdrs, (u_long *)&objp->symTblId))
  1613. return (FALSE);
  1614.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  1615. return (FALSE);
  1616.     if (!xdr_bool (xdrs, (bool_t *)&objp->exactName))
  1617. return (FALSE);
  1618.     if (!xdr_TGT_ADDR_T (xdrs, &objp->value))
  1619. return (FALSE);
  1620.     if (!xdr_u_char (xdrs, &objp->type))
  1621. return (FALSE);
  1622.     if (!xdr_u_char (xdrs, &objp->typeMask))
  1623. return (FALSE);
  1624.     if (!xdr_u_short (xdrs, &objp->group))
  1625. return (FALSE);
  1626.     if (!xdr_WRAPSTRING (xdrs, &objp->moduleName))
  1627. return (FALSE);
  1628.     /* 
  1629.      * There is no need to xdr the next field since it is only meaningfull
  1630.      * on one side of the protocol.
  1631.      */
  1633.     return (TRUE);
  1634.     }
  1636. /*******************************************************************************
  1637. *
  1638. * xdr_WTX_MSG_SYMBOL_DESC - WTX symbol descriptor
  1639. *
  1640. */
  1642. bool_t xdr_WTX_MSG_SYMBOL_DESC 
  1643.     (
  1644.     XDR *        xdrs,
  1645.     WTX_MSG_SYMBOL_DESC *  objp
  1646.     )
  1647.     {
  1648.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1649. return (FALSE);
  1650.     if (!xdr_WTX_SYMBOL (xdrs, &objp->symbol))
  1651. return (FALSE);
  1653.     return (TRUE);
  1654.     }
  1656. /*******************************************************************************
  1657. *
  1658. * xdr_WTX_SYM_LIST - symbol list
  1659. *
  1660. * We avoid recursives routines here since the symbol list may be huge and
  1661. * can blow the C stack.
  1662. */
  1664. bool_t xdr_WTX_SYM_LIST 
  1665.     (
  1666.     XDR *        xdrs,
  1667.     WTX_SYM_LIST *  pList
  1668.     )
  1669.     {
  1670.     bool_t moreData;
  1671.     WTX_SYMBOL * pSym;
  1672.     WTX_SYMBOL * pNext;
  1673.     WTX_SYMBOL ** ppSymLink = 0;
  1675.     /* The tough one, xdr the list of symbols */
  1677.     if (xdrs->x_op == XDR_FREE)
  1678. {
  1679. /* move through the list and free each one. */
  1681. for (pSym = pList->pSymbol; pSym; pSym = pNext)
  1682.     {
  1683.     pNext = pSym->next;
  1684.     if (!xdr_reference (xdrs, (caddr_t *)&pSym, sizeof (WTX_SYMBOL), 
  1685. xdr_WTX_SYMBOL))
  1686. return (FALSE);
  1687.     }
  1688. }
  1689.     else
  1690. {
  1691. /* we need to store the links ourselves. */
  1693. ppSymLink = &(pList->pSymbol);
  1695. for (;;)
  1696.     {
  1697.     moreData = (*ppSymLink != NULL); /* test for end of list */
  1699.     if (!xdr_bool(xdrs, &moreData)) /* xdr the moreData field */
  1700. return (FALSE);
  1702.     if (!moreData) /* if end of list it's time to leave */
  1703. break;
  1705.     /* 
  1706.      * Now xdr the current symbol. Note that xdr_WTX_SYMBOL is not 
  1707.      * recursive and will only serialize/de-serialize one symbol node.
  1708.      */
  1710.     if (!xdr_reference (xdrs, (caddr_t *)ppSymLink, sizeof (WTX_SYMBOL), 
  1711. xdr_WTX_SYMBOL))
  1712. return (FALSE);
  1714.     /* 
  1715.      * point to next node, if we are freeing buffers, use the node
  1716.      * whose address was saved prior calling xdr_reference().
  1717.      */
  1719.     ppSymLink = & ((*ppSymLink)->next);
  1720.     }
  1721. }
  1723.     return (TRUE);
  1724.     }
  1726. /*******************************************************************************
  1727. *
  1728. * xdr_LD_M_SECTION - object module section desciptor
  1729. *
  1730. */
  1732. bool_t xdr_LD_M_SECTION
  1733.     (
  1734.     XDR *          xdrs,
  1735.     LD_M_SECTION * objp
  1736.     )
  1737.     {
  1738.     if (!xdr_u_long (xdrs, (u_long *)&objp->flags))
  1739. return (FALSE);
  1740.     if (!xdr_u_long (xdrs, (u_long *)&objp->addr))
  1741. return (FALSE);
  1742.     if (!xdr_u_long (xdrs, (u_long *)&objp->length))
  1743. return (FALSE);
  1745.     return (TRUE);
  1746.     }
  1748. /*******************************************************************************
  1749. *
  1750. * xdr_WTX_MSG_LD_M_FILE_DESC - multiple section object file
  1751. *
  1752. */
  1754. bool_t xdr_WTX_MSG_LD_M_FILE_DESC 
  1755.     (
  1756.     XDR *       xdrs,
  1757.     WTX_MSG_LD_M_FILE_DESC * objp
  1758.     )
  1759.     {
  1760.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1761. return (FALSE);
  1762.     if (!xdr_WRAPSTRING (xdrs, &objp->filename))
  1763. return (FALSE);
  1764.     if (!xdr_int (xdrs, &objp->loadFlag))
  1765. return (FALSE);
  1766.     if (!xdr_u_long (xdrs, (u_long *)&objp->moduleId))
  1767. return (FALSE);
  1768.     if (!xdr_u_long (xdrs, (u_long *)&objp->nSections))
  1769. return (FALSE);
  1771.     if (!xdr_array (xdrs, (char **) &objp->section, 
  1772.     (u_int *) &objp->nSections, 
  1773.     (WTX_MAX_SECTION_CNT * sizeof (LD_M_SECTION)), 
  1774.     sizeof (LD_M_SECTION), xdr_LD_M_SECTION))
  1775. return (FALSE);
  1777.     if (!xdr_WTX_SYM_LIST (xdrs, &objp->undefSymList))
  1778. return (FALSE);
  1779.     
  1780.     return (TRUE);
  1781.     }
  1783. /*******************************************************************************
  1784. *
  1785. * xdr_MODULE_LIST - object module list
  1786. *
  1787. */
  1789. bool_t xdr_WTX_MSG_MODULE_LIST
  1790.     (
  1791.     XDR *          xdrs,
  1792.     WTX_MSG_MODULE_LIST * objp
  1793.     )
  1794.     {
  1795.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1796. return (FALSE);
  1797.     if (!xdr_u_long (xdrs, (u_long *)&objp->numObjMod))
  1798. return (FALSE);
  1799.     if (!xdr_array (xdrs, (char **)&objp->modIdList, (u_int *)&objp->numObjMod, 
  1800.     (WTX_MAX_MODULE_CNT * sizeof (u_int)), sizeof (u_int), 
  1801.     xdr_u_long))
  1802. return (FALSE);
  1804.     return (TRUE);
  1805.     }
  1807. /*******************************************************************************
  1808. *
  1809. * xdr_OBJ_SEGMENT - object module segment
  1810. *
  1811. */
  1813. bool_t xdr_OBJ_SEGMENT
  1814.     (
  1815.     XDR *         xdrs,
  1816.     OBJ_SEGMENT * objp
  1817.     )
  1818.     {
  1819.     if (!xdr_u_long (xdrs, (u_long *)&objp->flags))
  1820. return (FALSE);
  1821.     if (!xdr_u_long (xdrs, (u_long *)&objp->addr))
  1822. return (FALSE);
  1823.     if (!xdr_u_long (xdrs, (u_long *)&objp->length))
  1824. return (FALSE);
  1825.     if (!xdr_u_long (xdrs, (u_long *)&objp->reserved1))
  1826. return (FALSE);
  1827.     if (!xdr_u_long (xdrs, (u_long *)&objp->reserved2))
  1828. return (FALSE);
  1830.     return (TRUE);
  1831.     }
  1833. /*******************************************************************************
  1834. *
  1835. * xdr_WTX_MSG_MODULE_INFO - object module information
  1836. *
  1837. */
  1839. bool_t xdr_WTX_MSG_MODULE_INFO 
  1840.     (
  1841.     XDR *          xdrs,
  1842.     WTX_MSG_MODULE_INFO *  objp
  1843.     )
  1844.     {
  1845.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1846. return (FALSE);
  1847.     if (!xdr_u_long (xdrs, (u_long *)&objp->moduleId))
  1848. return (FALSE);
  1849.     if (!xdr_WRAPSTRING (xdrs, &objp->moduleName))
  1850. return (FALSE);
  1851.     if (!xdr_WRAPSTRING (xdrs, &objp->format))
  1852. return (FALSE);
  1853.     if (!xdr_u_long (xdrs, (u_long *)&objp->group))
  1854. return (FALSE);
  1855.     if (!xdr_u_long (xdrs, (u_long *)&objp->nSegments))
  1856. return (FALSE);
  1857.     if (!xdr_int (xdrs, &objp->loadFlag))
  1858. return (FALSE);
  1859.     if (!xdr_array (xdrs, (char **)&objp->segment, (u_int *)&objp->nSegments, 
  1860.     (WTX_MAX_OBJ_SEG_CNT * sizeof (OBJ_SEGMENT)), 
  1861.     sizeof (OBJ_SEGMENT), xdr_OBJ_SEGMENT))
  1862. return (FALSE);
  1864.     return (TRUE);
  1865.     }
  1867. /*******************************************************************************
  1868. *
  1869. * xdr_WTX_MSG_MOD_NAME_OR_ID - object module name or identifier
  1870. *
  1871. */
  1873. bool_t xdr_WTX_MSG_MOD_NAME_OR_ID
  1874.     (
  1875.     XDR *            xdrs,
  1876.     WTX_MSG_MOD_NAME_OR_ID * objp
  1877.     )
  1878.     {
  1879.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1880. return (FALSE);
  1881.     if (!xdr_u_long (xdrs, (u_long *)&objp->moduleId))
  1882. return (FALSE);
  1883.     if (!xdr_WRAPSTRING (xdrs, &objp->filename))
  1884. return (FALSE);
  1886.     return (TRUE);
  1887.     }
  1889. /*******************************************************************************
  1890. *
  1891. * xdr_WTX_MSG_SYM_LIST - symbol list message
  1892. *
  1893. */
  1895. bool_t xdr_WTX_MSG_SYM_LIST
  1896.     (
  1897.     XDR *           xdrs,
  1898.     WTX_MSG_SYM_LIST * objp
  1899.     )
  1900.     {
  1901.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1902. return (FALSE);
  1903.     if (!xdr_WTX_SYM_LIST (xdrs, &objp->symList))
  1904. return (FALSE);
  1905.     if (!xdr_bool (xdrs, (bool_t *)&objp->moreToCome))
  1906. return (FALSE);
  1908.     return (TRUE);
  1909.     }
  1911. /*******************************************************************************
  1912. *
  1913. * xdr_WTX_MSG_SYM_MATCH_DESC - symbol matching information
  1914. *
  1915. */
  1917. bool_t xdr_WTX_MSG_SYM_MATCH_DESC 
  1918.     (
  1919.     XDR *        xdrs,
  1920.     WTX_MSG_SYM_MATCH_DESC *  objp
  1921.     )
  1922.     {
  1923.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1924. return (FALSE);
  1925.     if (!xdr_u_long (xdrs, (u_long *)&objp->symTblId))
  1926. return (FALSE);
  1927.     if (!xdr_bool (xdrs, (bool_t *)&objp->matchString))
  1928. return (FALSE);
  1929.     if (!xdr_TGT_ADDR_T (xdrs, &objp->adrs))
  1930. return (FALSE);
  1931.     if (!xdr_WRAPSTRING (xdrs, &objp->stringToMatch))
  1932. return (FALSE);
  1934.     if (!xdr_bool (xdrs, (bool_t *)&objp->byModuleName)) 
  1935. return (FALSE);
  1937.     /* check if we were given a module name or a module Identifier */
  1939.     if (objp->byModuleName) 
  1940. {
  1941. if (!xdr_WRAPSTRING (xdrs, &objp->module.moduleName))
  1942.     return (FALSE);
  1943. }
  1944.     else
  1945. {
  1946. if (!xdr_u_long (xdrs, (u_long *)&objp->module.moduleId))
  1947.     return (FALSE);
  1948. }
  1950.     if (!xdr_bool (xdrs, (bool_t *)&objp->listUnknownSym))
  1951. return (FALSE);
  1952.     if (!xdr_bool (xdrs, (bool_t *)&objp->giveMeNext))
  1953. return (FALSE);
  1955.     return (TRUE);
  1956.     }
  1958. /*******************************************************************************
  1959. *
  1960. * xdr_WTX_MSG_SYM_TBL_INFO - symbol table information
  1961. *
  1962. */
  1964. bool_t xdr_WTX_MSG_SYM_TBL_INFO
  1965.     (
  1966.     XDR *          xdrs,
  1967.     WTX_MSG_SYM_TBL_INFO * objp
  1968.     )
  1969.     {
  1970.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  1971. return (FALSE);
  1972.     if (!xdr_u_long (xdrs, (u_long *)&objp->symTblId))
  1973. return (FALSE);
  1974.     if (!xdr_u_long (xdrs, (u_long *)&objp->symNum))
  1975. return (FALSE);
  1976.     if (!xdr_bool (xdrs, (bool_t *)&objp->sameNameOk))
  1977. return (FALSE);
  1979.     return (TRUE);
  1980.     }
  1982. /*******************************************************************************
  1983. *
  1984. * xdr_WTX_EVENT_DESC - WTX event descriptor
  1985. *
  1986. */
  1988. bool_t xdr_WTX_EVENT_DESC
  1989.     (
  1990.     XDR *       xdrs,
  1991.     WTX_EVENT_DESC * objp
  1992.     )
  1993.     {
  1994.     if (!xdr_WRAPSTRING (xdrs, &objp->event))
  1995. return (FALSE);
  1996.     if (!xdr_bytes (xdrs, (char **) &objp->addlData, 
  1997.     (u_int *) &objp->addlDataLen, ~0))
  1998. return (FALSE);
  2000.     return (TRUE);
  2001.     }
  2003. /*******************************************************************************
  2004. *
  2005. * xdr_WTX_MSG_EVENT_DESC - WTX event descriptor
  2006. *
  2007. */
  2009. bool_t xdr_WTX_MSG_EVENT_DESC
  2010.     (
  2011.     XDR *       xdrs,
  2012.     WTX_MSG_EVENT_DESC * objp
  2013.     )
  2014.     {
  2015.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2016. return (FALSE);
  2017.     if (!xdr_WTX_EVENT_DESC (xdrs, &objp->eventDesc))
  2018. return (FALSE);
  2020.     return (TRUE);
  2021.     }
  2023. /*******************************************************************************
  2024. *
  2025. * xdr_WTX_MSG_EVENT_REG_DESC - register for event descriptor
  2026. *
  2027. */
  2029. bool_t xdr_WTX_MSG_EVENT_REG_DESC 
  2030.     (
  2031.     XDR *            xdrs,
  2032.     WTX_MSG_EVENT_REG_DESC * objp
  2033.     )
  2034.     {
  2035.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2036. return (FALSE);
  2037.     if (!xdr_WRAPSTRING (xdrs, &objp->evtRegExp))
  2038. return (FALSE);
  2040.     return (TRUE);
  2041.     }
  2043. /*******************************************************************************
  2044. *
  2045. * xdr_WTX_WDB_SERVICE_DESC - service descriptor 
  2046. *
  2047. */
  2049. bool_t xdr_WTX_WDB_SERVICE_DESC
  2050.     (
  2051.     XDR *          xdrs,
  2052.     WTX_WDB_SERVICE_DESC * objp
  2053.     )
  2054.     {
  2055.     if (!xdr_u_int (xdrs, &objp->rpcNum))
  2056. return (FALSE);
  2057.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  2058. return (FALSE);
  2059.     if (!xdr_WRAPSTRING (xdrs, &objp->svcObjFile))
  2060. return (FALSE);
  2061.     if (!xdr_WRAPSTRING (xdrs, &objp->initRtnName))
  2062. return (FALSE);
  2064.     return (TRUE);
  2065.     }
  2067. /*******************************************************************************
  2068. *
  2069. * xdr_WTX_WTX_SERVICE_DESC - service descriptor 
  2070. *
  2071. */
  2073. bool_t xdr_WTX_WTX_SERVICE_DESC
  2074.     (
  2075.     XDR *          xdrs,
  2076.     WTX_WTX_SERVICE_DESC * objp
  2077.     )
  2078.     {
  2079.     if (!xdr_WRAPSTRING (xdrs, &objp->svcObjFile))
  2080. return (FALSE);
  2081.     if (!xdr_WRAPSTRING (xdrs, &objp->svcProcName))
  2082. return (FALSE);
  2083.     if (!xdr_WRAPSTRING (xdrs, &objp->inProcName))
  2084. return (FALSE);
  2085.     if (!xdr_WRAPSTRING (xdrs, &objp->outProcName))
  2086. return (FALSE);
  2088.     return (TRUE);
  2089.     }
  2091. /*******************************************************************************
  2092. *
  2093. * xdr_WTX_MSG_SERVICE_DESC - 
  2094. *
  2095. */
  2097. bool_t xdr_WTX_MSG_SERVICE_DESC 
  2098.     (
  2099.     XDR *            xdrs,
  2100.     WTX_MSG_SERVICE_DESC * objp
  2101.     )
  2102.     {
  2103.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2104. return (FALSE);
  2105.     if (!xdr_pointer (xdrs, (char **)&objp->pWtxServiceDesc,
  2106.       sizeof (WTX_WTX_SERVICE_DESC), 
  2107.       xdr_WTX_WTX_SERVICE_DESC))
  2108. return (FALSE);
  2109.     if (!xdr_pointer (xdrs, (char **)&objp->pWdbServiceDesc,
  2110.       sizeof (WTX_WDB_SERVICE_DESC), 
  2111.       xdr_WTX_WDB_SERVICE_DESC))
  2112. return (FALSE);
  2114.     return (TRUE);
  2115.     }
  2117. /*******************************************************************************
  2118. *
  2119. * xdr_WTX_MSG_SERVICE_LIST - list of protocol services
  2120. *
  2121. */
  2123. bool_t xdr_WTX_MSG_SERVICE_LIST 
  2124.     (
  2125.     XDR *          xdrs,
  2126.     WTX_MSG_SERVICE_LIST * objp
  2127.     )
  2128.     {
  2129.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2130. return (FALSE);
  2131.     if (!xdr_u_long (xdrs, (u_long *)&objp->nServices))
  2132. return (FALSE);
  2133.     if (!xdr_array (xdrs, (char **)&objp->serviceDesc, 
  2134.     (u_int *)&objp->nServices, 
  2135.     (WTX_MAX_SERVICE_CNT * sizeof (WTX_WDB_SERVICE_DESC)), 
  2136.     sizeof (WTX_WDB_SERVICE_DESC), xdr_WTX_WDB_SERVICE_DESC))
  2137. return (FALSE);
  2139.     return (TRUE);
  2140.     }
  2142. /*******************************************************************************
  2143. *
  2144. * xdr_WTX_CONSOLE_DESC - WTX console descriptor
  2145. *
  2146. */
  2148. bool_t xdr_WTX_CONSOLE_DESC 
  2149.     (
  2150.     XDR *          xdrs,
  2151.     WTX_CONSOLE_DESC * objp
  2152.     )
  2153.     {
  2154.     if (!xdr_int (xdrs, &objp->fdIn))
  2155. return (FALSE);
  2156.     if (!xdr_int (xdrs, &objp->fdOut))
  2157. return (FALSE);
  2158.     if (!xdr_int (xdrs, &objp->pid))
  2159. return (FALSE);
  2160.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  2161. return (FALSE);
  2162.     if (!xdr_WRAPSTRING (xdrs, &objp->display))
  2163. return (FALSE);
  2165.     return (TRUE);
  2166.     }
  2168. /*******************************************************************************
  2169. *
  2170. * xdr_WTX_MSG_CONSOLE_DESC - WTX console descriptor message
  2171. *
  2172. */
  2174. bool_t xdr_WTX_MSG_CONSOLE_DESC 
  2175.     (
  2176.     XDR *          xdrs,
  2177.     WTX_MSG_CONSOLE_DESC * objp
  2178.     )
  2179.     {
  2180.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2181. return (FALSE);
  2182.     if (!xdr_WTX_CONSOLE_DESC (xdrs, &objp->wtxConsDesc))
  2183. return (FALSE);
  2185.     return (TRUE);
  2186.     }
  2188. /*******************************************************************************
  2189. *
  2190. * xdr_WTX_MSG_MEM_INFO - target server memory information
  2191. *
  2192. */
  2194. bool_t xdr_WTX_MSG_MEM_INFO 
  2195.     (
  2196.     XDR *   xdrs,
  2197.     WTX_MSG_MEM_INFO * objp
  2198.     )
  2199.     {
  2200.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2201. return (FALSE);
  2203.     if (!xdr_u_long (xdrs, (u_long *)&objp->curBytesFree))
  2204. return (FALSE);
  2205.     if (!xdr_u_long (xdrs, (u_long *)&objp->curBytesAllocated))
  2206. return (FALSE);
  2207.     if (!xdr_u_long (xdrs, (u_long *)&objp->cumBytesAllocated))
  2208. return (FALSE);
  2209.     if (!xdr_u_long (xdrs, (u_long *)&objp->curBlocksFree))
  2210. return (FALSE);
  2211.     if (!xdr_u_long (xdrs, (u_long *)&objp->curBlocksAlloc))
  2212. return (FALSE);
  2213.     if (!xdr_u_long (xdrs, (u_long *)&objp->cumBlocksAlloc))
  2214. return (FALSE);
  2215.     if (!xdr_u_long (xdrs, (u_long *)&objp->avgFreeBlockSize))
  2216. return (FALSE);
  2217.     if (!xdr_u_long (xdrs, (u_long *)&objp->avgAllocBlockSize))
  2218. return (FALSE);
  2219.     if (!xdr_u_long (xdrs, (u_long *)&objp->cumAvgAllocBlockSize))
  2220. return (FALSE);
  2221.     if (!xdr_u_long (xdrs, (u_long *)&objp->biggestBlockSize))
  2222. return (FALSE);
  2224.     return (TRUE);
  2225.     }
  2227. /*******************************************************************************
  2228. *
  2229. * xdr_WTX_CORE - xdr routine for wtx core
  2230. */
  2232. bool_t xdr_WTX_CORE
  2233.     (
  2234.     XDR * xdrs,
  2235.     WTX_CORE * objp
  2236.     )
  2237.     {
  2238.     if (!xdr_u_long (xdrs, (u_long *)&objp->objId))
  2239. return (FALSE);
  2240.     if (!xdr_u_long (xdrs, (u_long *)&objp->errCode))
  2241. return (FALSE);
  2242.     if (!xdr_u_long (xdrs, (u_long *)&objp->protVersion))
  2243. return (FALSE);
  2245.     return (TRUE);
  2246.     }
  2248. /*******************************************************************************
  2249. *
  2250. * xdr_WTX_SVR_DESC - xdr routine for wtx descriptor
  2251. */
  2253. bool_t xdr_WTX_SVR_DESC
  2254.     (
  2255.     XDR * xdrs,
  2256.     WTX_SVR_DESC * objp
  2257.     )
  2258.     {
  2259.     if (!xdr_WRAPSTRING (xdrs, &objp->wpwrName))
  2260. return (FALSE);
  2261.     if (!xdr_WRAPSTRING (xdrs, &objp->wpwrType))
  2262. return (FALSE);
  2263.     if (!xdr_WRAPSTRING (xdrs, &objp->wpwrKey))
  2264. return (FALSE);
  2266.     return (TRUE);
  2267.     }
  2269. /*******************************************************************************
  2270. *
  2271. * xdr_WTX_MSG_SVR_DESC - xdr routine for wtx descriptor
  2272. */
  2274. bool_t xdr_WTX_MSG_SVR_DESC
  2275.     (
  2276.     XDR * xdrs,
  2277.     WTX_MSG_SVR_DESC * objp
  2278.     )
  2279.     {
  2280.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2281. return (FALSE);
  2283.     if (!xdr_WTX_SVR_DESC (xdrs, &objp->wtxSvrDesc))
  2284. return (FALSE);
  2286.     return (TRUE);
  2287.     }
  2289. /*******************************************************************************
  2290. *
  2291. * xdr_WTX_SVR_DESC_Q - xdr routine for wtx all descriptor
  2292. */
  2294. bool_t xdr_WTX_SVR_DESC_Q
  2295.     (
  2296.     XDR * xdrs,
  2297.     WTX_SVR_DESC_Q * objp
  2298.     )
  2299.     {
  2300.     if (!xdr_WTX_SVR_DESC (xdrs, &objp->wtxSvrDesc))
  2301. return (FALSE);
  2302.     if (!xdr_pointer (xdrs, (char **)&objp->pNext, sizeof (WTX_SVR_DESC_Q), 
  2303.       xdr_WTX_SVR_DESC_Q))
  2304. return (FALSE);
  2306.     return (TRUE);
  2307.     }
  2309. /*******************************************************************************
  2310. *
  2311. * xdr_WTX_MSG_SVR_DESC - xdr routine for wtx descriptor
  2312. */
  2314. bool_t xdr_WTX_MSG_SVR_DESC_Q
  2315.     (
  2316.     XDR * xdrs,
  2317.     WTX_MSG_SVR_DESC_Q * objp
  2318.     )
  2319.     {
  2320.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2321. return (FALSE);
  2323.     if (!xdr_WTX_SVR_DESC_Q (xdrs, &objp->wtxSvrDescQ))
  2324. return (FALSE);
  2326.     return (TRUE);
  2327.     }
  2329. /*******************************************************************************
  2330. *
  2331. * xdr_WTX_MSG_WTXREGD_PATTERN - xdr routine for WindPower deamon pattern
  2332. */
  2334. bool_t xdr_WTX_MSG_WTXREGD_PATTERN
  2335.     (
  2336.     XDR * xdrs,
  2337.     WTX_MSG_WTXREGD_PATTERN * objp
  2338.     )
  2339.     {
  2340.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2341. return (FALSE);
  2343.     if (!xdr_WRAPSTRING (xdrs, &objp->name))
  2344. return (FALSE);
  2345.     if (!xdr_WRAPSTRING (xdrs, &objp->type))
  2346. return (FALSE);
  2347.     if (!xdr_WRAPSTRING (xdrs, &objp->key))
  2348. return (FALSE);
  2350.     return (TRUE);
  2351.     }
  2353. /******************************************************************************
  2354. *
  2355. * xdr_WTX_GOPHER_TAPE -
  2356. */
  2358. static bool_t xdr_WTX_GOPHER_TAPE
  2359.     (
  2360.     XDR * xdrs,
  2361.     WTX_GOPHER_TAPE * objp
  2362.     )
  2363.     {
  2364.     u_int len = objp->len;
  2366.     if (!xdr_u_short (xdrs, &objp->len))
  2367. return (FALSE);
  2368.     if (!xdr_bytes (xdrs, &objp->data, &len, ~0))
  2369. return (FALSE);
  2371.     return (TRUE);
  2372.     }
  2374. /******************************************************************************
  2375. *
  2376. * xdr_WTX_MSG_GOPHER_TAPE -
  2377. */
  2379. bool_t xdr_WTX_MSG_GOPHER_TAPE
  2380.     (
  2381.     XDR * xdrs,
  2382.     WTX_MSG_GOPHER_TAPE * objp
  2383.     )
  2384.     {
  2385.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2386. return (FALSE);
  2387.     if (!xdr_WTX_GOPHER_TAPE  (xdrs, &objp->tape))
  2388. return (FALSE);
  2390.     return (TRUE);
  2391.     }
  2393. /*******************************************************************************
  2394. *
  2395. * xdr_WTX_MSG_DASM_DESC - XDR WTX_MSG_DASM_DESC transfer routine
  2396. *
  2397. */
  2399. bool_t xdr_WTX_MSG_DASM_DESC 
  2400.     (
  2401.     XDR *        xdrs,
  2402.     WTX_MSG_DASM_DESC *  objp
  2403.     )
  2404.     {
  2405.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2406. return (FALSE);
  2407.     if (!xdr_TGT_ADDR_T (xdrs, &objp->startAddr))
  2408. return (FALSE);
  2409.     if (!xdr_u_long (xdrs, (u_long *)&objp->nInst))
  2410. return (FALSE);
  2411.     if (!xdr_TGT_ADDR_T (xdrs, &objp->endAddr))
  2412. return (FALSE);
  2413.     if (!xdr_bool (xdrs, (bool_t *)&objp->printAddr))
  2414. return (FALSE);
  2415.     if (!xdr_bool (xdrs, (bool_t *)&objp->printOpcodes))
  2416. return (FALSE);
  2417.     if (!xdr_bool (xdrs, (bool_t *)&objp->hexAddr))
  2418. return (FALSE);
  2419.     if (!xdr_bool (xdrs, (bool_t *)&objp->giveMeNext))
  2420. return (FALSE);
  2422.     return (TRUE);
  2423.     }
  2425. /*******************************************************************************
  2426. *
  2427. * xdr_WTX_MSG_DASM_INST_LIST - XDR WTX_MSG_DASM_INST_LIST transfer routine
  2428. *
  2429. */
  2431. bool_t xdr_WTX_MSG_DASM_INST_LIST
  2432.     (
  2433.     XDR * xdrs,
  2434.     WTX_MSG_DASM_INST_LIST * objp
  2435.     )
  2436.     {
  2437.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2438. return (FALSE);
  2439.     if (!xdr_WRAPSTRING (xdrs, &objp->instList.pInst))
  2440. return (FALSE);
  2441.     if (!xdr_u_long (xdrs, (u_long *) &objp->instList.nextInst))
  2442. return (FALSE);
  2443.     if (!xdr_u_long (xdrs, (u_long *) &objp->instList.listSize))
  2444. return (FALSE);
  2445.     if (!xdr_bool (xdrs, (bool_t *) &objp->moreToCome))
  2446. return (FALSE);
  2448.     return (TRUE);
  2449.     }
  2451. /******************************************************************************
  2452. *
  2453. * xdr_WTX_EVENT_NODE -
  2454. */
  2455. bool_t xdr_WTX_EVENT_NODE
  2456.     (
  2457.     XDR *             xdrs,
  2458.     WTX_EVENT_NODE *  objp
  2459.     )
  2460.     {
  2461.     if (!xdr_WTX_EVENT_DESC (xdrs, &objp->event))
  2462.         return (FALSE);
  2463.     if (!xdr_pointer (xdrs, (char **)&objp->pNext, sizeof (WTX_EVENT_NODE),
  2464.                       xdr_WTX_EVENT_NODE))
  2465.         return (FALSE);
  2467.     return (TRUE);
  2468.     }
  2470. /******************************************************************************
  2471. *
  2472. * xdr_MSG_EVENT_LIST -
  2473. *
  2474. */
  2476. bool_t xdr_WTX_MSG_EVENT_LIST
  2477.     (
  2478.     XDR *                  xdrs,
  2479.     WTX_MSG_EVENT_LIST *   objp
  2480.     )
  2481.     {
  2482.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2483.         return (FALSE);
  2484.     if (!xdr_pointer(xdrs, (char **)&objp->pEventList,
  2485.                      sizeof(WTX_EVENT_NODE), xdr_WTX_EVENT_NODE))
  2486.         return (FALSE);
  2488.     return (TRUE);
  2489.     }
  2491. /*******************************************************************************
  2492. *
  2493. * xdr_WTX_MSG_FILE_LOAD_DESC -
  2494. *
  2495. */
  2497. bool_t xdr_WTX_MSG_FILE_LOAD_DESC
  2498.     (
  2499.     XDR *       xdrs,
  2500.     WTX_MSG_FILE_LOAD_DESC * objp
  2501.     )
  2502.     {
  2503.     /* Buffer where to decode data */
  2505.     char * buff;
  2507.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2508.         return (FALSE);
  2509.     if (!xdr_u_long (xdrs, (u_long *)&objp->flags))
  2510. return (FALSE);
  2512.     if (!xdr_WTX_LD_M_FILE_DESC (xdrs, &objp->fileDesc))
  2513.         return (FALSE);
  2514.     if (!xdr_u_long (xdrs, (u_long *)&objp->buffer))
  2515.         return (FALSE);
  2516.     if (!xdr_int (xdrs, &objp->numItems))
  2517.         return (FALSE);
  2518.     if (!xdr_int (xdrs, &objp->fileSize))
  2519.         return (FALSE);
  2520.     if (!xdr_int (xdrs, &objp->numPacket))
  2521.         return (FALSE);
  2523.     switch (xdrs->x_op)
  2524.         {
  2525.         case XDR_DECODE:
  2526.             {
  2527.     if (objp->numItems != 0)
  2528. {
  2529. /* Export block */
  2531. if ((buff = (char *) malloc (objp->numItems)) == NULL)
  2532.     return (FALSE);
  2534. if (!xdr_opaque (xdrs, (char *) buff, objp->numItems))
  2535.     return (FALSE);
  2537. /*
  2538.  * Save the allocated buffer address in objp->destination for
  2539.  * later use by the client.
  2540.  */
  2542. objp->buffer = (char *) buff;
  2543. }
  2544.     else
  2545. objp->buffer = NULL;
  2547.     return (TRUE);
  2548.     }
  2550.         case XDR_ENCODE:
  2551.     {
  2552.     if (objp->numItems != 0)
  2553. {
  2554. if (!xdr_opaque (xdrs, (char *) objp->buffer, objp->numItems))
  2555.     return (FALSE);
  2556. }
  2558.     return (TRUE);
  2559.     }
  2561.         case XDR_FREE:
  2562.             {
  2563.             /* Free memory */
  2565.             free (objp->buffer);
  2566.             return (TRUE);
  2567.             }
  2568.         }
  2570.     return (FALSE);
  2571.     }
  2573. /*******************************************************************************
  2574. *
  2575. * xdr_WTX_LD_M_FILE_DESC - multiple section object file
  2576. *
  2577. */
  2579. bool_t xdr_WTX_LD_M_FILE_DESC
  2580.     (
  2581.     XDR *       xdrs,
  2582.     WTX_LD_M_FILE_DESC * objp
  2583.     )
  2584.     {
  2585.     if (!xdr_WRAPSTRING (xdrs, &objp->filename))
  2586.         return (FALSE);
  2587.     if (!xdr_int (xdrs, &objp->loadFlag))
  2588.         return (FALSE);
  2589.     if (!xdr_u_long (xdrs, (u_long *)&objp->moduleId))
  2590.         return (FALSE);
  2591.     if (!xdr_u_long (xdrs, (u_long *)&objp->nSections))
  2592.         return (FALSE);
  2593.     if (!xdr_array (xdrs, (char **)&objp->section, (u_int *)&objp->nSections,
  2594.                     (WTX_MAX_SECTION_CNT * sizeof (LD_M_SECTION)),
  2595.                     sizeof (LD_M_SECTION), xdr_LD_M_SECTION))
  2596.         return (FALSE);
  2597.     if (!xdr_WTX_SYM_LIST (xdrs, &objp->undefSymList))
  2598.         return (FALSE);
  2600.     return (TRUE);
  2601.     }
  2603. /*******************************************************************************
  2604. *
  2605. * xdr_WTX_EVENT_2 - WTX
  2606. *
  2607. */
  2609. bool_t xdr_WTX_EVENT_2
  2610.     (
  2611.     XDR *        xdrs,
  2612.     WTX_EVENT_2 * objp
  2613.     )
  2614.     {
  2615.     if (!xdr_enum (xdrs, (enum_t *)&objp->eventType))
  2616.         return (FALSE);
  2618.     if (!xdr_u_long (xdrs, (u_long *)&objp->numArgs))
  2619.         return (FALSE);
  2621.     if (!xdr_array (xdrs, (char **)&objp->args, &objp->numArgs,
  2622.                     ~0, sizeof (u_long), xdr_u_long))
  2623.         return (FALSE);
  2625.     return (TRUE);
  2626.     }
  2628. /*******************************************************************************
  2629. *
  2630. * xdr_WTX_EVTPT_2 - WTX
  2631. *
  2632. */
  2634. bool_t xdr_WTX_EVTPT_2
  2635.     (
  2636.     XDR *        xdrs,
  2637.     WTX_EVTPT_2 * objp
  2638.     )
  2639.     {
  2640.     if (!xdr_WTX_EVENT_2 (xdrs, &objp->event))
  2641.         return (FALSE);
  2642.     if (!xdr_WTX_CONTEXT (xdrs, &objp->context))
  2643.         return (FALSE);
  2644.     if (!xdr_WTX_ACTION (xdrs, &objp->action))
  2645.         return (FALSE);
  2647.     return (TRUE);
  2648.     }
  2650. /*******************************************************************************
  2651. *
  2652. * xdr_WTX_MSG_EVTPT_DESC_2 - WTX
  2653. *
  2654. */
  2656. bool_t xdr_WTX_MSG_EVTPT_DESC_2
  2657.     (
  2658.     XDR *        xdrs,
  2659.     WTX_MSG_EVTPT_DESC_2 * objp
  2660.     )
  2661.     {
  2662.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2663.         return (FALSE);
  2664.     if (!xdr_WTX_EVTPT_2 (xdrs, &objp->wtxEvtpt))
  2665.         return (FALSE);
  2667.     return (TRUE);
  2668.     }
  2670. /*******************************************************************************
  2671. *
  2672. * xdr_WTX_EVTPT_INFO - eventpoint info
  2673. *
  2674. */
  2676. bool_t xdr_WTX_EVTPT_INFO
  2677.     (
  2678.     XDR * xdrs,
  2679.     WTX_EVTPT_INFO * objp
  2680.     )
  2681.     {
  2682.     if (!xdr_WTX_EVTPT_2 (xdrs, &objp->wtxEvtpt))
  2683.         return (FALSE);
  2684.     if (!xdr_u_long (xdrs, (u_long *)&objp->toolId))
  2685.         return (FALSE);
  2686.     if (!xdr_u_long (xdrs, (u_long *)&objp->evtptNum))
  2687.         return (FALSE);
  2688.     if (!xdr_u_long (xdrs, (u_long *)&objp->pReserved1))
  2689.         return (FALSE);
  2690.     if (!xdr_u_long (xdrs, (u_long *)&objp->pReserved2))
  2691.         return (FALSE);
  2693.     return (TRUE);
  2694.     }
  2696. /*******************************************************************************
  2697. *
  2698. * xdr_WTX_MSG_EVTPT_LIST_2 - eventpoint list
  2699. *
  2700. */
  2702. bool_t xdr_WTX_MSG_EVTPT_LIST_2
  2703.     (
  2704.     XDR * xdrs,
  2705.     WTX_MSG_EVTPT_LIST_2 * objp
  2706.     )
  2707.     {
  2708.     if (!xdr_WTX_CORE (xdrs, &objp->wtxCore))
  2709.         return (FALSE);
  2710.     if (!xdr_u_long (xdrs, (u_long *)&objp->nEvtpt))
  2711.         return (FALSE);
  2712.     if (!xdr_array (xdrs, (char **)&objp->pEvtptInfo, (u_int *)&objp->nEvtpt,
  2713.                     ~0, sizeof (WTX_EVTPT_INFO), xdr_WTX_EVTPT_INFO))
  2714.         return (FALSE);
  2716.     return (TRUE);
  2717.     }