/* BEGIN __db_associate_proc *//* * PUBLIC: void __db_associate_proc __P((long, long, long, u_int32_t, * PUBLIC:      __db_associate_reply *)); */void__db_associate_proc(dbpcl_id, txnpcl_id, sdbpcl_id,		flags, replyp)	long dbpcl_id;	long txnpcl_id;	long sdbpcl_id;	u_int32_t flags;	__db_associate_reply *replyp;/* END __db_associate_proc */{	DB *dbp, *sdbp;	DB_TXN *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 = (DB_TXN *)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(dbp, txnp, sdbp, NULL, flags);	replyp->status = ret;	return;}/* BEGIN __db_bt_minkey_proc *//* * PUBLIC: void __db_bt_minkey_proc __P((long, u_int32_t, * PUBLIC:      __db_bt_minkey_reply *)); */void__db_bt_minkey_proc(dbpcl_id, minkey, replyp)	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(dbp, minkey);	replyp->status = ret;	return;}/* BEGIN __db_close_proc *//* * PUBLIC: void __db_close_proc __P((long, u_int32_t, __db_close_reply *)); */void__db_close_proc(dbpcl_id, flags, replyp)	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 *//* * PUBLIC: void __db_create_proc __P((long, u_int32_t, __db_create_reply *)); */void__db_create_proc(dbenvcl_id, flags, replyp)	long dbenvcl_id;	u_int32_t flags;	__db_create_reply *replyp;/* END __db_create_proc */{	DB *dbp;	DB_ENV *dbenv;	ct_entry *dbenv_ctp, *dbp_ctp;	int ret;	ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);	dbenv = (DB_ENV *)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);	if ((ret = db_create(&dbp, dbenv, flags)) == 0) {		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;	} else		__dbclear_ctp(dbp_ctp);	replyp->status = ret;	return;}/* BEGIN __db_del_proc *//* * PUBLIC: void __db_del_proc __P((long, long, u_int32_t, u_int32_t, u_int32_t, * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, __db_del_reply *)); */void__db_del_proc(dbpcl_id, txnpcl_id, keydlen,		keydoff, keyulen, keyflags, keydata,		keysize, flags, replyp)	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;	DBT key;	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;	memset(&key, 0, sizeof(key));	/* Set up key DBT */	key.dlen = keydlen;	key.ulen = keyulen;	key.doff = keydoff;	key.flags = keyflags;	key.size = keysize;	key.data = keydata;	ret = dbp->del(dbp, txnp, &key, flags);	replyp->status = ret;	return;}/* BEGIN __db_encrypt_proc *//* * PUBLIC: void __db_encrypt_proc __P((long, char *, u_int32_t, * PUBLIC:      __db_encrypt_reply *)); */void__db_encrypt_proc(dbpcl_id, passwd, flags, replyp)	long dbpcl_id;	char *passwd;	u_int32_t flags;	__db_encrypt_reply *replyp;/* END __db_encrypt_proc */{	int ret;	DB * dbp;	ct_entry *dbp_ctp;	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);	dbp = (DB *)dbp_ctp->ct_anyp;	ret = dbp->set_encrypt(dbp, passwd, flags);	replyp->status = ret;	return;}/* BEGIN __db_extentsize_proc *//* * PUBLIC: void __db_extentsize_proc __P((long, u_int32_t, * PUBLIC:      __db_extentsize_reply *)); */void__db_extentsize_proc(dbpcl_id, extentsize, replyp)	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(dbp, extentsize);	replyp->status = ret;	return;}/* BEGIN __db_flags_proc *//* * PUBLIC: void __db_flags_proc __P((long, u_int32_t, __db_flags_reply *)); */void__db_flags_proc(dbpcl_id, flags, replyp)	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(dbp, flags);	dbp_ctp->ct_dbdp.setflags |= flags;	replyp->status = ret;	return;}/* BEGIN __db_get_proc *//* * PUBLIC: void __db_get_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_get_reply *, int *)); */void__db_get_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_get_reply *replyp;	int * freep;/* END __db_get_proc */{	DB *dbp;	DBT key, data;	DB_TXN *txnp;	ct_entry *dbp_ctp, *txnp_ctp;	int key_alloc, bulk_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;	bulk_alloc = 0;	memset(&key, 0, sizeof(key));	memset(&data, 0, sizeof(data));	/* Set up key and data DBT */	key.dlen = keydlen;	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.ulen = keyulen;	key.data = keydata;	data.dlen = datadlen;	data.doff = datadoff;	data.ulen = dataulen;	/*	 * Ignore memory related flags on server.	 */	data.size = datasize;	data.data = datadata;	if (flags & DB_MULTIPLE) {		if (data.data == 0) {			ret = __os_umalloc(dbp->dbenv,			    data.ulen, &data.data);			if (ret != 0)				goto err;			bulk_alloc = 1;		}		data.flags |= DB_DBT_USERMEM;	} else		data.flags |= DB_DBT_MALLOC;	if (dataflags & DB_DBT_PARTIAL)		data.flags |= DB_DBT_PARTIAL;	/* Got all our stuff, now do the get */	ret = dbp->get(dbp, 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.data == keydata) {			ret = __os_umalloc(dbp->dbenv,			    key.size, &replyp->keydata.keydata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, key.data);				__os_ufree(dbp->dbenv, data.data);				goto err;			}			key_alloc = 1;			memcpy(replyp->keydata.keydata_val, key.data, key.size);		} else			replyp->keydata.keydata_val = key.data;		replyp->keydata.keydata_len = key.size;		/*		 * Data		 */		if (data.data == datadata) {			ret = __os_umalloc(dbp->dbenv,			     data.size, &replyp->datadata.datadata_val);			if (ret != 0) {				__os_ufree(dbp->dbenv, key.data);				__os_ufree(dbp->dbenv, data.data);				if (key_alloc)					__os_ufree(dbp->dbenv,					    replyp->keydata.keydata_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->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->dbenv, data.data);	}	replyp->status = ret;	return;}/* BEGIN __db_h_ffactor_proc *//* * PUBLIC: void __db_h_ffactor_proc __P((long, u_int32_t, * PUBLIC:      __db_h_ffactor_reply *)); */void__db_h_ffactor_proc(dbpcl_id, ffactor, replyp)	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(dbp, ffactor);	replyp->status = ret;	return;}/* BEGIN __db_h_nelem_proc *//* * PUBLIC: void __db_h_nelem_proc __P((long, u_int32_t, * PUBLIC:      __db_h_nelem_reply *)); */void__db_h_nelem_proc(dbpcl_id, nelem, replyp)	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(dbp, nelem);	replyp->status = ret;	return;}/* BEGIN __db_key_range_proc *//* * PUBLIC: void __db_key_range_proc __P((long, long, u_int32_t, u_int32_t, * PUBLIC:      u_int32_t, u_int32_t, void *, u_int32_t, u_int32_t, __db_key_range_reply *)); */void__db_key_range_proc(dbpcl_id, txnpcl_id, keydlen,		keydoff, keyulen, keyflags, keydata,		keysize, flags, replyp)	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;	DBT key;	DB_KEY_RANGE range;	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;	memset(&key, 0, sizeof(key));	/* Set up key and data DBT */	key.dlen = keydlen;	key.ulen = keyulen;	key.doff = keydoff;	key.size = keysize;	key.data = keydata;	key.flags = keyflags;	ret = dbp->key_range(dbp, txnp, &key, &range, flags);	replyp->status = ret;	replyp->less = range.less;	replyp->equal = range.equal;	replyp->greater = range.greater;	return;}/* BEGIN __db_lorder_proc *//* * PUBLIC: void __db_lorder_proc __P((long, u_int32_t, __db_lorder_reply *)); */void__db_lorder_proc(dbpcl_id, lorder, replyp)	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(dbp, lorder);	replyp->status = ret;	return;}/* BEGIN __db_open_proc *//* * PUBLIC: void __db_open_proc __P((long, long, char *, char *, u_int32_t, * PUBLIC:      u_int32_t, u_int32_t, __db_open_reply *)); */void__db_open_proc(dbpcl_id, txnpcl_id, name,		subdb, type, flags, mode, replyp)	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;	DB_TXN *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 = (DB_TXN *)txnp_ctp->ct_anyp;	} else		txnp = NULL;	replyp->dbcl_id = dbpcl_id;	if ((new_ctp = __dbsrv_sharedb(dbp_ctp, name, subdb, 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(dbp, txnp, name, subdb, (DBTYPE)type, flags, mode);	if (ret == 0) {		(void)dbp->get_type(dbp, &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->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(dbp, &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->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->dbenv, subdb,		    &dbp_ctp->ct_dbdp.subdb)) != 0)			goto out;	}out:	replyp->status = ret;	return;}/* BEGIN __db_pagesize_proc *//* * PUBLIC: void __db_pagesize_proc __P((long, u_int32_t, * PUBLIC:      __db_pagesize_reply *));