BDB 4.1.24

bdb/rpc_server/java/DbDispatcher.java

@@ -0,0 +1,590 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: DbDispatcher.java,v 1.5 2002/08/09 01:56:08 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.IOException;
+import org.acplt.oncrpc.OncRpcException;
+
+/**
+ * Dispatcher for RPC messages for the Java RPC server.
+ * These are hooks that translate between RPC msg/reply structures and
+ * DB calls, which keeps the real implementation code in Rpc* classes cleaner.
+ */
+public abstract class DbDispatcher extends DbServerStub
+{
+	abstract int addEnv(RpcDbEnv rdbenv);
+	abstract int addDb(RpcDb rdb);
+	abstract int addTxn(RpcDbTxn rtxn);
+	abstract int addCursor(RpcDbc rdbc);
+	abstract void delEnv(RpcDbEnv rdbenv);
+	abstract void delDb(RpcDb rdb);
+	abstract void delTxn(RpcDbTxn rtxn);
+	abstract void delCursor(RpcDbc rdbc);
+	abstract RpcDbEnv getEnv(int envid);
+	abstract RpcDb getDb(int dbid);
+	abstract RpcDbTxn getTxn(int txnbid);
+	abstract RpcDbc getCursor(int dbcid);
+
+	public DbDispatcher() throws IOException, OncRpcException
+	{
+		super();
+	}
+
+	//// Db methods
+
+	public  __db_associate_reply __DB_db_associate_4001(__db_associate_msg args)
+	{
+		__db_associate_reply reply = new __db_associate_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.associate(this, args, reply);
+		return reply;
+	}
+
+	public  __db_bt_maxkey_reply __DB_db_bt_maxkey_4001(__db_bt_maxkey_msg args)
+	{
+		__db_bt_maxkey_reply reply = new __db_bt_maxkey_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_bt_maxkey(this, args, reply);
+		return reply;
+	}
+
+	public  __db_bt_minkey_reply __DB_db_bt_minkey_4001(__db_bt_minkey_msg args)
+	{
+		__db_bt_minkey_reply reply = new __db_bt_minkey_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_bt_minkey(this, args, reply);
+		return reply;
+	}
+
+	public  __db_close_reply __DB_db_close_4001(__db_close_msg args)
+	{
+		__db_close_reply reply = new __db_close_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.close(this, args, reply);
+		return reply;
+	}
+
+	public  __db_create_reply __DB_db_create_4001(__db_create_msg args)
+	{
+		__db_create_reply reply = new __db_create_reply();
+		RpcDb rdb = new RpcDb(getEnv(args.dbenvcl_id));
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.create(this, args, reply);
+		return reply;
+	}
+
+	public  __db_cursor_reply __DB_db_cursor_4001(__db_cursor_msg args)
+	{
+		__db_cursor_reply reply = new __db_cursor_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.cursor(this, args, reply);
+		return reply;
+	}
+
+	public  __db_del_reply __DB_db_del_4001(__db_del_msg args)
+	{
+		__db_del_reply reply = new __db_del_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.del(this, args, reply);
+		return reply;
+	}
+
+	public  __db_encrypt_reply __DB_db_encrypt_4001(__db_encrypt_msg args)
+	{
+		__db_encrypt_reply reply = new __db_encrypt_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_encrypt(this, args, reply);
+		return reply;
+	}
+
+	public  __db_extentsize_reply __DB_db_extentsize_4001(__db_extentsize_msg args)
+	{
+		__db_extentsize_reply reply = new __db_extentsize_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_q_extentsize(this, args, reply);
+		return reply;
+	}
+
+	public  __db_flags_reply __DB_db_flags_4001(__db_flags_msg args)
+	{
+		__db_flags_reply reply = new __db_flags_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_flags(this, args, reply);
+		return reply;
+	}
+
+	public  __db_get_reply __DB_db_get_4001(__db_get_msg args)
+	{
+		__db_get_reply reply = new __db_get_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.get(this, args, reply);
+		return reply;
+	}
+
+	public  __db_h_ffactor_reply __DB_db_h_ffactor_4001(__db_h_ffactor_msg args)
+	{
+		__db_h_ffactor_reply reply = new __db_h_ffactor_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_h_ffactor(this, args, reply);
+		return reply;
+	}
+
+	public  __db_h_nelem_reply __DB_db_h_nelem_4001(__db_h_nelem_msg args)
+	{
+		__db_h_nelem_reply reply = new __db_h_nelem_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_h_nelem(this, args, reply);
+		return reply;
+	}
+
+	public  __db_join_reply __DB_db_join_4001(__db_join_msg args)
+	{
+		__db_join_reply reply = new __db_join_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.join(this, args, reply);
+		return reply;
+	}
+
+	public  __db_key_range_reply __DB_db_key_range_4001(__db_key_range_msg args)
+	{
+		__db_key_range_reply reply = new __db_key_range_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.key_range(this, args, reply);
+		return reply;
+	}
+
+	public  __db_lorder_reply __DB_db_lorder_4001(__db_lorder_msg args)
+	{
+		__db_lorder_reply reply = new __db_lorder_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_lorder(this, args, reply);
+		return reply;
+	}
+
+	public  __db_open_reply __DB_db_open_4001(__db_open_msg args)
+	{
+		__db_open_reply reply = new __db_open_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.open(this, args, reply);
+		return reply;
+	}
+
+	public  __db_pagesize_reply __DB_db_pagesize_4001(__db_pagesize_msg args)
+	{
+		__db_pagesize_reply reply = new __db_pagesize_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_pagesize(this, args, reply);
+		return reply;
+	}
+
+	public  __db_pget_reply __DB_db_pget_4001(__db_pget_msg args)
+	{
+		__db_pget_reply reply = new __db_pget_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.pget(this, args, reply);
+		return reply;
+	}
+
+	public  __db_put_reply __DB_db_put_4001(__db_put_msg args)
+	{
+		__db_put_reply reply = new __db_put_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.put(this, args, reply);
+		return reply;
+	}
+
+	public  __db_remove_reply __DB_db_remove_4001(__db_remove_msg args)
+	{
+		__db_remove_reply reply = new __db_remove_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.remove(this, args, reply);
+		return reply;
+	}
+
+	public  __db_rename_reply __DB_db_rename_4001(__db_rename_msg args)
+	{
+		__db_rename_reply reply = new __db_rename_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.rename(this, args, reply);
+		return reply;
+	}
+
+	public  __db_re_delim_reply __DB_db_re_delim_4001(__db_re_delim_msg args)
+	{
+		__db_re_delim_reply reply = new __db_re_delim_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_re_delim(this, args, reply);
+		return reply;
+	}
+
+	public  __db_re_len_reply __DB_db_re_len_4001(__db_re_len_msg args)
+	{
+		__db_re_len_reply reply = new __db_re_len_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_re_len(this, args, reply);
+		return reply;
+	}
+
+	public  __db_re_pad_reply __DB_db_re_pad_4001(__db_re_pad_msg args)
+	{
+		__db_re_pad_reply reply = new __db_re_pad_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.set_re_pad(this, args, reply);
+		return reply;
+	}
+
+	public  __db_stat_reply __DB_db_stat_4001(__db_stat_msg args)
+	{
+		__db_stat_reply reply = new __db_stat_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.stat(this, args, reply);
+		return reply;
+	}
+
+	public  __db_sync_reply __DB_db_sync_4001(__db_sync_msg args)
+	{
+		__db_sync_reply reply = new __db_sync_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.sync(this, args, reply);
+		return reply;
+	}
+
+	public  __db_truncate_reply __DB_db_truncate_4001(__db_truncate_msg args)
+	{
+		__db_truncate_reply reply = new __db_truncate_reply();
+		RpcDb rdb = getDb(args.dbpcl_id);
+		if (rdb == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdb.truncate(this, args, reply);
+		return reply;
+	}
+
+	//// Cursor methods
+
+	public  __dbc_close_reply __DB_dbc_close_4001(__dbc_close_msg args)
+	{
+		__dbc_close_reply reply = new __dbc_close_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.close(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_count_reply __DB_dbc_count_4001(__dbc_count_msg args)
+	{
+		__dbc_count_reply reply = new __dbc_count_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.count(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_del_reply __DB_dbc_del_4001(__dbc_del_msg args)
+	{
+		__dbc_del_reply reply = new __dbc_del_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.del(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_dup_reply __DB_dbc_dup_4001(__dbc_dup_msg args)
+	{
+		__dbc_dup_reply reply = new __dbc_dup_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.dup(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_get_reply __DB_dbc_get_4001(__dbc_get_msg args)
+	{
+		__dbc_get_reply reply = new __dbc_get_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.get(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_pget_reply __DB_dbc_pget_4001(__dbc_pget_msg args) {
+		__dbc_pget_reply reply = new __dbc_pget_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.pget(this, args, reply);
+		return reply;
+	}
+
+	public  __dbc_put_reply __DB_dbc_put_4001(__dbc_put_msg args) {
+		__dbc_put_reply reply = new __dbc_put_reply();
+		RpcDbc rdbc = getCursor(args.dbccl_id);
+		if (rdbc == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbc.put(this, args, reply);
+		return reply;
+	}
+
+	//// Environment methods
+
+	public  __env_cachesize_reply __DB_env_cachesize_4001(__env_cachesize_msg args)
+	{
+		__env_cachesize_reply reply = new __env_cachesize_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.set_cachesize(this, args, reply);
+		return reply;
+	}
+
+	public  __env_close_reply __DB_env_close_4001(__env_close_msg args)
+	{
+		__env_close_reply reply = new __env_close_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.close(this, args, reply);
+		return reply;
+	}
+
+	public  __env_create_reply __DB_env_create_4001(__env_create_msg args)
+	{
+		__env_create_reply reply = new __env_create_reply();
+		RpcDbEnv rdbenv = new RpcDbEnv();
+		rdbenv.create(this, args, reply);
+		return reply;
+	}
+
+	public  __env_dbremove_reply __DB_env_dbremove_4001(__env_dbremove_msg args)
+	{
+		__env_dbremove_reply reply = new __env_dbremove_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.dbremove(this, args, reply);
+		return reply;
+	}
+
+	public  __env_dbrename_reply __DB_env_dbrename_4001(__env_dbrename_msg args)
+	{
+		__env_dbrename_reply reply = new __env_dbrename_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.dbrename(this, args, reply);
+		return reply;
+	}
+
+	public  __env_encrypt_reply __DB_env_encrypt_4001(__env_encrypt_msg args)
+	{
+		__env_encrypt_reply reply = new __env_encrypt_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.set_encrypt(this, args, reply);
+		return reply;
+	}
+
+	public  __env_flags_reply __DB_env_flags_4001(__env_flags_msg args)
+	{
+		__env_flags_reply reply = new __env_flags_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.set_flags(this, args, reply);
+		return reply;
+	}
+
+	public  __env_open_reply __DB_env_open_4001(__env_open_msg args)
+	{
+		__env_open_reply reply = new __env_open_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.open(this, args, reply);
+		return reply;
+	}
+
+	public  __env_remove_reply __DB_env_remove_4001(__env_remove_msg args)
+	{
+		__env_remove_reply reply = new __env_remove_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.remove(this, args, reply);
+		return reply;
+	}
+
+	//// Transaction methods
+
+	public  __txn_abort_reply __DB_txn_abort_4001(__txn_abort_msg args)
+	{
+		__txn_abort_reply reply = new __txn_abort_reply();
+		RpcDbTxn rdbtxn = getTxn(args.txnpcl_id);
+		if (rdbtxn == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbtxn.abort(this, args, reply);
+		return reply;
+	}
+
+	public  __txn_begin_reply __DB_txn_begin_4001(__txn_begin_msg args)
+	{
+		__txn_begin_reply reply = new __txn_begin_reply();
+		RpcDbTxn rdbtxn = new RpcDbTxn(getEnv(args.dbenvcl_id), null);
+		rdbtxn.begin(this, args, reply);
+		return reply;
+	}
+
+	public  __txn_commit_reply __DB_txn_commit_4001(__txn_commit_msg args)
+	{
+		__txn_commit_reply reply = new __txn_commit_reply();
+		RpcDbTxn rdbtxn = getTxn(args.txnpcl_id);
+		if (rdbtxn == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbtxn.commit(this, args, reply);
+		return reply;
+	}
+
+	public  __txn_discard_reply __DB_txn_discard_4001(__txn_discard_msg args)
+	{
+		__txn_discard_reply reply = new __txn_discard_reply();
+		RpcDbTxn rdbtxn = getTxn(args.txnpcl_id);
+		if (rdbtxn == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbtxn.discard(this, args, reply);
+		return reply;
+	}
+
+	public  __txn_prepare_reply __DB_txn_prepare_4001(__txn_prepare_msg args)
+	{
+		__txn_prepare_reply reply = new __txn_prepare_reply();
+		RpcDbTxn rdbtxn = getTxn(args.txnpcl_id);
+		if (rdbtxn == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbtxn.prepare(this, args, reply);
+		return reply;
+	}
+
+	public  __txn_recover_reply __DB_txn_recover_4001(__txn_recover_msg args)
+	{
+		__txn_recover_reply reply = new __txn_recover_reply();
+		RpcDbEnv rdbenv = getEnv(args.dbenvcl_id);
+		if (rdbenv == null)
+			reply.status = Db.DB_NOSERVER_ID;
+		else
+			rdbenv.txn_recover(this, args, reply);
+		return reply;
+	}
+}

bdb/rpc_server/java/DbServer.java

@@ -0,0 +1,301 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: DbServer.java,v 1.5 2002/08/09 01:56:09 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.*;
+import java.util.*;
+import org.acplt.oncrpc.OncRpcException;
+import org.acplt.oncrpc.server.OncRpcCallInformation;
+
+/**
+ * Main entry point for the Java version of the Berkeley DB RPC server
+ */
+public class DbServer extends DbDispatcher
+{
+	public static long idleto = 10 * 60 * 1000;	// 5 minutes
+	public static long defto = 5 * 60 * 1000;	// 5 minutes
+	public static long maxto = 60 * 60 * 1000;	// 1 hour
+	public static String passwd = null;
+	public static PrintWriter err;
+
+	long now, hint; // updated each operation
+	FreeList env_list = new FreeList();
+	FreeList db_list = new FreeList();
+	FreeList txn_list = new FreeList();
+	FreeList cursor_list = new FreeList();
+
+	public DbServer() throws IOException, OncRpcException
+	{
+		super();
+		init_lists();
+	}
+
+	public void dispatchOncRpcCall(OncRpcCallInformation call, int program,
+		int version, int procedure) throws OncRpcException, IOException
+	{
+		long newnow = System.currentTimeMillis();
+		// DbServer.err.println("Dispatching RPC call " + procedure + " after delay of " + (newnow - now));
+		now = newnow;
+		// DbServer.err.flush();
+		super.dispatchOncRpcCall(call, program, version, procedure);
+
+		try {
+			doTimeouts();
+		} catch(Throwable t) {
+			System.err.println("Caught " + t + " during doTimeouts()");
+			t.printStackTrace(System.err);
+		}
+	}
+
+	// Internal methods to track context
+	private void init_lists()
+	{
+		// We do this so that getEnv/Db/etc(0) == null
+		env_list.add(null);
+		db_list.add(null);
+		txn_list.add(null);
+		cursor_list.add(null);
+	}
+
+	int addEnv(RpcDbEnv rdbenv)
+	{
+		rdbenv.timer.last_access = now;
+		int id = env_list.add(rdbenv);
+		return id;
+	}
+
+	int addDb(RpcDb rdb)
+	{
+		int id = db_list.add(rdb);
+		return id;
+	}
+
+	int addTxn(RpcDbTxn rtxn)
+	{
+		rtxn.timer.last_access = now;
+		int id = txn_list.add(rtxn);
+		return id;
+	}
+
+	int addCursor(RpcDbc rdbc)
+	{
+		rdbc.timer.last_access = now;
+		int id = cursor_list.add(rdbc);
+		return id;
+	}
+
+	void delEnv(RpcDbEnv rdbenv)
+	{
+		// cursors and transactions will already have been cleaned up
+		for(LocalIterator i = db_list.iterator(); i.hasNext(); ) {
+			RpcDb rdb = (RpcDb)i.next();
+			if (rdb != null && rdb.rdbenv == rdbenv)
+				delDb(rdb);
+		}
+
+		env_list.del(rdbenv);
+		rdbenv.dispose();
+	}
+
+	void delDb(RpcDb rdb)
+	{
+		db_list.del(rdb);
+		rdb.dispose();
+
+		for(LocalIterator i = cursor_list.iterator(); i.hasNext(); ) {
+			RpcDbc rdbc = (RpcDbc)i.next();
+			if (rdbc != null && rdbc.timer == rdb)
+				i.remove();
+		}
+	}
+
+	void delTxn(RpcDbTxn rtxn)
+	{
+		txn_list.del(rtxn);
+		rtxn.dispose();
+
+		for(LocalIterator i = cursor_list.iterator(); i.hasNext(); ) {
+			RpcDbc rdbc = (RpcDbc)i.next();
+			if (rdbc != null && rdbc.timer == rtxn)
+				i.remove();
+		}
+
+		for(LocalIterator i = txn_list.iterator(); i.hasNext(); ) {
+			RpcDbTxn rtxn_child = (RpcDbTxn)i.next();
+			if (rtxn_child != null && rtxn_child.timer == rtxn)
+				i.remove();
+		}
+	}
+
+	void delCursor(RpcDbc rdbc)
+	{
+		cursor_list.del(rdbc);
+		rdbc.dispose();
+	}
+
+	RpcDbEnv getEnv(int envid)
+	{
+		RpcDbEnv rdbenv = (RpcDbEnv)env_list.get(envid);
+		if (rdbenv != null)
+			rdbenv.timer.last_access = now;
+		return rdbenv;
+	}
+
+	RpcDb getDb(int dbid)
+	{
+		RpcDb rdb = (RpcDb)db_list.get(dbid);
+		if (rdb != null)
+			rdb.rdbenv.timer.last_access = now;
+		return rdb;
+	}
+
+	RpcDbTxn getTxn(int txnid)
+	{
+		RpcDbTxn rtxn = (RpcDbTxn)txn_list.get(txnid);
+		if (rtxn != null)
+			rtxn.timer.last_access = rtxn.rdbenv.timer.last_access = now;
+		return rtxn;
+	}
+
+	RpcDbc getCursor(int dbcid)
+	{
+		RpcDbc rdbc = (RpcDbc)cursor_list.get(dbcid);
+		if (rdbc != null)
+			rdbc.last_access = rdbc.timer.last_access = rdbc.rdbenv.timer.last_access = now;
+		return rdbc;
+	}
+
+	void doTimeouts()
+	{
+		if (now < hint) {
+			// DbServer.err.println("Skipping cleaner sweep - now = " + now + ", hint = " + hint);
+			return;
+		}
+
+		// DbServer.err.println("Starting a cleaner sweep");
+		hint = now + DbServer.maxto;
+
+		for(LocalIterator i = cursor_list.iterator(); i.hasNext(); ) {
+			RpcDbc rdbc = (RpcDbc)i.next();
+			if (rdbc == null)
+				continue;
+
+			long end_time = rdbc.timer.last_access + rdbc.rdbenv.timeout;
+			// DbServer.err.println("Examining " + rdbc + ", time left = " + (end_time - now));
+			if (end_time < now) {
+				DbServer.err.println("Cleaning up " + rdbc);
+				delCursor(rdbc);
+			} else if (end_time < hint)
+				hint = end_time;
+		}
+
+		for(LocalIterator i = txn_list.iterator(); i.hasNext(); ) {
+			RpcDbTxn rtxn = (RpcDbTxn)i.next();
+			if (rtxn == null)
+				continue;
+
+			long end_time = rtxn.timer.last_access + rtxn.rdbenv.timeout;
+			// DbServer.err.println("Examining " + rtxn + ", time left = " + (end_time - now));
+			if (end_time < now) {
+				DbServer.err.println("Cleaning up " + rtxn);
+				delTxn(rtxn);
+			} else if (end_time < hint)
+				hint = end_time;
+		}
+
+		for(LocalIterator i = env_list.iterator(); i.hasNext(); ) {
+			RpcDbEnv rdbenv = (RpcDbEnv)i.next();
+			if (rdbenv == null)
+				continue;
+
+			long end_time = rdbenv.timer.last_access + rdbenv.idletime;
+			// DbServer.err.println("Examining " + rdbenv + ", time left = " + (end_time - now));
+			if (end_time < now) {
+				DbServer.err.println("Cleaning up " + rdbenv);
+				delEnv(rdbenv);
+			}
+		}
+
+		 // if we didn't find anything, reset the hint
+		if (hint == now + DbServer.maxto)
+			hint = 0;
+
+		// DbServer.err.println("Finishing a cleaner sweep");
+	}
+
+	// Some constants that aren't available elsewhere
+	static final int DB_SERVER_FLAGMASK = Db.DB_LOCKDOWN |
+	    Db.DB_PRIVATE | Db.DB_RECOVER | Db.DB_RECOVER_FATAL |
+	    Db.DB_SYSTEM_MEM | Db.DB_USE_ENVIRON |
+	    Db.DB_USE_ENVIRON_ROOT;
+	static final int DB_SERVER_ENVFLAGS = Db.DB_INIT_CDB |
+	    Db.DB_INIT_LOCK | Db.DB_INIT_LOG | Db.DB_INIT_MPOOL |
+	    Db.DB_INIT_TXN | Db.DB_JOINENV;
+	static final int DB_SERVER_DBFLAGS = Db.DB_DIRTY_READ |
+	    Db.DB_NOMMAP | Db.DB_RDONLY;
+	static final int DB_SERVER_DBNOSHARE = Db.DB_EXCL | Db.DB_TRUNCATE;
+
+	public static void main(String[] args)
+	{
+		System.out.println("Starting DbServer...");
+		for (int i = 0; i < args.length; i++) {
+			if (args[i].charAt(0) != '-')
+				usage();
+
+			switch (args[i].charAt(1)) {
+			case 'h':
+				++i; // add_home(args[++i]);
+				break;
+			case 'I':
+				idleto = Long.parseLong(args[++i]) * 1000L;
+				break;
+			case 'P':
+				passwd = args[++i];
+				break;
+			case 't':
+				defto = Long.parseLong(args[++i]) * 1000L;
+				break;
+			case 'T':
+				maxto = Long.parseLong(args[++i]) * 1000L;
+				break;
+			case 'V':
+				// version;
+				break;
+			case 'v':
+				// verbose
+				break;
+			default:
+				usage();
+			}
+		}
+
+		try {
+			DbServer.err = new PrintWriter(new FileOutputStream("JavaRPCServer.trace", true));
+			DbServer server = new DbServer();
+			server.run();
+		} catch (Throwable e) {
+			System.out.println("DbServer exception:");
+			e.printStackTrace(DbServer.err);
+		} finally {
+			if (DbServer.err != null)
+				DbServer.err.close();
+		}
+
+		System.out.println("DbServer stopped.");
+	}
+
+	static void usage()
+	{
+		System.err.println("usage: java com.sleepycat.db.rpcserver.DbServer \\");
+		System.err.println("[-Vv] [-h home] [-P passwd] [-I idletimeout] [-L logfile] [-t def_timeout] [-T maxtimeout]");
+		System.exit(1);
+	}
+}

bdb/rpc_server/java/FreeList.java

@@ -0,0 +1,102 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: FreeList.java,v 1.3 2002/08/09 01:56:09 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import java.util.*;
+
+/**
+ * Keep track of a list of objects by id with a free list.
+ * Intentionally package-protected exposure.
+ */
+class FreeList
+{
+	class FreeIndex {
+		int index;
+		FreeIndex(int index) { this.index = index; }
+		int getIndex() { return index; }
+	}
+
+	Vector items = new Vector();
+	FreeIndex free_head = null;
+
+	public synchronized int add(Object obj) {
+		int pos;
+		if (free_head == null) {
+			pos = items.size();
+			items.addElement(obj);
+			if (pos % 1000 == 0)
+				DbServer.err.println(this + " grew to size " + pos);
+		} else {
+			pos = free_head.getIndex();
+			free_head = (FreeIndex)items.elementAt(pos);
+			items.setElementAt(obj, pos);
+		}
+		return pos;
+	}
+
+	public synchronized void del(int pos) {
+		Object obj = items.elementAt(pos);
+		if (obj != null && obj instanceof FreeIndex)
+			throw new NoSuchElementException("index " + pos + " has already been freed");
+		items.setElementAt(free_head, pos);
+		free_head = new FreeIndex(pos);
+	}
+
+	public void del(Object obj) {
+		del(items.indexOf(obj));
+	}
+
+	public Object get(int pos) {
+		Object obj = items.elementAt(pos);
+		if (obj instanceof FreeIndex)
+			obj = null;
+		return obj;
+	}
+
+	public LocalIterator iterator() {
+		return new FreeListIterator();
+	}
+
+	/**
+	 * Iterator for a FreeList.  Note that this class doesn't implement
+	 * java.util.Iterator to maintain compatibility with Java 1.1
+	 * Intentionally package-protected exposure.
+	 */
+	class FreeListIterator implements LocalIterator {
+		int current;
+
+		FreeListIterator() { current = findNext(-1); }
+
+		private int findNext(int start) {
+			int next = start;
+			while (++next < items.size()) {
+				Object obj = items.elementAt(next);
+				if (obj == null || !(obj instanceof FreeIndex))
+					break;
+			}
+			return next;
+		}
+
+		public boolean hasNext() {
+			return (findNext(current) < items.size());
+		}
+
+		public Object next() {
+			current = findNext(current);
+			if (current == items.size())
+				throw new NoSuchElementException("enumerated past end of FreeList");
+			return items.elementAt(current);
+		}
+
+		public void remove() {
+			del(current);
+		}
+	}
+}

bdb/rpc_server/java/LocalIterator.java

@@ -0,0 +1,23 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: LocalIterator.java,v 1.2 2002/08/09 01:56:09 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import java.util.*;
+
+/**
+ * Iterator interface.  Note that this matches java.util.Iterator
+ * but maintains compatibility with Java 1.1
+ * Intentionally package-protected exposure.
+ */
+interface LocalIterator {
+	boolean hasNext();
+	Object next();
+	void remove();
+}

bdb/rpc_server/java/README

@@ -0,0 +1,24 @@
+Berkeley DB Java RPC server, copyright (C) 2002 Sleepycat Software
+
+The Java implementation of the Berkeley DB RPC server is intended
+primarily for testing purposes.  It provides the same interface
+as the C and C++ RPC servers, but is implemented via the Java API
+rather than the C or C++ APIs.  This allows the existing Tcl test
+suite to exercise the Java API without modification.
+
+The Java RPC server relies on a Java version of rpcgen to
+automatically generate appropriate Java classes from the RPC
+interface specification (../db_server.x).  We use jrpcgen, which
+is part of the Remote Tea for Java project:
+  acplt.plt.rwth-aachen.de/ks/english/remotetea.html
+
+To rebuild the Java stubs from db_server.x, you will need to
+download the full Remote Tea package, but if you just want to
+compile the Java sources and run the Java RPC server, the runtime
+component of Remote Tea is included in oncrpc.jar.  Building
+the Java RPC server is automatic when Berkeley DB is configured
+with the both --enable-rpc and --enable-java.
+
+All of the Remote Tea project is licensed under the Library GNU
+Public License, and we have made no modifications to their
+released code.

bdb/rpc_server/java/RpcDb.java

@@ -0,0 +1,694 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: RpcDb.java,v 1.8 2002/08/09 01:56:09 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+/**
+ * RPC wrapper around a db object for the Java RPC server.
+ */
+public class RpcDb extends Timer
+{
+	static final byte[] empty = new byte[0];
+	Db db;
+	RpcDbEnv rdbenv;
+	int refcount = 1;
+	String dbname, subdbname;
+	int type, setflags, openflags;
+
+	public RpcDb(RpcDbEnv rdbenv)
+	{
+		this.rdbenv = rdbenv;
+	}
+
+	void dispose()
+	{
+		if (db != null) {
+			try {
+				db.close(0);
+			} catch(DbException e) {
+				e.printStackTrace(DbServer.err);
+			}
+			db = null;
+		}
+	}
+
+	public  void associate(DbDispatcher server,
+		__db_associate_msg args, __db_associate_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			/*
+			 * We do not support DB_CREATE for associate.   Users
+			 * can only access secondary indices on a read-only basis,
+			 * so whatever they are looking for needs to be there already.
+			 */
+			db.associate(txn, server.getDb(args.sdbpcl_id).db, null, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void close(DbDispatcher server,
+		__db_close_msg args, __db_close_reply reply)
+	{
+		if (--refcount != 0) {
+			reply.status = 0;
+			return;
+		}
+
+		try {
+			db.close(args.flags);
+			db = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delDb(this);
+		}
+	}
+
+	public  void create(DbDispatcher server,
+		__db_create_msg args, __db_create_reply reply)
+	{
+		try {
+			db = new Db(server.getEnv(args.dbenvcl_id).dbenv, args.flags);
+			reply.dbcl_id = server.addDb(this);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void cursor(DbDispatcher server,
+		__db_cursor_msg args, __db_cursor_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			Dbc dbc = db.cursor(txn, args.flags);
+			RpcDbc rdbc = new RpcDbc(this, dbc, false);
+			rdbc.timer = (rtxn != null) ? rtxn.timer : this;
+			reply.dbcidcl_id = server.addCursor(rdbc);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void del(DbDispatcher server,
+		__db_del_msg args, __db_del_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_doff(args.keydoff);
+			key.set_ulen(args.keyulen);
+			key.set_flags(args.keyflags);
+
+			db.del(txn, key, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void get(DbDispatcher server,
+		__db_get_msg args, __db_get_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_doff(args.keydoff);
+			key.set_ulen(args.keyulen);
+			key.set_flags(Db.DB_DBT_MALLOC |
+				    (args.keyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_doff(args.datadoff);
+			data.set_ulen(args.dataulen);
+			if ((args.flags & Db.DB_MULTIPLE) != 0) {
+				if (data.get_data().length == 0)
+					data.set_data(new byte[data.get_ulen()]);
+				data.set_flags(Db.DB_DBT_USERMEM |
+				    (args.dataflags & Db.DB_DBT_PARTIAL));
+			} else
+				data.set_flags(Db.DB_DBT_MALLOC |
+				    (args.dataflags & Db.DB_DBT_PARTIAL));
+
+			reply.status = db.get(txn, key, data, args.flags);
+
+			if (key.get_data() == args.keydata ||
+			    key.get_data().length != key.get_size()) {
+				reply.keydata = new byte[key.get_size()];
+				System.arraycopy(key.get_data(), 0, reply.keydata, 0, key.get_size());
+			} else
+				reply.keydata = key.get_data();
+
+			if (data.get_data() == args.datadata ||
+			    data.get_data().length != data.get_size()) {
+				reply.datadata = new byte[data.get_size()];
+				System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
+			} else
+				reply.datadata = data.get_data();
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+			reply.keydata = reply.datadata = empty;
+		}
+	}
+
+	public  void join(DbDispatcher server,
+		__db_join_msg args, __db_join_reply reply)
+	{
+		try {
+			Dbc[] cursors = new Dbc[args.curs.length + 1];
+			for(int i = 0; i < args.curs.length; i++) {
+				RpcDbc rdbc = server.getCursor(args.curs[i]);
+				if (rdbc == null) {
+					reply.status = Db.DB_NOSERVER_ID;
+					return;
+				}
+				cursors[i] = rdbc.dbc;
+			}
+			cursors[args.curs.length] = null;
+
+			Dbc jdbc = db.join(cursors, args.flags);
+
+			RpcDbc rjdbc = new RpcDbc(this, jdbc, true);
+			/*
+			 * If our curslist has a parent txn, we need to use it too
+			 * for the activity timeout.  All cursors must be part of
+			 * the same transaction, so just check the first.
+			 */
+			RpcDbc rdbc0 = server.getCursor(args.curs[0]);
+			if (rdbc0.timer != rdbc0)
+				rjdbc.timer = rdbc0.timer;
+
+			/*
+			 * All of the curslist cursors must point to the join
+			 * cursor's timeout so that we do not timeout any of the
+			 * curlist cursors while the join cursor is active.
+			 */
+			for(int i = 0; i < args.curs.length; i++) {
+				RpcDbc rdbc = server.getCursor(args.curs[i]);
+				rdbc.orig_timer = rdbc.timer;
+				rdbc.timer = rjdbc;
+			}
+			reply.dbcidcl_id = server.addCursor(rjdbc);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void key_range(DbDispatcher server,
+		__db_key_range_msg args, __db_key_range_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_doff(args.keydoff);
+			key.set_ulen(args.keyulen);
+			key.set_flags(args.keyflags);
+
+			DbKeyRange range = new DbKeyRange();
+
+			db.key_range(txn, key, range, args.flags);
+			reply.status = 0;
+			reply.less = range.less;
+			reply.equal = range.equal;
+			reply.greater = range.greater;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	private boolean findSharedDb(DbDispatcher server, __db_open_reply reply)
+		throws DbException
+	{
+		RpcDb rdb = null;
+		boolean matchFound = false;
+		LocalIterator i = ((DbServer)server).db_list.iterator();
+
+		while (!matchFound && i.hasNext()) {
+			rdb = (RpcDb)i.next();
+			if (rdb != null && rdb != this && rdb.rdbenv == rdbenv &&
+			    (type == Db.DB_UNKNOWN || rdb.type == type) &&
+			    openflags == rdb.openflags &&
+			    setflags == rdb.setflags &&
+			    dbname != null && rdb.dbname != null &&
+			    dbname.equals(rdb.dbname) &&
+			    (subdbname == rdb.subdbname ||
+			     (subdbname != null && rdb.subdbname != null &&
+			      subdbname.equals(rdb.subdbname))))
+				matchFound = true;
+		}
+
+		if (matchFound) {
+			++rdb.refcount;
+			reply.dbcl_id = ((FreeList.FreeListIterator)i).current;
+			reply.type = rdb.db.get_type();
+			reply.dbflags = rdb.db.get_flags_raw();
+			// FIXME: not possible to work out byteorder from Java?
+			reply.lorder = rdb.db.get_byteswapped() ? 4321 : 1234;
+			reply.status = 0;
+
+			DbServer.err.println("Sharing Db: " + reply.dbcl_id);
+		}
+
+		return matchFound;
+	}
+
+	public  void open(DbDispatcher server,
+		__db_open_msg args, __db_open_reply reply)
+	{
+		try {
+			dbname = (args.name.length() > 0) ? args.name : null;
+			subdbname = (args.subdb.length() > 0) ? args.subdb : null;
+			type = args.type;
+			openflags = args.flags & DbServer.DB_SERVER_DBFLAGS;
+
+			if (findSharedDb(server, reply)) {
+				db.close(0);
+				db = null;
+				server.delDb(this);
+			} else {
+				DbServer.err.println("Calling db.open(" + null + ", " + dbname + ", " + subdbname + ", " + args.type + ", " + Integer.toHexString(args.flags) + ", " + args.mode + ")");
+				db.open(null, dbname, subdbname, args.type, args.flags, args.mode);
+
+				reply.dbcl_id = args.dbpcl_id;
+				reply.type = this.type = db.get_type();
+				reply.dbflags = db.get_flags_raw();
+				// FIXME: not possible to work out byteorder from Java?
+				reply.lorder = db.get_byteswapped() ? 4321 : 1234;
+				reply.status = 0;
+			}
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} catch(FileNotFoundException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = Db.DB_NOTFOUND;
+		}
+
+		// System.err.println("Db.open: reply.status = " + reply.status + ", reply.dbcl_id = " + reply.dbcl_id);
+	}
+
+	public  void pget(DbDispatcher server,
+		__db_pget_msg args, __db_pget_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			Dbt skey = new Dbt(args.skeydata);
+			skey.set_dlen(args.skeydlen);
+			skey.set_doff(args.skeydoff);
+			skey.set_ulen(args.skeyulen);
+			skey.set_flags(Db.DB_DBT_MALLOC |
+			    (args.skeyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt pkey = new Dbt(args.pkeydata);
+			pkey.set_dlen(args.pkeydlen);
+			pkey.set_doff(args.pkeydoff);
+			pkey.set_ulen(args.pkeyulen);
+			pkey.set_flags(Db.DB_DBT_MALLOC |
+			    (args.pkeyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_doff(args.datadoff);
+			data.set_ulen(args.dataulen);
+			data.set_flags(Db.DB_DBT_MALLOC |
+			    (args.dataflags & Db.DB_DBT_PARTIAL));
+
+			db.pget(txn, skey, pkey, data, args.flags);
+
+			if (skey.get_data() == args.skeydata ||
+			    skey.get_data().length != skey.get_size()) {
+				reply.skeydata = new byte[skey.get_size()];
+				System.arraycopy(skey.get_data(), 0, reply.skeydata, 0, skey.get_size());
+			} else
+				reply.skeydata = skey.get_data();
+
+			if (pkey.get_data() == args.pkeydata ||
+			    pkey.get_data().length != pkey.get_size()) {
+				reply.pkeydata = new byte[pkey.get_size()];
+				System.arraycopy(pkey.get_data(), 0, reply.pkeydata, 0, pkey.get_size());
+			} else
+				reply.pkeydata = pkey.get_data();
+
+			if (data.get_data() == args.datadata ||
+			    data.get_data().length != data.get_size()) {
+				reply.datadata = new byte[data.get_size()];
+				System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
+			} else
+				reply.datadata = data.get_data();
+
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+			reply.skeydata = reply.pkeydata = reply.datadata = empty;
+		}
+	}
+
+	public  void put(DbDispatcher server,
+		__db_put_msg args, __db_put_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_doff(args.keydoff);
+			key.set_ulen(args.keyulen);
+			key.set_flags(Db.DB_DBT_MALLOC |
+			    (args.keyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_doff(args.datadoff);
+			data.set_ulen(args.dataulen);
+			data.set_flags(args.dataflags);
+
+			reply.status = db.put(txn, key, data, args.flags);
+
+			/*
+			 * If the client did a DB_APPEND, set up key in reply.
+			 * Otherwise just status.
+			 */
+			if ((args.flags & Db.DB_APPEND) != 0) {
+				if (key.get_data() == args.keydata ||
+				    key.get_data().length != key.get_size()) {
+					reply.keydata = new byte[key.get_size()];
+					System.arraycopy(key.get_data(), 0, reply.keydata, 0, key.get_size());
+				} else
+					reply.keydata = key.get_data();
+			} else
+				reply.keydata = empty;
+		} catch(DbException e) {
+			reply.keydata = empty;
+			reply.status = e.get_errno();
+			DbServer.err.println("Exception, setting status to " + reply.status);
+			e.printStackTrace(DbServer.err);
+		}
+	}
+
+	public  void remove(DbDispatcher server,
+		__db_remove_msg args, __db_remove_reply reply)
+	{
+		try {
+			args.name = (args.name.length() > 0) ? args.name : null;
+			args.subdb = (args.subdb.length() > 0) ? args.subdb : null;
+			db.remove(args.name, args.subdb, args.flags);
+			db = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} catch(FileNotFoundException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = Db.DB_NOTFOUND;
+		} finally {
+			server.delDb(this);
+		}
+	}
+
+	public  void rename(DbDispatcher server,
+		__db_rename_msg args, __db_rename_reply reply)
+	{
+		try {
+			args.name = (args.name.length() > 0) ? args.name : null;
+			args.subdb = (args.subdb.length() > 0) ? args.subdb : null;
+			args.newname = (args.newname.length() > 0) ? args.newname : null;
+			db.rename(args.name, args.subdb, args.newname, args.flags);
+			db = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} catch(FileNotFoundException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = Db.DB_NOTFOUND;
+		} finally {
+			server.delDb(this);
+		}
+	}
+
+	public  void set_bt_maxkey(DbDispatcher server,
+		__db_bt_maxkey_msg args, __db_bt_maxkey_reply reply)
+	{
+		try {
+			db.set_bt_maxkey(args.maxkey);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_bt_minkey(DbDispatcher server,
+		__db_bt_minkey_msg args, __db_bt_minkey_reply reply)
+	{
+		try {
+			db.set_bt_minkey(args.minkey);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_encrypt(DbDispatcher server,
+		__db_encrypt_msg args, __db_encrypt_reply reply)
+	{
+		try {
+			db.set_encrypt(args.passwd, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_flags(DbDispatcher server,
+		__db_flags_msg args, __db_flags_reply reply)
+	{
+		try {
+			// DbServer.err.println("Calling db.setflags(" + Integer.toHexString(args.flags) + ")");
+			db.set_flags(args.flags);
+			setflags |= args.flags;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_h_ffactor(DbDispatcher server,
+		__db_h_ffactor_msg args, __db_h_ffactor_reply reply)
+	{
+		try {
+			db.set_h_ffactor(args.ffactor);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_h_nelem(DbDispatcher server,
+		__db_h_nelem_msg args, __db_h_nelem_reply reply)
+	{
+		try {
+			db.set_h_nelem(args.nelem);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_lorder(DbDispatcher server,
+		__db_lorder_msg args, __db_lorder_reply reply)
+	{
+		try {
+			db.set_lorder(args.lorder);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_pagesize(DbDispatcher server,
+		__db_pagesize_msg args, __db_pagesize_reply reply)
+	{
+		try {
+			db.set_pagesize(args.pagesize);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_q_extentsize(DbDispatcher server,
+		__db_extentsize_msg args, __db_extentsize_reply reply)
+	{
+		try {
+			db.set_q_extentsize(args.extentsize);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_re_delim(DbDispatcher server,
+		__db_re_delim_msg args, __db_re_delim_reply reply)
+	{
+		try {
+			db.set_re_delim(args.delim);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_re_len(DbDispatcher server,
+		__db_re_len_msg args, __db_re_len_reply reply)
+	{
+		try {
+			db.set_re_len(args.len);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_re_pad(DbDispatcher server,
+		__db_re_pad_msg args, __db_re_pad_reply reply)
+	{
+		try {
+			db.set_re_pad(args.pad);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void stat(DbDispatcher server,
+		__db_stat_msg args, __db_stat_reply reply)
+	{
+		try {
+			Object raw_stat = db.stat(args.flags);
+
+			if (raw_stat instanceof DbHashStat) {
+				DbHashStat hs = (DbHashStat)raw_stat;
+				int[] raw_stats = {
+					hs.hash_magic, hs.hash_version,
+					hs.hash_metaflags, hs.hash_nkeys,
+					hs.hash_ndata, hs.hash_pagesize,
+					hs.hash_ffactor, hs.hash_buckets,
+					hs.hash_free, hs.hash_bfree,
+					hs.hash_bigpages, hs.hash_big_bfree,
+					hs.hash_overflows, hs.hash_ovfl_free,
+					hs.hash_dup, hs.hash_dup_free
+				};
+				reply.stats = raw_stats;
+			} else if (raw_stat instanceof DbQueueStat) {
+				DbQueueStat qs = (DbQueueStat)raw_stat;
+				int[] raw_stats = {
+					qs.qs_magic, qs.qs_version,
+					qs.qs_metaflags, qs.qs_nkeys,
+					qs.qs_ndata, qs.qs_pagesize,
+					qs.qs_extentsize, qs.qs_pages,
+					qs.qs_re_len, qs.qs_re_pad,
+					qs.qs_pgfree, qs.qs_first_recno,
+					qs.qs_cur_recno
+				};
+				reply.stats = raw_stats;
+			} else if (raw_stat instanceof DbBtreeStat) {
+				DbBtreeStat bs = (DbBtreeStat)raw_stat;
+				int[] raw_stats = {
+					bs.bt_magic, bs.bt_version,
+					bs.bt_metaflags, bs.bt_nkeys,
+					bs.bt_ndata, bs.bt_pagesize,
+					bs.bt_maxkey, bs.bt_minkey,
+					bs.bt_re_len, bs.bt_re_pad,
+					bs.bt_levels, bs.bt_int_pg,
+					bs.bt_leaf_pg, bs.bt_dup_pg,
+					bs.bt_over_pg, bs.bt_free,
+					bs.bt_int_pgfree, bs.bt_leaf_pgfree,
+					bs.bt_dup_pgfree, bs.bt_over_pgfree
+				};
+				reply.stats = raw_stats;
+			} else
+				throw new DbException("Invalid return type from db.stat()", Db.DB_NOTFOUND);
+
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+			reply.stats = new int[0];
+		}
+	}
+
+	public  void sync(DbDispatcher server,
+		__db_sync_msg args, __db_sync_reply reply)
+	{
+		try {
+			db.sync(args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void truncate(DbDispatcher server,
+		__db_truncate_msg args, __db_truncate_reply reply)
+	{
+		try {
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			reply.count = db.truncate(txn, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+}

bdb/rpc_server/java/RpcDbEnv.java

@@ -0,0 +1,269 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: RpcDbEnv.java,v 1.6 2002/08/23 08:45:59 mjc Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+/**
+ * RPC wrapper around a dbenv for the Java RPC server.
+ */
+public class RpcDbEnv extends Timer
+{
+	DbEnv dbenv;
+	String home;
+	long idletime, timeout;
+	int openflags, onflags, offflags;
+	int refcount = 1;
+
+	void dispose()
+	{
+		if (dbenv != null) {
+			try {
+				dbenv.close(0);
+			} catch(DbException e) {
+				e.printStackTrace(DbServer.err);
+			}
+			dbenv = null;
+		}
+	}
+
+	public  void close(DbDispatcher server,
+		__env_close_msg args, __env_close_reply reply)
+	{
+		if (--refcount != 0) {
+			reply.status = 0;
+			return;
+		}
+
+		try {
+			dbenv.close(args.flags);
+			dbenv = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delEnv(this);
+		}
+	}
+
+	public  void create(DbDispatcher server,
+		__env_create_msg args, __env_create_reply reply)
+	{
+		this.idletime = (args.timeout != 0) ? args.timeout : DbServer.idleto;
+		this.timeout = DbServer.defto;
+		try {
+			dbenv = new DbEnv(0);
+			reply.envcl_id = server.addEnv(this);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void dbremove(DbDispatcher server,
+		__env_dbremove_msg args, __env_dbremove_reply reply)
+	{
+		try {
+			args.name = (args.name.length() > 0) ? args.name : null;
+			args.subdb = (args.subdb.length() > 0) ? args.subdb : null;
+
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			dbenv.dbremove(txn, args.name, args.subdb, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void dbrename(DbDispatcher server,
+		__env_dbrename_msg args, __env_dbrename_reply reply)
+	{
+		try {
+			args.name = (args.name.length() > 0) ? args.name : null;
+			args.subdb = (args.subdb.length() > 0) ? args.subdb : null;
+			args.newname = (args.newname.length() > 0) ? args.newname : null;
+
+			RpcDbTxn rtxn = server.getTxn(args.txnpcl_id);
+			DbTxn txn = (rtxn != null) ? rtxn.txn : null;
+			dbenv.dbrename(txn, args.name, args.subdb, args.newname, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	private boolean findSharedDbEnv(DbDispatcher server, __env_open_reply reply)
+		throws DbException
+	{
+		RpcDbEnv rdbenv = null;
+		boolean matchFound = false;
+		LocalIterator i = ((DbServer)server).env_list.iterator();
+
+		while (!matchFound && i.hasNext()) {
+			rdbenv = (RpcDbEnv)i.next();
+			if (rdbenv != null && rdbenv != this &&
+			    (home == rdbenv.home ||
+			     (home != null && home.equals(rdbenv.home))) &&
+			    openflags == rdbenv.openflags &&
+			    onflags == rdbenv.onflags &&
+			    offflags == rdbenv.offflags)
+				matchFound = true;
+		}
+
+		if (matchFound) {
+			/*
+			 * The only thing left to check is the timeout.
+			 * Since the server timeout set by the client is a hint, for sharing
+			 * we'll give them the benefit of the doubt and grant them the
+			 * longer timeout.
+			 */
+			if (rdbenv.timeout < timeout)
+				rdbenv.timeout = timeout;
+
+			++rdbenv.refcount;
+			reply.envcl_id = ((FreeList.FreeListIterator)i).current;
+			reply.status = 0;
+
+			DbServer.err.println("Sharing DbEnv: " + reply.envcl_id);
+		}
+
+		return matchFound;
+	}
+
+	public  void open(DbDispatcher server,
+		__env_open_msg args, __env_open_reply reply)
+	{
+		try {
+			home = (args.home.length() > 0) ? args.home : null;
+
+			/*
+			 * If they are using locking do deadlock detection for them,
+			 * internally.
+			 */
+			if ((args.flags & Db.DB_INIT_LOCK) != 0)
+				dbenv.set_lk_detect(Db.DB_LOCK_DEFAULT);
+
+			// adjust flags for RPC
+			int newflags = (args.flags & ~DbServer.DB_SERVER_FLAGMASK);
+			openflags = (newflags & DbServer.DB_SERVER_ENVFLAGS);
+
+			if (findSharedDbEnv(server, reply)) {
+				dbenv.close(0);
+				dbenv = null;
+				server.delEnv(this);
+			} else {
+				// TODO: check home?
+				dbenv.open(home, newflags, args.mode);
+				reply.status = 0;
+				reply.envcl_id = args.dbenvcl_id;
+			}
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} catch(FileNotFoundException e) {
+			reply.status = Db.DB_NOTFOUND;
+		}
+
+		// System.err.println("DbEnv.open: reply.status = " + reply.status + ", reply.envcl_id = " + reply.envcl_id);
+	}
+
+	public  void remove(DbDispatcher server,
+		__env_remove_msg args, __env_remove_reply reply)
+	{
+		try {
+			args.home = (args.home.length() > 0) ? args.home : null;
+			// TODO: check home?
+
+			dbenv.remove(args.home, args.flags);
+			dbenv = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} catch(FileNotFoundException e) {
+			reply.status = Db.DB_NOTFOUND;
+		} finally {
+			server.delEnv(this);
+		}
+	}
+
+	public  void set_cachesize(DbDispatcher server,
+		__env_cachesize_msg args, __env_cachesize_reply reply)
+	{
+		try {
+			dbenv.set_cachesize(args.gbytes, args.bytes, args.ncache);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_encrypt(DbDispatcher server,
+		__env_encrypt_msg args, __env_encrypt_reply reply)
+	{
+		try {
+			dbenv.set_encrypt(args.passwd, args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void set_flags(DbDispatcher server,
+		__env_flags_msg args, __env_flags_reply reply)
+	{
+		try {
+			dbenv.set_flags(args.flags, args.onoff != 0);
+			if (args.onoff != 0)
+				onflags |= args.flags;
+			else
+				offflags |= args.flags;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	// txn_recover implementation
+	public  void txn_recover(DbDispatcher server,
+		__txn_recover_msg args, __txn_recover_reply reply)
+	{
+		try {
+			DbPreplist[] prep_list = dbenv.txn_recover(args.count, args.flags);
+			if (prep_list != null && prep_list.length > 0) {
+				int count = prep_list.length;
+				reply.retcount = count;
+				reply.txn = new int[count];
+				reply.gid = new byte[count * Db.DB_XIDDATASIZE];
+
+				for(int i = 0; i < count; i++) {
+					reply.txn[i] = server.addTxn(new RpcDbTxn(this, prep_list[i].txn));
+					System.arraycopy(prep_list[i].gid, 0, reply.gid, i * Db.DB_XIDDATASIZE, Db.DB_XIDDATASIZE);
+				}
+			}
+
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+}

bdb/rpc_server/java/RpcDbTxn.java

@@ -0,0 +1,123 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: RpcDbTxn.java,v 1.2 2002/08/09 01:56:10 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+/**
+ * RPC wrapper around a txn object for the Java RPC server.
+ */
+public class RpcDbTxn extends Timer
+{
+	RpcDbEnv rdbenv;
+	DbTxn txn;
+
+	public RpcDbTxn(RpcDbEnv rdbenv, DbTxn txn)
+	{
+		this.rdbenv = rdbenv;
+		this.txn = txn;
+	}
+
+	void dispose()
+	{
+		if (txn != null) {
+			try {
+				txn.abort();
+			} catch(DbException e) {
+				e.printStackTrace(DbServer.err);
+			}
+			txn = null;
+		}
+	}
+
+	public  void abort(DbDispatcher server,
+		__txn_abort_msg args, __txn_abort_reply reply)
+	{
+		try {
+			txn.abort();
+			txn = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delTxn(this);
+		}
+	}
+
+	public  void begin(DbDispatcher server,
+		__txn_begin_msg args, __txn_begin_reply reply)
+	{
+		try {
+			if (rdbenv == null) {
+				reply.status = Db.DB_NOSERVER_ID;
+				return;
+			}
+			DbEnv dbenv = rdbenv.dbenv;
+			RpcDbTxn rparent = server.getTxn(args.parentcl_id);
+			DbTxn parent = (rparent != null) ? rparent.txn : null;
+
+			txn = dbenv.txn_begin(parent, args.flags);
+
+			if (rparent != null)
+				timer = rparent.timer;
+			reply.txnidcl_id = server.addTxn(this);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void commit(DbDispatcher server,
+		__txn_commit_msg args, __txn_commit_reply reply)
+	{
+		try {
+			txn.commit(args.flags);
+			txn = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delTxn(this);
+		}
+	}
+
+	public  void discard(DbDispatcher server,
+		__txn_discard_msg args, __txn_discard_reply reply)
+	{
+		try {
+			txn.discard(args.flags);
+			txn = null;
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delTxn(this);
+		}
+	}
+
+	public  void prepare(DbDispatcher server,
+		__txn_prepare_msg args, __txn_prepare_reply reply)
+	{
+		try {
+			txn.prepare(args.gid);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+}

bdb/rpc_server/java/RpcDbc.java

@@ -0,0 +1,238 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: RpcDbc.java,v 1.3 2002/08/09 01:56:10 bostic Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+import com.sleepycat.db.*;
+import java.io.IOException;
+import java.io.*;
+import java.util.*;
+
+/**
+ * RPC wrapper around a dbc object for the Java RPC server.
+ */
+public class RpcDbc extends Timer
+{
+	static final byte[] empty = new byte[0];
+	RpcDbEnv rdbenv;
+	RpcDb rdb;
+	Dbc dbc;
+	Timer orig_timer;
+	boolean isJoin;
+
+	public RpcDbc(RpcDb rdb, Dbc dbc, boolean isJoin)
+	{
+		this.rdb = rdb;
+		this.rdbenv = rdb.rdbenv;
+		this.dbc = dbc;
+		this.isJoin = isJoin;
+	}
+
+	void dispose()
+	{
+		if (dbc != null) {
+			try {
+				dbc.close();
+			} catch(DbException e) {
+				e.printStackTrace(DbServer.err);
+			}
+			dbc = null;
+		}
+	}
+
+	public  void close(DbDispatcher server,
+		__dbc_close_msg args, __dbc_close_reply reply)
+	{
+		try {
+			dbc.close();
+			dbc = null;
+
+			if (isJoin)
+				for(LocalIterator i = ((DbServer)server).cursor_list.iterator(); i.hasNext(); ) {
+					RpcDbc rdbc = (RpcDbc)i.next();
+					// Unjoin cursors that were joined to create this
+					if (rdbc != null && rdbc.timer == this)
+						rdbc.timer = rdbc.orig_timer;
+				}
+
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		} finally {
+			server.delCursor(this);
+		}
+	}
+
+	public  void count(DbDispatcher server,
+		__dbc_count_msg args, __dbc_count_reply reply)
+	{
+		try {
+			reply.dupcount = dbc.count(args.flags);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void del(DbDispatcher server,
+		__dbc_del_msg args, __dbc_del_reply reply)
+	{
+		try {
+			reply.status = dbc.del(args.flags);
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void dup(DbDispatcher server,
+		__dbc_dup_msg args, __dbc_dup_reply reply)
+	{
+		try {
+			Dbc newdbc = dbc.dup(args.flags);
+			RpcDbc rdbc = new RpcDbc(rdb, newdbc, false);
+			/* If this cursor has a parent txn, we need to use it too. */
+			if (timer != this)
+				rdbc.timer = timer;
+			reply.dbcidcl_id = server.addCursor(rdbc);
+			reply.status = 0;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void get(DbDispatcher server,
+		__dbc_get_msg args, __dbc_get_reply reply)
+	{
+		try {
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_ulen(args.keyulen);
+			key.set_doff(args.keydoff);
+			key.set_flags(Db.DB_DBT_MALLOC |
+			    (args.keyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_ulen(args.dataulen);
+			data.set_doff(args.datadoff);
+			if ((args.flags & Db.DB_MULTIPLE) != 0 ||
+			    (args.flags & Db.DB_MULTIPLE_KEY) != 0) {
+				if (data.get_data().length == 0)
+					data.set_data(new byte[data.get_ulen()]);
+				data.set_flags(Db.DB_DBT_USERMEM |
+				    (args.dataflags & Db.DB_DBT_PARTIAL));
+			} else
+				data.set_flags(Db.DB_DBT_MALLOC |
+				    (args.dataflags & Db.DB_DBT_PARTIAL));
+
+			reply.status = dbc.get(key, data, args.flags);
+
+			if (key.get_data() == args.keydata) {
+				reply.keydata = new byte[key.get_size()];
+				System.arraycopy(key.get_data(), 0, reply.keydata, 0, key.get_size());
+			} else
+				reply.keydata = key.get_data();
+
+			if (data.get_data() == args.datadata) {
+				reply.datadata = new byte[data.get_size()];
+				System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
+			} else
+				reply.datadata = data.get_data();
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+			reply.keydata = reply.datadata = empty;
+		}
+	}
+
+	public  void pget(DbDispatcher server,
+		__dbc_pget_msg args, __dbc_pget_reply reply)
+	{
+		try {
+			Dbt skey = new Dbt(args.skeydata);
+			skey.set_dlen(args.skeydlen);
+			skey.set_doff(args.skeydoff);
+			skey.set_ulen(args.skeyulen);
+			skey.set_flags(Db.DB_DBT_MALLOC |
+			    (args.skeyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt pkey = new Dbt(args.pkeydata);
+			pkey.set_dlen(args.pkeydlen);
+			pkey.set_doff(args.pkeydoff);
+			pkey.set_ulen(args.pkeyulen);
+			pkey.set_flags(Db.DB_DBT_MALLOC |
+			    (args.pkeyflags & Db.DB_DBT_PARTIAL));
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_doff(args.datadoff);
+			data.set_ulen(args.dataulen);
+			data.set_flags(Db.DB_DBT_MALLOC |
+			    (args.dataflags & Db.DB_DBT_PARTIAL));
+
+			reply.status = dbc.pget(skey, pkey, data, args.flags);
+
+			if (skey.get_data() == args.skeydata) {
+				reply.skeydata = new byte[skey.get_size()];
+				System.arraycopy(skey.get_data(), 0, reply.skeydata, 0, skey.get_size());
+			} else
+				reply.skeydata = skey.get_data();
+
+			if (pkey.get_data() == args.pkeydata) {
+				reply.pkeydata = new byte[pkey.get_size()];
+				System.arraycopy(pkey.get_data(), 0, reply.pkeydata, 0, pkey.get_size());
+			} else
+				reply.pkeydata = pkey.get_data();
+
+			if (data.get_data() == args.datadata) {
+				reply.datadata = new byte[data.get_size()];
+				System.arraycopy(data.get_data(), 0, reply.datadata, 0, data.get_size());
+			} else
+				reply.datadata = data.get_data();
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+		}
+	}
+
+	public  void put(DbDispatcher server,
+		__dbc_put_msg args, __dbc_put_reply reply)
+	{
+		try {
+			Dbt key = new Dbt(args.keydata);
+			key.set_dlen(args.keydlen);
+			key.set_ulen(args.keyulen);
+			key.set_doff(args.keydoff);
+			key.set_flags(args.keyflags & Db.DB_DBT_PARTIAL);
+
+			Dbt data = new Dbt(args.datadata);
+			data.set_dlen(args.datadlen);
+			data.set_ulen(args.dataulen);
+			data.set_doff(args.datadoff);
+			data.set_flags(args.dataflags);
+
+			reply.status = dbc.put(key, data, args.flags);
+
+			if (reply.status == 0 &&
+			    (args.flags == Db.DB_AFTER || args.flags == Db.DB_BEFORE) &&
+			    rdb.db.get_type() == Db.DB_RECNO)
+				reply.keydata = key.get_data();
+			else
+				reply.keydata = empty;
+		} catch(DbException e) {
+			e.printStackTrace(DbServer.err);
+			reply.status = e.get_errno();
+			reply.keydata = empty;
+		}
+	}
+}

bdb/rpc_server/java/Timer.java

@@ -0,0 +1,22 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *      Sleepycat Software.  All rights reserved.
+ *
+ * $Id: Timer.java,v 1.1 2002/01/03 02:59:39 mjc Exp $
+ */
+
+package com.sleepycat.db.rpcserver;
+
+/**
+ * Class to keep track of access times. This is slightly devious by having
+ * both the access_time and a reference to another Timer that can be
+ * used to group/share access times. This is done to keep the Java code
+ * close to the canonical C implementation of the RPC server.
+ */
+public class Timer
+{
+	Timer timer = this;
+	long last_access;
+}

bdb/rpc_server/java/gen/DbServerStub.java

@@ -0,0 +1,495 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 3/19/02 10:30 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+import org.acplt.oncrpc.server.*;
+
+/**
+ */
+public abstract class DbServerStub extends OncRpcServerStub implements OncRpcDispatchable {
+
+    public DbServerStub()
+           throws OncRpcException, IOException {
+        this(0);
+    }
+
+    public DbServerStub(int port)
+           throws OncRpcException, IOException {
+        info = new OncRpcServerTransportRegistrationInfo [] {
+            new OncRpcServerTransportRegistrationInfo(db_server.DB_RPC_SERVERPROG, 4001),
+        };
+        transports = new OncRpcServerTransport [] {
+            new OncRpcUdpServerTransport(this, port, info, 32768),
+            new OncRpcTcpServerTransport(this, port, info, 32768)
+        };
+    }
+
+    public void dispatchOncRpcCall(OncRpcCallInformation call, int program, int version, int procedure)
+           throws OncRpcException, IOException {
+        if ( version == 4001 ) {
+            switch ( procedure ) {
+            case 1: {
+                __env_cachesize_msg args$ = new __env_cachesize_msg();
+                call.retrieveCall(args$);
+                __env_cachesize_reply result$ = __DB_env_cachesize_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 2: {
+                __env_close_msg args$ = new __env_close_msg();
+                call.retrieveCall(args$);
+                __env_close_reply result$ = __DB_env_close_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 3: {
+                __env_create_msg args$ = new __env_create_msg();
+                call.retrieveCall(args$);
+                __env_create_reply result$ = __DB_env_create_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 4: {
+                __env_dbremove_msg args$ = new __env_dbremove_msg();
+                call.retrieveCall(args$);
+                __env_dbremove_reply result$ = __DB_env_dbremove_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 5: {
+                __env_dbrename_msg args$ = new __env_dbrename_msg();
+                call.retrieveCall(args$);
+                __env_dbrename_reply result$ = __DB_env_dbrename_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 6: {
+                __env_encrypt_msg args$ = new __env_encrypt_msg();
+                call.retrieveCall(args$);
+                __env_encrypt_reply result$ = __DB_env_encrypt_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 7: {
+                __env_flags_msg args$ = new __env_flags_msg();
+                call.retrieveCall(args$);
+                __env_flags_reply result$ = __DB_env_flags_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 8: {
+                __env_open_msg args$ = new __env_open_msg();
+                call.retrieveCall(args$);
+                __env_open_reply result$ = __DB_env_open_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 9: {
+                __env_remove_msg args$ = new __env_remove_msg();
+                call.retrieveCall(args$);
+                __env_remove_reply result$ = __DB_env_remove_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 10: {
+                __txn_abort_msg args$ = new __txn_abort_msg();
+                call.retrieveCall(args$);
+                __txn_abort_reply result$ = __DB_txn_abort_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 11: {
+                __txn_begin_msg args$ = new __txn_begin_msg();
+                call.retrieveCall(args$);
+                __txn_begin_reply result$ = __DB_txn_begin_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 12: {
+                __txn_commit_msg args$ = new __txn_commit_msg();
+                call.retrieveCall(args$);
+                __txn_commit_reply result$ = __DB_txn_commit_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 13: {
+                __txn_discard_msg args$ = new __txn_discard_msg();
+                call.retrieveCall(args$);
+                __txn_discard_reply result$ = __DB_txn_discard_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 14: {
+                __txn_prepare_msg args$ = new __txn_prepare_msg();
+                call.retrieveCall(args$);
+                __txn_prepare_reply result$ = __DB_txn_prepare_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 15: {
+                __txn_recover_msg args$ = new __txn_recover_msg();
+                call.retrieveCall(args$);
+                __txn_recover_reply result$ = __DB_txn_recover_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 16: {
+                __db_associate_msg args$ = new __db_associate_msg();
+                call.retrieveCall(args$);
+                __db_associate_reply result$ = __DB_db_associate_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 17: {
+                __db_bt_maxkey_msg args$ = new __db_bt_maxkey_msg();
+                call.retrieveCall(args$);
+                __db_bt_maxkey_reply result$ = __DB_db_bt_maxkey_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 18: {
+                __db_bt_minkey_msg args$ = new __db_bt_minkey_msg();
+                call.retrieveCall(args$);
+                __db_bt_minkey_reply result$ = __DB_db_bt_minkey_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 19: {
+                __db_close_msg args$ = new __db_close_msg();
+                call.retrieveCall(args$);
+                __db_close_reply result$ = __DB_db_close_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 20: {
+                __db_create_msg args$ = new __db_create_msg();
+                call.retrieveCall(args$);
+                __db_create_reply result$ = __DB_db_create_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 21: {
+                __db_del_msg args$ = new __db_del_msg();
+                call.retrieveCall(args$);
+                __db_del_reply result$ = __DB_db_del_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 22: {
+                __db_encrypt_msg args$ = new __db_encrypt_msg();
+                call.retrieveCall(args$);
+                __db_encrypt_reply result$ = __DB_db_encrypt_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 23: {
+                __db_extentsize_msg args$ = new __db_extentsize_msg();
+                call.retrieveCall(args$);
+                __db_extentsize_reply result$ = __DB_db_extentsize_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 24: {
+                __db_flags_msg args$ = new __db_flags_msg();
+                call.retrieveCall(args$);
+                __db_flags_reply result$ = __DB_db_flags_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 25: {
+                __db_get_msg args$ = new __db_get_msg();
+                call.retrieveCall(args$);
+                __db_get_reply result$ = __DB_db_get_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 26: {
+                __db_h_ffactor_msg args$ = new __db_h_ffactor_msg();
+                call.retrieveCall(args$);
+                __db_h_ffactor_reply result$ = __DB_db_h_ffactor_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 27: {
+                __db_h_nelem_msg args$ = new __db_h_nelem_msg();
+                call.retrieveCall(args$);
+                __db_h_nelem_reply result$ = __DB_db_h_nelem_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 28: {
+                __db_key_range_msg args$ = new __db_key_range_msg();
+                call.retrieveCall(args$);
+                __db_key_range_reply result$ = __DB_db_key_range_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 29: {
+                __db_lorder_msg args$ = new __db_lorder_msg();
+                call.retrieveCall(args$);
+                __db_lorder_reply result$ = __DB_db_lorder_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 30: {
+                __db_open_msg args$ = new __db_open_msg();
+                call.retrieveCall(args$);
+                __db_open_reply result$ = __DB_db_open_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 31: {
+                __db_pagesize_msg args$ = new __db_pagesize_msg();
+                call.retrieveCall(args$);
+                __db_pagesize_reply result$ = __DB_db_pagesize_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 32: {
+                __db_pget_msg args$ = new __db_pget_msg();
+                call.retrieveCall(args$);
+                __db_pget_reply result$ = __DB_db_pget_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 33: {
+                __db_put_msg args$ = new __db_put_msg();
+                call.retrieveCall(args$);
+                __db_put_reply result$ = __DB_db_put_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 34: {
+                __db_re_delim_msg args$ = new __db_re_delim_msg();
+                call.retrieveCall(args$);
+                __db_re_delim_reply result$ = __DB_db_re_delim_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 35: {
+                __db_re_len_msg args$ = new __db_re_len_msg();
+                call.retrieveCall(args$);
+                __db_re_len_reply result$ = __DB_db_re_len_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 36: {
+                __db_re_pad_msg args$ = new __db_re_pad_msg();
+                call.retrieveCall(args$);
+                __db_re_pad_reply result$ = __DB_db_re_pad_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 37: {
+                __db_remove_msg args$ = new __db_remove_msg();
+                call.retrieveCall(args$);
+                __db_remove_reply result$ = __DB_db_remove_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 38: {
+                __db_rename_msg args$ = new __db_rename_msg();
+                call.retrieveCall(args$);
+                __db_rename_reply result$ = __DB_db_rename_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 39: {
+                __db_stat_msg args$ = new __db_stat_msg();
+                call.retrieveCall(args$);
+                __db_stat_reply result$ = __DB_db_stat_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 40: {
+                __db_sync_msg args$ = new __db_sync_msg();
+                call.retrieveCall(args$);
+                __db_sync_reply result$ = __DB_db_sync_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 41: {
+                __db_truncate_msg args$ = new __db_truncate_msg();
+                call.retrieveCall(args$);
+                __db_truncate_reply result$ = __DB_db_truncate_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 42: {
+                __db_cursor_msg args$ = new __db_cursor_msg();
+                call.retrieveCall(args$);
+                __db_cursor_reply result$ = __DB_db_cursor_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 43: {
+                __db_join_msg args$ = new __db_join_msg();
+                call.retrieveCall(args$);
+                __db_join_reply result$ = __DB_db_join_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 44: {
+                __dbc_close_msg args$ = new __dbc_close_msg();
+                call.retrieveCall(args$);
+                __dbc_close_reply result$ = __DB_dbc_close_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 45: {
+                __dbc_count_msg args$ = new __dbc_count_msg();
+                call.retrieveCall(args$);
+                __dbc_count_reply result$ = __DB_dbc_count_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 46: {
+                __dbc_del_msg args$ = new __dbc_del_msg();
+                call.retrieveCall(args$);
+                __dbc_del_reply result$ = __DB_dbc_del_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 47: {
+                __dbc_dup_msg args$ = new __dbc_dup_msg();
+                call.retrieveCall(args$);
+                __dbc_dup_reply result$ = __DB_dbc_dup_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 48: {
+                __dbc_get_msg args$ = new __dbc_get_msg();
+                call.retrieveCall(args$);
+                __dbc_get_reply result$ = __DB_dbc_get_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 49: {
+                __dbc_pget_msg args$ = new __dbc_pget_msg();
+                call.retrieveCall(args$);
+                __dbc_pget_reply result$ = __DB_dbc_pget_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            case 50: {
+                __dbc_put_msg args$ = new __dbc_put_msg();
+                call.retrieveCall(args$);
+                __dbc_put_reply result$ = __DB_dbc_put_4001(args$);
+                call.reply(result$);
+                break;
+            }
+            default:
+                call.failProcedureUnavailable();
+            }
+        } else {
+            call.failProcedureUnavailable();
+        }
+    }
+
+    public abstract __env_cachesize_reply __DB_env_cachesize_4001(__env_cachesize_msg arg1);
+
+    public abstract __env_close_reply __DB_env_close_4001(__env_close_msg arg1);
+
+    public abstract __env_create_reply __DB_env_create_4001(__env_create_msg arg1);
+
+    public abstract __env_dbremove_reply __DB_env_dbremove_4001(__env_dbremove_msg arg1);
+
+    public abstract __env_dbrename_reply __DB_env_dbrename_4001(__env_dbrename_msg arg1);
+
+    public abstract __env_encrypt_reply __DB_env_encrypt_4001(__env_encrypt_msg arg1);
+
+    public abstract __env_flags_reply __DB_env_flags_4001(__env_flags_msg arg1);
+
+    public abstract __env_open_reply __DB_env_open_4001(__env_open_msg arg1);
+
+    public abstract __env_remove_reply __DB_env_remove_4001(__env_remove_msg arg1);
+
+    public abstract __txn_abort_reply __DB_txn_abort_4001(__txn_abort_msg arg1);
+
+    public abstract __txn_begin_reply __DB_txn_begin_4001(__txn_begin_msg arg1);
+
+    public abstract __txn_commit_reply __DB_txn_commit_4001(__txn_commit_msg arg1);
+
+    public abstract __txn_discard_reply __DB_txn_discard_4001(__txn_discard_msg arg1);
+
+    public abstract __txn_prepare_reply __DB_txn_prepare_4001(__txn_prepare_msg arg1);
+
+    public abstract __txn_recover_reply __DB_txn_recover_4001(__txn_recover_msg arg1);
+
+    public abstract __db_associate_reply __DB_db_associate_4001(__db_associate_msg arg1);
+
+    public abstract __db_bt_maxkey_reply __DB_db_bt_maxkey_4001(__db_bt_maxkey_msg arg1);
+
+    public abstract __db_bt_minkey_reply __DB_db_bt_minkey_4001(__db_bt_minkey_msg arg1);
+
+    public abstract __db_close_reply __DB_db_close_4001(__db_close_msg arg1);
+
+    public abstract __db_create_reply __DB_db_create_4001(__db_create_msg arg1);
+
+    public abstract __db_del_reply __DB_db_del_4001(__db_del_msg arg1);
+
+    public abstract __db_encrypt_reply __DB_db_encrypt_4001(__db_encrypt_msg arg1);
+
+    public abstract __db_extentsize_reply __DB_db_extentsize_4001(__db_extentsize_msg arg1);
+
+    public abstract __db_flags_reply __DB_db_flags_4001(__db_flags_msg arg1);
+
+    public abstract __db_get_reply __DB_db_get_4001(__db_get_msg arg1);
+
+    public abstract __db_h_ffactor_reply __DB_db_h_ffactor_4001(__db_h_ffactor_msg arg1);
+
+    public abstract __db_h_nelem_reply __DB_db_h_nelem_4001(__db_h_nelem_msg arg1);
+
+    public abstract __db_key_range_reply __DB_db_key_range_4001(__db_key_range_msg arg1);
+
+    public abstract __db_lorder_reply __DB_db_lorder_4001(__db_lorder_msg arg1);
+
+    public abstract __db_open_reply __DB_db_open_4001(__db_open_msg arg1);
+
+    public abstract __db_pagesize_reply __DB_db_pagesize_4001(__db_pagesize_msg arg1);
+
+    public abstract __db_pget_reply __DB_db_pget_4001(__db_pget_msg arg1);
+
+    public abstract __db_put_reply __DB_db_put_4001(__db_put_msg arg1);
+
+    public abstract __db_re_delim_reply __DB_db_re_delim_4001(__db_re_delim_msg arg1);
+
+    public abstract __db_re_len_reply __DB_db_re_len_4001(__db_re_len_msg arg1);
+
+    public abstract __db_re_pad_reply __DB_db_re_pad_4001(__db_re_pad_msg arg1);
+
+    public abstract __db_remove_reply __DB_db_remove_4001(__db_remove_msg arg1);
+
+    public abstract __db_rename_reply __DB_db_rename_4001(__db_rename_msg arg1);
+
+    public abstract __db_stat_reply __DB_db_stat_4001(__db_stat_msg arg1);
+
+    public abstract __db_sync_reply __DB_db_sync_4001(__db_sync_msg arg1);
+
+    public abstract __db_truncate_reply __DB_db_truncate_4001(__db_truncate_msg arg1);
+
+    public abstract __db_cursor_reply __DB_db_cursor_4001(__db_cursor_msg arg1);
+
+    public abstract __db_join_reply __DB_db_join_4001(__db_join_msg arg1);
+
+    public abstract __dbc_close_reply __DB_dbc_close_4001(__dbc_close_msg arg1);
+
+    public abstract __dbc_count_reply __DB_dbc_count_4001(__dbc_count_msg arg1);
+
+    public abstract __dbc_del_reply __DB_dbc_del_4001(__dbc_del_msg arg1);
+
+    public abstract __dbc_dup_reply __DB_dbc_dup_4001(__dbc_dup_msg arg1);
+
+    public abstract __dbc_get_reply __DB_dbc_get_4001(__dbc_get_msg arg1);
+
+    public abstract __dbc_pget_reply __DB_dbc_pget_4001(__dbc_pget_msg arg1);
+
+    public abstract __dbc_put_reply __DB_dbc_put_4001(__dbc_put_msg arg1);
+
+}
+// End of DbServerStub.java

bdb/rpc_server/java/gen/__db_associate_msg.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 4/25/02 11:01 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_associate_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int sdbpcl_id;
+    public int flags;
+
+    public __db_associate_msg() {
+    }
+
+    public __db_associate_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(sdbpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        sdbpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_associate_msg.java

bdb/rpc_server/java/gen/__db_associate_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_associate_reply implements XdrAble {
+    public int status;
+
+    public __db_associate_reply() {
+    }
+
+    public __db_associate_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_associate_reply.java

bdb/rpc_server/java/gen/__db_bt_maxkey_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_bt_maxkey_msg implements XdrAble {
+    public int dbpcl_id;
+    public int maxkey;
+
+    public __db_bt_maxkey_msg() {
+    }
+
+    public __db_bt_maxkey_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(maxkey);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        maxkey = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_bt_maxkey_msg.java

bdb/rpc_server/java/gen/__db_bt_maxkey_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_bt_maxkey_reply implements XdrAble {
+    public int status;
+
+    public __db_bt_maxkey_reply() {
+    }
+
+    public __db_bt_maxkey_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_bt_maxkey_reply.java

bdb/rpc_server/java/gen/__db_bt_minkey_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_bt_minkey_msg implements XdrAble {
+    public int dbpcl_id;
+    public int minkey;
+
+    public __db_bt_minkey_msg() {
+    }
+
+    public __db_bt_minkey_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(minkey);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        minkey = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_bt_minkey_msg.java

bdb/rpc_server/java/gen/__db_bt_minkey_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_bt_minkey_reply implements XdrAble {
+    public int status;
+
+    public __db_bt_minkey_reply() {
+    }
+
+    public __db_bt_minkey_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_bt_minkey_reply.java

bdb/rpc_server/java/gen/__db_close_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_close_msg implements XdrAble {
+    public int dbpcl_id;
+    public int flags;
+
+    public __db_close_msg() {
+    }
+
+    public __db_close_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_close_msg.java

bdb/rpc_server/java/gen/__db_close_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_close_reply implements XdrAble {
+    public int status;
+
+    public __db_close_reply() {
+    }
+
+    public __db_close_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_close_reply.java

bdb/rpc_server/java/gen/__db_create_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_create_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int flags;
+
+    public __db_create_msg() {
+    }
+
+    public __db_create_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_create_msg.java

bdb/rpc_server/java/gen/__db_create_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_create_reply implements XdrAble {
+    public int status;
+    public int dbcl_id;
+
+    public __db_create_reply() {
+    }
+
+    public __db_create_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dbcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dbcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_create_reply.java

bdb/rpc_server/java/gen/__db_cursor_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_cursor_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int flags;
+
+    public __db_cursor_msg() {
+    }
+
+    public __db_cursor_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_cursor_msg.java

bdb/rpc_server/java/gen/__db_cursor_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_cursor_reply implements XdrAble {
+    public int status;
+    public int dbcidcl_id;
+
+    public __db_cursor_reply() {
+    }
+
+    public __db_cursor_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dbcidcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dbcidcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_cursor_reply.java

bdb/rpc_server/java/gen/__db_del_msg.java

@@ -0,0 +1,53 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_del_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int flags;
+
+    public __db_del_msg() {
+    }
+
+    public __db_del_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_del_msg.java

bdb/rpc_server/java/gen/__db_del_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_del_reply implements XdrAble {
+    public int status;
+
+    public __db_del_reply() {
+    }
+
+    public __db_del_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_del_reply.java

bdb/rpc_server/java/gen/__db_encrypt_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 2/13/02 1:05 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_encrypt_msg implements XdrAble {
+    public int dbpcl_id;
+    public String passwd;
+    public int flags;
+
+    public __db_encrypt_msg() {
+    }
+
+    public __db_encrypt_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeString(passwd);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        passwd = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_encrypt_msg.java

bdb/rpc_server/java/gen/__db_encrypt_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 2/13/02 1:05 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_encrypt_reply implements XdrAble {
+    public int status;
+
+    public __db_encrypt_reply() {
+    }
+
+    public __db_encrypt_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_encrypt_reply.java

bdb/rpc_server/java/gen/__db_extentsize_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_extentsize_msg implements XdrAble {
+    public int dbpcl_id;
+    public int extentsize;
+
+    public __db_extentsize_msg() {
+    }
+
+    public __db_extentsize_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(extentsize);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        extentsize = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_extentsize_msg.java

bdb/rpc_server/java/gen/__db_extentsize_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_extentsize_reply implements XdrAble {
+    public int status;
+
+    public __db_extentsize_reply() {
+    }
+
+    public __db_extentsize_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_extentsize_reply.java

bdb/rpc_server/java/gen/__db_flags_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_flags_msg implements XdrAble {
+    public int dbpcl_id;
+    public int flags;
+
+    public __db_flags_msg() {
+    }
+
+    public __db_flags_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_flags_msg.java

bdb/rpc_server/java/gen/__db_flags_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_flags_reply implements XdrAble {
+    public int status;
+
+    public __db_flags_reply() {
+    }
+
+    public __db_flags_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_flags_reply.java

bdb/rpc_server/java/gen/__db_get_msg.java

@@ -0,0 +1,68 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_get_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __db_get_msg() {
+    }
+
+    public __db_get_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_get_msg.java

bdb/rpc_server/java/gen/__db_get_reply.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_get_reply implements XdrAble {
+    public int status;
+    public byte [] keydata;
+    public byte [] datadata;
+
+    public __db_get_reply() {
+    }
+
+    public __db_get_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __db_get_reply.java

bdb/rpc_server/java/gen/__db_h_ffactor_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_h_ffactor_msg implements XdrAble {
+    public int dbpcl_id;
+    public int ffactor;
+
+    public __db_h_ffactor_msg() {
+    }
+
+    public __db_h_ffactor_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(ffactor);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        ffactor = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_h_ffactor_msg.java

bdb/rpc_server/java/gen/__db_h_ffactor_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_h_ffactor_reply implements XdrAble {
+    public int status;
+
+    public __db_h_ffactor_reply() {
+    }
+
+    public __db_h_ffactor_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_h_ffactor_reply.java

bdb/rpc_server/java/gen/__db_h_nelem_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_h_nelem_msg implements XdrAble {
+    public int dbpcl_id;
+    public int nelem;
+
+    public __db_h_nelem_msg() {
+    }
+
+    public __db_h_nelem_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(nelem);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        nelem = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_h_nelem_msg.java

bdb/rpc_server/java/gen/__db_h_nelem_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_h_nelem_reply implements XdrAble {
+    public int status;
+
+    public __db_h_nelem_reply() {
+    }
+
+    public __db_h_nelem_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_h_nelem_reply.java

bdb/rpc_server/java/gen/__db_join_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_join_msg implements XdrAble {
+    public int dbpcl_id;
+    public int [] curs;
+    public int flags;
+
+    public __db_join_msg() {
+    }
+
+    public __db_join_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeIntVector(curs);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        curs = xdr.xdrDecodeIntVector();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_join_msg.java

bdb/rpc_server/java/gen/__db_join_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_join_reply implements XdrAble {
+    public int status;
+    public int dbcidcl_id;
+
+    public __db_join_reply() {
+    }
+
+    public __db_join_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dbcidcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dbcidcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_join_reply.java

bdb/rpc_server/java/gen/__db_key_range_msg.java

@@ -0,0 +1,53 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_key_range_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int flags;
+
+    public __db_key_range_msg() {
+    }
+
+    public __db_key_range_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_key_range_msg.java

bdb/rpc_server/java/gen/__db_key_range_reply.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_key_range_reply implements XdrAble {
+    public int status;
+    public double less;
+    public double equal;
+    public double greater;
+
+    public __db_key_range_reply() {
+    }
+
+    public __db_key_range_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDouble(less);
+        xdr.xdrEncodeDouble(equal);
+        xdr.xdrEncodeDouble(greater);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        less = xdr.xdrDecodeDouble();
+        equal = xdr.xdrDecodeDouble();
+        greater = xdr.xdrDecodeDouble();
+    }
+
+}
+// End of __db_key_range_reply.java

bdb/rpc_server/java/gen/__db_lorder_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_lorder_msg implements XdrAble {
+    public int dbpcl_id;
+    public int lorder;
+
+    public __db_lorder_msg() {
+    }
+
+    public __db_lorder_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(lorder);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        lorder = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_lorder_msg.java

bdb/rpc_server/java/gen/__db_lorder_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_lorder_reply implements XdrAble {
+    public int status;
+
+    public __db_lorder_reply() {
+    }
+
+    public __db_lorder_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_lorder_reply.java

bdb/rpc_server/java/gen/__db_open_msg.java

@@ -0,0 +1,50 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 2/13/02 1:05 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_open_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public String name;
+    public String subdb;
+    public int type;
+    public int flags;
+    public int mode;
+
+    public __db_open_msg() {
+    }
+
+    public __db_open_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeString(name);
+        xdr.xdrEncodeString(subdb);
+        xdr.xdrEncodeInt(type);
+        xdr.xdrEncodeInt(flags);
+        xdr.xdrEncodeInt(mode);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        name = xdr.xdrDecodeString();
+        subdb = xdr.xdrDecodeString();
+        type = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+        mode = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_open_msg.java

bdb/rpc_server/java/gen/__db_open_reply.java

@@ -0,0 +1,44 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_open_reply implements XdrAble {
+    public int status;
+    public int dbcl_id;
+    public int type;
+    public int dbflags;
+    public int lorder;
+
+    public __db_open_reply() {
+    }
+
+    public __db_open_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dbcl_id);
+        xdr.xdrEncodeInt(type);
+        xdr.xdrEncodeInt(dbflags);
+        xdr.xdrEncodeInt(lorder);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dbcl_id = xdr.xdrDecodeInt();
+        type = xdr.xdrDecodeInt();
+        dbflags = xdr.xdrDecodeInt();
+        lorder = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_open_reply.java

bdb/rpc_server/java/gen/__db_pagesize_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_pagesize_msg implements XdrAble {
+    public int dbpcl_id;
+    public int pagesize;
+
+    public __db_pagesize_msg() {
+    }
+
+    public __db_pagesize_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(pagesize);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        pagesize = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_pagesize_msg.java

bdb/rpc_server/java/gen/__db_pagesize_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_pagesize_reply implements XdrAble {
+    public int status;
+
+    public __db_pagesize_reply() {
+    }
+
+    public __db_pagesize_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_pagesize_reply.java

bdb/rpc_server/java/gen/__db_pget_msg.java

@@ -0,0 +1,83 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_pget_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int skeydlen;
+    public int skeydoff;
+    public int skeyulen;
+    public int skeyflags;
+    public byte [] skeydata;
+    public int pkeydlen;
+    public int pkeydoff;
+    public int pkeyulen;
+    public int pkeyflags;
+    public byte [] pkeydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __db_pget_msg() {
+    }
+
+    public __db_pget_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(skeydlen);
+        xdr.xdrEncodeInt(skeydoff);
+        xdr.xdrEncodeInt(skeyulen);
+        xdr.xdrEncodeInt(skeyflags);
+        xdr.xdrEncodeDynamicOpaque(skeydata);
+        xdr.xdrEncodeInt(pkeydlen);
+        xdr.xdrEncodeInt(pkeydoff);
+        xdr.xdrEncodeInt(pkeyulen);
+        xdr.xdrEncodeInt(pkeyflags);
+        xdr.xdrEncodeDynamicOpaque(pkeydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        skeydlen = xdr.xdrDecodeInt();
+        skeydoff = xdr.xdrDecodeInt();
+        skeyulen = xdr.xdrDecodeInt();
+        skeyflags = xdr.xdrDecodeInt();
+        skeydata = xdr.xdrDecodeDynamicOpaque();
+        pkeydlen = xdr.xdrDecodeInt();
+        pkeydoff = xdr.xdrDecodeInt();
+        pkeyulen = xdr.xdrDecodeInt();
+        pkeyflags = xdr.xdrDecodeInt();
+        pkeydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_pget_msg.java

bdb/rpc_server/java/gen/__db_pget_reply.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_pget_reply implements XdrAble {
+    public int status;
+    public byte [] skeydata;
+    public byte [] pkeydata;
+    public byte [] datadata;
+
+    public __db_pget_reply() {
+    }
+
+    public __db_pget_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(skeydata);
+        xdr.xdrEncodeDynamicOpaque(pkeydata);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        skeydata = xdr.xdrDecodeDynamicOpaque();
+        pkeydata = xdr.xdrDecodeDynamicOpaque();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __db_pget_reply.java

bdb/rpc_server/java/gen/__db_put_msg.java

@@ -0,0 +1,68 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_put_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __db_put_msg() {
+    }
+
+    public __db_put_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_put_msg.java

bdb/rpc_server/java/gen/__db_put_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_put_reply implements XdrAble {
+    public int status;
+    public byte [] keydata;
+
+    public __db_put_reply() {
+    }
+
+    public __db_put_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __db_put_reply.java

bdb/rpc_server/java/gen/__db_re_delim_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_delim_msg implements XdrAble {
+    public int dbpcl_id;
+    public int delim;
+
+    public __db_re_delim_msg() {
+    }
+
+    public __db_re_delim_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(delim);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        delim = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_delim_msg.java

bdb/rpc_server/java/gen/__db_re_delim_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_delim_reply implements XdrAble {
+    public int status;
+
+    public __db_re_delim_reply() {
+    }
+
+    public __db_re_delim_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_delim_reply.java

bdb/rpc_server/java/gen/__db_re_len_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_len_msg implements XdrAble {
+    public int dbpcl_id;
+    public int len;
+
+    public __db_re_len_msg() {
+    }
+
+    public __db_re_len_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(len);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        len = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_len_msg.java

bdb/rpc_server/java/gen/__db_re_len_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_len_reply implements XdrAble {
+    public int status;
+
+    public __db_re_len_reply() {
+    }
+
+    public __db_re_len_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_len_reply.java

bdb/rpc_server/java/gen/__db_re_pad_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_pad_msg implements XdrAble {
+    public int dbpcl_id;
+    public int pad;
+
+    public __db_re_pad_msg() {
+    }
+
+    public __db_re_pad_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(pad);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        pad = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_pad_msg.java

bdb/rpc_server/java/gen/__db_re_pad_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_re_pad_reply implements XdrAble {
+    public int status;
+
+    public __db_re_pad_reply() {
+    }
+
+    public __db_re_pad_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_re_pad_reply.java

bdb/rpc_server/java/gen/__db_remove_msg.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_remove_msg implements XdrAble {
+    public int dbpcl_id;
+    public String name;
+    public String subdb;
+    public int flags;
+
+    public __db_remove_msg() {
+    }
+
+    public __db_remove_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeString(name);
+        xdr.xdrEncodeString(subdb);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        name = xdr.xdrDecodeString();
+        subdb = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_remove_msg.java

bdb/rpc_server/java/gen/__db_remove_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_remove_reply implements XdrAble {
+    public int status;
+
+    public __db_remove_reply() {
+    }
+
+    public __db_remove_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_remove_reply.java

bdb/rpc_server/java/gen/__db_rename_msg.java

@@ -0,0 +1,44 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_rename_msg implements XdrAble {
+    public int dbpcl_id;
+    public String name;
+    public String subdb;
+    public String newname;
+    public int flags;
+
+    public __db_rename_msg() {
+    }
+
+    public __db_rename_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeString(name);
+        xdr.xdrEncodeString(subdb);
+        xdr.xdrEncodeString(newname);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        name = xdr.xdrDecodeString();
+        subdb = xdr.xdrDecodeString();
+        newname = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_rename_msg.java

bdb/rpc_server/java/gen/__db_rename_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_rename_reply implements XdrAble {
+    public int status;
+
+    public __db_rename_reply() {
+    }
+
+    public __db_rename_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_rename_reply.java

bdb/rpc_server/java/gen/__db_stat_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_stat_msg implements XdrAble {
+    public int dbpcl_id;
+    public int flags;
+
+    public __db_stat_msg() {
+    }
+
+    public __db_stat_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_stat_msg.java

bdb/rpc_server/java/gen/__db_stat_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_stat_reply implements XdrAble {
+    public int status;
+    public int [] stats;
+
+    public __db_stat_reply() {
+    }
+
+    public __db_stat_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeIntVector(stats);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        stats = xdr.xdrDecodeIntVector();
+    }
+
+}
+// End of __db_stat_reply.java

bdb/rpc_server/java/gen/__db_sync_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_sync_msg implements XdrAble {
+    public int dbpcl_id;
+    public int flags;
+
+    public __db_sync_msg() {
+    }
+
+    public __db_sync_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_sync_msg.java

bdb/rpc_server/java/gen/__db_sync_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_sync_reply implements XdrAble {
+    public int status;
+
+    public __db_sync_reply() {
+    }
+
+    public __db_sync_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_sync_reply.java

bdb/rpc_server/java/gen/__db_truncate_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_truncate_msg implements XdrAble {
+    public int dbpcl_id;
+    public int txnpcl_id;
+    public int flags;
+
+    public __db_truncate_msg() {
+    }
+
+    public __db_truncate_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbpcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbpcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_truncate_msg.java

bdb/rpc_server/java/gen/__db_truncate_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __db_truncate_reply implements XdrAble {
+    public int status;
+    public int count;
+
+    public __db_truncate_reply() {
+    }
+
+    public __db_truncate_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(count);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        count = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __db_truncate_reply.java

bdb/rpc_server/java/gen/__dbc_close_msg.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_close_msg implements XdrAble {
+    public int dbccl_id;
+
+    public __dbc_close_msg() {
+    }
+
+    public __dbc_close_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_close_msg.java

bdb/rpc_server/java/gen/__dbc_close_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_close_reply implements XdrAble {
+    public int status;
+
+    public __dbc_close_reply() {
+    }
+
+    public __dbc_close_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_close_reply.java

bdb/rpc_server/java/gen/__dbc_count_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_count_msg implements XdrAble {
+    public int dbccl_id;
+    public int flags;
+
+    public __dbc_count_msg() {
+    }
+
+    public __dbc_count_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_count_msg.java

bdb/rpc_server/java/gen/__dbc_count_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_count_reply implements XdrAble {
+    public int status;
+    public int dupcount;
+
+    public __dbc_count_reply() {
+    }
+
+    public __dbc_count_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dupcount);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dupcount = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_count_reply.java

bdb/rpc_server/java/gen/__dbc_del_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_del_msg implements XdrAble {
+    public int dbccl_id;
+    public int flags;
+
+    public __dbc_del_msg() {
+    }
+
+    public __dbc_del_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_del_msg.java

bdb/rpc_server/java/gen/__dbc_del_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_del_reply implements XdrAble {
+    public int status;
+
+    public __dbc_del_reply() {
+    }
+
+    public __dbc_del_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_del_reply.java

bdb/rpc_server/java/gen/__dbc_dup_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_dup_msg implements XdrAble {
+    public int dbccl_id;
+    public int flags;
+
+    public __dbc_dup_msg() {
+    }
+
+    public __dbc_dup_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_dup_msg.java

bdb/rpc_server/java/gen/__dbc_dup_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_dup_reply implements XdrAble {
+    public int status;
+    public int dbcidcl_id;
+
+    public __dbc_dup_reply() {
+    }
+
+    public __dbc_dup_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(dbcidcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        dbcidcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_dup_reply.java

bdb/rpc_server/java/gen/__dbc_get_msg.java

@@ -0,0 +1,65 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_get_msg implements XdrAble {
+    public int dbccl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __dbc_get_msg() {
+    }
+
+    public __dbc_get_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_get_msg.java

bdb/rpc_server/java/gen/__dbc_get_reply.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_get_reply implements XdrAble {
+    public int status;
+    public byte [] keydata;
+    public byte [] datadata;
+
+    public __dbc_get_reply() {
+    }
+
+    public __dbc_get_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __dbc_get_reply.java

bdb/rpc_server/java/gen/__dbc_pget_msg.java

@@ -0,0 +1,80 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_pget_msg implements XdrAble {
+    public int dbccl_id;
+    public int skeydlen;
+    public int skeydoff;
+    public int skeyulen;
+    public int skeyflags;
+    public byte [] skeydata;
+    public int pkeydlen;
+    public int pkeydoff;
+    public int pkeyulen;
+    public int pkeyflags;
+    public byte [] pkeydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __dbc_pget_msg() {
+    }
+
+    public __dbc_pget_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(skeydlen);
+        xdr.xdrEncodeInt(skeydoff);
+        xdr.xdrEncodeInt(skeyulen);
+        xdr.xdrEncodeInt(skeyflags);
+        xdr.xdrEncodeDynamicOpaque(skeydata);
+        xdr.xdrEncodeInt(pkeydlen);
+        xdr.xdrEncodeInt(pkeydoff);
+        xdr.xdrEncodeInt(pkeyulen);
+        xdr.xdrEncodeInt(pkeyflags);
+        xdr.xdrEncodeDynamicOpaque(pkeydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        skeydlen = xdr.xdrDecodeInt();
+        skeydoff = xdr.xdrDecodeInt();
+        skeyulen = xdr.xdrDecodeInt();
+        skeyflags = xdr.xdrDecodeInt();
+        skeydata = xdr.xdrDecodeDynamicOpaque();
+        pkeydlen = xdr.xdrDecodeInt();
+        pkeydoff = xdr.xdrDecodeInt();
+        pkeyulen = xdr.xdrDecodeInt();
+        pkeyflags = xdr.xdrDecodeInt();
+        pkeydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_pget_msg.java

bdb/rpc_server/java/gen/__dbc_pget_reply.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_pget_reply implements XdrAble {
+    public int status;
+    public byte [] skeydata;
+    public byte [] pkeydata;
+    public byte [] datadata;
+
+    public __dbc_pget_reply() {
+    }
+
+    public __dbc_pget_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(skeydata);
+        xdr.xdrEncodeDynamicOpaque(pkeydata);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        skeydata = xdr.xdrDecodeDynamicOpaque();
+        pkeydata = xdr.xdrDecodeDynamicOpaque();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __dbc_pget_reply.java

bdb/rpc_server/java/gen/__dbc_put_msg.java

@@ -0,0 +1,65 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_put_msg implements XdrAble {
+    public int dbccl_id;
+    public int keydlen;
+    public int keydoff;
+    public int keyulen;
+    public int keyflags;
+    public byte [] keydata;
+    public int datadlen;
+    public int datadoff;
+    public int dataulen;
+    public int dataflags;
+    public byte [] datadata;
+    public int flags;
+
+    public __dbc_put_msg() {
+    }
+
+    public __dbc_put_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbccl_id);
+        xdr.xdrEncodeInt(keydlen);
+        xdr.xdrEncodeInt(keydoff);
+        xdr.xdrEncodeInt(keyulen);
+        xdr.xdrEncodeInt(keyflags);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+        xdr.xdrEncodeInt(datadlen);
+        xdr.xdrEncodeInt(datadoff);
+        xdr.xdrEncodeInt(dataulen);
+        xdr.xdrEncodeInt(dataflags);
+        xdr.xdrEncodeDynamicOpaque(datadata);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbccl_id = xdr.xdrDecodeInt();
+        keydlen = xdr.xdrDecodeInt();
+        keydoff = xdr.xdrDecodeInt();
+        keyulen = xdr.xdrDecodeInt();
+        keyflags = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+        datadlen = xdr.xdrDecodeInt();
+        datadoff = xdr.xdrDecodeInt();
+        dataulen = xdr.xdrDecodeInt();
+        dataflags = xdr.xdrDecodeInt();
+        datadata = xdr.xdrDecodeDynamicOpaque();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __dbc_put_msg.java

bdb/rpc_server/java/gen/__dbc_put_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __dbc_put_reply implements XdrAble {
+    public int status;
+    public byte [] keydata;
+
+    public __dbc_put_reply() {
+    }
+
+    public __dbc_put_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeDynamicOpaque(keydata);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        keydata = xdr.xdrDecodeDynamicOpaque();
+    }
+
+}
+// End of __dbc_put_reply.java

bdb/rpc_server/java/gen/__env_cachesize_msg.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_cachesize_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int gbytes;
+    public int bytes;
+    public int ncache;
+
+    public __env_cachesize_msg() {
+    }
+
+    public __env_cachesize_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(gbytes);
+        xdr.xdrEncodeInt(bytes);
+        xdr.xdrEncodeInt(ncache);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        gbytes = xdr.xdrDecodeInt();
+        bytes = xdr.xdrDecodeInt();
+        ncache = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_cachesize_msg.java

bdb/rpc_server/java/gen/__env_cachesize_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_cachesize_reply implements XdrAble {
+    public int status;
+
+    public __env_cachesize_reply() {
+    }
+
+    public __env_cachesize_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_cachesize_reply.java

bdb/rpc_server/java/gen/__env_close_msg.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_close_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int flags;
+
+    public __env_close_msg() {
+    }
+
+    public __env_close_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_close_msg.java

bdb/rpc_server/java/gen/__env_close_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_close_reply implements XdrAble {
+    public int status;
+
+    public __env_close_reply() {
+    }
+
+    public __env_close_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_close_reply.java

bdb/rpc_server/java/gen/__env_create_msg.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_create_msg implements XdrAble {
+    public int timeout;
+
+    public __env_create_msg() {
+    }
+
+    public __env_create_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(timeout);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        timeout = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_create_msg.java

bdb/rpc_server/java/gen/__env_create_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_create_reply implements XdrAble {
+    public int status;
+    public int envcl_id;
+
+    public __env_create_reply() {
+    }
+
+    public __env_create_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(envcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        envcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_create_reply.java

bdb/rpc_server/java/gen/__env_dbremove_msg.java

@@ -0,0 +1,44 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 3/19/02 10:30 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_dbremove_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int txnpcl_id;
+    public String name;
+    public String subdb;
+    public int flags;
+
+    public __env_dbremove_msg() {
+    }
+
+    public __env_dbremove_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeString(name);
+        xdr.xdrEncodeString(subdb);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        name = xdr.xdrDecodeString();
+        subdb = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_dbremove_msg.java

bdb/rpc_server/java/gen/__env_dbremove_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 3/19/02 10:30 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_dbremove_reply implements XdrAble {
+    public int status;
+
+    public __env_dbremove_reply() {
+    }
+
+    public __env_dbremove_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_dbremove_reply.java

bdb/rpc_server/java/gen/__env_dbrename_msg.java

@@ -0,0 +1,47 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 3/19/02 10:30 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_dbrename_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int txnpcl_id;
+    public String name;
+    public String subdb;
+    public String newname;
+    public int flags;
+
+    public __env_dbrename_msg() {
+    }
+
+    public __env_dbrename_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(txnpcl_id);
+        xdr.xdrEncodeString(name);
+        xdr.xdrEncodeString(subdb);
+        xdr.xdrEncodeString(newname);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        txnpcl_id = xdr.xdrDecodeInt();
+        name = xdr.xdrDecodeString();
+        subdb = xdr.xdrDecodeString();
+        newname = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_dbrename_msg.java

bdb/rpc_server/java/gen/__env_dbrename_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 3/19/02 10:30 AM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_dbrename_reply implements XdrAble {
+    public int status;
+
+    public __env_dbrename_reply() {
+    }
+
+    public __env_dbrename_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_dbrename_reply.java

bdb/rpc_server/java/gen/__env_encrypt_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 2/13/02 1:05 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_encrypt_msg implements XdrAble {
+    public int dbenvcl_id;
+    public String passwd;
+    public int flags;
+
+    public __env_encrypt_msg() {
+    }
+
+    public __env_encrypt_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeString(passwd);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        passwd = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_encrypt_msg.java

bdb/rpc_server/java/gen/__env_encrypt_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 2/13/02 1:05 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_encrypt_reply implements XdrAble {
+    public int status;
+
+    public __env_encrypt_reply() {
+    }
+
+    public __env_encrypt_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_encrypt_reply.java

bdb/rpc_server/java/gen/__env_flags_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_flags_msg implements XdrAble {
+    public int dbenvcl_id;
+    public int flags;
+    public int onoff;
+
+    public __env_flags_msg() {
+    }
+
+    public __env_flags_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeInt(flags);
+        xdr.xdrEncodeInt(onoff);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        flags = xdr.xdrDecodeInt();
+        onoff = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_flags_msg.java

bdb/rpc_server/java/gen/__env_flags_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_flags_reply implements XdrAble {
+    public int status;
+
+    public __env_flags_reply() {
+    }
+
+    public __env_flags_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_flags_reply.java

bdb/rpc_server/java/gen/__env_open_msg.java

@@ -0,0 +1,41 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_open_msg implements XdrAble {
+    public int dbenvcl_id;
+    public String home;
+    public int flags;
+    public int mode;
+
+    public __env_open_msg() {
+    }
+
+    public __env_open_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeString(home);
+        xdr.xdrEncodeInt(flags);
+        xdr.xdrEncodeInt(mode);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        home = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+        mode = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_open_msg.java

bdb/rpc_server/java/gen/__env_open_reply.java

@@ -0,0 +1,35 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_open_reply implements XdrAble {
+    public int status;
+    public int envcl_id;
+
+    public __env_open_reply() {
+    }
+
+    public __env_open_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+        xdr.xdrEncodeInt(envcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+        envcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_open_reply.java

bdb/rpc_server/java/gen/__env_remove_msg.java

@@ -0,0 +1,38 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_remove_msg implements XdrAble {
+    public int dbenvcl_id;
+    public String home;
+    public int flags;
+
+    public __env_remove_msg() {
+    }
+
+    public __env_remove_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(dbenvcl_id);
+        xdr.xdrEncodeString(home);
+        xdr.xdrEncodeInt(flags);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        dbenvcl_id = xdr.xdrDecodeInt();
+        home = xdr.xdrDecodeString();
+        flags = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_remove_msg.java

bdb/rpc_server/java/gen/__env_remove_reply.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __env_remove_reply implements XdrAble {
+    public int status;
+
+    public __env_remove_reply() {
+    }
+
+    public __env_remove_reply(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(status);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        status = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __env_remove_reply.java

bdb/rpc_server/java/gen/__txn_abort_msg.java

@@ -0,0 +1,32 @@
+/*
+ * Automatically generated by jrpcgen 0.95.1 on 12/18/01 7:23 PM
+ * jrpcgen is part of the "Remote Tea" ONC/RPC package for Java
+ * See http://acplt.org/ks/remotetea.html for details
+ */
+package com.sleepycat.db.rpcserver;
+import org.acplt.oncrpc.*;
+import java.io.IOException;
+
+public class __txn_abort_msg implements XdrAble {
+    public int txnpcl_id;
+
+    public __txn_abort_msg() {
+    }
+
+    public __txn_abort_msg(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        xdrDecode(xdr);
+    }
+
+    public void xdrEncode(XdrEncodingStream xdr)
+           throws OncRpcException, IOException {
+        xdr.xdrEncodeInt(txnpcl_id);
+    }
+
+    public void xdrDecode(XdrDecodingStream xdr)
+           throws OncRpcException, IOException {
+        txnpcl_id = xdr.xdrDecodeInt();
+    }
+
+}
+// End of __txn_abort_msg.java