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

#include "kauth.h"

#define KAF_SETTABLE_FLAGS (KAFADMIN | KAFNOTGS | KAFNOSEAL | KAFNOCPW | KAFNEWASSOC)
#ifndef NEVERDATE
#define NEVERDATE 037777777777 /* a date that will never come */
#endif
#ifndef Date
#define Date afs_uint32
#endif
#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV)
#define AUTH_DBM_LOG
#endif
static afs_int32 _KAA_Authenticate_old(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_uint32 start_time, end_time;
	struct ka_CBS request;
	struct ka_BBS answer;


	request.SeqBody = 0;
	answer.SeqBody = 0;
	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_uint32(z_xdrs, &start_time))
	     || (!xdr_afs_uint32(z_xdrs, &end_time))
	     || (!xdr_ka_CBS(z_xdrs, &request))
	     || (!xdr_ka_BBS(z_xdrs, &answer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAA_Authenticate_old(z_call, name, instance, start_time, end_time, &request, &answer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &answer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &request)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &answer)) 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, KAA_STATINDEX,
		0, KAA_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, KAA_STATINDEX,
		0, KAA_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAA_Authenticate(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_uint32 start_time, end_time;
	struct ka_CBS request;
	struct ka_BBS answer;


	request.SeqBody = 0;
	answer.SeqBody = 0;
	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_uint32(z_xdrs, &start_time))
	     || (!xdr_afs_uint32(z_xdrs, &end_time))
	     || (!xdr_ka_CBS(z_xdrs, &request))
	     || (!xdr_ka_BBS(z_xdrs, &answer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAA_Authenticate(z_call, name, instance, start_time, end_time, &request, &answer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &answer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &request)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &answer)) 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, KAA_STATINDEX,
		1, KAA_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, KAA_STATINDEX,
		1, KAA_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAA_AuthenticateV2(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_uint32 start_time, end_time;
	struct ka_CBS request;
	struct ka_BBS answer;


	request.SeqBody = 0;
	answer.SeqBody = 0;
	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_uint32(z_xdrs, &start_time))
	     || (!xdr_afs_uint32(z_xdrs, &end_time))
	     || (!xdr_ka_CBS(z_xdrs, &request))
	     || (!xdr_ka_BBS(z_xdrs, &answer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAA_AuthenticateV2(z_call, name, instance, start_time, end_time, &request, &answer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &answer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &request)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &answer)) 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, KAA_STATINDEX,
		2, KAA_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, KAA_STATINDEX,
		2, KAA_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAA_ChangePassword(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	struct ka_CBS arequest;
	struct ka_BBS oanswer;


	arequest.SeqBody = 0;
	oanswer.SeqBody = 0;
	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_ka_CBS(z_xdrs, &arequest))
	     || (!xdr_ka_BBS(z_xdrs, &oanswer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAA_ChangePassword(z_call, name, instance, &arequest, &oanswer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &oanswer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &arequest)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &oanswer)) 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, KAA_STATINDEX,
		3, KAA_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, KAA_STATINDEX,
		3, KAA_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAT_GetTicket_old(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 kvno;
	kaname auth_domain, name, instance;
	struct ka_CBS aticket, atimes;
	struct ka_BBS oanswer;


	aticket.SeqBody = 0;
	atimes.SeqBody = 0;
	oanswer.SeqBody = 0;
	auth_domain = 0;
	name = 0;
	instance = 0;

	if ((!xdr_afs_int32(z_xdrs, &kvno))
	     || (!xdr_kaname(z_xdrs, &auth_domain))
	     || (!xdr_ka_CBS(z_xdrs, &aticket))
	     || (!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_ka_CBS(z_xdrs, &atimes))
	     || (!xdr_ka_BBS(z_xdrs, &oanswer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAT_GetTicket_old(z_call, kvno, auth_domain, &aticket, name, instance, &atimes, &oanswer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &oanswer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &auth_domain)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &aticket)) goto fail1;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &atimes)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &oanswer)) 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, KAT_STATINDEX,
		0, KAT_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, KAT_STATINDEX,
		0, KAT_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAT_GetTicket(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 kvno;
	kaname auth_domain, name, instance;
	struct ka_CBS aticket, atimes;
	struct ka_BBS oanswer;


	aticket.SeqBody = 0;
	atimes.SeqBody = 0;
	oanswer.SeqBody = 0;
	auth_domain = 0;
	name = 0;
	instance = 0;

	if ((!xdr_afs_int32(z_xdrs, &kvno))
	     || (!xdr_kaname(z_xdrs, &auth_domain))
	     || (!xdr_ka_CBS(z_xdrs, &aticket))
	     || (!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_ka_CBS(z_xdrs, &atimes))
	     || (!xdr_ka_BBS(z_xdrs, &oanswer))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAT_GetTicket(z_call, kvno, auth_domain, &aticket, name, instance, &atimes, &oanswer);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_BBS(z_xdrs, &oanswer)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &auth_domain)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &aticket)) goto fail1;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) goto fail1;
	if (!xdr_ka_CBS(z_xdrs, &atimes)) goto fail1;
	if (!xdr_ka_BBS(z_xdrs, &oanswer)) 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, KAT_STATINDEX,
		1, KAT_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, KAT_STATINDEX,
		1, KAT_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_SetPassword(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_int32 kvno;
	EncryptionKey password;



	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_int32(z_xdrs, &kvno))
	     || (!xdr_EncryptionKey(z_xdrs, &password))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_SetPassword(z_call, name, instance, kvno, password);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		0, KAM_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, KAM_STATINDEX,
		0, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_SetFields(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_int32 flags, max_ticket_lifetime, maxAssociates, spare2;
	afs_uint32 user_expiration, misc_auth_bytes;



	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_int32(z_xdrs, &flags))
	     || (!xdr_afs_uint32(z_xdrs, &user_expiration))
	     || (!xdr_afs_int32(z_xdrs, &max_ticket_lifetime))
	     || (!xdr_afs_int32(z_xdrs, &maxAssociates))
	     || (!xdr_afs_uint32(z_xdrs, &misc_auth_bytes))
	     || (!xdr_afs_int32(z_xdrs, &spare2))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_SetFields(z_call, name, instance, flags, user_expiration, max_ticket_lifetime, maxAssociates, misc_auth_bytes, spare2);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		1, KAM_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, KAM_STATINDEX,
		1, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_CreateUser(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	EncryptionKey password;



	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_EncryptionKey(z_xdrs, &password))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_CreateUser(z_call, name, instance, password);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		2, KAM_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, KAM_STATINDEX,
		2, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_DeleteUser(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;



	name = 0;
	instance = 0;

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

	z_result = SKAM_DeleteUser(z_call, name, instance);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		3, KAM_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, KAM_STATINDEX,
		3, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_GetEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_int32 major_version;
	struct kaentryinfo entry;



	name = 0;
	instance = 0;

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

	z_result = SKAM_GetEntry(z_call, name, instance, major_version, &entry);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_kaentryinfo(z_xdrs, &entry)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		4, KAM_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, KAM_STATINDEX,
		4, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_ListEntry(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 previous_index;
	afs_int32 index, count;
	kaident name;




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

	z_result = SKAM_ListEntry(z_call, previous_index, &index, &count, &name);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &index))
	     || (!xdr_afs_int32(z_xdrs, &count))
	     || (!xdr_kaident(z_xdrs, &name)))
		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, KAM_STATINDEX,
		5, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _KAM_GetStats(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 major_version;
	afs_int32 admin_accounts;
	struct kasstats statics;
	struct kadstats dynamics;




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

	z_result = SKAM_GetStats(z_call, major_version, &admin_accounts, &statics, &dynamics);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &admin_accounts))
	     || (!xdr_kasstats(z_xdrs, &statics))
	     || (!xdr_kadstats(z_xdrs, &dynamics)))
		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, KAM_STATINDEX,
		6, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _KAM_Debug(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	afs_int32 major_version;
	int checkDB;
	struct ka_debugInfo info;




	if ((!xdr_afs_int32(z_xdrs, &major_version))
	     || (!xdr_int(z_xdrs, &checkDB))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_Debug(z_call, major_version, checkDB, &info);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_ka_debugInfo(z_xdrs, &info)))
		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, KAM_STATINDEX,
		7, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _KAM_GetPassword(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name;
	EncryptionKey password;



	name = 0;

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

	z_result = SKAM_GetPassword(z_call, name, &password);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_EncryptionKey(z_xdrs, &password)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) 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, KAM_STATINDEX,
		8, KAM_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, KAM_STATINDEX,
		8, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

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



	z_result = SKAM_GetRandomKey(z_call, &password);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_EncryptionKey(z_xdrs, &password)))
		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, KAM_STATINDEX,
		9, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return z_result;
}

static afs_int32 _KAM_Unlock(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_int32 spare1, spare2, spare3, spare4;



	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_int32(z_xdrs, &spare1))
	     || (!xdr_afs_int32(z_xdrs, &spare2))
	     || (!xdr_afs_int32(z_xdrs, &spare3))
	     || (!xdr_afs_int32(z_xdrs, &spare4))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_Unlock(z_call, name, instance, spare1, spare2, spare3, spare4);
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		10, KAM_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, KAM_STATINDEX,
		10, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}

static afs_int32 _KAM_LockStatus(struct rx_call *z_call, XDR *z_xdrs)
{
	afs_int32 z_result;
	struct clock __QUEUE, __EXEC;
	kaname name, instance;
	afs_int32 lockeduntil;
	afs_int32 spare1, spare2, spare3, spare4;



	name = 0;
	instance = 0;

	if ((!xdr_kaname(z_xdrs, &name))
	     || (!xdr_kaname(z_xdrs, &instance))
	     || (!xdr_afs_int32(z_xdrs, &spare1))
	     || (!xdr_afs_int32(z_xdrs, &spare2))
	     || (!xdr_afs_int32(z_xdrs, &spare3))
	     || (!xdr_afs_int32(z_xdrs, &spare4))) {
		z_result = RXGEN_SS_UNMARSHAL;
		goto fail;
	}

	z_result = SKAM_LockStatus(z_call, name, instance, &lockeduntil, spare1, spare2, spare3, spare4);
	z_xdrs->x_op = XDR_ENCODE;
	if ((!xdr_afs_int32(z_xdrs, &lockeduntil)))
		z_result = RXGEN_SS_MARSHAL;
fail:
	z_xdrs->x_op = XDR_FREE;
	if (!xdr_kaname(z_xdrs, &name)) goto fail1;
	if (!xdr_kaname(z_xdrs, &instance)) 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, KAM_STATINDEX,
		11, KAM_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, KAM_STATINDEX,
		11, KAM_NO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,
		&z_call->bytesSent, &z_call->bytesRcvd, 0);
	}

	return RXGEN_SS_XDRFREE;
}


int KAA_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 1:
			z_result = _KAA_Authenticate_old(z_call, &z_xdrs);
			break;
		case 21:
			z_result = _KAA_Authenticate(z_call, &z_xdrs);
			break;
		case 22:
			z_result = _KAA_AuthenticateV2(z_call, &z_xdrs);
			break;
		case 2:
			z_result = _KAA_ChangePassword(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}

int KAT_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 3:
			z_result = _KAT_GetTicket_old(z_call, &z_xdrs);
			break;
		case 23:
			z_result = _KAT_GetTicket(z_call, &z_xdrs);
			break;
		default:
			z_result = RXGEN_OPCODE;
			break;
	}
fail:
	return z_result;
}


static afs_int32 (*StubProcsArray2[])(struct rx_call *z_call, XDR *z_xdrs) = {_KAM_SetPassword, _KAM_SetFields, _KAM_CreateUser, _KAM_DeleteUser, _KAM_GetEntry, _KAM_ListEntry, _KAM_GetStats, _KAM_Debug, _KAM_GetPassword, _KAM_GetRandomKey, _KAM_Unlock, _KAM_LockStatus};

int KAM_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 < KAM_LOWEST_OPCODE || op > KAM_HIGHEST_OPCODE)
		z_result = RXGEN_OPCODE;
	else
		z_result = (*StubProcsArray2[op - KAM_LOWEST_OPCODE])(z_call, &z_xdrs);
	return hton_syserr_conv(z_result);
}