ret = dbp->set_bt_maxkey(maxkey);	replyp->status = ret;	return;}/* BEGIN __db_associate_proc */extern "C" void__db_associate_proc(	long dbpcl_id,	long txnpcl_id,	long sdbpcl_id,	u_int32_t flags,	__db_associate_reply *replyp)/* END __db_associate_proc */{	Db *dbp, *sdbp;	DbTxn *txnp;	ct_entry *dbp_ctp, *sdbp_ctp, *txnp_ctp;	int ret;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (Db *)dbp_ctp->ct_anyp;	ACTIVATE_CTP(sdbp_ctp, sdbpcl_id, CT_DB);	sdbp = (Db *)sdbp_ctp->ct_anyp;	if (txnpcl_id != 0) {		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);		txnp = (DbTxn *)txnp_ctp->ct_anyp;	} else		txnp = 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.	 */	if (flags != 0)		ret = EINVAL;	else		ret = dbp->associate(txnp, sdbp, NULL, flags);	replyp->status = ret;	return;}/* BEGIN __db_bt_minkey_proc */extern "C" void__db_bt_minkey_proc(	long dbpcl_id,	u_int32_t minkey,	__db_bt_minkey_reply *replyp)/* END __db_bt_minkey_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_bt_minkey(minkey);	replyp->status = ret;	return;}/* BEGIN __db_close_proc */extern "C" void__db_close_proc(	long dbpcl_id,	u_int32_t flags,	__db_close_reply *replyp)/* END __db_close_proc */{	ct_entry *dbp_ctp;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	replyp->status = __db_close_int(dbpcl_id, flags);	return;}/* BEGIN __db_create_proc */extern "C" void__db_create_proc(	long dbenvcl_id,	u_int32_t flags,	__db_create_reply *replyp)/* END __db_create_proc */{	Db *dbp;	DbEnv *dbenv;	ct_entry *dbenv_ctp, *dbp_ctp;	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);	dbenv = (DbEnv *)dbenv_ctp->ct_anyp;	dbp_ctp = new_ct_ent(&replyp->status);	if (dbp_ctp == NULL)		return ;	/*	 * We actually require env's for databases.  The client should	 * have caught it, but just in case.	 */	DB_ASSERT(dbenv != NULL);	dbp = new Db(dbenv, flags);	dbp_ctp->ct_dbp = dbp;	dbp_ctp->ct_type = CT_DB;	dbp_ctp->ct_parent = dbenv_ctp;	dbp_ctp->ct_envparent = dbenv_ctp;	replyp->dbcl_id = dbp_ctp->ct_id;	replyp->status = 0;	return;}/* BEGIN __db_del_proc */extern "C" void__db_del_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 flags,	__db_del_reply *replyp)/* END __db_del_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;	/* Set up key */	Dbt key(keydata, keysize);	key.set_dlen(keydlen);	key.set_ulen(keyulen);	key.set_doff(keydoff);	key.set_flags(keyflags);	ret = dbp->del(txnp, &key, flags);	replyp->status = ret;	return;}/* BEGIN __db_encrypt_proc */extern "C" void__db_encrypt_proc(	long dbpcl_id,	char *passwd,	u_int32_t flags,	__db_encrypt_reply *replyp)/* END __db_encrypt_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_encrypt(passwd, flags);	replyp->status = ret;	return;}/* BEGIN __db_extentsize_proc */extern "C" void__db_extentsize_proc(	long dbpcl_id,	u_int32_t extentsize,	__db_extentsize_reply *replyp)/* END __db_extentsize_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_q_extentsize(extentsize);	replyp->status = ret;	return;}/* BEGIN __db_flags_proc */extern "C" void__db_flags_proc(	long dbpcl_id,	u_int32_t flags,	__db_flags_reply *replyp)/* END __db_flags_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_flags(flags);	dbp_ctp->ct_dbdp.setflags = flags;	replyp->status = ret;	return;}/* BEGIN __db_get_proc */extern "C" void__db_get_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_get_reply *replyp,	int * freep)/* END __db_get_proc */{	Db *dbp;	DbTxn *txnp;	ct_entry *dbp_ctp, *txnp_ctp;	int key_alloc, bulk_alloc, ret;	void *tmpdata;	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;	bulk_alloc = 0;	/* Set up key and data */	Dbt key(keydata, keysize);	key.set_dlen(keydlen);	key.set_ulen(keyulen);	key.set_doff(keydoff);	/*	 * Ignore memory related flags on server.	 */	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);	/*	 * Ignore memory related flags on server.	 */	dataflags &= DB_DBT_PARTIAL;	if (flags & DB_MULTIPLE) {		if (data.get_data() == 0) {			ret = __os_umalloc(dbp->get_DB()->dbenv,			    dataulen, &tmpdata);			if (ret != 0)				goto err;			data.set_data(tmpdata);			bulk_alloc = 1;		}		dataflags |= DB_DBT_USERMEM;	} else		dataflags |= DB_DBT_MALLOC;	data.set_flags(dataflags);	/* Got all our stuff, now do the get */	ret = dbp->get(txnp, &key, &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 (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());				__os_ufree(dbp->get_DB()->dbenv, data.get_data());				goto err;			}			key_alloc = 1;			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();		/*		 * 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, key.get_data());				__os_ufree(dbp->get_DB()->dbenv, data.get_data());				if (key_alloc)					__os_ufree(dbp->get_DB()->dbenv,					    replyp->keydata.keydata_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->keydata.keydata_val = NULL;		replyp->keydata.keydata_len = 0;		replyp->datadata.datadata_val = NULL;		replyp->datadata.datadata_len = 0;		*freep = 0;		if (bulk_alloc)			__os_ufree(dbp->get_DB()->dbenv, data.get_data());	}	replyp->status = ret;	return;}/* BEGIN __db_h_ffactor_proc */extern "C" void__db_h_ffactor_proc(	long dbpcl_id,	u_int32_t ffactor,	__db_h_ffactor_reply *replyp)/* END __db_h_ffactor_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_h_ffactor(ffactor);	replyp->status = ret;	return;}/* BEGIN __db_h_nelem_proc */extern "C" void__db_h_nelem_proc(	long dbpcl_id,	u_int32_t nelem,	__db_h_nelem_reply *replyp)/* END __db_h_nelem_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_h_nelem(nelem);	replyp->status = ret;	return;}/* BEGIN __db_key_range_proc */extern "C" void__db_key_range_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 flags,	__db_key_range_reply *replyp)/* END __db_key_range_proc */{	Db *dbp;	DB_KEY_RANGE range;	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;	/* Set up key */	Dbt key(keydata, keysize);	key.set_dlen(keydlen);	key.set_ulen(keyulen);	key.set_doff(keydoff);	key.set_flags(keyflags);	ret = dbp->key_range(txnp, &key, &range, flags);	replyp->status = ret;	replyp->less = range.less;	replyp->equal = range.equal;	replyp->greater = range.greater;	return;}/* BEGIN __db_lorder_proc */extern "C" void__db_lorder_proc(	long dbpcl_id,	u_int32_t lorder,	__db_lorder_reply *replyp)/* END __db_lorder_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_lorder(lorder);	replyp->status = ret;	return;}/* BEGIN __db_open_proc */extern "C" void__db_open_proc(	long dbpcl_id,	long txnpcl_id,	char *name,	char *subdb,	u_int32_t type,	u_int32_t flags,	u_int32_t mode,	__db_open_reply *replyp)/* END __db_open_proc */{	Db *dbp;	DbTxn *txnp;	DBTYPE dbtype;	ct_entry *dbp_ctp, *new_ctp, *txnp_ctp;	int isswapped, 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;	replyp->dbcl_id = dbpcl_id;	if ((new_ctp = __dbsrv_sharedb(dbp_ctp, name, subdb, (DBTYPE)type, flags))	    != NULL) {		/*		 * We can share, clean up old ID, set new one.		 */		if (__dbsrv_verbose)			printf("Sharing db ID %ld\n", new_ctp->ct_id);		replyp->dbcl_id = new_ctp->ct_id;		ret = __db_close_int(dbpcl_id, 0);		goto out;	}	ret = dbp->open(txnp, name, subdb, (DBTYPE)type, flags, mode);	if (ret == 0) {		(void)dbp->get_type(&dbtype);		replyp->type = dbtype;		/* XXX		 * Tcl needs to peek at dbp->flags for DB_AM_DUP.  Send		 * this dbp's flags back.		 */		replyp->dbflags = (int) dbp->get_DB()->flags;		/*		 * We need to determine the byte order of the database		 * and send it back to the client.  Determine it by		 * the server's native order and the swapped value of		 * the DB itself.		 */		(void)dbp->get_byteswapped(&isswapped);		if (__db_byteorder(NULL, 1234) == 0) {			if (isswapped == 0)				replyp->lorder = 1234;			else				replyp->lorder = 4321;		} else {			if (isswapped == 0)				replyp->lorder = 4321;			else				replyp->lorder = 1234;		}		dbp_ctp->ct_dbdp.type = dbtype;		dbp_ctp->ct_dbdp.dbflags = LF_ISSET(DB_SERVER_DBFLAGS);		if (name == NULL)			dbp_ctp->ct_dbdp.db = NULL;		else if ((ret = __os_strdup(dbp->get_DB()->dbenv, name,		    &dbp_ctp->ct_dbdp.db)) != 0)			goto out;		if (subdb == NULL)			dbp_ctp->ct_dbdp.subdb = NULL;		else if ((ret = __os_strdup(dbp->get_DB()->dbenv, subdb,		    &dbp_ctp->ct_dbdp.subdb)) != 0)			goto out;	}out:	replyp->status = ret;	return;}/* BEGIN __db_pagesize_proc */extern "C" void