gen_client_ret.c

这是linux下运行的mysql软件包,可用于linux 下安装 php + mysql + apach 的网络配置

		 * When dbp->get_flags exists, this should go away.
		 */
		dbp->flags = replyp->dbflags;
	}
	return (replyp->status);
}

/*
 * PUBLIC: int __dbcl_db_pget_ret __P((DB *, DB_TXN *, DBT *, DBT *, DBT *,
 * PUBLIC:      u_int32_t, __db_pget_reply *));
 */
int
__dbcl_db_pget_ret(dbp, txnp, skey, pkey, data, flags, replyp)
	DB * dbp;
	DB_TXN * txnp;
	DBT * skey;
	DBT * pkey;
	DBT * data;
	u_int32_t flags;
	__db_pget_reply *replyp;
{
	DB_ENV *dbenv;
	int ret;
	void *oldskey, *oldpkey;

	COMPQUIET(txnp, NULL);
	COMPQUIET(flags, 0);

	ret = 0;
	if (replyp->status != 0)
		return (replyp->status);

	dbenv = dbp->dbenv;

	oldskey = skey->data;
	ret = __dbcl_retcopy(dbenv, skey, replyp->skeydata.skeydata_val,
	    replyp->skeydata.skeydata_len, &dbp->my_rskey.data,
	    &dbp->my_rskey.ulen);
	if (ret)
		return (ret);

	oldpkey = pkey->data;
	ret = __dbcl_retcopy(dbenv, pkey, replyp->pkeydata.pkeydata_val,
	    replyp->pkeydata.pkeydata_len, &dbp->my_rkey.data,
	    &dbp->my_rkey.ulen);
	if (ret && oldskey != NULL) {
		__os_free(dbenv, skey->data);
		return (ret);
	}
	ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
	    replyp->datadata.datadata_len, &dbp->my_rdata.data,
	    &dbp->my_rdata.ulen);
	/*
	 * If an error on copying 'data' and we allocated for '*key'
	 * free it before returning the error.
	 */
	if (ret) {
		if (oldskey != NULL)
			__os_free(dbenv, skey->data);
		if (oldpkey != NULL)
			__os_free(dbenv, pkey->data);
	}
	return (ret);
}

/*
 * PUBLIC: int __dbcl_db_put_ret
 * PUBLIC:     __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t, __db_put_reply *));
 */
int
__dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp)
	DB *dbp;
	DB_TXN *txnp;
	DBT *key, *data;
	u_int32_t flags;
	__db_put_reply *replyp;
{
	int ret;

	COMPQUIET(dbp, NULL);
	COMPQUIET(txnp, NULL);
	COMPQUIET(data, NULL);

	ret = replyp->status;
	if (replyp->status == 0 && (flags == DB_APPEND))
		*(db_recno_t *)key->data =
		    *(db_recno_t *)replyp->keydata.keydata_val;
	return (ret);
}

/*
 * PUBLIC: int __dbcl_db_remove_ret __P((DB *,
 * PUBLIC:     const char *, const char *, u_int32_t, __db_remove_reply *));
 */
int
__dbcl_db_remove_ret(dbp, name, subdb, flags, replyp)
	DB *dbp;
	const char *name, *subdb;
	u_int32_t flags;
	__db_remove_reply *replyp;
{
	int ret;

	COMPQUIET(name, 0);
	COMPQUIET(subdb, 0);
	COMPQUIET(flags, 0);

	ret = __dbcl_dbclose_common(dbp);

	if (replyp->status != 0)
		return (replyp->status);
	else
		return (ret);
}

/*
 * PUBLIC: int __dbcl_db_rename_ret __P((DB *, const char *,
 * PUBLIC:     const char *, const char *, u_int32_t, __db_rename_reply *));
 */
int
__dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp)
	DB *dbp;
	const char *name, *subdb, *newname;
	u_int32_t flags;
	__db_rename_reply *replyp;
{
	int ret;

	COMPQUIET(name, 0);
	COMPQUIET(subdb, 0);
	COMPQUIET(newname, 0);
	COMPQUIET(flags, 0);

	ret = __dbcl_dbclose_common(dbp);

	if (replyp->status != 0)
		return (replyp->status);
	else
		return (ret);
}

/*
 * PUBLIC: int __dbcl_db_stat_ret
 * PUBLIC:     __P((DB *, void *, u_int32_t, __db_stat_reply *));
 */
int
__dbcl_db_stat_ret(dbp, sp, flags, replyp)
	DB *dbp;
	void *sp;
	u_int32_t flags;
	__db_stat_reply *replyp;
{
	int len, ret;
	u_int32_t i, *q, *p, *retsp;

	COMPQUIET(flags, 0);

	if (replyp->status != 0 || sp == NULL)
		return (replyp->status);

	len = replyp->stats.stats_len * sizeof(u_int32_t);
	if ((ret = __os_umalloc(dbp->dbenv, len, &retsp)) != 0)
		return (ret);
	for (i = 0, q = retsp, p = (u_int32_t *)replyp->stats.stats_val;
	    i < replyp->stats.stats_len; i++, q++, p++)
		*q = *p;
	*(u_int32_t **)sp = retsp;
	return (0);
}

/*
 * PUBLIC: int __dbcl_db_truncate_ret __P((DB *, DB_TXN *, u_int32_t  *,
 * PUBLIC:      u_int32_t, __db_truncate_reply *));
 */
int
__dbcl_db_truncate_ret(dbp, txnp, countp, flags, replyp)
	DB *dbp;
	DB_TXN *txnp;
	u_int32_t *countp, flags;
	__db_truncate_reply *replyp;
{
	COMPQUIET(dbp, NULL);
	COMPQUIET(txnp, NULL);
	COMPQUIET(flags, 0);

	if (replyp->status != 0)
		return (replyp->status);
	*countp = replyp->count;

	return (replyp->status);
}

/*
 * PUBLIC: int __dbcl_db_cursor_ret
 * PUBLIC:     __P((DB *, DB_TXN *, DBC **, u_int32_t, __db_cursor_reply *));
 */
int
__dbcl_db_cursor_ret(dbp, txnp, dbcp, flags, replyp)
	DB *dbp;
	DB_TXN *txnp;
	DBC **dbcp;
	u_int32_t flags;
	__db_cursor_reply *replyp;
{
	COMPQUIET(txnp, NULL);
	COMPQUIET(flags, 0);

	if (replyp->status != 0)
		return (replyp->status);

	return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcp));
}

/*
 * PUBLIC: int __dbcl_db_join_ret
 * PUBLIC:     __P((DB *, DBC **, DBC **, u_int32_t, __db_join_reply *));
 */
int
__dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp)
	DB *dbp;
	DBC **curs, **dbcp;
	u_int32_t flags;
	__db_join_reply *replyp;
{
	COMPQUIET(curs, NULL);
	COMPQUIET(flags, 0);

	if (replyp->status != 0)
		return (replyp->status);

	/*
	 * We set this up as a normal cursor.  We do not need
	 * to treat a join cursor any differently than a normal
	 * cursor, even though DB itself must.  We only need the
	 * client-side cursor/db relationship to know what cursors
	 * are open in the db, and to store their ID.  Nothing else.
	 */
	return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcp));
}

/*
 * PUBLIC: int __dbcl_dbc_close_ret __P((DBC *, __dbc_close_reply *));
 */
int
__dbcl_dbc_close_ret(dbc, replyp)
	DBC *dbc;
	__dbc_close_reply *replyp;
{
	__dbcl_c_refresh(dbc);
	return (replyp->status);
}

/*
 * PUBLIC: int __dbcl_dbc_count_ret
 * PUBLIC:     __P((DBC *, db_recno_t *, u_int32_t, __dbc_count_reply *));
 */
int
__dbcl_dbc_count_ret(dbc, countp, flags, replyp)
	DBC *dbc;
	db_recno_t *countp;
	u_int32_t flags;
	__dbc_count_reply *replyp;
{
	COMPQUIET(dbc, NULL);
	COMPQUIET(flags, 0);

	if (replyp->status != 0)
		return (replyp->status);
	*countp = replyp->dupcount;

	return (replyp->status);
}

/*
 * PUBLIC: int __dbcl_dbc_dup_ret
 * PUBLIC:     __P((DBC *, DBC **, u_int32_t, __dbc_dup_reply *));
 */
int
__dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp)
	DBC *dbc, **dbcp;
	u_int32_t flags;
	__dbc_dup_reply *replyp;
{
	COMPQUIET(flags, 0);

	if (replyp->status != 0)
		return (replyp->status);

	return (__dbcl_c_setup(replyp->dbcidcl_id, dbc->dbp, dbcp));
}

/*
 * PUBLIC: int __dbcl_dbc_get_ret
 * PUBLIC:     __P((DBC *, DBT *, DBT *, u_int32_t, __dbc_get_reply *));
 */
int
__dbcl_dbc_get_ret(dbc, key, data, flags, replyp)
	DBC *dbc;
	DBT *key, *data;
	u_int32_t flags;
	__dbc_get_reply *replyp;
{
	DB_ENV *dbenv;
	int ret;
	void *oldkey;

	COMPQUIET(flags, 0);

	ret = 0;
	if (replyp->status != 0)
		return (replyp->status);

	dbenv = dbc->dbp->dbenv;
	oldkey = key->data;
	ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val,
	    replyp->keydata.keydata_len, &dbc->my_rkey.data,
	    &dbc->my_rkey.ulen);
	if (ret)
		return (ret);
	ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
	    replyp->datadata.datadata_len, &dbc->my_rdata.data,
	    &dbc->my_rdata.ulen);

	/*
	 * If an error on copying 'data' and we allocated for 'key'
	 * free it before returning the error.
	 */
	if (ret && oldkey != NULL)
		__os_free(dbenv, key->data);
	return (ret);
}

/*
 * PUBLIC: int __dbcl_dbc_pget_ret __P((DBC *, DBT *, DBT *, DBT *, u_int32_t,
 * PUBLIC:      __dbc_pget_reply *));
 */
int
__dbcl_dbc_pget_ret(dbc, skey, pkey, data, flags, replyp)
	DBC * dbc;
	DBT * skey;
	DBT * pkey;
	DBT * data;
	u_int32_t flags;
	__dbc_pget_reply *replyp;
{
	DB_ENV *dbenv;
	int ret;
	void *oldskey, *oldpkey;

	COMPQUIET(flags, 0);

	ret = 0;
	if (replyp->status != 0)
		return (replyp->status);

	dbenv = dbc->dbp->dbenv;

	oldskey = skey->data;
	ret = __dbcl_retcopy(dbenv, skey, replyp->skeydata.skeydata_val,
	    replyp->skeydata.skeydata_len, &dbc->my_rskey.data,
	    &dbc->my_rskey.ulen);
	if (ret)
		return (ret);

	oldpkey = pkey->data;
	ret = __dbcl_retcopy(dbenv, pkey, replyp->pkeydata.pkeydata_val,
	    replyp->pkeydata.pkeydata_len, &dbc->my_rkey.data,
	    &dbc->my_rkey.ulen);
	if (ret && oldskey != NULL) {
		__os_free(dbenv, skey->data);
		return (ret);
	}
	ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
	    replyp->datadata.datadata_len, &dbc->my_rdata.data,
	    &dbc->my_rdata.ulen);
	/*
	 * If an error on copying 'data' and we allocated for '*key'
	 * free it before returning the error.
	 */
	if (ret) {
		if (oldskey != NULL)
			__os_free(dbenv, skey->data);
		if (oldpkey != NULL)
			__os_free(dbenv, pkey->data);
	}
	return (ret);
}

/*
 * PUBLIC: int __dbcl_dbc_put_ret
 * PUBLIC:     __P((DBC *, DBT *, DBT *, u_int32_t, __dbc_put_reply *));
 */
int
__dbcl_dbc_put_ret(dbc, key, data, flags, replyp)
	DBC *dbc;
	DBT *key, *data;
	u_int32_t flags;
	__dbc_put_reply *replyp;
{
	COMPQUIET(data, NULL);

	if (replyp->status != 0)
		return (replyp->status);

	if (replyp->status == 0 && dbc->dbp->type == DB_RECNO &&
	    (flags == DB_AFTER || flags == DB_BEFORE))
		*(db_recno_t *)key->data =
		    *(db_recno_t *)replyp->keydata.keydata_val;
	return (replyp->status);
}
#endif /* HAVE_RPC */