Ticket #78: 0003-Track-rpcgen-outputs.patch

File 0003-Track-rpcgen-outputs.patch, 93.7 KB (added by chuck@…, 13 years ago)

Track rpcgen outputs

  • .gitignore 

    From 262b37e3d789bae0bc7e258696eb45472198b432 Mon Sep 17 00:00:00 2001
From: Charlie Sharpsteen <source@sharpsteen.net>
Date: Wed, 9 Nov 2011 21:39:05 -0800
Subject: [PATCH 3/4] Track rpcgen outputs

The version of rpcgen included with OS X is ancient and cannot properly process
rcpif.x. The only way to get usable output is to generate the source files on
Linux and check them into version control.
---
 .gitignore               |    5 +-
 clientcomm/rpcif.h       |  842 +++++++++++++++++++++++++++
 clientcomm/rpcif_clnt.cc | 1432 ++++++++++++++++++++++++++++++++++++++++++++++
 clientcomm/rpcif_svc.cc  |  374 ++++++++++++
 clientcomm/rpcif_xdr.c   |  847 +++++++++++++++++++++++++++
 5 files changed, 3496 insertions(+), 4 deletions(-)
 create mode 100644 clientcomm/rpcif.h
 create mode 100644 clientcomm/rpcif_clnt.cc
 create mode 100644 clientcomm/rpcif_svc.cc
 create mode 100644 clientcomm/rpcif_xdr.c

diff --git a/.gitignore b/.gitignore
index a7ad13f..95bba7d 100644
    a b autom4te.cache  
    88*.a
    99#These are all generated files under openrasdaman
    1010applications/rasql/rasql
    11 clientcomm/rpcif.h
    12 clientcomm/rpcif_clnt.cc
    13 clientcomm/rpcif_svc.cc
    14 clientcomm/rpcif_xdr.c
    1511config.log
    1612config.status
    1713insertutils/insertppm
    … … dbparams.properties  
    5753petascope/build
    5854petascope/db/settings.properties
    5955petascope/nbproject/private/
     56petascope/doc/

  • new file clientcomm/rpcif.h 

    diff --git a/clientcomm/rpcif.h b/clientcomm/rpcif.h
new file mode 100644
index 0000000..bab3781
    - +  
     1/*
     2 * Please do not edit this file.
     3 * It was generated using rpcgen.
     4 */
     5
     6#ifndef _RPCIF.H_H_RPCGEN
     7#define _RPCIF.H_H_RPCGEN
     8
     9#include <rpc/rpc.h>
     10
     11
     12#ifdef __cplusplus
     13extern "C" {
     14#endif
     15
     16
     17typedef struct {
     18        u_int confarray_len;
     19        char *confarray_val;
     20} confarray;
     21
     22struct RPCMarray {
     23        char *domain;
     24        u_long cellTypeLength;
     25        u_short currentFormat;
     26        u_short storageFormat;
     27        confarray data;
     28};
     29typedef struct RPCMarray RPCMarray;
     30
     31struct RPCClientEntry {
     32        u_long clientId;
     33        char *clientIdText;
     34        char *userName;
     35        char *baseName;
     36        u_long creationTime;
     37        u_long lastActionTime;
     38        u_long transferColl;
     39        u_long transferIter;
     40        u_long assembleMDD;
     41        u_long transferMDD;
     42        u_long transTiles;
     43        u_long tileIter;
     44        u_long bytesToTransfer;
     45};
     46typedef struct RPCClientEntry RPCClientEntry;
     47
     48struct RPCOIdEntry {
     49        char *oid;
     50};
     51typedef struct RPCOIdEntry RPCOIdEntry;
     52
     53struct OpenDBParams {
     54        char *dbName;
     55        char *userName;
     56        char *capability;
     57};
     58typedef struct OpenDBParams OpenDBParams;
     59
     60struct OpenDBRes {
     61        u_short status;
     62        u_long clientID;
     63};
     64typedef struct OpenDBRes OpenDBRes;
     65
     66struct BeginTAParams {
     67        u_long clientID;
     68        u_short readOnly;
     69        char *capability;
     70};
     71typedef struct BeginTAParams BeginTAParams;
     72
     73struct ExecuteQueryParams {
     74        u_long clientID;
     75        char *query;
     76};
     77typedef struct ExecuteQueryParams ExecuteQueryParams;
     78
     79struct ExecuteQueryRes {
     80        u_short status;
     81        u_long errorNo;
     82        u_long lineNo;
     83        u_long columnNo;
     84        char *token;
     85        char *typeName;
     86        char *typeStructure;
     87};
     88typedef struct ExecuteQueryRes ExecuteQueryRes;
     89
     90struct ExecuteUpdateRes {
     91        u_short status;
     92        u_long errorNo;
     93        u_long lineNo;
     94        u_long columnNo;
     95        char *token;
     96};
     97typedef struct ExecuteUpdateRes ExecuteUpdateRes;
     98
     99struct InsertCollParams {
     100        u_long clientID;
     101        char *collName;
     102        char *typeName;
     103        char *oid;
     104};
     105typedef struct InsertCollParams InsertCollParams;
     106
     107struct NameSpecParams {
     108        u_long clientID;
     109        char *name;
     110};
     111typedef struct NameSpecParams NameSpecParams;
     112
     113struct OIdSpecParams {
     114        u_long clientID;
     115        char *oid;
     116};
     117typedef struct OIdSpecParams OIdSpecParams;
     118
     119struct RemoveObjFromCollParams {
     120        u_long clientID;
     121        char *collName;
     122        char *oid;
     123};
     124typedef struct RemoveObjFromCollParams RemoveObjFromCollParams;
     125
     126struct GetCollRes {
     127        u_short status;
     128        char *typeName;
     129        char *typeStructure;
     130        char *oid;
     131        char *collName;
     132};
     133typedef struct GetCollRes GetCollRes;
     134
     135struct GetCollOIdsRes {
     136        u_short status;
     137        char *typeName;
     138        char *typeStructure;
     139        char *oid;
     140        char *collName;
     141        struct {
     142                u_int oidTable_len;
     143                RPCOIdEntry *oidTable_val;
     144        } oidTable;
     145};
     146typedef struct GetCollOIdsRes GetCollOIdsRes;
     147
     148struct GetMDDRes {
     149        u_short status;
     150        char *domain;
     151        char *typeName;
     152        char *typeStructure;
     153        char *oid;
     154        u_short currentFormat;
     155};
     156typedef struct GetMDDRes GetMDDRes;
     157
     158struct GetTileRes {
     159        u_short status;
     160        RPCMarray *marray;
     161};
     162typedef struct GetTileRes GetTileRes;
     163
     164struct OIdRes {
     165        u_short status;
     166        char *oid;
     167};
     168typedef struct OIdRes OIdRes;
     169
     170struct ObjectTypeRes {
     171        u_short status;
     172        u_short objType;
     173};
     174typedef struct ObjectTypeRes ObjectTypeRes;
     175
     176struct InsertMDDParams {
     177        u_long clientID;
     178        char *collName;
     179        char *typeName;
     180        char *oid;
     181        RPCMarray *marray;
     182};
     183typedef struct InsertMDDParams InsertMDDParams;
     184
     185struct InsertTileParams {
     186        u_long clientID;
     187        int isPersistent;
     188        RPCMarray *marray;
     189};
     190typedef struct InsertTileParams InsertTileParams;
     191
     192struct EndInsertMDDParams {
     193        u_long clientID;
     194        int isPersistent;
     195};
     196typedef struct EndInsertMDDParams EndInsertMDDParams;
     197
     198struct InsertTransMDDParams {
     199        u_long clientID;
     200        char *collName;
     201        char *domain;
     202        u_long typeLength;
     203        char *typeName;
     204};
     205typedef struct InsertTransMDDParams InsertTransMDDParams;
     206
     207struct InsertPersMDDParams {
     208        u_long clientID;
     209        char *collName;
     210        char *domain;
     211        u_long typeLength;
     212        char *typeName;
     213        char *oid;
     214};
     215typedef struct InsertPersMDDParams InsertPersMDDParams;
     216
     217struct NewOIdParams {
     218        u_long clientID;
     219        u_short objType;
     220};
     221typedef struct NewOIdParams NewOIdParams;
     222
     223struct ServerStatRes {
     224        u_short status;
     225        u_long inactivityTimeout;
     226        u_long managementInterval;
     227        u_long transactionActive;
     228        u_long maxTransferBufferSize;
     229        u_long nextClientId;
     230        u_long clientNumber;
     231        u_long memArena;
     232        u_long memSmblks;
     233        u_long memOrdblks;
     234        u_long memFordblks;
     235        u_long memUordblks;
     236        struct {
     237                u_int clientTable_len;
     238                RPCClientEntry *clientTable_val;
     239        } clientTable;
     240};
     241typedef struct ServerStatRes ServerStatRes;
     242
     243struct ServerVersionRes {
     244        u_short status;
     245        double serverVersionNo;
     246        double rpcInterfaceVersionNo;
     247};
     248typedef struct ServerVersionRes ServerVersionRes;
     249
     250struct GetTypeStructureParams {
     251        u_long clientID;
     252        char *typeName;
     253        u_short typeType;
     254};
     255typedef struct GetTypeStructureParams GetTypeStructureParams;
     256
     257struct GetTypeStructureRes {
     258        u_short status;
     259        char *typeStructure;
     260};
     261typedef struct GetTypeStructureRes GetTypeStructureRes;
     262
     263struct GetElementRes {
     264        u_short status;
     265        confarray data;
     266};
     267typedef struct GetElementRes GetElementRes;
     268
     269struct SetServerTransferParams {
     270        u_long clientID;
     271        u_short format;
     272        char *formatParams;
     273};
     274typedef struct SetServerTransferParams SetServerTransferParams;
     275
     276struct GetExtendedErrorInfo {
     277        u_short status;
     278        char *errorText;
     279};
     280typedef struct GetExtendedErrorInfo GetExtendedErrorInfo;
     281
     282#define RPCIF 0x29999999
     283#define RPCIFVERS 1
     284
     285#if defined(__STDC__) || defined(__cplusplus)
     286#define RPCGETSERVERVERSION 1
     287extern  ServerVersionRes * rpcgetserverversion_1(int *, CLIENT *);
     288extern  ServerVersionRes * rpcgetserverversion_1_svc(int *, struct svc_req *);
     289#define RPCSHUTDOWN 2
     290extern  u_short * rpcshutdown_1(int *, CLIENT *);
     291extern  u_short * rpcshutdown_1_svc(int *, struct svc_req *);
     292#define RPCSERVERSTAT 3
     293extern  ServerStatRes * rpcserverstat_1(int *, CLIENT *);
     294extern  ServerStatRes * rpcserverstat_1_svc(int *, struct svc_req *);
     295#define RPCKILLTABLEENTRY 4
     296extern  u_short * rpckilltableentry_1(u_long *, CLIENT *);
     297extern  u_short * rpckilltableentry_1_svc(u_long *, struct svc_req *);
     298#define RPCALIVE 5
     299extern  u_short * rpcalive_1(u_long *, CLIENT *);
     300extern  u_short * rpcalive_1_svc(u_long *, struct svc_req *);
     301#define RPCOPENDB 6
     302extern  OpenDBRes * rpcopendb_1(OpenDBParams *, CLIENT *);
     303extern  OpenDBRes * rpcopendb_1_svc(OpenDBParams *, struct svc_req *);
     304#define RPCCLOSEDB 7
     305extern  u_short * rpcclosedb_1(u_long *, CLIENT *);
     306extern  u_short * rpcclosedb_1_svc(u_long *, struct svc_req *);
     307#define RPCCREATEDB 8
     308extern  u_short * rpccreatedb_1(char **, CLIENT *);
     309extern  u_short * rpccreatedb_1_svc(char **, struct svc_req *);
     310#define RPCDESTROYDB 9
     311extern  u_short * rpcdestroydb_1(char **, CLIENT *);
     312extern  u_short * rpcdestroydb_1_svc(char **, struct svc_req *);
     313#define RPCBEGINTA 10
     314extern  u_short * rpcbeginta_1(BeginTAParams *, CLIENT *);
     315extern  u_short * rpcbeginta_1_svc(BeginTAParams *, struct svc_req *);
     316#define RPCCOMMITTA 11
     317extern  u_short * rpccommitta_1(u_long *, CLIENT *);
     318extern  u_short * rpccommitta_1_svc(u_long *, struct svc_req *);
     319#define RPCABORTTA 12
     320extern  u_short * rpcabortta_1(u_long *, CLIENT *);
     321extern  u_short * rpcabortta_1_svc(u_long *, struct svc_req *);
     322#define RPCEXECUTEQUERY 13
     323extern  ExecuteQueryRes * rpcexecutequery_1(ExecuteQueryParams *, CLIENT *);
     324extern  ExecuteQueryRes * rpcexecutequery_1_svc(ExecuteQueryParams *, struct svc_req *);
     325#define RPCGETNEXTMDD 14
     326extern  GetMDDRes * rpcgetnextmdd_1(u_long *, CLIENT *);
     327extern  GetMDDRes * rpcgetnextmdd_1_svc(u_long *, struct svc_req *);
     328#define RPCGETMDDBYOID 15
     329extern  GetMDDRes * rpcgetmddbyoid_1(OIdSpecParams *, CLIENT *);
     330extern  GetMDDRes * rpcgetmddbyoid_1_svc(OIdSpecParams *, struct svc_req *);
     331#define RPCGETNEXTTILE 16
     332extern  GetTileRes * rpcgetnexttile_1(u_long *, CLIENT *);
     333extern  GetTileRes * rpcgetnexttile_1_svc(u_long *, struct svc_req *);
     334#define RPCENDTRANSFER 17
     335extern  u_short * rpcendtransfer_1(u_long *, CLIENT *);
     336extern  u_short * rpcendtransfer_1_svc(u_long *, struct svc_req *);
     337#define RPCINITEXECUTEUPDATE 18
     338extern  u_short * rpcinitexecuteupdate_1(u_long *, CLIENT *);
     339extern  u_short * rpcinitexecuteupdate_1_svc(u_long *, struct svc_req *);
     340#define RPCEXECUTEUPDATE 19
     341extern  ExecuteUpdateRes * rpcexecuteupdate_1(ExecuteQueryParams *, CLIENT *);
     342extern  ExecuteUpdateRes * rpcexecuteupdate_1_svc(ExecuteQueryParams *, struct svc_req *);
     343#define RPCSTARTINSERTTRANSMDD 20
     344extern  u_short * rpcstartinserttransmdd_1(InsertTransMDDParams *, CLIENT *);
     345extern  u_short * rpcstartinserttransmdd_1_svc(InsertTransMDDParams *, struct svc_req *);
     346#define RPCSTARTINSERTPERSMDD 21
     347extern  u_short * rpcstartinsertpersmdd_1(InsertPersMDDParams *, CLIENT *);
     348extern  u_short * rpcstartinsertpersmdd_1_svc(InsertPersMDDParams *, struct svc_req *);
     349#define RPCINSERTTILE 22
     350extern  u_short * rpcinserttile_1(InsertTileParams *, CLIENT *);
     351extern  u_short * rpcinserttile_1_svc(InsertTileParams *, struct svc_req *);
     352#define RPCENDINSERTMDD 23
     353extern  u_short * rpcendinsertmdd_1(EndInsertMDDParams *, CLIENT *);
     354extern  u_short * rpcendinsertmdd_1_svc(EndInsertMDDParams *, struct svc_req *);
     355#define RPCINSERTMDD 24
     356extern  u_short * rpcinsertmdd_1(InsertMDDParams *, CLIENT *);
     357extern  u_short * rpcinsertmdd_1_svc(InsertMDDParams *, struct svc_req *);
     358#define RPCGETCOLLBYNAME 25
     359extern  GetCollRes * rpcgetcollbyname_1(NameSpecParams *, CLIENT *);
     360extern  GetCollRes * rpcgetcollbyname_1_svc(NameSpecParams *, struct svc_req *);
     361#define RPCGETCOLLBYOID 26
     362extern  GetCollRes * rpcgetcollbyoid_1(OIdSpecParams *, CLIENT *);
     363extern  GetCollRes * rpcgetcollbyoid_1_svc(OIdSpecParams *, struct svc_req *);
     364#define RPCGETCOLLOIDSBYNAME 27
     365extern  GetCollOIdsRes * rpcgetcolloidsbyname_1(NameSpecParams *, CLIENT *);
     366extern  GetCollOIdsRes * rpcgetcolloidsbyname_1_svc(NameSpecParams *, struct svc_req *);
     367#define RPCGETCOLLOIDSBYOID 28
     368extern  GetCollOIdsRes * rpcgetcolloidsbyoid_1(OIdSpecParams *, CLIENT *);
     369extern  GetCollOIdsRes * rpcgetcolloidsbyoid_1_svc(OIdSpecParams *, struct svc_req *);
     370#define RPCINSERTCOLL 29
     371extern  u_short * rpcinsertcoll_1(InsertCollParams *, CLIENT *);
     372extern  u_short * rpcinsertcoll_1_svc(InsertCollParams *, struct svc_req *);
     373#define RPCDELETECOLLBYNAME 30
     374extern  u_short * rpcdeletecollbyname_1(NameSpecParams *, CLIENT *);
     375extern  u_short * rpcdeletecollbyname_1_svc(NameSpecParams *, struct svc_req *);
     376#define RPCDELETEOBJBYOID 31
     377extern  u_short * rpcdeleteobjbyoid_1(OIdSpecParams *, CLIENT *);
     378extern  u_short * rpcdeleteobjbyoid_1_svc(OIdSpecParams *, struct svc_req *);
     379#define RPCREMOVEOBJFROMCOLL 32
     380extern  u_short * rpcremoveobjfromcoll_1(RemoveObjFromCollParams *, CLIENT *);
     381extern  u_short * rpcremoveobjfromcoll_1_svc(RemoveObjFromCollParams *, struct svc_req *);
     382#define RPCGETNEWOID 33
     383extern  OIdRes * rpcgetnewoid_1(NewOIdParams *, CLIENT *);
     384extern  OIdRes * rpcgetnewoid_1_svc(NewOIdParams *, struct svc_req *);
     385#define RPCGETOBJECTTYPE 34
     386extern  ObjectTypeRes * rpcgetobjecttype_1(OIdSpecParams *, CLIENT *);
     387extern  ObjectTypeRes * rpcgetobjecttype_1_svc(OIdSpecParams *, struct svc_req *);
     388#define RPCGETTYPESTRUCTURE 35
     389extern  GetTypeStructureRes * rpcgettypestructure_1(GetTypeStructureParams *, CLIENT *);
     390extern  GetTypeStructureRes * rpcgettypestructure_1_svc(GetTypeStructureParams *, struct svc_req *);
     391#define RPCGETNEXTELEMENT 36
     392extern  GetElementRes * rpcgetnextelement_1(u_long *, CLIENT *);
     393extern  GetElementRes * rpcgetnextelement_1_svc(u_long *, struct svc_req *);
     394#define RPCGETSERVERENDIAN 37
     395extern  int * rpcgetserverendian_1(int *, CLIENT *);
     396extern  int * rpcgetserverendian_1_svc(int *, struct svc_req *);
     397#define RPCSETSERVERTRANSFER 38
     398extern  u_short * rpcsetservertransfer_1(SetServerTransferParams *, CLIENT *);
     399extern  u_short * rpcsetservertransfer_1_svc(SetServerTransferParams *, struct svc_req *);
     400#define RPCGETERRORINFO 39
     401extern  GetExtendedErrorInfo * rpcgeterrorinfo_1(void *, CLIENT *);
     402extern  GetExtendedErrorInfo * rpcgeterrorinfo_1_svc(void *, struct svc_req *);
     403#define RPCSETSERVERSTORAGE 40
     404extern  u_short * rpcsetserverstorage_1(SetServerTransferParams *, CLIENT *);
     405extern  u_short * rpcsetserverstorage_1_svc(SetServerTransferParams *, struct svc_req *);
     406extern int rpcif_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
     407
     408#else /* K&R C */
     409#define RPCGETSERVERVERSION 1
     410extern  ServerVersionRes * rpcgetserverversion_1();
     411extern  ServerVersionRes * rpcgetserverversion_1_svc();
     412#define RPCSHUTDOWN 2
     413extern  u_short * rpcshutdown_1();
     414extern  u_short * rpcshutdown_1_svc();
     415#define RPCSERVERSTAT 3
     416extern  ServerStatRes * rpcserverstat_1();
     417extern  ServerStatRes * rpcserverstat_1_svc();
     418#define RPCKILLTABLEENTRY 4
     419extern  u_short * rpckilltableentry_1();
     420extern  u_short * rpckilltableentry_1_svc();
     421#define RPCALIVE 5
     422extern  u_short * rpcalive_1();
     423extern  u_short * rpcalive_1_svc();
     424#define RPCOPENDB 6
     425extern  OpenDBRes * rpcopendb_1();
     426extern  OpenDBRes * rpcopendb_1_svc();
     427#define RPCCLOSEDB 7
     428extern  u_short * rpcclosedb_1();
     429extern  u_short * rpcclosedb_1_svc();
     430#define RPCCREATEDB 8
     431extern  u_short * rpccreatedb_1();
     432extern  u_short * rpccreatedb_1_svc();
     433#define RPCDESTROYDB 9
     434extern  u_short * rpcdestroydb_1();
     435extern  u_short * rpcdestroydb_1_svc();
     436#define RPCBEGINTA 10
     437extern  u_short * rpcbeginta_1();
     438extern  u_short * rpcbeginta_1_svc();
     439#define RPCCOMMITTA 11
     440extern  u_short * rpccommitta_1();
     441extern  u_short * rpccommitta_1_svc();
     442#define RPCABORTTA 12
     443extern  u_short * rpcabortta_1();
     444extern  u_short * rpcabortta_1_svc();
     445#define RPCEXECUTEQUERY 13
     446extern  ExecuteQueryRes * rpcexecutequery_1();
     447extern  ExecuteQueryRes * rpcexecutequery_1_svc();
     448#define RPCGETNEXTMDD 14
     449extern  GetMDDRes * rpcgetnextmdd_1();
     450extern  GetMDDRes * rpcgetnextmdd_1_svc();
     451#define RPCGETMDDBYOID 15
     452extern  GetMDDRes * rpcgetmddbyoid_1();
     453extern  GetMDDRes * rpcgetmddbyoid_1_svc();
     454#define RPCGETNEXTTILE 16
     455extern  GetTileRes * rpcgetnexttile_1();
     456extern  GetTileRes * rpcgetnexttile_1_svc();
     457#define RPCENDTRANSFER 17
     458extern  u_short * rpcendtransfer_1();
     459extern  u_short * rpcendtransfer_1_svc();
     460#define RPCINITEXECUTEUPDATE 18
     461extern  u_short * rpcinitexecuteupdate_1();
     462extern  u_short * rpcinitexecuteupdate_1_svc();
     463#define RPCEXECUTEUPDATE 19
     464extern  ExecuteUpdateRes * rpcexecuteupdate_1();
     465extern  ExecuteUpdateRes * rpcexecuteupdate_1_svc();
     466#define RPCSTARTINSERTTRANSMDD 20
     467extern  u_short * rpcstartinserttransmdd_1();
     468extern  u_short * rpcstartinserttransmdd_1_svc();
     469#define RPCSTARTINSERTPERSMDD 21
     470extern  u_short * rpcstartinsertpersmdd_1();
     471extern  u_short * rpcstartinsertpersmdd_1_svc();
     472#define RPCINSERTTILE 22
     473extern  u_short * rpcinserttile_1();
     474extern  u_short * rpcinserttile_1_svc();
     475#define RPCENDINSERTMDD 23
     476extern  u_short * rpcendinsertmdd_1();
     477extern  u_short * rpcendinsertmdd_1_svc();
     478#define RPCINSERTMDD 24
     479extern  u_short * rpcinsertmdd_1();
     480extern  u_short * rpcinsertmdd_1_svc();
     481#define RPCGETCOLLBYNAME 25
     482extern  GetCollRes * rpcgetcollbyname_1();
     483extern  GetCollRes * rpcgetcollbyname_1_svc();
     484#define RPCGETCOLLBYOID 26
     485extern  GetCollRes * rpcgetcollbyoid_1();
     486extern  GetCollRes * rpcgetcollbyoid_1_svc();
     487#define RPCGETCOLLOIDSBYNAME 27
     488extern  GetCollOIdsRes * rpcgetcolloidsbyname_1();
     489extern  GetCollOIdsRes * rpcgetcolloidsbyname_1_svc();
     490#define RPCGETCOLLOIDSBYOID 28
     491extern  GetCollOIdsRes * rpcgetcolloidsbyoid_1();
     492extern  GetCollOIdsRes * rpcgetcolloidsbyoid_1_svc();
     493#define RPCINSERTCOLL 29
     494extern  u_short * rpcinsertcoll_1();
     495extern  u_short * rpcinsertcoll_1_svc();
     496#define RPCDELETECOLLBYNAME 30
     497extern  u_short * rpcdeletecollbyname_1();
     498extern  u_short * rpcdeletecollbyname_1_svc();
     499#define RPCDELETEOBJBYOID 31
     500extern  u_short * rpcdeleteobjbyoid_1();
     501extern  u_short * rpcdeleteobjbyoid_1_svc();
     502#define RPCREMOVEOBJFROMCOLL 32
     503extern  u_short * rpcremoveobjfromcoll_1();
     504extern  u_short * rpcremoveobjfromcoll_1_svc();
     505#define RPCGETNEWOID 33
     506extern  OIdRes * rpcgetnewoid_1();
     507extern  OIdRes * rpcgetnewoid_1_svc();
     508#define RPCGETOBJECTTYPE 34
     509extern  ObjectTypeRes * rpcgetobjecttype_1();
     510extern  ObjectTypeRes * rpcgetobjecttype_1_svc();
     511#define RPCGETTYPESTRUCTURE 35
     512extern  GetTypeStructureRes * rpcgettypestructure_1();
     513extern  GetTypeStructureRes * rpcgettypestructure_1_svc();
     514#define RPCGETNEXTELEMENT 36
     515extern  GetElementRes * rpcgetnextelement_1();
     516extern  GetElementRes * rpcgetnextelement_1_svc();
     517#define RPCGETSERVERENDIAN 37
     518extern  int * rpcgetserverendian_1();
     519extern  int * rpcgetserverendian_1_svc();
     520#define RPCSETSERVERTRANSFER 38
     521extern  u_short * rpcsetservertransfer_1();
     522extern  u_short * rpcsetservertransfer_1_svc();
     523#define RPCGETERRORINFO 39
     524extern  GetExtendedErrorInfo * rpcgeterrorinfo_1();
     525extern  GetExtendedErrorInfo * rpcgeterrorinfo_1_svc();
     526#define RPCSETSERVERSTORAGE 40
     527extern  u_short * rpcsetserverstorage_1();
     528extern  u_short * rpcsetserverstorage_1_svc();
     529extern int rpcif_1_freeresult ();
     530#endif /* K&R C */
     531
     532/* the xdr functions */
     533
     534#if defined(__STDC__) || defined(__cplusplus)
     535extern  bool_t xdr_confarray (XDR *, confarray*);
     536extern  bool_t xdr_RPCMarray (XDR *, RPCMarray*);
     537extern  bool_t xdr_RPCClientEntry (XDR *, RPCClientEntry*);
     538extern  bool_t xdr_RPCOIdEntry (XDR *, RPCOIdEntry*);
     539#ifdef __cplusplus
     540  extern "C" {bool_t xdr_OpenDBParams(); }
     541#else
     542  bool_t xdr_OpenDBParams();
     543#endif
     544#ifdef __cplusplus
     545  extern "C" {bool_t xdr_OpenDBRes(); }
     546#else
     547  bool_t xdr_OpenDBRes();
     548#endif
     549#ifdef __cplusplus
     550  extern "C" {bool_t xdr_BeginTAParams(); }
     551#else
     552  bool_t xdr_BeginTAParams();
     553#endif
     554#ifdef __cplusplus
     555  extern "C" {bool_t xdr_ExecuteQueryParams(); }
     556#else
     557  bool_t xdr_ExecuteQueryParams();
     558#endif
     559#ifdef __cplusplus
     560  extern "C" {bool_t xdr_ExecuteQueryRes(); }
     561#else
     562  bool_t xdr_ExecuteQueryRes();
     563#endif
     564#ifdef __cplusplus
     565  extern "C" {bool_t xdr_ExecuteUpdateRes(); }
     566#else
     567  bool_t xdr_ExecuteUpdateRes();
     568#endif
     569#ifdef __cplusplus
     570  extern "C" {bool_t xdr_InsertCollParams(); }
     571#else
     572  bool_t xdr_InsertCollParams();
     573#endif
     574#ifdef __cplusplus
     575  extern "C" {bool_t xdr_NameSpecParams(); }
     576#else
     577  bool_t xdr_NameSpecParams();
     578#endif
     579#ifdef __cplusplus
     580  extern "C" {bool_t xdr_OIdSpecParams(); }
     581#else
     582  bool_t xdr_OIdSpecParams();
     583#endif
     584#ifdef __cplusplus
     585  extern "C" {bool_t xdr_RemoveObjFromCollParams(); }
     586#else
     587  bool_t xdr_RemoveObjFromCollParams();
     588#endif
     589#ifdef __cplusplus
     590  extern "C" {bool_t xdr_GetCollRes(); }
     591#else
     592  bool_t xdr_GetCollRes();
     593#endif
     594#ifdef __cplusplus
     595  extern "C" {bool_t xdr_GetCollOIdsRes(); }
     596#else
     597  bool_t xdr_GetCollOIdsRes();
     598#endif
     599#ifdef __cplusplus
     600  extern "C" {bool_t xdr_GetMDDRes(); }
     601#else
     602  bool_t xdr_GetMDDRes();
     603#endif
     604#ifdef __cplusplus
     605  extern "C" {bool_t xdr_GetTileRes(); }
     606#else
     607  bool_t xdr_GetTileRes();
     608#endif
     609#ifdef __cplusplus
     610  extern "C" {bool_t xdr_OIdRes(); }
     611#else
     612  bool_t xdr_OIdRes();
     613#endif
     614#ifdef __cplusplus
     615  extern "C" {bool_t xdr_ObjectTypeRes(); }
     616#else
     617  bool_t xdr_ObjectTypeRes();
     618#endif
     619#ifdef __cplusplus
     620  extern "C" {bool_t xdr_InsertMDDParams(); }
     621#else
     622  bool_t xdr_InsertMDDParams();
     623#endif
     624#ifdef __cplusplus
     625  extern "C" {bool_t xdr_InsertTileParams(); }
     626#else
     627  bool_t xdr_InsertTileParams();
     628#endif
     629#ifdef __cplusplus
     630  extern "C" {bool_t xdr_EndInsertMDDParams(); }
     631#else
     632  bool_t xdr_EndInsertMDDParams();
     633#endif
     634#ifdef __cplusplus
     635  extern "C" {bool_t xdr_InsertTransMDDParams(); }
     636#else
     637  bool_t xdr_InsertTransMDDParams();
     638#endif
     639#ifdef __cplusplus
     640  extern "C" {bool_t xdr_InsertPersMDDParams(); }
     641#else
     642  bool_t xdr_InsertPersMDDParams();
     643#endif
     644#ifdef __cplusplus
     645  extern "C" {bool_t xdr_NewOIdParams(); }
     646#else
     647  bool_t xdr_NewOIdParams();
     648#endif
     649#ifdef __cplusplus
     650  extern "C" {bool_t xdr_ServerStatRes(); }
     651#else
     652  bool_t xdr_ServerStatRes();
     653#endif
     654#ifdef __cplusplus
     655  extern "C" {bool_t xdr_ServerVersionRes(); }
     656#else
     657  bool_t xdr_ServerVersionRes();
     658#endif
     659#ifdef __cplusplus
     660  extern "C" {bool_t xdr_GetTypeStructureParams(); }
     661#else
     662  bool_t xdr_GetTypeStructureParams();
     663#endif
     664#ifdef __cplusplus
     665  extern "C" {bool_t xdr_GetTypeStructureRes(); }
     666#else
     667  bool_t xdr_GetTypeStructureRes();
     668#endif
     669#ifdef __cplusplus
     670  extern "C" {bool_t xdr_GetElementRes(); }
     671#else
     672  bool_t xdr_GetElementRes();
     673#endif
     674#ifdef __cplusplus
     675  extern "C" {bool_t xdr_SetServerTransferParams(); }
     676#else
     677  bool_t xdr_SetServerTransferParams();
     678#endif
     679#ifdef __cplusplus
     680  extern "C" {bool_t xdr_GetExtendedErrorInfo(); }
     681#else
     682  bool_t xdr_GetExtendedErrorInfo();
     683#endif
     684
     685#else /* K&R C */
     686extern bool_t xdr_confarray ();
     687extern bool_t xdr_RPCMarray ();
     688extern bool_t xdr_RPCClientEntry ();
     689extern bool_t xdr_RPCOIdEntry ();
     690#ifdef __cplusplus
     691  extern "C" {bool_t xdr_OpenDBParams(); }
     692#else
     693  bool_t xdr_OpenDBParams();
     694#endif
     695#ifdef __cplusplus
     696  extern "C" {bool_t xdr_OpenDBRes(); }
     697#else
     698  bool_t xdr_OpenDBRes();
     699#endif
     700#ifdef __cplusplus
     701  extern "C" {bool_t xdr_BeginTAParams(); }
     702#else
     703  bool_t xdr_BeginTAParams();
     704#endif
     705#ifdef __cplusplus
     706  extern "C" {bool_t xdr_ExecuteQueryParams(); }
     707#else
     708  bool_t xdr_ExecuteQueryParams();
     709#endif
     710#ifdef __cplusplus
     711  extern "C" {bool_t xdr_ExecuteQueryRes(); }
     712#else
     713  bool_t xdr_ExecuteQueryRes();
     714#endif
     715#ifdef __cplusplus
     716  extern "C" {bool_t xdr_ExecuteUpdateRes(); }
     717#else
     718  bool_t xdr_ExecuteUpdateRes();
     719#endif
     720#ifdef __cplusplus
     721  extern "C" {bool_t xdr_InsertCollParams(); }
     722#else
     723  bool_t xdr_InsertCollParams();
     724#endif
     725#ifdef __cplusplus
     726  extern "C" {bool_t xdr_NameSpecParams(); }
     727#else
     728  bool_t xdr_NameSpecParams();
     729#endif
     730#ifdef __cplusplus
     731  extern "C" {bool_t xdr_OIdSpecParams(); }
     732#else
     733  bool_t xdr_OIdSpecParams();
     734#endif
     735#ifdef __cplusplus
     736  extern "C" {bool_t xdr_RemoveObjFromCollParams(); }
     737#else
     738  bool_t xdr_RemoveObjFromCollParams();
     739#endif
     740#ifdef __cplusplus
     741  extern "C" {bool_t xdr_GetCollRes(); }
     742#else
     743  bool_t xdr_GetCollRes();
     744#endif
     745#ifdef __cplusplus
     746  extern "C" {bool_t xdr_GetCollOIdsRes(); }
     747#else
     748  bool_t xdr_GetCollOIdsRes();
     749#endif
     750#ifdef __cplusplus
     751  extern "C" {bool_t xdr_GetMDDRes(); }
     752#else
     753  bool_t xdr_GetMDDRes();
     754#endif
     755#ifdef __cplusplus
     756  extern "C" {bool_t xdr_GetTileRes(); }
     757#else
     758  bool_t xdr_GetTileRes();
     759#endif
     760#ifdef __cplusplus
     761  extern "C" {bool_t xdr_OIdRes(); }
     762#else
     763  bool_t xdr_OIdRes();
     764#endif
     765#ifdef __cplusplus
     766  extern "C" {bool_t xdr_ObjectTypeRes(); }
     767#else
     768  bool_t xdr_ObjectTypeRes();
     769#endif
     770#ifdef __cplusplus
     771  extern "C" {bool_t xdr_InsertMDDParams(); }
     772#else
     773  bool_t xdr_InsertMDDParams();
     774#endif
     775#ifdef __cplusplus
     776  extern "C" {bool_t xdr_InsertTileParams(); }
     777#else
     778  bool_t xdr_InsertTileParams();
     779#endif
     780#ifdef __cplusplus
     781  extern "C" {bool_t xdr_EndInsertMDDParams(); }
     782#else
     783  bool_t xdr_EndInsertMDDParams();
     784#endif
     785#ifdef __cplusplus
     786  extern "C" {bool_t xdr_InsertTransMDDParams(); }
     787#else
     788  bool_t xdr_InsertTransMDDParams();
     789#endif
     790#ifdef __cplusplus
     791  extern "C" {bool_t xdr_InsertPersMDDParams(); }
     792#else
     793  bool_t xdr_InsertPersMDDParams();
     794#endif
     795#ifdef __cplusplus
     796  extern "C" {bool_t xdr_NewOIdParams(); }
     797#else
     798  bool_t xdr_NewOIdParams();
     799#endif
     800#ifdef __cplusplus
     801  extern "C" {bool_t xdr_ServerStatRes(); }
     802#else
     803  bool_t xdr_ServerStatRes();
     804#endif
     805#ifdef __cplusplus
     806  extern "C" {bool_t xdr_ServerVersionRes(); }
     807#else
     808  bool_t xdr_ServerVersionRes();
     809#endif
     810#ifdef __cplusplus
     811  extern "C" {bool_t xdr_GetTypeStructureParams(); }
     812#else
     813  bool_t xdr_GetTypeStructureParams();
     814#endif
     815#ifdef __cplusplus
     816  extern "C" {bool_t xdr_GetTypeStructureRes(); }
     817#else
     818  bool_t xdr_GetTypeStructureRes();
     819#endif
     820#ifdef __cplusplus
     821  extern "C" {bool_t xdr_GetElementRes(); }
     822#else
     823  bool_t xdr_GetElementRes();
     824#endif
     825#ifdef __cplusplus
     826  extern "C" {bool_t xdr_SetServerTransferParams(); }
     827#else
     828  bool_t xdr_SetServerTransferParams();
     829#endif
     830#ifdef __cplusplus
     831  extern "C" {bool_t xdr_GetExtendedErrorInfo(); }
     832#else
     833  bool_t xdr_GetExtendedErrorInfo();
     834#endif
     835
     836#endif /* K&R C */
     837
     838#ifdef __cplusplus
     839}
     840#endif
     841
     842#endif /* !_RPCIF.H_H_RPCGEN */

  • new file clientcomm/rpcif_clnt.cc 

    diff --git a/clientcomm/rpcif_clnt.cc b/clientcomm/rpcif_clnt.cc
new file mode 100644
index 0000000..6039548
    - +  
     1#include <stdio.h>
     2#include "raslib/error.hh"
     3#include "raslib/rminit.hh"
     4/*
     5 * Please do not edit this file.
     6 * It was generated using rpcgen.
     7 */
     8
     9#include <memory.h> /* for memset */
     10#include "rpcif.h"
     11
     12/* Default timeout can be changed using clnt_control() */
     13static struct timeval TIMEOUT = { 25, 0 };
     14
     15ServerVersionRes *
     16rpcgetserverversion_1(int *argp, CLIENT *clnt)
     17{
     18        static ServerVersionRes clnt_res;
     19        enum clnt_stat stat;
     20
     21
     22        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     23        if ( (stat = clnt_call (clnt, RPCGETSERVERVERSION,
     24                (xdrproc_t) xdr_int, (caddr_t) argp,
     25                (xdrproc_t) xdr_ServerVersionRes, (caddr_t) &clnt_res,
     26                TIMEOUT) ) != RPC_SUCCESS ) {
     27                clnt_perrno( stat );
     28                return (NULL);
     29                }
     30        if (*((u_short*)&clnt_res) == 42)
     31                {
     32                GetExtendedErrorInfo* result = NULL;
     33                int dummy;
     34                int counter = 0;
     35                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     36                        {
     37                        counter++;
     38                        }
     39                r_Error* t = NULL, e;
     40                if (counter == RMInit::rpcMaxRetry)
     41                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     42                else
     43                        t = r_Error::getAnyError(result->errorText);
     44                e=*t;
     45                delete t;
     46                throw e;
     47        }
     48        return (&clnt_res);
     49}
     50
     51u_short *
     52rpcshutdown_1(int *argp, CLIENT *clnt)
     53{
     54        static u_short clnt_res;
     55
     56        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     57        if (clnt_call (clnt, RPCSHUTDOWN,
     58                (xdrproc_t) xdr_int, (caddr_t) argp,
     59                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     60                TIMEOUT) != RPC_SUCCESS) {
     61                return (NULL);
     62        }
     63        return (&clnt_res);
     64}
     65
     66ServerStatRes *
     67rpcserverstat_1(int *argp, CLIENT *clnt)
     68{
     69        static ServerStatRes clnt_res;
     70        enum clnt_stat stat;
     71
     72
     73        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     74        if ( (stat = clnt_call (clnt, RPCSERVERSTAT,
     75                (xdrproc_t) xdr_int, (caddr_t) argp,
     76                (xdrproc_t) xdr_ServerStatRes, (caddr_t) &clnt_res,
     77                TIMEOUT) ) != RPC_SUCCESS ) {
     78                clnt_perrno( stat );
     79                return (NULL);
     80                }
     81        if (*((u_short*)&clnt_res) == 42)
     82                {
     83                GetExtendedErrorInfo* result = NULL;
     84                int dummy;
     85                int counter = 0;
     86                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     87                        {
     88                        counter++;
     89                        }
     90                r_Error* t = NULL, e;
     91                if (counter == RMInit::rpcMaxRetry)
     92                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     93                else
     94                        t = r_Error::getAnyError(result->errorText);
     95                e=*t;
     96                delete t;
     97                throw e;
     98        }
     99        return (&clnt_res);
     100}
     101
     102u_short *
     103rpckilltableentry_1(u_long *argp, CLIENT *clnt)
     104{
     105        static u_short clnt_res;
     106        enum clnt_stat stat;
     107
     108
     109        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     110        if ( (stat = clnt_call (clnt, RPCKILLTABLEENTRY,
     111                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     112                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     113                TIMEOUT) ) != RPC_SUCCESS ) {
     114                clnt_perrno( stat );
     115                return (NULL);
     116                }
     117        if (*((u_short*)&clnt_res) == 42)
     118                {
     119                GetExtendedErrorInfo* result = NULL;
     120                int dummy;
     121                int counter = 0;
     122                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     123                        {
     124                        counter++;
     125                        }
     126                r_Error* t = NULL, e;
     127                if (counter == RMInit::rpcMaxRetry)
     128                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     129                else
     130                        t = r_Error::getAnyError(result->errorText);
     131                e=*t;
     132                delete t;
     133                throw e;
     134        }
     135        return (&clnt_res);
     136}
     137
     138u_short *
     139rpcalive_1(u_long *argp, CLIENT *clnt)
     140{
     141        static u_short clnt_res;
     142        enum clnt_stat stat;
     143
     144
     145        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     146        if ( (stat = clnt_call (clnt, RPCALIVE,
     147                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     148                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     149                TIMEOUT) ) != RPC_SUCCESS ) {
     150                clnt_perrno( stat );
     151                return (NULL);
     152                }
     153        if (*((u_short*)&clnt_res) == 42)
     154                {
     155                GetExtendedErrorInfo* result = NULL;
     156                int dummy;
     157                int counter = 0;
     158                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     159                        {
     160                        counter++;
     161                        }
     162                r_Error* t = NULL, e;
     163                if (counter == RMInit::rpcMaxRetry)
     164                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     165                else
     166                        t = r_Error::getAnyError(result->errorText);
     167                e=*t;
     168                delete t;
     169                throw e;
     170        }
     171        return (&clnt_res);
     172}
     173
     174OpenDBRes *
     175rpcopendb_1(OpenDBParams *argp, CLIENT *clnt)
     176{
     177        static OpenDBRes clnt_res;
     178        enum clnt_stat stat;
     179
     180
     181        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     182        if ( (stat = clnt_call (clnt, RPCOPENDB,
     183                (xdrproc_t) xdr_OpenDBParams, (caddr_t) argp,
     184                (xdrproc_t) xdr_OpenDBRes, (caddr_t) &clnt_res,
     185                TIMEOUT) ) != RPC_SUCCESS ) {
     186                clnt_perrno( stat );
     187                return (NULL);
     188                }
     189        if (*((u_short*)&clnt_res) == 42)
     190                {
     191                GetExtendedErrorInfo* result = NULL;
     192                int dummy;
     193                int counter = 0;
     194                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     195                        {
     196                        counter++;
     197                        }
     198                r_Error* t = NULL, e;
     199                if (counter == RMInit::rpcMaxRetry)
     200                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     201                else
     202                        t = r_Error::getAnyError(result->errorText);
     203                e=*t;
     204                delete t;
     205                throw e;
     206        }
     207        return (&clnt_res);
     208}
     209
     210u_short *
     211rpcclosedb_1(u_long *argp, CLIENT *clnt)
     212{
     213        static u_short clnt_res;
     214        enum clnt_stat stat;
     215
     216
     217        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     218        if ( (stat = clnt_call (clnt, RPCCLOSEDB,
     219                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     220                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     221                TIMEOUT) ) != RPC_SUCCESS ) {
     222                clnt_perrno( stat );
     223                return (NULL);
     224                }
     225        if (*((u_short*)&clnt_res) == 42)
     226                {
     227                GetExtendedErrorInfo* result = NULL;
     228                int dummy;
     229                int counter = 0;
     230                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     231                        {
     232                        counter++;
     233                        }
     234                r_Error* t = NULL, e;
     235                if (counter == RMInit::rpcMaxRetry)
     236                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     237                else
     238                        t = r_Error::getAnyError(result->errorText);
     239                e=*t;
     240                delete t;
     241                throw e;
     242        }
     243        return (&clnt_res);
     244}
     245
     246u_short *
     247rpccreatedb_1(char **argp, CLIENT *clnt)
     248{
     249        static u_short clnt_res;
     250        enum clnt_stat stat;
     251
     252
     253        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     254        if ( (stat = clnt_call (clnt, RPCCREATEDB,
     255                (xdrproc_t) xdr_wrapstring, (caddr_t) argp,
     256                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     257                TIMEOUT) ) != RPC_SUCCESS ) {
     258                clnt_perrno( stat );
     259                return (NULL);
     260                }
     261        if (*((u_short*)&clnt_res) == 42)
     262                {
     263                GetExtendedErrorInfo* result = NULL;
     264                int dummy;
     265                int counter = 0;
     266                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     267                        {
     268                        counter++;
     269                        }
     270                r_Error* t = NULL, e;
     271                if (counter == RMInit::rpcMaxRetry)
     272                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     273                else
     274                        t = r_Error::getAnyError(result->errorText);
     275                e=*t;
     276                delete t;
     277                throw e;
     278        }
     279        return (&clnt_res);
     280}
     281
     282u_short *
     283rpcdestroydb_1(char **argp, CLIENT *clnt)
     284{
     285        static u_short clnt_res;
     286        enum clnt_stat stat;
     287
     288
     289        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     290        if ( (stat = clnt_call (clnt, RPCDESTROYDB,
     291                (xdrproc_t) xdr_wrapstring, (caddr_t) argp,
     292                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     293                TIMEOUT) ) != RPC_SUCCESS ) {
     294                clnt_perrno( stat );
     295                return (NULL);
     296                }
     297        if (*((u_short*)&clnt_res) == 42)
     298                {
     299                GetExtendedErrorInfo* result = NULL;
     300                int dummy;
     301                int counter = 0;
     302                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     303                        {
     304                        counter++;
     305                        }
     306                r_Error* t = NULL, e;
     307                if (counter == RMInit::rpcMaxRetry)
     308                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     309                else
     310                        t = r_Error::getAnyError(result->errorText);
     311                e=*t;
     312                delete t;
     313                throw e;
     314        }
     315        return (&clnt_res);
     316}
     317
     318u_short *
     319rpcbeginta_1(BeginTAParams *argp, CLIENT *clnt)
     320{
     321        static u_short clnt_res;
     322        enum clnt_stat stat;
     323
     324
     325        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     326        if ( (stat = clnt_call (clnt, RPCBEGINTA,
     327                (xdrproc_t) xdr_BeginTAParams, (caddr_t) argp,
     328                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     329                TIMEOUT) ) != RPC_SUCCESS ) {
     330                clnt_perrno( stat );
     331                return (NULL);
     332                }
     333        if (*((u_short*)&clnt_res) == 42)
     334                {
     335                GetExtendedErrorInfo* result = NULL;
     336                int dummy;
     337                int counter = 0;
     338                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     339                        {
     340                        counter++;
     341                        }
     342                r_Error* t = NULL, e;
     343                if (counter == RMInit::rpcMaxRetry)
     344                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     345                else
     346                        t = r_Error::getAnyError(result->errorText);
     347                e=*t;
     348                delete t;
     349                throw e;
     350        }
     351        return (&clnt_res);
     352}
     353
     354u_short *
     355rpccommitta_1(u_long *argp, CLIENT *clnt)
     356{
     357        static u_short clnt_res;
     358        enum clnt_stat stat;
     359
     360
     361        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     362        if ( (stat = clnt_call (clnt, RPCCOMMITTA,
     363                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     364                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     365                TIMEOUT) ) != RPC_SUCCESS ) {
     366                clnt_perrno( stat );
     367                return (NULL);
     368                }
     369        if (*((u_short*)&clnt_res) == 42)
     370                {
     371                GetExtendedErrorInfo* result = NULL;
     372                int dummy;
     373                int counter = 0;
     374                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     375                        {
     376                        counter++;
     377                        }
     378                r_Error* t = NULL, e;
     379                if (counter == RMInit::rpcMaxRetry)
     380                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     381                else
     382                        t = r_Error::getAnyError(result->errorText);
     383                e=*t;
     384                delete t;
     385                throw e;
     386        }
     387        return (&clnt_res);
     388}
     389
     390u_short *
     391rpcabortta_1(u_long *argp, CLIENT *clnt)
     392{
     393        static u_short clnt_res;
     394        enum clnt_stat stat;
     395
     396
     397        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     398        if ( (stat = clnt_call (clnt, RPCABORTTA,
     399                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     400                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     401                TIMEOUT) ) != RPC_SUCCESS ) {
     402                clnt_perrno( stat );
     403                return (NULL);
     404                }
     405        if (*((u_short*)&clnt_res) == 42)
     406                {
     407                GetExtendedErrorInfo* result = NULL;
     408                int dummy;
     409                int counter = 0;
     410                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     411                        {
     412                        counter++;
     413                        }
     414                r_Error* t = NULL, e;
     415                if (counter == RMInit::rpcMaxRetry)
     416                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     417                else
     418                        t = r_Error::getAnyError(result->errorText);
     419                e=*t;
     420                delete t;
     421                throw e;
     422        }
     423        return (&clnt_res);
     424}
     425
     426ExecuteQueryRes *
     427rpcexecutequery_1(ExecuteQueryParams *argp, CLIENT *clnt)
     428{
     429        static ExecuteQueryRes clnt_res;
     430        enum clnt_stat stat;
     431
     432
     433        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     434        if ( (stat = clnt_call (clnt, RPCEXECUTEQUERY,
     435                (xdrproc_t) xdr_ExecuteQueryParams, (caddr_t) argp,
     436                (xdrproc_t) xdr_ExecuteQueryRes, (caddr_t) &clnt_res,
     437                TIMEOUT) ) != RPC_SUCCESS ) {
     438                clnt_perrno( stat );
     439                return (NULL);
     440                }
     441        if (*((u_short*)&clnt_res) == 42)
     442                {
     443                GetExtendedErrorInfo* result = NULL;
     444                int dummy;
     445                int counter = 0;
     446                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     447                        {
     448                        counter++;
     449                        }
     450                r_Error* t = NULL, e;
     451                if (counter == RMInit::rpcMaxRetry)
     452                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     453                else
     454                        t = r_Error::getAnyError(result->errorText);
     455                e=*t;
     456                delete t;
     457                throw e;
     458        }
     459        return (&clnt_res);
     460}
     461
     462GetMDDRes *
     463rpcgetnextmdd_1(u_long *argp, CLIENT *clnt)
     464{
     465        static GetMDDRes clnt_res;
     466        enum clnt_stat stat;
     467
     468
     469        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     470        if ( (stat = clnt_call (clnt, RPCGETNEXTMDD,
     471                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     472                (xdrproc_t) xdr_GetMDDRes, (caddr_t) &clnt_res,
     473                TIMEOUT) ) != RPC_SUCCESS ) {
     474                clnt_perrno( stat );
     475                return (NULL);
     476                }
     477        if (*((u_short*)&clnt_res) == 42)
     478                {
     479                GetExtendedErrorInfo* result = NULL;
     480                int dummy;
     481                int counter = 0;
     482                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     483                        {
     484                        counter++;
     485                        }
     486                r_Error* t = NULL, e;
     487                if (counter == RMInit::rpcMaxRetry)
     488                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     489                else
     490                        t = r_Error::getAnyError(result->errorText);
     491                e=*t;
     492                delete t;
     493                throw e;
     494        }
     495        return (&clnt_res);
     496}
     497
     498GetMDDRes *
     499rpcgetmddbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
     500{
     501        static GetMDDRes clnt_res;
     502        enum clnt_stat stat;
     503
     504
     505        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     506        if ( (stat = clnt_call (clnt, RPCGETMDDBYOID,
     507                (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
     508                (xdrproc_t) xdr_GetMDDRes, (caddr_t) &clnt_res,
     509                TIMEOUT) ) != RPC_SUCCESS ) {
     510                clnt_perrno( stat );
     511                return (NULL);
     512                }
     513        if (*((u_short*)&clnt_res) == 42)
     514                {
     515                GetExtendedErrorInfo* result = NULL;
     516                int dummy;
     517                int counter = 0;
     518                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     519                        {
     520                        counter++;
     521                        }
     522                r_Error* t = NULL, e;
     523                if (counter == RMInit::rpcMaxRetry)
     524                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     525                else
     526                        t = r_Error::getAnyError(result->errorText);
     527                e=*t;
     528                delete t;
     529                throw e;
     530        }
     531        return (&clnt_res);
     532}
     533
     534GetTileRes *
     535rpcgetnexttile_1(u_long *argp, CLIENT *clnt)
     536{
     537        static GetTileRes clnt_res;
     538        enum clnt_stat stat;
     539
     540
     541        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     542        if ( (stat = clnt_call (clnt, RPCGETNEXTTILE,
     543                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     544                (xdrproc_t) xdr_GetTileRes, (caddr_t) &clnt_res,
     545                TIMEOUT) ) != RPC_SUCCESS ) {
     546                clnt_perrno( stat );
     547                return (NULL);
     548                }
     549        if (*((u_short*)&clnt_res) == 42)
     550                {
     551                GetExtendedErrorInfo* result = NULL;
     552                int dummy;
     553                int counter = 0;
     554                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     555                        {
     556                        counter++;
     557                        }
     558                r_Error* t = NULL, e;
     559                if (counter == RMInit::rpcMaxRetry)
     560                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     561                else
     562                        t = r_Error::getAnyError(result->errorText);
     563                e=*t;
     564                delete t;
     565                throw e;
     566        }
     567        return (&clnt_res);
     568}
     569
     570u_short *
     571rpcendtransfer_1(u_long *argp, CLIENT *clnt)
     572{
     573        static u_short clnt_res;
     574        enum clnt_stat stat;
     575
     576
     577        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     578        if ( (stat = clnt_call (clnt, RPCENDTRANSFER,
     579                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     580                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     581                TIMEOUT) ) != RPC_SUCCESS ) {
     582                clnt_perrno( stat );
     583                return (NULL);
     584                }
     585        if (*((u_short*)&clnt_res) == 42)
     586                {
     587                GetExtendedErrorInfo* result = NULL;
     588                int dummy;
     589                int counter = 0;
     590                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     591                        {
     592                        counter++;
     593                        }
     594                r_Error* t = NULL, e;
     595                if (counter == RMInit::rpcMaxRetry)
     596                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     597                else
     598                        t = r_Error::getAnyError(result->errorText);
     599                e=*t;
     600                delete t;
     601                throw e;
     602        }
     603        return (&clnt_res);
     604}
     605
     606u_short *
     607rpcinitexecuteupdate_1(u_long *argp, CLIENT *clnt)
     608{
     609        static u_short clnt_res;
     610        enum clnt_stat stat;
     611
     612
     613        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     614        if ( (stat = clnt_call (clnt, RPCINITEXECUTEUPDATE,
     615                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     616                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     617                TIMEOUT) ) != RPC_SUCCESS ) {
     618                clnt_perrno( stat );
     619                return (NULL);
     620                }
     621        if (*((u_short*)&clnt_res) == 42)
     622                {
     623                GetExtendedErrorInfo* result = NULL;
     624                int dummy;
     625                int counter = 0;
     626                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     627                        {
     628                        counter++;
     629                        }
     630                r_Error* t = NULL, e;
     631                if (counter == RMInit::rpcMaxRetry)
     632                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     633                else
     634                        t = r_Error::getAnyError(result->errorText);
     635                e=*t;
     636                delete t;
     637                throw e;
     638        }
     639        return (&clnt_res);
     640}
     641
     642ExecuteUpdateRes *
     643rpcexecuteupdate_1(ExecuteQueryParams *argp, CLIENT *clnt)
     644{
     645        static ExecuteUpdateRes clnt_res;
     646        enum clnt_stat stat;
     647
     648
     649        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     650        if ( (stat = clnt_call (clnt, RPCEXECUTEUPDATE,
     651                (xdrproc_t) xdr_ExecuteQueryParams, (caddr_t) argp,
     652                (xdrproc_t) xdr_ExecuteUpdateRes, (caddr_t) &clnt_res,
     653                TIMEOUT) ) != RPC_SUCCESS ) {
     654                clnt_perrno( stat );
     655                return (NULL);
     656                }
     657        if (*((u_short*)&clnt_res) == 42)
     658                {
     659                GetExtendedErrorInfo* result = NULL;
     660                int dummy;
     661                int counter = 0;
     662                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     663                        {
     664                        counter++;
     665                        }
     666                r_Error* t = NULL, e;
     667                if (counter == RMInit::rpcMaxRetry)
     668                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     669                else
     670                        t = r_Error::getAnyError(result->errorText);
     671                e=*t;
     672                delete t;
     673                throw e;
     674        }
     675        return (&clnt_res);
     676}
     677
     678u_short *
     679rpcstartinserttransmdd_1(InsertTransMDDParams *argp, CLIENT *clnt)
     680{
     681        static u_short clnt_res;
     682        enum clnt_stat stat;
     683
     684
     685        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     686        if ( (stat = clnt_call (clnt, RPCSTARTINSERTTRANSMDD,
     687                (xdrproc_t) xdr_InsertTransMDDParams, (caddr_t) argp,
     688                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     689                TIMEOUT) ) != RPC_SUCCESS ) {
     690                clnt_perrno( stat );
     691                return (NULL);
     692                }
     693        if (*((u_short*)&clnt_res) == 42)
     694                {
     695                GetExtendedErrorInfo* result = NULL;
     696                int dummy;
     697                int counter = 0;
     698                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     699                        {
     700                        counter++;
     701                        }
     702                r_Error* t = NULL, e;
     703                if (counter == RMInit::rpcMaxRetry)
     704                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     705                else
     706                        t = r_Error::getAnyError(result->errorText);
     707                e=*t;
     708                delete t;
     709                throw e;
     710        }
     711        return (&clnt_res);
     712}
     713
     714u_short *
     715rpcstartinsertpersmdd_1(InsertPersMDDParams *argp, CLIENT *clnt)
     716{
     717        static u_short clnt_res;
     718        enum clnt_stat stat;
     719
     720
     721        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     722        if ( (stat = clnt_call (clnt, RPCSTARTINSERTPERSMDD,
     723                (xdrproc_t) xdr_InsertPersMDDParams, (caddr_t) argp,
     724                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     725                TIMEOUT) ) != RPC_SUCCESS ) {
     726                clnt_perrno( stat );
     727                return (NULL);
     728                }
     729        if (*((u_short*)&clnt_res) == 42)
     730                {
     731                GetExtendedErrorInfo* result = NULL;
     732                int dummy;
     733                int counter = 0;
     734                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     735                        {
     736                        counter++;
     737                        }
     738                r_Error* t = NULL, e;
     739                if (counter == RMInit::rpcMaxRetry)
     740                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     741                else
     742                        t = r_Error::getAnyError(result->errorText);
     743                e=*t;
     744                delete t;
     745                throw e;
     746        }
     747        return (&clnt_res);
     748}
     749
     750u_short *
     751rpcinserttile_1(InsertTileParams *argp, CLIENT *clnt)
     752{
     753        static u_short clnt_res;
     754        enum clnt_stat stat;
     755
     756
     757        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     758        if ( (stat = clnt_call (clnt, RPCINSERTTILE,
     759                (xdrproc_t) xdr_InsertTileParams, (caddr_t) argp,
     760                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     761                TIMEOUT) ) != RPC_SUCCESS ) {
     762                clnt_perrno( stat );
     763                return (NULL);
     764                }
     765        if (*((u_short*)&clnt_res) == 42)
     766                {
     767                GetExtendedErrorInfo* result = NULL;
     768                int dummy;
     769                int counter = 0;
     770                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     771                        {
     772                        counter++;
     773                        }
     774                r_Error* t = NULL, e;
     775                if (counter == RMInit::rpcMaxRetry)
     776                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     777                else
     778                        t = r_Error::getAnyError(result->errorText);
     779                e=*t;
     780                delete t;
     781                throw e;
     782        }
     783        return (&clnt_res);
     784}
     785
     786u_short *
     787rpcendinsertmdd_1(EndInsertMDDParams *argp, CLIENT *clnt)
     788{
     789        static u_short clnt_res;
     790        enum clnt_stat stat;
     791
     792
     793        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     794        if ( (stat = clnt_call (clnt, RPCENDINSERTMDD,
     795                (xdrproc_t) xdr_EndInsertMDDParams, (caddr_t) argp,
     796                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     797                TIMEOUT) ) != RPC_SUCCESS ) {
     798                clnt_perrno( stat );
     799                return (NULL);
     800                }
     801        if (*((u_short*)&clnt_res) == 42)
     802                {
     803                GetExtendedErrorInfo* result = NULL;
     804                int dummy;
     805                int counter = 0;
     806                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     807                        {
     808                        counter++;
     809                        }
     810                r_Error* t = NULL, e;
     811                if (counter == RMInit::rpcMaxRetry)
     812                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     813                else
     814                        t = r_Error::getAnyError(result->errorText);
     815                e=*t;
     816                delete t;
     817                throw e;
     818        }
     819        return (&clnt_res);
     820}
     821
     822u_short *
     823rpcinsertmdd_1(InsertMDDParams *argp, CLIENT *clnt)
     824{
     825        static u_short clnt_res;
     826        enum clnt_stat stat;
     827
     828
     829        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     830        if ( (stat = clnt_call (clnt, RPCINSERTMDD,
     831                (xdrproc_t) xdr_InsertMDDParams, (caddr_t) argp,
     832                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     833                TIMEOUT) ) != RPC_SUCCESS ) {
     834                clnt_perrno( stat );
     835                return (NULL);
     836                }
     837        if (*((u_short*)&clnt_res) == 42)
     838                {
     839                GetExtendedErrorInfo* result = NULL;
     840                int dummy;
     841                int counter = 0;
     842                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     843                        {
     844                        counter++;
     845                        }
     846                r_Error* t = NULL, e;
     847                if (counter == RMInit::rpcMaxRetry)
     848                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     849                else
     850                        t = r_Error::getAnyError(result->errorText);
     851                e=*t;
     852                delete t;
     853                throw e;
     854        }
     855        return (&clnt_res);
     856}
     857
     858GetCollRes *
     859rpcgetcollbyname_1(NameSpecParams *argp, CLIENT *clnt)
     860{
     861        static GetCollRes clnt_res;
     862        enum clnt_stat stat;
     863
     864
     865        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     866        if ( (stat = clnt_call (clnt, RPCGETCOLLBYNAME,
     867                (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
     868                (xdrproc_t) xdr_GetCollRes, (caddr_t) &clnt_res,
     869                TIMEOUT) ) != RPC_SUCCESS ) {
     870                clnt_perrno( stat );
     871                return (NULL);
     872                }
     873        if (*((u_short*)&clnt_res) == 42)
     874                {
     875                GetExtendedErrorInfo* result = NULL;
     876                int dummy;
     877                int counter = 0;
     878                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     879                        {
     880                        counter++;
     881                        }
     882                r_Error* t = NULL, e;
     883                if (counter == RMInit::rpcMaxRetry)
     884                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     885                else
     886                        t = r_Error::getAnyError(result->errorText);
     887                e=*t;
     888                delete t;
     889                throw e;
     890        }
     891        return (&clnt_res);
     892}
     893
     894GetCollRes *
     895rpcgetcollbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
     896{
     897        static GetCollRes clnt_res;
     898        enum clnt_stat stat;
     899
     900
     901        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     902        if ( (stat = clnt_call (clnt, RPCGETCOLLBYOID,
     903                (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
     904                (xdrproc_t) xdr_GetCollRes, (caddr_t) &clnt_res,
     905                TIMEOUT) ) != RPC_SUCCESS ) {
     906                clnt_perrno( stat );
     907                return (NULL);
     908                }
     909        if (*((u_short*)&clnt_res) == 42)
     910                {
     911                GetExtendedErrorInfo* result = NULL;
     912                int dummy;
     913                int counter = 0;
     914                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     915                        {
     916                        counter++;
     917                        }
     918                r_Error* t = NULL, e;
     919                if (counter == RMInit::rpcMaxRetry)
     920                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     921                else
     922                        t = r_Error::getAnyError(result->errorText);
     923                e=*t;
     924                delete t;
     925                throw e;
     926        }
     927        return (&clnt_res);
     928}
     929
     930GetCollOIdsRes *
     931rpcgetcolloidsbyname_1(NameSpecParams *argp, CLIENT *clnt)
     932{
     933        static GetCollOIdsRes clnt_res;
     934        enum clnt_stat stat;
     935
     936
     937        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     938        if ( (stat = clnt_call (clnt, RPCGETCOLLOIDSBYNAME,
     939                (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
     940                (xdrproc_t) xdr_GetCollOIdsRes, (caddr_t) &clnt_res,
     941                TIMEOUT) ) != RPC_SUCCESS ) {
     942                clnt_perrno( stat );
     943                return (NULL);
     944                }
     945        if (*((u_short*)&clnt_res) == 42)
     946                {
     947                GetExtendedErrorInfo* result = NULL;
     948                int dummy;
     949                int counter = 0;
     950                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     951                        {
     952                        counter++;
     953                        }
     954                r_Error* t = NULL, e;
     955                if (counter == RMInit::rpcMaxRetry)
     956                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     957                else
     958                        t = r_Error::getAnyError(result->errorText);
     959                e=*t;
     960                delete t;
     961                throw e;
     962        }
     963        return (&clnt_res);
     964}
     965
     966GetCollOIdsRes *
     967rpcgetcolloidsbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
     968{
     969        static GetCollOIdsRes clnt_res;
     970        enum clnt_stat stat;
     971
     972
     973        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     974        if ( (stat = clnt_call (clnt, RPCGETCOLLOIDSBYOID,
     975                (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
     976                (xdrproc_t) xdr_GetCollOIdsRes, (caddr_t) &clnt_res,
     977                TIMEOUT) ) != RPC_SUCCESS ) {
     978                clnt_perrno( stat );
     979                return (NULL);
     980                }
     981        if (*((u_short*)&clnt_res) == 42)
     982                {
     983                GetExtendedErrorInfo* result = NULL;
     984                int dummy;
     985                int counter = 0;
     986                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     987                        {
     988                        counter++;
     989                        }
     990                r_Error* t = NULL, e;
     991                if (counter == RMInit::rpcMaxRetry)
     992                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     993                else
     994                        t = r_Error::getAnyError(result->errorText);
     995                e=*t;
     996                delete t;
     997                throw e;
     998        }
     999        return (&clnt_res);
     1000}
     1001
     1002u_short *
     1003rpcinsertcoll_1(InsertCollParams *argp, CLIENT *clnt)
     1004{
     1005        static u_short clnt_res;
     1006        enum clnt_stat stat;
     1007
     1008
     1009        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1010        if ( (stat = clnt_call (clnt, RPCINSERTCOLL,
     1011                (xdrproc_t) xdr_InsertCollParams, (caddr_t) argp,
     1012                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1013                TIMEOUT) ) != RPC_SUCCESS ) {
     1014                clnt_perrno( stat );
     1015                return (NULL);
     1016                }
     1017        if (*((u_short*)&clnt_res) == 42)
     1018                {
     1019                GetExtendedErrorInfo* result = NULL;
     1020                int dummy;
     1021                int counter = 0;
     1022                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1023                        {
     1024                        counter++;
     1025                        }
     1026                r_Error* t = NULL, e;
     1027                if (counter == RMInit::rpcMaxRetry)
     1028                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1029                else
     1030                        t = r_Error::getAnyError(result->errorText);
     1031                e=*t;
     1032                delete t;
     1033                throw e;
     1034        }
     1035        return (&clnt_res);
     1036}
     1037
     1038u_short *
     1039rpcdeletecollbyname_1(NameSpecParams *argp, CLIENT *clnt)
     1040{
     1041        static u_short clnt_res;
     1042        enum clnt_stat stat;
     1043
     1044
     1045        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1046        if ( (stat = clnt_call (clnt, RPCDELETECOLLBYNAME,
     1047                (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
     1048                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1049                TIMEOUT) ) != RPC_SUCCESS ) {
     1050                clnt_perrno( stat );
     1051                return (NULL);
     1052                }
     1053        if (*((u_short*)&clnt_res) == 42)
     1054                {
     1055                GetExtendedErrorInfo* result = NULL;
     1056                int dummy;
     1057                int counter = 0;
     1058                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1059                        {
     1060                        counter++;
     1061                        }
     1062                r_Error* t = NULL, e;
     1063                if (counter == RMInit::rpcMaxRetry)
     1064                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1065                else
     1066                        t = r_Error::getAnyError(result->errorText);
     1067                e=*t;
     1068                delete t;
     1069                throw e;
     1070        }
     1071        return (&clnt_res);
     1072}
     1073
     1074u_short *
     1075rpcdeleteobjbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
     1076{
     1077        static u_short clnt_res;
     1078        enum clnt_stat stat;
     1079
     1080
     1081        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1082        if ( (stat = clnt_call (clnt, RPCDELETEOBJBYOID,
     1083                (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
     1084                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1085                TIMEOUT) ) != RPC_SUCCESS ) {
     1086                clnt_perrno( stat );
     1087                return (NULL);
     1088                }
     1089        if (*((u_short*)&clnt_res) == 42)
     1090                {
     1091                GetExtendedErrorInfo* result = NULL;
     1092                int dummy;
     1093                int counter = 0;
     1094                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1095                        {
     1096                        counter++;
     1097                        }
     1098                r_Error* t = NULL, e;
     1099                if (counter == RMInit::rpcMaxRetry)
     1100                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1101                else
     1102                        t = r_Error::getAnyError(result->errorText);
     1103                e=*t;
     1104                delete t;
     1105                throw e;
     1106        }
     1107        return (&clnt_res);
     1108}
     1109
     1110u_short *
     1111rpcremoveobjfromcoll_1(RemoveObjFromCollParams *argp, CLIENT *clnt)
     1112{
     1113        static u_short clnt_res;
     1114        enum clnt_stat stat;
     1115
     1116
     1117        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1118        if ( (stat = clnt_call (clnt, RPCREMOVEOBJFROMCOLL,
     1119                (xdrproc_t) xdr_RemoveObjFromCollParams, (caddr_t) argp,
     1120                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1121                TIMEOUT) ) != RPC_SUCCESS ) {
     1122                clnt_perrno( stat );
     1123                return (NULL);
     1124                }
     1125        if (*((u_short*)&clnt_res) == 42)
     1126                {
     1127                GetExtendedErrorInfo* result = NULL;
     1128                int dummy;
     1129                int counter = 0;
     1130                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1131                        {
     1132                        counter++;
     1133                        }
     1134                r_Error* t = NULL, e;
     1135                if (counter == RMInit::rpcMaxRetry)
     1136                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1137                else
     1138                        t = r_Error::getAnyError(result->errorText);
     1139                e=*t;
     1140                delete t;
     1141                throw e;
     1142        }
     1143        return (&clnt_res);
     1144}
     1145
     1146OIdRes *
     1147rpcgetnewoid_1(NewOIdParams *argp, CLIENT *clnt)
     1148{
     1149        static OIdRes clnt_res;
     1150        enum clnt_stat stat;
     1151
     1152
     1153        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1154        if ( (stat = clnt_call (clnt, RPCGETNEWOID,
     1155                (xdrproc_t) xdr_NewOIdParams, (caddr_t) argp,
     1156                (xdrproc_t) xdr_OIdRes, (caddr_t) &clnt_res,
     1157                TIMEOUT) ) != RPC_SUCCESS ) {
     1158                clnt_perrno( stat );
     1159                return (NULL);
     1160                }
     1161        if (*((u_short*)&clnt_res) == 42)
     1162                {
     1163                GetExtendedErrorInfo* result = NULL;
     1164                int dummy;
     1165                int counter = 0;
     1166                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1167                        {
     1168                        counter++;
     1169                        }
     1170                r_Error* t = NULL, e;
     1171                if (counter == RMInit::rpcMaxRetry)
     1172                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1173                else
     1174                        t = r_Error::getAnyError(result->errorText);
     1175                e=*t;
     1176                delete t;
     1177                throw e;
     1178        }
     1179        return (&clnt_res);
     1180}
     1181
     1182ObjectTypeRes *
     1183rpcgetobjecttype_1(OIdSpecParams *argp, CLIENT *clnt)
     1184{
     1185        static ObjectTypeRes clnt_res;
     1186        enum clnt_stat stat;
     1187
     1188
     1189        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1190        if ( (stat = clnt_call (clnt, RPCGETOBJECTTYPE,
     1191                (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
     1192                (xdrproc_t) xdr_ObjectTypeRes, (caddr_t) &clnt_res,
     1193                TIMEOUT) ) != RPC_SUCCESS ) {
     1194                clnt_perrno( stat );
     1195                return (NULL);
     1196                }
     1197        if (*((u_short*)&clnt_res) == 42)
     1198                {
     1199                GetExtendedErrorInfo* result = NULL;
     1200                int dummy;
     1201                int counter = 0;
     1202                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1203                        {
     1204                        counter++;
     1205                        }
     1206                r_Error* t = NULL, e;
     1207                if (counter == RMInit::rpcMaxRetry)
     1208                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1209                else
     1210                        t = r_Error::getAnyError(result->errorText);
     1211                e=*t;
     1212                delete t;
     1213                throw e;
     1214        }
     1215        return (&clnt_res);
     1216}
     1217
     1218GetTypeStructureRes *
     1219rpcgettypestructure_1(GetTypeStructureParams *argp, CLIENT *clnt)
     1220{
     1221        static GetTypeStructureRes clnt_res;
     1222        enum clnt_stat stat;
     1223
     1224
     1225        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1226        if ( (stat = clnt_call (clnt, RPCGETTYPESTRUCTURE,
     1227                (xdrproc_t) xdr_GetTypeStructureParams, (caddr_t) argp,
     1228                (xdrproc_t) xdr_GetTypeStructureRes, (caddr_t) &clnt_res,
     1229                TIMEOUT) ) != RPC_SUCCESS ) {
     1230                clnt_perrno( stat );
     1231                return (NULL);
     1232                }
     1233        if (*((u_short*)&clnt_res) == 42)
     1234                {
     1235                GetExtendedErrorInfo* result = NULL;
     1236                int dummy;
     1237                int counter = 0;
     1238                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1239                        {
     1240                        counter++;
     1241                        }
     1242                r_Error* t = NULL, e;
     1243                if (counter == RMInit::rpcMaxRetry)
     1244                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1245                else
     1246                        t = r_Error::getAnyError(result->errorText);
     1247                e=*t;
     1248                delete t;
     1249                throw e;
     1250        }
     1251        return (&clnt_res);
     1252}
     1253
     1254GetElementRes *
     1255rpcgetnextelement_1(u_long *argp, CLIENT *clnt)
     1256{
     1257        static GetElementRes clnt_res;
     1258        enum clnt_stat stat;
     1259
     1260
     1261        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1262        if ( (stat = clnt_call (clnt, RPCGETNEXTELEMENT,
     1263                (xdrproc_t) xdr_u_long, (caddr_t) argp,
     1264                (xdrproc_t) xdr_GetElementRes, (caddr_t) &clnt_res,
     1265                TIMEOUT) ) != RPC_SUCCESS ) {
     1266                clnt_perrno( stat );
     1267                return (NULL);
     1268                }
     1269        if (*((u_short*)&clnt_res) == 42)
     1270                {
     1271                GetExtendedErrorInfo* result = NULL;
     1272                int dummy;
     1273                int counter = 0;
     1274                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1275                        {
     1276                        counter++;
     1277                        }
     1278                r_Error* t = NULL, e;
     1279                if (counter == RMInit::rpcMaxRetry)
     1280                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1281                else
     1282                        t = r_Error::getAnyError(result->errorText);
     1283                e=*t;
     1284                delete t;
     1285                throw e;
     1286        }
     1287        return (&clnt_res);
     1288}
     1289
     1290int *
     1291rpcgetserverendian_1(int *argp, CLIENT *clnt)
     1292{
     1293        static int clnt_res;
     1294        enum clnt_stat stat;
     1295
     1296
     1297        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1298        if ( (stat = clnt_call (clnt, RPCGETSERVERENDIAN,
     1299                (xdrproc_t) xdr_int, (caddr_t) argp,
     1300                (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
     1301                TIMEOUT) ) != RPC_SUCCESS ) {
     1302                clnt_perrno( stat );
     1303                return (NULL);
     1304                }
     1305        if (*((u_short*)&clnt_res) == 42)
     1306                {
     1307                GetExtendedErrorInfo* result = NULL;
     1308                int dummy;
     1309                int counter = 0;
     1310                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1311                        {
     1312                        counter++;
     1313                        }
     1314                r_Error* t = NULL, e;
     1315                if (counter == RMInit::rpcMaxRetry)
     1316                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1317                else
     1318                        t = r_Error::getAnyError(result->errorText);
     1319                e=*t;
     1320                delete t;
     1321                throw e;
     1322        }
     1323        return (&clnt_res);
     1324}
     1325
     1326u_short *
     1327rpcsetservertransfer_1(SetServerTransferParams *argp, CLIENT *clnt)
     1328{
     1329        static u_short clnt_res;
     1330        enum clnt_stat stat;
     1331
     1332
     1333        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1334        if ( (stat = clnt_call (clnt, RPCSETSERVERTRANSFER,
     1335                (xdrproc_t) xdr_SetServerTransferParams, (caddr_t) argp,
     1336                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1337                TIMEOUT) ) != RPC_SUCCESS ) {
     1338                clnt_perrno( stat );
     1339                return (NULL);
     1340                }
     1341        if (*((u_short*)&clnt_res) == 42)
     1342                {
     1343                GetExtendedErrorInfo* result = NULL;
     1344                int dummy;
     1345                int counter = 0;
     1346                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1347                        {
     1348                        counter++;
     1349                        }
     1350                r_Error* t = NULL, e;
     1351                if (counter == RMInit::rpcMaxRetry)
     1352                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1353                else
     1354                        t = r_Error::getAnyError(result->errorText);
     1355                e=*t;
     1356                delete t;
     1357                throw e;
     1358        }
     1359        return (&clnt_res);
     1360}
     1361
     1362GetExtendedErrorInfo *
     1363rpcgeterrorinfo_1(void *argp, CLIENT *clnt)
     1364{
     1365        static GetExtendedErrorInfo clnt_res;
     1366        enum clnt_stat stat;
     1367
     1368
     1369        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1370        if ( (stat = clnt_call (clnt, RPCGETERRORINFO,
     1371                (xdrproc_t) xdr_void, (caddr_t) argp,
     1372                (xdrproc_t) xdr_GetExtendedErrorInfo, (caddr_t) &clnt_res,
     1373                TIMEOUT) ) != RPC_SUCCESS ) {
     1374                clnt_perrno( stat );
     1375                return (NULL);
     1376                }
     1377        if (*((u_short*)&clnt_res) == 42)
     1378                {
     1379                GetExtendedErrorInfo* result = NULL;
     1380                int dummy;
     1381                int counter = 0;
     1382                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1383                        {
     1384                        counter++;
     1385                        }
     1386                r_Error* t = NULL, e;
     1387                if (counter == RMInit::rpcMaxRetry)
     1388                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1389                else
     1390                        t = r_Error::getAnyError(result->errorText);
     1391                e=*t;
     1392                delete t;
     1393                throw e;
     1394        }
     1395        return (&clnt_res);
     1396}
     1397
     1398u_short *
     1399rpcsetserverstorage_1(SetServerTransferParams *argp, CLIENT *clnt)
     1400{
     1401        static u_short clnt_res;
     1402        enum clnt_stat stat;
     1403
     1404
     1405        memset((char *)&clnt_res, 0, sizeof(clnt_res));
     1406        if ( (stat = clnt_call (clnt, RPCSETSERVERSTORAGE,
     1407                (xdrproc_t) xdr_SetServerTransferParams, (caddr_t) argp,
     1408                (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
     1409                TIMEOUT) ) != RPC_SUCCESS ) {
     1410                clnt_perrno( stat );
     1411                return (NULL);
     1412                }
     1413        if (*((u_short*)&clnt_res) == 42)
     1414                {
     1415                GetExtendedErrorInfo* result = NULL;
     1416                int dummy;
     1417                int counter = 0;
     1418                while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
     1419                        {
     1420                        counter++;
     1421                        }
     1422                r_Error* t = NULL, e;
     1423                if (counter == RMInit::rpcMaxRetry)
     1424                        t = new r_Error(RPCCOMMUNICATIONFAILURE);
     1425                else
     1426                        t = r_Error::getAnyError(result->errorText);
     1427                e=*t;
     1428                delete t;
     1429                throw e;
     1430        }
     1431        return (&clnt_res);
     1432}

  • new file clientcomm/rpcif_svc.cc 

    diff --git a/clientcomm/rpcif_svc.cc b/clientcomm/rpcif_svc.cc
new file mode 100644
index 0000000..afebad0
    - +  
     1//patched by awk 1
     2#include "raslib/error.hh"
     3#include "servercomm/servercomm.hh"
     4#include <new>
     5char *secureResultBufferForRPC;
     6bool bMemFailed = false;
     7//end patched by awk 1
     8/*
     9 * Please do not edit this file.
     10 * It was generated using rpcgen.
     11 */
     12
     13#include "rpcif.h"
     14#include <stdio.h>
     15#include <stdlib.h>
     16#include <rpc/pmap_clnt.h>
     17#include <string.h>
     18#include <memory.h>
     19#include <sys/socket.h>
     20#include <netinet/in.h>
     21
     22#ifndef SIG_PF
     23#define SIG_PF void(*)(int)
     24#endif
     25
     26//patched by awk 3
     27char*
     28//end patched by awk 3
     29rpcif_1(struct svc_req *rqstp, register SVCXPRT *transp)
     30{
     31//patched by awk 4
     32char* retvalTxt = 0;
     33//end patched by awk 4
     34        union {
     35                int rpcgetserverversion_1_arg;
     36                int rpcshutdown_1_arg;
     37                int rpcserverstat_1_arg;
     38                u_long rpckilltableentry_1_arg;
     39                u_long rpcalive_1_arg;
     40                OpenDBParams rpcopendb_1_arg;
     41                u_long rpcclosedb_1_arg;
     42                char *rpccreatedb_1_arg;
     43                char *rpcdestroydb_1_arg;
     44                BeginTAParams rpcbeginta_1_arg;
     45                u_long rpccommitta_1_arg;
     46                u_long rpcabortta_1_arg;
     47                ExecuteQueryParams rpcexecutequery_1_arg;
     48                u_long rpcgetnextmdd_1_arg;
     49                OIdSpecParams rpcgetmddbyoid_1_arg;
     50                u_long rpcgetnexttile_1_arg;
     51                u_long rpcendtransfer_1_arg;
     52                u_long rpcinitexecuteupdate_1_arg;
     53                ExecuteQueryParams rpcexecuteupdate_1_arg;
     54                InsertTransMDDParams rpcstartinserttransmdd_1_arg;
     55                InsertPersMDDParams rpcstartinsertpersmdd_1_arg;
     56                InsertTileParams rpcinserttile_1_arg;
     57                EndInsertMDDParams rpcendinsertmdd_1_arg;
     58                InsertMDDParams rpcinsertmdd_1_arg;
     59                NameSpecParams rpcgetcollbyname_1_arg;
     60                OIdSpecParams rpcgetcollbyoid_1_arg;
     61                NameSpecParams rpcgetcolloidsbyname_1_arg;
     62                OIdSpecParams rpcgetcolloidsbyoid_1_arg;
     63                InsertCollParams rpcinsertcoll_1_arg;
     64                NameSpecParams rpcdeletecollbyname_1_arg;
     65                OIdSpecParams rpcdeleteobjbyoid_1_arg;
     66                RemoveObjFromCollParams rpcremoveobjfromcoll_1_arg;
     67                NewOIdParams rpcgetnewoid_1_arg;
     68                OIdSpecParams rpcgetobjecttype_1_arg;
     69                GetTypeStructureParams rpcgettypestructure_1_arg;
     70                u_long rpcgetnextelement_1_arg;
     71                int rpcgetserverendian_1_arg;
     72                SetServerTransferParams rpcsetservertransfer_1_arg;
     73                SetServerTransferParams rpcsetserverstorage_1_arg;
     74        } argument;
     75        char *result;
     76        xdrproc_t _xdr_argument, _xdr_result;
     77        char *(*local)(char *, struct svc_req *);
     78
     79        switch (rqstp->rq_proc) {
     80        case NULLPROC:
     81                (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
     82//patched by awk 5
     83return retvalTxt;
     84//end patched by awk 5
     85
     86        case RPCGETSERVERVERSION:
     87                _xdr_argument = (xdrproc_t) xdr_int;
     88                _xdr_result = (xdrproc_t) xdr_ServerVersionRes;
     89                local = (char *(*)(char *, struct svc_req *)) rpcgetserverversion_1_svc;
     90                break;
     91
     92        case RPCSHUTDOWN:
     93                _xdr_argument = (xdrproc_t) xdr_int;
     94                _xdr_result = (xdrproc_t) xdr_u_short;
     95                local = (char *(*)(char *, struct svc_req *)) rpcshutdown_1_svc;
     96                break;
     97
     98        case RPCSERVERSTAT:
     99                _xdr_argument = (xdrproc_t) xdr_int;
     100                _xdr_result = (xdrproc_t) xdr_ServerStatRes;
     101                local = (char *(*)(char *, struct svc_req *)) rpcserverstat_1_svc;
     102                break;
     103
     104        case RPCKILLTABLEENTRY:
     105                _xdr_argument = (xdrproc_t) xdr_u_long;
     106                _xdr_result = (xdrproc_t) xdr_u_short;
     107                local = (char *(*)(char *, struct svc_req *)) rpckilltableentry_1_svc;
     108                break;
     109
     110        case RPCALIVE:
     111                _xdr_argument = (xdrproc_t) xdr_u_long;
     112                _xdr_result = (xdrproc_t) xdr_u_short;
     113                local = (char *(*)(char *, struct svc_req *)) rpcalive_1_svc;
     114                break;
     115
     116        case RPCOPENDB:
     117                _xdr_argument = (xdrproc_t) xdr_OpenDBParams;
     118                _xdr_result = (xdrproc_t) xdr_OpenDBRes;
     119                local = (char *(*)(char *, struct svc_req *)) rpcopendb_1_svc;
     120                break;
     121
     122        case RPCCLOSEDB:
     123                _xdr_argument = (xdrproc_t) xdr_u_long;
     124                _xdr_result = (xdrproc_t) xdr_u_short;
     125                local = (char *(*)(char *, struct svc_req *)) rpcclosedb_1_svc;
     126                break;
     127
     128        case RPCCREATEDB:
     129                _xdr_argument = (xdrproc_t) xdr_wrapstring;
     130                _xdr_result = (xdrproc_t) xdr_u_short;
     131                local = (char *(*)(char *, struct svc_req *)) rpccreatedb_1_svc;
     132                break;
     133
     134        case RPCDESTROYDB:
     135                _xdr_argument = (xdrproc_t) xdr_wrapstring;
     136                _xdr_result = (xdrproc_t) xdr_u_short;
     137                local = (char *(*)(char *, struct svc_req *)) rpcdestroydb_1_svc;
     138                break;
     139
     140        case RPCBEGINTA:
     141                _xdr_argument = (xdrproc_t) xdr_BeginTAParams;
     142                _xdr_result = (xdrproc_t) xdr_u_short;
     143                local = (char *(*)(char *, struct svc_req *)) rpcbeginta_1_svc;
     144                break;
     145
     146        case RPCCOMMITTA:
     147                _xdr_argument = (xdrproc_t) xdr_u_long;
     148                _xdr_result = (xdrproc_t) xdr_u_short;
     149                local = (char *(*)(char *, struct svc_req *)) rpccommitta_1_svc;
     150                break;
     151
     152        case RPCABORTTA:
     153                _xdr_argument = (xdrproc_t) xdr_u_long;
     154                _xdr_result = (xdrproc_t) xdr_u_short;
     155                local = (char *(*)(char *, struct svc_req *)) rpcabortta_1_svc;
     156                break;
     157
     158        case RPCEXECUTEQUERY:
     159                _xdr_argument = (xdrproc_t) xdr_ExecuteQueryParams;
     160                _xdr_result = (xdrproc_t) xdr_ExecuteQueryRes;
     161                local = (char *(*)(char *, struct svc_req *)) rpcexecutequery_1_svc;
     162                break;
     163
     164        case RPCGETNEXTMDD:
     165                _xdr_argument = (xdrproc_t) xdr_u_long;
     166                _xdr_result = (xdrproc_t) xdr_GetMDDRes;
     167                local = (char *(*)(char *, struct svc_req *)) rpcgetnextmdd_1_svc;
     168                break;
     169
     170        case RPCGETMDDBYOID:
     171                _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
     172                _xdr_result = (xdrproc_t) xdr_GetMDDRes;
     173                local = (char *(*)(char *, struct svc_req *)) rpcgetmddbyoid_1_svc;
     174                break;
     175
     176        case RPCGETNEXTTILE:
     177                _xdr_argument = (xdrproc_t) xdr_u_long;
     178                _xdr_result = (xdrproc_t) xdr_GetTileRes;
     179                local = (char *(*)(char *, struct svc_req *)) rpcgetnexttile_1_svc;
     180                break;
     181
     182        case RPCENDTRANSFER:
     183                _xdr_argument = (xdrproc_t) xdr_u_long;
     184                _xdr_result = (xdrproc_t) xdr_u_short;
     185                local = (char *(*)(char *, struct svc_req *)) rpcendtransfer_1_svc;
     186                break;
     187
     188        case RPCINITEXECUTEUPDATE:
     189                _xdr_argument = (xdrproc_t) xdr_u_long;
     190                _xdr_result = (xdrproc_t) xdr_u_short;
     191                local = (char *(*)(char *, struct svc_req *)) rpcinitexecuteupdate_1_svc;
     192                break;
     193
     194        case RPCEXECUTEUPDATE:
     195                _xdr_argument = (xdrproc_t) xdr_ExecuteQueryParams;
     196                _xdr_result = (xdrproc_t) xdr_ExecuteUpdateRes;
     197                local = (char *(*)(char *, struct svc_req *)) rpcexecuteupdate_1_svc;
     198                break;
     199
     200        case RPCSTARTINSERTTRANSMDD:
     201                _xdr_argument = (xdrproc_t) xdr_InsertTransMDDParams;
     202                _xdr_result = (xdrproc_t) xdr_u_short;
     203                local = (char *(*)(char *, struct svc_req *)) rpcstartinserttransmdd_1_svc;
     204                break;
     205
     206        case RPCSTARTINSERTPERSMDD:
     207                _xdr_argument = (xdrproc_t) xdr_InsertPersMDDParams;
     208                _xdr_result = (xdrproc_t) xdr_u_short;
     209                local = (char *(*)(char *, struct svc_req *)) rpcstartinsertpersmdd_1_svc;
     210                break;
     211
     212        case RPCINSERTTILE:
     213                _xdr_argument = (xdrproc_t) xdr_InsertTileParams;
     214                _xdr_result = (xdrproc_t) xdr_u_short;
     215                local = (char *(*)(char *, struct svc_req *)) rpcinserttile_1_svc;
     216                break;
     217
     218        case RPCENDINSERTMDD:
     219                _xdr_argument = (xdrproc_t) xdr_EndInsertMDDParams;
     220                _xdr_result = (xdrproc_t) xdr_u_short;
     221                local = (char *(*)(char *, struct svc_req *)) rpcendinsertmdd_1_svc;
     222                break;
     223
     224        case RPCINSERTMDD:
     225                _xdr_argument = (xdrproc_t) xdr_InsertMDDParams;
     226                _xdr_result = (xdrproc_t) xdr_u_short;
     227                local = (char *(*)(char *, struct svc_req *)) rpcinsertmdd_1_svc;
     228                break;
     229
     230        case RPCGETCOLLBYNAME:
     231                _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
     232                _xdr_result = (xdrproc_t) xdr_GetCollRes;
     233                local = (char *(*)(char *, struct svc_req *)) rpcgetcollbyname_1_svc;
     234                break;
     235
     236        case RPCGETCOLLBYOID:
     237                _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
     238                _xdr_result = (xdrproc_t) xdr_GetCollRes;
     239                local = (char *(*)(char *, struct svc_req *)) rpcgetcollbyoid_1_svc;
     240                break;
     241
     242        case RPCGETCOLLOIDSBYNAME:
     243                _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
     244                _xdr_result = (xdrproc_t) xdr_GetCollOIdsRes;
     245                local = (char *(*)(char *, struct svc_req *)) rpcgetcolloidsbyname_1_svc;
     246                break;
     247
     248        case RPCGETCOLLOIDSBYOID:
     249                _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
     250                _xdr_result = (xdrproc_t) xdr_GetCollOIdsRes;
     251                local = (char *(*)(char *, struct svc_req *)) rpcgetcolloidsbyoid_1_svc;
     252                break;
     253
     254        case RPCINSERTCOLL:
     255                _xdr_argument = (xdrproc_t) xdr_InsertCollParams;
     256                _xdr_result = (xdrproc_t) xdr_u_short;
     257                local = (char *(*)(char *, struct svc_req *)) rpcinsertcoll_1_svc;
     258                break;
     259
     260        case RPCDELETECOLLBYNAME:
     261                _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
     262                _xdr_result = (xdrproc_t) xdr_u_short;
     263                local = (char *(*)(char *, struct svc_req *)) rpcdeletecollbyname_1_svc;
     264                break;
     265
     266        case RPCDELETEOBJBYOID:
     267                _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
     268                _xdr_result = (xdrproc_t) xdr_u_short;
     269                local = (char *(*)(char *, struct svc_req *)) rpcdeleteobjbyoid_1_svc;
     270                break;
     271
     272        case RPCREMOVEOBJFROMCOLL:
     273                _xdr_argument = (xdrproc_t) xdr_RemoveObjFromCollParams;
     274                _xdr_result = (xdrproc_t) xdr_u_short;
     275                local = (char *(*)(char *, struct svc_req *)) rpcremoveobjfromcoll_1_svc;
     276                break;
     277
     278        case RPCGETNEWOID:
     279                _xdr_argument = (xdrproc_t) xdr_NewOIdParams;
     280                _xdr_result = (xdrproc_t) xdr_OIdRes;
     281                local = (char *(*)(char *, struct svc_req *)) rpcgetnewoid_1_svc;
     282                break;
     283
     284        case RPCGETOBJECTTYPE:
     285                _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
     286                _xdr_result = (xdrproc_t) xdr_ObjectTypeRes;
     287                local = (char *(*)(char *, struct svc_req *)) rpcgetobjecttype_1_svc;
     288                break;
     289
     290        case RPCGETTYPESTRUCTURE:
     291                _xdr_argument = (xdrproc_t) xdr_GetTypeStructureParams;
     292                _xdr_result = (xdrproc_t) xdr_GetTypeStructureRes;
     293                local = (char *(*)(char *, struct svc_req *)) rpcgettypestructure_1_svc;
     294                break;
     295
     296        case RPCGETNEXTELEMENT:
     297                _xdr_argument = (xdrproc_t) xdr_u_long;
     298                _xdr_result = (xdrproc_t) xdr_GetElementRes;
     299                local = (char *(*)(char *, struct svc_req *)) rpcgetnextelement_1_svc;
     300                break;
     301
     302        case RPCGETSERVERENDIAN:
     303                _xdr_argument = (xdrproc_t) xdr_int;
     304                _xdr_result = (xdrproc_t) xdr_int;
     305                local = (char *(*)(char *, struct svc_req *)) rpcgetserverendian_1_svc;
     306                break;
     307
     308        case RPCSETSERVERTRANSFER:
     309                _xdr_argument = (xdrproc_t) xdr_SetServerTransferParams;
     310                _xdr_result = (xdrproc_t) xdr_u_short;
     311                local = (char *(*)(char *, struct svc_req *)) rpcsetservertransfer_1_svc;
     312                break;
     313
     314        case RPCGETERRORINFO:
     315                _xdr_argument = (xdrproc_t) xdr_void;
     316                _xdr_result = (xdrproc_t) xdr_GetExtendedErrorInfo;
     317                local = (char *(*)(char *, struct svc_req *)) rpcgeterrorinfo_1_svc;
     318                break;
     319
     320        case RPCSETSERVERSTORAGE:
     321                _xdr_argument = (xdrproc_t) xdr_SetServerTransferParams;
     322                _xdr_result = (xdrproc_t) xdr_u_short;
     323                local = (char *(*)(char *, struct svc_req *)) rpcsetserverstorage_1_svc;
     324                break;
     325
     326        default:
     327                svcerr_noproc (transp);
     328//patched by awk 5
     329return retvalTxt;
     330//end patched by awk 5
     331        }
     332        memset ((char *)&argument, 0, sizeof (argument));
     333        if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
     334                svcerr_decode (transp);
     335//patched by awk 5
     336return retvalTxt;
     337//end patched by awk 5
     338        }
     339//patched by awk 2
     340        try     {
     341//end patched by awk 2
     342        result = (*local)((char *)&argument, rqstp);
     343//patched by awk 2.1
     344                }
     345        catch (r_Error& e)
     346                {
     347                retvalTxt = e.serialiseError();
     348                u_short temp = 42;
     349                result = secureResultBufferForRPC;
     350                memcpy(result, (char*)&temp, sizeof(u_short));
     351                }
     352        catch (std::bad_alloc)
     353                {
     354                bMemFailed = true;
     355                ServerComm* sc = ServerComm::actual_servercomm;
     356                r_Ememory_allocation e;
     357                retvalTxt = e.serialiseError();
     358                u_short temp = 42;
     359                result = secureResultBufferForRPC;
     360                memcpy(result, (char*)&temp, sizeof(u_short));
     361               
     362                }
     363//end patched by awk 2.1
     364        if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {
     365                svcerr_systemerr (transp);
     366        }
     367        if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
     368                fprintf (stderr, "%s", "unable to free arguments");
     369                exit (1);
     370        }
     371//patched by awk 5
     372return retvalTxt;
     373//end patched by awk 5
     374}

  • new file clientcomm/rpcif_xdr.c 

    diff --git a/clientcomm/rpcif_xdr.c b/clientcomm/rpcif_xdr.c
new file mode 100644
index 0000000..1dbb45e
    - +  
     1/*
     2 * Please do not edit this file.
     3 * It was generated using rpcgen.
     4 */
     5
     6#include "rpcif.h"
     7
     8bool_t
     9xdr_confarray (XDR *xdrs, confarray *objp)
     10{
     11        register int32_t *buf;
     12
     13         if (!xdr_bytes (xdrs, (char **)&objp->confarray_val, (u_int *) &objp->confarray_len, ~0))
     14                 return FALSE;
     15        return TRUE;
     16}
     17
     18bool_t
     19xdr_RPCMarray (XDR *xdrs, RPCMarray *objp)
     20{
     21        register int32_t *buf;
     22
     23
     24        if (xdrs->x_op == XDR_ENCODE) {
     25                 if (!xdr_string (xdrs, &objp->domain, ~0))
     26                         return FALSE;
     27                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     28                if (buf == NULL) {
     29                         if (!xdr_u_long (xdrs, &objp->cellTypeLength))
     30                                 return FALSE;
     31                         if (!xdr_u_short (xdrs, &objp->currentFormat))
     32                                 return FALSE;
     33                         if (!xdr_u_short (xdrs, &objp->storageFormat))
     34                                 return FALSE;
     35
     36                } else {
     37                IXDR_PUT_U_LONG(buf, objp->cellTypeLength);
     38                IXDR_PUT_U_SHORT(buf, objp->currentFormat);
     39                IXDR_PUT_U_SHORT(buf, objp->storageFormat);
     40                }
     41                 if (!xdr_confarray (xdrs, &objp->data))
     42                         return FALSE;
     43                return TRUE;
     44        } else if (xdrs->x_op == XDR_DECODE) {
     45                 if (!xdr_string (xdrs, &objp->domain, ~0))
     46                         return FALSE;
     47                buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
     48                if (buf == NULL) {
     49                         if (!xdr_u_long (xdrs, &objp->cellTypeLength))
     50                                 return FALSE;
     51                         if (!xdr_u_short (xdrs, &objp->currentFormat))
     52                                 return FALSE;
     53                         if (!xdr_u_short (xdrs, &objp->storageFormat))
     54                                 return FALSE;
     55
     56                } else {
     57                objp->cellTypeLength = IXDR_GET_U_LONG(buf);
     58                objp->currentFormat = IXDR_GET_U_SHORT(buf);
     59                objp->storageFormat = IXDR_GET_U_SHORT(buf);
     60                }
     61                 if (!xdr_confarray (xdrs, &objp->data))
     62                         return FALSE;
     63         return TRUE;
     64        }
     65
     66         if (!xdr_string (xdrs, &objp->domain, ~0))
     67                 return FALSE;
     68         if (!xdr_u_long (xdrs, &objp->cellTypeLength))
     69                 return FALSE;
     70         if (!xdr_u_short (xdrs, &objp->currentFormat))
     71                 return FALSE;
     72         if (!xdr_u_short (xdrs, &objp->storageFormat))
     73                 return FALSE;
     74         if (!xdr_confarray (xdrs, &objp->data))
     75                 return FALSE;
     76        return TRUE;
     77}
     78
     79bool_t
     80xdr_RPCClientEntry (XDR *xdrs, RPCClientEntry *objp)
     81{
     82        register int32_t *buf;
     83
     84
     85        if (xdrs->x_op == XDR_ENCODE) {
     86                 if (!xdr_u_long (xdrs, &objp->clientId))
     87                         return FALSE;
     88                 if (!xdr_string (xdrs, &objp->clientIdText, ~0))
     89                         return FALSE;
     90                 if (!xdr_string (xdrs, &objp->userName, ~0))
     91                         return FALSE;
     92                 if (!xdr_string (xdrs, &objp->baseName, ~0))
     93                         return FALSE;
     94                buf = XDR_INLINE (xdrs, 9 * BYTES_PER_XDR_UNIT);
     95                if (buf == NULL) {
     96                         if (!xdr_u_long (xdrs, &objp->creationTime))
     97                                 return FALSE;
     98                         if (!xdr_u_long (xdrs, &objp->lastActionTime))
     99                                 return FALSE;
     100                         if (!xdr_u_long (xdrs, &objp->transferColl))
     101                                 return FALSE;
     102                         if (!xdr_u_long (xdrs, &objp->transferIter))
     103                                 return FALSE;
     104                         if (!xdr_u_long (xdrs, &objp->assembleMDD))
     105                                 return FALSE;
     106                         if (!xdr_u_long (xdrs, &objp->transferMDD))
     107                                 return FALSE;
     108                         if (!xdr_u_long (xdrs, &objp->transTiles))
     109                                 return FALSE;
     110                         if (!xdr_u_long (xdrs, &objp->tileIter))
     111                                 return FALSE;
     112                         if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
     113                                 return FALSE;
     114                } else {
     115                        IXDR_PUT_U_LONG(buf, objp->creationTime);
     116                        IXDR_PUT_U_LONG(buf, objp->lastActionTime);
     117                        IXDR_PUT_U_LONG(buf, objp->transferColl);
     118                        IXDR_PUT_U_LONG(buf, objp->transferIter);
     119                        IXDR_PUT_U_LONG(buf, objp->assembleMDD);
     120                        IXDR_PUT_U_LONG(buf, objp->transferMDD);
     121                        IXDR_PUT_U_LONG(buf, objp->transTiles);
     122                        IXDR_PUT_U_LONG(buf, objp->tileIter);
     123                        IXDR_PUT_U_LONG(buf, objp->bytesToTransfer);
     124                }
     125                return TRUE;
     126        } else if (xdrs->x_op == XDR_DECODE) {
     127                 if (!xdr_u_long (xdrs, &objp->clientId))
     128                         return FALSE;
     129                 if (!xdr_string (xdrs, &objp->clientIdText, ~0))
     130                         return FALSE;
     131                 if (!xdr_string (xdrs, &objp->userName, ~0))
     132                         return FALSE;
     133                 if (!xdr_string (xdrs, &objp->baseName, ~0))
     134                         return FALSE;
     135                buf = XDR_INLINE (xdrs, 9 * BYTES_PER_XDR_UNIT);
     136                if (buf == NULL) {
     137                         if (!xdr_u_long (xdrs, &objp->creationTime))
     138                                 return FALSE;
     139                         if (!xdr_u_long (xdrs, &objp->lastActionTime))
     140                                 return FALSE;
     141                         if (!xdr_u_long (xdrs, &objp->transferColl))
     142                                 return FALSE;
     143                         if (!xdr_u_long (xdrs, &objp->transferIter))
     144                                 return FALSE;
     145                         if (!xdr_u_long (xdrs, &objp->assembleMDD))
     146                                 return FALSE;
     147                         if (!xdr_u_long (xdrs, &objp->transferMDD))
     148                                 return FALSE;
     149                         if (!xdr_u_long (xdrs, &objp->transTiles))
     150                                 return FALSE;
     151                         if (!xdr_u_long (xdrs, &objp->tileIter))
     152                                 return FALSE;
     153                         if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
     154                                 return FALSE;
     155                } else {
     156                        objp->creationTime = IXDR_GET_U_LONG(buf);
     157                        objp->lastActionTime = IXDR_GET_U_LONG(buf);
     158                        objp->transferColl = IXDR_GET_U_LONG(buf);
     159                        objp->transferIter = IXDR_GET_U_LONG(buf);
     160                        objp->assembleMDD = IXDR_GET_U_LONG(buf);
     161                        objp->transferMDD = IXDR_GET_U_LONG(buf);
     162                        objp->transTiles = IXDR_GET_U_LONG(buf);
     163                        objp->tileIter = IXDR_GET_U_LONG(buf);
     164                        objp->bytesToTransfer = IXDR_GET_U_LONG(buf);
     165                }
     166         return TRUE;
     167        }
     168
     169         if (!xdr_u_long (xdrs, &objp->clientId))
     170                 return FALSE;
     171         if (!xdr_string (xdrs, &objp->clientIdText, ~0))
     172                 return FALSE;
     173         if (!xdr_string (xdrs, &objp->userName, ~0))
     174                 return FALSE;
     175         if (!xdr_string (xdrs, &objp->baseName, ~0))
     176                 return FALSE;
     177         if (!xdr_u_long (xdrs, &objp->creationTime))
     178                 return FALSE;
     179         if (!xdr_u_long (xdrs, &objp->lastActionTime))
     180                 return FALSE;
     181         if (!xdr_u_long (xdrs, &objp->transferColl))
     182                 return FALSE;
     183         if (!xdr_u_long (xdrs, &objp->transferIter))
     184                 return FALSE;
     185         if (!xdr_u_long (xdrs, &objp->assembleMDD))
     186                 return FALSE;
     187         if (!xdr_u_long (xdrs, &objp->transferMDD))
     188                 return FALSE;
     189         if (!xdr_u_long (xdrs, &objp->transTiles))
     190                 return FALSE;
     191         if (!xdr_u_long (xdrs, &objp->tileIter))
     192                 return FALSE;
     193         if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
     194                 return FALSE;
     195        return TRUE;
     196}
     197
     198bool_t
     199xdr_RPCOIdEntry (XDR *xdrs, RPCOIdEntry *objp)
     200{
     201        register int32_t *buf;
     202
     203         if (!xdr_string (xdrs, &objp->oid, ~0))
     204                 return FALSE;
     205        return TRUE;
     206}
     207
     208bool_t
     209xdr_OpenDBParams (XDR *xdrs, OpenDBParams *objp)
     210{
     211        register int32_t *buf;
     212
     213         if (!xdr_string (xdrs, &objp->dbName, ~0))
     214                 return FALSE;
     215         if (!xdr_string (xdrs, &objp->userName, ~0))
     216                 return FALSE;
     217         if (!xdr_string (xdrs, &objp->capability, ~0))
     218                 return FALSE;
     219        return TRUE;
     220}
     221
     222bool_t
     223xdr_OpenDBRes (XDR *xdrs, OpenDBRes *objp)
     224{
     225        register int32_t *buf;
     226
     227         if (!xdr_u_short (xdrs, &objp->status))
     228                 return FALSE;
     229         if (!xdr_u_long (xdrs, &objp->clientID))
     230                 return FALSE;
     231        return TRUE;
     232}
     233
     234bool_t
     235xdr_BeginTAParams (XDR *xdrs, BeginTAParams *objp)
     236{
     237        register int32_t *buf;
     238
     239         if (!xdr_u_long (xdrs, &objp->clientID))
     240                 return FALSE;
     241         if (!xdr_u_short (xdrs, &objp->readOnly))
     242                 return FALSE;
     243         if (!xdr_string (xdrs, &objp->capability, ~0))
     244                 return FALSE;
     245        return TRUE;
     246}
     247
     248bool_t
     249xdr_ExecuteQueryParams (XDR *xdrs, ExecuteQueryParams *objp)
     250{
     251        register int32_t *buf;
     252
     253         if (!xdr_u_long (xdrs, &objp->clientID))
     254                 return FALSE;
     255         if (!xdr_string (xdrs, &objp->query, ~0))
     256                 return FALSE;
     257        return TRUE;
     258}
     259
     260bool_t
     261xdr_ExecuteQueryRes (XDR *xdrs, ExecuteQueryRes *objp)
     262{
     263        register int32_t *buf;
     264
     265
     266        if (xdrs->x_op == XDR_ENCODE) {
     267                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     268                if (buf == NULL) {
     269                         if (!xdr_u_short (xdrs, &objp->status))
     270                                 return FALSE;
     271                         if (!xdr_u_long (xdrs, &objp->errorNo))
     272                                 return FALSE;
     273                         if (!xdr_u_long (xdrs, &objp->lineNo))
     274                                 return FALSE;
     275                         if (!xdr_u_long (xdrs, &objp->columnNo))
     276                                 return FALSE;
     277
     278                } else {
     279                IXDR_PUT_U_SHORT(buf, objp->status);
     280                IXDR_PUT_U_LONG(buf, objp->errorNo);
     281                IXDR_PUT_U_LONG(buf, objp->lineNo);
     282                IXDR_PUT_U_LONG(buf, objp->columnNo);
     283                }
     284                 if (!xdr_string (xdrs, &objp->token, ~0))
     285                         return FALSE;
     286                 if (!xdr_string (xdrs, &objp->typeName, ~0))
     287                         return FALSE;
     288                 if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     289                         return FALSE;
     290                return TRUE;
     291        } else if (xdrs->x_op == XDR_DECODE) {
     292                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     293                if (buf == NULL) {
     294                         if (!xdr_u_short (xdrs, &objp->status))
     295                                 return FALSE;
     296                         if (!xdr_u_long (xdrs, &objp->errorNo))
     297                                 return FALSE;
     298                         if (!xdr_u_long (xdrs, &objp->lineNo))
     299                                 return FALSE;
     300                         if (!xdr_u_long (xdrs, &objp->columnNo))
     301                                 return FALSE;
     302
     303                } else {
     304                objp->status = IXDR_GET_U_SHORT(buf);
     305                objp->errorNo = IXDR_GET_U_LONG(buf);
     306                objp->lineNo = IXDR_GET_U_LONG(buf);
     307                objp->columnNo = IXDR_GET_U_LONG(buf);
     308                }
     309                 if (!xdr_string (xdrs, &objp->token, ~0))
     310                         return FALSE;
     311                 if (!xdr_string (xdrs, &objp->typeName, ~0))
     312                         return FALSE;
     313                 if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     314                         return FALSE;
     315         return TRUE;
     316        }
     317
     318         if (!xdr_u_short (xdrs, &objp->status))
     319                 return FALSE;
     320         if (!xdr_u_long (xdrs, &objp->errorNo))
     321                 return FALSE;
     322         if (!xdr_u_long (xdrs, &objp->lineNo))
     323                 return FALSE;
     324         if (!xdr_u_long (xdrs, &objp->columnNo))
     325                 return FALSE;
     326         if (!xdr_string (xdrs, &objp->token, ~0))
     327                 return FALSE;
     328         if (!xdr_string (xdrs, &objp->typeName, ~0))
     329                 return FALSE;
     330         if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     331                 return FALSE;
     332        return TRUE;
     333}
     334
     335bool_t
     336xdr_ExecuteUpdateRes (XDR *xdrs, ExecuteUpdateRes *objp)
     337{
     338        register int32_t *buf;
     339
     340
     341        if (xdrs->x_op == XDR_ENCODE) {
     342                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     343                if (buf == NULL) {
     344                         if (!xdr_u_short (xdrs, &objp->status))
     345                                 return FALSE;
     346                         if (!xdr_u_long (xdrs, &objp->errorNo))
     347                                 return FALSE;
     348                         if (!xdr_u_long (xdrs, &objp->lineNo))
     349                                 return FALSE;
     350                         if (!xdr_u_long (xdrs, &objp->columnNo))
     351                                 return FALSE;
     352
     353                } else {
     354                IXDR_PUT_U_SHORT(buf, objp->status);
     355                IXDR_PUT_U_LONG(buf, objp->errorNo);
     356                IXDR_PUT_U_LONG(buf, objp->lineNo);
     357                IXDR_PUT_U_LONG(buf, objp->columnNo);
     358                }
     359                 if (!xdr_string (xdrs, &objp->token, ~0))
     360                         return FALSE;
     361                return TRUE;
     362        } else if (xdrs->x_op == XDR_DECODE) {
     363                buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
     364                if (buf == NULL) {
     365                         if (!xdr_u_short (xdrs, &objp->status))
     366                                 return FALSE;
     367                         if (!xdr_u_long (xdrs, &objp->errorNo))
     368                                 return FALSE;
     369                         if (!xdr_u_long (xdrs, &objp->lineNo))
     370                                 return FALSE;
     371                         if (!xdr_u_long (xdrs, &objp->columnNo))
     372                                 return FALSE;
     373
     374                } else {
     375                objp->status = IXDR_GET_U_SHORT(buf);
     376                objp->errorNo = IXDR_GET_U_LONG(buf);
     377                objp->lineNo = IXDR_GET_U_LONG(buf);
     378                objp->columnNo = IXDR_GET_U_LONG(buf);
     379                }
     380                 if (!xdr_string (xdrs, &objp->token, ~0))
     381                         return FALSE;
     382         return TRUE;
     383        }
     384
     385         if (!xdr_u_short (xdrs, &objp->status))
     386                 return FALSE;
     387         if (!xdr_u_long (xdrs, &objp->errorNo))
     388                 return FALSE;
     389         if (!xdr_u_long (xdrs, &objp->lineNo))
     390                 return FALSE;
     391         if (!xdr_u_long (xdrs, &objp->columnNo))
     392                 return FALSE;
     393         if (!xdr_string (xdrs, &objp->token, ~0))
     394                 return FALSE;
     395        return TRUE;
     396}
     397
     398bool_t
     399xdr_InsertCollParams (XDR *xdrs, InsertCollParams *objp)
     400{
     401        register int32_t *buf;
     402
     403         if (!xdr_u_long (xdrs, &objp->clientID))
     404                 return FALSE;
     405         if (!xdr_string (xdrs, &objp->collName, ~0))
     406                 return FALSE;
     407         if (!xdr_string (xdrs, &objp->typeName, ~0))
     408                 return FALSE;
     409         if (!xdr_string (xdrs, &objp->oid, ~0))
     410                 return FALSE;
     411        return TRUE;
     412}
     413
     414bool_t
     415xdr_NameSpecParams (XDR *xdrs, NameSpecParams *objp)
     416{
     417        register int32_t *buf;
     418
     419         if (!xdr_u_long (xdrs, &objp->clientID))
     420                 return FALSE;
     421         if (!xdr_string (xdrs, &objp->name, ~0))
     422                 return FALSE;
     423        return TRUE;
     424}
     425
     426bool_t
     427xdr_OIdSpecParams (XDR *xdrs, OIdSpecParams *objp)
     428{
     429        register int32_t *buf;
     430
     431         if (!xdr_u_long (xdrs, &objp->clientID))
     432                 return FALSE;
     433         if (!xdr_string (xdrs, &objp->oid, ~0))
     434                 return FALSE;
     435        return TRUE;
     436}
     437
     438bool_t
     439xdr_RemoveObjFromCollParams (XDR *xdrs, RemoveObjFromCollParams *objp)
     440{
     441        register int32_t *buf;
     442
     443         if (!xdr_u_long (xdrs, &objp->clientID))
     444                 return FALSE;
     445         if (!xdr_string (xdrs, &objp->collName, ~0))
     446                 return FALSE;
     447         if (!xdr_string (xdrs, &objp->oid, ~0))
     448                 return FALSE;
     449        return TRUE;
     450}
     451
     452bool_t
     453xdr_GetCollRes (XDR *xdrs, GetCollRes *objp)
     454{
     455        register int32_t *buf;
     456
     457         if (!xdr_u_short (xdrs, &objp->status))
     458                 return FALSE;
     459         if (!xdr_string (xdrs, &objp->typeName, ~0))
     460                 return FALSE;
     461         if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     462                 return FALSE;
     463         if (!xdr_string (xdrs, &objp->oid, ~0))
     464                 return FALSE;
     465         if (!xdr_string (xdrs, &objp->collName, ~0))
     466                 return FALSE;
     467        return TRUE;
     468}
     469
     470bool_t
     471xdr_GetCollOIdsRes (XDR *xdrs, GetCollOIdsRes *objp)
     472{
     473        register int32_t *buf;
     474
     475         if (!xdr_u_short (xdrs, &objp->status))
     476                 return FALSE;
     477         if (!xdr_string (xdrs, &objp->typeName, ~0))
     478                 return FALSE;
     479         if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     480                 return FALSE;
     481         if (!xdr_string (xdrs, &objp->oid, ~0))
     482                 return FALSE;
     483         if (!xdr_string (xdrs, &objp->collName, ~0))
     484                 return FALSE;
     485         if (!xdr_array (xdrs, (char **)&objp->oidTable.oidTable_val, (u_int *) &objp->oidTable.oidTable_len, ~0,
     486                sizeof (RPCOIdEntry), (xdrproc_t) xdr_RPCOIdEntry))
     487                 return FALSE;
     488        return TRUE;
     489}
     490
     491bool_t
     492xdr_GetMDDRes (XDR *xdrs, GetMDDRes *objp)
     493{
     494        register int32_t *buf;
     495
     496         if (!xdr_u_short (xdrs, &objp->status))
     497                 return FALSE;
     498         if (!xdr_string (xdrs, &objp->domain, ~0))
     499                 return FALSE;
     500         if (!xdr_string (xdrs, &objp->typeName, ~0))
     501                 return FALSE;
     502         if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     503                 return FALSE;
     504         if (!xdr_string (xdrs, &objp->oid, ~0))
     505                 return FALSE;
     506         if (!xdr_u_short (xdrs, &objp->currentFormat))
     507                 return FALSE;
     508        return TRUE;
     509}
     510
     511bool_t
     512xdr_GetTileRes (XDR *xdrs, GetTileRes *objp)
     513{
     514        register int32_t *buf;
     515
     516         if (!xdr_u_short (xdrs, &objp->status))
     517                 return FALSE;
     518         if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
     519                 return FALSE;
     520        return TRUE;
     521}
     522
     523bool_t
     524xdr_OIdRes (XDR *xdrs, OIdRes *objp)
     525{
     526        register int32_t *buf;
     527
     528         if (!xdr_u_short (xdrs, &objp->status))
     529                 return FALSE;
     530         if (!xdr_string (xdrs, &objp->oid, ~0))
     531                 return FALSE;
     532        return TRUE;
     533}
     534
     535bool_t
     536xdr_ObjectTypeRes (XDR *xdrs, ObjectTypeRes *objp)
     537{
     538        register int32_t *buf;
     539
     540         if (!xdr_u_short (xdrs, &objp->status))
     541                 return FALSE;
     542         if (!xdr_u_short (xdrs, &objp->objType))
     543                 return FALSE;
     544        return TRUE;
     545}
     546
     547bool_t
     548xdr_InsertMDDParams (XDR *xdrs, InsertMDDParams *objp)
     549{
     550        register int32_t *buf;
     551
     552         if (!xdr_u_long (xdrs, &objp->clientID))
     553                 return FALSE;
     554         if (!xdr_string (xdrs, &objp->collName, ~0))
     555                 return FALSE;
     556         if (!xdr_string (xdrs, &objp->typeName, ~0))
     557                 return FALSE;
     558         if (!xdr_string (xdrs, &objp->oid, ~0))
     559                 return FALSE;
     560         if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
     561                 return FALSE;
     562        return TRUE;
     563}
     564
     565bool_t
     566xdr_InsertTileParams (XDR *xdrs, InsertTileParams *objp)
     567{
     568        register int32_t *buf;
     569
     570         if (!xdr_u_long (xdrs, &objp->clientID))
     571                 return FALSE;
     572         if (!xdr_int (xdrs, &objp->isPersistent))
     573                 return FALSE;
     574         if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
     575                 return FALSE;
     576        return TRUE;
     577}
     578
     579bool_t
     580xdr_EndInsertMDDParams (XDR *xdrs, EndInsertMDDParams *objp)
     581{
     582        register int32_t *buf;
     583
     584         if (!xdr_u_long (xdrs, &objp->clientID))
     585                 return FALSE;
     586         if (!xdr_int (xdrs, &objp->isPersistent))
     587                 return FALSE;
     588        return TRUE;
     589}
     590
     591bool_t
     592xdr_InsertTransMDDParams (XDR *xdrs, InsertTransMDDParams *objp)
     593{
     594        register int32_t *buf;
     595
     596         if (!xdr_u_long (xdrs, &objp->clientID))
     597                 return FALSE;
     598         if (!xdr_string (xdrs, &objp->collName, ~0))
     599                 return FALSE;
     600         if (!xdr_string (xdrs, &objp->domain, ~0))
     601                 return FALSE;
     602         if (!xdr_u_long (xdrs, &objp->typeLength))
     603                 return FALSE;
     604         if (!xdr_string (xdrs, &objp->typeName, ~0))
     605                 return FALSE;
     606        return TRUE;
     607}
     608
     609bool_t
     610xdr_InsertPersMDDParams (XDR *xdrs, InsertPersMDDParams *objp)
     611{
     612        register int32_t *buf;
     613
     614         if (!xdr_u_long (xdrs, &objp->clientID))
     615                 return FALSE;
     616         if (!xdr_string (xdrs, &objp->collName, ~0))
     617                 return FALSE;
     618         if (!xdr_string (xdrs, &objp->domain, ~0))
     619                 return FALSE;
     620         if (!xdr_u_long (xdrs, &objp->typeLength))
     621                 return FALSE;
     622         if (!xdr_string (xdrs, &objp->typeName, ~0))
     623                 return FALSE;
     624         if (!xdr_string (xdrs, &objp->oid, ~0))
     625                 return FALSE;
     626        return TRUE;
     627}
     628
     629bool_t
     630xdr_NewOIdParams (XDR *xdrs, NewOIdParams *objp)
     631{
     632        register int32_t *buf;
     633
     634         if (!xdr_u_long (xdrs, &objp->clientID))
     635                 return FALSE;
     636         if (!xdr_u_short (xdrs, &objp->objType))
     637                 return FALSE;
     638        return TRUE;
     639}
     640
     641bool_t
     642xdr_ServerStatRes (XDR *xdrs, ServerStatRes *objp)
     643{
     644        register int32_t *buf;
     645
     646
     647        if (xdrs->x_op == XDR_ENCODE) {
     648                buf = XDR_INLINE (xdrs, 12 * BYTES_PER_XDR_UNIT);
     649                if (buf == NULL) {
     650                         if (!xdr_u_short (xdrs, &objp->status))
     651                                 return FALSE;
     652                         if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
     653                                 return FALSE;
     654                         if (!xdr_u_long (xdrs, &objp->managementInterval))
     655                                 return FALSE;
     656                         if (!xdr_u_long (xdrs, &objp->transactionActive))
     657                                 return FALSE;
     658                         if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
     659                                 return FALSE;
     660                         if (!xdr_u_long (xdrs, &objp->nextClientId))
     661                                 return FALSE;
     662                         if (!xdr_u_long (xdrs, &objp->clientNumber))
     663                                 return FALSE;
     664                         if (!xdr_u_long (xdrs, &objp->memArena))
     665                                 return FALSE;
     666                         if (!xdr_u_long (xdrs, &objp->memSmblks))
     667                                 return FALSE;
     668                         if (!xdr_u_long (xdrs, &objp->memOrdblks))
     669                                 return FALSE;
     670                         if (!xdr_u_long (xdrs, &objp->memFordblks))
     671                                 return FALSE;
     672                         if (!xdr_u_long (xdrs, &objp->memUordblks))
     673                                 return FALSE;
     674
     675                } else {
     676                IXDR_PUT_U_SHORT(buf, objp->status);
     677                IXDR_PUT_U_LONG(buf, objp->inactivityTimeout);
     678                IXDR_PUT_U_LONG(buf, objp->managementInterval);
     679                IXDR_PUT_U_LONG(buf, objp->transactionActive);
     680                IXDR_PUT_U_LONG(buf, objp->maxTransferBufferSize);
     681                IXDR_PUT_U_LONG(buf, objp->nextClientId);
     682                IXDR_PUT_U_LONG(buf, objp->clientNumber);
     683                IXDR_PUT_U_LONG(buf, objp->memArena);
     684                IXDR_PUT_U_LONG(buf, objp->memSmblks);
     685                IXDR_PUT_U_LONG(buf, objp->memOrdblks);
     686                IXDR_PUT_U_LONG(buf, objp->memFordblks);
     687                IXDR_PUT_U_LONG(buf, objp->memUordblks);
     688                }
     689                 if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
     690                        sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
     691                         return FALSE;
     692                return TRUE;
     693        } else if (xdrs->x_op == XDR_DECODE) {
     694                buf = XDR_INLINE (xdrs, 12 * BYTES_PER_XDR_UNIT);
     695                if (buf == NULL) {
     696                         if (!xdr_u_short (xdrs, &objp->status))
     697                                 return FALSE;
     698                         if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
     699                                 return FALSE;
     700                         if (!xdr_u_long (xdrs, &objp->managementInterval))
     701                                 return FALSE;
     702                         if (!xdr_u_long (xdrs, &objp->transactionActive))
     703                                 return FALSE;
     704                         if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
     705                                 return FALSE;
     706                         if (!xdr_u_long (xdrs, &objp->nextClientId))
     707                                 return FALSE;
     708                         if (!xdr_u_long (xdrs, &objp->clientNumber))
     709                                 return FALSE;
     710                         if (!xdr_u_long (xdrs, &objp->memArena))
     711                                 return FALSE;
     712                         if (!xdr_u_long (xdrs, &objp->memSmblks))
     713                                 return FALSE;
     714                         if (!xdr_u_long (xdrs, &objp->memOrdblks))
     715                                 return FALSE;
     716                         if (!xdr_u_long (xdrs, &objp->memFordblks))
     717                                 return FALSE;
     718                         if (!xdr_u_long (xdrs, &objp->memUordblks))
     719                                 return FALSE;
     720
     721                } else {
     722                objp->status = IXDR_GET_U_SHORT(buf);
     723                objp->inactivityTimeout = IXDR_GET_U_LONG(buf);
     724                objp->managementInterval = IXDR_GET_U_LONG(buf);
     725                objp->transactionActive = IXDR_GET_U_LONG(buf);
     726                objp->maxTransferBufferSize = IXDR_GET_U_LONG(buf);
     727                objp->nextClientId = IXDR_GET_U_LONG(buf);
     728                objp->clientNumber = IXDR_GET_U_LONG(buf);
     729                objp->memArena = IXDR_GET_U_LONG(buf);
     730                objp->memSmblks = IXDR_GET_U_LONG(buf);
     731                objp->memOrdblks = IXDR_GET_U_LONG(buf);
     732                objp->memFordblks = IXDR_GET_U_LONG(buf);
     733                objp->memUordblks = IXDR_GET_U_LONG(buf);
     734                }
     735                 if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
     736                        sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
     737                         return FALSE;
     738         return TRUE;
     739        }
     740
     741         if (!xdr_u_short (xdrs, &objp->status))
     742                 return FALSE;
     743         if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
     744                 return FALSE;
     745         if (!xdr_u_long (xdrs, &objp->managementInterval))
     746                 return FALSE;
     747         if (!xdr_u_long (xdrs, &objp->transactionActive))
     748                 return FALSE;
     749         if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
     750                 return FALSE;
     751         if (!xdr_u_long (xdrs, &objp->nextClientId))
     752                 return FALSE;
     753         if (!xdr_u_long (xdrs, &objp->clientNumber))
     754                 return FALSE;
     755         if (!xdr_u_long (xdrs, &objp->memArena))
     756                 return FALSE;
     757         if (!xdr_u_long (xdrs, &objp->memSmblks))
     758                 return FALSE;
     759         if (!xdr_u_long (xdrs, &objp->memOrdblks))
     760                 return FALSE;
     761         if (!xdr_u_long (xdrs, &objp->memFordblks))
     762                 return FALSE;
     763         if (!xdr_u_long (xdrs, &objp->memUordblks))
     764                 return FALSE;
     765         if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
     766                sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
     767                 return FALSE;
     768        return TRUE;
     769}
     770
     771bool_t
     772xdr_ServerVersionRes (XDR *xdrs, ServerVersionRes *objp)
     773{
     774        register int32_t *buf;
     775
     776         if (!xdr_u_short (xdrs, &objp->status))
     777                 return FALSE;
     778         if (!xdr_double (xdrs, &objp->serverVersionNo))
     779                 return FALSE;
     780         if (!xdr_double (xdrs, &objp->rpcInterfaceVersionNo))
     781                 return FALSE;
     782        return TRUE;
     783}
     784
     785bool_t
     786xdr_GetTypeStructureParams (XDR *xdrs, GetTypeStructureParams *objp)
     787{
     788        register int32_t *buf;
     789
     790         if (!xdr_u_long (xdrs, &objp->clientID))
     791                 return FALSE;
     792         if (!xdr_string (xdrs, &objp->typeName, ~0))
     793                 return FALSE;
     794         if (!xdr_u_short (xdrs, &objp->typeType))
     795                 return FALSE;
     796        return TRUE;
     797}
     798
     799bool_t
     800xdr_GetTypeStructureRes (XDR *xdrs, GetTypeStructureRes *objp)
     801{
     802        register int32_t *buf;
     803
     804         if (!xdr_u_short (xdrs, &objp->status))
     805                 return FALSE;
     806         if (!xdr_string (xdrs, &objp->typeStructure, ~0))
     807                 return FALSE;
     808        return TRUE;
     809}
     810
     811bool_t
     812xdr_GetElementRes (XDR *xdrs, GetElementRes *objp)
     813{
     814        register int32_t *buf;
     815
     816         if (!xdr_u_short (xdrs, &objp->status))
     817                 return FALSE;
     818         if (!xdr_confarray (xdrs, &objp->data))
     819                 return FALSE;
     820        return TRUE;
     821}
     822
     823bool_t
     824xdr_SetServerTransferParams (XDR *xdrs, SetServerTransferParams *objp)
     825{
     826        register int32_t *buf;
     827
     828         if (!xdr_u_long (xdrs, &objp->clientID))
     829                 return FALSE;
     830         if (!xdr_u_short (xdrs, &objp->format))
     831                 return FALSE;
     832         if (!xdr_string (xdrs, &objp->formatParams, ~0))
     833                 return FALSE;
     834        return TRUE;
     835}
     836
     837bool_t
     838xdr_GetExtendedErrorInfo (XDR *xdrs, GetExtendedErrorInfo *objp)
     839{
     840        register int32_t *buf;
     841
     842         if (!xdr_u_short (xdrs, &objp->status))
     843                 return FALSE;
     844         if (!xdr_string (xdrs, &objp->errorText, ~0))
     845                 return FALSE;
     846        return TRUE;
     847}