/* Machine generated file -- Do NOT edit */

#include <afsconfig.h>
#include <afs/param.h>
#include <roken.h>
#include <afs/opr.h>
#ifdef AFS_PTHREAD_ENV
# include <opr/lock.h>
#endif
#include "afscbint.h"

#ifndef FSINT_COMMON_XG
#endif /* FSINT_COMMON_XG */
int RXAFSCB_CallBack(struct rx_connection *z_conn,AFSCBFids * Fids_Array,AFSCBs * CallBacks_Array)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 204;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_AFSCBFids(&z_xdrs, Fids_Array))
	     || (!xdr_AFSCBs(&z_xdrs, CallBacks_Array))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		0, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartRXAFSCB_CallBack(struct rx_call *z_call,AFSCBFids * Fids_Array,AFSCBs * CallBacks_Array)
{
	static int z_op = 204;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_AFSCBFids(&z_xdrs, Fids_Array))
	     || (!xdr_AFSCBs(&z_xdrs, CallBacks_Array))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndRXAFSCB_CallBack(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		0, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_InitCallBackState(struct rx_connection *z_conn)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 205;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		1, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_Probe(struct rx_connection *z_conn)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 206;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		2, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartRXAFSCB_Probe(struct rx_call *z_call)
{
	static int z_op = 206;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndRXAFSCB_Probe(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		2, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetLock(struct rx_connection *z_conn,afs_int32 index,AFSDBLock * lock)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 207;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &index))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_AFSDBLock(&z_xdrs, lock))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		3, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetCE(struct rx_connection *z_conn,afs_int32 index,AFSDBCacheEntry * ce)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 208;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &index))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_AFSDBCacheEntry(&z_xdrs, ce))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		4, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_XStatsVersion(struct rx_connection *z_conn,afs_int32 * versionNumberP)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 209;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, versionNumberP))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		5, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetXStats(struct rx_connection *z_conn,afs_int32 clientVersionNumber,afs_int32 collectionNumber,afs_int32 * srvVersionNumberP,afs_int32 * timeP,AFSCB_CollData * dataP)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 210;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &clientVersionNumber))
	     || (!xdr_afs_int32(&z_xdrs, &collectionNumber))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, srvVersionNumberP))
	     || (!xdr_afs_int32(&z_xdrs, timeP))
	     || (!xdr_AFSCB_CollData(&z_xdrs, dataP))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		6, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_InitCallBackState2(struct rx_connection *z_conn,struct interfaceAddr * addr)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 211;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_interfaceAddr(&z_xdrs, addr))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		7, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_WhoAreYou(struct rx_connection *z_conn,struct interfaceAddr * addr)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 212;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_interfaceAddr(&z_xdrs, addr))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		8, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_InitCallBackState3(struct rx_connection *z_conn,afsUUID * serverUuid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 213;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afsUUID(&z_xdrs, serverUuid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		9, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_ProbeUuid(struct rx_connection *z_conn,afsUUID * clientUuid)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 214;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afsUUID(&z_xdrs, clientUuid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		10, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int StartRXAFSCB_ProbeUuid(struct rx_call *z_call,afsUUID * clientUuid)
{
	static int z_op = 214;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afsUUID(&z_xdrs, clientUuid))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	return z_result;
}

int EndRXAFSCB_ProbeUuid(struct rx_call *z_call)
{
	int z_result;
	z_result = RXGEN_SUCCESS;
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		10, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetServerPrefs(struct rx_connection *z_conn,afs_int32 serverIndex,afs_int32 * srvrAddr,afs_int32 * srvrRank)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 215;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &serverIndex))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_int32(&z_xdrs, srvrAddr))
	     || (!xdr_afs_int32(&z_xdrs, srvrRank))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		11, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetCellServDB(struct rx_connection *z_conn,afs_int32 cellIndex,char * *cellName,serverList * cellHosts)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 216;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &cellIndex))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_string(&z_xdrs, cellName, AFSNAMEMAX))
	     || (!xdr_serverList(&z_xdrs, cellHosts))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		12, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetLocalCell(struct rx_connection *z_conn,char * *cellName)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 217;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_string(&z_xdrs, cellName, AFSNAMEMAX))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		13, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetCacheConfig(struct rx_connection *z_conn,afs_uint32 callerVersion,afs_uint32 * serverVersion,afs_uint32 * configCount,cacheConfig * config)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 218;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_uint32(&z_xdrs, &callerVersion))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_afs_uint32(&z_xdrs, serverVersion))
	     || (!xdr_afs_uint32(&z_xdrs, configCount))
	     || (!xdr_cacheConfig(&z_xdrs, config))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		14, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetCE64(struct rx_connection *z_conn,afs_int32 index,AFSDBCacheEntry64 * ce)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65536;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &index))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_AFSDBCacheEntry64(&z_xdrs, ce))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		15, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_GetCellByNum(struct rx_connection *z_conn,afs_int32 cellNumber,char * *cellName,serverList * cellHosts)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65537;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))
	     || (!xdr_afs_int32(&z_xdrs, &cellNumber))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_string(&z_xdrs, cellName, AFSNAMEMAX))
	     || (!xdr_serverList(&z_xdrs, cellHosts))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		16, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

int RXAFSCB_TellMeAboutYourself(struct rx_connection *z_conn,struct interfaceAddr * addr,Capabilities * capabilities)
{
	struct rx_call *z_call = rx_NewCall(z_conn);
	static int z_op = 65538;
	int z_result;
	XDR z_xdrs;
	xdrrx_create(&z_xdrs, z_call, XDR_ENCODE);

	/* Marshal the arguments */
	if ((!xdr_int(&z_xdrs, &z_op))) {
		z_result = RXGEN_CC_MARSHAL;
		goto fail;
	}

	/* Un-marshal the reply arguments */
	z_xdrs.x_op = XDR_DECODE;
	if ((!xdr_interfaceAddr(&z_xdrs, addr))
	     || (!xdr_Capabilities(&z_xdrs, capabilities))) {
		z_result = RXGEN_CC_UNMARSHAL;
		goto fail;
	}

	z_result = RXGEN_SUCCESS;
fail:
	z_result = rx_EndCall(z_call, z_result);
	if (rx_enable_stats) {
	    rx_RecordCallStatistics(z_call, RXAFSCB_STATINDEX,
		17, RXAFSCB_NO_OF_STAT_FUNCS, 1);
	}

	return z_result;
}

