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

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

VxWorks

开发平台：

C/C++

wtxrpc.c：源码内容
  1. /* wtxrpc.c - tornado rpc transport library */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02w,28sep01,fle  SPR#28684 : added usePMap parameter to ExchangeCreate ()
  10.                  routines
  11. 02v,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. 02u,19apr00,fle  SPR#28684 : Win32 port
  15. 02t,29mar00,fle  SPR#28684 : HPUX port
  16. 02s,24nov99,fle  SPR#28684 fix : multiple adapters in target server connection
  17. 02r,10may99,fle  made wtxRpcExchangeFree not use CLIENT anymore
  18. 02q,24mar99,fle  made WIN32 code also use auth_destroy mechanism (SPR#26002)
  19. 02p,07jan99,c_c  Let the target use the hard-coded Registry port number (SPR
  20.                  #23681 and #23449).
  21. 02o,21oct98,c_c  replaced a getenv by a wpwrGetEnv to be sure that
  22.                  WIND_REGISTRY is set.
  23. 02n,18aug98,pcn  Re-use xdr_WTX_MSG_EVTPT_LIST_2.
  24. 02m,11jun98,pcn  Added an input parameter at wtxEventListGet.
  25. 02l,26may98,pcn  Changed WTX_MSG_EVTPT_LIST_2 in WTX_MSG_EVTPT_LIST_GET.
  26. 02k,25mar98,dbt  added WTX_CONTEXT_STATUS_GET.
  27. 02j,24mar98,fle  Adapted wtxrpcKey to NULL transport handle mangement.
  28. 02i,24mar98,c_c  Get rid of portmapper.
  29. 02h,17mar98,jmb  merge HPSIM patch by jmb from 19aug97:
  30.  added socket option call to prevent target server sync task
  31.  from hanging when retrieving symbols from host. (SPR 8708)
  32. 02g,03mar98,fle  got rid of WTX_REGISTRY_PING service
  33.  + got rid of regex uses
  34. 02f,02mar98,pcn  WTX 2: Removed WTX_UN_REGIS_FOR_EVENT. Added
  35.                  WTX_UNREGISTER_FOR_EVENT, WTX_CACHE_TEXT_UPDATE,
  36.                  WTX_MEM_WIDTH_READ, WTX_MEM_WIDTH_WRITE, WTX_COMMAND_SEND,
  37.                  WTX_OBJ_MODULE_CHECKSUM, WTX_EVENT_LIST_GET,
  38.                  WTX_OBJ_MODULE_LOAD_2, WTX_EVENTPOINT_ADD_2,
  39.                  WTX_EVENTPOINT_LIST_2, WTX_OBJ_MODULE_UNLOAD_2.
  40. 02e,06feb98,c_c  Undo the last remove.
  41. 02d,05feb98,c_c  Removed an extra include "regex.h".
  42. 02c,04feb98,lcs  relocate #ifdef to repair damages
  43. 02b,03feb98,lcs  remove static variable declarations
  44. 02a,03feb98,lcs  use regex.h for WIN32 & </usr/include/regex.h> for UNIX
  45. 01z,26jan98,fle  added WTX_REGISTRY_PING routine
  46. 01y,20nov97,fle  added WTX_MEM_DISASSEMBLE service
  47. 01x,25feb97,elp  added valid machname in authunix_create() call (SPR# 7959).
  48. 01w,30sep96,elp  put in share, adapted to be compiled on target side SPR# 6775.
  49. 01v,28jun96,c_s  tweaks for AIX.
  50. 01u,09dec95,wmd  used authunix_create() call to pass uid explicity for WIN32,
  51.                  to fix SPR# 5609.
  52. 01t,27oct95,p_m  fixed SPR# 5196 by using the pid to generate the base
  53.  RPC program number (Unix only).
  54. 01s,26oct95,p_m  added WTX_AGENT_MODE_GET and WTX_DIRECT_CALL.
  55. 01r,24oct95,wmd  fixed so that processing delays caused by timeout in call
  56.                  to hostbyname() is eliminated, spr #5084, 
  57. 01q,14jun95,s_w  return WTX_ERR_EXCHANGE_NO_SERVER if client create fails.
  58. 01p,08jun95,c_s  added WTX_TARGET_ATTACH to rpc function list.
  59. 01o,01jun95,p_m  changed WTX_FUNC_CALL to use xdr_WTX_MSG_CONTEXT_DESC.
  60. 01n,30may95,p_m  completed WTX_MEM_SCAN and WTX_MEM_MOVE implementation.
  61. 01m,30may95,c_s  portablity tweak: use struct in_addr with inet_ntoa().
  62. 01l,30may95,c_s  added dotted-decimal IP address to key
  63. 01k,23may95,s_w  don't setup or destroy authentication for WIN32
  64. 01j,23may95,p_m  made missing name changes.
  65. 01i,22may95,s_w  update RPC server table for new WTX_MSG_OBJ_KILL in args
  66.  and add WTX_MSG_VIO_CHAN_GET/RELEASE messages.
  67. 01h,22may95,jcf  name revision.
  68. 01g,19may95,jcf  changed over to WIND_REGISTRY.
  69. 01g,18may95,jcf  changed over to TORNADO_REGISTRY.
  70. 01f,14may95,s_w  add in exchange functions for use by C API (wtx.c). Tidy
  71.  up rouintes to use types from host.h and make all routines
  72.  use status and error codes rather than print error messages.
  73. 01e,23feb95,p_m  took care of WIN32 platform.
  74. 01d,14feb95,p_m  changed S_wtx_ to WTX_ERR_ .
  75. 01c,22jan95,c_s  fixed memory leak.
  76. 01b,20jan95.jcf  made more portable.
  77. 01a,24dec94,c_s  written.
  78. */
  80. /* includes */
  82. #ifdef HOST
  83. #include "wpwrutil.h"
  84. #include "wtxrpc.h"
  85. #include "private/wtxexchp.h"
  86. #include "wtxmsg.h"
  87. #include "wtxxdr.h"
  89. #if defined(RS6000_AIX4) || defined (RS6000_AIX3)
  90. #undef malloc
  91. #endif
  93. #include <stdlib.h>
  94. #include <stdio.h>
  95. #include <string.h>
  96. #include <errno.h>
  98. #include <sys/param.h>
  99. #include <sys/socket.h>
  100. #include <sys/ioctl.h>
  101. #include <netdb.h>
  102. #include <arpa/inet.h>
  104. #ifdef SUN4_SOLARIS2
  105. #   include <sys/sockio.h>
  106. #endif /* SUN4_SOLARIS2 */
  108. #ifndef WIN32
  109. #   include <net/if.h>
  110. #endif /* ! WIN32 */
  112. #include <netinet/in.h>
  113. #include <unistd.h>
  115. #else
  116. #include "hostLib.h"
  117. #include "arpa/inet.h"
  118. #include "socket.h"
  120. #include "string.h"
  121. #include "stdio.h"
  122. #include "stdlib.h"
  123. #include "errno.h"
  124. #include "wtx.h"
  126. #include "wtxrpc.h"
  127. #include "private/wtxexchp.h"
  128. #include "wtxmsg.h"
  129. #include "wtxxdr.h"
  130. #if (CPU==SIMHPPA)
  131. #include "wdb/wdbLibP.h"
  132. #include "sockLib.h"
  133. #endif /* (CPU==SIMHPPA) */
  134. #endif /* HOST */
  137. /* typedefs */
  139. typedef struct rpc_service
  140.     {
  141.     xdrproc_t xdrIn;
  142.     xdrproc_t xdrOut;
  143.     } RPC_SERVICE;
  145. #ifndef HOST
  146. /* globals */
  148. UINT32 syncRegistry; /* inet registry address */
  149. struct opaque_auth  authCred; /* address of the authentication info */
  150. #endif /* HOST */
  152. #ifndef MCALL_MSG_SIZE
  153. #define MCALL_MSG_SIZE 24 /* marshalled call message */
  154. #endif /* MCALL_MSG_SIZE */
  156. /* locals */
  158. LOCAL RPC_SERVICE * (*rpcSvcTable)[] = NULL;
  159. LOCAL UINT32 rpcSvcTableSize = 0;
  160. LOCAL XDR svrXdrs; /* server XDR struct  */
  161. LOCAL char svrXdrsMCall[MCALL_MSG_SIZE]; /* marshalled callmsg */
  163. /* This is the UDP retry timeout used when creating a UDP service connection */
  165. LOCAL struct timeval rpcDefaultUdpTimeout = { 5, 0 };
  167. /* forward declarations */
  169. LOCAL WTX_ERROR_T rpcStatToError /* convert RPC status to WTX err code */
  170.     (
  171.     enum clnt_stat rpcStat /* status from call */
  172.     );
  174. LOCAL STATUS rpcSvcTableInstall (void); /* install initial service table */
  176. LOCAL STATUS rpcSvcAdd /* add new key in exchange svc table */
  177.     (
  178.     UINT32 svcNum, /* service number */
  179.     xdrproc_t xdrIn, /* XDR input procedure */
  180.     xdrproc_t xdrOut /* XDR output procedure */
  181.     );
  183. LOCAL char * wtxRpcKeyFromRpcKeySplitGet /* get rpc key from structure */
  184.     (
  185.     WTX_RPC_SPLIT_KEY * pSplitKey /* splitted key to create key from    */
  186.     );
  188. LOCAL int wtxRpcKeyIPListSizeGet /* get the number of IP adapters      */
  189.     (
  190.     WTX_RPC_SPLIT_KEY * pSplitKey /* splitted RPC key desc              */
  191.     );
  194. /******************************************************************************
  195. *
  196. * wtxRpcSvcUnregister - perform svc_unregister using RPC key string
  197. *
  198. * This routine will unregister the specified RPC service with svc_unregister.
  199. * This routine will not destroy the service.
  200. *
  201. * RETURNS: WTX_OK, or WTX_ERROR if invalid key.
  202. */
  204. STATUS wtxRpcSvcUnregister
  205.     (
  206.     const char * rpcKey /* service key for service to unregister */
  207.     )
  208.     {
  209.     WTX_RPC_SPLIT_KEY splitKey;
  211.     if (wtxRpcKeySplit (rpcKey, &splitKey) != WTX_OK) /* split the key */
  212. return (WTX_ERROR);
  214.     svc_unregister (splitKey.progNum, splitKey.version);
  216.     wtxRpcKeySplitFree (&splitKey);
  217.     return (WTX_OK);
  218.     }
  220. /******************************************************************************
  221. *
  222. * wtxRpcKey - construct an RPC key string given RPC parameters.
  223. *
  224. * An RPC key string is built from the given progNum, version, and protocol
  225. * code.  The format of the string is
  226. * 
  227. *     rpc/<hostname>/<ip-addr>/<progNum>/<version>|<tcp|udp>/<port#>
  228. *
  229. * The hostname is found from the OS.
  230. *
  231. * RETURNS:
  232. * The constructed RPC key string, or NULL if the input data does not represent
  233. * a valid RPC server address or memory for the string could not be allocated.
  234. * The storage for the string should be freed with free() when it is no longer
  235. * needed.
  236. */
  238. char *wtxRpcKey
  239.     (
  240.     UINT32 progNum, /* rpc prog number, or NULL TBA */
  241.     UINT32 version, /* rpc version number */
  242.     UINT32 protocol, /* IPPROTO_TCP or IPPROTO_UDP */
  243.     void (* dispatch)  /* rpc dispatch routine */
  244. (struct svc_req *, SVCXPRT *),
  245.     BOOL register2pmap, /* Do we register to the local portmapper ? */
  246.     SVCXPRT ** ppNewXprt /* where to return transport */
  247.     )
  248.     {
  249. #if (!defined SUN4_SOLARIS2)
  250.     struct in_addr ina; /* inet address               */
  251. #endif /* ! SUN4_SOLARIS2 */
  252.     SVCXPRT * newXprt = NULL; /* transport we make          */
  253.     UINT32  rpcProgNum; /* hunted rpc program num     */
  254.     UINT32 svc_protocol; /* protocol sent to the       */
  255. /* svc_register ()            */
  256.     char *  ipAddrStr = NULL; /* string IP addr (a.b.c.d)   */
  257.     char * newKey = NULL; /* final key (malloc'd)       */
  258.     char hostName [MAXHOSTNAMELEN]; /* our host name              */
  259.     char buf [256]; /* accumulates key string     */
  260.     int newKeyLen = 0; /* new key string length      */
  262. #ifdef HOST
  263.     BOOL firstAddress = TRUE; /* first inet address ?       */
  264.     int inetLen = 0; /* iet address string length  */
  265.     #ifdef WIN32
  266.     struct hostent * pHostEnt; /* contains our IP addr       */
  267.     char ** addrList = NULL; /* address list               */
  268.     char * inetAddr = NULL; /* address from inet_ntoa()   */
  269.     #else
  270.     struct sockaddr_in addr; /* socket address definition  */
  271.     struct ifconf ifc; /* if config result           */
  272.     struct ifreq ifReq; /* current if config request  */
  273.     struct ifreq * ifr = NULL; /* if config request result   */
  274.     char ifBuf [BUFSIZ]; /* if config container        */
  275.     char ipAddr [16]; /* current IP string          */
  276.     int addrLen = 0; /* current address length     */
  277.     int len = 0; /* adress counter for loop    */
  278.     int s = 0; /* connection socket          */
  279.     #endif /* WIN32 */
  280. #endif /* HOST */
  282.     /* sanity check progNum >= 0, version > 0, and IPPROTO_TCP or IPPROTO_UDP */
  284.     if (((protocol != IPPROTO_TCP) && (protocol != IPPROTO_UDP)) ||
  285. ((progNum == 0) && (dispatch == NULL)))
  286. goto error1;
  288.     if (progNum == 0) /* hunt for prog num */
  289. {
  290. if (protocol == IPPROTO_TCP)
  291.     newXprt = svctcp_create (RPC_ANYSOCK, 0, 0);
  292. else
  293.     newXprt = svcudp_create (RPC_ANYSOCK);
  295. if (! newXprt) /* service kaput! */
  296.     goto error1;
  298. /*
  299.  * In order to limit the number of times a Target Server can
  300.  * get the RPC program number of a just killed (with kill -9)
  301.  * Target Server we introduce a little bit of random here (SPR# 5196).
  302.  */
  304. #if defined(WIN32) || !defined(HOST)
  306. rpcProgNum = WTX_SVC_BASE;
  307. #else /* WIN32 */
  309. rpcProgNum = WTX_SVC_BASE + ((int) getpid () & 0xff);
  310. #endif /* WIN32 */
  312. /*
  313.  * If we don't want to register ourself to the local portmapper, set the
  314.  * protocol to 0 before calling svc_register ().
  315.  */
  317. svc_protocol = register2pmap?protocol:0;
  319. while (!svc_register (newXprt, ++rpcProgNum, version, dispatch,
  320.       svc_protocol))
  321.     if (rpcProgNum >= WTX_SVC_BASE + WTX_MAX_SERVICE_CNT)
  322. goto error1;
  324. if (ppNewXprt) /* return transport? */
  325.     *ppNewXprt = newXprt;
  327. progNum = rpcProgNum; /* store prog num */
  328. }
  330.     /* Key format: "rpc/host/ip/port/prog/version/{tcp,udp}" */
  332.     gethostname (hostName, sizeof (hostName)); /* where are we? */
  334. #ifdef HOST
  336.     #ifdef WIN32
  337.     if ((pHostEnt = gethostbyname (hostName))) /* know our IP addr? */
  338. {
  339. /* get the size of the cumulative adapters string */
  341. for (addrList = pHostEnt->h_addr_list ; *addrList != NULL ; addrList ++)
  342.     {
  343.     memcpy (&ina.s_addr, *addrList, sizeof (ina.s_addr));
  345.     if ( (inetAddr = inet_ntoa (ina)) != NULL)
  346. inetLen += strlen (inetAddr) + 1;
  347.     }
  349. /* allocate memory for the IP addresses string */
  351. if ( (ipAddrStr = (char *) calloc (inetLen, sizeof (char))) == NULL)
  352.     goto error1;
  354. /* now concat all the IP addresses in one string separeted with ',' */
  356. firstAddress = TRUE;
  358. for (addrList = pHostEnt->h_addr_list ; *addrList != NULL ; addrList ++)
  359.     {
  360.     memcpy (&ina.s_addr, *addrList, sizeof (ina.s_addr));
  362.     if (firstAddress)
  363. {
  364. strcpy (ipAddrStr, inet_ntoa (ina));
  365. firstAddress = FALSE;
  366. }
  367.     else
  368.         {
  369. sprintf (ipAddrStr, "%s,%s", ipAddrStr, inet_ntoa (ina));
  370. }
  371.     }
  372. }
  373.     else
  374. if ( (ipAddrStr = strdup ("")) == NULL)
  375.     goto error1;
  377.     #else /* WIN32 */
  379.     /* init some variables */
  381.     memset (&addr, 0, sizeof (struct sockaddr_in));
  382.     memset (ifBuf, 0, sizeof (ifBuf));
  383.     memset (&ifc, 0, sizeof (struct ifconf));
  384.     memset (&ifReq, 0, sizeof (struct ifreq));
  386.     /*
  387.      * On UNIX hosts, the gethostbyname() routine may not return all the
  388.      * available IP addresses for the local host. We use a part of the
  389.      * RPC 4.0 get_myaddress.c code to retrieve the list of all IPs registered
  390.      * for the local host
  391.      */
  393.     if ( (s = socket (AF_INET, SOCK_DGRAM, 0)) < 0)
  394. goto error1;
  396.     ifc.ifc_len = sizeof (ifBuf);
  397.     ifc.ifc_buf = ifBuf;
  399.     /* get the if config */
  401.     if (ioctl (s, SIOCGIFCONF, (char *)&ifc) < 0)
  402. goto error2;
  404.     ifr = ifc.ifc_req;
  406.     /* get the list of all the IP addresses */
  408.     for (len = ifc.ifc_len; len; len -= sizeof (ifReq))
  409. {
  410. /* first take to get the length of the ip addr list length */
  412. ifReq = *ifr;
  413. if (ioctl (s, SIOCGIFFLAGS, (char *)&ifReq) < 0)
  414.     goto error2;
  417. if ( (ifReq.ifr_flags & IFF_UP) &&
  418.      (ifr->ifr_addr.sa_family == AF_INET))
  419.     {
  420.     memcpy (&addr, &ifr->ifr_addr, sizeof (struct sockaddr_in));
  422. #ifdef PARISC_HPUX10
  423.     strcpy (ipAddr, inet_ntoa (addr.sin_addr));
  424. #else
  425.     sprintf (ipAddr, "%i.%i.%i.%i", addr.sin_addr.S_un.S_un_b.s_b1,
  426.     addr.sin_addr.S_un.S_un_b.s_b2,
  427.     addr.sin_addr.S_un.S_un_b.s_b3,
  428.     addr.sin_addr.S_un.S_un_b.s_b4);
  429. #endif /* PARISC_HPUX10 */
  431.     addrLen = strlen (ipAddr);
  432.     if ( (addrLen >= 4) && (strncmp (ipAddr, "127.", 4) == 0))
  433. {
  434. /* this is the local host address 127.0.0.1, don't add it */
  435. }
  436.     else
  437. {
  438. inetLen += addrLen + 1;
  439. }
  440.     }
  442. ifr++;
  443. }
  445.     close (s);
  447.     /* do that again */
  449.     if ( (s = socket (AF_INET, SOCK_DGRAM, 0)) < 0)
  450. goto error1;
  452.     ifc.ifc_len = sizeof (ifBuf);
  453.     ifc.ifc_buf = ifBuf;
  455.     /* get the if config */
  457.     if (ioctl (s, SIOCGIFCONF, (char *)&ifc) < 0)
  458. goto error2;
  460.     ifr = ifc.ifc_req;
  462.     /* get the list of all the IP addresses */
  463.     /* allocate the string for the IP addresses list */
  465.     if ( (ipAddrStr = (char *) calloc (inetLen, sizeof (char))) == NULL)
  466. goto error2;
  468.     for (len = ifc.ifc_len; len; len -= sizeof (ifReq))
  469. {
  470. /* first take to get the length of the ip addr list length */
  472. ifReq = *ifr;
  473. if (ioctl (s, SIOCGIFFLAGS, (char *)&ifReq) < 0)
  474.     goto error2;
  477. if ( (ifReq.ifr_flags & IFF_UP) &&
  478.      (ifr->ifr_addr.sa_family == AF_INET))
  479.     {
  480.     memcpy (&addr, &ifr->ifr_addr, sizeof (struct sockaddr_in));
  482. #ifdef PARISC_HPUX10
  483.     strcpy (ipAddr, inet_ntoa (addr.sin_addr));
  484. #else
  485.     sprintf (ipAddr, "%i.%i.%i.%i", addr.sin_addr.S_un.S_un_b.s_b1,
  486.     addr.sin_addr.S_un.S_un_b.s_b2,
  487.     addr.sin_addr.S_un.S_un_b.s_b3,
  488.     addr.sin_addr.S_un.S_un_b.s_b4);
  489. #endif /* PARISC_HPUX10 */
  491.     addrLen = strlen (ipAddr);
  493.     if (firstAddress)
  494. {
  495. if ( (addrLen >= 4) && (strncmp (ipAddr, "127.", 4) == 0))
  496.     {
  497.     /* this is the local host address 127.0.01, do not add it */
  498.     }
  499. else
  500.     {
  501.     strcpy (ipAddrStr, ipAddr);
  502.     firstAddress = FALSE;
  503.     }
  504. }
  505.     else
  506.         {
  507. addrLen = strlen (ipAddr);
  508. if ( (addrLen >= 4) && (strncmp (ipAddr, "127.", 4) == 0))
  509.     {
  510.     /* this is the local host address 127.0.0.1, don't add it */
  511.     }
  512. else
  513.     {
  514.     sprintf (ipAddrStr, "%s,%s", ipAddrStr, ipAddr);
  515.     }
  516. }
  517.     }
  519. ifr++;
  520. }
  522.      #endif /* WIN32 */
  523. #else /* HOST */
  525.     ina.s_addr = hostGetByName (hostName);
  526.     strcpy (ipAddrStr, inet_ntoa (ina));
  527. #endif /* HOST */
  529.     /* calculate the new key length */
  531.     newKeyLen = strlen (hostName) + strlen (ipAddrStr) + 10;
  532.     sprintf (buf, "%d", progNum);
  533.     newKeyLen += strlen (buf) + 1;
  534.     sprintf (buf, "%d", version);
  535.     newKeyLen += strlen (buf) + 1;
  537.     /* If we cannot get the port used, don't write it. */
  539.     if(ppNewXprt == NULL)
  540. {
  541. /* allocate room for the new key string */
  543. if ( (newKey = (char *) calloc (newKeyLen + 1, sizeof (char))) == NULL)
  544.     goto error2;
  546. sprintf (newKey, "rpc/%s/%s/%d/%d/%s", hostName, ipAddrStr,
  547.  progNum, version, (protocol == IPPROTO_TCP) ? "tcp" : "udp");
  548. }
  549.     else
  550. {
  551. sprintf (buf, "%d", (*ppNewXprt)->xp_port);
  552. newKeyLen += strlen (buf) + 1;
  554. /* allocate room for the new key string */
  556. if ( (newKey = (char *) calloc (newKeyLen + 1, sizeof (char))) == NULL)
  557.     goto error2;
  559. sprintf (newKey, "rpc/%s/%s/%d/%d/%s/%d", hostName, ipAddrStr,
  560.  progNum, version, (protocol == IPPROTO_TCP) ? "tcp" : "udp",
  561.  (*ppNewXprt)->xp_port);
  562. }
  564.     /* free the ip address string now */
  566. error2:
  567.     if (ipAddrStr != NULL)
  568. free (ipAddrStr);
  569. #if (defined HOST) && (!defined WIN32)
  570.     close (s); 
  571. #endif /* ! WIN32 */
  572. error1:
  573.     return (newKey); /* return key */
  574.     }
  576. /*******************************************************************************
  577. *
  578. * wtxRpcKeyIPListUpdate - updates IP address list of the given RPC key
  579. *
  580. * This routine uses the given <rpcKeyStr> RPC key string to update the
  581. * IP address list with the given <ipNum>. It takes the IP address <ipNum> in the
  582. * <rpcKeyStr> (if there are several), and set it first in the IP address list.
  583. *
  584. * This allows to put the given <ipNum> as the first address in the list
  585. * of addresses to use to connect to the target server
  586. *
  587. * If <ipNum> is negative, or if the <rpcKeyStr> is NULL, the routine will exit,
  588. * returning NULL.
  589. *
  590. * RETURNS: a string with updated RPC key, or NULL on error.
  591. *
  592. * ERRORS:
  593. * ibs
  594. * ibe
  595. *
  596. * SEE ALSO: wtxRpcKey(), wtxRpcKeySplit()
  597. */
  599. char * wtxRpcKeyIPListUpdate
  600.     (
  601.     const char * rpcKeyStr, /* rpc Key string to update with IP   */
  602.     int ipNum /* IP address num to set as default   */
  603.     )
  604.     {
  605.     WTX_RPC_SPLIT_KEY splitKey; /* splitted key output struct */
  606.     char * newKey = NULL; /* new updated RPC key string */
  607.     char * tmpIP = NULL; /* temp address IP holder     */
  608.     int nAddr = 0; /* address number in list     */
  610.     /* first of all, check the imput parameters */
  612.     if ((rpcKeyStr == NULL) || (ipNum < 0))
  613. goto error1;
  616.     /* split the key and look for <withIP> in this key */
  618.     memset (&splitKey, 0, sizeof (WTX_RPC_SPLIT_KEY));
  619.     if (wtxRpcKeySplit (rpcKeyStr, &splitKey) != WTX_OK)
  620. goto error1;
  622.     if ( ( (nAddr = wtxRpcKeyIPListSizeGet (&splitKey)) == 0) ||
  623.  (nAddr < ipNum))
  624. goto error2;
  626.     tmpIP = splitKey.ipAddrList [0];
  627.     splitKey.ipAddrList [0] = splitKey.ipAddrList [ipNum];
  628.     splitKey.ipAddrList [ipNum] = tmpIP;
  630.     /* we have an updated split key structure. Build new key string with it */
  632.     newKey = wtxRpcKeyFromRpcKeySplitGet (&splitKey);
  634. error2:
  635.     wtxRpcKeySplitFree (&splitKey);
  636. error1:
  637.     return (newKey);
  638.     }
  640. /*******************************************************************************
  641. *
  642. * wtxRpcKeyIPListSizeGet - get the number of IP addresses of a splitted RPC key
  643. *
  644. * This routine returns the number of IP addresses from a splitted RPC key
  645. * structure, where the WTX_RPC_SPLIT_KEY structure has the following
  646. * description :
  647. *
  648. * EXPAND ../../../include/wtxrpc.h WTX_RPC_SPLIT_KEY
  649. *
  650. * The <ipAddrList> contains the list of several IP adapters for the given
  651. * address
  652. *
  653. * RETURNS: the number of IP adapters or 0 if there was no adapters
  654. *
  655. * ERRROS: N/A
  656. *
  657. * SEE ALSO: wtxRpcKeySplit(), wtxRpcKey()
  658. *
  659. * NOMANUAL
  660. */
  662. LOCAL int wtxRpcKeyIPListSizeGet
  663.     (
  664.     WTX_RPC_SPLIT_KEY * pSplitKey /* splitted RPC key desc              */
  665.     )
  666.     {
  667.     int nIpAddr = 0; /* number of adapters for this IP     */
  669.     if ( (pSplitKey == 0) || (pSplitKey->ipAddrList == NULL))
  670. goto error1;
  672.     while (pSplitKey->ipAddrList [nIpAddr] != NULL)
  673. nIpAddr++;
  675. error1:
  676.     return (nIpAddr);
  677.     }
  679. /*******************************************************************************
  680. *
  681. * wtxRpcKeySplitFree - free the freeable members of an RPC key structure
  682. *
  683. * This routine frees the freeable members of an RPC splitted structure which
  684. * definition is :
  685. *
  686. * EXPAND ../../../include/wtxrpc.h WTX_RPC_SPLIT_KEY
  687. *
  688. * The RPC key structure itself is not freed, and it is up to the user to know
  689. * if he has to free it calling free() or not.
  690. *
  691. * RETURNS: WTX_OK
  692. *
  693. * ERRORS: N/A
  694. *
  695. * SEE ALSO: wtxRpcKeySplit(), wtxRpcKeyIPListUpdate()
  696. */
  698. STATUS wtxRpcKeySplitFree
  699.     (
  700.     WTX_RPC_SPLIT_KEY * pRpcSplitKey /* RPC key to free members of         */
  701.     )
  702.     {
  703.     int addrNum = 0; /* address number in address list     */
  705.     /* first of all, check the input parameters */
  707.     if ( (pRpcSplitKey == NULL) || (pRpcSplitKey->ipAddrList == NULL))
  708. goto error1;
  710.     /* free all the IP addressed from the IP address list */
  712.     while (pRpcSplitKey->ipAddrList [addrNum] != NULL)
  713. {
  714. free (pRpcSplitKey->ipAddrList [addrNum]);
  715. addrNum ++;
  716. }
  718.     free (pRpcSplitKey->ipAddrList);
  719. error1:
  720.     return (WTX_OK);
  721.     }
  723. /******************************************************************************
  724. *
  725. * wtxRpcKeySplit - split an RPC key string into its component parts
  726. *
  727. * The given RPC key string is decoded and the various fields are placed
  728. * into the WTX_RPC_SPLIT_KEY structure provided (by reference).
  729. *
  730. * RETURNS:
  731. * WTX_OK, if the key was split successfully and pSplitKey is filled, or
  732. * WTX_ERROR if the key could not be decoded.
  733. */
  735. STATUS wtxRpcKeySplit
  736.     (
  737.     const char * rpcKey, /* rpc key string to split            */
  738.     WTX_RPC_SPLIT_KEY * pSplitKey /* splitted key output structure      */
  739.     )
  740.     {
  741.     STATUS status = WTX_ERROR; /* routine returned status            */
  742.     char * ipAddrList = NULL; /* list of IP addressed for key       */
  743.     char * keyStart = NULL; /* key start in string                */
  744.     char * ptr = NULL; /* address list cursor                */
  745.     char * curIPAddr = NULL; /* current IP address string          */
  746.     char  progNum[10]; /* program number in string format    */
  747.     char version[10]; /* transport version in string format */
  748.     char protocol[10]; /* tcp or udp                         */
  749.     char portNum[10] = "     0"; /* port number in string format       */
  750.     char keyPat[] = "rpc/%[^/]/%[.,0-9a-fA-F]/%[0-9a-fA-F]/%[0-9a-fA-F]/%[tcpudp]/%[0-9a-fA-F]";
  751.     int nPatternsToMatch = 6; /* number of patterns to match        */
  752.     int nMatchedPatterns; /* number of matched patterns         */
  753.     int nAddr = 1; /* number of addresses in key         */
  755.     /* check arguments */
  757.     if ( (rpcKey == NULL) || (pSplitKey == NULL))
  758. goto error1;
  760.     /*
  761.      * allocate memory for the IP adresses list, default it to the length of the
  762.      * RPC key ... the list of IP addresses should not be longer
  763.      */
  765.     if ( (ipAddrList = (char *) calloc (strlen (rpcKey) + 1, sizeof (char)))
  766.  == NULL)
  767. goto error1;
  769.     /* type/host/ipaddr/prognum/vers/protocol/portnum */
  771.     memset (pSplitKey, 0, sizeof (*pSplitKey));
  773.     nMatchedPatterns = sscanf (rpcKey, keyPat, pSplitKey->host,
  774.        ipAddrList, progNum,
  775.        version, protocol, portNum);
  777.     /*
  778.      * The port number may not be present in the key. Lets' examine if we got
  779.      * all the elements or not.
  780.      */
  782.     if (nMatchedPatterns == nPatternsToMatch)
  783. {
  784.      pSplitKey->port = (unsigned short) atoi (portNum);
  785. }
  786.     else
  787. {
  788. if (nMatchedPatterns == (nPatternsToMatch-1))
  789.     { /* port number not present. Use the portmapper */
  790.     pSplitKey->port = 0; /* use portmapper */
  791.     }
  792. else /* something wrong in the key! */
  793.     goto error2;
  794. }
  796.     pSplitKey->progNum = atoi (progNum);
  797.     pSplitKey->version = atoi (version);
  799.     if (! strcmp (protocol, "udp"))
  800. pSplitKey->protocol = IPPROTO_UDP;
  801.     else if (! strcmp (protocol, "tcp"))
  802. pSplitKey->protocol = IPPROTO_TCP;
  803.     else
  804. goto error2;
  806.     /* allocate and store the list of IP addresses */
  808.     ptr = ipAddrList;
  809.     nAddr = 1;
  811.     while ( (ptr != NULL) && (*ptr != ''))
  812. {
  813. /* count the number of ',' in the address list */
  815. if ( (*ptr) == ',')
  816.     nAddr++;
  818. ptr++;
  819. }
  821.     /* allocate <nAddr> + 1 strings */
  823.     if ( (pSplitKey->ipAddrList = (char **) calloc (nAddr + 1, sizeof (char *)))
  824.  == NULL)
  825. goto error2;
  827.     keyStart = ipAddrList;
  828.     ptr = ipAddrList;
  829.     nAddr = 0;
  831.     while ((ptr != NULL) && (*ptr != ''))
  832. {
  833. if ( (*ptr) == ',')
  834.     {
  835.     /* there is an IP address list separator, copy this address */
  837.     if ( (curIPAddr = (char *) calloc ( (int) (ptr - keyStart) + 1,
  838. sizeof (char))) == NULL)
  839. goto error3;
  841.     strncpy (curIPAddr, keyStart, (int) (ptr - keyStart));
  843.     pSplitKey->ipAddrList [nAddr] = curIPAddr;
  845.     nAddr ++;
  846.     keyStart = ptr + 1;
  847.     }
  849. ptr ++;
  850. }
  852.     /* we need to also copy the last address form the key */
  854.     if ( (pSplitKey->ipAddrList [nAddr] = (char *)
  855.   calloc ( (int) (ptr - keyStart) + 1, sizeof (char))) == NULL)
  856. goto error3;
  858.     strcpy (pSplitKey->ipAddrList [nAddr], keyStart);
  859.     status = WTX_OK;
  861. error3:
  862.     if (status != WTX_OK)
  863. wtxRpcKeySplitFree (pSplitKey);
  864. error2:
  865.     if (ipAddrList != NULL)
  866. free (ipAddrList);
  867. error1:
  868.     return (status);
  869.     }
  871. /*******************************************************************************
  872. *
  873. * wtxRpcKeyFromRpcKeySplitGet - get an RPC key from a splitted RPC key structure
  874. *
  875. * This routines takes the input <pSplitKey> RPC splitted key structure, to
  876. * build an RPC key string.
  877. *
  878. * RETURNS: The RPC key string or NULL on error
  879. *
  880. * ERRORS: N/A
  881. *
  882. * SEE ALSO: wtxRpcKey(), wtxRpcKeySplit(), wtxRpcKeyIPListUpdate()
  883. * wtxRpcKeySplitFree()
  884. *
  885. * NOMANUAL
  886. */
  888. LOCAL char * wtxRpcKeyFromRpcKeySplitGet
  889.     (
  890.     WTX_RPC_SPLIT_KEY * pSplitKey /* splitted key to create key from    */
  891.     )
  892.     {
  893.     char * ipList = NULL; /* IP address list, ',' separated     */
  894.     char * rpcKey = NULL; /* extracted RPC ey string            */
  895.     char buf [256]; /* formatting buffer                  */
  896.     int addrNum = 0; /* address number in list             */
  897.     int keyLen = 0; /* RPC key string length              */
  898.     int ipListLen = 0; /* IP addresses list length           */
  900.     /* first of all, check the routines' arguments */
  902.     if ( (pSplitKey == NULL) || (pSplitKey->host == NULL) ||
  903.  (pSplitKey->ipAddrList == NULL))
  904. goto error1;
  906.     /* calculate the RPC ey string length */
  908.     memset (&buf, 0, 256);
  909.     keyLen += strlen (pSplitKey->host) + 1;
  910.     sprintf (buf, "%d", pSplitKey->progNum);
  911.     keyLen += strlen (buf) + 1;
  912.     sprintf (buf, "%d", pSplitKey->version);
  913.     keyLen += strlen (buf) + 1;
  915.     /* add the rpc/ + the (udp)|(rpc)/? */
  917.     keyLen += 7;
  919.     /* allocate and store the list of IP addresses */
  921.     addrNum = 0;
  922.     while (pSplitKey->ipAddrList [addrNum] != NULL)
  923. {
  924. ipListLen += strlen (pSplitKey->ipAddrList [addrNum]) + 1;
  925. addrNum ++;
  926. }
  928.     keyLen += ipListLen;
  930.     /* we have the key cumulated IP list length, allocate the string for it */
  932.     if ( (ipList = (char *) calloc (ipListLen, sizeof (char))) == NULL)
  933. goto error1;
  935.     addrNum = 0;
  936.     while (pSplitKey->ipAddrList [addrNum] != NULL)
  937. {
  938. if (addrNum == 0)
  939.     strcpy (ipList, pSplitKey->ipAddrList [addrNum]);
  940. else
  941.     sprintf (ipList, "%s,%s", ipList, pSplitKey->ipAddrList [addrNum]);
  943. addrNum ++;
  944. }
  946.     if (pSplitKey->port == 0)
  947. {
  948. /* allocate room for the new key string */
  950. if ( (rpcKey = (char *) calloc (keyLen + 1, sizeof (char))) == NULL)
  951.     goto error2;
  953. sprintf (rpcKey, "rpc/%s/%s/%d/%d/%s", pSplitKey->host,
  954.  ipList, pSplitKey->progNum, pSplitKey->version,
  955.  (pSplitKey->protocol == IPPROTO_TCP) ? "tcp" : "udp");
  956. }
  957.     else
  958. {
  959. sprintf (buf, "%u", pSplitKey->port);
  960. keyLen += strlen (buf) + 1;
  962. /* allocate room for the new key string */
  964. if ( (rpcKey = (char *) calloc (keyLen + 1, sizeof (char))) == NULL)
  965.     goto error2;
  967. sprintf (rpcKey, "rpc/%s/%s/%d/%d/%s/%u", pSplitKey->host,
  968.  ipList, pSplitKey->progNum, pSplitKey->version,
  969.  (pSplitKey->protocol == IPPROTO_TCP) ? "tcp" : "udp",
  970.  pSplitKey->port);
  971. }
  973. error2:
  974.     if (ipList != NULL)
  975. free (ipList);
  976. error1:
  977.     return (rpcKey);
  978.     }
  980. /*******************************************************************************
  981. *
  982. * wtxRpcExchangeCreate - create a new exchange client using the RPC transport
  983. *
  984. * This routine takes a wpwr key string and creates a new exchange client
  985. * 
  986. * RETURNS: WTX_OK, or WTX_ERROR
  987. *
  988. * NOMANUAL
  989. */
  991. STATUS wtxRpcExchangeCreate
  992.     (
  993.     WTX_XID xid, /* Exchange handle                    */
  994.     const char * key, /* Key for server to connect to       */
  995.     BOOL usePMap /* use port mapper to connect ?       */
  996.     )
  997.     {
  998.     struct sockaddr_in addr; /* socket address             */
  999.     WTX_RPC_SPLIT_KEY split; /* split key                  */
  1000.     CLIENT * pClient = NULL; /* rpc client handle          */
  1001.     int rpcSock = 0; /* rpc socket                 */
  1003. #ifdef HOST
  1004.     struct hostent * pHostEnt = NULL; /* host entry                 */
  1005.     char *              registryHost = NULL; /* registry host name         */
  1006. #endif /* HOST */
  1008.     if (key != NULL)
  1009. {
  1010. if (wtxRpcKeySplit (key, &split) != WTX_OK)
  1011.     WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_BAD_KEY, WTX_ERROR);
  1012. }
  1013.     else 
  1014. {
  1015. /*
  1016.  * NULL key => contact the registry service so fill in the split key
  1017.  * with the Tornado registry particulars 
  1018.  */
  1020. #ifdef HOST
  1022. if ((registryHost = wpwrGetEnv ("WIND_REGISTRY")) == NULL)
  1023.     registryHost = "127.0.0.1"; /* its probably local */
  1024. strncpy (split.host, registryHost, sizeof (split.host));
  1025. split.host [sizeof (split.host) - 1] = '';
  1026. #endif
  1027. if (usePMap)
  1028.     split.port = 0;
  1029. else
  1030.     split.port = REGISTRY_PORT;
  1032. /*
  1033.  * Set ipAddrList to NULL.  That will cause the address lookup logic
  1034.  * below to use gethostbyname for us.
  1035.  */
  1037. split.ipAddrList = NULL;
  1038. split.progNum = WTX_SVC_BASE;
  1039. split.version = 1;
  1040. split.protocol = IPPROTO_TCP;
  1041. }
  1043.     /* 
  1044.      * Get the internet address for the given host.  Parse hostname
  1045.      * as host name or alternatively in the `xx.xx.xx.xx' notation. 
  1046.      */
  1048.     memset ((void *) &addr, 0, sizeof (addr));
  1050.     /*
  1051.      * Get the IP address. First use the dotted decimal part of the
  1052.      * split key if that is comprehensible.  Otherwise use
  1053.      * gethostbyname to look up the address.  If that fails try to
  1054.      * parse the hostname itself as a dotted decimal.  Otherwise
  1055.      * complain. 
  1056.      */
  1058.     if ( (split.ipAddrList != NULL) &&
  1059.  (int) (addr.sin_addr.s_addr = inet_addr (split.ipAddrList [0])) != -1)
  1060. ;
  1062. #ifdef HOST
  1063. #   ifdef WIN32
  1065.     else if ((addr.sin_addr.s_addr = inet_addr (split.host)) != INADDR_NONE)
  1066. ;
  1067.     else if ((pHostEnt = (struct hostent *)gethostbyname (split.host)) != NULL)
  1068. addr.sin_addr.s_addr = * ((u_long *) pHostEnt->h_addr_list[0]);
  1069.     else
  1070. {
  1071. wtxRpcKeySplitFree (&split);
  1072. WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_NO_SERVER, WTX_ERROR);
  1073. }
  1075. #   else /* WIN32 */
  1077.     else if ((pHostEnt = (struct hostent *)gethostbyname (split.host)) != NULL)
  1078. addr.sin_addr.s_addr = * ((u_long *) pHostEnt->h_addr_list[0]);
  1079.     else if ( (int) (addr.sin_addr.s_addr = inet_addr (split.host)) == -1)
  1080. {
  1081. wtxRpcKeySplitFree (&split);
  1082. WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_NO_SERVER, WTX_ERROR);
  1083. }
  1085. #   endif /* WIN32 */
  1086. #else
  1088.     else
  1089. addr.sin_addr.s_addr = syncRegistry;
  1090. #endif /* HOST */
  1092.     addr.sin_family = AF_INET;
  1093.     addr.sin_port = htons(split.port); /* given by registry/portmapper */
  1094.     rpcSock = RPC_ANYSOCK; /* any old socket */
  1096.     if (split.protocol == IPPROTO_TCP)
  1097. pClient = clnttcp_create (&addr, split.progNum, split.version,
  1098.   &rpcSock, 0, 0);
  1099.     else
  1100. pClient = clntudp_create (&addr, split.progNum, split.version,
  1101.   rpcDefaultUdpTimeout, &rpcSock);
  1103.     if (pClient == NULL) /* transport failed? */
  1104. {
  1105. wtxRpcKeySplitFree (&split);
  1106. WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_NO_SERVER, WTX_ERROR);
  1107. }
  1109.     /* Set up the authorization mechanism */
  1111. #ifdef HOST
  1113. #   ifndef WIN32
  1115.     pClient->cl_auth = authunix_create_default();
  1116. #   else
  1118.     pClient->cl_auth = authunix_create("WIN32", wpwrGetUid(), NULL, NULL, NULL);
  1119. #   endif /* WIN32 */
  1121. #else
  1122.     /* authentication */
  1124.     pClient->cl_auth = authunix_create ("", 0, 0, 0, NULL);
  1126.     /* set the real value computed on host and stored on target */
  1128.     pClient->cl_auth->ah_cred.oa_flavor = authCred.oa_flavor;
  1129.     pClient->cl_auth->ah_cred.oa_base = authCred.oa_base;
  1130.     pClient->cl_auth->ah_cred.oa_length = authCred.oa_length;
  1131. #endif  /* HOST */
  1133.     xid->transport = pClient;
  1134. #ifndef HOST
  1135. #if (CPU==SIMHPPA)
  1136.     /*
  1137.      *  Set RPC receive buffer for HPSIM when using SLIP.  This is needed for
  1138.      *  target symbol synchronization, since the target server can send
  1139.      *  messages larger than the target MTU when not communicating thru WDB.
  1140.      */
  1141.     {
  1142.     WDB_AGENT_INFO agentInfo;
  1143.     int blen;
  1145.     wdbInfoGet (&agentInfo);
  1146.     blen = agentInfo.mtu;
  1147.     if ( blen < 1000 ) /* Must be using SLIP */
  1148. setsockopt (rpcSock, SOL_SOCKET, SO_RCVBUF, 
  1149.     (void *) &blen, sizeof (blen));
  1150.     }
  1151. #endif /* CPU=SIMHPPA */
  1152. #endif /* ! HOST */
  1154.     wtxRpcKeySplitFree (&split);
  1155.     return WTX_OK;
  1156.     }
  1158. /*******************************************************************************
  1159. *
  1160. * wtxRpcExchangeControl - perform a miscellaneous exchange control function.
  1161. *
  1162. * This routine performs a miscellaneous control function on the exchange 
  1163. * handle <xid>. 
  1164. *
  1165. * RETURNS: WTX_OK, or WTX_ERROR.
  1166. *
  1167. * ERRORS: WTX_ERR_EXCHANGE_INVALID_HANDLE, WTX_ERR_EXCHANGE_INVALID_ARG
  1168. *
  1169. * NOMANUAL
  1170. */
  1172. STATUS wtxRpcExchangeControl
  1173.     (
  1174.     WTX_XID xid, /* Exchange handle */
  1175.     UINT32 request, /* Exchange control request number */
  1176.     void * arg /* Pointer to request argument */
  1177.     )
  1179.     {
  1180.     CLIENT * pClient;
  1182.     pClient = (CLIENT *) xid->transport;
  1184.     switch (request) 
  1185. {
  1186. case WTX_EXCHANGE_CTL_TIMEOUT_SET:
  1187.     xid->timeout = *(UINT32 *) arg;
  1188.     break;
  1189.     
  1190. case WTX_EXCHANGE_CTL_TIMEOUT_GET:
  1191.     *(UINT32 *) arg = xid->timeout;
  1192.     break;
  1193.     
  1194. default:
  1195.     WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED, 
  1196.  WTX_ERROR);
  1197. }
  1199.     return WTX_OK;
  1200.     }
  1203. /*******************************************************************************
  1204. *
  1205. * wxRpcDelete - delete the exchange handle and any transport connection.
  1206. *
  1207. * This routine deletes the exchange mechanism specified by the exchange 
  1208. * handle <xid>. <xid> should not be used again in any further exchange
  1209. * calls as the underlying transport mechanism is closed also.
  1210. *
  1211. * RETURNS: WTX_OK, or WTX_ERROR
  1212. *
  1213. * NOMANUAL
  1214. */
  1216. STATUS wtxRpcExchangeDelete
  1217.     (
  1218.     WTX_XID xid /* Exchange handle */
  1219.     )
  1220.     {
  1221.     CLIENT *pClient;
  1223.     pClient = (CLIENT *) xid->transport;
  1225.     if (pClient == NULL)
  1226. /* Nothing to do */
  1227. return WTX_OK;
  1229.     if (pClient->cl_auth != NULL)
  1230. auth_destroy (pClient->cl_auth);
  1232.     clnt_destroy (pClient);
  1234.     xid->transport = NULL;
  1236.     return (WTX_OK);
  1237.     }
  1240. /*******************************************************************************
  1241. *
  1242. * wtxRpcExchangeFree - free a exchange call result message
  1243. *
  1244. * This routine frees the memory allocated internally to the result message
  1245. * <pMsg> used in making the exchange service call <svcNum>.
  1246. *
  1247. * RETURNS: WTX_OK, or WTX_ERROR
  1248. *
  1249. * NOMANUAL
  1250. */
  1252. WTX_ERROR_T wtxRpcExchangeFree
  1253.     (
  1254.     WTX_REQUEST svcNum, /* number of server service result to free */
  1255.     void * pMsg /* pointer to result message to free */
  1256.     )
  1257.     {
  1258.     if (svcNum > rpcSvcTableSize || (*rpcSvcTable)[svcNum] == NULL)
  1259. return (WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED);
  1261.     (*rpcSvcTable)[svcNum]->xdrOut (&svrXdrs, pMsg);
  1262.  
  1263.     return (WTX_ERR_NONE);
  1264.     }
  1268. /*******************************************************************************
  1269. *
  1270. * wtxRpcExchange - do a WTX API call via the exchange mechanism
  1271. *
  1272. * This routine performs the exchange service call <svcNum> with in parameters
  1273. * pointed to by <pIn> and result (out) parameters pointed to by <pOut>. The
  1274. * status of the call is represented by the error code returned.  The result
  1275. * <pOut> may have memory allocated to it internally which can be freed by
  1276. * using wtxRpcExchangeFree().
  1277. *
  1278. * RETURNS: WTX_OK, or WTX_ERROR
  1279. *
  1280. * NOMANUAL
  1281. */
  1283. STATUS wtxRpcExchange
  1284.     (
  1285.     WTX_XID xid, /* exchange handle */
  1286.     WTX_REQUEST svcNum, /* exchange service number */
  1287.     void * pIn, /* exchange service in args */
  1288.     void * pOut /* exchange service out args */
  1289.     )
  1291.     {
  1292.     enum clnt_stat rpcStat; 
  1293.     WTX_ERROR_T wtxStat;
  1294.     WTX_MSG_RESULT * pMsgOut;
  1295.     CLIENT * pClient;
  1296.     RPC_SERVICE * pService;
  1297.     struct timeval timeout;
  1300.     pClient = (CLIENT *) xid->transport;
  1301.     if (pClient == NULL)
  1302. WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_NO_TRANSPORT, WTX_ERROR);
  1304.     /* Make sure the table has been initialized */
  1306.     if (rpcSvcTable == NULL)
  1307. rpcSvcTableInstall ();
  1309.     if (svcNum > rpcSvcTableSize || (*rpcSvcTable)[svcNum] == NULL)
  1310. WTX_EXCHANGE_RETURN (xid, WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED, 
  1311.      WTX_ERROR);
  1313.     pService = (*rpcSvcTable)[svcNum];
  1315.     /* Construct a timeout struct on the fly for service request */
  1317.     timeout.tv_sec = xid->timeout / 1000;
  1318.     timeout.tv_usec = xid->timeout * 1000 - timeout.tv_sec * 1000000;
  1320.     rpcStat = clnt_call (pClient,
  1321.  svcNum, 
  1322.  pService->xdrIn, pIn,  
  1323.  pService->xdrOut, pOut,  
  1324.  timeout);
  1326.     wtxStat = rpcStatToError (rpcStat);
  1328.     if (wtxStat != WTX_ERR_NONE)
  1329. {
  1330. /* An RPC error occured. Free the result and return */
  1331. clnt_freeres (pClient, pService->xdrOut, pOut);
  1333. /* Handle case of RPC failing so badly we must disconnect */
  1334. if (wtxStat == WTX_ERR_EXCHANGE_TRANSPORT_DISCONNECT)
  1335.     wtxRpcExchangeDelete (xid);
  1337. WTX_EXCHANGE_RETURN (xid, wtxStat, WTX_ERROR);
  1338. }
  1340.     /* Sort cut for NULLPROC that doesn't return a proper WTX message result. */
  1342.     if (svcNum == NULLPROC)
  1343. return WTX_OK;
  1345.     pMsgOut = (WTX_MSG_RESULT *) pOut;
  1347.     if (pMsgOut->wtxCore.errCode != OK)
  1348. {
  1349. UINT32 errCode;
  1351. /* A service specific error occured. Free the result and return */
  1353. errCode = pMsgOut->wtxCore.errCode;
  1354. clnt_freeres (pClient, pService->xdrOut, pOut);
  1355. WTX_EXCHANGE_RETURN (xid, errCode, WTX_ERROR);
  1356. }
  1358.     return WTX_ERR_NONE;
  1359.     }
  1362. /*******************************************************************************
  1363. *
  1364. * rpcStatToError - convert an RPC status to a WTX error code.
  1365. * 
  1366. * This routine converts an RPC error status <callStat> to a WTX error code.
  1367. *
  1368. * RETURNS: the WTX error code or WTX_ERR_NONE if no error occured.
  1369. *
  1370. * NOMANUAL
  1371. */
  1373. LOCAL WTX_ERROR_T rpcStatToError
  1374.     (
  1375.     enum clnt_stat rpcStat /* status from call */
  1376.     )
  1378.     {
  1379.     switch (rpcStat) 
  1380. {
  1381. case RPC_SUCCESS:
  1382.     return WTX_ERR_NONE; /* call succeeded */
  1384. case RPC_CANTENCODEARGS: /* can't encode arguments */
  1385. case RPC_CANTDECODERES: /* can't decode results */
  1386. case RPC_CANTDECODEARGS: /* decode arguments error */
  1387. case RPC_SYSTEMERROR: /* generic "other problem" */
  1388. case RPC_UNKNOWNHOST: /* unknown host name */
  1389. case RPC_UNKNOWNPROTO: /* unknown protocol -- 4.0 */
  1390. case RPC_PMAPFAILURE: /* the pmapper failed in its call */
  1391. case RPC_PROGNOTREGISTERED: /* remote program is not registered */
  1392. case RPC_FAILED:
  1393.     return WTX_ERR_EXCHANGE_TRANSPORT_ERROR;
  1395. case RPC_PROCUNAVAIL: /* procedure unavailable */
  1396.     return WTX_ERR_EXCHANGE_REQUEST_UNSUPPORTED;
  1398. case RPC_CANTSEND: /* failure in sending call */
  1399. case RPC_CANTRECV: /* failure in receiving result */
  1400. case RPC_VERSMISMATCH: /* rpc versions not compatible */
  1401. case RPC_AUTHERROR: /* authentication error */
  1402. case RPC_PROGUNAVAIL: /* program not available */
  1403. case RPC_PROGVERSMISMATCH: /* program version mismatched */
  1404.     return WTX_ERR_EXCHANGE_TRANSPORT_DISCONNECT;
  1406. case RPC_TIMEDOUT: /* call timed out */
  1407.     return WTX_ERR_EXCHANGE_TIMEOUT;
  1409. default:
  1410.     return WTX_ERR_EXCHANGE;
  1411. }
  1412.     
  1413.     }
  1416. /*******************************************************************************
  1417. *
  1418. * rpcSvcAdd - add a new service into the exchange service table
  1419. *
  1420. * This routine adds a new service with service number <svcNum> into the
  1421. * exchange service table.  The in and out XDR routines <xdrIn> and <xdrOut>
  1422. * are recorded in the table.
  1423. *
  1424. * RETURNS: OK, or ERROR.
  1425. */
  1427. LOCAL STATUS rpcSvcAdd
  1428.     (
  1429.     UINT32 svcNum,
  1430.     xdrproc_t xdrIn,
  1431.     xdrproc_t xdrOut
  1432.     )
  1434.     {
  1435.     if (svcNum + 1 > rpcSvcTableSize)
  1436. {
  1437. RPC_SERVICE *(*newTable)[];
  1439. /* Current table not big enough */
  1441. newTable = calloc (svcNum + 1, sizeof (RPC_SERVICE *));
  1442. if (newTable == NULL)
  1443.     return ERROR;
  1445. /* Copy and free the old one */
  1447. if (rpcSvcTable != NULL)
  1448.     {
  1449.     memcpy (newTable, rpcSvcTable, 
  1450.     rpcSvcTableSize * sizeof (RPC_SERVICE *));
  1451.     free (rpcSvcTable);
  1452.     }
  1454. rpcSvcTable = newTable;
  1455. rpcSvcTableSize = svcNum + 1;
  1456. }
  1457.     
  1458.     (*rpcSvcTable)[svcNum] = malloc (sizeof (RPC_SERVICE));
  1459.     if  ((*rpcSvcTable)[svcNum] == NULL)
  1460. /* No space for the new service description */
  1461. return ERROR;
  1463.     (*rpcSvcTable)[svcNum]->xdrIn = xdrIn;
  1464.     (*rpcSvcTable)[svcNum]->xdrOut = xdrOut;
  1466.     return OK;
  1467.     }
  1469.     
  1470. /*******************************************************************************
  1471. *
  1472. * rpcSvcTableInstall - install initial table of service definitions
  1473. *
  1474. * This routine sets a the table that defines the XDR conversion functions
  1475. * for each available exchange service. No action is taken if this function
  1476. * is called more than once.
  1477. *
  1478. * RETURNS: OK, or ERROR
  1479. */
  1481. LOCAL STATUS rpcSvcTableInstall (void)
  1482.     {
  1483.     if (rpcSvcTable != NULL)
  1485. /* Already initialized */
  1487. return (OK);
  1489.     /* Add the services to the table of available services */
  1491.     /* store the client XDRs */
  1493.     xdrmem_create (&svrXdrs, svrXdrsMCall, MCALL_MSG_SIZE, XDR_FREE);
  1495.     /* Ping or no-op service */
  1497.     rpcSvcAdd (NULLPROC, xdr_void, xdr_void);
  1499.     /* Registry services */
  1501.     rpcSvcAdd (WTX_INFO_Q_GET, 
  1502.        xdr_WTX_MSG_WTXREGD_PATTERN, xdr_WTX_MSG_SVR_DESC_Q); 
  1503.     rpcSvcAdd (WTX_INFO_GET, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_SVR_DESC); 
  1504.     rpcSvcAdd (WTX_REGISTER, xdr_WTX_MSG_SVR_DESC, xdr_WTX_MSG_SVR_DESC); 
  1505.     rpcSvcAdd (WTX_UNREGISTER, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT); 
  1507.     /* Target server services */
  1509.     rpcSvcAdd (WTX_TOOL_ATTACH, xdr_WTX_MSG_TOOL_DESC, xdr_WTX_MSG_TOOL_DESC);
  1510.     rpcSvcAdd (WTX_TOOL_DETACH, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1511.     rpcSvcAdd (WTX_TS_INFO_GET_V1, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_TS_INFO_V1);
  1512.     rpcSvcAdd (WTX_TS_INFO_GET_V2, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_TS_INFO_V2);
  1513.     rpcSvcAdd (WTX_TS_LOCK, xdr_WTX_MSG_TS_LOCK, xdr_WTX_MSG_RESULT);
  1514.     rpcSvcAdd (WTX_TS_UNLOCK, xdr_WTX_MSG_TS_UNLOCK, xdr_WTX_MSG_RESULT);
  1515.     rpcSvcAdd (WTX_TARGET_RESET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1516.     rpcSvcAdd (WTX_TARGET_ATTACH, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1518. #if 0 /* ELP */
  1520.     rpcSvcAdd (WTX_TARGET_PING, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1521. #endif
  1523.     rpcSvcAdd (WTX_CONTEXT_CREATE,
  1524.        xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_CONTEXT);
  1525.     rpcSvcAdd (WTX_CONTEXT_KILL, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
  1526.     rpcSvcAdd (WTX_CONTEXT_SUSPEND, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
  1527.     rpcSvcAdd (WTX_CONTEXT_CONT, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
  1528.     rpcSvcAdd (WTX_CONTEXT_RESUME, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
  1529.     rpcSvcAdd (WTX_CONTEXT_STATUS_GET, xdr_WTX_MSG_CONTEXT, xdr_WTX_MSG_RESULT);
  1530.     rpcSvcAdd (WTX_CONTEXT_STEP,
  1531.        xdr_WTX_MSG_CONTEXT_STEP_DESC, xdr_WTX_MSG_RESULT);
  1532.     rpcSvcAdd (WTX_EVENTPOINT_ADD, xdr_WTX_MSG_EVTPT_DESC, xdr_WTX_MSG_RESULT);
  1533.     rpcSvcAdd (WTX_EVENTPOINT_DELETE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1534.     rpcSvcAdd (WTX_EVENTPOINT_LIST, 
  1535.        xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVTPT_LIST);
  1536.     rpcSvcAdd (WTX_MEM_CHECKSUM, xdr_WTX_MSG_MEM_SET_DESC, xdr_WTX_MSG_RESULT);
  1537.     rpcSvcAdd (WTX_MEM_DISASSEMBLE, xdr_WTX_MSG_DASM_DESC,
  1538.                xdr_WTX_MSG_DASM_INST_LIST);
  1539.     rpcSvcAdd (WTX_MEM_READ, 
  1540.        xdr_WTX_MSG_MEM_READ_DESC, xdr_WTX_MSG_MEM_COPY_DESC);
  1541.     rpcSvcAdd (WTX_MEM_WRITE, xdr_WTX_MSG_MEM_COPY_DESC, xdr_WTX_MSG_RESULT);
  1542.     rpcSvcAdd (WTX_MEM_SET, xdr_WTX_MSG_MEM_SET_DESC, xdr_WTX_MSG_RESULT);
  1543.     rpcSvcAdd (WTX_MEM_SCAN, xdr_WTX_MSG_MEM_SCAN_DESC, xdr_WTX_MSG_RESULT);
  1544.     rpcSvcAdd (WTX_MEM_MOVE, xdr_WTX_MSG_MEM_MOVE_DESC, xdr_WTX_MSG_RESULT);
  1545.     rpcSvcAdd (WTX_MEM_ALLOC, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1546.     rpcSvcAdd (WTX_MEM_REALLOC, xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
  1547.     rpcSvcAdd (WTX_MEM_ALIGN, xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
  1548.     rpcSvcAdd (WTX_MEM_ADD_TO_POOL,
  1549.        xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
  1550.     rpcSvcAdd (WTX_MEM_FREE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1551.     rpcSvcAdd (WTX_MEM_INFO_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_MEM_INFO);
  1552.     rpcSvcAdd (WTX_REGS_GET, xdr_WTX_MSG_REG_READ, xdr_WTX_MSG_MEM_XFER_DESC);
  1553.     rpcSvcAdd (WTX_REGS_SET, xdr_WTX_MSG_REG_WRITE, xdr_WTX_MSG_RESULT);
  1554.     rpcSvcAdd (WTX_OPEN, xdr_WTX_MSG_OPEN_DESC, xdr_WTX_MSG_RESULT);
  1555.     rpcSvcAdd (WTX_VIO_READ, 
  1556.        xdr_WTX_MSG_VIO_COPY_DESC, xdr_WTX_MSG_VIO_COPY_DESC);
  1557.     rpcSvcAdd (WTX_VIO_WRITE, xdr_WTX_MSG_VIO_COPY_DESC, xdr_WTX_MSG_RESULT);
  1558.     rpcSvcAdd (WTX_CLOSE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1559.     rpcSvcAdd (WTX_VIO_CTL, xdr_WTX_MSG_VIO_CTL_DESC, xdr_WTX_MSG_RESULT);
  1560.     rpcSvcAdd (WTX_VIO_FILE_LIST, 
  1561.        xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_VIO_FILE_LIST);
  1562.     rpcSvcAdd (WTX_OBJ_MODULE_LOAD, 
  1563.        xdr_WTX_MSG_LD_M_FILE_DESC, xdr_WTX_MSG_LD_M_FILE_DESC);
  1564.     rpcSvcAdd (WTX_OBJ_MODULE_UNLOAD, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1565.     rpcSvcAdd (WTX_OBJ_MODULE_LIST, 
  1566.        xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_MODULE_LIST);
  1567.     rpcSvcAdd (WTX_OBJ_MODULE_INFO_GET, 
  1568.        xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_MODULE_INFO);
  1569.     rpcSvcAdd (WTX_OBJ_MODULE_FIND, 
  1570.        xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_MOD_NAME_OR_ID);
  1571.     rpcSvcAdd (WTX_SYM_TBL_INFO_GET, 
  1572.        xdr_WTX_MSG_PARAM, xdr_WTX_MSG_SYM_TBL_INFO);
  1573.     rpcSvcAdd (WTX_SYM_LIST_GET, 
  1574.        xdr_WTX_MSG_SYM_MATCH_DESC, xdr_WTX_MSG_SYM_LIST);
  1575.     rpcSvcAdd (WTX_SYM_FIND, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_SYMBOL_DESC);
  1576.     rpcSvcAdd (WTX_SYM_ADD, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_RESULT);
  1577.     rpcSvcAdd (WTX_SYM_REMOVE, xdr_WTX_MSG_SYMBOL_DESC, xdr_WTX_MSG_RESULT);
  1578.     rpcSvcAdd (WTX_EVENT_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVENT_DESC);
  1579.     rpcSvcAdd (WTX_REGISTER_FOR_EVENT, 
  1580.        xdr_WTX_MSG_EVENT_REG_DESC, xdr_WTX_MSG_RESULT);
  1581.     rpcSvcAdd (WTX_EVENT_ADD, xdr_WTX_MSG_EVENT_DESC, xdr_WTX_MSG_RESULT);
  1582.     rpcSvcAdd (WTX_GOPHER_EVAL, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_GOPHER_TAPE);
  1583.     rpcSvcAdd (WTX_FUNC_CALL, xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_RESULT);
  1584.     rpcSvcAdd (WTX_DIRECT_CALL, xdr_WTX_MSG_CONTEXT_DESC, xdr_WTX_MSG_RESULT);
  1585.     rpcSvcAdd (WTX_SERVICE_ADD, xdr_WTX_MSG_SERVICE_DESC, xdr_WTX_MSG_RESULT);
  1586.     rpcSvcAdd (WTX_AGENT_MODE_SET, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1587.     rpcSvcAdd (WTX_AGENT_MODE_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1588.     rpcSvcAdd (WTX_CONSOLE_CREATE, 
  1589.        xdr_WTX_MSG_CONSOLE_DESC, xdr_WTX_MSG_CONSOLE_DESC);
  1590.     rpcSvcAdd (WTX_CONSOLE_KILL, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1591.     rpcSvcAdd (WTX_OBJ_KILL, xdr_WTX_MSG_KILL_DESC, xdr_WTX_MSG_RESULT);
  1592.     rpcSvcAdd (WTX_VIO_CHAN_GET, xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_RESULT);
  1593.     rpcSvcAdd (WTX_VIO_CHAN_RELEASE, xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1595.     /* WTX 2: new services */
  1597.     rpcSvcAdd (WTX_UNREGISTER_FOR_EVENT,
  1598.                xdr_WTX_MSG_EVENT_REG_DESC, xdr_WTX_MSG_RESULT);
  1599.     rpcSvcAdd (WTX_CACHE_TEXT_UPDATE,
  1600.                xdr_WTX_MSG_MEM_BLOCK_DESC, xdr_WTX_MSG_RESULT);
  1601.     rpcSvcAdd (WTX_MEM_WIDTH_READ,
  1602.                xdr_WTX_MSG_MEM_WIDTH_READ_DESC, xdr_WTX_MSG_MEM_WIDTH_COPY_DESC);
  1603.     rpcSvcAdd (WTX_MEM_WIDTH_WRITE,
  1604.                xdr_WTX_MSG_MEM_WIDTH_COPY_DESC, xdr_WTX_MSG_RESULT);
  1605.     rpcSvcAdd (WTX_COMMAND_SEND,
  1606.                xdr_WTX_MSG_PARAM, xdr_WTX_MSG_RESULT);
  1607.     rpcSvcAdd (WTX_OBJ_MODULE_CHECKSUM,
  1608.                xdr_WTX_MSG_MOD_NAME_OR_ID, xdr_WTX_MSG_RESULT);
  1609.     rpcSvcAdd (WTX_EVENT_LIST_GET,
  1610.                xdr_WTX_MSG_PARAM, xdr_WTX_MSG_EVENT_LIST);
  1611.     rpcSvcAdd (WTX_OBJ_MODULE_LOAD_2,
  1612.                xdr_WTX_MSG_FILE_LOAD_DESC, xdr_WTX_MSG_LD_M_FILE_DESC);
  1613.     rpcSvcAdd (WTX_EVENTPOINT_ADD_2,
  1614.                xdr_WTX_MSG_EVTPT_DESC_2, xdr_WTX_MSG_RESULT);
  1615.     rpcSvcAdd (WTX_EVENTPOINT_LIST_GET,
  1616.                xdr_WTX_MSG_TOOL_ID, xdr_WTX_MSG_EVTPT_LIST_2);
  1617.     rpcSvcAdd (WTX_OBJ_MODULE_UNLOAD_2, xdr_WTX_MSG_MOD_NAME_OR_ID,
  1618.                xdr_WTX_MSG_RESULT);
  1620.     return (OK);
  1621.     }