db_server_proc.c.in

mysql-5.0.22.tar.gz源码包

/* 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 *));