diff options
Diffstat (limited to 'db/rpc_client')
| -rw-r--r-- | db/rpc_client/client.c | 371 | ||||
| -rw-r--r-- | db/rpc_client/db_server_clnt.c | 692 | ||||
| -rw-r--r-- | db/rpc_client/gen_client.c | 2494 | ||||
| -rw-r--r-- | db/rpc_client/gen_client_ret.c | 542 |
4 files changed, 4099 insertions, 0 deletions
diff --git a/db/rpc_client/client.c b/db/rpc_client/client.c new file mode 100644 index 000000000..70744f54b --- /dev/null +++ b/db/rpc_client/client.c @@ -0,0 +1,371 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1996, 1997, 1998, 1999, 2000 + * Sleepycat Software. All rights reserved. + */ + +#include "db_config.h" + +#ifndef lint +static const char revid[] = "$Id: client.c,v 1.21 2000/11/30 00:58:44 ubell Exp $"; +#endif /* not lint */ + +#ifdef HAVE_RPC +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <rpc/rpc.h> + +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#endif +#include "db_server.h" + +#include "db_int.h" +#include "txn.h" +#include "gen_client_ext.h" +#include "rpc_client_ext.h" + +/* + * __dbclenv_server -- + * Initialize an environment's server. + * + * PUBLIC: int __dbcl_envserver __P((DB_ENV *, char *, long, long, u_int32_t)); + */ +int +__dbcl_envserver(dbenv, host, tsec, ssec, flags) + DB_ENV *dbenv; + char *host; + long tsec, ssec; + u_int32_t flags; +{ + CLIENT *cl; + __env_create_msg req; + __env_create_reply *replyp; + struct timeval tp; + int ret; + + COMPQUIET(flags, 0); + +#ifdef HAVE_VXWORKS + if ((ret = rpcTaskInit()) != 0) { + __db_err(dbenv, "Could not initialize VxWorks RPC"); + return (ERROR); + } +#endif + if ((cl = + clnt_create(host, DB_SERVERPROG, DB_SERVERVERS, "tcp")) == NULL) { + __db_err(dbenv, clnt_spcreateerror(host)); + return (DB_NOSERVER); + } + dbenv->cl_handle = cl; + + if (tsec != 0) { + tp.tv_sec = tsec; + tp.tv_usec = 0; + (void)clnt_control(cl, CLSET_TIMEOUT, (char *)&tp); + } + + req.timeout = ssec; + /* + * CALL THE SERVER + */ + if ((replyp = __db_env_create_1(&req, cl)) == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + return (DB_NOSERVER); + } + + /* + * Process reply and free up our space from request + * SUCCESS: Store ID from server. + */ + if ((ret = replyp->status) != 0) + return (ret); + + dbenv->cl_id = replyp->envcl_id; + return (0); +} + +/* + * __dbcl_refresh -- + * Clean up an environment. + * + * PUBLIC: int __dbcl_refresh __P((DB_ENV *)); + */ +int +__dbcl_refresh(dbenv) + DB_ENV *dbenv; +{ + CLIENT *cl; + int ret; + + cl = (CLIENT *)dbenv->cl_handle; + + ret = 0; + if (dbenv->tx_handle != NULL) { + /* + * We only need to free up our stuff, the caller + * of this function will call the server who will + * do all the real work. + */ + ret = __dbcl_txn_close(dbenv); + dbenv->tx_handle = NULL; + } + if (cl != NULL) + clnt_destroy(cl); + dbenv->cl_handle = NULL; + return (ret); +} + +/* + * __dbcl_txn_close -- + * Clean up an environment's transactions. + * + * PUBLIC: int __dbcl_txn_close __P((DB_ENV *)); + */ +int +__dbcl_txn_close(dbenv) + DB_ENV *dbenv; +{ + DB_TXN *txnp; + DB_TXNMGR *tmgrp; + int ret; + + ret = 0; + tmgrp = dbenv->tx_handle; + + /* + * This function can only be called once per process (i.e., not + * once per thread), so no synchronization is required. + * Also this function is called *after* the server has been called, + * so the server has already closed/aborted any transactions that + * were open on its side. We only need to do local cleanup. + */ + while ((txnp = TAILQ_FIRST(&tmgrp->txn_chain)) != NULL) + __dbcl_txn_end(txnp); + + __os_free(tmgrp, sizeof(*tmgrp)); + return (ret); + +} + +/* + * __dbcl_txn_end -- + * Clean up an transaction. + * RECURSIVE FUNCTION: Clean up nested transactions. + * + * PUBLIC: void __dbcl_txn_end __P((DB_TXN *)); + */ +void +__dbcl_txn_end(txnp) + DB_TXN *txnp; +{ + DB_ENV *dbenv; + DB_TXN *kids; + DB_TXNMGR *mgr; + + mgr = txnp->mgrp; + dbenv = mgr->dbenv; + + /* + * First take care of any kids we have + */ + for (kids = TAILQ_FIRST(&txnp->kids); + kids != NULL; + kids = TAILQ_FIRST(&txnp->kids)) + __dbcl_txn_end(kids); + + /* + * We are ending this transaction no matter what the parent + * may eventually do, if we have a parent. All those details + * are taken care of by the server. We only need to make sure + * that we properly release resources. + */ + if (txnp->parent != NULL) + TAILQ_REMOVE(&txnp->parent->kids, txnp, klinks); + TAILQ_REMOVE(&mgr->txn_chain, txnp, links); + __os_free(txnp, sizeof(*txnp)); + + return; +} + +/* + * __dbcl_c_destroy -- + * Destroy a cursor. + * + * PUBLIC: int __dbcl_c_destroy __P((DBC *)); + */ +int +__dbcl_c_destroy(dbc) + DBC *dbc; +{ + DB *dbp; + + dbp = dbc->dbp; + + TAILQ_REMOVE(&dbp->free_queue, dbc, links); + __os_free(dbc, sizeof(*dbc)); + + return (0); +} + +/* + * __dbcl_c_refresh -- + * Refresh a cursor. Move it from the active queue to the free queue. + * + * PUBLIC: void __dbcl_c_refresh __P((DBC *)); + */ +void +__dbcl_c_refresh(dbcp) + DBC *dbcp; +{ + DB *dbp; + + dbp = dbcp->dbp; + dbcp->flags = 0; + dbcp->cl_id = 0; + + /* + * If dbp->cursor fails locally, we use a local dbc so that + * we can close it. In that case, dbp will be NULL. + */ + if (dbp != NULL) { + TAILQ_REMOVE(&dbp->active_queue, dbcp, links); + TAILQ_INSERT_TAIL(&dbp->free_queue, dbcp, links); + } + return; +} + +/* + * __dbcl_c_setup -- + * Allocate a cursor. + * + * PUBLIC: int __dbcl_c_setup __P((long, DB *, DBC **)); + */ +int +__dbcl_c_setup(cl_id, dbp, dbcpp) + long cl_id; + DB *dbp; + DBC **dbcpp; +{ + DBC *dbc, tmpdbc; + int ret, t_ret; + + if ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL) + TAILQ_REMOVE(&dbp->free_queue, dbc, links); + else { + if ((ret = + __os_calloc(dbp->dbenv, 1, sizeof(DBC), &dbc)) != 0) { + /* + * If we die here, set up a tmp dbc to call the + * server to shut down that cursor. + */ + tmpdbc.dbp = NULL; + tmpdbc.cl_id = cl_id; + t_ret = __dbcl_dbc_close(&tmpdbc); + return (ret); + } + dbc->c_close = __dbcl_dbc_close; + dbc->c_count = __dbcl_dbc_count; + dbc->c_del = __dbcl_dbc_del; + dbc->c_dup = __dbcl_dbc_dup; + dbc->c_get = __dbcl_dbc_get; + dbc->c_put = __dbcl_dbc_put; + dbc->c_am_destroy = __dbcl_c_destroy; + } + dbc->cl_id = cl_id; + dbc->dbp = dbp; + TAILQ_INSERT_TAIL(&dbp->active_queue, dbc, links); + *dbcpp = dbc; + return (0); +} + +/* + * __dbcl_retcopy -- + * Copy the returned data into the user's DBT, handling special flags + * as they apply to a client. Modeled after __db_retcopy(). + * + * PUBLIC: int __dbcl_retcopy __P((DB_ENV *, DBT *, void *, u_int32_t)); + */ +int +__dbcl_retcopy(dbenv, dbt, data, len) + DB_ENV *dbenv; + DBT *dbt; + void *data; + u_int32_t len; +{ + int ret; + + /* + * No need to handle DB_DBT_PARTIAL here, server already did. + */ + dbt->size = len; + + /* + * Allocate memory to be owned by the application: DB_DBT_MALLOC + * and DB_DBT_REALLOC. Always allocate even if we're copying 0 bytes. + * Or use memory specified by application: DB_DBT_USERMEM. + */ + if (F_ISSET(dbt, DB_DBT_MALLOC)) { + if ((ret = __os_malloc(dbenv, len, NULL, &dbt->data)) != 0) + return (ret); + } else if (F_ISSET(dbt, DB_DBT_REALLOC)) { + if ((ret = __os_realloc(dbenv, len, NULL, &dbt->data)) != 0) + return (ret); + } else if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (len != 0 && (dbt->data == NULL || dbt->ulen < len)) + return (ENOMEM); + } else { + /* + * If no user flags, then set the DBT to point to the + * returned data pointer and return. + */ + dbt->data = data; + return (0); + } + + if (len != 0) + memcpy(dbt->data, data, len); + return (0); +} + +/* + * __dbcl_dbclose_common -- + * Common code for closing/cleaning a dbp. + * + * PUBLIC: int __dbcl_dbclose_common __P((DB *)); + */ +int +__dbcl_dbclose_common(dbp) + DB *dbp; +{ + int ret, t_ret; + DBC *dbc; + + /* + * Go through the active cursors and call the cursor recycle routine, + * which resolves pending operations and moves the cursors onto the + * free list. Then, walk the free list and call the cursor destroy + * routine. + * + * NOTE: We do not need to use the join_queue for join cursors. + * See comment in __dbcl_dbjoin_ret. + */ + ret = 0; + while ((dbc = TAILQ_FIRST(&dbp->active_queue)) != NULL) + __dbcl_c_refresh(dbc); + while ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL) + if ((t_ret = __dbcl_c_destroy(dbc)) != 0 && ret == 0) + ret = t_ret; + + TAILQ_INIT(&dbp->free_queue); + TAILQ_INIT(&dbp->active_queue); + + memset(dbp, CLEAR_BYTE, sizeof(*dbp)); + __os_free(dbp, sizeof(*dbp)); + return (ret); +} +#endif /* HAVE_RPC */ diff --git a/db/rpc_client/db_server_clnt.c b/db/rpc_client/db_server_clnt.c new file mode 100644 index 000000000..680a26144 --- /dev/null +++ b/db/rpc_client/db_server_clnt.c @@ -0,0 +1,692 @@ +#include "db_config.h" +#ifdef HAVE_RPC +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#include "db_server.h" + +/* Default timeout can be changed using clnt_control() */ +static struct timeval TIMEOUT = { 25, 0 }; + +__env_cachesize_reply * +__db_env_cachesize_1(argp, clnt) + __env_cachesize_msg *argp; + CLIENT *clnt; +{ + static __env_cachesize_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_cachesize, + (xdrproc_t) xdr___env_cachesize_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_cachesize_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__env_close_reply * +__db_env_close_1(argp, clnt) + __env_close_msg *argp; + CLIENT *clnt; +{ + static __env_close_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_close, + (xdrproc_t) xdr___env_close_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_close_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__env_create_reply * +__db_env_create_1(argp, clnt) + __env_create_msg *argp; + CLIENT *clnt; +{ + static __env_create_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_create, + (xdrproc_t) xdr___env_create_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_create_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__env_flags_reply * +__db_env_flags_1(argp, clnt) + __env_flags_msg *argp; + CLIENT *clnt; +{ + static __env_flags_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_flags, + (xdrproc_t) xdr___env_flags_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_flags_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__env_open_reply * +__db_env_open_1(argp, clnt) + __env_open_msg *argp; + CLIENT *clnt; +{ + static __env_open_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_open, + (xdrproc_t) xdr___env_open_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_open_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__env_remove_reply * +__db_env_remove_1(argp, clnt) + __env_remove_msg *argp; + CLIENT *clnt; +{ + static __env_remove_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_env_remove, + (xdrproc_t) xdr___env_remove_msg, (caddr_t) argp, + (xdrproc_t) xdr___env_remove_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__txn_abort_reply * +__db_txn_abort_1(argp, clnt) + __txn_abort_msg *argp; + CLIENT *clnt; +{ + static __txn_abort_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_txn_abort, + (xdrproc_t) xdr___txn_abort_msg, (caddr_t) argp, + (xdrproc_t) xdr___txn_abort_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__txn_begin_reply * +__db_txn_begin_1(argp, clnt) + __txn_begin_msg *argp; + CLIENT *clnt; +{ + static __txn_begin_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_txn_begin, + (xdrproc_t) xdr___txn_begin_msg, (caddr_t) argp, + (xdrproc_t) xdr___txn_begin_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__txn_commit_reply * +__db_txn_commit_1(argp, clnt) + __txn_commit_msg *argp; + CLIENT *clnt; +{ + static __txn_commit_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_txn_commit, + (xdrproc_t) xdr___txn_commit_msg, (caddr_t) argp, + (xdrproc_t) xdr___txn_commit_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_bt_maxkey_reply * +__db_db_bt_maxkey_1(argp, clnt) + __db_bt_maxkey_msg *argp; + CLIENT *clnt; +{ + static __db_bt_maxkey_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_bt_maxkey, + (xdrproc_t) xdr___db_bt_maxkey_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_bt_maxkey_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_bt_minkey_reply * +__db_db_bt_minkey_1(argp, clnt) + __db_bt_minkey_msg *argp; + CLIENT *clnt; +{ + static __db_bt_minkey_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_bt_minkey, + (xdrproc_t) xdr___db_bt_minkey_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_bt_minkey_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_close_reply * +__db_db_close_1(argp, clnt) + __db_close_msg *argp; + CLIENT *clnt; +{ + static __db_close_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_close, + (xdrproc_t) xdr___db_close_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_close_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_create_reply * +__db_db_create_1(argp, clnt) + __db_create_msg *argp; + CLIENT *clnt; +{ + static __db_create_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_create, + (xdrproc_t) xdr___db_create_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_create_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_del_reply * +__db_db_del_1(argp, clnt) + __db_del_msg *argp; + CLIENT *clnt; +{ + static __db_del_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_del, + (xdrproc_t) xdr___db_del_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_del_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_extentsize_reply * +__db_db_extentsize_1(argp, clnt) + __db_extentsize_msg *argp; + CLIENT *clnt; +{ + static __db_extentsize_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_extentsize, + (xdrproc_t) xdr___db_extentsize_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_extentsize_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_flags_reply * +__db_db_flags_1(argp, clnt) + __db_flags_msg *argp; + CLIENT *clnt; +{ + static __db_flags_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_flags, + (xdrproc_t) xdr___db_flags_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_flags_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_get_reply * +__db_db_get_1(argp, clnt) + __db_get_msg *argp; + CLIENT *clnt; +{ + static __db_get_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_get, + (xdrproc_t) xdr___db_get_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_get_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_h_ffactor_reply * +__db_db_h_ffactor_1(argp, clnt) + __db_h_ffactor_msg *argp; + CLIENT *clnt; +{ + static __db_h_ffactor_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_h_ffactor, + (xdrproc_t) xdr___db_h_ffactor_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_h_ffactor_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_h_nelem_reply * +__db_db_h_nelem_1(argp, clnt) + __db_h_nelem_msg *argp; + CLIENT *clnt; +{ + static __db_h_nelem_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_h_nelem, + (xdrproc_t) xdr___db_h_nelem_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_h_nelem_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_key_range_reply * +__db_db_key_range_1(argp, clnt) + __db_key_range_msg *argp; + CLIENT *clnt; +{ + static __db_key_range_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_key_range, + (xdrproc_t) xdr___db_key_range_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_key_range_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_lorder_reply * +__db_db_lorder_1(argp, clnt) + __db_lorder_msg *argp; + CLIENT *clnt; +{ + static __db_lorder_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_lorder, + (xdrproc_t) xdr___db_lorder_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_lorder_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_open_reply * +__db_db_open_1(argp, clnt) + __db_open_msg *argp; + CLIENT *clnt; +{ + static __db_open_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_open, + (xdrproc_t) xdr___db_open_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_open_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_pagesize_reply * +__db_db_pagesize_1(argp, clnt) + __db_pagesize_msg *argp; + CLIENT *clnt; +{ + static __db_pagesize_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_pagesize, + (xdrproc_t) xdr___db_pagesize_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_pagesize_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_put_reply * +__db_db_put_1(argp, clnt) + __db_put_msg *argp; + CLIENT *clnt; +{ + static __db_put_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_put, + (xdrproc_t) xdr___db_put_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_put_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_re_delim_reply * +__db_db_re_delim_1(argp, clnt) + __db_re_delim_msg *argp; + CLIENT *clnt; +{ + static __db_re_delim_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_re_delim, + (xdrproc_t) xdr___db_re_delim_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_re_delim_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_re_len_reply * +__db_db_re_len_1(argp, clnt) + __db_re_len_msg *argp; + CLIENT *clnt; +{ + static __db_re_len_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_re_len, + (xdrproc_t) xdr___db_re_len_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_re_len_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_re_pad_reply * +__db_db_re_pad_1(argp, clnt) + __db_re_pad_msg *argp; + CLIENT *clnt; +{ + static __db_re_pad_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_re_pad, + (xdrproc_t) xdr___db_re_pad_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_re_pad_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_remove_reply * +__db_db_remove_1(argp, clnt) + __db_remove_msg *argp; + CLIENT *clnt; +{ + static __db_remove_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_remove, + (xdrproc_t) xdr___db_remove_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_remove_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_rename_reply * +__db_db_rename_1(argp, clnt) + __db_rename_msg *argp; + CLIENT *clnt; +{ + static __db_rename_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_rename, + (xdrproc_t) xdr___db_rename_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_rename_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_stat_reply * +__db_db_stat_1(argp, clnt) + __db_stat_msg *argp; + CLIENT *clnt; +{ + static __db_stat_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_stat, + (xdrproc_t) xdr___db_stat_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_stat_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_swapped_reply * +__db_db_swapped_1(argp, clnt) + __db_swapped_msg *argp; + CLIENT *clnt; +{ + static __db_swapped_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_swapped, + (xdrproc_t) xdr___db_swapped_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_swapped_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_sync_reply * +__db_db_sync_1(argp, clnt) + __db_sync_msg *argp; + CLIENT *clnt; +{ + static __db_sync_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_sync, + (xdrproc_t) xdr___db_sync_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_sync_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_cursor_reply * +__db_db_cursor_1(argp, clnt) + __db_cursor_msg *argp; + CLIENT *clnt; +{ + static __db_cursor_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_cursor, + (xdrproc_t) xdr___db_cursor_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_cursor_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__db_join_reply * +__db_db_join_1(argp, clnt) + __db_join_msg *argp; + CLIENT *clnt; +{ + static __db_join_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_db_join, + (xdrproc_t) xdr___db_join_msg, (caddr_t) argp, + (xdrproc_t) xdr___db_join_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_close_reply * +__db_dbc_close_1(argp, clnt) + __dbc_close_msg *argp; + CLIENT *clnt; +{ + static __dbc_close_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_close, + (xdrproc_t) xdr___dbc_close_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_close_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_count_reply * +__db_dbc_count_1(argp, clnt) + __dbc_count_msg *argp; + CLIENT *clnt; +{ + static __dbc_count_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_count, + (xdrproc_t) xdr___dbc_count_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_count_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_del_reply * +__db_dbc_del_1(argp, clnt) + __dbc_del_msg *argp; + CLIENT *clnt; +{ + static __dbc_del_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_del, + (xdrproc_t) xdr___dbc_del_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_del_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_dup_reply * +__db_dbc_dup_1(argp, clnt) + __dbc_dup_msg *argp; + CLIENT *clnt; +{ + static __dbc_dup_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_dup, + (xdrproc_t) xdr___dbc_dup_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_dup_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_get_reply * +__db_dbc_get_1(argp, clnt) + __dbc_get_msg *argp; + CLIENT *clnt; +{ + static __dbc_get_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_get, + (xdrproc_t) xdr___dbc_get_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_get_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +__dbc_put_reply * +__db_dbc_put_1(argp, clnt) + __dbc_put_msg *argp; + CLIENT *clnt; +{ + static __dbc_put_reply clnt_res; + + memset((char *)&clnt_res, 0, sizeof (clnt_res)); + if (clnt_call(clnt, __DB_dbc_put, + (xdrproc_t) xdr___dbc_put_msg, (caddr_t) argp, + (xdrproc_t) xdr___dbc_put_reply, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} +#endif /* HAVE_RPC */ diff --git a/db/rpc_client/gen_client.c b/db/rpc_client/gen_client.c new file mode 100644 index 000000000..7cc598e7d --- /dev/null +++ b/db/rpc_client/gen_client.c @@ -0,0 +1,2494 @@ +/* Do not edit: automatically built by gen_rpc.awk. */ +#include "db_config.h" + +#ifdef HAVE_RPC +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> +#include <rpc/rpc.h> +#include <rpc/xdr.h> + +#include <errno.h> +#include <string.h> +#endif +#include "db_server.h" + +#include "db_int.h" +#include "db_page.h" +#include "db_ext.h" +#include "mp.h" +#include "rpc_client_ext.h" +#include "txn.h" + +#include "gen_client_ext.h" + +int +__dbcl_env_cachesize(dbenv, gbytes, bytes, ncache) + DB_ENV * dbenv; + u_int32_t gbytes; + u_int32_t bytes; + int ncache; +{ + CLIENT *cl; + __env_cachesize_msg req; + static __env_cachesize_reply *replyp = NULL; + int ret; + + ret = 0; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___env_cachesize_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbenv == NULL) + req.dbenvcl_id = 0; + else + req.dbenvcl_id = dbenv->cl_id; + req.gbytes = gbytes; + req.bytes = bytes; + req.ncache = ncache; + + replyp = __db_env_cachesize_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_env_close(dbenv, flags) + DB_ENV * dbenv; + u_int32_t flags; +{ + CLIENT *cl; + __env_close_msg req; + static __env_close_reply *replyp = NULL; + int ret; + + ret = 0; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___env_close_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbenv == NULL) + req.dbenvcl_id = 0; + else + req.dbenvcl_id = dbenv->cl_id; + req.flags = flags; + + replyp = __db_env_close_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_env_close_ret(dbenv, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_rpc_illegal(dbenv, name) + DB_ENV *dbenv; + char *name; +{ + __db_err(dbenv, + "%s method meaningless in RPC environment", name); + return (__db_eopnotsup(dbenv)); +} + +int +__dbcl_set_data_dir(dbenv, dir) + DB_ENV * dbenv; + const char * dir; +{ + COMPQUIET(dir, NULL); + return (__dbcl_rpc_illegal(dbenv, "set_data_dir")); +} + +int +__dbcl_env_set_feedback(dbenv, func0) + DB_ENV * dbenv; + void (*func0) __P((DB_ENV *, int, int)); +{ + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "env_set_feedback")); +} + +int +__dbcl_env_flags(dbenv, flags, onoff) + DB_ENV * dbenv; + u_int32_t flags; + int onoff; +{ + CLIENT *cl; + __env_flags_msg req; + static __env_flags_reply *replyp = NULL; + int ret; + + ret = 0; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___env_flags_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbenv == NULL) + req.dbenvcl_id = 0; + else + req.dbenvcl_id = dbenv->cl_id; + req.flags = flags; + req.onoff = onoff; + + replyp = __db_env_flags_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_set_lg_bsize(dbenv, bsize) + DB_ENV * dbenv; + u_int32_t bsize; +{ + COMPQUIET(bsize, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lg_bsize")); +} + +int +__dbcl_set_lg_dir(dbenv, dir) + DB_ENV * dbenv; + const char * dir; +{ + COMPQUIET(dir, NULL); + return (__dbcl_rpc_illegal(dbenv, "set_lg_dir")); +} + +int +__dbcl_set_lg_max(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lg_max")); +} + +int +__dbcl_set_lk_conflict(dbenv, conflicts, modes) + DB_ENV * dbenv; + u_int8_t * conflicts; + int modes; +{ + COMPQUIET(conflicts, 0); + COMPQUIET(modes, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_conflict")); +} + +int +__dbcl_set_lk_detect(dbenv, detect) + DB_ENV * dbenv; + u_int32_t detect; +{ + COMPQUIET(detect, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_detect")); +} + +int +__dbcl_set_lk_max(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_max")); +} + +int +__dbcl_set_lk_max_locks(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_max_locks")); +} + +int +__dbcl_set_lk_max_lockers(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_max_lockers")); +} + +int +__dbcl_set_lk_max_objects(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_lk_max_objects")); +} + +int +__dbcl_set_mp_mmapsize(dbenv, mmapsize) + DB_ENV * dbenv; + size_t mmapsize; +{ + COMPQUIET(mmapsize, 0); + return (__dbcl_rpc_illegal(dbenv, "set_mp_mmapsize")); +} + +int +__dbcl_set_mutex_locks(dbenv, do_lock) + DB_ENV * dbenv; + int do_lock; +{ + COMPQUIET(do_lock, 0); + return (__dbcl_rpc_illegal(dbenv, "set_mutex_locks")); +} + +int +__dbcl_env_open(dbenv, home, flags, mode) + DB_ENV * dbenv; + const char * home; + u_int32_t flags; + int mode; +{ + CLIENT *cl; + __env_open_msg req; + static __env_open_reply *replyp = NULL; + int ret; + + ret = 0; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___env_open_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbenv == NULL) + req.dbenvcl_id = 0; + else + req.dbenvcl_id = dbenv->cl_id; + if (home == NULL) + req.home = ""; + else + req.home = (char *)home; + req.flags = flags; + req.mode = mode; + + replyp = __db_env_open_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_env_open_ret(dbenv, home, flags, mode, replyp)); +out: + return (ret); +} + +int +__dbcl_env_paniccall(dbenv, func0) + DB_ENV * dbenv; + void (*func0) __P((DB_ENV *, int)); +{ + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "env_paniccall")); +} + +int +__dbcl_set_recovery_init(dbenv, func0) + DB_ENV * dbenv; + int (*func0) __P((DB_ENV *)); +{ + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "set_recovery_init")); +} + +int +__dbcl_env_remove(dbenv, home, flags) + DB_ENV * dbenv; + const char * home; + u_int32_t flags; +{ + CLIENT *cl; + __env_remove_msg req; + static __env_remove_reply *replyp = NULL; + int ret; + + ret = 0; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___env_remove_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbenv == NULL) + req.dbenvcl_id = 0; + else + req.dbenvcl_id = dbenv->cl_id; + if (home == NULL) + req.home = ""; + else + req.home = (char *)home; + req.flags = flags; + + replyp = __db_env_remove_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_env_remove_ret(dbenv, home, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_set_shm_key(dbenv, shm_key) + DB_ENV * dbenv; + long shm_key; +{ + COMPQUIET(shm_key, 0); + return (__dbcl_rpc_illegal(dbenv, "set_shm_key")); +} + +int +__dbcl_set_tmp_dir(dbenv, dir) + DB_ENV * dbenv; + const char * dir; +{ + COMPQUIET(dir, NULL); + return (__dbcl_rpc_illegal(dbenv, "set_tmp_dir")); +} + +int +__dbcl_set_tx_recover(dbenv, func0) + DB_ENV * dbenv; + int (*func0) __P((DB_ENV *, DBT *, DB_LSN *, db_recops)); +{ + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "set_tx_recover")); +} + +int +__dbcl_set_tx_max(dbenv, max) + DB_ENV * dbenv; + u_int32_t max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_tx_max")); +} + +int +__dbcl_set_tx_timestamp(dbenv, max) + DB_ENV * dbenv; + time_t * max; +{ + COMPQUIET(max, 0); + return (__dbcl_rpc_illegal(dbenv, "set_tx_timestamp")); +} + +int +__dbcl_set_verbose(dbenv, which, onoff) + DB_ENV * dbenv; + u_int32_t which; + int onoff; +{ + COMPQUIET(which, 0); + COMPQUIET(onoff, 0); + return (__dbcl_rpc_illegal(dbenv, "set_verbose")); +} + +int +__dbcl_txn_abort(txnp) + DB_TXN * txnp; +{ + CLIENT *cl; + __txn_abort_msg req; + static __txn_abort_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = txnp->mgrp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___txn_abort_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + + replyp = __db_txn_abort_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_txn_abort_ret(txnp, replyp)); +out: + return (ret); +} + +int +__dbcl_txn_begin(envp, parent, txnpp, flags) + DB_ENV * envp; + DB_TXN * parent; + DB_TXN ** txnpp; + u_int32_t flags; +{ + CLIENT *cl; + __txn_begin_msg req; + static __txn_begin_reply *replyp = NULL; + int ret; + + ret = 0; + if (envp == NULL || envp->cl_handle == NULL) { + __db_err(envp, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___txn_begin_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)envp->cl_handle; + + if (envp == NULL) + req.envpcl_id = 0; + else + req.envpcl_id = envp->cl_id; + if (parent == NULL) + req.parentcl_id = 0; + else + req.parentcl_id = parent->txnid; + req.flags = flags; + + replyp = __db_txn_begin_1(&req, cl); + if (replyp == NULL) { + __db_err(envp, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_txn_begin_ret(envp, parent, txnpp, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_txn_checkpoint(dbenv, kbyte, min) + DB_ENV * dbenv; + u_int32_t kbyte; + u_int32_t min; +{ + COMPQUIET(kbyte, 0); + COMPQUIET(min, 0); + return (__dbcl_rpc_illegal(dbenv, "txn_checkpoint")); +} + +int +__dbcl_txn_commit(txnp, flags) + DB_TXN * txnp; + u_int32_t flags; +{ + CLIENT *cl; + __txn_commit_msg req; + static __txn_commit_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = txnp->mgrp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___txn_commit_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.flags = flags; + + replyp = __db_txn_commit_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_txn_commit_ret(txnp, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_txn_prepare(txnp) + DB_TXN * txnp; +{ + DB_ENV *dbenv; + + dbenv = txnp->mgrp->dbenv; + return (__dbcl_rpc_illegal(dbenv, "txn_prepare")); +} + +int +__dbcl_txn_stat(dbenv, statp, func0) + DB_ENV * dbenv; + DB_TXN_STAT ** statp; + void *(*func0) __P((size_t)); +{ + COMPQUIET(statp, 0); + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "txn_stat")); +} + +int +__dbcl_db_bt_compare(dbp, func0) + DB * dbp; + int (*func0) __P((DB *, const DBT *, const DBT *)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_bt_compare")); +} + +int +__dbcl_db_bt_maxkey(dbp, maxkey) + DB * dbp; + u_int32_t maxkey; +{ + CLIENT *cl; + __db_bt_maxkey_msg req; + static __db_bt_maxkey_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_bt_maxkey_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.maxkey = maxkey; + + replyp = __db_db_bt_maxkey_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_bt_minkey(dbp, minkey) + DB * dbp; + u_int32_t minkey; +{ + CLIENT *cl; + __db_bt_minkey_msg req; + static __db_bt_minkey_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_bt_minkey_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.minkey = minkey; + + replyp = __db_db_bt_minkey_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_bt_prefix(dbp, func0) + DB * dbp; + size_t (*func0) __P((DB *, const DBT *, const DBT *)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_bt_prefix")); +} + +int +__dbcl_db_set_append_recno(dbp, func0) + DB * dbp; + int (*func0) __P((DB *, DBT *, db_recno_t)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_set_append_recno")); +} + +int +__dbcl_db_cachesize(dbp, gbytes, bytes, ncache) + DB * dbp; + u_int32_t gbytes; + u_int32_t bytes; + int ncache; +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(gbytes, 0); + COMPQUIET(bytes, 0); + COMPQUIET(ncache, 0); + return (__dbcl_rpc_illegal(dbenv, "db_cachesize")); +} + +int +__dbcl_db_close(dbp, flags) + DB * dbp; + u_int32_t flags; +{ + CLIENT *cl; + __db_close_msg req; + static __db_close_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_close_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.flags = flags; + + replyp = __db_db_close_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_close_ret(dbp, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_del(dbp, txnp, key, flags) + DB * dbp; + DB_TXN * txnp; + DBT * key; + u_int32_t flags; +{ + CLIENT *cl; + __db_del_msg req; + static __db_del_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_del_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.flags = flags; + + replyp = __db_db_del_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_extentsize(dbp, extentsize) + DB * dbp; + u_int32_t extentsize; +{ + CLIENT *cl; + __db_extentsize_msg req; + static __db_extentsize_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_extentsize_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.extentsize = extentsize; + + replyp = __db_db_extentsize_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_fd(dbp, fdp) + DB * dbp; + int * fdp; +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(fdp, 0); + return (__dbcl_rpc_illegal(dbenv, "db_fd")); +} + +int +__dbcl_db_feedback(dbp, func0) + DB * dbp; + void (*func0) __P((DB *, int, int)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_feedback")); +} + +int +__dbcl_db_flags(dbp, flags) + DB * dbp; + u_int32_t flags; +{ + CLIENT *cl; + __db_flags_msg req; + static __db_flags_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_flags_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.flags = flags; + + replyp = __db_db_flags_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_get(dbp, txnp, key, data, flags) + DB * dbp; + DB_TXN * txnp; + DBT * key; + DBT * data; + u_int32_t flags; +{ + CLIENT *cl; + __db_get_msg req; + static __db_get_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_get_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.datadlen = data->dlen; + req.datadoff = data->doff; + req.dataflags = data->flags; + req.datadata.datadata_val = data->data; + req.datadata.datadata_len = data->size; + req.flags = flags; + + replyp = __db_db_get_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_h_ffactor(dbp, ffactor) + DB * dbp; + u_int32_t ffactor; +{ + CLIENT *cl; + __db_h_ffactor_msg req; + static __db_h_ffactor_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_h_ffactor_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.ffactor = ffactor; + + replyp = __db_db_h_ffactor_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_h_hash(dbp, func0) + DB * dbp; + u_int32_t (*func0) __P((DB *, const void *, u_int32_t)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_h_hash")); +} + +int +__dbcl_db_h_nelem(dbp, nelem) + DB * dbp; + u_int32_t nelem; +{ + CLIENT *cl; + __db_h_nelem_msg req; + static __db_h_nelem_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_h_nelem_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.nelem = nelem; + + replyp = __db_db_h_nelem_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_key_range(dbp, txnp, key, range, flags) + DB * dbp; + DB_TXN * txnp; + DBT * key; + DB_KEY_RANGE * range; + u_int32_t flags; +{ + CLIENT *cl; + __db_key_range_msg req; + static __db_key_range_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_key_range_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.flags = flags; + + replyp = __db_db_key_range_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_lorder(dbp, lorder) + DB * dbp; + int lorder; +{ + CLIENT *cl; + __db_lorder_msg req; + static __db_lorder_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_lorder_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.lorder = lorder; + + replyp = __db_db_lorder_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_malloc(dbp, func0) + DB * dbp; + void *(*func0) __P((size_t)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_malloc")); +} + +int +__dbcl_db_open(dbp, name, subdb, type, flags, mode) + DB * dbp; + const char * name; + const char * subdb; + DBTYPE type; + u_int32_t flags; + int mode; +{ + CLIENT *cl; + __db_open_msg req; + static __db_open_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_open_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (name == NULL) + req.name = ""; + else + req.name = (char *)name; + if (subdb == NULL) + req.subdb = ""; + else + req.subdb = (char *)subdb; + req.type = type; + req.flags = flags; + req.mode = mode; + + replyp = __db_db_open_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_open_ret(dbp, name, subdb, type, flags, mode, replyp)); +out: + return (ret); +} + +int +__dbcl_db_pagesize(dbp, pagesize) + DB * dbp; + u_int32_t pagesize; +{ + CLIENT *cl; + __db_pagesize_msg req; + static __db_pagesize_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_pagesize_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.pagesize = pagesize; + + replyp = __db_db_pagesize_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_panic(dbp, func0) + DB * dbp; + void (*func0) __P((DB_ENV *, int)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_panic")); +} + +int +__dbcl_db_put(dbp, txnp, key, data, flags) + DB * dbp; + DB_TXN * txnp; + DBT * key; + DBT * data; + u_int32_t flags; +{ + CLIENT *cl; + __db_put_msg req; + static __db_put_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_put_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.datadlen = data->dlen; + req.datadoff = data->doff; + req.dataflags = data->flags; + req.datadata.datadata_val = data->data; + req.datadata.datadata_len = data->size; + req.flags = flags; + + replyp = __db_db_put_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_realloc(dbp, func0) + DB * dbp; + void *(*func0) __P((void *, size_t)); +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "db_realloc")); +} + +int +__dbcl_db_re_delim(dbp, delim) + DB * dbp; + int delim; +{ + CLIENT *cl; + __db_re_delim_msg req; + static __db_re_delim_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_re_delim_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.delim = delim; + + replyp = __db_db_re_delim_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_re_len(dbp, len) + DB * dbp; + u_int32_t len; +{ + CLIENT *cl; + __db_re_len_msg req; + static __db_re_len_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_re_len_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.len = len; + + replyp = __db_db_re_len_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_re_pad(dbp, pad) + DB * dbp; + int pad; +{ + CLIENT *cl; + __db_re_pad_msg req; + static __db_re_pad_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_re_pad_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.pad = pad; + + replyp = __db_db_re_pad_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_re_source(dbp, re_source) + DB * dbp; + const char * re_source; +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(re_source, NULL); + return (__dbcl_rpc_illegal(dbenv, "db_re_source")); +} + +int +__dbcl_db_remove(dbp, name, subdb, flags) + DB * dbp; + const char * name; + const char * subdb; + u_int32_t flags; +{ + CLIENT *cl; + __db_remove_msg req; + static __db_remove_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_remove_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (name == NULL) + req.name = ""; + else + req.name = (char *)name; + if (subdb == NULL) + req.subdb = ""; + else + req.subdb = (char *)subdb; + req.flags = flags; + + replyp = __db_db_remove_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_remove_ret(dbp, name, subdb, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_rename(dbp, name, subdb, newname, flags) + DB * dbp; + const char * name; + const char * subdb; + const char * newname; + u_int32_t flags; +{ + CLIENT *cl; + __db_rename_msg req; + static __db_rename_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_rename_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (name == NULL) + req.name = ""; + else + req.name = (char *)name; + if (subdb == NULL) + req.subdb = ""; + else + req.subdb = (char *)subdb; + if (newname == NULL) + req.newname = ""; + else + req.newname = (char *)newname; + req.flags = flags; + + replyp = __db_db_rename_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_stat(dbp, sp, func0, flags) + DB * dbp; + void * sp; + void *(*func0) __P((size_t)); + u_int32_t flags; +{ + CLIENT *cl; + __db_stat_msg req; + static __db_stat_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (func0 != NULL) { + __db_err(sp, "User functions not supported in RPC."); + return (EINVAL); + } + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.flags = flags; + + replyp = __db_db_stat_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_stat_ret(dbp, sp, func0, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_db_swapped(dbp) + DB * dbp; +{ + CLIENT *cl; + __db_swapped_msg req; + static __db_swapped_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_swapped_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + + replyp = __db_db_swapped_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_sync(dbp, flags) + DB * dbp; + u_int32_t flags; +{ + CLIENT *cl; + __db_sync_msg req; + static __db_sync_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_sync_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + req.flags = flags; + + replyp = __db_db_sync_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_db_upgrade(dbp, fname, flags) + DB * dbp; + const char * fname; + u_int32_t flags; +{ + DB_ENV *dbenv; + + dbenv = dbp->dbenv; + COMPQUIET(fname, NULL); + COMPQUIET(flags, 0); + return (__dbcl_rpc_illegal(dbenv, "db_upgrade")); +} + +int +__dbcl_db_cursor(dbp, txnp, dbcpp, flags) + DB * dbp; + DB_TXN * txnp; + DBC ** dbcpp; + u_int32_t flags; +{ + CLIENT *cl; + __db_cursor_msg req; + static __db_cursor_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_cursor_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if (txnp == NULL) + req.txnpcl_id = 0; + else + req.txnpcl_id = txnp->txnid; + req.flags = flags; + + replyp = __db_db_cursor_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp)); +out: + return (ret); +} + +static int __dbcl_db_join_curslist __P((__db_join_curslist **, DBC **)); +static void __dbcl_db_join_cursfree __P((__db_join_curslist **)); +int +__dbcl_db_join(dbp, curs, dbcp, flags) + DB * dbp; + DBC ** curs; + DBC ** dbcp; + u_int32_t flags; +{ + CLIENT *cl; + __db_join_msg req; + static __db_join_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___db_join_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbp == NULL) + req.dbpcl_id = 0; + else + req.dbpcl_id = dbp->cl_id; + if ((ret = __dbcl_db_join_curslist(&req.curslist, curs)) != 0) + goto out; + req.flags = flags; + + replyp = __db_db_join_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + __dbcl_db_join_cursfree(&req.curslist); + return (__dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp)); +out: + __dbcl_db_join_cursfree(&req.curslist); + return (ret); +} + +int +__dbcl_db_join_curslist(locp, pp) + __db_join_curslist **locp; + DBC ** pp; +{ + DBC ** p; + u_int32_t *q; + int ret; + __db_join_curslist *nl, **nlp; + + *locp = NULL; + if (pp == NULL) + return (0); + nlp = locp; + for (p = pp; *p != 0; p++) { + if ((ret = __os_malloc(NULL, sizeof(*nl), NULL, nlp)) != 0) + goto out; + nl = *nlp; + nl->next = NULL; + nl->ent.ent_val = NULL; + nl->ent.ent_len = 0; + if ((ret = __os_malloc(NULL, sizeof(u_int32_t), NULL, &nl->ent.ent_val)) != 0) + goto out; + q = (u_int32_t *)nl->ent.ent_val; + *q = (*p)->cl_id; + nl->ent.ent_len = sizeof(u_int32_t); + nlp = &nl->next; + } + return (0); +out: + __dbcl_db_join_cursfree(locp); + return (ret); +} + +void +__dbcl_db_join_cursfree(locp) + __db_join_curslist **locp; +{ + __db_join_curslist *nl, *nl1; + + if (locp == NULL) + return; + for (nl = *locp; nl != NULL; nl = nl1) { + nl1 = nl->next; + if (nl->ent.ent_val) + __os_free(nl->ent.ent_val, nl->ent.ent_len); + __os_free(nl, sizeof(*nl)); + } +} + +int +__dbcl_dbc_close(dbc) + DBC * dbc; +{ + CLIENT *cl; + __dbc_close_msg req; + static __dbc_close_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_close_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + + replyp = __db_dbc_close_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_dbc_close_ret(dbc, replyp)); +out: + return (ret); +} + +int +__dbcl_dbc_count(dbc, countp, flags) + DBC * dbc; + db_recno_t * countp; + u_int32_t flags; +{ + CLIENT *cl; + __dbc_count_msg req; + static __dbc_count_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_count_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + req.flags = flags; + + replyp = __db_dbc_count_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_dbc_count_ret(dbc, countp, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_dbc_del(dbc, flags) + DBC * dbc; + u_int32_t flags; +{ + CLIENT *cl; + __dbc_del_msg req; + static __dbc_del_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_del_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + req.flags = flags; + + replyp = __db_dbc_del_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + ret = replyp->status; +out: + return (ret); +} + +int +__dbcl_dbc_dup(dbc, dbcp, flags) + DBC * dbc; + DBC ** dbcp; + u_int32_t flags; +{ + CLIENT *cl; + __dbc_dup_msg req; + static __dbc_dup_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_dup_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + req.flags = flags; + + replyp = __db_dbc_dup_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_dbc_get(dbc, key, data, flags) + DBC * dbc; + DBT * key; + DBT * data; + u_int32_t flags; +{ + CLIENT *cl; + __dbc_get_msg req; + static __dbc_get_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.datadlen = data->dlen; + req.datadoff = data->doff; + req.dataflags = data->flags; + req.datadata.datadata_val = data->data; + req.datadata.datadata_len = data->size; + req.flags = flags; + + replyp = __db_dbc_get_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_dbc_get_ret(dbc, key, data, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_dbc_put(dbc, key, data, flags) + DBC * dbc; + DBT * key; + DBT * data; + u_int32_t flags; +{ + CLIENT *cl; + __dbc_put_msg req; + static __dbc_put_reply *replyp = NULL; + int ret; + DB_ENV *dbenv; + + ret = 0; + dbenv = NULL; + dbenv = dbc->dbp->dbenv; + if (dbenv == NULL || dbenv->cl_handle == NULL) { + __db_err(dbenv, "No server environment."); + return (DB_NOSERVER); + } + + if (replyp != NULL) { + xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)replyp); + replyp = NULL; + } + cl = (CLIENT *)dbenv->cl_handle; + + if (dbc == NULL) + req.dbccl_id = 0; + else + req.dbccl_id = dbc->cl_id; + req.keydlen = key->dlen; + req.keydoff = key->doff; + req.keyflags = key->flags; + req.keydata.keydata_val = key->data; + req.keydata.keydata_len = key->size; + req.datadlen = data->dlen; + req.datadoff = data->doff; + req.dataflags = data->flags; + req.datadata.datadata_val = data->data; + req.datadata.datadata_len = data->size; + req.flags = flags; + + replyp = __db_dbc_put_1(&req, cl); + if (replyp == NULL) { + __db_err(dbenv, clnt_sperror(cl, "Berkeley DB")); + ret = DB_NOSERVER; + goto out; + } + return (__dbcl_dbc_put_ret(dbc, key, data, flags, replyp)); +out: + return (ret); +} + +int +__dbcl_lock_detect(dbenv, flags, atype, aborted) + DB_ENV * dbenv; + u_int32_t flags; + u_int32_t atype; + int * aborted; +{ + COMPQUIET(flags, 0); + COMPQUIET(atype, 0); + COMPQUIET(aborted, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_detect")); +} + +int +__dbcl_lock_get(dbenv, locker, flags, obj, mode, lock) + DB_ENV * dbenv; + u_int32_t locker; + u_int32_t flags; + const DBT * obj; + db_lockmode_t mode; + DB_LOCK * lock; +{ + COMPQUIET(locker, 0); + COMPQUIET(flags, 0); + COMPQUIET(obj, NULL); + COMPQUIET(mode, 0); + COMPQUIET(lock, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_get")); +} + +int +__dbcl_lock_id(dbenv, idp) + DB_ENV * dbenv; + u_int32_t * idp; +{ + COMPQUIET(idp, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_id")); +} + +int +__dbcl_lock_put(dbenv, lock) + DB_ENV * dbenv; + DB_LOCK * lock; +{ + COMPQUIET(lock, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_put")); +} + +int +__dbcl_lock_stat(dbenv, statp, func0) + DB_ENV * dbenv; + DB_LOCK_STAT ** statp; + void *(*func0) __P((size_t)); +{ + COMPQUIET(statp, 0); + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_stat")); +} + +int +__dbcl_lock_vec(dbenv, locker, flags, list, nlist, elistp) + DB_ENV * dbenv; + u_int32_t locker; + u_int32_t flags; + DB_LOCKREQ * list; + int nlist; + DB_LOCKREQ ** elistp; +{ + COMPQUIET(locker, 0); + COMPQUIET(flags, 0); + COMPQUIET(list, 0); + COMPQUIET(nlist, 0); + COMPQUIET(elistp, 0); + return (__dbcl_rpc_illegal(dbenv, "lock_vec")); +} + +int +__dbcl_log_archive(dbenv, listp, flags, func0) + DB_ENV * dbenv; + char *** listp; + u_int32_t flags; + void *(*func0) __P((size_t)); +{ + COMPQUIET(listp, 0); + COMPQUIET(flags, 0); + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "log_archive")); +} + +int +__dbcl_log_file(dbenv, lsn, namep, len) + DB_ENV * dbenv; + const DB_LSN * lsn; + char * namep; + size_t len; +{ + COMPQUIET(lsn, NULL); + COMPQUIET(namep, NULL); + COMPQUIET(len, 0); + return (__dbcl_rpc_illegal(dbenv, "log_file")); +} + +int +__dbcl_log_flush(dbenv, lsn) + DB_ENV * dbenv; + const DB_LSN * lsn; +{ + COMPQUIET(lsn, NULL); + return (__dbcl_rpc_illegal(dbenv, "log_flush")); +} + +int +__dbcl_log_get(dbenv, lsn, data, flags) + DB_ENV * dbenv; + DB_LSN * lsn; + DBT * data; + u_int32_t flags; +{ + COMPQUIET(lsn, 0); + COMPQUIET(data, NULL); + COMPQUIET(flags, 0); + return (__dbcl_rpc_illegal(dbenv, "log_get")); +} + +int +__dbcl_log_put(dbenv, lsn, data, flags) + DB_ENV * dbenv; + DB_LSN * lsn; + const DBT * data; + u_int32_t flags; +{ + COMPQUIET(lsn, 0); + COMPQUIET(data, NULL); + COMPQUIET(flags, 0); + return (__dbcl_rpc_illegal(dbenv, "log_put")); +} + +int +__dbcl_log_register(dbenv, dbp, namep) + DB_ENV * dbenv; + DB * dbp; + const char * namep; +{ + COMPQUIET(dbp, 0); + COMPQUIET(namep, NULL); + return (__dbcl_rpc_illegal(dbenv, "log_register")); +} + +int +__dbcl_log_stat(dbenv, statp, func0) + DB_ENV * dbenv; + DB_LOG_STAT ** statp; + void *(*func0) __P((size_t)); +{ + COMPQUIET(statp, 0); + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "log_stat")); +} + +int +__dbcl_log_unregister(dbenv, dbp) + DB_ENV * dbenv; + DB * dbp; +{ + COMPQUIET(dbp, 0); + return (__dbcl_rpc_illegal(dbenv, "log_unregister")); +} + +int +__dbcl_memp_fclose(mpf) + DB_MPOOLFILE * mpf; +{ + DB_ENV *dbenv; + + dbenv = mpf->dbmp->dbenv; + return (__dbcl_rpc_illegal(dbenv, "memp_fclose")); +} + +int +__dbcl_memp_fget(mpf, pgno, flags, pagep) + DB_MPOOLFILE * mpf; + db_pgno_t * pgno; + u_int32_t flags; + void ** pagep; +{ + DB_ENV *dbenv; + + dbenv = mpf->dbmp->dbenv; + COMPQUIET(pgno, 0); + COMPQUIET(flags, 0); + COMPQUIET(pagep, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_fget")); +} + +int +__dbcl_memp_fopen(dbenv, file, flags, mode, pagesize, finfop, mpf) + DB_ENV * dbenv; + const char * file; + u_int32_t flags; + int mode; + size_t pagesize; + DB_MPOOL_FINFO * finfop; + DB_MPOOLFILE ** mpf; +{ + COMPQUIET(file, NULL); + COMPQUIET(flags, 0); + COMPQUIET(mode, 0); + COMPQUIET(pagesize, 0); + COMPQUIET(finfop, 0); + COMPQUIET(mpf, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_fopen")); +} + +int +__dbcl_memp_fput(mpf, pgaddr, flags) + DB_MPOOLFILE * mpf; + void * pgaddr; + u_int32_t flags; +{ + DB_ENV *dbenv; + + dbenv = mpf->dbmp->dbenv; + COMPQUIET(pgaddr, 0); + COMPQUIET(flags, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_fput")); +} + +int +__dbcl_memp_fset(mpf, pgaddr, flags) + DB_MPOOLFILE * mpf; + void * pgaddr; + u_int32_t flags; +{ + DB_ENV *dbenv; + + dbenv = mpf->dbmp->dbenv; + COMPQUIET(pgaddr, 0); + COMPQUIET(flags, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_fset")); +} + +int +__dbcl_memp_fsync(mpf) + DB_MPOOLFILE * mpf; +{ + DB_ENV *dbenv; + + dbenv = mpf->dbmp->dbenv; + return (__dbcl_rpc_illegal(dbenv, "memp_fsync")); +} + +int +__dbcl_memp_register(dbenv, ftype, func0, func1) + DB_ENV * dbenv; + int ftype; + int (*func0) __P((DB_ENV *, db_pgno_t, void *, DBT *)); + int (*func1) __P((DB_ENV *, db_pgno_t, void *, DBT *)); +{ + COMPQUIET(ftype, 0); + COMPQUIET(func0, 0); + COMPQUIET(func1, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_register")); +} + +int +__dbcl_memp_stat(dbenv, gstatp, fstatp, func0) + DB_ENV * dbenv; + DB_MPOOL_STAT ** gstatp; + DB_MPOOL_FSTAT *** fstatp; + void *(*func0) __P((size_t)); +{ + COMPQUIET(gstatp, 0); + COMPQUIET(fstatp, 0); + COMPQUIET(func0, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_stat")); +} + +int +__dbcl_memp_sync(dbenv, lsn) + DB_ENV * dbenv; + DB_LSN * lsn; +{ + COMPQUIET(lsn, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_sync")); +} + +int +__dbcl_memp_trickle(dbenv, pct, nwrotep) + DB_ENV * dbenv; + int pct; + int * nwrotep; +{ + COMPQUIET(pct, 0); + COMPQUIET(nwrotep, 0); + return (__dbcl_rpc_illegal(dbenv, "memp_trickle")); +} + +#endif /* HAVE_RPC */ diff --git a/db/rpc_client/gen_client_ret.c b/db/rpc_client/gen_client_ret.c new file mode 100644 index 000000000..17e3f195f --- /dev/null +++ b/db/rpc_client/gen_client_ret.c @@ -0,0 +1,542 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000 + * Sleepycat Software. All rights reserved. + */ + +#include "db_config.h" + +#ifndef lint +static const char revid[] = "$Id: gen_client_ret.c,v 1.29 2000/12/31 19:26:23 bostic Exp $"; +#endif /* not lint */ + +#ifdef HAVE_RPC +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <rpc/rpc.h> + +#include <string.h> +#endif +#include "db_server.h" + +#include "db_int.h" +#include "db_page.h" +#include "txn.h" +#include "db_ext.h" +#include "rpc_client_ext.h" + +static void __db_db_stat_statsfree __P((u_int32_t *)); +static int __db_db_stat_statslist __P((__db_stat_statsreplist *, u_int32_t **)); + +int +__dbcl_env_close_ret(dbenv, flags, replyp) + DB_ENV *dbenv; + u_int32_t flags; + __env_close_reply *replyp; +{ + int ret; + + COMPQUIET(flags, 0); + + ret = __dbcl_refresh(dbenv); + __os_free(dbenv, sizeof(*dbenv)); + if (replyp->status == 0 && ret != 0) + return (ret); + else + return (replyp->status); +} + +int +__dbcl_env_open_ret(dbenv, home, flags, mode, replyp) + DB_ENV *dbenv; + const char *home; + u_int32_t flags; + int mode; + __env_open_reply *replyp; +{ + DB_TXNMGR *tmgrp; + int ret; + + COMPQUIET(home, NULL); + COMPQUIET(mode, 0); + + /* + * If error, return it. + */ + if (replyp->status != 0) + return (replyp->status); + + /* + * If the user requested transactions, then we have some + * local client-side setup to do also. + */ + if (LF_ISSET(DB_INIT_TXN)) { + if ((ret = __os_calloc(dbenv, + 1, sizeof(DB_TXNMGR), &tmgrp)) != 0) + return (ret); + TAILQ_INIT(&tmgrp->txn_chain); + tmgrp->dbenv = dbenv; + dbenv->tx_handle = tmgrp; + } + + return (replyp->status); +} + +int +__dbcl_env_remove_ret(dbenv, home, flags, replyp) + DB_ENV *dbenv; + const char *home; + u_int32_t flags; + __env_remove_reply *replyp; +{ + int ret; + + COMPQUIET(home, NULL); + COMPQUIET(flags, 0); + + ret = __dbcl_refresh(dbenv); + __os_free(dbenv, sizeof(*dbenv)); + if (replyp->status == 0 && ret != 0) + return (ret); + else + return (replyp->status); +} + +int +__dbcl_txn_abort_ret(txnp, replyp) + DB_TXN *txnp; + __txn_abort_reply *replyp; +{ + __dbcl_txn_end(txnp); + return (replyp->status); +} + +int +__dbcl_txn_begin_ret(envp, parent, txnpp, flags, replyp) + DB_ENV *envp; + DB_TXN *parent, **txnpp; + u_int32_t flags; + __txn_begin_reply *replyp; +{ + DB_TXN *txn; + int ret; + + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + + if ((ret = __os_calloc(envp, 1, sizeof(DB_TXN), &txn)) != 0) + return (ret); + txn->txnid = replyp->txnidcl_id; + txn->mgrp = envp->tx_handle; + txn->parent = parent; + TAILQ_INIT(&txn->kids); + txn->flags = TXN_MALLOC; + if (parent != NULL) + TAILQ_INSERT_HEAD(&parent->kids, txn, klinks); + + /* + * XXX + * In DB library the txn_chain is protected by the mgrp->mutexp. + * However, that mutex is implemented in the environments shared + * memory region. The client library does not support all of the + * region - that just get forwarded to the server. Therefore, + * the chain is unprotected here, but properly protected on the + * server. + */ + TAILQ_INSERT_TAIL(&txn->mgrp->txn_chain, txn, links); + + *txnpp = txn; + return (replyp->status); +} + +int +__dbcl_txn_commit_ret(txnp, flags, replyp) + DB_TXN *txnp; + u_int32_t flags; + __txn_commit_reply *replyp; +{ + COMPQUIET(flags, 0); + + __dbcl_txn_end(txnp); + return (replyp->status); +} + +int +__dbcl_db_close_ret(dbp, flags, replyp) + DB *dbp; + u_int32_t flags; + __db_close_reply *replyp; +{ + int ret; + + COMPQUIET(flags, 0); + + ret = __dbcl_dbclose_common(dbp); + + if (replyp->status != 0) + return (replyp->status); + else + return (ret); +} + +int +__dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp) + DB *dbp; + DB_TXN *txnp; + DBT *key, *data; + u_int32_t flags; + __db_get_reply *replyp; +{ + DB_ENV *dbenv; + int ret; + void *oldkey; + + COMPQUIET(txnp, NULL); + COMPQUIET(flags, 0); + + ret = 0; + if (replyp->status != 0) + return (replyp->status); + + dbenv = dbp->dbenv; + + oldkey = key->data; + ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val, + replyp->keydata.keydata_len); + if (ret) + return (ret); + ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val, + replyp->datadata.datadata_len); + /* + * If an error on copying 'data' and we allocated for 'key' + * free it before returning the error. + */ + if (ret && oldkey != NULL) + __os_free(key->data, key->size); + return (ret); +} + +int +__dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp) + DB *dbp; + DB_TXN *txnp; + DBT *key; + DB_KEY_RANGE *range; + u_int32_t flags; + __db_key_range_reply *replyp; +{ + COMPQUIET(dbp, NULL); + COMPQUIET(txnp, NULL); + COMPQUIET(key, NULL); + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + range->less = replyp->less; + range->equal = replyp->equal; + range->greater = replyp->greater; + return (replyp->status); +} + +int +__dbcl_db_open_ret(dbp, name, subdb, type, flags, mode, replyp) + DB *dbp; + const char *name, *subdb; + DBTYPE type; + u_int32_t flags; + int mode; + __db_open_reply *replyp; +{ + COMPQUIET(name, NULL); + COMPQUIET(subdb, NULL); + COMPQUIET(type, 0); + COMPQUIET(flags, 0); + COMPQUIET(mode, 0); + + dbp->type = replyp->type; + + /* + * XXX + * This is only for Tcl which peeks at the dbp flags. + * When dbp->get_flags exists, this should go away. + */ + dbp->flags = replyp->dbflags; + return (replyp->status); +} + +int +__dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp) + DB *dbp; + DB_TXN *txnp; + DBT *key, *data; + u_int32_t flags; + __db_put_reply *replyp; +{ + int ret; + + COMPQUIET(dbp, NULL); + COMPQUIET(txnp, NULL); + COMPQUIET(data, NULL); + + ret = replyp->status; + if (replyp->status == 0 && (flags == DB_APPEND)) + *(db_recno_t *)key->data = + *(db_recno_t *)replyp->keydata.keydata_val; + return (ret); +} + +int +__dbcl_db_remove_ret(dbp, name, subdb, flags, replyp) + DB *dbp; + const char *name, *subdb; + u_int32_t flags; + __db_remove_reply *replyp; +{ + int ret; + + COMPQUIET(name, 0); + COMPQUIET(subdb, 0); + COMPQUIET(flags, 0); + + ret = __dbcl_dbclose_common(dbp); + + if (replyp->status != 0) + return (replyp->status); + else + return (ret); +} + +int +__dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp) + DB *dbp; + const char *name, *subdb, *newname; + u_int32_t flags; + __db_remove_reply *replyp; +{ + int ret; + + COMPQUIET(name, 0); + COMPQUIET(subdb, 0); + COMPQUIET(newname, 0); + COMPQUIET(flags, 0); + + ret = __dbcl_dbclose_common(dbp); + + if (replyp->status != 0) + return (replyp->status); + else + return (ret); +} + +int +__dbcl_db_stat_ret(dbp, sp, func, flags, replyp) + DB *dbp; + void *sp; + void *(*func) __P((size_t)); + u_int32_t flags; + __db_stat_reply *replyp; +{ + int ret; + u_int32_t *__db_statslist; + + COMPQUIET(dbp, NULL); + COMPQUIET(func, NULL); + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + + if ((ret = + __db_db_stat_statslist(replyp->statslist, &__db_statslist)) != 0) + return (ret); + + if (sp == NULL) + __db_db_stat_statsfree(__db_statslist); + else + *(u_int32_t **)sp = __db_statslist; + return (replyp->status); +} + +static int +__db_db_stat_statslist(locp, ppp) + __db_stat_statsreplist *locp; + u_int32_t **ppp; +{ + u_int32_t *pp; + int cnt, ret, size; + __db_stat_statsreplist *nl; + + for (cnt = 0, nl = locp; nl != NULL; cnt++, nl = nl->next) + ; + + if (cnt == 0) { + *ppp = NULL; + return (0); + } + size = sizeof(*pp) * cnt; + if ((ret = __os_malloc(NULL, size, NULL, ppp)) != 0) + return (ret); + memset(*ppp, 0, size); + for (pp = *ppp, nl = locp; nl != NULL; nl = nl->next, pp++) { + *pp = *(u_int32_t *)nl->ent.ent_val; + } + return (0); +} + +static void +__db_db_stat_statsfree(pp) + u_int32_t *pp; +{ + size_t size; + u_int32_t *p; + + if (pp == NULL) + return; + size = sizeof(*p); + for (p = pp; *p != 0; p++) + size += sizeof(*p); + + __os_free(pp, size); +} + +int +__dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp) + DB *dbp; + DB_TXN *txnp; + DBC **dbcpp; + u_int32_t flags; + __db_cursor_reply *replyp; +{ + COMPQUIET(txnp, NULL); + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + + return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcpp)); +} + +int +__dbcl_db_join_ret(dbp, curs, dbcpp, flags, replyp) + DB *dbp; + DBC **curs, **dbcpp; + u_int32_t flags; + __db_join_reply *replyp; +{ + COMPQUIET(curs, NULL); + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + + /* + * We set this up as a normal cursor. We do not need + * to treat a join cursor any differently than a normal + * cursor, even though DB itself must. We only need the + * client-side cursor/db relationship to know what cursors + * are open in the db, and to store their ID. Nothing else. + */ + return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcpp)); +} + +int +__dbcl_dbc_close_ret(dbcp, replyp) + DBC *dbcp; + __dbc_close_reply *replyp; +{ + DB *dbp; + + dbp = dbcp->dbp; + __dbcl_c_refresh(dbcp); + return (replyp->status); +} + +int +__dbcl_dbc_count_ret(dbc, countp, flags, replyp) + DBC *dbc; + db_recno_t *countp; + u_int32_t flags; + __dbc_count_reply *replyp; +{ + COMPQUIET(dbc, NULL); + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + *countp = replyp->dupcount; + + return (replyp->status); +} + +int +__dbcl_dbc_dup_ret(dbcp, dbcpp, flags, replyp) + DBC *dbcp, **dbcpp; + u_int32_t flags; + __dbc_dup_reply *replyp; +{ + COMPQUIET(flags, 0); + + if (replyp->status != 0) + return (replyp->status); + + return (__dbcl_c_setup(replyp->dbcidcl_id, dbcp->dbp, dbcpp)); +} + +int +__dbcl_dbc_get_ret(dbcp, key, data, flags, replyp) + DBC *dbcp; + DBT *key, *data; + u_int32_t flags; + __dbc_get_reply *replyp; +{ + DB_ENV *dbenv; + int ret; + void *oldkey; + + COMPQUIET(flags, 0); + + ret = 0; + if (replyp->status != 0) + return (replyp->status); + + dbenv = dbcp->dbp->dbenv; + oldkey = key->data; + ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val, + replyp->keydata.keydata_len); + if (ret) + return (ret); + ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val, + replyp->datadata.datadata_len); + + /* + * If an error on copying 'data' and we allocated for 'key' + * free it before returning the error. + */ + if (ret && oldkey != NULL) + __os_free(key->data, key->size); + return (ret); +} + +int +__dbcl_dbc_put_ret(dbcp, key, data, flags, replyp) + DBC *dbcp; + DBT *key, *data; + u_int32_t flags; + __dbc_put_reply *replyp; +{ + COMPQUIET(data, NULL); + + if (replyp->status != 0) + return (replyp->status); + + if (replyp->status == 0 && dbcp->dbp->type == DB_RECNO && + (flags == DB_AFTER || flags == DB_BEFORE)) + *(db_recno_t *)key->data = + *(db_recno_t *)replyp->keydata.keydata_val; + return (replyp->status); +} +#endif /* HAVE_RPC */ |