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

#include "bosint.h"

#undef min
#define BOZO_HASCORE 1 /* core file exists */
#define BOZO_ERRORSTOP 2 /* stopped due to too many errors */
#define BOZO_BADDIRACCESS 4 /* bad mode bits on /usr/afs dirs */
#define BOZO_PRUNEOLD 1 /* prune .OLD files */
#define BOZO_PRUNEBAK 2 /* prune .BAK files */
#define BOZO_PRUNECORE 4 /* prune core files */
static afs_int32 _BOZO_CreateBnode(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * type=(char *)0, *instance=(char *)0, *p1=(char *)0, *p2=(char *)0, *p3=(char *)0, *p4=(char *)0, *p5=(char *)0, *p6=(char *)0;



	if ((!xdr_string(z_xdrs, &type, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p1, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p2, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p3, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p4, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p5, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &p6, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_CreateBnode(z_call, type, instance, p1, p2, p3, p4, p5, p6);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &type, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p1, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p2, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p3, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p4, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p5, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &p6, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		0, BOZO_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, BOZO_STATINDEX,
		0, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_DeleteBnode(z_call, instance);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		1, BOZO_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, BOZO_STATINDEX,
		1, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))
	     || (!xdr_afs_int32(z_xdrs, &status))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_SetStatus(z_call, instance, status);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		2, BOZO_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, BOZO_STATINDEX,
		2, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_GetStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * instance=(char *)0, *statdescr=(char *)0;
	afs_int32 intStat;



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetStatus(z_call, instance, &intStat, &statdescr);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &intStat))
	     || (!xdr_string(z_xdrs, &statdescr, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &statdescr, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		3, BOZO_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, BOZO_STATINDEX,
		3, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



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

	z_result = SBOZO_EnumerateInstance(z_call, instance, &iname);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &iname, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &iname, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		4, BOZO_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, BOZO_STATINDEX,
		4, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_GetInstanceInfo(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * instance=(char *)0, *type=(char *)0;
	struct bozo_status status;



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetInstanceInfo(z_call, instance, &type, &status);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &type, BOZO_BSSIZE))
	     || (!xdr_bozo_status(z_xdrs, &status)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &type, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		5, BOZO_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, BOZO_STATINDEX,
		5, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_GetInstanceParm(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * instance=(char *)0, *parm=(char *)0;
	afs_int32 num;



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))
	     || (!xdr_afs_int32(z_xdrs, &num))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetInstanceParm(z_call, instance, num, &parm);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &parm, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &parm, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		6, BOZO_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, BOZO_STATINDEX,
		6, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_AddSUser(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		7, BOZO_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, BOZO_STATINDEX,
		7, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_DeleteSUser(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		8, BOZO_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, BOZO_STATINDEX,
		8, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



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

	z_result = SBOZO_ListSUsers(z_call, an, &name);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		9, BOZO_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, BOZO_STATINDEX,
		9, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_ListKeys(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 an;
	afs_int32 kvno;
	struct bozo_key key;
	struct bozo_keyInfo keyinfo;




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

	z_result = SBOZO_ListKeys(z_call, an, &kvno, &key, &keyinfo);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &kvno))
	     || (!xdr_bozo_key(z_xdrs, &key))
	     || (!xdr_bozo_keyInfo(z_xdrs, &keyinfo)))
		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, BOZO_STATINDEX,
		10, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _BOZO_AddKey(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 an;
	struct bozo_key key;




	if ((!xdr_afs_int32(z_xdrs, &an))
	     || (!xdr_bozo_key(z_xdrs, &key))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_AddKey(z_call, an, &key);
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, BOZO_STATINDEX,
		11, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SBOZO_DeleteKey(z_call, an);
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, BOZO_STATINDEX,
		12, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_SetCellName(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		13, BOZO_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, BOZO_STATINDEX,
		13, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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


	z_result = SBOZO_GetCellName(z_call, &name);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		14, BOZO_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, BOZO_STATINDEX,
		14, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_GetCellHost(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_uint32 awhich;
	char * name=(char *)0;



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

	z_result = SBOZO_GetCellHost(z_call, awhich, &name);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		15, BOZO_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, BOZO_STATINDEX,
		15, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_AddCellHost(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		16, BOZO_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, BOZO_STATINDEX,
		16, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_DeleteCellHost(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		17, BOZO_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, BOZO_STATINDEX,
		17, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))
	     || (!xdr_afs_int32(z_xdrs, &status))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_SetTStatus(z_call, instance, status);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		18, BOZO_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, BOZO_STATINDEX,
		18, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = SBOZO_ShutdownAll(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, BOZO_STATINDEX,
		19, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = SBOZO_RestartAll(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, BOZO_STATINDEX,
		20, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = SBOZO_StartupAll(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, BOZO_STATINDEX,
		21, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SBOZO_SetNoAuthFlag(z_call, flag);
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, BOZO_STATINDEX,
		22, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	z_result = SBOZO_ReBozo(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, BOZO_STATINDEX,
		23, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_Restart(z_call, instance);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		24, BOZO_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, BOZO_STATINDEX,
		24, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_Install(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * path=(char *)0;
	afs_int32 size, flags, date;



	if ((!xdr_string(z_xdrs, &path, BOZO_BSSIZE))
	     || (!xdr_afs_int32(z_xdrs, &size))
	     || (!xdr_afs_int32(z_xdrs, &flags))
	     || (!xdr_afs_int32(z_xdrs, &date))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_Install(z_call, path, size, flags, date);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &path, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		25, BOZO_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, BOZO_STATINDEX,
		25, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &path, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_UnInstall(z_call, path);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &path, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		26, BOZO_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, BOZO_STATINDEX,
		26, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _BOZO_GetDates(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * path=(char *)0;
	afs_int32 newtime, baktime, oldtime;



	if ((!xdr_string(z_xdrs, &path, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetDates(z_call, path, &newtime, &baktime, &oldtime);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &newtime))
	     || (!xdr_afs_int32(z_xdrs, &baktime))
	     || (!xdr_afs_int32(z_xdrs, &oldtime)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &path, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		27, BOZO_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, BOZO_STATINDEX,
		27, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	if ((!xdr_string(z_xdrs, &cmd, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_Exec(z_call, cmd);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &cmd, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		28, BOZO_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, BOZO_STATINDEX,
		28, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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




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

	z_result = SBOZO_Prune(z_call, flags);
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, BOZO_STATINDEX,
		29, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _BOZO_SetRestartTime(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 type;
	struct bozo_netKTime restartTime;




	if ((!xdr_afs_int32(z_xdrs, &type))
	     || (!xdr_bozo_netKTime(z_xdrs, &restartTime))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_SetRestartTime(z_call, type, &restartTime);
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, BOZO_STATINDEX,
		30, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _BOZO_GetRestartTime(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 type;
	struct bozo_netKTime restartTime;




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

	z_result = SBOZO_GetRestartTime(z_call, type, &restartTime);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_bozo_netKTime(z_xdrs, &restartTime)))
		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, BOZO_STATINDEX,
		31, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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



	if ((!xdr_string(z_xdrs, &name, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetLog(z_call, name);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &name, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		32, BOZO_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, BOZO_STATINDEX,
		32, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = SBOZO_WaitAll(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, BOZO_STATINDEX,
		33, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _BOZO_GetInstanceStrings(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	char * instance=(char *)0, *errorName=(char *)0, *spare1=(char *)0, *spare2=(char *)0, *spare3=(char *)0;



	if ((!xdr_string(z_xdrs, &instance, BOZO_BSSIZE))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SBOZO_GetInstanceStrings(z_call, instance, &errorName, &spare1, &spare2, &spare3);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_string(z_xdrs, &errorName, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &spare1, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &spare2, BOZO_BSSIZE))
	     || (!xdr_string(z_xdrs, &spare3, BOZO_BSSIZE)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_string(z_xdrs, &instance, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &errorName, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &spare1, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &spare2, BOZO_BSSIZE)) goto fail1;
	if (!xdr_string(z_xdrs, &spare3, BOZO_BSSIZE)) 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, BOZO_STATINDEX,
		34, BOZO_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, BOZO_STATINDEX,
		34, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = SBOZO_GetRestrictedMode(z_call, &restmode);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &restmode)))
		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, BOZO_STATINDEX,
		35, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

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




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

	z_result = SBOZO_SetRestrictedMode(z_call, restmode);
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, BOZO_STATINDEX,
		36, BOZO_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}



static afs_int32 (*StubProcsArray0[])(struct rx_call *z_call, XDR *z_xdrs) = {_BOZO_CreateBnode, _BOZO_DeleteBnode, _BOZO_SetStatus, _BOZO_GetStatus, _BOZO_EnumerateInstance, _BOZO_GetInstanceInfo, _BOZO_GetInstanceParm, _BOZO_AddSUser, _BOZO_DeleteSUser, _BOZO_ListSUsers, _BOZO_ListKeys, _BOZO_AddKey, _BOZO_DeleteKey, _BOZO_SetCellName, _BOZO_GetCellName, _BOZO_GetCellHost, _BOZO_AddCellHost, _BOZO_DeleteCellHost, _BOZO_SetTStatus, _BOZO_ShutdownAll, _BOZO_RestartAll, _BOZO_StartupAll, _BOZO_SetNoAuthFlag, _BOZO_ReBozo, _BOZO_Restart, _BOZO_Install, _BOZO_UnInstall, _BOZO_GetDates, _BOZO_Exec, _BOZO_Prune, _BOZO_SetRestartTime, _BOZO_GetRestartTime, _BOZO_GetLog, _BOZO_WaitAll, _BOZO_GetInstanceStrings, _BOZO_GetRestrictedMode, _BOZO_SetRestrictedMode};

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

	xdrrx_create(&z_xdrs, z_call, XDR_DECODE);
	if (!xdr_int(&z_xdrs, &op))
		z_result = RXGEN_DECODE;
	else if (op < BOZO_LOWEST_OPCODE || op > BOZO_HIGHEST_OPCODE)
		z_result = RXGEN_OPCODE;
	else
		z_result = (*StubProcsArray0[op - BOZO_LOWEST_OPCODE])(z_call, &z_xdrs);
	return hton_syserr_conv(z_result);
}