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

#include "afscbint.h"
#ifndef FSINT_COMMON_XG
#endif /* FSINT_COMMON_XG */
#ifdef KERNEL
#include "../afs/longc_procs.h"
#endif
static afs_int32 _RXAFSCB_CallBack(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	AFSCBFids Fids_Array;
	AFSCBs CallBacks_Array;



	Fids_Array.AFSCBFids_val = 0;
	Fids_Array.AFSCBFids_len = 0;
	CallBacks_Array.AFSCBs_val = 0;
	CallBacks_Array.AFSCBs_len = 0;

	if ((!xdr_AFSCBFids(z_xdrs, &Fids_Array))
	     || (!xdr_AFSCBs(z_xdrs, &CallBacks_Array))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_CallBack(z_call, &Fids_Array, &CallBacks_Array);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSCBFids(z_xdrs, &Fids_Array)) goto fail1;
	if (!xdr_AFSCBs(z_xdrs, &CallBacks_Array)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		0, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		0, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_InitCallBackState(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;



	z_result = SRXAFSCB_InitCallBackState(z_call);
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		1, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_Probe(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;



	z_result = SRXAFSCB_Probe(z_call);
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		2, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetLock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 index;
	AFSDBLock lock;




	if ((!xdr_afs_int32(z_xdrs, &index))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetLock(z_call, index, &lock);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSDBLock(z_xdrs, &lock)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		3, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetCE(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 index;
	AFSDBCacheEntry ce;




	if ((!xdr_afs_int32(z_xdrs, &index))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetCE(z_call, index, &ce);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSDBCacheEntry(z_xdrs, &ce)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		4, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_XStatsVersion(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 versionNumberP;



	z_result = SRXAFSCB_XStatsVersion(z_call, &versionNumberP);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &versionNumberP)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		5, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetXStats(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 clientVersionNumber, collectionNumber;
	afs_int32 srvVersionNumberP, timeP;
	AFSCB_CollData dataP;



	dataP.AFSCB_CollData_val = 0;
	dataP.AFSCB_CollData_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &clientVersionNumber))
	     || (!xdr_afs_int32(z_xdrs, &collectionNumber))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetXStats(z_call, clientVersionNumber, collectionNumber, &srvVersionNumberP, &timeP, &dataP);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &srvVersionNumberP))
	     || (!xdr_afs_int32(z_xdrs, &timeP))
	     || (!xdr_AFSCB_CollData(z_xdrs, &dataP)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_AFSCB_CollData(z_xdrs, &dataP)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		6, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		6, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_InitCallBackState2(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	struct interfaceAddr addr;



	z_result = SRXAFSCB_InitCallBackState2(z_call, &addr);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_interfaceAddr(z_xdrs, &addr)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		7, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_WhoAreYou(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	struct interfaceAddr addr;



	z_result = SRXAFSCB_WhoAreYou(z_call, &addr);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_interfaceAddr(z_xdrs, &addr)))
		z_result = RXGEN_SS_MARSHAL;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		8, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_InitCallBackState3(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afsUUID serverUuid;




	if ((!xdr_afsUUID(z_xdrs, &serverUuid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_InitCallBackState3(z_call, &serverUuid);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		9, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_ProbeUuid(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afsUUID clientUuid;




	if ((!xdr_afsUUID(z_xdrs, &clientUuid))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_ProbeUuid(z_call, &clientUuid);
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		10, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetServerPrefs(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 serverIndex;
	afs_int32 srvrAddr, srvrRank;




	if ((!xdr_afs_int32(z_xdrs, &serverIndex))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetServerPrefs(z_call, serverIndex, &srvrAddr, &srvrRank);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &srvrAddr))
	     || (!xdr_afs_int32(z_xdrs, &srvrRank)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		11, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetCellServDB(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 cellIndex;
	char * cellName=(char *)0;
	serverList cellHosts;


	cellHosts.serverList_val = 0;
	cellHosts.serverList_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &cellIndex))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetCellServDB(z_call, cellIndex, &cellName, &cellHosts);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &cellName, AFSNAMEMAX))
	     || (!xdr_serverList(z_xdrs, &cellHosts)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &cellName, AFSNAMEMAX)) goto fail1;
	if (!xdr_serverList(z_xdrs, &cellHosts)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		12, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		12, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_GetLocalCell(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * cellName=(char *)0;


	z_result = SRXAFSCB_GetLocalCell(z_call, &cellName);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &cellName, AFSNAMEMAX)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &cellName, AFSNAMEMAX)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		13, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		13, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_GetCacheConfig(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_uint32 callerVersion;
	afs_uint32 serverVersion, configCount;
	cacheConfig config;



	config.cacheConfig_val = 0;
	config.cacheConfig_len = 0;

	if ((!xdr_afs_uint32(z_xdrs, &callerVersion))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetCacheConfig(z_call, callerVersion, &serverVersion, &configCount, &config);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_uint32(z_xdrs, &serverVersion))
	     || (!xdr_afs_uint32(z_xdrs, &configCount))
	     || (!xdr_cacheConfig(z_xdrs, &config)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_cacheConfig(z_xdrs, &config)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		14, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		14, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_GetCE64(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 index;
	AFSDBCacheEntry64 ce;




	if ((!xdr_afs_int32(z_xdrs, &index))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetCE64(z_call, index, &ce);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_AFSDBCacheEntry64(z_xdrs, &ce)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		15, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _RXAFSCB_GetCellByNum(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 cellNumber;
	char * cellName=(char *)0;
	serverList cellHosts;


	cellHosts.serverList_val = 0;
	cellHosts.serverList_len = 0;

	if ((!xdr_afs_int32(z_xdrs, &cellNumber))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SRXAFSCB_GetCellByNum(z_call, cellNumber, &cellName, &cellHosts);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &cellName, AFSNAMEMAX))
	     || (!xdr_serverList(z_xdrs, &cellHosts)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &cellName, AFSNAMEMAX)) goto fail1;
	if (!xdr_serverList(z_xdrs, &cellHosts)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		16, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		16, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _RXAFSCB_TellMeAboutYourself(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	struct interfaceAddr addr;
	Capabilities capabilities;



	capabilities.Capabilities_val = 0;
	capabilities.Capabilities_len = 0;
	z_result = SRXAFSCB_TellMeAboutYourself(z_call, &addr, &capabilities);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_interfaceAddr(z_xdrs, &addr))
	     || (!xdr_Capabilities(z_xdrs, &capabilities)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_Capabilities(z_xdrs, &capabilities)) goto fail1;
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		17, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
fail1:
	if (rx_enable_stats) {
	    clock_GetTime(&__EXEC);
	    clock_Sub(&__EXEC, &z_call->startTime);
	    __QUEUE = z_call->startTime;
	    clock_Sub(&__QUEUE, &z_call->queueTime);
	    rx_IncrementTimeAndCount(z_call->conn->peer, RXAFSCB_STATINDEX,
		17, RXAFSCB_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}


int RXAFSCB_ExecuteRequest (register struct rx_call *z_call)
{
	int op;
	XDR z_xdrs;
	afs_int32 z_result;

	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	z_result = RXGEN_DECODE;
	if (!xdr_int(&z_xdrs, &op)) goto fail;
	switch (op) {
		case 204:
			z_result = _RXAFSCB_CallBack(z_call, &z_xdrs);
			break;
		case 205:
			z_result = _RXAFSCB_InitCallBackState(z_call, &z_xdrs);
			break;
		case 206:
			z_result = _RXAFSCB_Probe(z_call, &z_xdrs);
			break;
		case 207:
			z_result = _RXAFSCB_GetLock(z_call, &z_xdrs);
			break;
		case 208:
			z_result = _RXAFSCB_GetCE(z_call, &z_xdrs);
			break;
		case 209:
			z_result = _RXAFSCB_XStatsVersion(z_call, &z_xdrs);
			break;
		case 210:
			z_result = _RXAFSCB_GetXStats(z_call, &z_xdrs);
			break;
		case 211:
			z_result = _RXAFSCB_InitCallBackState2(z_call, &z_xdrs);
			break;
		case 212:
			z_result = _RXAFSCB_WhoAreYou(z_call, &z_xdrs);
			break;
		case 213:
			z_result = _RXAFSCB_InitCallBackState3(z_call, &z_xdrs);
			break;
		case 214:
			z_result = _RXAFSCB_ProbeUuid(z_call, &z_xdrs);
			break;
		case 215:
			z_result = _RXAFSCB_GetServerPrefs(z_call, &z_xdrs);
			break;
		case 216:
			z_result = _RXAFSCB_GetCellServDB(z_call, &z_xdrs);
			break;
		case 217:
			z_result = _RXAFSCB_GetLocalCell(z_call, &z_xdrs);
			break;
		case 218:
			z_result = _RXAFSCB_GetCacheConfig(z_call, &z_xdrs);
			break;
		case 65536:
			z_result = _RXAFSCB_GetCE64(z_call, &z_xdrs);
			break;
		case 65537:
			z_result = _RXAFSCB_GetCellByNum(z_call, &z_xdrs);
			break;
		case 65538:
			z_result = _RXAFSCB_TellMeAboutYourself(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}