Skip to content

Instantly share code, notes, and snippets.

@Sharpie

Sharpie/rasdaman_os_x.patch

Created November 10, 2011 08:03
Show Gist options
  • Save Sharpie/1354395 to your computer and use it in GitHub Desktop.
Save Sharpie/1354395 to your computer and use it in GitHub Desktop.
Download ZIP
Patches to enable Rasdaman to compile on OS X
Raw
rasdaman_os_x.patch
From 74ed3f1e3e965426168bafa8f46e044261ce8aba Mon Sep 17 00:00:00 2001
From: Charlie Sharpsteen <[email protected]>
Date: Mon, 27 Sep 2010 14:36:43 -0700
Subject: [PATCH 1/4] Disable libgcrypt and libnsl in configure.ac
OS X does not have libcrypt or libnsl. This commit allows Rasdaman to compile
on OS X but most likely breaks Linux compiles.
Someone who actually knows how to use the autotools should revise these changes
so that the libraries are only disabled on OS X.
---
configure.ac | 6 +++---
1 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/configure.ac b/configure.ac
index 043e293..1c79170 100644
--- a/configure.ac
+++ b/configure.ac
@@ -31,7 +31,7 @@ AC_CHECK_PROGS(YACC, bison, [${am_missing_run} bison])
# Checks for libraries.
# FIXME: Replace `main' with a function in `-lcrypt':
-AC_CHECK_LIB([crypt], [main], , [AC_MSG_FAILURE([libcrypt.a not found! Please install.])])
+#AC_CHECK_LIB([crypt], [main], , [AC_MSG_FAILURE([libcrypt.a not found! Please install.])])
AC_CHECK_LIB([crypto], [EVP_DigestFinal], , [AC_MSG_FAILURE([libcrypto.a not found! Please install.])])
# FIXME: Replace `main' with a function in `-ldf':
#AC_CHECK_LIB([df], [main], , [AC_MSG_FAILURE([libdf.a not found! Please install.])])
@@ -333,8 +333,8 @@ AC_DEFINE([RASARCHITECTURE], ["X86"])
AC_DEFINE([RASSCHEMAVERSION], [5])
AC_DEFINE([NOPRE])
# if not on DEC Alpha
-BASEDBLDFLAGS+=" -lnsl"
-STATICBASEDBLDFLAGS+=" -lnsl"
+#BASEDBLDFLAGS+=" -lnsl"
+#STATICBASEDBLDFLAGS+=" -lnsl"
# endif
AC_DEFINE([NO_in_addr_t])
BASEDBCXXFLAGS+=" $DBIF_INC "
--
1.7.7.1
From efb3ce66f648fccc7c46e92ffcfbb4a5202aed4c Mon Sep 17 00:00:00 2001
From: Charlie Sharpsteen <[email protected]>
Date: Mon, 27 Sep 2010 15:01:34 -0700
Subject: [PATCH 2/4] OS X specific changes to include statements
On OS X some header files are in different locations or have different names.
The most notable change is that `sys/malloc.h` must be included instead of
`malloc.h` on OS X.
---
catalogmgr/ops.cc | 7 ++++++-
conversion/memfs.cc | 4 ++++
raslib/metaobject.cc | 4 ++++
raslib/property.cc | 5 ++++-
raslib/structuretype.cc | 6 +++++-
rasmgr/rasmgr_config.cc | 3 +++
rasmgr/rasmgr_config.hh | 4 ++++
rasmgr/rasmgr_localsrv.cc | 4 ++++
reladminif/databaseifcommon.cc | 4 ++++
relcatalogif/complextype.hh | 4 ++++
relcatalogif/floattype.C | 4 ++++
relcatalogif/mddbasetypecommon.cc | 4 ++++
relcatalogif/mdddimensiontypecommon.cc | 4 ++++
relcatalogif/mdddomaintypecommon.cc | 6 +++++-
relcatalogif/mddtypecommon.cc | 4 ++++
relcatalogif/settypecommon.cc | 4 ++++
servercomm/callbackmgr.cc | 4 ++++
servercomm/httpserver.cc | 4 ++++
servercomm/manager.cc | 5 +++++
servercomm/servercomm.cc | 6 ++++++
servercomm/servercomm2.cc | 4 ++++
21 files changed, 90 insertions(+), 4 deletions(-)
diff --git a/catalogmgr/ops.cc b/catalogmgr/ops.cc
index 0bf67f8..7911e65 100644
--- a/catalogmgr/ops.cc
+++ b/catalogmgr/ops.cc
@@ -23,9 +23,14 @@ rasdaman GmbH.
static const char rcsid[] = "@(#)catalogif,ops.cc: $Header: /home/rasdev/CVS-repository/rasdaman/catalogmgr/ops.cc,v 1.67 2003/12/20 23:41:27 rasdev Exp $";
#include <limits.h>
-#include <values.h>
#include <string.h> // memcpy()
+#ifdef __APPLE__
+#include <sys/malloc.h> // malloc()
+#include <float.h>
+#else
#include <malloc.h> // malloc()
+#include <values.h>
+#endif
#include "ops.hh"
#include "relcatalogif/alltypes.hh"
#include "typefactory.hh"
diff --git a/conversion/memfs.cc b/conversion/memfs.cc
index 8dca196..5b6db04 100644
--- a/conversion/memfs.cc
+++ b/conversion/memfs.cc
@@ -35,7 +35,11 @@ rasdaman GmbH.
#include "mymalloc/mymalloc.h"
#include <stdio.h>
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
#include "conversion/memfs.hh"
diff --git a/raslib/metaobject.cc b/raslib/metaobject.cc
index 844aa48..9253a5a 100644
--- a/raslib/metaobject.cc
+++ b/raslib/metaobject.cc
@@ -27,7 +27,11 @@ static const char rcsid[] = "@(#)raslib, r_Meta_Object: $Header: /home/rasdev/CV
#include "raslib/metaobject.hh"
#include <stdlib.h> // OSF1 has the definition for malloc here
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
r_Meta_Object::r_Meta_Object()
diff --git a/raslib/property.cc b/raslib/property.cc
index ddd75c2..414a887 100644
--- a/raslib/property.cc
+++ b/raslib/property.cc
@@ -28,8 +28,11 @@ static const char rcsid[] = "@(#)raslib, r_Meta_Object: $Header: /home/rasdev/CV
#include "raslib/rminit.hh"
#include "raslib/error.hh"
-
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
r_Property::r_Property()
diff --git a/raslib/structuretype.cc b/raslib/structuretype.cc
index ddfd9fb..3a3ec4d 100644
--- a/raslib/structuretype.cc
+++ b/raslib/structuretype.cc
@@ -23,7 +23,11 @@ rasdaman GmbH.
static const char rcsid[] = "@(#)raslib, r_Structure_Type: $Header: /home/rasdev/CVS-repository/rasdaman/raslib/structuretype.cc,v 1.23 2003/12/27 23:01:21 rasdev Exp $";
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
#include "raslib/structuretype.hh"
@@ -273,4 +277,4 @@ std::ostream &operator<<( std::ostream &str, const r_Structure_Type &type )
{
type.print_status(str);
return str;
-}
\ No newline at end of file
+}
diff --git a/rasmgr/rasmgr_config.cc b/rasmgr/rasmgr_config.cc
index 20f47c4..7698f07 100644
--- a/rasmgr/rasmgr_config.cc
+++ b/rasmgr/rasmgr_config.cc
@@ -55,6 +55,9 @@ using namespace std;
#include <iomanip>
#include <time.h>
#include <bits/list.tcc>
+#ifdef __APPLE__
+#include <sys/stat.h> // mkdir()
+#endif
#include "debug-srv.hh"
#include "raslib/rminit.hh"
diff --git a/rasmgr/rasmgr_config.hh b/rasmgr/rasmgr_config.hh
index 506e7c1..8e14356 100644
--- a/rasmgr/rasmgr_config.hh
+++ b/rasmgr/rasmgr_config.hh
@@ -39,7 +39,11 @@ rasdaman GmbH.
#include <iostream>
#include <string>
#include <sys/time.h>
+#ifdef __APPLE__
+#include <limits.h>
+#else
#include <linux/limits.h> // PATH_MAX
+#endif
#include "commline/cmlparser.hh"
diff --git a/rasmgr/rasmgr_localsrv.cc b/rasmgr/rasmgr_localsrv.cc
index 61058bc..eab7ee9 100644
--- a/rasmgr/rasmgr_localsrv.cc
+++ b/rasmgr/rasmgr_localsrv.cc
@@ -42,7 +42,11 @@ using namespace std;
#include <signal.h>
#include <time.h>
+#ifdef __APPLE__
+#include <limits.h>
+#else
#include <linux/limits.h> // ARG_MAX
+#endif
// fix for missing ARG_MAX; workaround for glibc-2.8 and above
#if defined(_SC_ARG_MAX)
# if defined(ARG_MAX)
diff --git a/reladminif/databaseifcommon.cc b/reladminif/databaseifcommon.cc
index b3e3097..23eca1f 100644
--- a/reladminif/databaseifcommon.cc
+++ b/reladminif/databaseifcommon.cc
@@ -36,7 +36,11 @@ rasdaman GmbH.
#include <string.h>
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include "globals.hh" // DEFAULT_DBNAME
diff --git a/relcatalogif/complextype.hh b/relcatalogif/complextype.hh
index c3d5f16..b1e4d22 100644
--- a/relcatalogif/complextype.hh
+++ b/relcatalogif/complextype.hh
@@ -38,7 +38,11 @@ rasdaman GmbH.
#define _COMPLEXTYPE_HH_
#include <iostream>
+#ifdef __APPLE__
+#include <float.h>
+#else
#include <values.h>
+#endif
#include "realtype.hh"
#include "catalogmgr/ops.hh"
diff --git a/relcatalogif/floattype.C b/relcatalogif/floattype.C
index f043dd9..cae4b4b 100644
--- a/relcatalogif/floattype.C
+++ b/relcatalogif/floattype.C
@@ -38,7 +38,11 @@ static const char rcsid[] = "@(#)catalogif,FloatType: $Header: /home/rasdev/CVS-
#include <iomanip>
#include <string.h>
#include "reladminif/oidif.hh"
+#ifdef __APPLE__
+#include <float.h>
+#else
#include <values.h>
+#endif
FloatType::FloatType(const OId& id) throw (r_Error)
: RealType(id)
diff --git a/relcatalogif/mddbasetypecommon.cc b/relcatalogif/mddbasetypecommon.cc
index 036abe8..15867ec 100644
--- a/relcatalogif/mddbasetypecommon.cc
+++ b/relcatalogif/mddbasetypecommon.cc
@@ -31,7 +31,11 @@ rasdaman GmbH.
* CHANGE HISTORY (append further entries):
*/
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include "raslib/rmdebug.hh"
#include "mddbasetype.hh"
#include "mdddomaintype.hh"
diff --git a/relcatalogif/mdddimensiontypecommon.cc b/relcatalogif/mdddimensiontypecommon.cc
index dc71b06..91ce8bd 100644
--- a/relcatalogif/mdddimensiontypecommon.cc
+++ b/relcatalogif/mdddimensiontypecommon.cc
@@ -23,7 +23,11 @@ rasdaman GmbH.
#include "mymalloc/mymalloc.h"
#include "raslib/rmdebug.hh"
#include "mdddimensiontype.hh"
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include "basetype.hh"
#include "mdddomaintype.hh"
#include <iostream>
diff --git a/relcatalogif/mdddomaintypecommon.cc b/relcatalogif/mdddomaintypecommon.cc
index 0f64848..5013e4a 100644
--- a/relcatalogif/mdddomaintypecommon.cc
+++ b/relcatalogif/mdddomaintypecommon.cc
@@ -24,7 +24,11 @@ rasdaman GmbH.
#include "raslib/rmdebug.hh"
#include "mdddomaintype.hh"
#include "mdddimensiontype.hh"
-#include "malloc.h"
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
+#include <malloc.h>
+#endif
#include "basetype.hh"
#include <iostream>
#include "reladminif/sqlerror.hh"
diff --git a/relcatalogif/mddtypecommon.cc b/relcatalogif/mddtypecommon.cc
index e1ed1dd..6aba2d5 100644
--- a/relcatalogif/mddtypecommon.cc
+++ b/relcatalogif/mddtypecommon.cc
@@ -21,7 +21,11 @@ rasdaman GmbH.
* or contact Peter Baumann via <[email protected]>.
*/
#include "mymalloc/mymalloc.h"
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <iostream>
#include <string.h>
#include "raslib/minterval.hh"
diff --git a/relcatalogif/settypecommon.cc b/relcatalogif/settypecommon.cc
index c05e74c..fa348b1 100644
--- a/relcatalogif/settypecommon.cc
+++ b/relcatalogif/settypecommon.cc
@@ -21,7 +21,11 @@ rasdaman GmbH.
* or contact Peter Baumann via <[email protected]>.
*/
#include "mymalloc/mymalloc.h"
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include "settype.hh"
#include <stdlib.h>
#include <string.h>
diff --git a/servercomm/callbackmgr.cc b/servercomm/callbackmgr.cc
index ff5cb08..b244b38 100644
--- a/servercomm/callbackmgr.cc
+++ b/servercomm/callbackmgr.cc
@@ -31,7 +31,11 @@ rasdaman GmbH.
*/
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
#include <stdio.h>
diff --git a/servercomm/httpserver.cc b/servercomm/httpserver.cc
index f75b9b0..247517d 100644
--- a/servercomm/httpserver.cc
+++ b/servercomm/httpserver.cc
@@ -35,7 +35,11 @@ rasdaman GmbH.
static const char rcsid[] = "@(#)servercomm, HttpServer: $Id: httpserver.cc,v 1.54 2005/09/03 21:05:14 rasdev Exp $";
#include <iostream>
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <time.h> // for time()
#include <string.h>
diff --git a/servercomm/manager.cc b/servercomm/manager.cc
index 8177919..9f9198b 100644
--- a/servercomm/manager.cc
+++ b/servercomm/manager.cc
@@ -38,7 +38,12 @@ using namespace std;
#include <string.h> // for strcat()
#include <time.h> // for time()
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
+
// server option for switching off garbageCollection (Formerly there were problems
// because of illegal functions called in signal handler, see man 5 attributes;
diff --git a/servercomm/servercomm.cc b/servercomm/servercomm.cc
index 076c532..52c7133 100644
--- a/servercomm/servercomm.cc
+++ b/servercomm/servercomm.cc
@@ -59,7 +59,11 @@ static const char rcsid[] = "@(#)servercomm, ServerComm: $Id: servercomm.cc,v 1.
#include<openssl/evp.h>
#include <iostream>
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <time.h> // for time()
#include <string.h>
@@ -830,6 +834,7 @@ ServerComm::getServerStatus( ServerStatRes& returnStruct )
}
}
+#ifndef __APPLE__
struct mallinfo meminfo = mallinfo();
returnStruct.memArena = meminfo.arena;
@@ -837,6 +842,7 @@ ServerComm::getServerStatus( ServerStatRes& returnStruct )
returnStruct.memOrdblks = meminfo.ordblks;
returnStruct.memFordblks = meminfo.fordblks;
returnStruct.memUordblks = meminfo.uordblks;
+#endif
}
diff --git a/servercomm/servercomm2.cc b/servercomm/servercomm2.cc
index 14b7695..0db3010 100644
--- a/servercomm/servercomm2.cc
+++ b/servercomm/servercomm2.cc
@@ -43,7 +43,11 @@ static const char rcsid[] = "@(#)servercomm2, ServerComm: $Id: servercomm2.cc,v
#define ANDREAS_2306
#include <iostream>
+#ifdef __APPLE__
+#include <sys/malloc.h>
+#else
#include <malloc.h>
+#endif
#include <string.h>
#include <math.h> // for log(), exp(), floor()
#include <ctime> // time
--
1.7.7.1
From 262b37e3d789bae0bc7e258696eb45472198b432 Mon Sep 17 00:00:00 2001
From: Charlie Sharpsteen <[email protected]>
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/.gitignore
+++ b/.gitignore
@@ -8,10 +8,6 @@ autom4te.cache
*.a
#These are all generated files under openrasdaman
applications/rasql/rasql
-clientcomm/rpcif.h
-clientcomm/rpcif_clnt.cc
-clientcomm/rpcif_svc.cc
-clientcomm/rpcif_xdr.c
config.log
config.status
insertutils/insertppm
diff --git a/clientcomm/rpcif.h b/clientcomm/rpcif.h
new file mode 100644
index 0000000..bab3781
--- /dev/null
+++ b/clientcomm/rpcif.h
@@ -0,0 +1,842 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _RPCIF.H_H_RPCGEN
+#define _RPCIF.H_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct {
+ u_int confarray_len;
+ char *confarray_val;
+} confarray;
+
+struct RPCMarray {
+ char *domain;
+ u_long cellTypeLength;
+ u_short currentFormat;
+ u_short storageFormat;
+ confarray data;
+};
+typedef struct RPCMarray RPCMarray;
+
+struct RPCClientEntry {
+ u_long clientId;
+ char *clientIdText;
+ char *userName;
+ char *baseName;
+ u_long creationTime;
+ u_long lastActionTime;
+ u_long transferColl;
+ u_long transferIter;
+ u_long assembleMDD;
+ u_long transferMDD;
+ u_long transTiles;
+ u_long tileIter;
+ u_long bytesToTransfer;
+};
+typedef struct RPCClientEntry RPCClientEntry;
+
+struct RPCOIdEntry {
+ char *oid;
+};
+typedef struct RPCOIdEntry RPCOIdEntry;
+
+struct OpenDBParams {
+ char *dbName;
+ char *userName;
+ char *capability;
+};
+typedef struct OpenDBParams OpenDBParams;
+
+struct OpenDBRes {
+ u_short status;
+ u_long clientID;
+};
+typedef struct OpenDBRes OpenDBRes;
+
+struct BeginTAParams {
+ u_long clientID;
+ u_short readOnly;
+ char *capability;
+};
+typedef struct BeginTAParams BeginTAParams;
+
+struct ExecuteQueryParams {
+ u_long clientID;
+ char *query;
+};
+typedef struct ExecuteQueryParams ExecuteQueryParams;
+
+struct ExecuteQueryRes {
+ u_short status;
+ u_long errorNo;
+ u_long lineNo;
+ u_long columnNo;
+ char *token;
+ char *typeName;
+ char *typeStructure;
+};
+typedef struct ExecuteQueryRes ExecuteQueryRes;
+
+struct ExecuteUpdateRes {
+ u_short status;
+ u_long errorNo;
+ u_long lineNo;
+ u_long columnNo;
+ char *token;
+};
+typedef struct ExecuteUpdateRes ExecuteUpdateRes;
+
+struct InsertCollParams {
+ u_long clientID;
+ char *collName;
+ char *typeName;
+ char *oid;
+};
+typedef struct InsertCollParams InsertCollParams;
+
+struct NameSpecParams {
+ u_long clientID;
+ char *name;
+};
+typedef struct NameSpecParams NameSpecParams;
+
+struct OIdSpecParams {
+ u_long clientID;
+ char *oid;
+};
+typedef struct OIdSpecParams OIdSpecParams;
+
+struct RemoveObjFromCollParams {
+ u_long clientID;
+ char *collName;
+ char *oid;
+};
+typedef struct RemoveObjFromCollParams RemoveObjFromCollParams;
+
+struct GetCollRes {
+ u_short status;
+ char *typeName;
+ char *typeStructure;
+ char *oid;
+ char *collName;
+};
+typedef struct GetCollRes GetCollRes;
+
+struct GetCollOIdsRes {
+ u_short status;
+ char *typeName;
+ char *typeStructure;
+ char *oid;
+ char *collName;
+ struct {
+ u_int oidTable_len;
+ RPCOIdEntry *oidTable_val;
+ } oidTable;
+};
+typedef struct GetCollOIdsRes GetCollOIdsRes;
+
+struct GetMDDRes {
+ u_short status;
+ char *domain;
+ char *typeName;
+ char *typeStructure;
+ char *oid;
+ u_short currentFormat;
+};
+typedef struct GetMDDRes GetMDDRes;
+
+struct GetTileRes {
+ u_short status;
+ RPCMarray *marray;
+};
+typedef struct GetTileRes GetTileRes;
+
+struct OIdRes {
+ u_short status;
+ char *oid;
+};
+typedef struct OIdRes OIdRes;
+
+struct ObjectTypeRes {
+ u_short status;
+ u_short objType;
+};
+typedef struct ObjectTypeRes ObjectTypeRes;
+
+struct InsertMDDParams {
+ u_long clientID;
+ char *collName;
+ char *typeName;
+ char *oid;
+ RPCMarray *marray;
+};
+typedef struct InsertMDDParams InsertMDDParams;
+
+struct InsertTileParams {
+ u_long clientID;
+ int isPersistent;
+ RPCMarray *marray;
+};
+typedef struct InsertTileParams InsertTileParams;
+
+struct EndInsertMDDParams {
+ u_long clientID;
+ int isPersistent;
+};
+typedef struct EndInsertMDDParams EndInsertMDDParams;
+
+struct InsertTransMDDParams {
+ u_long clientID;
+ char *collName;
+ char *domain;
+ u_long typeLength;
+ char *typeName;
+};
+typedef struct InsertTransMDDParams InsertTransMDDParams;
+
+struct InsertPersMDDParams {
+ u_long clientID;
+ char *collName;
+ char *domain;
+ u_long typeLength;
+ char *typeName;
+ char *oid;
+};
+typedef struct InsertPersMDDParams InsertPersMDDParams;
+
+struct NewOIdParams {
+ u_long clientID;
+ u_short objType;
+};
+typedef struct NewOIdParams NewOIdParams;
+
+struct ServerStatRes {
+ u_short status;
+ u_long inactivityTimeout;
+ u_long managementInterval;
+ u_long transactionActive;
+ u_long maxTransferBufferSize;
+ u_long nextClientId;
+ u_long clientNumber;
+ u_long memArena;
+ u_long memSmblks;
+ u_long memOrdblks;
+ u_long memFordblks;
+ u_long memUordblks;
+ struct {
+ u_int clientTable_len;
+ RPCClientEntry *clientTable_val;
+ } clientTable;
+};
+typedef struct ServerStatRes ServerStatRes;
+
+struct ServerVersionRes {
+ u_short status;
+ double serverVersionNo;
+ double rpcInterfaceVersionNo;
+};
+typedef struct ServerVersionRes ServerVersionRes;
+
+struct GetTypeStructureParams {
+ u_long clientID;
+ char *typeName;
+ u_short typeType;
+};
+typedef struct GetTypeStructureParams GetTypeStructureParams;
+
+struct GetTypeStructureRes {
+ u_short status;
+ char *typeStructure;
+};
+typedef struct GetTypeStructureRes GetTypeStructureRes;
+
+struct GetElementRes {
+ u_short status;
+ confarray data;
+};
+typedef struct GetElementRes GetElementRes;
+
+struct SetServerTransferParams {
+ u_long clientID;
+ u_short format;
+ char *formatParams;
+};
+typedef struct SetServerTransferParams SetServerTransferParams;
+
+struct GetExtendedErrorInfo {
+ u_short status;
+ char *errorText;
+};
+typedef struct GetExtendedErrorInfo GetExtendedErrorInfo;
+
+#define RPCIF 0x29999999
+#define RPCIFVERS 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define RPCGETSERVERVERSION 1
+extern ServerVersionRes * rpcgetserverversion_1(int *, CLIENT *);
+extern ServerVersionRes * rpcgetserverversion_1_svc(int *, struct svc_req *);
+#define RPCSHUTDOWN 2
+extern u_short * rpcshutdown_1(int *, CLIENT *);
+extern u_short * rpcshutdown_1_svc(int *, struct svc_req *);
+#define RPCSERVERSTAT 3
+extern ServerStatRes * rpcserverstat_1(int *, CLIENT *);
+extern ServerStatRes * rpcserverstat_1_svc(int *, struct svc_req *);
+#define RPCKILLTABLEENTRY 4
+extern u_short * rpckilltableentry_1(u_long *, CLIENT *);
+extern u_short * rpckilltableentry_1_svc(u_long *, struct svc_req *);
+#define RPCALIVE 5
+extern u_short * rpcalive_1(u_long *, CLIENT *);
+extern u_short * rpcalive_1_svc(u_long *, struct svc_req *);
+#define RPCOPENDB 6
+extern OpenDBRes * rpcopendb_1(OpenDBParams *, CLIENT *);
+extern OpenDBRes * rpcopendb_1_svc(OpenDBParams *, struct svc_req *);
+#define RPCCLOSEDB 7
+extern u_short * rpcclosedb_1(u_long *, CLIENT *);
+extern u_short * rpcclosedb_1_svc(u_long *, struct svc_req *);
+#define RPCCREATEDB 8
+extern u_short * rpccreatedb_1(char **, CLIENT *);
+extern u_short * rpccreatedb_1_svc(char **, struct svc_req *);
+#define RPCDESTROYDB 9
+extern u_short * rpcdestroydb_1(char **, CLIENT *);
+extern u_short * rpcdestroydb_1_svc(char **, struct svc_req *);
+#define RPCBEGINTA 10
+extern u_short * rpcbeginta_1(BeginTAParams *, CLIENT *);
+extern u_short * rpcbeginta_1_svc(BeginTAParams *, struct svc_req *);
+#define RPCCOMMITTA 11
+extern u_short * rpccommitta_1(u_long *, CLIENT *);
+extern u_short * rpccommitta_1_svc(u_long *, struct svc_req *);
+#define RPCABORTTA 12
+extern u_short * rpcabortta_1(u_long *, CLIENT *);
+extern u_short * rpcabortta_1_svc(u_long *, struct svc_req *);
+#define RPCEXECUTEQUERY 13
+extern ExecuteQueryRes * rpcexecutequery_1(ExecuteQueryParams *, CLIENT *);
+extern ExecuteQueryRes * rpcexecutequery_1_svc(ExecuteQueryParams *, struct svc_req *);
+#define RPCGETNEXTMDD 14
+extern GetMDDRes * rpcgetnextmdd_1(u_long *, CLIENT *);
+extern GetMDDRes * rpcgetnextmdd_1_svc(u_long *, struct svc_req *);
+#define RPCGETMDDBYOID 15
+extern GetMDDRes * rpcgetmddbyoid_1(OIdSpecParams *, CLIENT *);
+extern GetMDDRes * rpcgetmddbyoid_1_svc(OIdSpecParams *, struct svc_req *);
+#define RPCGETNEXTTILE 16
+extern GetTileRes * rpcgetnexttile_1(u_long *, CLIENT *);
+extern GetTileRes * rpcgetnexttile_1_svc(u_long *, struct svc_req *);
+#define RPCENDTRANSFER 17
+extern u_short * rpcendtransfer_1(u_long *, CLIENT *);
+extern u_short * rpcendtransfer_1_svc(u_long *, struct svc_req *);
+#define RPCINITEXECUTEUPDATE 18
+extern u_short * rpcinitexecuteupdate_1(u_long *, CLIENT *);
+extern u_short * rpcinitexecuteupdate_1_svc(u_long *, struct svc_req *);
+#define RPCEXECUTEUPDATE 19
+extern ExecuteUpdateRes * rpcexecuteupdate_1(ExecuteQueryParams *, CLIENT *);
+extern ExecuteUpdateRes * rpcexecuteupdate_1_svc(ExecuteQueryParams *, struct svc_req *);
+#define RPCSTARTINSERTTRANSMDD 20
+extern u_short * rpcstartinserttransmdd_1(InsertTransMDDParams *, CLIENT *);
+extern u_short * rpcstartinserttransmdd_1_svc(InsertTransMDDParams *, struct svc_req *);
+#define RPCSTARTINSERTPERSMDD 21
+extern u_short * rpcstartinsertpersmdd_1(InsertPersMDDParams *, CLIENT *);
+extern u_short * rpcstartinsertpersmdd_1_svc(InsertPersMDDParams *, struct svc_req *);
+#define RPCINSERTTILE 22
+extern u_short * rpcinserttile_1(InsertTileParams *, CLIENT *);
+extern u_short * rpcinserttile_1_svc(InsertTileParams *, struct svc_req *);
+#define RPCENDINSERTMDD 23
+extern u_short * rpcendinsertmdd_1(EndInsertMDDParams *, CLIENT *);
+extern u_short * rpcendinsertmdd_1_svc(EndInsertMDDParams *, struct svc_req *);
+#define RPCINSERTMDD 24
+extern u_short * rpcinsertmdd_1(InsertMDDParams *, CLIENT *);
+extern u_short * rpcinsertmdd_1_svc(InsertMDDParams *, struct svc_req *);
+#define RPCGETCOLLBYNAME 25
+extern GetCollRes * rpcgetcollbyname_1(NameSpecParams *, CLIENT *);
+extern GetCollRes * rpcgetcollbyname_1_svc(NameSpecParams *, struct svc_req *);
+#define RPCGETCOLLBYOID 26
+extern GetCollRes * rpcgetcollbyoid_1(OIdSpecParams *, CLIENT *);
+extern GetCollRes * rpcgetcollbyoid_1_svc(OIdSpecParams *, struct svc_req *);
+#define RPCGETCOLLOIDSBYNAME 27
+extern GetCollOIdsRes * rpcgetcolloidsbyname_1(NameSpecParams *, CLIENT *);
+extern GetCollOIdsRes * rpcgetcolloidsbyname_1_svc(NameSpecParams *, struct svc_req *);
+#define RPCGETCOLLOIDSBYOID 28
+extern GetCollOIdsRes * rpcgetcolloidsbyoid_1(OIdSpecParams *, CLIENT *);
+extern GetCollOIdsRes * rpcgetcolloidsbyoid_1_svc(OIdSpecParams *, struct svc_req *);
+#define RPCINSERTCOLL 29
+extern u_short * rpcinsertcoll_1(InsertCollParams *, CLIENT *);
+extern u_short * rpcinsertcoll_1_svc(InsertCollParams *, struct svc_req *);
+#define RPCDELETECOLLBYNAME 30
+extern u_short * rpcdeletecollbyname_1(NameSpecParams *, CLIENT *);
+extern u_short * rpcdeletecollbyname_1_svc(NameSpecParams *, struct svc_req *);
+#define RPCDELETEOBJBYOID 31
+extern u_short * rpcdeleteobjbyoid_1(OIdSpecParams *, CLIENT *);
+extern u_short * rpcdeleteobjbyoid_1_svc(OIdSpecParams *, struct svc_req *);
+#define RPCREMOVEOBJFROMCOLL 32
+extern u_short * rpcremoveobjfromcoll_1(RemoveObjFromCollParams *, CLIENT *);
+extern u_short * rpcremoveobjfromcoll_1_svc(RemoveObjFromCollParams *, struct svc_req *);
+#define RPCGETNEWOID 33
+extern OIdRes * rpcgetnewoid_1(NewOIdParams *, CLIENT *);
+extern OIdRes * rpcgetnewoid_1_svc(NewOIdParams *, struct svc_req *);
+#define RPCGETOBJECTTYPE 34
+extern ObjectTypeRes * rpcgetobjecttype_1(OIdSpecParams *, CLIENT *);
+extern ObjectTypeRes * rpcgetobjecttype_1_svc(OIdSpecParams *, struct svc_req *);
+#define RPCGETTYPESTRUCTURE 35
+extern GetTypeStructureRes * rpcgettypestructure_1(GetTypeStructureParams *, CLIENT *);
+extern GetTypeStructureRes * rpcgettypestructure_1_svc(GetTypeStructureParams *, struct svc_req *);
+#define RPCGETNEXTELEMENT 36
+extern GetElementRes * rpcgetnextelement_1(u_long *, CLIENT *);
+extern GetElementRes * rpcgetnextelement_1_svc(u_long *, struct svc_req *);
+#define RPCGETSERVERENDIAN 37
+extern int * rpcgetserverendian_1(int *, CLIENT *);
+extern int * rpcgetserverendian_1_svc(int *, struct svc_req *);
+#define RPCSETSERVERTRANSFER 38
+extern u_short * rpcsetservertransfer_1(SetServerTransferParams *, CLIENT *);
+extern u_short * rpcsetservertransfer_1_svc(SetServerTransferParams *, struct svc_req *);
+#define RPCGETERRORINFO 39
+extern GetExtendedErrorInfo * rpcgeterrorinfo_1(void *, CLIENT *);
+extern GetExtendedErrorInfo * rpcgeterrorinfo_1_svc(void *, struct svc_req *);
+#define RPCSETSERVERSTORAGE 40
+extern u_short * rpcsetserverstorage_1(SetServerTransferParams *, CLIENT *);
+extern u_short * rpcsetserverstorage_1_svc(SetServerTransferParams *, struct svc_req *);
+extern int rpcif_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define RPCGETSERVERVERSION 1
+extern ServerVersionRes * rpcgetserverversion_1();
+extern ServerVersionRes * rpcgetserverversion_1_svc();
+#define RPCSHUTDOWN 2
+extern u_short * rpcshutdown_1();
+extern u_short * rpcshutdown_1_svc();
+#define RPCSERVERSTAT 3
+extern ServerStatRes * rpcserverstat_1();
+extern ServerStatRes * rpcserverstat_1_svc();
+#define RPCKILLTABLEENTRY 4
+extern u_short * rpckilltableentry_1();
+extern u_short * rpckilltableentry_1_svc();
+#define RPCALIVE 5
+extern u_short * rpcalive_1();
+extern u_short * rpcalive_1_svc();
+#define RPCOPENDB 6
+extern OpenDBRes * rpcopendb_1();
+extern OpenDBRes * rpcopendb_1_svc();
+#define RPCCLOSEDB 7
+extern u_short * rpcclosedb_1();
+extern u_short * rpcclosedb_1_svc();
+#define RPCCREATEDB 8
+extern u_short * rpccreatedb_1();
+extern u_short * rpccreatedb_1_svc();
+#define RPCDESTROYDB 9
+extern u_short * rpcdestroydb_1();
+extern u_short * rpcdestroydb_1_svc();
+#define RPCBEGINTA 10
+extern u_short * rpcbeginta_1();
+extern u_short * rpcbeginta_1_svc();
+#define RPCCOMMITTA 11
+extern u_short * rpccommitta_1();
+extern u_short * rpccommitta_1_svc();
+#define RPCABORTTA 12
+extern u_short * rpcabortta_1();
+extern u_short * rpcabortta_1_svc();
+#define RPCEXECUTEQUERY 13
+extern ExecuteQueryRes * rpcexecutequery_1();
+extern ExecuteQueryRes * rpcexecutequery_1_svc();
+#define RPCGETNEXTMDD 14
+extern GetMDDRes * rpcgetnextmdd_1();
+extern GetMDDRes * rpcgetnextmdd_1_svc();
+#define RPCGETMDDBYOID 15
+extern GetMDDRes * rpcgetmddbyoid_1();
+extern GetMDDRes * rpcgetmddbyoid_1_svc();
+#define RPCGETNEXTTILE 16
+extern GetTileRes * rpcgetnexttile_1();
+extern GetTileRes * rpcgetnexttile_1_svc();
+#define RPCENDTRANSFER 17
+extern u_short * rpcendtransfer_1();
+extern u_short * rpcendtransfer_1_svc();
+#define RPCINITEXECUTEUPDATE 18
+extern u_short * rpcinitexecuteupdate_1();
+extern u_short * rpcinitexecuteupdate_1_svc();
+#define RPCEXECUTEUPDATE 19
+extern ExecuteUpdateRes * rpcexecuteupdate_1();
+extern ExecuteUpdateRes * rpcexecuteupdate_1_svc();
+#define RPCSTARTINSERTTRANSMDD 20
+extern u_short * rpcstartinserttransmdd_1();
+extern u_short * rpcstartinserttransmdd_1_svc();
+#define RPCSTARTINSERTPERSMDD 21
+extern u_short * rpcstartinsertpersmdd_1();
+extern u_short * rpcstartinsertpersmdd_1_svc();
+#define RPCINSERTTILE 22
+extern u_short * rpcinserttile_1();
+extern u_short * rpcinserttile_1_svc();
+#define RPCENDINSERTMDD 23
+extern u_short * rpcendinsertmdd_1();
+extern u_short * rpcendinsertmdd_1_svc();
+#define RPCINSERTMDD 24
+extern u_short * rpcinsertmdd_1();
+extern u_short * rpcinsertmdd_1_svc();
+#define RPCGETCOLLBYNAME 25
+extern GetCollRes * rpcgetcollbyname_1();
+extern GetCollRes * rpcgetcollbyname_1_svc();
+#define RPCGETCOLLBYOID 26
+extern GetCollRes * rpcgetcollbyoid_1();
+extern GetCollRes * rpcgetcollbyoid_1_svc();
+#define RPCGETCOLLOIDSBYNAME 27
+extern GetCollOIdsRes * rpcgetcolloidsbyname_1();
+extern GetCollOIdsRes * rpcgetcolloidsbyname_1_svc();
+#define RPCGETCOLLOIDSBYOID 28
+extern GetCollOIdsRes * rpcgetcolloidsbyoid_1();
+extern GetCollOIdsRes * rpcgetcolloidsbyoid_1_svc();
+#define RPCINSERTCOLL 29
+extern u_short * rpcinsertcoll_1();
+extern u_short * rpcinsertcoll_1_svc();
+#define RPCDELETECOLLBYNAME 30
+extern u_short * rpcdeletecollbyname_1();
+extern u_short * rpcdeletecollbyname_1_svc();
+#define RPCDELETEOBJBYOID 31
+extern u_short * rpcdeleteobjbyoid_1();
+extern u_short * rpcdeleteobjbyoid_1_svc();
+#define RPCREMOVEOBJFROMCOLL 32
+extern u_short * rpcremoveobjfromcoll_1();
+extern u_short * rpcremoveobjfromcoll_1_svc();
+#define RPCGETNEWOID 33
+extern OIdRes * rpcgetnewoid_1();
+extern OIdRes * rpcgetnewoid_1_svc();
+#define RPCGETOBJECTTYPE 34
+extern ObjectTypeRes * rpcgetobjecttype_1();
+extern ObjectTypeRes * rpcgetobjecttype_1_svc();
+#define RPCGETTYPESTRUCTURE 35
+extern GetTypeStructureRes * rpcgettypestructure_1();
+extern GetTypeStructureRes * rpcgettypestructure_1_svc();
+#define RPCGETNEXTELEMENT 36
+extern GetElementRes * rpcgetnextelement_1();
+extern GetElementRes * rpcgetnextelement_1_svc();
+#define RPCGETSERVERENDIAN 37
+extern int * rpcgetserverendian_1();
+extern int * rpcgetserverendian_1_svc();
+#define RPCSETSERVERTRANSFER 38
+extern u_short * rpcsetservertransfer_1();
+extern u_short * rpcsetservertransfer_1_svc();
+#define RPCGETERRORINFO 39
+extern GetExtendedErrorInfo * rpcgeterrorinfo_1();
+extern GetExtendedErrorInfo * rpcgeterrorinfo_1_svc();
+#define RPCSETSERVERSTORAGE 40
+extern u_short * rpcsetserverstorage_1();
+extern u_short * rpcsetserverstorage_1_svc();
+extern int rpcif_1_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern bool_t xdr_confarray (XDR *, confarray*);
+extern bool_t xdr_RPCMarray (XDR *, RPCMarray*);
+extern bool_t xdr_RPCClientEntry (XDR *, RPCClientEntry*);
+extern bool_t xdr_RPCOIdEntry (XDR *, RPCOIdEntry*);
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OpenDBParams(); }
+#else
+ bool_t xdr_OpenDBParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OpenDBRes(); }
+#else
+ bool_t xdr_OpenDBRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_BeginTAParams(); }
+#else
+ bool_t xdr_BeginTAParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteQueryParams(); }
+#else
+ bool_t xdr_ExecuteQueryParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteQueryRes(); }
+#else
+ bool_t xdr_ExecuteQueryRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteUpdateRes(); }
+#else
+ bool_t xdr_ExecuteUpdateRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertCollParams(); }
+#else
+ bool_t xdr_InsertCollParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_NameSpecParams(); }
+#else
+ bool_t xdr_NameSpecParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OIdSpecParams(); }
+#else
+ bool_t xdr_OIdSpecParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_RemoveObjFromCollParams(); }
+#else
+ bool_t xdr_RemoveObjFromCollParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetCollRes(); }
+#else
+ bool_t xdr_GetCollRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetCollOIdsRes(); }
+#else
+ bool_t xdr_GetCollOIdsRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetMDDRes(); }
+#else
+ bool_t xdr_GetMDDRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTileRes(); }
+#else
+ bool_t xdr_GetTileRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OIdRes(); }
+#else
+ bool_t xdr_OIdRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ObjectTypeRes(); }
+#else
+ bool_t xdr_ObjectTypeRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertMDDParams(); }
+#else
+ bool_t xdr_InsertMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertTileParams(); }
+#else
+ bool_t xdr_InsertTileParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_EndInsertMDDParams(); }
+#else
+ bool_t xdr_EndInsertMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertTransMDDParams(); }
+#else
+ bool_t xdr_InsertTransMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertPersMDDParams(); }
+#else
+ bool_t xdr_InsertPersMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_NewOIdParams(); }
+#else
+ bool_t xdr_NewOIdParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ServerStatRes(); }
+#else
+ bool_t xdr_ServerStatRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ServerVersionRes(); }
+#else
+ bool_t xdr_ServerVersionRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTypeStructureParams(); }
+#else
+ bool_t xdr_GetTypeStructureParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTypeStructureRes(); }
+#else
+ bool_t xdr_GetTypeStructureRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetElementRes(); }
+#else
+ bool_t xdr_GetElementRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_SetServerTransferParams(); }
+#else
+ bool_t xdr_SetServerTransferParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetExtendedErrorInfo(); }
+#else
+ bool_t xdr_GetExtendedErrorInfo();
+#endif
+
+#else /* K&R C */
+extern bool_t xdr_confarray ();
+extern bool_t xdr_RPCMarray ();
+extern bool_t xdr_RPCClientEntry ();
+extern bool_t xdr_RPCOIdEntry ();
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OpenDBParams(); }
+#else
+ bool_t xdr_OpenDBParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OpenDBRes(); }
+#else
+ bool_t xdr_OpenDBRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_BeginTAParams(); }
+#else
+ bool_t xdr_BeginTAParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteQueryParams(); }
+#else
+ bool_t xdr_ExecuteQueryParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteQueryRes(); }
+#else
+ bool_t xdr_ExecuteQueryRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ExecuteUpdateRes(); }
+#else
+ bool_t xdr_ExecuteUpdateRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertCollParams(); }
+#else
+ bool_t xdr_InsertCollParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_NameSpecParams(); }
+#else
+ bool_t xdr_NameSpecParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OIdSpecParams(); }
+#else
+ bool_t xdr_OIdSpecParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_RemoveObjFromCollParams(); }
+#else
+ bool_t xdr_RemoveObjFromCollParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetCollRes(); }
+#else
+ bool_t xdr_GetCollRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetCollOIdsRes(); }
+#else
+ bool_t xdr_GetCollOIdsRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetMDDRes(); }
+#else
+ bool_t xdr_GetMDDRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTileRes(); }
+#else
+ bool_t xdr_GetTileRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_OIdRes(); }
+#else
+ bool_t xdr_OIdRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ObjectTypeRes(); }
+#else
+ bool_t xdr_ObjectTypeRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertMDDParams(); }
+#else
+ bool_t xdr_InsertMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertTileParams(); }
+#else
+ bool_t xdr_InsertTileParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_EndInsertMDDParams(); }
+#else
+ bool_t xdr_EndInsertMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertTransMDDParams(); }
+#else
+ bool_t xdr_InsertTransMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_InsertPersMDDParams(); }
+#else
+ bool_t xdr_InsertPersMDDParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_NewOIdParams(); }
+#else
+ bool_t xdr_NewOIdParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ServerStatRes(); }
+#else
+ bool_t xdr_ServerStatRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_ServerVersionRes(); }
+#else
+ bool_t xdr_ServerVersionRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTypeStructureParams(); }
+#else
+ bool_t xdr_GetTypeStructureParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetTypeStructureRes(); }
+#else
+ bool_t xdr_GetTypeStructureRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetElementRes(); }
+#else
+ bool_t xdr_GetElementRes();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_SetServerTransferParams(); }
+#else
+ bool_t xdr_SetServerTransferParams();
+#endif
+#ifdef __cplusplus
+ extern "C" {bool_t xdr_GetExtendedErrorInfo(); }
+#else
+ bool_t xdr_GetExtendedErrorInfo();
+#endif
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_RPCIF.H_H_RPCGEN */
diff --git a/clientcomm/rpcif_clnt.cc b/clientcomm/rpcif_clnt.cc
new file mode 100644
index 0000000..6039548
--- /dev/null
+++ b/clientcomm/rpcif_clnt.cc
@@ -0,0 +1,1432 @@
+#include <stdio.h>
+#include "raslib/error.hh"
+#include "raslib/rminit.hh"
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "rpcif.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+ServerVersionRes *
+rpcgetserverversion_1(int *argp, CLIENT *clnt)
+{
+ static ServerVersionRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETSERVERVERSION,
+ (xdrproc_t) xdr_int, (caddr_t) argp,
+ (xdrproc_t) xdr_ServerVersionRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcshutdown_1(int *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if (clnt_call (clnt, RPCSHUTDOWN,
+ (xdrproc_t) xdr_int, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) != RPC_SUCCESS) {
+ return (NULL);
+ }
+ return (&clnt_res);
+}
+
+ServerStatRes *
+rpcserverstat_1(int *argp, CLIENT *clnt)
+{
+ static ServerStatRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCSERVERSTAT,
+ (xdrproc_t) xdr_int, (caddr_t) argp,
+ (xdrproc_t) xdr_ServerStatRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpckilltableentry_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCKILLTABLEENTRY,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcalive_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCALIVE,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+OpenDBRes *
+rpcopendb_1(OpenDBParams *argp, CLIENT *clnt)
+{
+ static OpenDBRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCOPENDB,
+ (xdrproc_t) xdr_OpenDBParams, (caddr_t) argp,
+ (xdrproc_t) xdr_OpenDBRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcclosedb_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCCLOSEDB,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpccreatedb_1(char **argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCCREATEDB,
+ (xdrproc_t) xdr_wrapstring, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcdestroydb_1(char **argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCDESTROYDB,
+ (xdrproc_t) xdr_wrapstring, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcbeginta_1(BeginTAParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCBEGINTA,
+ (xdrproc_t) xdr_BeginTAParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpccommitta_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCCOMMITTA,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcabortta_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCABORTTA,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+ExecuteQueryRes *
+rpcexecutequery_1(ExecuteQueryParams *argp, CLIENT *clnt)
+{
+ static ExecuteQueryRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCEXECUTEQUERY,
+ (xdrproc_t) xdr_ExecuteQueryParams, (caddr_t) argp,
+ (xdrproc_t) xdr_ExecuteQueryRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetMDDRes *
+rpcgetnextmdd_1(u_long *argp, CLIENT *clnt)
+{
+ static GetMDDRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETNEXTMDD,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_GetMDDRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetMDDRes *
+rpcgetmddbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
+{
+ static GetMDDRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETMDDBYOID,
+ (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetMDDRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetTileRes *
+rpcgetnexttile_1(u_long *argp, CLIENT *clnt)
+{
+ static GetTileRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETNEXTTILE,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_GetTileRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcendtransfer_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCENDTRANSFER,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcinitexecuteupdate_1(u_long *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCINITEXECUTEUPDATE,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+ExecuteUpdateRes *
+rpcexecuteupdate_1(ExecuteQueryParams *argp, CLIENT *clnt)
+{
+ static ExecuteUpdateRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCEXECUTEUPDATE,
+ (xdrproc_t) xdr_ExecuteQueryParams, (caddr_t) argp,
+ (xdrproc_t) xdr_ExecuteUpdateRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcstartinserttransmdd_1(InsertTransMDDParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCSTARTINSERTTRANSMDD,
+ (xdrproc_t) xdr_InsertTransMDDParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcstartinsertpersmdd_1(InsertPersMDDParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCSTARTINSERTPERSMDD,
+ (xdrproc_t) xdr_InsertPersMDDParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcinserttile_1(InsertTileParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCINSERTTILE,
+ (xdrproc_t) xdr_InsertTileParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcendinsertmdd_1(EndInsertMDDParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCENDINSERTMDD,
+ (xdrproc_t) xdr_EndInsertMDDParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcinsertmdd_1(InsertMDDParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCINSERTMDD,
+ (xdrproc_t) xdr_InsertMDDParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetCollRes *
+rpcgetcollbyname_1(NameSpecParams *argp, CLIENT *clnt)
+{
+ static GetCollRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETCOLLBYNAME,
+ (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetCollRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetCollRes *
+rpcgetcollbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
+{
+ static GetCollRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETCOLLBYOID,
+ (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetCollRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetCollOIdsRes *
+rpcgetcolloidsbyname_1(NameSpecParams *argp, CLIENT *clnt)
+{
+ static GetCollOIdsRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETCOLLOIDSBYNAME,
+ (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetCollOIdsRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetCollOIdsRes *
+rpcgetcolloidsbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
+{
+ static GetCollOIdsRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETCOLLOIDSBYOID,
+ (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetCollOIdsRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcinsertcoll_1(InsertCollParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCINSERTCOLL,
+ (xdrproc_t) xdr_InsertCollParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcdeletecollbyname_1(NameSpecParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCDELETECOLLBYNAME,
+ (xdrproc_t) xdr_NameSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcdeleteobjbyoid_1(OIdSpecParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCDELETEOBJBYOID,
+ (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcremoveobjfromcoll_1(RemoveObjFromCollParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCREMOVEOBJFROMCOLL,
+ (xdrproc_t) xdr_RemoveObjFromCollParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+OIdRes *
+rpcgetnewoid_1(NewOIdParams *argp, CLIENT *clnt)
+{
+ static OIdRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETNEWOID,
+ (xdrproc_t) xdr_NewOIdParams, (caddr_t) argp,
+ (xdrproc_t) xdr_OIdRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+ObjectTypeRes *
+rpcgetobjecttype_1(OIdSpecParams *argp, CLIENT *clnt)
+{
+ static ObjectTypeRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETOBJECTTYPE,
+ (xdrproc_t) xdr_OIdSpecParams, (caddr_t) argp,
+ (xdrproc_t) xdr_ObjectTypeRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetTypeStructureRes *
+rpcgettypestructure_1(GetTypeStructureParams *argp, CLIENT *clnt)
+{
+ static GetTypeStructureRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETTYPESTRUCTURE,
+ (xdrproc_t) xdr_GetTypeStructureParams, (caddr_t) argp,
+ (xdrproc_t) xdr_GetTypeStructureRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetElementRes *
+rpcgetnextelement_1(u_long *argp, CLIENT *clnt)
+{
+ static GetElementRes clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETNEXTELEMENT,
+ (xdrproc_t) xdr_u_long, (caddr_t) argp,
+ (xdrproc_t) xdr_GetElementRes, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+int *
+rpcgetserverendian_1(int *argp, CLIENT *clnt)
+{
+ static int clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETSERVERENDIAN,
+ (xdrproc_t) xdr_int, (caddr_t) argp,
+ (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcsetservertransfer_1(SetServerTransferParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCSETSERVERTRANSFER,
+ (xdrproc_t) xdr_SetServerTransferParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+GetExtendedErrorInfo *
+rpcgeterrorinfo_1(void *argp, CLIENT *clnt)
+{
+ static GetExtendedErrorInfo clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCGETERRORINFO,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_GetExtendedErrorInfo, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
+
+u_short *
+rpcsetserverstorage_1(SetServerTransferParams *argp, CLIENT *clnt)
+{
+ static u_short clnt_res;
+ enum clnt_stat stat;
+
+
+ memset((char *)&clnt_res, 0, sizeof(clnt_res));
+ if ( (stat = clnt_call (clnt, RPCSETSERVERSTORAGE,
+ (xdrproc_t) xdr_SetServerTransferParams, (caddr_t) argp,
+ (xdrproc_t) xdr_u_short, (caddr_t) &clnt_res,
+ TIMEOUT) ) != RPC_SUCCESS ) {
+ clnt_perrno( stat );
+ return (NULL);
+ }
+ if (*((u_short*)&clnt_res) == 42)
+ {
+ GetExtendedErrorInfo* result = NULL;
+ int dummy;
+ int counter = 0;
+ while (!(result = rpcgeterrorinfo_1(&dummy, clnt)) && (counter < RMInit::rpcMaxRetry))
+ {
+ counter++;
+ }
+ r_Error* t = NULL, e;
+ if (counter == RMInit::rpcMaxRetry)
+ t = new r_Error(RPCCOMMUNICATIONFAILURE);
+ else
+ t = r_Error::getAnyError(result->errorText);
+ e=*t;
+ delete t;
+ throw e;
+ }
+ return (&clnt_res);
+}
diff --git a/clientcomm/rpcif_svc.cc b/clientcomm/rpcif_svc.cc
new file mode 100644
index 0000000..afebad0
--- /dev/null
+++ b/clientcomm/rpcif_svc.cc
@@ -0,0 +1,374 @@
+//patched by awk 1
+#include "raslib/error.hh"
+#include "servercomm/servercomm.hh"
+#include <new>
+char *secureResultBufferForRPC;
+bool bMemFailed = false;
+//end patched by awk 1
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "rpcif.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <rpc/pmap_clnt.h>
+#include <string.h>
+#include <memory.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef SIG_PF
+#define SIG_PF void(*)(int)
+#endif
+
+//patched by awk 3
+char*
+//end patched by awk 3
+rpcif_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+//patched by awk 4
+char* retvalTxt = 0;
+//end patched by awk 4
+ union {
+ int rpcgetserverversion_1_arg;
+ int rpcshutdown_1_arg;
+ int rpcserverstat_1_arg;
+ u_long rpckilltableentry_1_arg;
+ u_long rpcalive_1_arg;
+ OpenDBParams rpcopendb_1_arg;
+ u_long rpcclosedb_1_arg;
+ char *rpccreatedb_1_arg;
+ char *rpcdestroydb_1_arg;
+ BeginTAParams rpcbeginta_1_arg;
+ u_long rpccommitta_1_arg;
+ u_long rpcabortta_1_arg;
+ ExecuteQueryParams rpcexecutequery_1_arg;
+ u_long rpcgetnextmdd_1_arg;
+ OIdSpecParams rpcgetmddbyoid_1_arg;
+ u_long rpcgetnexttile_1_arg;
+ u_long rpcendtransfer_1_arg;
+ u_long rpcinitexecuteupdate_1_arg;
+ ExecuteQueryParams rpcexecuteupdate_1_arg;
+ InsertTransMDDParams rpcstartinserttransmdd_1_arg;
+ InsertPersMDDParams rpcstartinsertpersmdd_1_arg;
+ InsertTileParams rpcinserttile_1_arg;
+ EndInsertMDDParams rpcendinsertmdd_1_arg;
+ InsertMDDParams rpcinsertmdd_1_arg;
+ NameSpecParams rpcgetcollbyname_1_arg;
+ OIdSpecParams rpcgetcollbyoid_1_arg;
+ NameSpecParams rpcgetcolloidsbyname_1_arg;
+ OIdSpecParams rpcgetcolloidsbyoid_1_arg;
+ InsertCollParams rpcinsertcoll_1_arg;
+ NameSpecParams rpcdeletecollbyname_1_arg;
+ OIdSpecParams rpcdeleteobjbyoid_1_arg;
+ RemoveObjFromCollParams rpcremoveobjfromcoll_1_arg;
+ NewOIdParams rpcgetnewoid_1_arg;
+ OIdSpecParams rpcgetobjecttype_1_arg;
+ GetTypeStructureParams rpcgettypestructure_1_arg;
+ u_long rpcgetnextelement_1_arg;
+ int rpcgetserverendian_1_arg;
+ SetServerTransferParams rpcsetservertransfer_1_arg;
+ SetServerTransferParams rpcsetserverstorage_1_arg;
+ } argument;
+ char *result;
+ xdrproc_t _xdr_argument, _xdr_result;
+ char *(*local)(char *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+//patched by awk 5
+return retvalTxt;
+//end patched by awk 5
+
+ case RPCGETSERVERVERSION:
+ _xdr_argument = (xdrproc_t) xdr_int;
+ _xdr_result = (xdrproc_t) xdr_ServerVersionRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetserverversion_1_svc;
+ break;
+
+ case RPCSHUTDOWN:
+ _xdr_argument = (xdrproc_t) xdr_int;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcshutdown_1_svc;
+ break;
+
+ case RPCSERVERSTAT:
+ _xdr_argument = (xdrproc_t) xdr_int;
+ _xdr_result = (xdrproc_t) xdr_ServerStatRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcserverstat_1_svc;
+ break;
+
+ case RPCKILLTABLEENTRY:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpckilltableentry_1_svc;
+ break;
+
+ case RPCALIVE:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcalive_1_svc;
+ break;
+
+ case RPCOPENDB:
+ _xdr_argument = (xdrproc_t) xdr_OpenDBParams;
+ _xdr_result = (xdrproc_t) xdr_OpenDBRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcopendb_1_svc;
+ break;
+
+ case RPCCLOSEDB:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcclosedb_1_svc;
+ break;
+
+ case RPCCREATEDB:
+ _xdr_argument = (xdrproc_t) xdr_wrapstring;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpccreatedb_1_svc;
+ break;
+
+ case RPCDESTROYDB:
+ _xdr_argument = (xdrproc_t) xdr_wrapstring;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcdestroydb_1_svc;
+ break;
+
+ case RPCBEGINTA:
+ _xdr_argument = (xdrproc_t) xdr_BeginTAParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcbeginta_1_svc;
+ break;
+
+ case RPCCOMMITTA:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpccommitta_1_svc;
+ break;
+
+ case RPCABORTTA:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcabortta_1_svc;
+ break;
+
+ case RPCEXECUTEQUERY:
+ _xdr_argument = (xdrproc_t) xdr_ExecuteQueryParams;
+ _xdr_result = (xdrproc_t) xdr_ExecuteQueryRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcexecutequery_1_svc;
+ break;
+
+ case RPCGETNEXTMDD:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_GetMDDRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetnextmdd_1_svc;
+ break;
+
+ case RPCGETMDDBYOID:
+ _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
+ _xdr_result = (xdrproc_t) xdr_GetMDDRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetmddbyoid_1_svc;
+ break;
+
+ case RPCGETNEXTTILE:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_GetTileRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetnexttile_1_svc;
+ break;
+
+ case RPCENDTRANSFER:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcendtransfer_1_svc;
+ break;
+
+ case RPCINITEXECUTEUPDATE:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcinitexecuteupdate_1_svc;
+ break;
+
+ case RPCEXECUTEUPDATE:
+ _xdr_argument = (xdrproc_t) xdr_ExecuteQueryParams;
+ _xdr_result = (xdrproc_t) xdr_ExecuteUpdateRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcexecuteupdate_1_svc;
+ break;
+
+ case RPCSTARTINSERTTRANSMDD:
+ _xdr_argument = (xdrproc_t) xdr_InsertTransMDDParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcstartinserttransmdd_1_svc;
+ break;
+
+ case RPCSTARTINSERTPERSMDD:
+ _xdr_argument = (xdrproc_t) xdr_InsertPersMDDParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcstartinsertpersmdd_1_svc;
+ break;
+
+ case RPCINSERTTILE:
+ _xdr_argument = (xdrproc_t) xdr_InsertTileParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcinserttile_1_svc;
+ break;
+
+ case RPCENDINSERTMDD:
+ _xdr_argument = (xdrproc_t) xdr_EndInsertMDDParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcendinsertmdd_1_svc;
+ break;
+
+ case RPCINSERTMDD:
+ _xdr_argument = (xdrproc_t) xdr_InsertMDDParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcinsertmdd_1_svc;
+ break;
+
+ case RPCGETCOLLBYNAME:
+ _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
+ _xdr_result = (xdrproc_t) xdr_GetCollRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetcollbyname_1_svc;
+ break;
+
+ case RPCGETCOLLBYOID:
+ _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
+ _xdr_result = (xdrproc_t) xdr_GetCollRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetcollbyoid_1_svc;
+ break;
+
+ case RPCGETCOLLOIDSBYNAME:
+ _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
+ _xdr_result = (xdrproc_t) xdr_GetCollOIdsRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetcolloidsbyname_1_svc;
+ break;
+
+ case RPCGETCOLLOIDSBYOID:
+ _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
+ _xdr_result = (xdrproc_t) xdr_GetCollOIdsRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetcolloidsbyoid_1_svc;
+ break;
+
+ case RPCINSERTCOLL:
+ _xdr_argument = (xdrproc_t) xdr_InsertCollParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcinsertcoll_1_svc;
+ break;
+
+ case RPCDELETECOLLBYNAME:
+ _xdr_argument = (xdrproc_t) xdr_NameSpecParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcdeletecollbyname_1_svc;
+ break;
+
+ case RPCDELETEOBJBYOID:
+ _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcdeleteobjbyoid_1_svc;
+ break;
+
+ case RPCREMOVEOBJFROMCOLL:
+ _xdr_argument = (xdrproc_t) xdr_RemoveObjFromCollParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcremoveobjfromcoll_1_svc;
+ break;
+
+ case RPCGETNEWOID:
+ _xdr_argument = (xdrproc_t) xdr_NewOIdParams;
+ _xdr_result = (xdrproc_t) xdr_OIdRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetnewoid_1_svc;
+ break;
+
+ case RPCGETOBJECTTYPE:
+ _xdr_argument = (xdrproc_t) xdr_OIdSpecParams;
+ _xdr_result = (xdrproc_t) xdr_ObjectTypeRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetobjecttype_1_svc;
+ break;
+
+ case RPCGETTYPESTRUCTURE:
+ _xdr_argument = (xdrproc_t) xdr_GetTypeStructureParams;
+ _xdr_result = (xdrproc_t) xdr_GetTypeStructureRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgettypestructure_1_svc;
+ break;
+
+ case RPCGETNEXTELEMENT:
+ _xdr_argument = (xdrproc_t) xdr_u_long;
+ _xdr_result = (xdrproc_t) xdr_GetElementRes;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetnextelement_1_svc;
+ break;
+
+ case RPCGETSERVERENDIAN:
+ _xdr_argument = (xdrproc_t) xdr_int;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (char *(*)(char *, struct svc_req *)) rpcgetserverendian_1_svc;
+ break;
+
+ case RPCSETSERVERTRANSFER:
+ _xdr_argument = (xdrproc_t) xdr_SetServerTransferParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcsetservertransfer_1_svc;
+ break;
+
+ case RPCGETERRORINFO:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_GetExtendedErrorInfo;
+ local = (char *(*)(char *, struct svc_req *)) rpcgeterrorinfo_1_svc;
+ break;
+
+ case RPCSETSERVERSTORAGE:
+ _xdr_argument = (xdrproc_t) xdr_SetServerTransferParams;
+ _xdr_result = (xdrproc_t) xdr_u_short;
+ local = (char *(*)(char *, struct svc_req *)) rpcsetserverstorage_1_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+//patched by awk 5
+return retvalTxt;
+//end patched by awk 5
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+//patched by awk 5
+return retvalTxt;
+//end patched by awk 5
+ }
+//patched by awk 2
+ try {
+//end patched by awk 2
+ result = (*local)((char *)&argument, rqstp);
+//patched by awk 2.1
+ }
+ catch (r_Error& e)
+ {
+ retvalTxt = e.serialiseError();
+ u_short temp = 42;
+ result = secureResultBufferForRPC;
+ memcpy(result, (char*)&temp, sizeof(u_short));
+ }
+ catch (std::bad_alloc)
+ {
+ bMemFailed = true;
+ ServerComm* sc = ServerComm::actual_servercomm;
+ r_Ememory_allocation e;
+ retvalTxt = e.serialiseError();
+ u_short temp = 42;
+ result = secureResultBufferForRPC;
+ memcpy(result, (char*)&temp, sizeof(u_short));
+
+ }
+//end patched by awk 2.1
+ if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+//patched by awk 5
+return retvalTxt;
+//end patched by awk 5
+}
diff --git a/clientcomm/rpcif_xdr.c b/clientcomm/rpcif_xdr.c
new file mode 100644
index 0000000..1dbb45e
--- /dev/null
+++ b/clientcomm/rpcif_xdr.c
@@ -0,0 +1,847 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "rpcif.h"
+
+bool_t
+xdr_confarray (XDR *xdrs, confarray *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_bytes (xdrs, (char **)&objp->confarray_val, (u_int *) &objp->confarray_len, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_RPCMarray (XDR *xdrs, RPCMarray *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_long (xdrs, &objp->cellTypeLength))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->currentFormat))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->storageFormat))
+ return FALSE;
+
+ } else {
+ IXDR_PUT_U_LONG(buf, objp->cellTypeLength);
+ IXDR_PUT_U_SHORT(buf, objp->currentFormat);
+ IXDR_PUT_U_SHORT(buf, objp->storageFormat);
+ }
+ if (!xdr_confarray (xdrs, &objp->data))
+ return FALSE;
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_long (xdrs, &objp->cellTypeLength))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->currentFormat))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->storageFormat))
+ return FALSE;
+
+ } else {
+ objp->cellTypeLength = IXDR_GET_U_LONG(buf);
+ objp->currentFormat = IXDR_GET_U_SHORT(buf);
+ objp->storageFormat = IXDR_GET_U_SHORT(buf);
+ }
+ if (!xdr_confarray (xdrs, &objp->data))
+ return FALSE;
+ return TRUE;
+ }
+
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->cellTypeLength))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->currentFormat))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->storageFormat))
+ return FALSE;
+ if (!xdr_confarray (xdrs, &objp->data))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_RPCClientEntry (XDR *xdrs, RPCClientEntry *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ if (!xdr_u_long (xdrs, &objp->clientId))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->clientIdText, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->userName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->baseName, ~0))
+ return FALSE;
+ buf = XDR_INLINE (xdrs, 9 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_long (xdrs, &objp->creationTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lastActionTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferColl))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->assembleMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transTiles))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->tileIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
+ return FALSE;
+ } else {
+ IXDR_PUT_U_LONG(buf, objp->creationTime);
+ IXDR_PUT_U_LONG(buf, objp->lastActionTime);
+ IXDR_PUT_U_LONG(buf, objp->transferColl);
+ IXDR_PUT_U_LONG(buf, objp->transferIter);
+ IXDR_PUT_U_LONG(buf, objp->assembleMDD);
+ IXDR_PUT_U_LONG(buf, objp->transferMDD);
+ IXDR_PUT_U_LONG(buf, objp->transTiles);
+ IXDR_PUT_U_LONG(buf, objp->tileIter);
+ IXDR_PUT_U_LONG(buf, objp->bytesToTransfer);
+ }
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ if (!xdr_u_long (xdrs, &objp->clientId))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->clientIdText, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->userName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->baseName, ~0))
+ return FALSE;
+ buf = XDR_INLINE (xdrs, 9 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_long (xdrs, &objp->creationTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lastActionTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferColl))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->assembleMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transTiles))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->tileIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
+ return FALSE;
+ } else {
+ objp->creationTime = IXDR_GET_U_LONG(buf);
+ objp->lastActionTime = IXDR_GET_U_LONG(buf);
+ objp->transferColl = IXDR_GET_U_LONG(buf);
+ objp->transferIter = IXDR_GET_U_LONG(buf);
+ objp->assembleMDD = IXDR_GET_U_LONG(buf);
+ objp->transferMDD = IXDR_GET_U_LONG(buf);
+ objp->transTiles = IXDR_GET_U_LONG(buf);
+ objp->tileIter = IXDR_GET_U_LONG(buf);
+ objp->bytesToTransfer = IXDR_GET_U_LONG(buf);
+ }
+ return TRUE;
+ }
+
+ if (!xdr_u_long (xdrs, &objp->clientId))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->clientIdText, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->userName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->baseName, ~0))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->creationTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lastActionTime))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferColl))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->assembleMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transferMDD))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transTiles))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->tileIter))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->bytesToTransfer))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_RPCOIdEntry (XDR *xdrs, RPCOIdEntry *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_OpenDBParams (XDR *xdrs, OpenDBParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_string (xdrs, &objp->dbName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->userName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->capability, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_OpenDBRes (XDR *xdrs, OpenDBRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_BeginTAParams (XDR *xdrs, BeginTAParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->readOnly))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->capability, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ExecuteQueryParams (XDR *xdrs, ExecuteQueryParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->query, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ExecuteQueryRes (XDR *xdrs, ExecuteQueryRes *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+
+ } else {
+ IXDR_PUT_U_SHORT(buf, objp->status);
+ IXDR_PUT_U_LONG(buf, objp->errorNo);
+ IXDR_PUT_U_LONG(buf, objp->lineNo);
+ IXDR_PUT_U_LONG(buf, objp->columnNo);
+ }
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+
+ } else {
+ objp->status = IXDR_GET_U_SHORT(buf);
+ objp->errorNo = IXDR_GET_U_LONG(buf);
+ objp->lineNo = IXDR_GET_U_LONG(buf);
+ objp->columnNo = IXDR_GET_U_LONG(buf);
+ }
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ return TRUE;
+ }
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ExecuteUpdateRes (XDR *xdrs, ExecuteUpdateRes *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+
+ } else {
+ IXDR_PUT_U_SHORT(buf, objp->status);
+ IXDR_PUT_U_LONG(buf, objp->errorNo);
+ IXDR_PUT_U_LONG(buf, objp->lineNo);
+ IXDR_PUT_U_LONG(buf, objp->columnNo);
+ }
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+
+ } else {
+ objp->status = IXDR_GET_U_SHORT(buf);
+ objp->errorNo = IXDR_GET_U_LONG(buf);
+ objp->lineNo = IXDR_GET_U_LONG(buf);
+ objp->columnNo = IXDR_GET_U_LONG(buf);
+ }
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ return TRUE;
+ }
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->errorNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->lineNo))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->columnNo))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->token, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_InsertCollParams (XDR *xdrs, InsertCollParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_NameSpecParams (XDR *xdrs, NameSpecParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->name, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_OIdSpecParams (XDR *xdrs, OIdSpecParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_RemoveObjFromCollParams (XDR *xdrs, RemoveObjFromCollParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetCollRes (XDR *xdrs, GetCollRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetCollOIdsRes (XDR *xdrs, GetCollOIdsRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_array (xdrs, (char **)&objp->oidTable.oidTable_val, (u_int *) &objp->oidTable.oidTable_len, ~0,
+ sizeof (RPCOIdEntry), (xdrproc_t) xdr_RPCOIdEntry))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetMDDRes (XDR *xdrs, GetMDDRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->currentFormat))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetTileRes (XDR *xdrs, GetTileRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_OIdRes (XDR *xdrs, OIdRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ObjectTypeRes (XDR *xdrs, ObjectTypeRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->objType))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_InsertMDDParams (XDR *xdrs, InsertMDDParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_InsertTileParams (XDR *xdrs, InsertTileParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->isPersistent))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->marray, sizeof (RPCMarray), (xdrproc_t) xdr_RPCMarray))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_EndInsertMDDParams (XDR *xdrs, EndInsertMDDParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->isPersistent))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_InsertTransMDDParams (XDR *xdrs, InsertTransMDDParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->typeLength))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_InsertPersMDDParams (XDR *xdrs, InsertPersMDDParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->collName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->domain, ~0))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->typeLength))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->oid, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_NewOIdParams (XDR *xdrs, NewOIdParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->objType))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ServerStatRes (XDR *xdrs, ServerStatRes *objp)
+{
+ register int32_t *buf;
+
+
+ if (xdrs->x_op == XDR_ENCODE) {
+ buf = XDR_INLINE (xdrs, 12 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->managementInterval))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transactionActive))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->nextClientId))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->clientNumber))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memArena))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memSmblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memOrdblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memFordblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memUordblks))
+ return FALSE;
+
+ } else {
+ IXDR_PUT_U_SHORT(buf, objp->status);
+ IXDR_PUT_U_LONG(buf, objp->inactivityTimeout);
+ IXDR_PUT_U_LONG(buf, objp->managementInterval);
+ IXDR_PUT_U_LONG(buf, objp->transactionActive);
+ IXDR_PUT_U_LONG(buf, objp->maxTransferBufferSize);
+ IXDR_PUT_U_LONG(buf, objp->nextClientId);
+ IXDR_PUT_U_LONG(buf, objp->clientNumber);
+ IXDR_PUT_U_LONG(buf, objp->memArena);
+ IXDR_PUT_U_LONG(buf, objp->memSmblks);
+ IXDR_PUT_U_LONG(buf, objp->memOrdblks);
+ IXDR_PUT_U_LONG(buf, objp->memFordblks);
+ IXDR_PUT_U_LONG(buf, objp->memUordblks);
+ }
+ if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
+ sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
+ return FALSE;
+ return TRUE;
+ } else if (xdrs->x_op == XDR_DECODE) {
+ buf = XDR_INLINE (xdrs, 12 * BYTES_PER_XDR_UNIT);
+ if (buf == NULL) {
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->managementInterval))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transactionActive))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->nextClientId))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->clientNumber))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memArena))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memSmblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memOrdblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memFordblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memUordblks))
+ return FALSE;
+
+ } else {
+ objp->status = IXDR_GET_U_SHORT(buf);
+ objp->inactivityTimeout = IXDR_GET_U_LONG(buf);
+ objp->managementInterval = IXDR_GET_U_LONG(buf);
+ objp->transactionActive = IXDR_GET_U_LONG(buf);
+ objp->maxTransferBufferSize = IXDR_GET_U_LONG(buf);
+ objp->nextClientId = IXDR_GET_U_LONG(buf);
+ objp->clientNumber = IXDR_GET_U_LONG(buf);
+ objp->memArena = IXDR_GET_U_LONG(buf);
+ objp->memSmblks = IXDR_GET_U_LONG(buf);
+ objp->memOrdblks = IXDR_GET_U_LONG(buf);
+ objp->memFordblks = IXDR_GET_U_LONG(buf);
+ objp->memUordblks = IXDR_GET_U_LONG(buf);
+ }
+ if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
+ sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
+ return FALSE;
+ return TRUE;
+ }
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->inactivityTimeout))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->managementInterval))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->transactionActive))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->maxTransferBufferSize))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->nextClientId))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->clientNumber))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memArena))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memSmblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memOrdblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memFordblks))
+ return FALSE;
+ if (!xdr_u_long (xdrs, &objp->memUordblks))
+ return FALSE;
+ if (!xdr_array (xdrs, (char **)&objp->clientTable.clientTable_val, (u_int *) &objp->clientTable.clientTable_len, ~0,
+ sizeof (RPCClientEntry), (xdrproc_t) xdr_RPCClientEntry))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_ServerVersionRes (XDR *xdrs, ServerVersionRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->serverVersionNo))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->rpcInterfaceVersionNo))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetTypeStructureParams (XDR *xdrs, GetTypeStructureParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeName, ~0))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->typeType))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetTypeStructureRes (XDR *xdrs, GetTypeStructureRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->typeStructure, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetElementRes (XDR *xdrs, GetElementRes *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_confarray (xdrs, &objp->data))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_SetServerTransferParams (XDR *xdrs, SetServerTransferParams *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_long (xdrs, &objp->clientID))
+ return FALSE;
+ if (!xdr_u_short (xdrs, &objp->format))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->formatParams, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_GetExtendedErrorInfo (XDR *xdrs, GetExtendedErrorInfo *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_short (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_string (xdrs, &objp->errorText, ~0))
+ return FALSE;
+ return TRUE;
+}
--
1.7.7.1
From 140caffef17f6e5dbd722eb68e8d7dd96cd7a9ba Mon Sep 17 00:00:00 2001
From: Charlie Sharpsteen <[email protected]>
Date: Wed, 9 Nov 2011 22:02:12 -0800
Subject: [PATCH 4/4] Protect signals not present on OS X
On OS X, signal.h does not define the following values:
- SIGSTKFLT
- SIGCLD
- SIGPOLL
- SIGPWR
These are now protected by the preprocessor.
---
applications/rasql/rasql_signal.cc | 20 +++++++++++++++-----
1 files changed, 15 insertions(+), 5 deletions(-)
diff --git a/applications/rasql/rasql_signal.cc b/applications/rasql/rasql_signal.cc
index b36f0cb..b7b68f4 100644
--- a/applications/rasql/rasql_signal.cc
+++ b/applications/rasql/rasql_signal.cc
@@ -117,14 +117,13 @@ signalHandler(int sig)
break;
#ifndef SOLARIS
#ifndef DECALPHA
+#ifndef __APPLE__
case SIGSTKFLT:
cout << "Stack fault.";
break;
#endif
#endif
- case SIGCLD:
- cout << "SIGCHLD (System V) or child status has changed (POSIX).";
- break;
+#endif
case SIGCONT:
cout << "Continue (POSIX).";
break;
@@ -158,12 +157,17 @@ signalHandler(int sig)
case SIGWINCH:
cout << "Window size change (4.3 BSD, Sun). Continuing operation.";
break;
+#ifndef __APPLE__
+ case SIGCLD:
+ cout << "SIGCHLD (System V) or child status has changed (POSIX).";
+ break;
case SIGPOLL:
cout << "Pollable event occurred (System V) or I/O now possible (4.2 BSD).";
break;
case SIGPWR:
cout << "Power failure restart (System V).";
break;
+#endif
case SIGSYS:
cout << "Bad system call.";
break;
@@ -213,10 +217,11 @@ installSignalHandlers()
signal(SIGTERM, signalHandler);
#ifndef SOLARIS
#ifndef DECALPHA
+#ifndef __APPLE__
signal(SIGSTKFLT, signalHandler);
#endif
#endif
- signal(SIGCLD, signalHandler);
+#endif
signal(SIGCHLD, signalHandler);
signal(SIGCONT, signalHandler);
signal(SIGSTOP, signalHandler);
@@ -229,15 +234,20 @@ installSignalHandlers()
signal(SIGVTALRM, signalHandler);
signal(SIGPROF, signalHandler);
signal(SIGWINCH, signalHandler);
+#ifndef __APPLE__
+ signal(SIGCLD, signalHandler);
signal(SIGPOLL, signalHandler);
- signal(SIGIO, signalHandler);
signal(SIGPWR, signalHandler);
+#endif
+ signal(SIGIO, signalHandler);
signal(SIGSYS, signalHandler);
#if !defined SOLARIS
#if !defined DECALPHA
+#ifndef __APPLE__
signal(SIGUNUSED, signalHandler);
#endif
#endif
+#endif
LEAVE( "installSignalHandlers" );
}
--
1.7.7.1
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment