__db_pagesize_proc(	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(pagesize);	replyp->status = ret;	return;}/* BEGIN __db_pget_proc */extern "C" void__db_pget_proc(	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;	DbTxn *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 = (DbTxn *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	*freep = 0;	/*	 * Ignore memory related flags on server.	 */	/* Set up key and data */	Dbt skey(skeydata, skeysize);	skey.set_dlen(skeydlen);	skey.set_ulen(skeyulen);	skey.set_doff(skeydoff);	skey.set_flags(DB_DBT_MALLOC | (skeyflags & DB_DBT_PARTIAL));	Dbt pkey(pkeydata, pkeysize);	pkey.set_dlen(pkeydlen);	pkey.set_ulen(pkeyulen);	pkey.set_doff(pkeydoff);	pkey.set_flags(DB_DBT_MALLOC | (pkeyflags & DB_DBT_PARTIAL));	Dbt data(datadata, datasize);	data.set_dlen(datadlen);	data.set_ulen(dataulen);	data.set_doff(datadoff);	data.set_flags(DB_DBT_MALLOC | (dataflags & DB_DBT_PARTIAL));	/* Got all our stuff, now do the get */	ret = dbp->pget(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.get_data() == skeydata) {			ret = __os_umalloc(dbp->get_DB()->dbenv,			    skey.get_size(), &replyp->skeydata.skeydata_val);			if (ret != 0) {				__os_ufree(dbp->get_DB()->dbenv, skey.get_data());				__os_ufree(dbp->get_DB()->dbenv, pkey.get_data());				__os_ufree(dbp->get_DB()->dbenv, data.get_data());				goto err;			}			key_alloc = 1;			memcpy(replyp->skeydata.skeydata_val, skey.get_data(),			    skey.get_size());		} else			replyp->skeydata.skeydata_val = (char *)skey.get_data();		replyp->skeydata.skeydata_len = skey.get_size();		/*		 * Primary key		 */		if (pkey.get_data() == pkeydata) {			ret = __os_umalloc(dbp->get_DB()->dbenv,			     pkey.get_size(), &replyp->pkeydata.pkeydata_val);			if (ret != 0) {				__os_ufree(dbp->get_DB()->dbenv, skey.get_data());				__os_ufree(dbp->get_DB()->dbenv, pkey.get_data());				__os_ufree(dbp->get_DB()->dbenv, data.get_data());				if (key_alloc)					__os_ufree(dbp->get_DB()->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.get_data(),			    pkey.get_size());		} else			replyp->pkeydata.pkeydata_val = (char *)pkey.get_data();		replyp->pkeydata.pkeydata_len = pkey.get_size();		/*		 * Data		 */		if (data.get_data() == datadata) {			ret = __os_umalloc(dbp->get_DB()->dbenv,			     data.get_size(), &replyp->datadata.datadata_val);			if (ret != 0) {				__os_ufree(dbp->get_DB()->dbenv, skey.get_data());				__os_ufree(dbp->get_DB()->dbenv, pkey.get_data());				__os_ufree(dbp->get_DB()->dbenv, data.get_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->get_DB()->dbenv,					    replyp->skeydata.skeydata_val);				if (key_alloc)					__os_ufree(dbp->get_DB()->dbenv,					    replyp->pkeydata.pkeydata_val);				goto err;			}			memcpy(replyp->datadata.datadata_val, data.get_data(),			    data.get_size());		} else			replyp->datadata.datadata_val = (char *)data.get_data();		replyp->datadata.datadata_len = data.get_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 */extern "C" void__db_put_proc(	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;	DbTxn *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 = (DbTxn *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	*freep = 0;	/* Set up key and data */	Dbt key(keydata, keysize);	key.set_dlen(keydlen);	key.set_ulen(keyulen);	key.set_doff(keydoff);	key.set_flags(DB_DBT_MALLOC | (keyflags & DB_DBT_PARTIAL));	Dbt data(datadata, datasize);	data.set_dlen(datadlen);	data.set_ulen(dataulen);	data.set_doff(datadoff);	data.set_flags(dataflags);	/* Got all our stuff, now do the put */	ret = dbp->put(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.get_data() == keydata) {			ret = __os_umalloc(dbp->get_DB()->dbenv,			    key.get_size(), &replyp->keydata.keydata_val);			if (ret != 0) {				__os_ufree(dbp->get_DB()->dbenv, key.get_data());				goto err;			}			memcpy(replyp->keydata.keydata_val, key.get_data(), key.get_size());		} else			replyp->keydata.keydata_val = (char *)key.get_data();		replyp->keydata.keydata_len = key.get_size();	} else {err:		replyp->keydata.keydata_val = NULL;		replyp->keydata.keydata_len = 0;		*freep = 0;	}	replyp->status = ret;	return;}/* BEGIN __db_re_delim_proc */extern "C" void__db_re_delim_proc(	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(delim);	replyp->status = ret;	return;}/* BEGIN __db_re_len_proc */extern "C" void__db_re_len_proc(	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(len);	replyp->status = ret;	return;}/* BEGIN __db_re_pad_proc */extern "C" void__db_re_pad_proc(	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(pad);	replyp->status = ret;	return;}/* BEGIN __db_remove_proc */extern "C" void__db_remove_proc(	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(name, subdb, flags);	__dbdel_ctp(dbp_ctp);	replyp->status = ret;	return;}/* BEGIN __db_rename_proc */extern "C" void__db_rename_proc(	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(name, subdb, newname, flags);	__dbdel_ctp(dbp_ctp);	replyp->status = ret;	return;}/* BEGIN __db_stat_proc */extern "C" void__db_stat_proc(	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(&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(&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->get_DB()->dbenv,	    len * replyp->stats.stats_len, &retsp)) != 0)		goto out;	for (i = 0, q = retsp, p = (u_int32_t *)sp; i < len;	    i++, q++, p++)		*q = *p;	replyp->stats.stats_val = retsp;	__os_ufree(dbp->get_DB()->dbenv, sp);	if (ret == 0)		*freep = 1;out:	replyp->status = ret;	return;}/* BEGIN __db_sync_proc */extern "C" void__db_sync_proc(	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(flags);	replyp->status = ret;	return;}/* BEGIN __db_truncate_proc */extern "C" void__db_truncate_proc(	long dbpcl_id,	long txnpcl_id,	u_int32_t flags,	__db_truncate_reply *replyp)/* END __db_truncate_proc */{	Db *dbp;	DbTxn *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 = (DbTxn *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	ret = dbp->truncate(txnp, &count, flags);	replyp->status = ret;	if (ret == 0)		replyp->count = count;	return;}/* BEGIN __db_cursor_proc */extern "C" void__db_cursor_proc(	long dbpcl_id,	long txnpcl_id,	u_int32_t flags,	__db_cursor_reply *replyp)/* END __db_cursor_proc */{	Db *dbp;	Dbc *dbc;	DbTxn *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 = (DbTxn *)txnp_ctp->ct_anyp;		dbc_ctp->ct_activep = txnp_ctp->ct_activep;	} else		txnp = NULL;	if ((ret = dbp->cursor(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 */extern "C" void__db_join_proc(	long dbpcl_id,	u_int32_t *curs,	u_int32_t curslen,	u_int32_t flags,	__db_join_reply *replyp)/* END __db_join_proc */