*/void__db_pagesize_proc(dbpcl_id, pagesize, replyp)	long dbpcl_id;	u_int32_t pagesize;	__db_pagesize_reply *replyp;/* END __db_pagesize_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->set_pagesize(dbp, pagesize);	replyp->status = ret;	return;}/* BEGIN __db_pget_proc *//* * PUBLIC: void __db_pget_proc __P((long, long, u_int32_t, u_int32_t, * PUBLIC:      u_int32_t, u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *, * PUBLIC:      u_int32_t, u_int32_t, __db_pget_reply *, int *)); */void__db_pget_proc(dbpcl_id, txnpcl_id, skeydlen,		skeydoff, skeyulen, skeyflags, skeydata,		skeysize, pkeydlen, pkeydoff, pkeyulen,		pkeyflags, pkeydata, pkeysize, datadlen,		datadoff, dataulen, dataflags, datadata,		datasize, flags, replyp, freep)	long dbpcl_id;	long txnpcl_id;	u_int32_t skeydlen;	u_int32_t skeydoff;	u_int32_t skeyulen;	u_int32_t skeyflags;	void *skeydata;	u_int32_t skeysize;	u_int32_t pkeydlen;	u_int32_t pkeydoff;	u_int32_t pkeyulen;	u_int32_t pkeyflags;	void *pkeydata;	u_int32_t pkeysize;	u_int32_t datadlen;	u_int32_t datadoff;	u_int32_t dataulen;	u_int32_t dataflags;	void *datadata;	u_int32_t datasize;	u_int32_t flags;	__db_pget_reply *replyp;	int * freep;/* END __db_pget_proc */{	DB *dbp;	DBT skey, pkey, data;	DB_TXN *txnp;	ct_entry *dbp_ctp, *txnp_ctp;	int key_alloc, ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	if (txnpcl_id != 0) {		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);		txnp = (DB_TXN *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	*freep = 0;	memset(&skey, 0, sizeof(skey));	memset(&pkey, 0, sizeof(pkey));	memset(&data, 0, sizeof(data));	/*	 * Ignore memory related flags on server.	 */	/* Set up key and data DBT */	skey.flags = DB_DBT_MALLOC;	skey.dlen = skeydlen;	skey.ulen = skeyulen;	skey.doff = skeydoff;	if (skeyflags & DB_DBT_PARTIAL)		skey.flags |= DB_DBT_PARTIAL;	skey.size = skeysize;	skey.data = skeydata;	pkey.flags = DB_DBT_MALLOC;	pkey.dlen = pkeydlen;	pkey.ulen = pkeyulen;	pkey.doff = pkeydoff;	if (pkeyflags & DB_DBT_PARTIAL)		pkey.flags |= DB_DBT_PARTIAL;	pkey.size = pkeysize;	pkey.data = pkeydata;	data.flags = DB_DBT_MALLOC;	data.dlen = datadlen;	data.ulen = dataulen;	data.doff = datadoff;	if (dataflags & DB_DBT_PARTIAL)		data.flags |= DB_DBT_PARTIAL;	data.size = datasize;	data.data = datadata;	/* Got all our stuff, now do the get */	ret = dbp->pget(dbp, txnp, &skey, &pkey, &data, flags);	/*	 * Otherwise just status.	 */	if (ret == 0) {		/*		 * XXX		 * We need to xdr_free whatever we are returning, next time.		 * However, DB does not allocate a new key if one was given		 * and we'd be free'ing up space allocated in the request.		 * So, allocate a new key/data pointer if it is the same one		 * as in the request.		 */		*freep = 1;		/*		 * Key		 */		key_alloc = 0;		if (skey.data == skeydata) {			ret = __os_umalloc(dbp->dbenv,			    skey.size, &replyp->skeydata.skeydata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, skey.data);				__os_ufree(dbp->dbenv, pkey.data);				__os_ufree(dbp->dbenv, data.data);				goto err;			}			key_alloc = 1;			memcpy(replyp->skeydata.skeydata_val, skey.data,			    skey.size);		} else			replyp->skeydata.skeydata_val = skey.data;		replyp->skeydata.skeydata_len = skey.size;		/*		 * Primary key		 */		if (pkey.data == pkeydata) {			ret = __os_umalloc(dbp->dbenv,			     pkey.size, &replyp->pkeydata.pkeydata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, skey.data);				__os_ufree(dbp->dbenv, pkey.data);				__os_ufree(dbp->dbenv, data.data);				if (key_alloc)					__os_ufree(dbp->dbenv,					    replyp->skeydata.skeydata_val);				goto err;			}			/*			 * We can set it to 2, because they cannot send the			 * pkey over without sending the skey over too.			 * So if they did send a pkey, they must have sent			 * the skey as well.			 */			key_alloc = 2;			memcpy(replyp->pkeydata.pkeydata_val, pkey.data,			    pkey.size);		} else			replyp->pkeydata.pkeydata_val = pkey.data;		replyp->pkeydata.pkeydata_len = pkey.size;		/*		 * Data		 */		if (data.data == datadata) {			ret = __os_umalloc(dbp->dbenv,			     data.size, &replyp->datadata.datadata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, skey.data);				__os_ufree(dbp->dbenv, pkey.data);				__os_ufree(dbp->dbenv, data.data);				/*				 * If key_alloc is 1, just skey needs to be				 * freed, if key_alloc is 2, both skey and pkey				 * need to be freed.				 */				if (key_alloc--)					__os_ufree(dbp->dbenv,					    replyp->skeydata.skeydata_val);				if (key_alloc)					__os_ufree(dbp->dbenv,					    replyp->pkeydata.pkeydata_val);				goto err;			}			memcpy(replyp->datadata.datadata_val, data.data,			    data.size);		} else			replyp->datadata.datadata_val = data.data;		replyp->datadata.datadata_len = data.size;	} else {err:		replyp->skeydata.skeydata_val = NULL;		replyp->skeydata.skeydata_len = 0;		replyp->pkeydata.pkeydata_val = NULL;		replyp->pkeydata.pkeydata_len = 0;		replyp->datadata.datadata_val = NULL;		replyp->datadata.datadata_len = 0;		*freep = 0;	}	replyp->status = ret;	return;}/* BEGIN __db_put_proc *//* * PUBLIC: void __db_put_proc __P((long, long, u_int32_t, u_int32_t, u_int32_t, * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *, * PUBLIC:      u_int32_t, u_int32_t, __db_put_reply *, int *)); */void__db_put_proc(dbpcl_id, txnpcl_id, keydlen,		keydoff, keyulen, keyflags, keydata,		keysize, datadlen, datadoff, dataulen,		dataflags, datadata, datasize, flags, replyp, freep)	long dbpcl_id;	long txnpcl_id;	u_int32_t keydlen;	u_int32_t keydoff;	u_int32_t keyulen;	u_int32_t keyflags;	void *keydata;	u_int32_t keysize;	u_int32_t datadlen;	u_int32_t datadoff;	u_int32_t dataulen;	u_int32_t dataflags;	void *datadata;	u_int32_t datasize;	u_int32_t flags;	__db_put_reply *replyp;	int * freep;/* END __db_put_proc */{	DB *dbp;	DBT key, data;	DB_TXN *txnp;	ct_entry *dbp_ctp, *txnp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	if (txnpcl_id != 0) {		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);		txnp = (DB_TXN *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	*freep = 0;	memset(&key, 0, sizeof(key));	memset(&data, 0, sizeof(data));	/* Set up key and data DBT */	key.dlen = keydlen;	key.ulen = keyulen;	key.doff = keydoff;	/*	 * Ignore memory related flags on server.	 */	key.flags = DB_DBT_MALLOC;	if (keyflags & DB_DBT_PARTIAL)		key.flags |= DB_DBT_PARTIAL;	key.size = keysize;	key.data = keydata;	data.dlen = datadlen;	data.ulen = dataulen;	data.doff = datadoff;	data.flags = dataflags;	data.size = datasize;	data.data = datadata;	/* Got all our stuff, now do the put */	ret = dbp->put(dbp, txnp, &key, &data, flags);	/*	 * If the client did a DB_APPEND, set up key in reply.	 * Otherwise just status.	 */	if (ret == 0 && (flags == DB_APPEND)) {		/*		 * XXX		 * We need to xdr_free whatever we are returning, next time.		 * However, DB does not allocate a new key if one was given		 * and we'd be free'ing up space allocated in the request.		 * So, allocate a new key/data pointer if it is the same one		 * as in the request.		 */		*freep = 1;		/*		 * Key		 */		if (key.data == keydata) {			ret = __os_umalloc(dbp->dbenv,			    key.size, &replyp->keydata.keydata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, key.data);				goto err;			}			memcpy(replyp->keydata.keydata_val, key.data, key.size);		} else			replyp->keydata.keydata_val = key.data;		replyp->keydata.keydata_len = key.size;	} else {err:		replyp->keydata.keydata_val = NULL;		replyp->keydata.keydata_len = 0;		*freep = 0;	}	replyp->status = ret;	return;}/* BEGIN __db_re_delim_proc *//* * PUBLIC: void __db_re_delim_proc __P((long, u_int32_t, * PUBLIC:      __db_re_delim_reply *)); */void__db_re_delim_proc(dbpcl_id, delim, replyp)	long dbpcl_id;	u_int32_t delim;	__db_re_delim_reply *replyp;/* END __db_re_delim_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->set_re_delim(dbp, delim);	replyp->status = ret;	return;}/* BEGIN __db_re_len_proc *//* * PUBLIC: void __db_re_len_proc __P((long, u_int32_t, __db_re_len_reply *)); */void__db_re_len_proc(dbpcl_id, len, replyp)	long dbpcl_id;	u_int32_t len;	__db_re_len_reply *replyp;/* END __db_re_len_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->set_re_len(dbp, len);	replyp->status = ret;	return;}/* BEGIN __db_re_pad_proc *//* * PUBLIC: void __db_re_pad_proc __P((long, u_int32_t, __db_re_pad_reply *)); */void__db_re_pad_proc(dbpcl_id, pad, replyp)	long dbpcl_id;	u_int32_t pad;	__db_re_pad_reply *replyp;/* END __db_re_pad_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->set_re_pad(dbp, pad);	replyp->status = ret;	return;}/* BEGIN __db_remove_proc *//* * PUBLIC: void __db_remove_proc __P((long, char *, char *, u_int32_t, * PUBLIC:      __db_remove_reply *)); */void__db_remove_proc(dbpcl_id, name, subdb,		flags, replyp)	long dbpcl_id;	char *name;	char *subdb;	u_int32_t flags;	__db_remove_reply *replyp;/* END __db_remove_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->remove(dbp, name, subdb, flags);	__dbdel_ctp(dbp_ctp);	replyp->status = ret;	return;}/* BEGIN __db_rename_proc *//* * PUBLIC: void __db_rename_proc __P((long, char *, char *, char *, u_int32_t, * PUBLIC:      __db_rename_reply *)); */void__db_rename_proc(dbpcl_id, name, subdb,		newname, flags, replyp)	long dbpcl_id;	char *name;	char *subdb;	char *newname;	u_int32_t flags;	__db_rename_reply *replyp;/* END __db_rename_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->rename(dbp, name, subdb, newname, flags);	__dbdel_ctp(dbp_ctp);	replyp->status = ret;	return;}/* BEGIN __db_stat_proc *//* * PUBLIC: void __db_stat_proc __P((long, u_int32_t, __db_stat_reply *, * PUBLIC:      int *)); */void__db_stat_proc(dbpcl_id, flags, replyp, freep)	long dbpcl_id;	u_int32_t flags;	__db_stat_reply *replyp;	int * freep;/* END __db_stat_proc */{	DB *dbp;	DBTYPE type;	ct_entry *dbp_ctp;	u_int32_t *q, *p, *retsp;	int i, len, ret;	void *sp;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->stat(dbp, &sp, flags);	replyp->status = ret;	if (ret != 0)		return;	/*	 * We get here, we have success.  Allocate an array so that	 * we can use the list generator.  Generate the reply, free	 * up the space.	 */	/*	 * XXX This assumes that all elements of all stat structures	 * are u_int32_t fields.  They are, currently.	 */	(void)dbp->get_type(dbp, &type);	if (type == DB_HASH)		len = sizeof(DB_HASH_STAT);	else if (type == DB_QUEUE)		len = sizeof(DB_QUEUE_STAT);	else            /* BTREE or RECNO are same stats */		len = sizeof(DB_BTREE_STAT);	replyp->stats.stats_len = len / sizeof(u_int32_t);	if ((ret = __os_umalloc(dbp->dbenv, len * replyp->stats.stats_len,	    &retsp)) != 0)		goto out;	for (i = 0, q = retsp, p = sp; i < len;	    i++, q++, p++)		*q = *p;	replyp->stats.stats_val = retsp;	__os_ufree(dbp->dbenv, sp);	if (ret == 0)		*freep = 1;out:	replyp->status = ret;	return;}/* BEGIN __db_sync_proc *//* * PUBLIC: void __db_sync_proc __P((long, u_int32_t, __db_sync_reply *)); */void__db_sync_proc(dbpcl_id, flags, replyp)	long dbpcl_id;	u_int32_t flags;	__db_sync_reply *replyp;/* END __db_sync_proc */{	DB *dbp;	ct_entry *dbp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->sync(dbp, flags);	replyp->status = ret;	return;}/* BEGIN __db_truncate_proc *//* * PUBLIC: void __db_truncate_proc __P((long, long, u_int32_t, * PUBLIC:      __db_truncate_reply *)); */void__db_truncate_proc(dbpcl_id, txnpcl_id,		flags, replyp)	long dbpcl_id;	long txnpcl_id;	u_int32_t flags;	__db_truncate_reply *replyp;/* END __db_truncate_proc */{	DB *dbp;	DB_TXN *txnp;	ct_entry *dbp_ctp, *txnp_ctp;	u_int32_t count;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	if (txnpcl_id != 0) {		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);		txnp = (DB_TXN *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	ret = dbp->truncate(dbp, txnp, &count, flags);	replyp->status = ret;	if (ret == 0)		replyp->count = count;	return;}/* BEGIN __db_cursor_proc *//* * PUBLIC: void __db_cursor_proc __P((long, long, u_int32_t, * PUBLIC:      __db_cursor_reply *)); */void__db_cursor_proc(dbpcl_id, txnpcl_id,		flags, replyp)	long dbpcl_id;	long txnpcl_id;	u_int32_t flags;	__db_cursor_reply *replyp;/* END __db_cursor_proc */{	DB *dbp;	DBC *dbc;	DB_TXN *txnp;	ct_entry *dbc_ctp, *env_ctp, *dbp_ctp, *txnp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	dbc_ctp = new_ct_ent(&replyp->status);	if (dbc_ctp == NULL)		return;	if (txnpcl_id != 0) {		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);		txnp = (DB_TXN *)txnp_ctp->ct_anyp;		dbc_ctp->ct_activep = txnp_ctp->ct_activep;	} else		txnp = NULL;	if ((ret = dbp->cursor(dbp, txnp, &dbc, flags)) == 0) {		dbc_ctp->ct_dbc = dbc;		dbc_ctp->ct_type = CT_CURSOR;		dbc_ctp->ct_parent = dbp_ctp;		env_ctp = dbp_ctp->ct_envparent;		dbc_ctp->ct_envparent = env_ctp;		__dbsrv_settimeout(dbc_ctp, env_ctp->ct_timeout);		__dbsrv_active(dbc_ctp);		replyp->dbcidcl_id = dbc_ctp->ct_id;	} else		__dbclear_ctp(dbc_ctp);	replyp->status = ret;	return;}/* BEGIN __db_join_proc *//* * PUBLIC: void __db_join_proc __P((long, u_int32_t *, u_int32_t, u_int32_t,