api.cc

/* 
   EyeDB Object Database Management System
   Copyright (C) 1994-2008 SYSRA
   
   EyeDB is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   EyeDB is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA 
*/

/*
   Author: Eric Viara <viara@sysra.com>
*/


#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>
#include <errno.h>

#include "base_p.h"
#include "eyedb/internals/ObjectHeader.h"
#include "eyedb/Exception.h"
#include "eyedb/TransactionParams.h"
#include "api_lib.h"

#include "kernel.h"
#include "misc.h"
#include "SchemaInfo.h"
#include "Argument_code.h"
#include "code.h"
#include "eyedb/internals/kern_const.h"

#define IDB_MAXARGS 16

namespace eyedbsm {
  extern unsigned int import_xid;
}

namespace eyedb {

  extern void setBackendInterrupt(Bool);

#define status_copy(D, S) \
{ \
   (D).err = (S).err; \
   if ((S).err) strcpy((D).err_msg, (S).err_msg); \
}

#define start_rpc()

  static RPCStatusRec status_r;

#define SERVER_CRASH_MSG \
 "EyeDB server has probably crashed. " \
 "Contact your system administrator.\n"

#undef SERVER_CRASH_MSG

#define SERVER_CRASH_MSG \
 "the EyeDB server has probably crashed or timed out."

  /*      fprintf(stderr, \
          "eyedb fatal error: server failure [" #RPC ". code #%d].\n" \
          SERVER_CRASH_MSG, r); \

          return rpcStatusMake(IDB_SERVER_FAILURE, \
          "[" #RPC ", code #%d].\n" SERVER_CRASH_MSG, r); \

  */

#define RPC_RPCMAKE(CH, RPC, UA) \
{ \
  int r; \
  r = rpc_rpcMake(CH, 0, RPC, UA); \
 \
  if (r) \
    { \
      if (errno) perror("server"); \
      return rpcStatusMake(IDB_SERVER_FAILURE, SERVER_CRASH_MSG); \
    } \
}

#define STATUS_RETURN(S) \
return (((S).err == IDB_SUCCESS) ? RPCSuccess : &(S))

#define RDBHID_GET(DBH) \
((DBH)->ldbctx.local ? (DBH)->ldbctx.rdbhid : (DBH)->u.rdbhid)

#define CHECK_DBH(DBH, OP) \
if (!(DBH)) return rpcStatusMake(IDB_ERROR, "operation " OP ": database must be opened")

#define DBH_IS_LOCAL(DBH) ((DBH)->ldbctx.local)

const int CONN_COUNT = 3; // 20/03/06: can be more for multi-threading

RPCStatus
connOpen(const char *hostname, const char *portname,
         ConnHandle **pch, int flags, std::string &errmsg)
{
  *pch = rpc_new(ConnHandle);

  if (!rpc_connOpen(getRpcClient(), hostname, portname,
                    &((*pch)->ch), RPC_PROTOCOL_MAGIC, CONN_COUNT, 0,
                    errmsg))
    return RPCSuccess;
  else {
    free(*pch);
    *pch = 0;
    return rpcStatusMake(IDB_CONNECTION_FAILURE,
                         "portname '%s'", portname);
  }
}

RPCStatus
connClose(ConnHandle *ch)
{
  if (ch->ch && !rpc_connClose(ch->ch))
    {
      free(ch);
      return RPCSuccess;
    }
  else
    return rpcStatusMake(IDB_CONNECTION_FAILURE, "cannot close connection");
}

/* remote procedure calls */
RPCStatus
dbOpen(ConnHandle *ch, const char *dbmdb,
           const char *userauth, const char *passwdauth,
           const char *dbname, int dbid, int flags, int oh_maph,
           unsigned int oh_mapwide, int *puid, void *db,
           char **rname, int *rdbid, unsigned int *pversion,
           DbHandle **dbh)
{
  ClientArg ua[IDB_MAXARGS], *pua = ua;
      
  pua++->a_string = (char *)dbmdb;
  pua++->a_string = (char *)userauth;
  pua++->a_string = (char *)passwdauth;
  pua++->a_string = (char *)dbname;
  pua++->a_int    = dbid;
  /* LOCAL_REMOTE */
  pua++->a_int    = flags;
  pua++->a_int    = oh_maph;
  pua++->a_int    = oh_mapwide;
  
  if (flags & _DBOpenLocal)
    {
      RPC_RPCMAKE(ch->ch, DBOPENLOCAL_RPC, ua);

      status_copy(status_r, ua[14].a_status);

      if (status_r.err == IDB_SUCCESS)
        {
          DbHandle *tdbh;
          RPCStatus status;
          rpcDB_LocalDBContext *ldbctx = &ua[12].a_ldbctx;

          /*      se_import_xid = ldbctx->rdbhid;*/
          eyedbsm::import_xid = ldbctx->xid;

          /*printf("se_import_xid = %d (%s)\n", se_import_xid, dbname);*/

          status = IDB_dbOpen(ch, dbmdb, userauth, passwdauth, dbname, dbid,
                              flags & ~_DBOpenLocal, oh_maph,
                              oh_mapwide, 0, puid, db, rname,
                              rdbid, pversion, &tdbh);

          if (status == RPCSuccess)
            {
              *dbh = rpc_new(DbHandle);
              (*dbh)->ch = (ConnHandle *)ch;
#ifndef LOCKMTX
              if ((ldbctx->semid[0] = sem_openSX(ldbctx->semkey[0]))<0 || 
                  (ldbctx->semid[1] = sem_openSX(ldbctx->semkey[1]))<0)
                return rpcStatusMake(IDB_ERROR, "");
#endif

              (*dbh)->ldbctx = *ldbctx;
              (*dbh)->u.dbh = tdbh;
              (*dbh)->flags = flags & ~_DBOpenLocal;
              (*dbh)->sch_oid = ua[13].a_oid;
            }
          return status;
        }
      STATUS_RETURN(status_r);
    }
  else
    {
      RPC_RPCMAKE(ch->ch, DBOPEN_RPC, ua);

      status_copy(status_r, ua[14].a_status);

      if (status_r.err == IDB_SUCCESS)
        {
          *dbh = rpc_new(DbHandle);
          (*dbh)->u.rdbhid = ua[11].a_int;
          (*dbh)->ch = (ConnHandle *)ch;
          (*dbh)->flags = flags & ~_DBOpenLocal;
          (*dbh)->sch_oid = ua[13].a_oid;       
          *puid = ua[8].a_int;
          *rname = ua[9].a_string;
          *rdbid = ua[10].a_int;
          *pversion = ua[12].a_int;
        }
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbClose(const DbHandle *dbh)
{
  ClientArg ua[IDB_MAXARGS], *pua = ua;

  CHECK_DBH(dbh, "dbClose");

  if (DBH_IS_LOCAL(dbh))
    {
      pua++->a_int = dbh->ldbctx.rdbhid;
      IDB_dbCloseLocal((DbHandle *)dbh->u.dbh);
    }
  else
    pua++->a_int = dbh->u.rdbhid;

  RPC_RPCMAKE(dbh->ch->ch, DBCLOSE_RPC, ua);

  status_copy(status_r, ua[1].a_status);
  
  STATUS_RETURN(status_r);
}

RPCStatus
backendInterrupt(ConnHandle *ch, int info)
{
  ClientArg ua[IDB_MAXARGS], *pua = ua;
  int r;

  setBackendInterrupt(True);

  pua++->a_int = info;

  r = rpc_rpcMake(ch->ch, 1, BACKEND_INTERRUPT_RPC, ua);

  status_copy(status_r, ua[1].a_status);
  
  STATUS_RETURN(status_r);
}

RPCStatus
getServerOutOfBandData(ConnHandle *ch, int * type, Data * data,
                           unsigned int *size)
{
  if (!ch) 
    return IDB_getServerOutOfBandData(0, type, data, size, 0);
  else {
    ClientArg ua[IDB_MAXARGS], *pua = ua;
    int r, offset;

    pua++->a_int = *type;
    pua->a_data.data = 0; /* force RPC to allocate buffer */
    pua++->a_data.size   = 0;
  
    r = rpc_rpcMake(ch->ch, 2, GET_SERVER_OUTOFBAND_DATA_RPC, ua);
    
    *type = ua[0].a_int;
    
    if (!r) {
      *data = (unsigned char *)ua[1].a_data.data;
      *size = ua[1].a_data.size;
    }
    else {
      *data = 0;
      *size = 0;
    }
    
    status_copy(status_r, ua[2].a_status);
    STATUS_RETURN(status_r);
  }
}

RPCStatus
transactionBegin(DbHandle *dbh, 
                     const TransactionParams *params,
                     TransactionId *tid)
{
  CHECK_DBH(dbh, "transactionBegin");

  if (DBH_IS_LOCAL(dbh))
    {
      *tid = 0;
      return IDB_transactionBegin((DbHandle *)dbh->u.dbh, params, True);
    }
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = params->trsmode;
      pua++->a_int = params->lockmode;
      pua++->a_int = params->recovmode;
      pua++->a_int = params->magorder;
      pua++->a_int = params->ratioalrt;
      pua++->a_int = params->wait_timeout; 

      RPC_RPCMAKE(dbh->ch->ch, TRANSACTION_BEGIN_RPC, ua);
      
      status_copy(status_r, ua[8].a_status);
      
      *tid = ua[7].a_int;

      STATUS_RETURN(status_r);
    }
}

RPCStatus
transactionCommit(DbHandle *dbh, TransactionId tid)
{
  CHECK_DBH(dbh, "transactionCommit");

  if (DBH_IS_LOCAL(dbh))
    return IDB_transactionCommit((DbHandle *)dbh->u.dbh, True);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = 0;

      RPC_RPCMAKE(dbh->ch->ch, TRANSACTION_COMMIT_RPC, ua);

      status_copy(status_r, ua[2].a_status);
      
      STATUS_RETURN(status_r);
    }
}

RPCStatus
transactionAbort(DbHandle *dbh, TransactionId tid)
{
  CHECK_DBH(dbh, "transactionAbort");

  if (DBH_IS_LOCAL(dbh))
    return IDB_transactionAbort((DbHandle *)dbh->u.dbh, True);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = 0;
      
      RPC_RPCMAKE(dbh->ch->ch, TRANSACTION_ABORT_RPC, ua);
      
      status_copy(status_r, ua[2].a_status);
      
      STATUS_RETURN(status_r);
    }
}

RPCStatus
transactionParamsSet(DbHandle *dbh, const TransactionParams *params)
{
  CHECK_DBH(dbh, "transactionParamsSet");

  if (DBH_IS_LOCAL(dbh))
    return IDB_transactionParamsSet((DbHandle *)dbh->u.dbh, params);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = params->trsmode;
      pua++->a_int = params->lockmode;
      pua++->a_int = params->recovmode;
      pua++->a_int = params->magorder;
      pua++->a_int = params->ratioalrt;
      pua++->a_int = params->wait_timeout; 

      RPC_RPCMAKE(dbh->ch->ch, TRANSACTION_PARAMS_SET_RPC, ua);
      
      status_copy(status_r, ua[7].a_status);
      
      STATUS_RETURN(status_r);
    }
}

RPCStatus
transactionParamsGet(DbHandle *dbh, TransactionParams *params)
{
  CHECK_DBH(dbh, "transactionParamsGet");

  if (DBH_IS_LOCAL(dbh))
    return IDB_transactionParamsGet((DbHandle *)dbh->u.dbh, params);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_int = RDBHID_GET(dbh);

      RPC_RPCMAKE(dbh->ch->ch, TRANSACTION_PARAMS_GET_RPC, ua);

      params->trsmode = (TransactionMode)ua[1].a_int;
      params->lockmode = (TransactionLockMode)ua[2].a_int;
      params->recovmode = (RecoveryMode)ua[3].a_int;
      params->magorder = ua[4].a_int;
      params->ratioalrt = ua[5].a_int;
      params->wait_timeout = ua[6].a_int;
      
      status_copy(status_r, ua[7].a_status);
      
      STATUS_RETURN(status_r);
    }
}

extern Data code_dbdescription(const DbCreateDescription *, int *);
extern Data code_oids(const eyedbsm::Oid *, unsigned int, int *);
extern Data code_datafiles(void *datafiles, unsigned int datafile_cnt,
                               int *);
extern void decode_locarr(Data, void *locarr);
extern void decode_atom_array(rpc_ClientData *, void *, int);
extern void decode_value(void *data, void *value);
extern void decode_datinfo(Data, void *info);
extern void decode_index_stats(Data, void *stats);
extern void decode_index_impl(Data, void *impl);

RPCStatus
dbmCreate(ConnHandle *ch, const char *dbmdb, const char *passwdauth,
              const DbCreateDescription *dbdesc)
{
  if (!ch || !ch->ch)
    return IDB_dbmCreate(ch, dbmdb, passwdauth, dbdesc);
  else
    {
      Data dbdesc_data;
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)passwdauth;
      dbdesc_data = code_dbdescription(dbdesc, &pua->a_data.size);
      pua->a_data.data = dbdesc_data;

      RPC_RPCMAKE(ch->ch, DBMCREATE_RPC, ua);

      free(dbdesc_data);
      status_copy(status_r, ua[3].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbmUpdate(ConnHandle *ch, const char *dbmdb,
              const char *username, const char *passwd)
{
  if (!ch || !ch->ch)
    return IDB_dbmUpdate(ch, dbmdb, username, passwd);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)username;
      pua++->a_string = (char *)passwd;

      RPC_RPCMAKE(ch->ch, DBMUPDATE_RPC, ua);

      status_copy(status_r, ua[3].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbCreate(ConnHandle *ch, const char *dbmdb,
             const char *userauth, const char *passwdauth,
             const char *dbname, const DbCreateDescription *dbdesc)
{
  if (!ch || !ch->ch)
    return IDB_dbCreate(ch, dbmdb, userauth, passwdauth, dbname, dbdesc);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      Data dbdesc_data;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      dbdesc_data = code_dbdescription(dbdesc, &pua->a_data.size);
      pua->a_data.data = dbdesc_data;

      RPC_RPCMAKE(ch->ch, DBCREATE_RPC, ua);

      free(dbdesc_data);
      status_copy(status_r, ua[5].a_status);
      
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbDelete(ConnHandle *ch, const char *dbmdb,
             const char *userauth, const char *passwdauth,
             const char *dbname)
{
  if (!ch || !ch->ch)
    return IDB_dbDelete(ch, dbmdb, userauth, passwdauth, dbname);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      
      RPC_RPCMAKE(ch->ch, DBDELETE_RPC, ua);

      status_copy(status_r, ua[4].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbInfo(ConnHandle *ch, const char *dbmdb,
           const char *userauth, const char *passwdauth, const char *dbname,
           int *rdbid, DbCreateDescription *pdbdesc)
{
  if (!ch || !ch->ch)
    return IDB_dbInfo(ch, dbmdb, userauth, passwdauth, dbname,
                      rdbid, pdbdesc);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      pua++;
      pua++->a_data.data = 0;
      
      RPC_RPCMAKE(ch->ch, DBINFO_RPC, ua);

      if (rdbid)
        *rdbid = ua[4].a_int;
      status_copy(status_r, ua[6].a_status);

      if (!status_r.err)
        decode_dbdescription((unsigned char *)ua[5].a_data.data, 0, pdbdesc);
      
      free(ua[5].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbMove(ConnHandle *ch, const char *dbmdb,
           const char *userauth, const char *passwdauth,
           const char *dbname, const DbCreateDescription *dbdesc)
{
  if (!ch || !ch->ch)
    return IDB_dbMove(ch, dbmdb, userauth, passwdauth, dbname, dbdesc);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      Data dbdesc_data;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      dbdesc_data = code_dbdescription(dbdesc, &pua->a_data.size);
      pua->a_data.data = dbdesc_data;

      RPC_RPCMAKE(ch->ch, DBMOVE_RPC, ua);
      free(dbdesc_data);

      status_copy(status_r, ua[5].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbCopy(ConnHandle *ch, const char *dbmdb,
           const char *userauth, const char *passwdauth, const char *dbname,
           const char *newname, Bool newdbid,
           const DbCreateDescription *dbdesc)
{
  if (!ch || !ch->ch)
    return IDB_dbCopy(ch, dbmdb, userauth, passwdauth, dbname,
                      newname, newdbid, dbdesc);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      Data dbdesc_data;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      pua++->a_string = (char *)newname;
      pua++->a_int    = (int)newdbid;
      dbdesc_data = code_dbdescription(dbdesc, &pua->a_data.size);
      pua->a_data.data = dbdesc_data;

      RPC_RPCMAKE(ch->ch, DBCOPY_RPC, ua);

      free(dbdesc_data);

      status_copy(status_r, ua[7].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dbRename(ConnHandle *ch, const char *dbmdb,
             const char *userauth, const char *passwdauth,
             const char *dbname, const char *newname)
{
  if (!ch || !ch->ch)
    return IDB_dbRename(ch, dbmdb, userauth, passwdauth,
                        dbname, newname);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      pua++->a_string = (char *)newname;

      RPC_RPCMAKE(ch->ch, DBRENAME_RPC, ua);

      status_copy(status_r, ua[5].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
userAdd(ConnHandle *ch, const char *dbmdb,
            const char *userauth, const char *passwdauth,
            const char *user, const char *passwd, int user_type)
{
  if (!ch || !ch->ch)
    return IDB_userAdd(ch, dbmdb, userauth, passwdauth,
                       user, passwd, user_type);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)user;
      pua++->a_string = (char *)(passwd ? passwd : "");
      pua++->a_int    = user_type;

      RPC_RPCMAKE(ch->ch, USER_ADD_RPC, ua);

      status_copy(status_r, ua[6].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
userDelete(ConnHandle *ch, const char *dbmdb,
               const char *userauth, const char *passwdauth,
               const char *user)
{
  if (!ch || !ch->ch)
    return IDB_userDelete(ch, dbmdb, userauth, passwdauth, user);
  else 
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)user;

      RPC_RPCMAKE(ch->ch, USER_DELETE_RPC, ua);

      status_copy(status_r, ua[4].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
userPasswdSet(ConnHandle *ch, const char *dbmdb,
                  const char *userauth, const char *passwdauth,
                  const char *user, const char *passwd)
{
  if (!ch || !ch->ch)
    return IDB_userPasswdSet(ch, dbmdb, userauth, passwdauth,
                             user, passwd);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)user;
      pua++->a_string = (char *)passwd;

      RPC_RPCMAKE(ch->ch, USER_PASSWD_SET_RPC, ua);

      status_copy(status_r, ua[5].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
passwdSet(ConnHandle *ch, const char *dbmdb,
              const char *user, const char *passwd,
              const char *newpasswd)
{
  if (!ch || !ch->ch)
    return IDB_passwdSet(ch, dbmdb, user, passwd, newpasswd);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)user;
      pua++->a_string = (char *)passwd;
      pua++->a_string = (char *)newpasswd;

      RPC_RPCMAKE(ch->ch, PASSWD_SET_RPC, ua);

      status_copy(status_r, ua[4].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
defaultDBAccessSet(ConnHandle *ch, const char *dbmdb,
                       const char *userauth, const char *passwdauth,
                       const char *dbname, int mode)
{
  if (!ch || !ch->ch)
    return IDB_defaultDBAccessSet(ch, dbmdb, userauth, passwdauth,
                                  dbname, mode);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      pua++->a_int    = mode;

      RPC_RPCMAKE(ch->ch, DEFAULT_DBACCESS_SET_RPC, ua);

      status_copy(status_r, ua[5].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
userDBAccessSet(ConnHandle *ch, const char *dbmdb,
                    const char *userauth, const char *passwdauth,
                    const char *dbname, const char *user, int mode)
{
  if (!ch || !ch->ch)
    return IDB_userDBAccessSet(ch, dbmdb, userauth, passwdauth,
                               dbname, user, mode);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)dbname;
      pua++->a_string = (char *)user;
      pua++->a_int    = mode;

      RPC_RPCMAKE(ch->ch, USER_DBACCESS_SET_RPC, ua);

      status_copy(status_r, ua[6].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
userSysAccessSet(ConnHandle *ch, const char *dbmdb,
                     const char *userauth, const char *passwdauth,
                     const char *user, int mode)
{
  if (!ch || !ch->ch)
    return IDB_userSysAccessSet(ch, dbmdb, userauth, passwdauth, user, mode);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_string = (char *)dbmdb;
      pua++->a_string = (char *)userauth;
      pua++->a_string = (char *)passwdauth;
      pua++->a_string = (char *)user;
      pua++->a_int    = mode;

      RPC_RPCMAKE(ch->ch, USER_SYSACCESS_SET_RPC, ua);

      status_copy(status_r, ua[5].a_status);
  
      STATUS_RETURN(status_r);
    }
}

/* typed object */
RPCStatus
objectCreate(DbHandle *dbh, short dspid, const Data idr, eyedbsm::Oid *oid)
{
  start_rpc();

  CHECK_DBH(dbh, "objectCreate");

  if (DBH_IS_LOCAL(dbh))
    {
      Data inv_data;
      RPCStatus rpc_status = IDB_objectCreate((DbHandle *)dbh->u.dbh, dspid, idr,
                                              oid, 0, &inv_data, 0);
      if (!rpc_status)
        object_epilogue(dbh->db, oid, inv_data, True);
      return rpc_status;
    }
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      ObjectHeader hdr;
      Offset offset = 0;

      if (!object_header_decode(idr, &offset, &hdr))
        return rpcStatusMake(IDB_INVALID_OBJECT_HEADER,
                                 "objectCreate: invalid object_header");

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      pua->a_data.data = (const Data)idr;
      pua++->a_data.size = hdr.size;      
      pua++->a_oid    = *oid;
      pua->a_data.data = 0; /* inv_data */
      pua++->a_data.size = 0;

      RPC_RPCMAKE(dbh->ch->ch, OBJECT_CREATE_RPC, ua);

      *oid = ua[3].a_oid;

      status_copy(status_r, ua[5].a_status);

      if (!status_r.err)
        object_epilogue(dbh->db, oid, (unsigned char *)ua[4].a_data.data, True);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectDelete(DbHandle *dbh, const eyedbsm::Oid *oid, unsigned int flags)
{
  CHECK_DBH(dbh, "objectDelete");

  if (DBH_IS_LOCAL(dbh))
    {
      Data inv_data;
      RPCStatus rpc_status = IDB_objectDelete((DbHandle *)dbh->u.dbh, oid,
                                              flags, &inv_data, 0);
      if (!rpc_status)
        object_epilogue(dbh->db, oid, inv_data, False);
      return rpc_status;
    }
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;
      pua++->a_int = flags;
      pua->a_data.data = 0; /* inv_data */
      pua++->a_data.size = 0;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_DELETE_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      
      if (!status_r.err)
        object_epilogue(dbh->db, oid, (unsigned char *)ua[3].a_data.data, False);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectRead(DbHandle *dbh, Data idr, Data *pidr,
               short *pdspid, const eyedbsm::Oid *oid, ObjectHeader *phdr,
               LockMode lockmode, void **pcl)
{
  CHECK_DBH(dbh, "objectRead");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectReadLocal((DbHandle *)dbh->u.dbh, idr, pidr, pdspid, oid, phdr, lockmode, pcl);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      ObjectHeader hdr;
      char buf[IDB_OBJ_HEAD_SIZE];

      start_rpc();

      if (idr)
        {
          object_header_decode_head(idr, &hdr);
          memcpy(buf, idr, IDB_OBJ_HEAD_SIZE);
        }
      else
        {
          memset(buf, 0, IDB_OBJ_HEAD_SIZE);
          hdr.size = 0;
        }

      pua++->a_int = RDBHID_GET(dbh);
      pua->a_data.data = buf;
      pua++->a_data.size = IDB_OBJ_HEAD_SIZE;
      pua++; /* dspid */
      pua++->a_oid = *oid;
      pua++->a_int = lockmode;

      pua->a_data.data = idr;
      pua++->a_data.size = hdr.size;

      RPC_RPCMAKE(dbh->ch->ch, OBJECT_READ_RPC, ua);

      status_copy(status_r, ua[6].a_status);
      
      if (!idr && !status_r.err)
        *pidr = (unsigned char *)ua[5].a_data.data;
      if (!status_r.err && pdspid)
        *pdspid = ua[2].a_int;

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectWrite(DbHandle *dbh, const Data idr, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "objectWrite");

  if (DBH_IS_LOCAL(dbh))
    {
      Data inv_data;
      RPCStatus rpc_status = IDB_objectWrite((DbHandle *)dbh->u.dbh, idr, oid, 0,
                                             &inv_data, 0);
      if (!rpc_status)
        object_epilogue(dbh->db, oid, inv_data, False);
      return rpc_status;
    }
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      Offset offset = 0;
      ObjectHeader hdr;

      start_rpc();

      if (!object_header_decode(idr, &offset, &hdr))
        return rpcStatusMake(IDB_INVALID_OBJECT_HEADER,
                                 "objectCreate: invalid object_header");

      pua++->a_int = RDBHID_GET(dbh);

      pua->a_data.data = (const Data)idr;
      pua++->a_data.size = hdr.size;
      pua++->a_oid = *oid;
      pua->a_data.data = 0; /* inv_data */
      pua++->a_data.size = 0;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_WRITE_RPC, ua);

      status_copy(status_r, ua[4].a_status);

      if (!status_r.err)
        object_epilogue(dbh->db, oid, (unsigned char *)ua[3].a_data.data, False);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectHeaderRead(DbHandle *dbh, const eyedbsm::Oid *oid, ObjectHeader *hdr)
{
  CHECK_DBH(dbh, "objectHeaderRead");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectHeaderRead((DbHandle *)dbh->u.dbh, oid, hdr);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;

      RPC_RPCMAKE(dbh->ch->ch, OBJECT_HEADER_READ_RPC, ua);

      status_copy(status_r, ua[8].a_status);

      if (status_r.err == IDB_SUCCESS)
        {
          hdr->magic   = IDB_OBJ_HEAD_MAGIC;
          hdr->type    = ua[2].a_int;
          hdr->size    = ua[3].a_int;
          hdr->ctime   = ua[4].a_int;
          hdr->mtime   = ua[5].a_int;
          hdr->oid_cl = ua[6].a_oid;
          hdr->oid_prot = ua[7].a_oid;
          hdr->xinfo   = 0;
        }

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectSizeModify(DbHandle *dbh, unsigned int size, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "objectSizeModify");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectSizeModify((DbHandle *)dbh->u.dbh, size, oid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = size;
      pua++->a_oid = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_SIZE_MODIFY_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectCheck(DbHandle *dbh, const eyedbsm::Oid *oid, int *state,
                eyedbsm::Oid *cloid)
{
  CHECK_DBH(dbh, "objectCheck");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectCheck((DbHandle *)dbh->u.dbh, oid, state, cloid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_CHECK_RPC, ua);

      *state = ua[2].a_int;
      *cloid = ua[3].a_oid;

      status_copy(status_r, ua[4].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectProtectionSet(DbHandle *dbh, const eyedbsm::Oid *obj_oid,
                        const eyedbsm::Oid *prot_oid)
{
  CHECK_DBH(dbh, "objectProtectionSet");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectProtectionSet((DbHandle *)dbh->u.dbh, obj_oid, prot_oid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *obj_oid;
      pua++->a_oid = *prot_oid;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_PROTECTION_SET_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
objectProtectionGet(DbHandle *dbh, const eyedbsm::Oid *obj_oid,
                        eyedbsm::Oid *prot_oid)
{
  CHECK_DBH(dbh, "objectProtectionGet");

  if (DBH_IS_LOCAL(dbh))
    return IDB_objectProtectionGet((DbHandle *)dbh->u.dbh, obj_oid, prot_oid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *obj_oid;
      
      RPC_RPCMAKE(dbh->ch->ch, OBJECT_PROTECTION_GET_RPC, ua);

      *prot_oid = ua[2].a_oid;

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}


RPCStatus
oidMake(DbHandle *dbh, short dspid, const Data idr, unsigned int size,
            eyedbsm::Oid *oid)
{
  /*
    #ifdef E_XDR
    ObjectHeader hdr;
    #endif
  */

  CHECK_DBH(dbh, "oidMake");

  /*
    #ifdef E_XDR
    memcpy(&hdr, idr, IDB_OBJ_HEAD_SIZE);
    Offset offset = 0;
    Size sz = IDB_OBJ_HEAD_SIZE;
    object_header_code((Data *)&idr, &offset, &sz, &hdr);
    #endif
  */

  if (DBH_IS_LOCAL(dbh)) {
#ifdef E_XDR
    ObjectHeader hdr;
    Offset offset = 0;
    object_header_decode(idr, &offset, &hdr);
    return IDB_oidMake((DbHandle *)dbh->u.dbh, &hdr, dspid, size, oid);
#else
    return IDB_oidMake((DbHandle *)dbh->u.dbh, (ObjectHeader *)idr, dspid, size, oid);
#endif
  }
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      /* XDR TBD : should code HDR */

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      pua->a_data.data = (const Data)idr;
      pua++->a_data.size = IDB_OBJ_HEAD_SIZE;
      pua++->a_int = size;
      
      RPC_RPCMAKE(dbh->ch->ch, OID_MAKE_RPC, ua);

      *oid = ua[4].a_oid;

      status_copy(status_r, ua[5].a_status);

      STATUS_RETURN(status_r);
    }
}

/* raw data object */
RPCStatus
dataCreate(DbHandle *dbh, short dspid, unsigned int size, const Data idr, eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "dataCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_dataCreate((DbHandle *)dbh->u.dbh, dspid, size, idr, oid, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = dspid;
      pua->a_data.size   = size;
      pua++->a_data.data = idr;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_CREATE_RPC, ua);

      *oid = ua[3].a_oid;

      status_copy(status_r, ua[4].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataDelete(DbHandle *dbh, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "dataDelete");

  if (DBH_IS_LOCAL(dbh))
    return IDB_dataDelete((DbHandle *)dbh->u.dbh, oid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid       = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_DELETE_RPC, ua);

      status_copy(status_r, ua[2].a_status);
      
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataRead(DbHandle *dbh, int offset, unsigned int size, Data idr, short *pdspid, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "dataRead");

  if (DBH_IS_LOCAL(dbh))
    return IDB_dataRead((DbHandle *)dbh->u.dbh, offset, size, idr, pdspid, oid, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = offset;
      pua++->a_int       = size;
      pua++; /* pdspid */
      pua++->a_oid       = *oid;
      pua->a_data.size   = size;
      pua++->a_data.data = idr;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_READ_RPC, ua);

      status_copy(status_r, ua[6].a_status);
      if (pdspid) *pdspid = ua[3].a_int;

      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataWrite(DbHandle *dbh, int offset, unsigned int size, const Data idr, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "dataWrite");
  
  if (DBH_IS_LOCAL(dbh))
    return IDB_dataWrite((DbHandle *)dbh->u.dbh, offset, size, idr, oid, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = offset;
      pua->a_data.size   = size;
      pua++->a_data.data = idr;
      pua++->a_oid       = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_WRITE_RPC, ua);

      status_copy(status_r, ua[4].a_status);
  
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataSizeGet(DbHandle *dbh, const eyedbsm::Oid *oid, unsigned int *size)
{
  CHECK_DBH(dbh, "dataSizeGet");

  if (DBH_IS_LOCAL(dbh))
    return IDB_dataSizeGet((DbHandle *)dbh->u.dbh, oid, size);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_SIZE_GET_RPC, ua);

      *size = ua[2].a_int;
      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataSizeModify(DbHandle *dbh, unsigned int size, const eyedbsm::Oid *oid)
{
  CHECK_DBH(dbh, "dataSizeModify");

  if (DBH_IS_LOCAL(dbh))
    return IDB_dataSizeModify((DbHandle *)dbh->u.dbh, size, oid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = size;
      pua++->a_oid       = *oid;
      
      RPC_RPCMAKE(dbh->ch->ch, DATA_SIZE_MODIFY_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
VDdataCreate(DbHandle *dbh, short dspid, const eyedbsm::Oid *actual_oid_cl,
                 const eyedbsm::Oid *oid_cl, int num,
                 int count, int size, const Data data,
                 const eyedbsm::Oid *agr_oid, eyedbsm::Oid *data_oid,
                 Data idx_data, Size idx_size)
{
  CHECK_DBH(dbh, "VDdataCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_VDdataCreate((DbHandle *)dbh->u.dbh, dspid, actual_oid_cl, oid_cl,
                            num, count, size, data,
                            agr_oid, data_oid, idx_data, idx_size, 0, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = dspid;
      pua++->a_oid       = *actual_oid_cl;
      pua++->a_oid       = *oid_cl;
      pua++->a_int       = num;
      pua++->a_int       = count;
      pua->a_data.size   = size;
      pua++->a_data.data = data;
      pua->a_data.size   = idx_size;
      pua++->a_data.data = idx_data;
      pua++->a_oid       = *agr_oid;
      
      RPC_RPCMAKE(dbh->ch->ch, VDDATA_CREATE_RPC, ua);

      *data_oid = ua[9].a_oid;

      status_copy(status_r, ua[10].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
VDdataDelete(DbHandle *dbh, const eyedbsm::Oid *actual_oid_cl,
                 const eyedbsm::Oid *oid_cl, int num,
                 const eyedbsm::Oid *agr_oid, const eyedbsm::Oid *data_oid,
                 Data idx_data, Size idx_size)
{
  CHECK_DBH(dbh, "VDdataDelete");

  if (DBH_IS_LOCAL(dbh))
    return IDB_VDdataDelete((DbHandle *)dbh->u.dbh, actual_oid_cl, oid_cl,
                            num, agr_oid, data_oid, idx_data, idx_size, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *actual_oid_cl;
      pua++->a_oid       = *oid_cl;
      pua++->a_int       = num;
      pua++->a_oid       = *agr_oid;
      pua++->a_oid       = *data_oid;
      pua->a_data.size   = idx_size;
      pua++->a_data.data = idx_data;

      RPC_RPCMAKE(dbh->ch->ch, VDDATA_DELETE_RPC, ua);

      status_copy(status_r, ua[7].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
VDdataWrite(DbHandle *dbh, const eyedbsm::Oid *actual_oid_cl,
                const eyedbsm::Oid *oid_cl, int num,
                int count, unsigned int size, const Data data,
                const eyedbsm::Oid *agr_oid,
                const eyedbsm::Oid *data_oid,
                Data idx_data, Size idx_size)
{
  CHECK_DBH(dbh, "VDdataWrite");

  if (DBH_IS_LOCAL(dbh))
    return IDB_VDdataWrite((DbHandle *)dbh->u.dbh, actual_oid_cl, oid_cl, num,
                           count, size, data,
                           agr_oid, data_oid, idx_data, idx_size, 0, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *actual_oid_cl;
      pua++->a_oid       = *oid_cl;
      pua++->a_int       = num;
      pua++->a_int       = count;
      pua->a_data.size   = size;
      pua++->a_data.data = data;
      pua->a_data.size   = idx_size;
      pua++->a_data.data = idx_data;
      pua++->a_oid       = *agr_oid;
      pua++->a_oid       = *data_oid;
      
      RPC_RPCMAKE(dbh->ch->ch, VDDATA_WRITE_RPC, ua);

      status_copy(status_r, ua[9].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
schemaComplete(DbHandle *dbh, const char *schname)
{
  CHECK_DBH(dbh, "schemaComplete");

  if (DBH_IS_LOCAL(dbh))
    return IDB_schemaComplete((DbHandle *)dbh->u.dbh, schname);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int    = RDBHID_GET(dbh);
      pua++->a_string = (char *)schname;
      
      RPC_RPCMAKE(dbh->ch->ch, SCHEMA_COMPLETE_RPC, ua);

      status_copy(status_r, ua[2].a_status);

      STATUS_RETURN(status_r);
    }
}

/* agreg item indexes */
RPCStatus
attributeIndexCreate(DbHandle *dbh, const eyedbsm::Oid *cloid, int num,
                         int mode, eyedbsm::Oid *multi_idx_oid,
                         Data idx_data, Size idx_size)
{
  CHECK_DBH(dbh, "attributeIndexCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_attributeIndexCreate((DbHandle *)dbh->u.dbh, cloid, num, mode,
                                    multi_idx_oid, idx_data, idx_size, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *cloid;
      pua++->a_int       = num;
      pua++->a_int       = mode;
      pua++->a_oid       = *multi_idx_oid;
      pua->a_data.data   = idx_data;
      pua++->a_data.size  = idx_size;
      
      RPC_RPCMAKE(dbh->ch->ch, ATTRIBUTE_INDEX_CREATE_RPC, ua);

      status_copy(status_r, ua[6].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
attributeIndexRemove(DbHandle *dbh, const eyedbsm::Oid *cloid, int num,
                         int mode, Data idx_data, Size idx_size)
{
  CHECK_DBH(dbh, "attributeIndexRemove");

  if (DBH_IS_LOCAL(dbh))
    return IDB_attributeIndexRemove((DbHandle *)dbh->u.dbh, cloid, num, mode,
                                    idx_data, idx_size, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *cloid;
      pua++->a_int       = num;
      pua++->a_int       = mode;
      pua->a_data.data   = idx_data;
      pua++->a_data.size  = idx_size;
      
      RPC_RPCMAKE(dbh->ch->ch, ATTRIBUTE_INDEX_REMOVE_RPC, ua);

      status_copy(status_r, ua[5].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexCreate(DbHandle * dbh, bool index_move, const eyedbsm::Oid * objoid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexCreate((DbHandle *)dbh->u.dbh, index_move, objoid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = index_move;
      pua++->a_oid = *objoid;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_CREATE_RPC, ua);


      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexRemove(DbHandle * dbh, const eyedbsm::Oid * objoid, int reentrant)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexRemove((DbHandle *)dbh->u.dbh, objoid, reentrant);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *objoid;
      pua++->a_int = reentrant;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_REMOVE_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
constraintCreate(DbHandle * dbh, const eyedbsm::Oid * objoid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_constraintCreate((DbHandle *)dbh->u.dbh, objoid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *objoid;

      RPC_RPCMAKE(dbh->ch->ch, CONSTRAINT_CREATE_RPC, ua);


      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
constraintDelete(DbHandle * dbh, const eyedbsm::Oid * objoid, int reentrant)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_constraintDelete((DbHandle *)dbh->u.dbh, objoid, reentrant);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *objoid;
      pua++->a_int = reentrant;

      RPC_RPCMAKE(dbh->ch->ch, CONSTRAINT_DELETE_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

/* collections */
RPCStatus
collectionGetByInd(DbHandle *dbh, const eyedbsm::Oid *oid, int ind,
                       int *found, Data buf, int size)
{
  CHECK_DBH(dbh, "collectionGetByInd");

  if (DBH_IS_LOCAL(dbh))
    return IDB_collectionGetByInd((DbHandle *)dbh->u.dbh, oid, ind, found, buf, (void *)0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *oid;
      pua++->a_int       = ind;
      pua++;               /* found */
      pua->a_data.data   = buf;
      pua++->a_data.size = size;

      RPC_RPCMAKE(dbh->ch->ch, COLLECTION_GET_BY_IND_RPC, ua);

      *found = ua[3].a_int;
      status_copy(status_r, ua[5].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
collectionGetByValue(DbHandle *dbh, const eyedbsm::Oid *oid, Data val,
                         int size, int *found, int *ind)
{
  CHECK_DBH(dbh, "collectionGetByValue");

  if (DBH_IS_LOCAL(dbh))
    return IDB_collectionGetByValue((DbHandle *)dbh->u.dbh, oid, val, found, ind);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *oid;
      pua->a_data.data   = val;
      pua++->a_data.size = size;
      
      RPC_RPCMAKE(dbh->ch->ch, COLLECTION_GET_BY_VALUE_RPC, ua);

      *found = ua[3].a_int;
      *ind   = ua[4].a_int;
      status_copy(status_r, ua[5].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
collectionGetByOid(DbHandle *dbh, const eyedbsm::Oid *oid,
                       const eyedbsm::Oid *loid, int *found, int *ind)
{
  unsigned char data[sizeof(*loid)];
  oid_code(data, (Data)loid);
  return collectionGetByValue(dbh, oid, data,
                                  sizeof(eyedbsm::Oid), found, ind);

  return collectionGetByValue(dbh, oid, (Data)loid,
                                  sizeof(eyedbsm::Oid), found, ind);
}

/* object lock */

RPCStatus
setObjectLock(DbHandle * dbh, const eyedbsm::Oid * oid, int lockmode, int * rlockmode)
{
  CHECK_DBH(dbh, "setObjectLock");

  if (DBH_IS_LOCAL(dbh))
    return IDB_setObjectLock((DbHandle *)dbh->u.dbh, oid, lockmode, rlockmode);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;
      pua++->a_int = lockmode;
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, SET_OBJECT_LOCK_RPC, ua);

      *rlockmode = ua[4].a_int;

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getObjectLock(DbHandle * dbh, const eyedbsm::Oid * oid, int * lockmode)
{
  CHECK_DBH(dbh, "getObjectLock");

  if (DBH_IS_LOCAL(dbh))
    return IDB_getObjectLock((DbHandle *)dbh->u.dbh, oid, lockmode);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, GET_OBJECT_LOCK_RPC, ua);

      *lockmode = ua[3].a_int;

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

/* queries */
#if 0
RPCStatus
queryLangCreate(DbHandle *dbh, const char *str, int *qid,
                    void *pschinfo, int *count)
{
  CHECK_DBH(dbh, "queryLangCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryLangCreate((DbHandle *)dbh->u.dbh, str, qid, count, pschinfo,
                               (void *)0, (void *)0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua->a_data.data   = (const Data)str;
      pua++->a_data.size = strlen(str)+1;
      pua++; /* qid */
      pua++; /* count */
      pua->a_data.size   = 0;
      pua++->a_data.data = 0; /* force RPC to allocate buffer */
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_LANG_CREATE_RPC, ua);

      *qid   = ua[2].a_int;
      *count = ua[3].a_int;
      status_copy(status_r, ua[5].a_status);
      if (!status_r.err)
        decode_sch_info((unsigned char *)ua[4].a_data.data, pschinfo);

      free(ua[4].a_data.data);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
queryDatabaseCreate(DbHandle *dbh, int *qid)
{
  CHECK_DBH(dbh, "queryDatabaseCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryDatabaseCreate((DbHandle *)dbh->u.dbh, qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_DATABASE_CREATE_RPC, ua);

      *qid   = ua[1].a_int;
      status_copy(status_r, ua[2].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
queryClassCreate(DbHandle *dbh, const eyedbsm::Oid *cloid, int *qid)
{
  CHECK_DBH(dbh, "queryClassCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryClassCreate((DbHandle *)dbh->u.dbh, cloid, qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *cloid;
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_CLASS_CREATE_RPC, ua);

      *qid   = ua[2].a_int;
      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}
#endif

RPCStatus
queryCollectionCreate(DbHandle *dbh, const eyedbsm::Oid *oid, Bool index,
                          int *qid)
{
  CHECK_DBH(dbh, "queryCollectionCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryCollectionCreate((DbHandle *)dbh->u.dbh, oid, (int)index, qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int    = RDBHID_GET(dbh);
      pua++->a_oid    = *oid;
      pua++->a_int    = (int)index;
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_COLLECTION_CREATE_RPC, ua);

      *qid   = ua[3].a_int;
      status_copy(status_r, ua[4].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
queryAttributeCreate(DbHandle *dbh, const eyedbsm::Oid *cloid, int num,
                         int ind, Data start, Data end, int sexcl,
                         int eexcl, int x_size, int *qid)
{
  CHECK_DBH(dbh, "queryAttributeCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryAttributeCreate((DbHandle *)dbh->u.dbh, cloid, num, ind,
                                    start, end, sexcl, eexcl, x_size,
                                    qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_oid       = *cloid;
      pua++->a_int       = num;
      pua++->a_int       = ind;
      pua->a_data.data   = start;
      pua++->a_data.size = x_size;
      pua->a_data.data   = end;
      pua++->a_data.size = x_size;
      pua++->a_int       = sexcl;
      pua++->a_int       = eexcl;
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_ATTRIBUTE_CREATE_RPC, ua);

      *qid   = ua[8].a_int;
      status_copy(status_r, ua[9].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
queryDelete(DbHandle *dbh, int qid)
{
  CHECK_DBH(dbh, "queryDelete");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryDelete((DbHandle *)dbh->u.dbh, qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;

      start_rpc();

      pua++->a_int    = RDBHID_GET(dbh);
      pua++->a_int    = qid;
      
      RPC_RPCMAKE(dbh->ch->ch, QUERY_DELETE_RPC, ua);

      status_copy(status_r, ua[2].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
queryScanNext(DbHandle *dbh, int qid, int wanted, int *found,
                  void *atom_array)
{
  CHECK_DBH(dbh, "queryScanNext");

  if (DBH_IS_LOCAL(dbh))
    return IDB_queryScanNext((DbHandle *)dbh->u.dbh, qid, wanted, found, atom_array, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_int       = qid;
      pua++->a_int       = wanted;
      pua++;
      pua->a_data.size   = 0;
      pua++->a_data.data = 0; /* force RPC to allocate buffer */

      RPC_RPCMAKE(dbh->ch->ch, QUERY_SCAN_NEXT_RPC, ua);

      *found   = ua[3].a_int;
      status_copy(status_r, ua[5].a_status);
      if (!status_r.err)
        decode_atom_array(&ua[4].a_data, atom_array, *found);

      STATUS_RETURN(status_r);
    }
}

/* oql */

RPCStatus
oqlCreate(ConnHandle *ch, DbHandle * dbh, const char * oql,
              int *qid, void *schema_info)
{
  CHECK_DBH(dbh, "oqlCreate");

  if (DBH_IS_LOCAL(dbh))
    return IDB_oqlCreate((DbHandle *)(dbh ? dbh->u.dbh : 0), oql, qid, schema_info,
                         0, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = (dbh ? RDBHID_GET(dbh) : 0);
      pua->a_data.data   = (const Data)oql;
      pua++->a_data.size = strlen(oql)+1;
      pua++; /* qid */
      pua->a_data.size   = 0;
      pua++->a_data.data = 0; /* force RPC to allocate buffer */

      RPC_RPCMAKE(ch->ch, OQL_CREATE_RPC, ua);

      *qid = ua[2].a_int;
      status_copy(status_r, ua[4].a_status);
      if (!status_r.err)
        decode_sch_info((unsigned char *)ua[3].a_data.data, schema_info);

      free(ua[3].a_data.data);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
oqlDelete(ConnHandle *ch, DbHandle * dbh, int qid)
{
  CHECK_DBH(dbh, "oqlDelete");

  if (DBH_IS_LOCAL(dbh))
    return IDB_oqlDelete((DbHandle *)(dbh ? dbh->u.dbh : 0), qid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = (dbh ? RDBHID_GET(dbh) : 0);
      pua++->a_int = qid;

      RPC_RPCMAKE(ch->ch, OQL_DELETE_RPC, ua);

      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
oqlGetResult(ConnHandle *ch, DbHandle * dbh, int qid,
                 void *value)
{
  CHECK_DBH(dbh, "oqlGetResult");

  if (DBH_IS_LOCAL(dbh))
    return IDB_oqlGetResult((DbHandle *)(dbh ? dbh->u.dbh : 0), qid, value, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = (dbh ? RDBHID_GET(dbh) : 0);
      pua++->a_int = qid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(ch->ch, OQL_GETRESULT_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      if (!status_r.err)
        decode_value(&ua[2].a_data, value);

      free(ua[2].a_data.data); /* added the 3/11/99 */

      STATUS_RETURN(status_r);
    }
}

/* executables */
RPCStatus
execExecute(DbHandle *dbh, const char *user, const char *passwd,
                const char *intname,
                const char *name, 
                int exec_type,
                const eyedbsm::Oid *cloid,
                const char *extref,
                const void *sign,
                const eyedbsm::Oid *execoid,
                const eyedbsm::Oid *objoid,
                void *o,
                const void *argarray,
                void *argret)
{
  CHECK_DBH(dbh, "execExecute");

  if (DBH_IS_LOCAL(dbh))
    return IDB_execExecute((DbHandle *)dbh->u.dbh, user, passwd, intname,
                           name, exec_type, cloid,
                           extref, sign, 0, execoid, objoid, o,
                           argarray, 0, argret, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      unsigned char *sign_data;
      unsigned char *argarray_data;
      start_rpc();

      code_signature(&ua[8], sign);
      code_arg_array(&ua[11], argarray);

      sign_data = (unsigned char *)ua[8].a_data.data;
      argarray_data = (unsigned char *)ua[11].a_data.data;

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_string    = (char *)user;
      pua++->a_string    = (char *)passwd;
      pua++->a_string    = (char *)intname;
      pua++->a_string    = (char *)name;
      pua++->a_int       = exec_type;
      pua++->a_oid       = *cloid;
      pua++->a_string    = (char *)extref;
      pua++;             /* ua[8] <= sign */
      pua++->a_oid       = *execoid;
      pua++->a_oid       = *objoid;
      pua++;             /* ua[11] <= argarray */
      pua->a_data.size   = 0;
      pua++->a_data.data = 0; /* force RPC to allocate buffer */

      RPC_RPCMAKE(dbh->ch->ch, EXECUTABLE_EXECUTE_RPC, ua);

      status_copy(status_r, ua[13].a_status);

      if (!status_r.err)
        {
          offset = decode_arg_array(dbh->db, &ua[12].a_data, (void **)argarray,
                                        False);
          decode_argument(dbh->db, &ua[12].a_data, argret, offset);
        }

      /* added the 15/01/99;*/
      free(ua[12].a_data.data);

      free(sign_data);
      free(argarray_data);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
execCheck(DbHandle *dbh, const char *intname, const eyedbsm::Oid *oid,
              const char *extref)
{
  CHECK_DBH(dbh, "execCheck");

  if (DBH_IS_LOCAL(dbh))
    return IDB_execCheck((DbHandle *)dbh->u.dbh, intname, oid, extref);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r;

      start_rpc();

      pua++->a_int       = RDBHID_GET(dbh);
      pua++->a_string    = (char *)intname;
      pua++->a_oid       = *oid;
      pua++->a_string    = (char *)extref;

      RPC_RPCMAKE(dbh->ch->ch, EXECUTABLE_CHECK_RPC, ua);

      status_copy(status_r, ua[4].a_status);

      STATUS_RETURN(status_r);
    }
}

extern RPCStatus
execSetExtRefPath(ConnHandle *ch, const char *user,
                      const char *passwd, const char *path)
{
  if (!ch)
    return IDB_execSetExtRefPath(user, passwd, path);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r;

      start_rpc();

      pua++->a_string    = (char *)user;
      pua++->a_string    = (char *)passwd;
      pua++->a_string    = (char *)path;

      RPC_RPCMAKE(ch->ch, EXECUTABLE_SET_EXTREF_PATH_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

extern RPCStatus
execGetExtRefPath(ConnHandle *ch, const char *user,
                      const char *passwd, char path[], unsigned int pathlen)
{
  if (!ch)
    return IDB_execGetExtRefPath(user, passwd, path, pathlen);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, min;

      start_rpc();

      pua++->a_string    = (char *)user;
      pua++->a_string    = (char *)passwd;
      pua->a_data.size   = 0;
      pua++->a_data.data = 0; /* force RPC to allocate buffer */

      RPC_RPCMAKE(ch->ch, EXECUTABLE_GET_EXTREF_PATH_RPC, ua);

      min = (pathlen < ua[2].a_data.size ? pathlen : ua[2].a_data.size);
      memcpy(path, ua[2].a_data.data, min);
      path[min] = 0;

      free(ua[2].a_data.data); // 1/10/05

      status_copy(status_r, ua[3].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
checkAuth(ConnHandle *ch, const char *file)
{
  if (!ch)
    return IDB_checkAuth(file);
  else
   {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_string = (char *)file;

      RPC_RPCMAKE(ch->ch, CHECK_AUTH_RPC, ua);

      status_copy(status_r, ua[1].a_status);
      STATUS_RETURN(status_r);
    }
}


RPCStatus
set_conn_info(ConnHandle *ch, const char *hostname,
              int uid, const char *username, const char *progname,
              int *sv_pid, int *sv_uid, int sv_version, char **challenge)
{
  if (!ch)
    return IDB_setConnInfo(hostname, uid, username, progname, getpid(),
                           sv_pid, sv_uid, sv_version, challenge);
  else {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, min;

      start_rpc();

      pua++->a_string = (char *)hostname;
      pua++->a_int    = uid;
      pua++->a_string = (char *)username;
      pua++->a_string = (char *)progname;
      pua++->a_int    = getpid();
      pua++;            /* sv_pid */
      pua++;            /* sv_uid */
      pua++->a_int    = sv_version;

      RPC_RPCMAKE(ch->ch, SET_CONN_INFO_RPC, ua);

      *sv_pid = ua[5].a_int;
      *sv_uid = ua[6].a_int;
      *challenge = ua[8].a_string;

      status_copy(status_r, ua[9].a_status);

      STATUS_RETURN(status_r);
    }
}

RPCStatus
setLogMask(ConnHandle *ch, eyedblib::int64 logmask)
{
  if (!ch)
    return IDB_setLogMask(logmask);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int64 = logmask;

      RPC_RPCMAKE(ch->ch, SET_LOG_MASK_RPC, ua);

      status_copy(status_r, ua[1].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getDefaultDataspace(DbHandle * dbh, int * dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getDefaultDataspace((DbHandle *)dbh->u.dbh, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, GET_DEFAULT_DATASPACE_RPC, ua);

      *dspid = ua[1].a_int;

      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
setDefaultDataspace(DbHandle * dbh, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_setDefaultDataspace((DbHandle *)dbh->u.dbh, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, SET_DEFAULT_DATASPACE_RPC, ua);

      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getDefaultIndexDataspace(DbHandle * dbh, const eyedbsm::Oid *oid, int type, int * dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getDefaultIndexDataspace((DbHandle *)dbh->u.dbh, oid, type, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *oid;
      pua++->a_int = type;
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, GET_DEFAULT_INDEX_DATASPACE_RPC, ua);

      *dspid = ua[3].a_int;

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataspaceSetCurrentDatafile(DbHandle * dbh, int dspid, int datid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_dataspaceSetCurrentDatafile((DbHandle *)dbh->u.dbh, dspid, datid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      pua++->a_int = datid;

      RPC_RPCMAKE(dbh->ch->ch, DATASPACE_SET_CURRENT_DATAFILE_RPC, ua);


      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
dataspaceGetCurrentDatafile(DbHandle * dbh, int dspid, int * datid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_dataspaceGetCurrentDatafile((DbHandle *)dbh->u.dbh, dspid, datid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, DATASPACE_GET_CURRENT_DATAFILE_RPC, ua);

      *datid = ua[2].a_int;

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
setDefaultIndexDataspace(DbHandle * dbh, const eyedbsm::Oid *idxoid, int type, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_setDefaultIndexDataspace((DbHandle *)dbh->u.dbh, idxoid, type, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      start_rpc();

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua++->a_int = type;
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, SET_DEFAULT_INDEX_DATASPACE_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getIndexLocations(DbHandle * dbh, const eyedbsm::Oid * idxoid,
                      int type, void * locarr)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getIndexLocations((DbHandle *)dbh->u.dbh, idxoid, type, (unsigned char **)locarr, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua++->a_int = type;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, GET_INDEX_LOCATIONS_RPC, ua);

      if (!status_r.err)
        decode_locarr((unsigned char *)ua[3].a_data.data, locarr);

      free(ua[3].a_data.data); // 1/10/05

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}


RPCStatus
moveIndex(DbHandle * dbh, const eyedbsm::Oid * idxoid, int type, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_moveIndex((DbHandle *)dbh->u.dbh, idxoid, type, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua++->a_int = type;
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, MOVE_INDEX_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getInstanceClassLocations(DbHandle * dbh, const eyedbsm::Oid * clsoid,
                              int subclasses, Data * locarr)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getInstanceClassLocations((DbHandle *)dbh->u.dbh, clsoid, subclasses, locarr, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *clsoid;
      pua++->a_int = subclasses;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, GET_INSTANCE_CLASS_LOCATIONS_RPC, ua);

      if (!status_r.err)
        decode_locarr((unsigned char *)ua[3].a_data.data, locarr);

      free(ua[3].a_data.data); // 1/10/05

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
moveInstanceClass(DbHandle * dbh, const eyedbsm::Oid * clsoid,
                      int subclasses, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_moveInstanceClass((DbHandle *)dbh->u.dbh, clsoid, subclasses, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *clsoid;
      pua++->a_int = subclasses;
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, MOVE_INSTANCE_CLASS_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getObjectsLocations(DbHandle * dbh, const eyedbsm::Oid *oids, unsigned int oid_cnt, void * locarr)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getObjectsLocations((DbHandle *)dbh->u.dbh, oids, oid_cnt, 0, (unsigned char **)locarr, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      Data oid_data;

      pua++->a_int = RDBHID_GET(dbh);
      oid_data = code_oids(oids, oid_cnt, &pua->a_data.size);
      pua++->a_data.data = oid_data;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, GET_OBJECTS_LOCATIONS_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      if (!status_r.err)
        decode_locarr((unsigned char *)ua[2].a_data.data, locarr);

      free(oid_data);
      free(ua[2].a_data.data); // 1/10/05

      STATUS_RETURN(status_r);
    }
}

RPCStatus
moveObjects(DbHandle * dbh, const eyedbsm::Oid * oids, unsigned int oid_cnt,
                int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_moveObjects((DbHandle *)dbh->u.dbh, oids, oid_cnt, dspid, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      Data oids_data;

      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      oids_data = code_oids(oids, oid_cnt, &pua->a_data.size);
      pua++->a_data.data = oids_data;
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, MOVE_OBJECTS_RPC, ua);

      free(oids_data);
      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getAttributeLocations(DbHandle * dbh, const eyedbsm::Oid * clsoid, int attrnum, Data * locarr)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getAttributeLocations((DbHandle *)dbh->u.dbh, clsoid, attrnum, locarr, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *clsoid;
      pua++->a_int = attrnum;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, GET_ATTRIBUTE_LOCATIONS_RPC, ua);

      *locarr = (unsigned char *)ua[3].a_data.data;

      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
moveAttribute(DbHandle * dbh, const eyedbsm::Oid * clsoid, int attrnum, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_moveAttribute((DbHandle *)dbh->u.dbh, clsoid, attrnum, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *clsoid;
      pua++->a_int = attrnum;
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, MOVE_ATTRIBUTE_RPC, ua);


      status_copy(status_r, ua[4].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
createDatafile(DbHandle * dbh, const char * datfile, const char * name, int maxsize, int slotsize, int dtype)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_createDatafile((DbHandle *)dbh->u.dbh, datfile, name, maxsize, slotsize, dtype);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_string = (char *)datfile;
      pua++->a_string = (char *)name;
      pua++->a_int = maxsize;
      pua++->a_int = slotsize;
      pua++->a_int = dtype;

      RPC_RPCMAKE(dbh->ch->ch, CREATE_DATAFILE_RPC, ua);

      status_copy(status_r, ua[6].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
deleteDatafile(DbHandle * dbh, int datid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_deleteDatafile((DbHandle *)dbh->u.dbh, datid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;

      RPC_RPCMAKE(dbh->ch->ch, DELETE_DATAFILE_RPC, ua);


      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
moveDatafile(DbHandle * dbh, int datid, const char * datafile)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_moveDatafile((DbHandle *)dbh->u.dbh, datid, datafile);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;
      pua++->a_string = (char *)datafile;

      RPC_RPCMAKE(dbh->ch->ch, MOVE_DATAFILE_RPC, ua);


      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
defragmentDatafile(DbHandle * dbh, int datid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_defragmentDatafile((DbHandle *)dbh->u.dbh, datid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;

      RPC_RPCMAKE(dbh->ch->ch, DEFRAGMENT_DATAFILE_RPC, ua);


      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
resizeDatafile(DbHandle * dbh, int datid, unsigned int size)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_resizeDatafile((DbHandle *)dbh->u.dbh, datid, size);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;
      pua++->a_int = size;

      RPC_RPCMAKE(dbh->ch->ch, RESIZE_DATAFILE_RPC, ua);


      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
getDatafileInfo(DbHandle * dbh, int datid, void * info)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_getDatafileInfo((DbHandle *)dbh->u.dbh, datid, (unsigned char **)info, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, GET_DATAFILEI_NFO_RPC, ua);

      if (!status_r.err)
        decode_datinfo((unsigned char *)ua[2].a_data.data, info);

      free(ua[2].a_data.data); // 1/10/05
      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
renameDatafile(DbHandle * dbh, int datid, const char * name)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_renameDatafile((DbHandle *)dbh->u.dbh, datid, name);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = datid;
      pua++->a_string = (char *)name;

      RPC_RPCMAKE(dbh->ch->ch, RENAME_DATAFILE_RPC, ua);


      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
createDataspace(DbHandle * dbh, const char * dspname, void *datafiles,
                    unsigned int datafile_cnt)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_createDataspace((DbHandle *)dbh->u.dbh, dspname, datafiles, datafile_cnt, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      Data datfile_data;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_string = (char *)dspname;
      datfile_data = code_datafiles(datafiles, datafile_cnt,
                                        &pua->a_data.size);
      pua++->a_data.data = datfile_data;

      RPC_RPCMAKE(dbh->ch->ch, CREATE_DATASPACE_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      free(datfile_data);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
updateDataspace(DbHandle * dbh, int dspid,  void *datafiles,
                    unsigned int datafile_cnt)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_updateDataspace((DbHandle *)dbh->u.dbh, dspid, datafiles, datafile_cnt, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      Data datfile_data;

      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      datfile_data = code_datafiles(datafiles, datafile_cnt,
                                        &pua->a_data.size);
      pua++->a_data.data = datfile_data;

      RPC_RPCMAKE(dbh->ch->ch, UPDATE_DATASPACE_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      free(datfile_data);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
deleteDataspace(DbHandle * dbh, int dspid)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_deleteDataspace((DbHandle *)dbh->u.dbh, dspid);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;

      RPC_RPCMAKE(dbh->ch->ch, DELETE_DATASPACE_RPC, ua);


      status_copy(status_r, ua[2].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
renameDataspace(DbHandle * dbh, int dspid, const char * name)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_renameDataspace((DbHandle *)dbh->u.dbh, dspid, name);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = dspid;
      pua++->a_string = (char *)name;

      RPC_RPCMAKE(dbh->ch->ch, RENAME_DATASPACE_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexGetCount(DbHandle * dbh, const eyedbsm::Oid * idxoid, int * cnt)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexGetCount((DbHandle *)dbh->u.dbh, idxoid, cnt);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua++;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_GET_COUNT_RPC, ua);

      *cnt = ua[2].a_int;

      status_copy(status_r, ua[3].a_status);
      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexGetStats(DbHandle * dbh, const eyedbsm::Oid * idxoid, Data * stats)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexGetStats((DbHandle *)dbh->u.dbh, idxoid, stats, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_GET_STATS_RPC, ua);

      status_copy(status_r, ua[3].a_status);

      if (!status_r.err)
        decode_index_stats((unsigned char *)ua[2].a_data.data, stats);

      free(ua[2].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexSimulStats(DbHandle * dbh, const eyedbsm::Oid * idxoid,
                    const Data impl, Size impl_size, Data * stats)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexSimulStats((DbHandle *)dbh->u.dbh, idxoid, impl, 0, stats, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua->a_data.data = (const Data)impl;
      pua++->a_data.size = impl_size;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_SIMUL_STATS_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      if (!status_r.err)
        decode_index_stats((unsigned char *)ua[3].a_data.data, stats);

      free(ua[3].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
collectionGetImplStats(DbHandle * dbh, int idxtype,
                           const eyedbsm::Oid * idxoid, Data * stats)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_collectionGetImplStats((DbHandle *)dbh->u.dbh, idxtype, idxoid, stats, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = idxtype;
      pua++->a_oid = *idxoid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, COLLECTION_GET_IMPLSTATS_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      if (!status_r.err)
        decode_index_stats((unsigned char *)ua[3].a_data.data, stats);

      free(ua[3].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
collectionSimulImplStats(DbHandle * dbh, int idxtype, const eyedbsm::Oid * idxoid, const Data impl, Size impl_size, Data * stats)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_collectionSimulImplStats((DbHandle *)dbh->u.dbh, idxtype, idxoid, impl, 0,
                                        stats, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = idxtype;
      pua++->a_oid = *idxoid;
      pua->a_data.data = (const Data)impl;
      pua++->a_data.size = impl_size;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, COLLECTION_SIMUL_IMPLSTATS_RPC, ua);

      status_copy(status_r, ua[5].a_status);
      if (!status_r.err)
        decode_index_stats((unsigned char *)ua[4].a_data.data, stats);

      free(ua[4].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
indexGetImplementation(DbHandle * dbh, const eyedbsm::Oid * idxoid, Data * impl)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_indexGetImplementation((DbHandle *)dbh->u.dbh, idxoid, impl, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_oid = *idxoid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, INDEX_GET_IMPL_RPC, ua);

      status_copy(status_r, ua[3].a_status);
      if (!status_r.err)
        decode_index_impl((unsigned char *)ua[2].a_data.data, impl);

      free(ua[2].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}

RPCStatus
collectionGetImplementation(DbHandle * dbh, int idxtype, const eyedbsm::Oid * idxoid, Data * impl)
{
  if (DBH_IS_LOCAL(dbh))
    return IDB_collectionGetImplementation((DbHandle *)dbh->u.dbh, idxtype, idxoid, impl, 0);
  else
    {
      ClientArg ua[IDB_MAXARGS], *pua = ua;
      int r, offset;
      pua++->a_int = RDBHID_GET(dbh);
      pua++->a_int = idxtype;
      pua++->a_oid = *idxoid;
      pua->a_data.data = 0; /* force RPC to allocate buffer */
      pua++->a_data.size   = 0;

      RPC_RPCMAKE(dbh->ch->ch, COLLECTION_GET_IMPL_RPC, ua);

      status_copy(status_r, ua[4].a_status);
      if (!status_r.err)
        decode_index_impl((unsigned char *)ua[3].a_data.data, impl);

      free(ua[3].a_data.data); // 1/10/05
      STATUS_RETURN(status_r);
    }
}
}

---