db_server_cxxproc.cpp

关于Berkelay数据库的共享源码

	u_int32_t type,
	u_int32_t flags,
	u_int32_t mode,
	__db_open_reply *replyp)
{
	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;
		/*
		 * 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;
}

extern "C" void
__db_get_pagesize_proc(
	u_int dbpcl_id,
	__db_get_pagesize_reply *replyp)
{
	Db *dbp;
	ct_entry *dbp_ctp;

	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
	dbp = (Db *)dbp_ctp->ct_anyp;

	replyp->status = dbp->get_pagesize(&replyp->pagesize);
}

extern "C" void
__db_set_pagesize_proc(
	u_int dbpcl_id,
	u_int32_t pagesize,
	__db_set_pagesize_reply *replyp)
{
	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;
}

extern "C" void
__db_pget_proc(
	u_int dbpcl_id,
	u_int 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)
{
	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;

	replyp->skeydata.skeydata_val = NULL;
	replyp->pkeydata.pkeydata_val = NULL;
	replyp->datadata.datadata_val = 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
		 */
		if (skey.get_data() == skeydata) {
			ret = __os_umalloc(dbp->get_DB()->dbenv,
			    skey.get_size(), &replyp->skeydata.skeydata_val);
			if (ret != 0)
				goto err;
			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)
				goto err;
			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)
				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:		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    skey.get_data(), skeydata);
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    pkey.get_data(), pkeydata);
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    data.get_data(), datadata);
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    replyp->skeydata.skeydata_val, skey.get_data());
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    replyp->pkeydata.pkeydata_val, pkey.get_data());
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    replyp->datadata.datadata_val, data.get_data());
		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;
}

extern "C" void
__db_put_proc(
	u_int dbpcl_id,
	u_int 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)
{
	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;

	replyp->keydata.keydata_val = 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)
				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:		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    key.get_data(), keydata);
		FREE_IF_CHANGED(dbp->get_DB()->dbenv,
		    replyp->keydata.keydata_val, key.get_data());
		replyp->keydata.keydata_val = NULL;
		replyp->keydata.keydata_len = 0;
		*freep = 0;
	}
	replyp->status = ret;
	return;
}

extern "C" void
__db_get_re_delim_proc(
	u_int dbpcl_id,
	__db_get_re_delim_reply *replyp)
{
	Db *dbp;
	ct_entry *dbp_ctp;

	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
	dbp = (Db *)dbp_ctp->ct_anyp;

	replyp->status = dbp->get_re_delim((int *)&replyp->delim);
}

extern "C" void
__db_set_re_delim_proc(
	u_int dbpcl_id,
	u_int32_t delim,
	__db_set_re_delim_reply *replyp)
{
	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;
}

extern "C" void
__db_get_re_len_proc(
	u_int dbpcl_id,
	__db_get_re_len_reply *replyp)
{
	Db *dbp;
	ct_entry *dbp_ctp;

	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
	dbp = (Db *)dbp_ctp->ct_anyp;

	replyp->status = dbp->get_re_len(&replyp->len);
}

extern "C" void
__db_set_re_len_proc(
	u_int dbpcl_id,
	u_int32_t len,
	__db_set_re_len_reply *replyp)
{
	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;
}

void
__db_get_re_pad_proc(
	u_int dbpcl_id,
	__db_get_re_pad_reply *replyp)
{
	Db *dbp;
	ct_entry *dbp_ctp;

	ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
	dbp = (Db *)dbp_ctp->ct_anyp;

	replyp->status = dbp->get_re_pad((int *)&replyp->pad);
}

extern "C" void
__db_set_re_pad_proc(
	u_int dbpcl_id,
	u_int32_t pad,
	__db_set_re_pad_reply *replyp)
{
	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;
}

extern "C" void
__db_remove_proc(
	u_int dbpcl_id,
	char *name,
	char *subdb,
	u_int32_t flags,
	__db_remove_reply *replyp)
{
	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;
}

extern "C" void
__db_rename_proc(
	u_int dbpcl_id,
	char *name,
	char *subdb,
	char *newname,
	u_int32_t flags,
	__db_rename_reply *replyp)
{
	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;
}

extern "C" void
__db_stat_proc(
	u_int dbpcl_id,
	u_int txnpcl_id,
	u_int32_t flags,
	__db_stat_reply *replyp,
	int * freep)
{
	Db *dbp;
	DbTxn *txnp;
	DBTYPE type;
	ct_entry *dbp_ctp, *txnp_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;
	if (txnpcl_id != 0) {
		ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
		txnp = (DbTxn *)txnp_ctp->ct_anyp;
	} else
		txnp = NULL;

	ret = dbp->stat(txnp, &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;
}

extern "C" void
__db_sync_proc(
	u_int dbpcl_id,
	u_int32_t flags,
	__db_sync_reply *replyp)
{
	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;
}

extern "C" void
__db_truncate_proc(
	u_int dbpcl_id,
	u_int txnpcl_id,
	u_int32_t flags,
	__db_truncate_reply *replyp)
{
	Db *dbp;
	DbTxn *txnp;
	ct_entry *dbp_ctp, *txnp_ctp;
	u_int32_t count;