Implement support for RPCSEC_GSS authentication to both the NFS client

and server. This replaces the RPC implementation of the NFS client and
server with the newer RPC implementation originally developed
(actually ported from the userland sunrpc code) to support the NFS
Lock Manager.  I have tested this code extensively and I believe it is
stable and that performance is at least equal to the legacy RPC
implementation.

The NFS code currently contains support for both the new RPC
implementation and the older legacy implementation inherited from the
original NFS codebase. The default is to use the new implementation -
add the NFS_LEGACYRPC option to fall back to the old code. When I
merge this support back to RELENG_7, I will probably change this so
that users have to 'opt in' to get the new code.

To use RPCSEC_GSS on either client or server, you must build a kernel
which includes the KGSSAPI option and the crypto device. On the
userland side, you must build at least a new libc, mountd, mount_nfs
and gssd. You must install new versions of /etc/rc.d/gssd and
/etc/rc.d/nfsd and add 'gssd_enable=YES' to /etc/rc.conf.

As long as gssd is running, you should be able to mount an NFS
filesystem from a server that requires RPCSEC_GSS authentication. The
mount itself can happen without any kerberos credentials but all
access to the filesystem will be denied unless the accessing user has
a valid ticket file in the standard place (/tmp/krb5cc_<uid>). There
is currently no support for situations where the ticket file is in a
different place, such as when the user logged in via SSH and has
delegated credentials from that login. This restriction is also
present in Solaris and Linux. In theory, we could improve this in
future, possibly using Brooks Davis' implementation of variant
symlinks.

Supporting RPCSEC_GSS on a server is nearly as simple. You must create
service creds for the server in the form 'nfs/<fqdn>@<REALM>' and
install them in /etc/krb5.keytab. The standard heimdal utility ktutil
makes this fairly easy. After the service creds have been created, you
can add a '-sec=krb5' option to /etc/exports and restart both mountd
and nfsd.

The only other difference an administrator should notice is that nfsd
doesn't fork to create service threads any more. In normal operation,
there will be two nfsd processes, one in userland waiting for TCP
connections and one in the kernel handling requests. The latter
process will create as many kthreads as required - these should be
visible via 'top -H'. The code has some support for varying the number
of service threads according to load but initially at least, nfsd uses
a fixed number of threads according to the value supplied to its '-n'
option.

Sponsored by:	Isilon Systems
MFC after:	1 month

6 files changed, 3218 insertions, 0 deletions

diff --git a/sys/rpc/rpcsec_gss/rpcsec_gss.c b/sys/rpc/rpcsec_gss/rpcsec_gss.c
new file mode 100644
index 0000000..790804d
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/rpcsec_gss.c
@@ -0,0 +1,1064 @@
+/*-
+ * Copyright (c) 2008 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+  auth_gss.c
+
+  RPCSEC_GSS client routines.
+  
+  Copyright (c) 2000 The Regents of the University of Michigan.
+  All rights reserved.
+
+  Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
+  All rights reserved, all wrongs reversed.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name of the University nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  $Id: auth_gss.c,v 1.32 2002/01/15 15:43:00 andros Exp $
+*/
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/hash.h>
+#include <sys/kernel.h>
+#include <sys/kobj.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
+#include <sys/refcount.h>
+#include <sys/sx.h>
+#include <sys/ucred.h>
+
+#include <rpc/rpc.h>
+#include <rpc/rpcsec_gss.h>
+
+#include "rpcsec_gss_int.h"
+
+static void	rpc_gss_nextverf(AUTH*);
+static bool_t	rpc_gss_marshal(AUTH *, uint32_t, XDR *, struct mbuf *);
+static bool_t	rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret);
+static bool_t	rpc_gss_refresh(AUTH *, void *);
+static bool_t	rpc_gss_validate(AUTH *, uint32_t, struct opaque_auth *,
+    struct mbuf **);
+static void	rpc_gss_destroy(AUTH *);
+static void	rpc_gss_destroy_context(AUTH *, bool_t);
+
+static struct auth_ops rpc_gss_ops = {
+	rpc_gss_nextverf,
+	rpc_gss_marshal,
+	rpc_gss_validate,
+	rpc_gss_refresh,
+	rpc_gss_destroy,
+};
+
+enum rpcsec_gss_state {
+	RPCSEC_GSS_START,
+	RPCSEC_GSS_CONTEXT,
+	RPCSEC_GSS_ESTABLISHED,
+	RPCSEC_GSS_DESTROYING
+};
+
+struct rpc_pending_request {
+	uint32_t		pr_xid;		/* XID of rpc */
+	uint32_t		pr_seq;		/* matching GSS seq */
+	LIST_ENTRY(rpc_pending_request) pr_link;
+};
+LIST_HEAD(rpc_pending_request_list, rpc_pending_request);
+
+struct rpc_gss_data {
+	volatile u_int		gd_refs;	/* number of current users */
+	struct mtx		gd_lock;
+	uint32_t		gd_hash;
+	AUTH			*gd_auth;	/* link back to AUTH */
+	struct ucred		*gd_ucred;	/* matching local cred */
+	char			*gd_principal;	/* server principal name */
+	rpc_gss_options_req_t	gd_options;	/* GSS context options */
+	enum rpcsec_gss_state	gd_state;	/* connection state */
+	gss_buffer_desc		gd_verf;	/* save GSS_S_COMPLETE
+						 * NULL RPC verfier to
+						 * process at end of
+						 * context negotiation */
+	CLIENT			*gd_clnt;	/* client handle */
+	gss_OID			gd_mech;	/* mechanism to use */
+	gss_qop_t		gd_qop;		/* quality of protection */
+	gss_ctx_id_t		gd_ctx;		/* context id */
+	struct rpc_gss_cred	gd_cred;	/* client credentials */
+	uint32_t		gd_seq;		/* next sequence number */
+	u_int			gd_win;		/* sequence window */
+	struct rpc_pending_request_list gd_reqs;
+	TAILQ_ENTRY(rpc_gss_data) gd_link;
+	TAILQ_ENTRY(rpc_gss_data) gd_alllink;
+};
+TAILQ_HEAD(rpc_gss_data_list, rpc_gss_data);
+
+#define	AUTH_PRIVATE(auth)	((struct rpc_gss_data *)auth->ah_private)
+
+static struct timeval AUTH_TIMEOUT = { 25, 0 };
+
+#define RPC_GSS_HASH_SIZE	11
+#define RPC_GSS_MAX		256
+static struct rpc_gss_data_list rpc_gss_cache[RPC_GSS_HASH_SIZE];
+static struct rpc_gss_data_list rpc_gss_all;
+static struct sx rpc_gss_lock;
+static int rpc_gss_count;
+
+static AUTH *rpc_gss_seccreate_int(CLIENT *, struct ucred *, const char *,
+    gss_OID, rpc_gss_service_t, u_int, rpc_gss_options_req_t *,
+    rpc_gss_options_ret_t *);
+
+static void
+rpc_gss_hashinit(void *dummy)
+{
+	int i;
+
+	for (i = 0; i < RPC_GSS_HASH_SIZE; i++)
+		TAILQ_INIT(&rpc_gss_cache[i]);
+	TAILQ_INIT(&rpc_gss_all);
+	sx_init(&rpc_gss_lock, "rpc_gss_lock");
+}
+SYSINIT(rpc_gss_hashinit, SI_SUB_KMEM, SI_ORDER_ANY, rpc_gss_hashinit, NULL);
+
+static uint32_t
+rpc_gss_hash(const char *principal, gss_OID mech,
+    struct ucred *cred, rpc_gss_service_t service)
+{
+	uint32_t h;
+
+	h = HASHSTEP(HASHINIT, cred->cr_uid);
+	h = hash32_str(principal, h);
+	h = hash32_buf(mech->elements, mech->length, h);
+	h = HASHSTEP(h, (int) service);
+
+	return (h % RPC_GSS_HASH_SIZE);
+}
+
+/*
+ * Simplified interface to create a security association for the
+ * current thread's * ucred.
+ */
+AUTH *
+rpc_gss_secfind(CLIENT *clnt, struct ucred *cred, const char *principal,
+    gss_OID mech_oid, rpc_gss_service_t service)
+{
+	uint32_t		h, th;
+	AUTH			*auth;
+	struct rpc_gss_data	*gd, *tgd;
+
+	if (rpc_gss_count > RPC_GSS_MAX) {
+		while (rpc_gss_count > RPC_GSS_MAX) {
+			sx_xlock(&rpc_gss_lock);
+			tgd = TAILQ_FIRST(&rpc_gss_all);
+			th = tgd->gd_hash;
+			TAILQ_REMOVE(&rpc_gss_cache[th], tgd, gd_link);
+			TAILQ_REMOVE(&rpc_gss_all, tgd, gd_alllink);
+			rpc_gss_count--;
+			sx_xunlock(&rpc_gss_lock);
+			AUTH_DESTROY(tgd->gd_auth);
+		}
+	}
+
+	/*
+	 * See if we already have an AUTH which matches.
+	 */
+	h = rpc_gss_hash(principal, mech_oid, cred, service);
+
+again:
+	sx_slock(&rpc_gss_lock);
+	TAILQ_FOREACH(gd, &rpc_gss_cache[h], gd_link) {
+		if (gd->gd_ucred->cr_uid == cred->cr_uid
+		    && !strcmp(gd->gd_principal, principal)
+		    && gd->gd_mech == mech_oid
+		    && gd->gd_cred.gc_svc == service) {
+			refcount_acquire(&gd->gd_refs);
+			if (sx_try_upgrade(&rpc_gss_lock)) {
+				/*
+				 * Keep rpc_gss_all LRU sorted.
+				 */
+				TAILQ_REMOVE(&rpc_gss_all, gd, gd_alllink);
+				TAILQ_INSERT_TAIL(&rpc_gss_all, gd,
+				    gd_alllink);
+				sx_xunlock(&rpc_gss_lock);
+			} else {
+				sx_sunlock(&rpc_gss_lock);
+			}
+			return (gd->gd_auth);
+		}
+	}
+	sx_sunlock(&rpc_gss_lock);
+
+	/*
+	 * We missed in the cache - create a new association.
+	 */
+	auth = rpc_gss_seccreate_int(clnt, cred, principal, mech_oid, service,
+	    GSS_C_QOP_DEFAULT, NULL, NULL);
+	if (!auth)
+		return (NULL);
+
+	gd = AUTH_PRIVATE(auth);
+	gd->gd_hash = h;
+	
+	sx_xlock(&rpc_gss_lock);
+	TAILQ_FOREACH(tgd, &rpc_gss_cache[h], gd_link) {
+		if (tgd->gd_ucred->cr_uid == cred->cr_uid
+		    && !strcmp(tgd->gd_principal, principal)
+		    && tgd->gd_mech == mech_oid
+		    && tgd->gd_cred.gc_svc == service) {
+			/*
+			 * We lost a race to create the AUTH that
+			 * matches this cred.
+			 */
+			sx_xunlock(&rpc_gss_lock);
+			AUTH_DESTROY(auth);
+			goto again;
+		}
+	}
+
+	rpc_gss_count++;
+	TAILQ_INSERT_TAIL(&rpc_gss_cache[h], gd, gd_link);
+	TAILQ_INSERT_TAIL(&rpc_gss_all, gd, gd_alllink);
+	refcount_acquire(&gd->gd_refs);	/* one for the cache, one for user */
+	sx_xunlock(&rpc_gss_lock);
+
+	return (auth);
+}
+
+void
+rpc_gss_secpurge(CLIENT *clnt)
+{
+	uint32_t		h;
+	struct rpc_gss_data	*gd, *tgd;
+
+	TAILQ_FOREACH_SAFE(gd, &rpc_gss_all, gd_alllink, tgd) {
+		if (gd->gd_clnt == clnt) {
+			sx_xlock(&rpc_gss_lock);
+			h = gd->gd_hash;
+			TAILQ_REMOVE(&rpc_gss_cache[h], gd, gd_link);
+			TAILQ_REMOVE(&rpc_gss_all, gd, gd_alllink);
+			rpc_gss_count--;
+			sx_xunlock(&rpc_gss_lock);
+			AUTH_DESTROY(gd->gd_auth);
+		}
+	}
+}
+
+AUTH *
+rpc_gss_seccreate(CLIENT *clnt, struct ucred *cred, const char *principal,
+    const char *mechanism, rpc_gss_service_t service, const char *qop,
+    rpc_gss_options_req_t *options_req, rpc_gss_options_ret_t *options_ret)
+{
+	gss_OID			oid;
+	u_int			qop_num;
+
+	/*
+	 * Bail out now if we don't know this mechanism.
+	 */
+	if (!rpc_gss_mech_to_oid(mechanism, &oid))
+		return (NULL);
+
+	if (qop) {
+		if (!rpc_gss_qop_to_num(qop, mechanism, &qop_num))
+			return (NULL);
+	} else {
+		qop_num = GSS_C_QOP_DEFAULT;
+	}
+
+	return (rpc_gss_seccreate_int(clnt, cred, principal, oid, service,
+		qop_num, options_req, options_ret));
+}
+
+static AUTH *
+rpc_gss_seccreate_int(CLIENT *clnt, struct ucred *cred, const char *principal,
+    gss_OID mech_oid, rpc_gss_service_t service, u_int qop_num,
+    rpc_gss_options_req_t *options_req, rpc_gss_options_ret_t *options_ret)
+{
+	AUTH			*auth;
+	rpc_gss_options_ret_t	options;
+	struct rpc_gss_data	*gd;
+
+	/*
+	 * If the caller doesn't want the options, point at local
+	 * storage to simplify the code below.
+	 */
+	if (!options_ret)
+		options_ret = &options;
+
+	/*
+	 * Default service is integrity.
+	 */
+	if (service == rpc_gss_svc_default)
+		service = rpc_gss_svc_integrity;
+
+	memset(options_ret, 0, sizeof(*options_ret));
+
+	rpc_gss_log_debug("in rpc_gss_seccreate()");
+	
+	memset(&rpc_createerr, 0, sizeof(rpc_createerr));
+	
+	auth = mem_alloc(sizeof(*auth));
+	if (auth == NULL) {
+		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+		rpc_createerr.cf_error.re_errno = ENOMEM;
+		return (NULL);
+	}
+	gd = mem_alloc(sizeof(*gd));
+	if (gd == NULL) {
+		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+		rpc_createerr.cf_error.re_errno = ENOMEM;
+		mem_free(auth, sizeof(*auth));
+		return (NULL);
+	}
+
+	auth->ah_ops = &rpc_gss_ops;
+	auth->ah_private = (caddr_t) gd;
+	auth->ah_cred.oa_flavor = RPCSEC_GSS;
+	
+	refcount_init(&gd->gd_refs, 1);
+	mtx_init(&gd->gd_lock, "gd->gd_lock", NULL, MTX_DEF);
+	gd->gd_auth = auth;
+	gd->gd_ucred = crdup(cred);
+	gd->gd_principal = strdup(principal, M_RPC);
+
+
+	if (options_req) {
+		gd->gd_options = *options_req;
+	} else {
+		gd->gd_options.req_flags = GSS_C_MUTUAL_FLAG;
+		gd->gd_options.time_req = 0;
+		gd->gd_options.my_cred = GSS_C_NO_CREDENTIAL;
+		gd->gd_options.input_channel_bindings = NULL;
+	}
+	CLNT_ACQUIRE(clnt);
+	gd->gd_clnt = clnt;
+	gd->gd_ctx = GSS_C_NO_CONTEXT;
+	gd->gd_mech = mech_oid;
+	gd->gd_qop = qop_num;
+
+	gd->gd_cred.gc_version = RPCSEC_GSS_VERSION;
+	gd->gd_cred.gc_proc = RPCSEC_GSS_INIT;
+	gd->gd_cred.gc_seq = 0;
+	gd->gd_cred.gc_svc = service;
+	LIST_INIT(&gd->gd_reqs);
+	
+	if (!rpc_gss_init(auth, options_ret)) {
+		goto bad;
+	}
+	
+	return (auth);
+
+ bad:
+	AUTH_DESTROY(auth);
+	return (NULL);
+}
+
+bool_t
+rpc_gss_set_defaults(AUTH *auth, rpc_gss_service_t service, const char *qop)
+{
+	struct rpc_gss_data	*gd;
+	u_int			qop_num;
+	const char		*mechanism;
+
+	gd = AUTH_PRIVATE(auth);
+	if (!rpc_gss_oid_to_mech(gd->gd_mech, &mechanism)) {
+		return (FALSE);
+	}
+
+	if (qop) {
+		if (!rpc_gss_qop_to_num(qop, mechanism, &qop_num)) {
+			return (FALSE);
+		}
+	} else {
+		qop_num = GSS_C_QOP_DEFAULT;
+	}
+
+	gd->gd_cred.gc_svc = service;
+	gd->gd_qop = qop_num;
+	return (TRUE);
+}
+
+static void
+rpc_gss_purge_xid(struct rpc_gss_data *gd, uint32_t xid)
+{
+	struct rpc_pending_request *pr, *npr;
+	struct rpc_pending_request_list reqs;
+
+	LIST_INIT(&reqs);
+	mtx_lock(&gd->gd_lock);
+	LIST_FOREACH_SAFE(pr, &gd->gd_reqs, pr_link, npr) {
+		if (pr->pr_xid == xid) {
+			LIST_REMOVE(pr, pr_link);
+			LIST_INSERT_HEAD(&reqs, pr, pr_link);
+		}
+	}
+
+	mtx_unlock(&gd->gd_lock);
+
+	LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr) {
+		mem_free(pr, sizeof(*pr));
+	}
+}
+
+static uint32_t
+rpc_gss_alloc_seq(struct rpc_gss_data *gd)
+{
+	uint32_t seq;
+
+	mtx_lock(&gd->gd_lock);
+	seq = gd->gd_seq;
+	gd->gd_seq++;
+	mtx_unlock(&gd->gd_lock);
+
+	return (seq);
+}
+
+static void
+rpc_gss_nextverf(__unused AUTH *auth)
+{
+
+	/* not used */
+}
+
+static bool_t
+rpc_gss_marshal(AUTH *auth, uint32_t xid, XDR *xdrs, struct mbuf *args)
+{
+	struct rpc_gss_data	*gd;
+	struct rpc_pending_request *pr;
+	uint32_t		 seq;
+	XDR			 tmpxdrs;
+	struct rpc_gss_cred	 gsscred;
+	char			 credbuf[MAX_AUTH_BYTES];
+	struct opaque_auth	 creds, verf;
+	gss_buffer_desc		 rpcbuf, checksum;
+	OM_uint32		 maj_stat, min_stat;
+	bool_t			 xdr_stat;
+
+	rpc_gss_log_debug("in rpc_gss_marshal()");
+
+	gd = AUTH_PRIVATE(auth);
+	
+	gsscred = gd->gd_cred;
+	seq = rpc_gss_alloc_seq(gd);
+	gsscred.gc_seq = seq;
+
+	xdrmem_create(&tmpxdrs, credbuf, sizeof(credbuf), XDR_ENCODE);
+	if (!xdr_rpc_gss_cred(&tmpxdrs, &gsscred)) {
+		XDR_DESTROY(&tmpxdrs);
+		_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
+		return (FALSE);
+	}
+	creds.oa_flavor = RPCSEC_GSS;
+	creds.oa_base = credbuf;
+	creds.oa_length = XDR_GETPOS(&tmpxdrs);
+	XDR_DESTROY(&tmpxdrs);
+
+	xdr_opaque_auth(xdrs, &creds);
+
+	if (gd->gd_cred.gc_proc == RPCSEC_GSS_INIT ||
+	    gd->gd_cred.gc_proc == RPCSEC_GSS_CONTINUE_INIT) {
+		if (!xdr_opaque_auth(xdrs, &_null_auth)) {
+			_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
+			return (FALSE);
+		}
+		xdrmbuf_append(xdrs, args);
+		return (TRUE);
+	} else {
+		/*
+		 * Keep track of this XID + seq pair so that we can do
+		 * the matching gss_verify_mic in AUTH_VALIDATE.
+		 */
+		pr = mem_alloc(sizeof(struct rpc_pending_request));
+		mtx_lock(&gd->gd_lock);
+		pr->pr_xid = xid;
+		pr->pr_seq = seq;
+		LIST_INSERT_HEAD(&gd->gd_reqs, pr, pr_link);
+		mtx_unlock(&gd->gd_lock);
+
+		/*
+		 * Checksum serialized RPC header, up to and including
+		 * credential. For the in-kernel environment, we
+		 * assume that our XDR stream is on a contiguous
+		 * memory buffer (e.g. an mbuf).
+		 */
+		rpcbuf.length = XDR_GETPOS(xdrs);
+		XDR_SETPOS(xdrs, 0);
+		rpcbuf.value = XDR_INLINE(xdrs, rpcbuf.length);
+
+		maj_stat = gss_get_mic(&min_stat, gd->gd_ctx, gd->gd_qop,
+		    &rpcbuf, &checksum);
+
+		if (maj_stat != GSS_S_COMPLETE) {
+			rpc_gss_log_status("gss_get_mic", gd->gd_mech,
+			    maj_stat, min_stat);
+			if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
+				rpc_gss_destroy_context(auth, TRUE);
+			}
+			_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
+			return (FALSE);
+		}
+
+		verf.oa_flavor = RPCSEC_GSS;
+		verf.oa_base = checksum.value;
+		verf.oa_length = checksum.length;
+
+		xdr_stat = xdr_opaque_auth(xdrs, &verf);
+		gss_release_buffer(&min_stat, &checksum);
+		if (!xdr_stat) {
+			_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
+			return (FALSE);
+		}
+		if (gd->gd_state != RPCSEC_GSS_ESTABLISHED ||
+		    gd->gd_cred.gc_svc == rpc_gss_svc_none) {
+			xdrmbuf_append(xdrs, args);
+			return (TRUE);
+		} else {
+			if (!xdr_rpc_gss_wrap_data(&args,
+				gd->gd_ctx, gd->gd_qop, gd->gd_cred.gc_svc,
+				seq))
+				return (FALSE);
+			xdrmbuf_append(xdrs, args);
+			return (TRUE);
+		}
+	}
+
+	return (TRUE);
+}
+
+static bool_t
+rpc_gss_validate(AUTH *auth, uint32_t xid, struct opaque_auth *verf,
+    struct mbuf **resultsp)
+{
+	struct rpc_gss_data	*gd;
+	struct rpc_pending_request *pr, *npr;
+	struct rpc_pending_request_list reqs;
+	gss_qop_t		qop_state;
+	uint32_t		num, seq;
+	gss_buffer_desc		signbuf, checksum;
+	OM_uint32		maj_stat, min_stat;
+
+	rpc_gss_log_debug("in rpc_gss_validate()");
+	
+	gd = AUTH_PRIVATE(auth);
+
+	/*
+	 * The client will call us with a NULL verf when it gives up
+	 * on an XID.
+	 */
+	if (!verf) {
+		rpc_gss_purge_xid(gd, xid);
+		return (TRUE);
+	}
+
+	if (gd->gd_state == RPCSEC_GSS_CONTEXT) {
+		/*
+		 * Save the on the wire verifier to validate last INIT
+		 * phase packet after decode if the major status is
+		 * GSS_S_COMPLETE.
+		 */
+		if (gd->gd_verf.value)
+			xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+			    (char *) &gd->gd_verf);
+		gd->gd_verf.value = mem_alloc(verf->oa_length);
+		if (gd->gd_verf.value == NULL) {
+			printf("gss_validate: out of memory\n");
+			_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
+			m_freem(*resultsp);
+			*resultsp = NULL;
+			return (FALSE);
+		}
+		memcpy(gd->gd_verf.value, verf->oa_base, verf->oa_length);
+		gd->gd_verf.length = verf->oa_length;
+
+		return (TRUE);
+	}
+
+	/*
+	 * We need to check the verifier against all the requests
+	 * we've send for this XID - for unreliable protocols, we
+	 * retransmit with the same XID but different sequence
+	 * number. We temporarily take this set of requests out of the
+	 * list so that we can work through the list without having to
+	 * hold the lock.
+	 */
+	mtx_lock(&gd->gd_lock);
+	LIST_INIT(&reqs);
+	LIST_FOREACH_SAFE(pr, &gd->gd_reqs, pr_link, npr) {
+		if (pr->pr_xid == xid) {
+			LIST_REMOVE(pr, pr_link);
+			LIST_INSERT_HEAD(&reqs, pr, pr_link);
+		}
+	}
+	mtx_unlock(&gd->gd_lock);
+	LIST_FOREACH(pr, &reqs, pr_link) {
+		if (pr->pr_xid == xid) {
+			seq = pr->pr_seq;
+			num = htonl(seq);
+			signbuf.value = &num;
+			signbuf.length = sizeof(num);
+	
+			checksum.value = verf->oa_base;
+			checksum.length = verf->oa_length;
+	
+			maj_stat = gss_verify_mic(&min_stat, gd->gd_ctx,
+			    &signbuf, &checksum, &qop_state);
+			if (maj_stat != GSS_S_COMPLETE
+			    || qop_state != gd->gd_qop) {
+				continue;
+			}
+			if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
+				rpc_gss_destroy_context(auth, TRUE);
+				break;
+			}
+			//rpc_gss_purge_reqs(gd, seq);
+			LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr)
+				mem_free(pr, sizeof(*pr));
+
+			if (gd->gd_cred.gc_svc == rpc_gss_svc_none) {
+				return (TRUE);
+			} else {
+				if (!xdr_rpc_gss_unwrap_data(resultsp,
+					gd->gd_ctx, gd->gd_qop,
+					gd->gd_cred.gc_svc, seq)) {
+					return (FALSE);
+				}
+			}
+			return (TRUE);
+		}
+	}
+
+	/*
+	 * We didn't match - put back any entries for this XID so that
+	 * a future call to validate can retry.
+	 */
+	mtx_lock(&gd->gd_lock);
+	LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr) {
+		LIST_REMOVE(pr, pr_link);
+		LIST_INSERT_HEAD(&gd->gd_reqs, pr, pr_link);
+	}
+	mtx_unlock(&gd->gd_lock);
+
+	/*
+	 * Nothing matches - give up.
+	 */
+	_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
+	m_freem(*resultsp);
+	*resultsp = NULL;
+	return (FALSE);
+}
+
+static bool_t
+rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret)
+{
+	struct thread		*td = curthread;
+	struct ucred		*crsave;
+	struct rpc_gss_data	*gd;
+	struct rpc_gss_init_res	 gr;
+	gss_buffer_desc		principal_desc;
+	gss_buffer_desc		*recv_tokenp, recv_token, send_token;
+	gss_name_t		name;
+	OM_uint32		 maj_stat, min_stat, call_stat;
+	const char		*mech;
+	struct rpc_callextra	 ext;
+
+	rpc_gss_log_debug("in rpc_gss_refresh()");
+	
+	gd = AUTH_PRIVATE(auth);
+	
+	mtx_lock(&gd->gd_lock);
+	/*
+	 * If the context isn't in START state, someone else is
+	 * refreshing - we wait till they are done. If they fail, they
+	 * will put the state back to START and we can try (most
+	 * likely to also fail).
+	 */
+	while (gd->gd_state != RPCSEC_GSS_START
+	    && gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
+		msleep(gd, &gd->gd_lock, 0, "gssstate", 0);
+	}
+	if (gd->gd_state == RPCSEC_GSS_ESTABLISHED) {
+		mtx_unlock(&gd->gd_lock);
+		return (TRUE);
+	}
+	gd->gd_state = RPCSEC_GSS_CONTEXT;
+	mtx_unlock(&gd->gd_lock);
+
+	principal_desc.value = (void *)gd->gd_principal;
+	principal_desc.length = strlen(gd->gd_principal);
+	maj_stat = gss_import_name(&min_stat, &principal_desc,
+	    GSS_C_NT_HOSTBASED_SERVICE, &name);
+	if (maj_stat != GSS_S_COMPLETE) {
+		options_ret->major_status = maj_stat;
+		options_ret->minor_status = min_stat;
+		goto out;
+	}
+
+	/* GSS context establishment loop. */
+	gd->gd_cred.gc_proc = RPCSEC_GSS_INIT;
+	gd->gd_cred.gc_seq = 0;
+
+	memset(&recv_token, 0, sizeof(recv_token));
+	memset(&gr, 0, sizeof(gr));
+	memset(options_ret, 0, sizeof(*options_ret));
+	options_ret->major_status = GSS_S_FAILURE;
+	recv_tokenp = GSS_C_NO_BUFFER;
+	
+	for (;;) {
+		crsave = td->td_ucred;
+		td->td_ucred = gd->gd_ucred;
+		maj_stat = gss_init_sec_context(&min_stat,
+		    gd->gd_options.my_cred,
+		    &gd->gd_ctx,
+		    name,
+		    gd->gd_mech,
+		    gd->gd_options.req_flags,
+		    gd->gd_options.time_req,
+		    gd->gd_options.input_channel_bindings,
+		    recv_tokenp,
+		    &gd->gd_mech,	/* used mech */
+		    &send_token,
+		    &options_ret->ret_flags,
+		    &options_ret->time_req);
+		td->td_ucred = crsave;
+		
+		/*
+		 * Free the token which we got from the server (if
+		 * any).  Remember that this was allocated by XDR, not
+		 * GSS-API.
+		 */
+		if (recv_tokenp != GSS_C_NO_BUFFER) {
+			xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+			    (char *) &recv_token);
+			recv_tokenp = GSS_C_NO_BUFFER;
+		}
+		if (gd->gd_mech && rpc_gss_oid_to_mech(gd->gd_mech, &mech)) {
+			strlcpy(options_ret->actual_mechanism,
+			    mech,
+			    sizeof(options_ret->actual_mechanism));
+		}
+		if (maj_stat != GSS_S_COMPLETE &&
+		    maj_stat != GSS_S_CONTINUE_NEEDED) {
+			rpc_gss_log_status("gss_init_sec_context", gd->gd_mech,
+			    maj_stat, min_stat);
+			options_ret->major_status = maj_stat;
+			options_ret->minor_status = min_stat;
+			break;
+		}
+		if (send_token.length != 0) {
+			memset(&gr, 0, sizeof(gr));
+			
+			bzero(&ext, sizeof(ext));
+			ext.rc_auth = auth;
+			call_stat = CLNT_CALL_EXT(gd->gd_clnt, &ext, NULLPROC,
+			    (xdrproc_t)xdr_gss_buffer_desc,
+			    &send_token,
+			    (xdrproc_t)xdr_rpc_gss_init_res,
+			    (caddr_t)&gr, AUTH_TIMEOUT);
+			
+			gss_release_buffer(&min_stat, &send_token);
+			
+			if (call_stat != RPC_SUCCESS)
+				break;
+
+			if (gr.gr_major != GSS_S_COMPLETE &&
+			    gr.gr_major != GSS_S_CONTINUE_NEEDED) {
+				rpc_gss_log_status("server reply", gd->gd_mech,
+				    gr.gr_major, gr.gr_minor);
+				options_ret->major_status = gr.gr_major;
+				options_ret->minor_status = gr.gr_minor;
+				break;
+			}
+			
+			/*
+			 * Save the server's gr_handle value, freeing
+			 * what we have already (remember that this
+			 * was allocated by XDR, not GSS-API).
+			 */
+			if (gr.gr_handle.length != 0) {
+				xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+				    (char *) &gd->gd_cred.gc_handle);
+				gd->gd_cred.gc_handle = gr.gr_handle;
+			}
+
+			/*
+			 * Save the server's token as well.
+			 */
+			if (gr.gr_token.length != 0) {
+				recv_token = gr.gr_token;
+				recv_tokenp = &recv_token;
+			}
+
+			/*
+			 * Since we have copied out all the bits of gr
+			 * which XDR allocated for us, we don't need
+			 * to free it.
+			 */
+			gd->gd_cred.gc_proc = RPCSEC_GSS_CONTINUE_INIT;
+		}
+
+		if (maj_stat == GSS_S_COMPLETE) {
+			gss_buffer_desc   bufin;
+			u_int seq, qop_state = 0;
+
+			/* 
+			 * gss header verifier,
+			 * usually checked in gss_validate
+			 */
+			seq = htonl(gr.gr_win);
+			bufin.value = (unsigned char *)&seq;
+			bufin.length = sizeof(seq);
+
+			maj_stat = gss_verify_mic(&min_stat, gd->gd_ctx,
+			    &bufin, &gd->gd_verf, &qop_state);
+
+			if (maj_stat != GSS_S_COMPLETE ||
+			    qop_state != gd->gd_qop) {
+				rpc_gss_log_status("gss_verify_mic", gd->gd_mech,
+				    maj_stat, min_stat);
+				if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
+					rpc_gss_destroy_context(auth, TRUE);
+				}
+				_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR,
+				    EPERM);
+				options_ret->major_status = maj_stat;
+				options_ret->minor_status = min_stat;
+				break;
+			}
+
+			options_ret->major_status = GSS_S_COMPLETE;
+			options_ret->minor_status = 0;
+			options_ret->rpcsec_version = gd->gd_cred.gc_version;
+			options_ret->gss_context = gd->gd_ctx;
+
+			gd->gd_cred.gc_proc = RPCSEC_GSS_DATA;
+			gd->gd_seq = 1;
+			gd->gd_win = gr.gr_win;
+			break;
+		}
+	}
+
+	gss_release_name(&min_stat, &name);
+	xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+	    (char *) &gd->gd_verf);
+
+out:
+	/* End context negotiation loop. */
+	if (gd->gd_cred.gc_proc != RPCSEC_GSS_DATA) {
+		rpc_createerr.cf_stat = RPC_AUTHERROR;
+		_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
+		if (gd->gd_ctx) {
+			gss_delete_sec_context(&min_stat, &gd->gd_ctx,
+				GSS_C_NO_BUFFER);
+		}
+		mtx_lock(&gd->gd_lock);
+		gd->gd_state = RPCSEC_GSS_START;
+		wakeup(gd);
+		mtx_unlock(&gd->gd_lock);
+		return (FALSE);
+	}
+	
+	mtx_lock(&gd->gd_lock);
+	gd->gd_state = RPCSEC_GSS_ESTABLISHED;
+	wakeup(gd);
+	mtx_unlock(&gd->gd_lock);
+
+	return (TRUE);
+}
+
+static bool_t
+rpc_gss_refresh(AUTH *auth, void *msg)
+{
+	struct rpc_msg *reply = (struct rpc_msg *) msg;
+	rpc_gss_options_ret_t options;
+
+	/*
+	 * If the error was RPCSEC_GSS_CREDPROBLEM of
+	 * RPCSEC_GSS_CTXPROBLEM we start again from scratch. All
+	 * other errors are fatal.
+	 */
+	if (reply->rm_reply.rp_stat == MSG_DENIED
+	    && reply->rm_reply.rp_rjct.rj_stat == AUTH_ERROR
+	    && (reply->rm_reply.rp_rjct.rj_why == RPCSEC_GSS_CREDPROBLEM
+		|| reply->rm_reply.rp_rjct.rj_why == RPCSEC_GSS_CTXPROBLEM)) {
+		rpc_gss_destroy_context(auth, FALSE);
+		memset(&options, 0, sizeof(options));
+		return (rpc_gss_init(auth, &options));
+	}
+
+	return (FALSE);
+}
+
+static void
+rpc_gss_destroy_context(AUTH *auth, bool_t send_destroy)
+{
+	struct rpc_gss_data	*gd;
+	struct rpc_pending_request *pr;
+	OM_uint32		 min_stat;
+	struct rpc_callextra	 ext;
+
+	rpc_gss_log_debug("in rpc_gss_destroy_context()");
+	
+	gd = AUTH_PRIVATE(auth);
+	
+	mtx_lock(&gd->gd_lock);
+	/*
+	 * If the context isn't in ESTABISHED state, someone else is
+	 * destroying/refreshing - we wait till they are done.
+	 */
+	if (gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
+		while (gd->gd_state != RPCSEC_GSS_START
+		    && gd->gd_state != RPCSEC_GSS_ESTABLISHED)
+			msleep(gd, &gd->gd_lock, 0, "gssstate", 0);
+		mtx_unlock(&gd->gd_lock);
+		return;
+	}
+	gd->gd_state = RPCSEC_GSS_DESTROYING;
+	mtx_unlock(&gd->gd_lock);
+
+	if (send_destroy) {
+		gd->gd_cred.gc_proc = RPCSEC_GSS_DESTROY;
+		bzero(&ext, sizeof(ext));
+		ext.rc_auth = auth;
+		CLNT_CALL_EXT(gd->gd_clnt, &ext, NULLPROC,
+		    (xdrproc_t)xdr_void, NULL,
+		    (xdrproc_t)xdr_void, NULL, AUTH_TIMEOUT);
+	}
+
+	while ((pr = LIST_FIRST(&gd->gd_reqs)) != NULL) {
+		LIST_REMOVE(pr, pr_link);
+		mem_free(pr, sizeof(*pr));
+	}
+
+	/*
+	 * Free the context token. Remember that this was
+	 * allocated by XDR, not GSS-API.
+	 */
+	xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+	    (char *) &gd->gd_cred.gc_handle);
+	gd->gd_cred.gc_handle.length = 0;
+
+	if (gd->gd_ctx != GSS_C_NO_CONTEXT)
+		gss_delete_sec_context(&min_stat, &gd->gd_ctx, NULL);
+
+	mtx_lock(&gd->gd_lock);
+	gd->gd_state = RPCSEC_GSS_START;
+	wakeup(gd);
+	mtx_unlock(&gd->gd_lock);
+}
+
+static void
+rpc_gss_destroy(AUTH *auth)
+{
+	struct rpc_gss_data	*gd;
+	
+	rpc_gss_log_debug("in rpc_gss_destroy()");
+	
+	gd = AUTH_PRIVATE(auth);
+	
+	if (!refcount_release(&gd->gd_refs))
+		return;
+
+	rpc_gss_destroy_context(auth, TRUE);
+	
+	CLNT_RELEASE(gd->gd_clnt);
+	crfree(gd->gd_ucred);
+	free(gd->gd_principal, M_RPC);
+	if (gd->gd_verf.value)
+		xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+		    (char *) &gd->gd_verf);
+	mtx_destroy(&gd->gd_lock);
+
+	mem_free(gd, sizeof(*gd));
+	mem_free(auth, sizeof(*auth));
+}
+
+int
+rpc_gss_max_data_length(AUTH *auth, int max_tp_unit_len)
+{
+	struct rpc_gss_data	*gd;
+	int			want_conf;
+	OM_uint32		max;
+	OM_uint32		maj_stat, min_stat;
+	int			result;
+
+	gd = AUTH_PRIVATE(auth);
+
+	switch (gd->gd_cred.gc_svc) {
+	case rpc_gss_svc_none:
+		return (max_tp_unit_len);
+		break;
+
+	case rpc_gss_svc_default:
+	case rpc_gss_svc_integrity:
+		want_conf = FALSE;
+		break;
+
+	case rpc_gss_svc_privacy:
+		want_conf = TRUE;
+		break;
+
+	default:
+		return (0);
+	}
+
+	maj_stat = gss_wrap_size_limit(&min_stat, gd->gd_ctx, want_conf,
+	    gd->gd_qop, max_tp_unit_len, &max);
+
+	if (maj_stat == GSS_S_COMPLETE) {
+		result = (int) max;
+		if (result < 0)
+			result = 0;
+		return (result);
+	} else {
+		rpc_gss_log_status("gss_wrap_size_limit", gd->gd_mech,
+		    maj_stat, min_stat);
+		return (0);
+	}
+}
diff --git a/sys/rpc/rpcsec_gss/rpcsec_gss_conf.c b/sys/rpc/rpcsec_gss/rpcsec_gss_conf.c
new file mode 100644
index 0000000..b5e99d4
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/rpcsec_gss_conf.c
@@ -0,0 +1,163 @@
+/*-
+ * Copyright (c) 2008 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kobj.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mutex.h>
+
+#include <rpc/rpc.h>
+#include <rpc/rpcsec_gss.h>
+
+#include "rpcsec_gss_int.h"
+
+bool_t
+rpc_gss_mech_to_oid(const char *mech, gss_OID *oid_ret)
+{
+	gss_OID oid = kgss_find_mech_by_name(mech);
+
+	if (oid) {
+		*oid_ret = oid;
+		return (TRUE);
+	}
+	_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
+	return (FALSE);
+}
+
+bool_t
+rpc_gss_oid_to_mech(gss_OID oid, const char **mech_ret)
+{
+	const char *name = kgss_find_mech_by_oid(oid);
+
+	if (name) {
+		*mech_ret = name;
+		return (TRUE);
+	}
+	_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
+	return (FALSE);
+}
+
+bool_t
+rpc_gss_qop_to_num(const char *qop, const char *mech, u_int *num_ret)
+{
+
+	if (!strcmp(qop, "default")) {
+		*num_ret = GSS_C_QOP_DEFAULT;
+		return (TRUE);
+	}
+	_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
+	return (FALSE);
+}
+
+const char *
+_rpc_gss_num_to_qop(const char *mech, u_int num)
+{
+
+	if (num == GSS_C_QOP_DEFAULT)
+		return "default";
+
+	return (NULL);
+}
+
+const char **
+rpc_gss_get_mechanisms(void)
+{
+	static const char **mech_names = NULL;
+	struct kgss_mech *km;
+	int count;
+
+	if (mech_names)
+		return (mech_names);
+
+	count = 0;
+	LIST_FOREACH(km, &kgss_mechs, km_link) {
+		count++;
+	}
+	count++;
+
+	mech_names = malloc(count * sizeof(const char *), M_RPC, M_WAITOK);
+	count = 0;
+	LIST_FOREACH(km, &kgss_mechs, km_link) {
+		mech_names[count++] = km->km_mech_name;
+	}
+	mech_names[count++] = NULL;
+	
+	return (mech_names);
+}
+
+#if 0
+const char **
+rpc_gss_get_mech_info(const char *mech, rpc_gss_service_t *service)
+{
+	struct mech_info *info;
+
+	_rpc_gss_load_mech();
+	_rpc_gss_load_qop();
+	SLIST_FOREACH(info, &mechs, link) {
+		if (!strcmp(mech, info->name)) {
+			/*
+			 * I'm not sure what to do with service
+			 * here. The Solaris manpages are not clear on
+			 * the subject and the OpenSolaris code just
+			 * sets it to rpc_gss_svc_privacy
+			 * unconditionally with a comment noting that
+			 * it is bogus.
+			 */
+			*service = rpc_gss_svc_privacy;
+			return info->qops;
+		}
+	}
+
+	_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
+	return (NULL);
+}
+#endif
+
+bool_t
+rpc_gss_get_versions(u_int *vers_hi, u_int *vers_lo)
+{
+
+	*vers_hi = 1;
+	*vers_lo = 1;
+	return (TRUE);
+}
+
+bool_t
+rpc_gss_is_installed(const char *mech)
+{
+	gss_OID oid = kgss_find_mech_by_name(mech);
+
+	if (oid)
+		return (TRUE);
+	else
+		return (FALSE);
+}
+
diff --git a/sys/rpc/rpcsec_gss/rpcsec_gss_int.h b/sys/rpc/rpcsec_gss/rpcsec_gss_int.h
new file mode 100644
index 0000000..4f38828
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/rpcsec_gss_int.h
@@ -0,0 +1,94 @@
+/*
+  rpcsec_gss.h
+  
+  Copyright (c) 2000 The Regents of the University of Michigan.
+  All rights reserved.
+  
+  Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
+  All rights reserved, all wrongs reversed.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name of the University nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  $Id: auth_gss.h,v 1.12 2001/04/30 19:44:47 andros Exp $
+*/
+/* $FreeBSD$ */
+
+#ifndef _RPCSEC_GSS_INT_H
+#define _RPCSEC_GSS_INT_H
+
+#include <kgssapi/gssapi_impl.h>
+
+/* RPCSEC_GSS control procedures. */
+typedef enum {
+	RPCSEC_GSS_DATA = 0,
+	RPCSEC_GSS_INIT = 1,
+	RPCSEC_GSS_CONTINUE_INIT = 2,
+	RPCSEC_GSS_DESTROY = 3
+} rpc_gss_proc_t;
+
+#define RPCSEC_GSS_VERSION	1
+
+/* Credentials. */
+struct rpc_gss_cred {
+	u_int		gc_version;	/* version */
+	rpc_gss_proc_t	gc_proc;	/* control procedure */
+	u_int		gc_seq;		/* sequence number */
+	rpc_gss_service_t gc_svc;	/* service */
+	gss_buffer_desc	gc_handle;	/* handle to server-side context */
+};
+
+/* Context creation response. */
+struct rpc_gss_init_res {
+	gss_buffer_desc	gr_handle;	/* handle to server-side context */
+	u_int		gr_major;	/* major status */
+	u_int		gr_minor;	/* minor status */
+	u_int		gr_win;		/* sequence window */
+	gss_buffer_desc	gr_token;	/* token */
+};
+
+/* Maximum sequence number value. */
+#define MAXSEQ		0x80000000
+
+/* Prototypes. */
+__BEGIN_DECLS
+
+bool_t	xdr_rpc_gss_cred(XDR *xdrs, struct rpc_gss_cred *p);
+bool_t	xdr_rpc_gss_init_res(XDR *xdrs, struct rpc_gss_init_res *p);
+bool_t xdr_rpc_gss_wrap_data(struct mbuf **argsp,
+    gss_ctx_id_t ctx, gss_qop_t qop, rpc_gss_service_t svc,
+    u_int seq);
+bool_t xdr_rpc_gss_unwrap_data(struct mbuf **resultsp,
+    gss_ctx_id_t ctx, gss_qop_t qop, rpc_gss_service_t svc, u_int seq);
+const char *_rpc_gss_num_to_qop(const char *mech, u_int num);
+void	_rpc_gss_set_error(int rpc_gss_error, int system_error);
+
+void	rpc_gss_log_debug(const char *fmt, ...);
+void	rpc_gss_log_status(const char *m, gss_OID mech, OM_uint32 major,
+    OM_uint32 minor);
+
+__END_DECLS
+
+#endif /* !_RPCSEC_GSS_INT_H */
diff --git a/sys/rpc/rpcsec_gss/rpcsec_gss_misc.c b/sys/rpc/rpcsec_gss/rpcsec_gss_misc.c
new file mode 100644
index 0000000..5c8bf91
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/rpcsec_gss_misc.c
@@ -0,0 +1,53 @@
+/*-
+ * Copyright (c) 2008 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/kobj.h>
+#include <sys/malloc.h>
+#include <rpc/rpc.h>
+#include <rpc/rpcsec_gss.h>
+
+#include "rpcsec_gss_int.h"
+
+static rpc_gss_error_t _rpc_gss_error;
+
+void
+_rpc_gss_set_error(int rpc_gss_error, int system_error)
+{
+
+	_rpc_gss_error.rpc_gss_error = rpc_gss_error;
+	_rpc_gss_error.system_error = system_error;
+}
+
+void
+rpc_gss_get_error(rpc_gss_error_t *error)
+{
+
+	*error = _rpc_gss_error;
+}
diff --git a/sys/rpc/rpcsec_gss/rpcsec_gss_prot.c b/sys/rpc/rpcsec_gss/rpcsec_gss_prot.c
new file mode 100644
index 0000000..0654a6e
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/rpcsec_gss_prot.c
@@ -0,0 +1,359 @@
+/*
+  rpcsec_gss_prot.c
+  
+  Copyright (c) 2000 The Regents of the University of Michigan.
+  All rights reserved.
+  
+  Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
+  All rights reserved, all wrongs reversed.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name of the University nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  $Id: authgss_prot.c,v 1.18 2000/09/01 04:14:03 dugsong Exp $
+*/
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kobj.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mutex.h>
+
+#include <rpc/rpc.h>
+#include <rpc/rpcsec_gss.h>
+
+#include "rpcsec_gss_int.h"
+
+#define MAX_GSS_SIZE	10240	/* XXX */
+
+#if 0				/* use the one from kgssapi */
+bool_t
+xdr_gss_buffer_desc(XDR *xdrs, gss_buffer_desc *p)
+{
+	char *val;
+	u_int len;
+	bool_t ret;
+
+	val = p->value;
+	len = p->length;
+	ret = xdr_bytes(xdrs, &val, &len, MAX_GSS_SIZE);
+	p->value = val;
+	p->length = len;
+
+	return (ret);
+}
+#endif
+
+bool_t
+xdr_rpc_gss_cred(XDR *xdrs, struct rpc_gss_cred *p)
+{
+	enum_t proc, svc;
+	bool_t ret;
+
+	proc = p->gc_proc;
+	svc = p->gc_svc;
+	ret = (xdr_u_int(xdrs, &p->gc_version) &&
+	    xdr_enum(xdrs, &proc) &&
+	    xdr_u_int(xdrs, &p->gc_seq) &&
+	    xdr_enum(xdrs, &svc) &&
+	    xdr_gss_buffer_desc(xdrs, &p->gc_handle));
+	p->gc_proc = proc;
+	p->gc_svc = svc;
+
+	return (ret);
+}
+
+bool_t
+xdr_rpc_gss_init_res(XDR *xdrs, struct rpc_gss_init_res *p)
+{
+
+	return (xdr_gss_buffer_desc(xdrs, &p->gr_handle) &&
+	    xdr_u_int(xdrs, &p->gr_major) &&
+	    xdr_u_int(xdrs, &p->gr_minor) &&
+	    xdr_u_int(xdrs, &p->gr_win) &&
+	    xdr_gss_buffer_desc(xdrs, &p->gr_token));
+}
+
+static void
+put_uint32(struct mbuf **mp, uint32_t v)
+{
+	struct mbuf *m = *mp;
+	uint32_t n;
+
+	M_PREPEND(m, sizeof(uint32_t), M_WAIT);
+	n = htonl(v);
+	bcopy(&n, mtod(m, uint32_t *), sizeof(uint32_t));
+	*mp = m;
+}
+
+bool_t
+xdr_rpc_gss_wrap_data(struct mbuf **argsp,
+		      gss_ctx_id_t ctx, gss_qop_t qop,
+		      rpc_gss_service_t svc, u_int seq)
+{
+	struct mbuf	*args, *mic;
+	OM_uint32	maj_stat, min_stat;
+	int		conf_state;
+	u_int		len;
+	static char	zpad[4];
+
+	args = *argsp;
+
+	/*
+	 * Prepend the sequence number before calling gss_get_mic or gss_wrap.
+	 */
+	put_uint32(&args, seq);
+	len = m_length(args, NULL);
+
+	if (svc == rpc_gss_svc_integrity) {
+		/* Checksum rpc_gss_data_t. */
+		maj_stat = gss_get_mic_mbuf(&min_stat, ctx, qop, args, &mic);
+		if (maj_stat != GSS_S_COMPLETE) {
+			rpc_gss_log_debug("gss_get_mic failed");
+			m_freem(args);
+			return (FALSE);
+		}
+
+		/*
+		 * Marshal databody_integ. Note that since args is
+		 * already RPC encoded, there will be no padding.
+		 */
+		put_uint32(&args, len);
+
+		/*
+		 * Marshal checksum. This is likely to need padding.
+		 */
+		len = m_length(mic, NULL);
+		put_uint32(&mic, len);
+		if (len != RNDUP(len)) {
+			m_append(mic, RNDUP(len) - len, zpad);
+		}
+
+		/*
+		 * Concatenate databody_integ with checksum.
+		 */
+		m_cat(args, mic);
+	} else if (svc == rpc_gss_svc_privacy) {
+		/* Encrypt rpc_gss_data_t. */
+		maj_stat = gss_wrap_mbuf(&min_stat, ctx, TRUE, qop,
+		    &args, &conf_state);
+		if (maj_stat != GSS_S_COMPLETE) {
+			rpc_gss_log_status("gss_wrap", NULL,
+			    maj_stat, min_stat);
+			return (FALSE);
+		}
+
+		/*
+		 *  Marshal databody_priv and deal with RPC padding.
+		 */
+		len = m_length(args, NULL);
+		put_uint32(&args, len);
+		if (len != RNDUP(len)) {
+			m_append(args, RNDUP(len) - len, zpad);
+		}
+	}
+	*argsp = args;
+	return (TRUE);
+}
+
+static uint32_t
+get_uint32(struct mbuf **mp)
+{
+	struct mbuf *m = *mp;
+	uint32_t n;
+
+	if (m->m_len < sizeof(uint32_t)) {
+		m = m_pullup(m, sizeof(uint32_t));
+		if (!m) {
+			*mp = NULL;
+			return (0);
+		}
+	}
+	bcopy(mtod(m, uint32_t *), &n, sizeof(uint32_t));
+	m_adj(m, sizeof(uint32_t));
+	*mp = m;
+	return (ntohl(n));
+}
+
+static void
+m_trim(struct mbuf *m, int len)
+{
+	struct mbuf *n;
+	int off;
+
+	n = m_getptr(m, len, &off);
+	if (n) {
+		n->m_len = off;
+		if (n->m_next) {
+			m_freem(n->m_next);
+			n->m_next = NULL;
+		}
+	}
+}
+
+bool_t
+xdr_rpc_gss_unwrap_data(struct mbuf **resultsp,
+			gss_ctx_id_t ctx, gss_qop_t qop,
+			rpc_gss_service_t svc, u_int seq)
+{
+	struct mbuf	*results, *message, *mic;
+	uint32_t	len, cklen;
+	OM_uint32	maj_stat, min_stat;
+	u_int		seq_num, conf_state, qop_state;
+
+	results = *resultsp;
+	*resultsp = NULL;
+	
+	message = NULL;
+	if (svc == rpc_gss_svc_integrity) {
+		/*
+		 * Extract the seq+message part. Remember that there
+		 * may be extra RPC padding in the checksum. The
+		 * message part is RPC encoded already so no
+		 * padding.
+		 */
+		len = get_uint32(&results);
+		message = results;
+		results = m_split(results, len, M_WAIT);
+		if (!results) {
+			m_freem(message);
+			return (FALSE);
+		}
+
+		/*
+		 * Extract the MIC and make it contiguous.
+		 */
+		cklen = get_uint32(&results);
+		KASSERT(cklen <= MHLEN, ("unexpected large GSS-API checksum"));
+		mic = results;
+		if (cklen > mic->m_len)
+			mic = m_pullup(mic, cklen);
+		if (cklen != RNDUP(cklen))
+			m_trim(mic, cklen);
+
+		/* Verify checksum and QOP. */
+		maj_stat = gss_verify_mic_mbuf(&min_stat, ctx,
+		    message, mic, &qop_state);
+		m_freem(mic);
+		
+		if (maj_stat != GSS_S_COMPLETE || qop_state != qop) {
+			m_freem(message);
+			rpc_gss_log_status("gss_verify_mic", NULL,
+			    maj_stat, min_stat);
+			return (FALSE);
+		}
+	} else if (svc == rpc_gss_svc_privacy) {
+		/* Decode databody_priv. */
+		len = get_uint32(&results);
+
+		/* Decrypt databody. */
+		message = results;
+		if (len != RNDUP(len))
+			m_trim(message, len);
+		maj_stat = gss_unwrap_mbuf(&min_stat, ctx, &message,
+		    &conf_state, &qop_state);
+		
+		/* Verify encryption and QOP. */
+		if (maj_stat != GSS_S_COMPLETE) {
+			rpc_gss_log_status("gss_unwrap", NULL,
+			    maj_stat, min_stat);
+			return (FALSE);
+		}
+		if (qop_state != qop || conf_state != TRUE) {
+			m_freem(results);
+			return (FALSE);
+		}
+	}
+
+	/* Decode rpc_gss_data_t (sequence number + arguments). */
+	seq_num = get_uint32(&message);
+	
+	/* Verify sequence number. */
+	if (seq_num != seq) {
+		rpc_gss_log_debug("wrong sequence number in databody");
+		m_freem(message);
+		return (FALSE);
+	}
+
+	*resultsp = message;
+	return (TRUE);
+}
+
+#ifdef DEBUG
+#include <ctype.h>
+
+void
+rpc_gss_log_debug(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "rpcsec_gss: ");
+	vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "\n");
+	va_end(ap);
+}
+
+void
+rpc_gss_log_status(const char *m, gss_OID mech, OM_uint32 maj_stat, OM_uint32 min_stat)
+{
+	OM_uint32 min;
+	gss_buffer_desc msg;
+	int msg_ctx = 0;
+
+	fprintf(stderr, "rpcsec_gss: %s: ", m);
+	
+	gss_display_status(&min, maj_stat, GSS_C_GSS_CODE, GSS_C_NULL_OID,
+			   &msg_ctx, &msg);
+	printf("%s - ", (char *)msg.value);
+	gss_release_buffer(&min, &msg);
+
+	gss_display_status(&min, min_stat, GSS_C_MECH_CODE, mech,
+			   &msg_ctx, &msg);
+	printf("%s\n", (char *)msg.value);
+	gss_release_buffer(&min, &msg);
+}
+
+#else
+
+void
+rpc_gss_log_debug(__unused const char *fmt, ...)
+{
+}
+
+void
+rpc_gss_log_status(__unused const char *m, __unused gss_OID mech,
+    __unused OM_uint32 maj_stat, __unused OM_uint32 min_stat)
+{
+}
+
+#endif
+
+
diff --git a/sys/rpc/rpcsec_gss/svc_rpcsec_gss.c b/sys/rpc/rpcsec_gss/svc_rpcsec_gss.c
new file mode 100644
index 0000000..e2469fd
--- /dev/null
+++ b/sys/rpc/rpcsec_gss/svc_rpcsec_gss.c
@@ -0,0 +1,1485 @@
+/*-
+ * Copyright (c) 2008 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+  svc_rpcsec_gss.c
+  
+  Copyright (c) 2000 The Regents of the University of Michigan.
+  All rights reserved.
+
+  Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
+  All rights reserved, all wrongs reversed.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name of the University nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  $Id: svc_auth_gss.c,v 1.27 2002/01/15 15:43:00 andros Exp $
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/kobj.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mutex.h>
+#include <sys/sx.h>
+#include <sys/ucred.h>
+
+#include <rpc/rpc.h>
+#include <rpc/rpcsec_gss.h>
+
+#include "rpcsec_gss_int.h"
+
+static bool_t   svc_rpc_gss_wrap(SVCAUTH *, struct mbuf **);
+static bool_t   svc_rpc_gss_unwrap(SVCAUTH *, struct mbuf **);
+static void     svc_rpc_gss_release(SVCAUTH *);
+static enum auth_stat svc_rpc_gss(struct svc_req *, struct rpc_msg *);
+static int rpc_gss_svc_getcred(struct svc_req *, struct ucred **, int *);
+
+static struct svc_auth_ops svc_auth_gss_ops = {
+	svc_rpc_gss_wrap,
+	svc_rpc_gss_unwrap,
+	svc_rpc_gss_release,
+};
+
+struct sx svc_rpc_gss_lock;
+
+struct svc_rpc_gss_callback {
+	SLIST_ENTRY(svc_rpc_gss_callback) cb_link;
+	rpc_gss_callback_t	cb_callback;
+};
+static SLIST_HEAD(svc_rpc_gss_callback_list, svc_rpc_gss_callback)
+	svc_rpc_gss_callbacks = SLIST_HEAD_INITIALIZER(&svc_rpc_gss_callbacks);
+
+struct svc_rpc_gss_svc_name {
+	SLIST_ENTRY(svc_rpc_gss_svc_name) sn_link;
+	char			*sn_principal;
+	gss_OID			sn_mech;
+	u_int			sn_req_time;
+	gss_cred_id_t		sn_cred;
+	u_int			sn_program;
+	u_int			sn_version;
+};
+static SLIST_HEAD(svc_rpc_gss_svc_name_list, svc_rpc_gss_svc_name)
+	svc_rpc_gss_svc_names = SLIST_HEAD_INITIALIZER(&svc_rpc_gss_svc_names);
+
+enum svc_rpc_gss_client_state {
+	CLIENT_NEW,				/* still authenticating */
+	CLIENT_ESTABLISHED,			/* context established */
+	CLIENT_STALE				/* garbage to collect */
+};
+
+#define SVC_RPC_GSS_SEQWINDOW	128
+
+struct svc_rpc_gss_clientid {
+	uint32_t		ci_hostid;
+	uint32_t		ci_boottime;
+	uint32_t		ci_id;
+};
+
+struct svc_rpc_gss_client {
+	TAILQ_ENTRY(svc_rpc_gss_client) cl_link;
+	TAILQ_ENTRY(svc_rpc_gss_client) cl_alllink;
+	volatile u_int		cl_refs;
+	struct sx		cl_lock;
+	struct svc_rpc_gss_clientid cl_id;
+	time_t			cl_expiration;	/* when to gc */
+	enum svc_rpc_gss_client_state cl_state;	/* client state */
+	bool_t			cl_locked;	/* fixed service+qop */
+	gss_ctx_id_t		cl_ctx;		/* context id */
+	gss_cred_id_t		cl_creds;	/* delegated creds */
+	gss_name_t		cl_cname;	/* client name */
+	struct svc_rpc_gss_svc_name *cl_sname;	/* server name used */
+	rpc_gss_rawcred_t	cl_rawcred;	/* raw credentials */
+	rpc_gss_ucred_t		cl_ucred;	/* unix-style credentials */
+	struct ucred		*cl_cred;	/* kernel-style credentials */
+	int			cl_rpcflavor;	/* RPC pseudo sec flavor */
+	bool_t			cl_done_callback; /* TRUE after call */
+	void			*cl_cookie;	/* user cookie from callback */
+	gid_t			cl_gid_storage[NGROUPS];
+	gss_OID			cl_mech;	/* mechanism */
+	gss_qop_t		cl_qop;		/* quality of protection */
+	uint32_t		cl_seqlast;	/* sequence window origin */
+	uint32_t		cl_seqmask[SVC_RPC_GSS_SEQWINDOW/32]; /* bitmask of seqnums */
+};
+TAILQ_HEAD(svc_rpc_gss_client_list, svc_rpc_gss_client);
+
+/*
+ * This structure holds enough information to unwrap arguments or wrap
+ * results for a given request. We use the rq_clntcred area for this
+ * (which is a per-request buffer).
+ */
+struct svc_rpc_gss_cookedcred {
+	struct svc_rpc_gss_client *cc_client;
+	rpc_gss_service_t	cc_service;
+	uint32_t		cc_seq;
+};
+
+#define CLIENT_HASH_SIZE	256
+#define CLIENT_MAX		128
+struct svc_rpc_gss_client_list svc_rpc_gss_client_hash[CLIENT_HASH_SIZE];
+struct svc_rpc_gss_client_list svc_rpc_gss_clients;
+static size_t svc_rpc_gss_client_count;
+static uint32_t svc_rpc_gss_next_clientid = 1;
+
+static void
+svc_rpc_gss_init(void *arg)
+{
+	int i;
+
+	for (i = 0; i < CLIENT_HASH_SIZE; i++)
+		TAILQ_INIT(&svc_rpc_gss_client_hash[i]);
+	TAILQ_INIT(&svc_rpc_gss_clients);
+	svc_auth_reg(RPCSEC_GSS, svc_rpc_gss, rpc_gss_svc_getcred);
+	sx_init(&svc_rpc_gss_lock, "gsslock");
+}
+SYSINIT(svc_rpc_gss_init, SI_SUB_KMEM, SI_ORDER_ANY, svc_rpc_gss_init, NULL);
+
+bool_t
+rpc_gss_set_callback(rpc_gss_callback_t *cb)
+{
+	struct svc_rpc_gss_callback *scb;
+
+	scb = mem_alloc(sizeof(struct svc_rpc_gss_callback));
+	if (!scb) {
+		_rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
+		return (FALSE);
+	}
+	scb->cb_callback = *cb;
+	sx_xlock(&svc_rpc_gss_lock);
+	SLIST_INSERT_HEAD(&svc_rpc_gss_callbacks, scb, cb_link);
+	sx_xunlock(&svc_rpc_gss_lock);
+
+	return (TRUE);
+}
+
+void
+rpc_gss_clear_callback(rpc_gss_callback_t *cb)
+{
+	struct svc_rpc_gss_callback *scb;
+
+	sx_xlock(&svc_rpc_gss_lock);
+	SLIST_FOREACH(scb, &svc_rpc_gss_callbacks, cb_link) {
+		if (scb->cb_callback.program == cb->program
+		    && scb->cb_callback.version == cb->version
+		    && scb->cb_callback.callback == cb->callback) {
+			SLIST_REMOVE(&svc_rpc_gss_callbacks, scb,
+			    svc_rpc_gss_callback, cb_link);
+			sx_xunlock(&svc_rpc_gss_lock);
+			mem_free(scb, sizeof(*scb));
+			return;
+		}
+	}
+	sx_xunlock(&svc_rpc_gss_lock);
+}
+
+static bool_t
+rpc_gss_acquire_svc_cred(struct svc_rpc_gss_svc_name *sname)
+{
+	OM_uint32		maj_stat, min_stat;
+	gss_buffer_desc		namebuf;
+	gss_name_t		name;
+	gss_OID_set_desc	oid_set;
+
+	oid_set.count = 1;
+	oid_set.elements = sname->sn_mech;
+
+	namebuf.value = (void *) sname->sn_principal;
+	namebuf.length = strlen(sname->sn_principal);
+
+	maj_stat = gss_import_name(&min_stat, &namebuf,
+				   GSS_C_NT_HOSTBASED_SERVICE, &name);
+	if (maj_stat != GSS_S_COMPLETE)
+		return (FALSE);
+
+	if (sname->sn_cred != GSS_C_NO_CREDENTIAL)
+		gss_release_cred(&min_stat, &sname->sn_cred);
+
+	maj_stat = gss_acquire_cred(&min_stat, name,
+	    sname->sn_req_time, &oid_set, GSS_C_ACCEPT, &sname->sn_cred,
+	    NULL, NULL);
+	if (maj_stat != GSS_S_COMPLETE) {
+		gss_release_name(&min_stat, &name);
+		return (FALSE);
+	}
+	gss_release_name(&min_stat, &name);
+
+	return (TRUE);
+}
+
+bool_t
+rpc_gss_set_svc_name(const char *principal, const char *mechanism,
+    u_int req_time, u_int program, u_int version)
+{
+	struct svc_rpc_gss_svc_name *sname;
+	gss_OID			mech_oid;
+
+	if (!rpc_gss_mech_to_oid(mechanism, &mech_oid))
+		return (FALSE);
+
+	sname = mem_alloc(sizeof(*sname));
+	if (!sname)
+		return (FALSE);
+	sname->sn_principal = strdup(principal, M_RPC);
+	sname->sn_mech = mech_oid;
+	sname->sn_req_time = req_time;
+	sname->sn_cred = GSS_C_NO_CREDENTIAL;
+	sname->sn_program = program;
+	sname->sn_version = version;
+
+	if (!rpc_gss_acquire_svc_cred(sname)) {
+		free(sname->sn_principal, M_RPC);
+		mem_free(sname, sizeof(*sname));
+		return (FALSE);
+	}
+
+	sx_xlock(&svc_rpc_gss_lock);
+	SLIST_INSERT_HEAD(&svc_rpc_gss_svc_names, sname, sn_link);
+	sx_xunlock(&svc_rpc_gss_lock);
+
+	return (TRUE);
+}
+
+void
+rpc_gss_clear_svc_name(u_int program, u_int version)
+{
+	OM_uint32		min_stat;
+	struct svc_rpc_gss_svc_name *sname;
+
+	sx_xlock(&svc_rpc_gss_lock);
+	SLIST_FOREACH(sname, &svc_rpc_gss_svc_names, sn_link) {
+		if (sname->sn_program == program
+		    && sname->sn_version == version) {
+			SLIST_REMOVE(&svc_rpc_gss_svc_names, sname,
+			    svc_rpc_gss_svc_name, sn_link);
+			sx_xunlock(&svc_rpc_gss_lock);
+			gss_release_cred(&min_stat, &sname->sn_cred);
+			free(sname->sn_principal, M_RPC);
+			mem_free(sname, sizeof(*sname));
+			return;
+		}
+	}
+	sx_xunlock(&svc_rpc_gss_lock);
+}
+
+bool_t
+rpc_gss_get_principal_name(rpc_gss_principal_t *principal,
+    const char *mech, const char *name, const char *node, const char *domain)
+{
+	OM_uint32		maj_stat, min_stat;
+	gss_OID			mech_oid;
+	size_t			namelen;
+	gss_buffer_desc		buf;
+	gss_name_t		gss_name, gss_mech_name;
+	rpc_gss_principal_t	result;
+
+	if (!rpc_gss_mech_to_oid(mech, &mech_oid))
+		return (FALSE);
+
+	/*
+	 * Construct a gss_buffer containing the full name formatted
+	 * as "name/node@domain" where node and domain are optional.
+	 */
+	namelen = strlen(name);
+	if (node) {
+		namelen += strlen(node) + 1;
+	}
+	if (domain) {
+		namelen += strlen(domain) + 1;
+	}
+
+	buf.value = mem_alloc(namelen);
+	buf.length = namelen;
+	strcpy((char *) buf.value, name);
+	if (node) {
+		strcat((char *) buf.value, "/");
+		strcat((char *) buf.value, node);
+	}
+	if (domain) {
+		strcat((char *) buf.value, "@");
+		strcat((char *) buf.value, domain);
+	}
+
+	/*
+	 * Convert that to a gss_name_t and then convert that to a
+	 * mechanism name in the selected mechanism.
+	 */
+	maj_stat = gss_import_name(&min_stat, &buf,
+	    GSS_C_NT_USER_NAME, &gss_name);
+	mem_free(buf.value, buf.length);
+	if (maj_stat != GSS_S_COMPLETE) {
+		rpc_gss_log_status("gss_import_name", mech_oid, maj_stat, min_stat);
+		return (FALSE);
+	}
+	maj_stat = gss_canonicalize_name(&min_stat, gss_name, mech_oid,
+	    &gss_mech_name);
+	if (maj_stat != GSS_S_COMPLETE) {
+		rpc_gss_log_status("gss_canonicalize_name", mech_oid, maj_stat,
+		    min_stat);
+		gss_release_name(&min_stat, &gss_name);
+		return (FALSE);
+	}
+	gss_release_name(&min_stat, &gss_name);
+
+	/*
+	 * Export the mechanism name and use that to construct the
+	 * rpc_gss_principal_t result.
+	 */
+	maj_stat = gss_export_name(&min_stat, gss_mech_name, &buf);
+	if (maj_stat != GSS_S_COMPLETE) {
+		rpc_gss_log_status("gss_export_name", mech_oid, maj_stat, min_stat);
+		gss_release_name(&min_stat, &gss_mech_name);
+		return (FALSE);
+	}
+	gss_release_name(&min_stat, &gss_mech_name);
+
+	result = mem_alloc(sizeof(int) + buf.length);
+	if (!result) {
+		gss_release_buffer(&min_stat, &buf);
+		return (FALSE);
+	}
+	result->len = buf.length;
+	memcpy(result->name, buf.value, buf.length);
+	gss_release_buffer(&min_stat, &buf);
+
+	*principal = result;
+	return (TRUE);
+}
+
+bool_t
+rpc_gss_getcred(struct svc_req *req, rpc_gss_rawcred_t **rcred,
+    rpc_gss_ucred_t **ucred, void **cookie)
+{
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+
+	if (req->rq_cred.oa_flavor != RPCSEC_GSS)
+		return (FALSE);
+
+	cc = req->rq_clntcred;
+	client = cc->cc_client;
+	if (rcred)
+		*rcred = &client->cl_rawcred;
+	if (ucred)
+		*ucred = &client->cl_ucred;
+	if (cookie)
+		*cookie = client->cl_cookie;
+	return (TRUE);
+}
+
+/*
+ * This simpler interface is used by svc_getcred to copy the cred data
+ * into a kernel cred structure.
+ */
+static int
+rpc_gss_svc_getcred(struct svc_req *req, struct ucred **crp, int *flavorp)
+{
+	struct ucred *cr;
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+	rpc_gss_ucred_t *uc;
+	int i;
+
+	if (req->rq_cred.oa_flavor != RPCSEC_GSS)
+		return (FALSE);
+
+	cc = req->rq_clntcred;
+	client = cc->cc_client;
+
+	if (flavorp)
+		*flavorp = client->cl_rpcflavor;
+
+	if (client->cl_cred) {
+		*crp = crhold(client->cl_cred);
+		return (TRUE);
+	}
+
+	uc = &client->cl_ucred;
+	cr = client->cl_cred = crget();
+	cr->cr_uid = cr->cr_ruid = cr->cr_svuid = uc->uid;
+	cr->cr_rgid = cr->cr_svgid = uc->gid;
+	cr->cr_ngroups = uc->gidlen;
+	if (cr->cr_ngroups > NGROUPS)
+		cr->cr_ngroups = NGROUPS;
+	for (i = 0; i < cr->cr_ngroups; i++)
+		cr->cr_groups[i] = uc->gidlist[i];
+	*crp = crhold(cr);
+
+	return (TRUE);
+}
+
+int
+rpc_gss_svc_max_data_length(struct svc_req *req, int max_tp_unit_len)
+{
+	struct svc_rpc_gss_cookedcred *cc = req->rq_clntcred;
+	struct svc_rpc_gss_client *client = cc->cc_client;
+	int			want_conf;
+	OM_uint32		max;
+	OM_uint32		maj_stat, min_stat;
+	int			result;
+
+	switch (client->cl_rawcred.service) {
+	case rpc_gss_svc_none:
+		return (max_tp_unit_len);
+		break;
+
+	case rpc_gss_svc_default:
+	case rpc_gss_svc_integrity:
+		want_conf = FALSE;
+		break;
+
+	case rpc_gss_svc_privacy:
+		want_conf = TRUE;
+		break;
+
+	default:
+		return (0);
+	}
+
+	maj_stat = gss_wrap_size_limit(&min_stat, client->cl_ctx, want_conf,
+	    client->cl_qop, max_tp_unit_len, &max);
+
+	if (maj_stat == GSS_S_COMPLETE) {
+		result = (int) max;
+		if (result < 0)
+			result = 0;
+		return (result);
+	} else {
+		rpc_gss_log_status("gss_wrap_size_limit", client->cl_mech,
+		    maj_stat, min_stat);
+		return (0);
+	}
+}
+
+static struct svc_rpc_gss_client *
+svc_rpc_gss_find_client(struct svc_rpc_gss_clientid *id)
+{
+	struct svc_rpc_gss_client *client;
+	struct svc_rpc_gss_client_list *list;
+
+	rpc_gss_log_debug("in svc_rpc_gss_find_client(%d)", id->ci_id);
+
+	if (id->ci_hostid != hostid || id->ci_boottime != boottime.tv_sec)
+		return (NULL);
+
+	list = &svc_rpc_gss_client_hash[id->ci_id % CLIENT_HASH_SIZE];
+	sx_xlock(&svc_rpc_gss_lock);
+	TAILQ_FOREACH(client, list, cl_link) {
+		if (client->cl_id.ci_id == id->ci_id) {
+			/*
+			 * Move this client to the front of the LRU
+			 * list.
+			 */
+			TAILQ_REMOVE(&svc_rpc_gss_clients, client, cl_alllink);
+			TAILQ_INSERT_HEAD(&svc_rpc_gss_clients, client,
+			    cl_alllink);
+			refcount_acquire(&client->cl_refs);
+			break;
+		}
+	}
+	sx_xunlock(&svc_rpc_gss_lock);
+
+	return (client);
+}
+
+static struct svc_rpc_gss_client *
+svc_rpc_gss_create_client(void)
+{
+	struct svc_rpc_gss_client *client;
+	struct svc_rpc_gss_client_list *list;
+
+	rpc_gss_log_debug("in svc_rpc_gss_create_client()");
+
+	client = mem_alloc(sizeof(struct svc_rpc_gss_client));
+	memset(client, 0, sizeof(struct svc_rpc_gss_client));
+	refcount_init(&client->cl_refs, 1);
+	sx_init(&client->cl_lock, "GSS-client");
+	client->cl_id.ci_hostid = hostid;
+	client->cl_id.ci_boottime = boottime.tv_sec;
+	client->cl_id.ci_id = svc_rpc_gss_next_clientid++;
+	list = &svc_rpc_gss_client_hash[client->cl_id.ci_id % CLIENT_HASH_SIZE];
+	sx_xlock(&svc_rpc_gss_lock);
+	TAILQ_INSERT_HEAD(list, client, cl_link);
+	TAILQ_INSERT_HEAD(&svc_rpc_gss_clients, client, cl_alllink);
+	svc_rpc_gss_client_count++;
+	sx_xunlock(&svc_rpc_gss_lock);
+
+	/*
+	 * Start the client off with a short expiration time. We will
+	 * try to get a saner value from the client creds later.
+	 */
+	client->cl_state = CLIENT_NEW;
+	client->cl_locked = FALSE;
+	client->cl_expiration = time_uptime + 5*60;
+
+	return (client);
+}
+
+static void
+svc_rpc_gss_destroy_client(struct svc_rpc_gss_client *client)
+{
+	OM_uint32 min_stat;
+
+	rpc_gss_log_debug("in svc_rpc_gss_destroy_client()");
+
+	if (client->cl_ctx)
+		gss_delete_sec_context(&min_stat,
+		    &client->cl_ctx, GSS_C_NO_BUFFER);
+
+	if (client->cl_cname)
+		gss_release_name(&min_stat, &client->cl_cname);
+
+	if (client->cl_rawcred.client_principal)
+		mem_free(client->cl_rawcred.client_principal,
+		    sizeof(*client->cl_rawcred.client_principal)
+		    + client->cl_rawcred.client_principal->len);
+
+	if (client->cl_cred)
+		crfree(client->cl_cred);
+
+	sx_destroy(&client->cl_lock);
+	mem_free(client, sizeof(*client));
+}
+
+/*
+ * Drop a reference to a client and free it if that was the last reference.
+ */
+static void
+svc_rpc_gss_release_client(struct svc_rpc_gss_client *client)
+{
+
+	if (!refcount_release(&client->cl_refs))
+		return;
+	svc_rpc_gss_destroy_client(client);
+}
+
+/*
+ * Remove a client from our global lists and free it if we can.
+ */
+static void
+svc_rpc_gss_forget_client(struct svc_rpc_gss_client *client)
+{
+	struct svc_rpc_gss_client_list *list;
+
+	list = &svc_rpc_gss_client_hash[client->cl_id.ci_id % CLIENT_HASH_SIZE];
+	sx_xlock(&svc_rpc_gss_lock);
+	TAILQ_REMOVE(list, client, cl_link);
+	TAILQ_REMOVE(&svc_rpc_gss_clients, client, cl_alllink);
+	svc_rpc_gss_client_count--;
+	sx_xunlock(&svc_rpc_gss_lock);
+	svc_rpc_gss_release_client(client);
+}
+
+static void
+svc_rpc_gss_timeout_clients(void)
+{
+	struct svc_rpc_gss_client *client;
+	struct svc_rpc_gss_client *nclient;
+	time_t now = time_uptime;
+
+	rpc_gss_log_debug("in svc_rpc_gss_timeout_clients()");
+
+	/*
+	 * First enforce the max client limit. We keep
+	 * svc_rpc_gss_clients in LRU order.
+	 */
+	while (svc_rpc_gss_client_count > CLIENT_MAX)
+		svc_rpc_gss_forget_client(TAILQ_LAST(&svc_rpc_gss_clients,
+			    svc_rpc_gss_client_list));
+	TAILQ_FOREACH_SAFE(client, &svc_rpc_gss_clients, cl_alllink, nclient) {
+		if (client->cl_state == CLIENT_STALE
+		    || now > client->cl_expiration) {
+			rpc_gss_log_debug("expiring client %p", client);
+			svc_rpc_gss_forget_client(client);
+		}
+	}
+}
+
+#ifdef DEBUG
+/*
+ * OID<->string routines.  These are uuuuugly.
+ */
+static OM_uint32
+gss_oid_to_str(OM_uint32 *minor_status, gss_OID oid, gss_buffer_t oid_str)
+{
+	char		numstr[128];
+	unsigned long	number;
+	int		numshift;
+	size_t		string_length;
+	size_t		i;
+	unsigned char	*cp;
+	char		*bp;
+
+	/* Decoded according to krb5/gssapi_krb5.c */
+
+	/* First determine the size of the string */
+	string_length = 0;
+	number = 0;
+	numshift = 0;
+	cp = (unsigned char *) oid->elements;
+	number = (unsigned long) cp[0];
+	sprintf(numstr, "%ld ", number/40);
+	string_length += strlen(numstr);
+	sprintf(numstr, "%ld ", number%40);
+	string_length += strlen(numstr);
+	for (i=1; i<oid->length; i++) {
+		if ( (size_t) (numshift+7) < (sizeof(unsigned long)*8)) {
+			number = (number << 7) | (cp[i] & 0x7f);
+			numshift += 7;
+		}
+		else {
+			*minor_status = 0;
+			return(GSS_S_FAILURE);
+		}
+		if ((cp[i] & 0x80) == 0) {
+			sprintf(numstr, "%ld ", number);
+			string_length += strlen(numstr);
+			number = 0;
+			numshift = 0;
+		}
+	}
+	/*
+	 * If we get here, we've calculated the length of "n n n ... n ".  Add 4
+	 * here for "{ " and "}\0".
+	 */
+	string_length += 4;
+	if ((bp = (char *) mem_alloc(string_length))) {
+		strcpy(bp, "{ ");
+		number = (unsigned long) cp[0];
+		sprintf(numstr, "%ld ", number/40);
+		strcat(bp, numstr);
+		sprintf(numstr, "%ld ", number%40);
+		strcat(bp, numstr);
+		number = 0;
+		cp = (unsigned char *) oid->elements;
+		for (i=1; i<oid->length; i++) {
+			number = (number << 7) | (cp[i] & 0x7f);
+			if ((cp[i] & 0x80) == 0) {
+				sprintf(numstr, "%ld ", number);
+				strcat(bp, numstr);
+				number = 0;
+			}
+		}
+		strcat(bp, "}");
+		oid_str->length = strlen(bp)+1;
+		oid_str->value = (void *) bp;
+		*minor_status = 0;
+		return(GSS_S_COMPLETE);
+	}
+	*minor_status = 0;
+	return(GSS_S_FAILURE);
+}
+#endif
+
+static void
+svc_rpc_gss_build_ucred(struct svc_rpc_gss_client *client,
+    const gss_name_t name)
+{
+	OM_uint32		maj_stat, min_stat;
+	rpc_gss_ucred_t		*uc = &client->cl_ucred;
+	int			numgroups;
+
+	uc->uid = 65534;
+	uc->gid = 65534;
+	uc->gidlist = client->cl_gid_storage;
+
+	numgroups = NGROUPS;
+	maj_stat = gss_pname_to_unix_cred(&min_stat, name, client->cl_mech,
+	    &uc->uid, &uc->gid, &numgroups, &uc->gidlist[0]);
+	if (GSS_ERROR(maj_stat))
+		uc->gidlen = 0;
+	else
+		uc->gidlen = numgroups;
+}
+
+static void
+svc_rpc_gss_set_flavor(struct svc_rpc_gss_client *client)
+{
+	static gss_OID_desc krb5_mech_oid =
+		{9, (void *) "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" };
+
+	/*
+	 * Attempt to translate mech type and service into a
+	 * 'pseudo flavor'. Hardwire in krb5 support for now.
+	 */
+	if (kgss_oid_equal(client->cl_mech, &krb5_mech_oid)) {
+		switch (client->cl_rawcred.service) {
+		case rpc_gss_svc_default:
+		case rpc_gss_svc_none:
+			client->cl_rpcflavor = RPCSEC_GSS_KRB5;
+			break;
+		case rpc_gss_svc_integrity:
+			client->cl_rpcflavor = RPCSEC_GSS_KRB5I;
+			break;
+		case rpc_gss_svc_privacy:
+			client->cl_rpcflavor = RPCSEC_GSS_KRB5P;
+			break;
+		}
+	} else {
+		client->cl_rpcflavor = RPCSEC_GSS;
+	}
+}
+
+static bool_t
+svc_rpc_gss_accept_sec_context(struct svc_rpc_gss_client *client,
+			       struct svc_req *rqst,
+			       struct rpc_gss_init_res *gr,
+			       struct rpc_gss_cred *gc)
+{
+	gss_buffer_desc		recv_tok;
+	gss_OID			mech;
+	OM_uint32		maj_stat = 0, min_stat = 0, ret_flags;
+	OM_uint32		cred_lifetime;
+	struct svc_rpc_gss_svc_name *sname;
+
+	rpc_gss_log_debug("in svc_rpc_gss_accept_context()");
+	
+	/* Deserialize arguments. */
+	memset(&recv_tok, 0, sizeof(recv_tok));
+	
+	if (!svc_getargs(rqst,
+		(xdrproc_t) xdr_gss_buffer_desc,
+		(caddr_t) &recv_tok)) {
+		client->cl_state = CLIENT_STALE;
+		return (FALSE);
+	}
+
+	/*
+	 * First time round, try all the server names we have until
+	 * one matches. Afterwards, stick with that one.
+	 */
+	sx_xlock(&svc_rpc_gss_lock);
+	if (!client->cl_sname) {
+		SLIST_FOREACH(sname, &svc_rpc_gss_svc_names, sn_link) {
+			if (sname->sn_program == rqst->rq_prog
+			    && sname->sn_version == rqst->rq_vers) {
+			retry:
+				gr->gr_major = gss_accept_sec_context(
+					&gr->gr_minor,
+					&client->cl_ctx,
+					sname->sn_cred,
+					&recv_tok,
+					GSS_C_NO_CHANNEL_BINDINGS,
+					&client->cl_cname,
+					&mech,
+					&gr->gr_token,
+					&ret_flags,
+					&cred_lifetime,
+					&client->cl_creds);
+				if (gr->gr_major == 
+				    GSS_S_CREDENTIALS_EXPIRED) {
+					/*
+					 * Either our creds really did
+					 * expire or gssd was
+					 * restarted.
+					 */
+					if (rpc_gss_acquire_svc_cred(sname))
+						goto retry;
+				}
+				client->cl_sname = sname;
+				break;
+			}
+		}
+		if (!sname) {
+			xdr_free((xdrproc_t) xdr_gss_buffer_desc,
+			    (char *) &recv_tok);
+			sx_xunlock(&svc_rpc_gss_lock);
+			return (FALSE);
+		}
+	} else {
+		gr->gr_major = gss_accept_sec_context(
+			&gr->gr_minor,
+			&client->cl_ctx,
+			client->cl_sname->sn_cred,
+			&recv_tok,
+			GSS_C_NO_CHANNEL_BINDINGS,
+			&client->cl_cname,
+			&mech,
+			&gr->gr_token,
+			&ret_flags,
+			&cred_lifetime,
+			NULL);
+	}
+	sx_xunlock(&svc_rpc_gss_lock);
+	
+	xdr_free((xdrproc_t) xdr_gss_buffer_desc, (char *) &recv_tok);
+
+	/*
+	 * If we get an error from gss_accept_sec_context, send the
+	 * reply anyway so that the client gets a chance to see what
+	 * is wrong.
+	 */
+	if (gr->gr_major != GSS_S_COMPLETE &&
+	    gr->gr_major != GSS_S_CONTINUE_NEEDED) {
+		rpc_gss_log_status("accept_sec_context", client->cl_mech,
+		    gr->gr_major, gr->gr_minor);
+		client->cl_state = CLIENT_STALE;
+		return (TRUE);
+	}
+
+	gr->gr_handle.value = &client->cl_id;
+	gr->gr_handle.length = sizeof(client->cl_id);
+	gr->gr_win = SVC_RPC_GSS_SEQWINDOW;
+	
+	/* Save client info. */
+	client->cl_mech = mech;
+	client->cl_qop = GSS_C_QOP_DEFAULT;
+	client->cl_done_callback = FALSE;
+
+	if (gr->gr_major == GSS_S_COMPLETE) {
+		gss_buffer_desc	export_name;
+
+		/*
+		 * Change client expiration time to be near when the
+		 * client creds expire (or 24 hours if we can't figure
+		 * that out).
+		 */
+		if (cred_lifetime == GSS_C_INDEFINITE)
+			cred_lifetime = time_uptime + 24*60*60;
+
+		client->cl_expiration = time_uptime + cred_lifetime;
+
+		/*
+		 * Fill in cred details in the rawcred structure.
+		 */
+		client->cl_rawcred.version = RPCSEC_GSS_VERSION;
+		rpc_gss_oid_to_mech(mech, &client->cl_rawcred.mechanism);
+		maj_stat = gss_export_name(&min_stat, client->cl_cname,
+		    &export_name);
+		if (maj_stat != GSS_S_COMPLETE) {
+			rpc_gss_log_status("gss_export_name", client->cl_mech,
+			    maj_stat, min_stat);
+			return (FALSE);
+		}
+		client->cl_rawcred.client_principal =
+			mem_alloc(sizeof(*client->cl_rawcred.client_principal)
+			    + export_name.length);
+		client->cl_rawcred.client_principal->len = export_name.length;
+		memcpy(client->cl_rawcred.client_principal->name,
+		    export_name.value, export_name.length);
+		gss_release_buffer(&min_stat, &export_name);
+		client->cl_rawcred.svc_principal =
+			client->cl_sname->sn_principal;
+		client->cl_rawcred.service = gc->gc_svc;
+
+		/*
+		 * Use gss_pname_to_uid to map to unix creds. For
+		 * kerberos5, this uses krb5_aname_to_localname.
+		 */
+		svc_rpc_gss_build_ucred(client, client->cl_cname);
+		svc_rpc_gss_set_flavor(client);
+		gss_release_name(&min_stat, &client->cl_cname);
+
+#ifdef DEBUG
+		{
+			gss_buffer_desc mechname;
+
+			gss_oid_to_str(&min_stat, mech, &mechname);
+			
+			rpc_gss_log_debug("accepted context for %s with "
+			    "<mech %.*s, qop %d, svc %d>",
+			    client->cl_rawcred.client_principal->name,
+			    mechname.length, (char *)mechname.value,
+			    client->cl_qop, client->rawcred.service);
+
+			gss_release_buffer(&min_stat, &mechname);
+		}
+#endif /* DEBUG */
+	}
+	return (TRUE);
+}
+
+static bool_t
+svc_rpc_gss_validate(struct svc_rpc_gss_client *client, struct rpc_msg *msg,
+    gss_qop_t *qop)
+{
+	struct opaque_auth	*oa;
+	gss_buffer_desc		 rpcbuf, checksum;
+	OM_uint32		 maj_stat, min_stat;
+	gss_qop_t		 qop_state;
+	int32_t			 rpchdr[128 / sizeof(int32_t)];
+	int32_t			*buf;
+
+	rpc_gss_log_debug("in svc_rpc_gss_validate()");
+	
+	memset(rpchdr, 0, sizeof(rpchdr));
+
+	/* Reconstruct RPC header for signing (from xdr_callmsg). */
+	buf = rpchdr;
+	IXDR_PUT_LONG(buf, msg->rm_xid);
+	IXDR_PUT_ENUM(buf, msg->rm_direction);
+	IXDR_PUT_LONG(buf, msg->rm_call.cb_rpcvers);
+	IXDR_PUT_LONG(buf, msg->rm_call.cb_prog);
+	IXDR_PUT_LONG(buf, msg->rm_call.cb_vers);
+	IXDR_PUT_LONG(buf, msg->rm_call.cb_proc);
+	oa = &msg->rm_call.cb_cred;
+	IXDR_PUT_ENUM(buf, oa->oa_flavor);
+	IXDR_PUT_LONG(buf, oa->oa_length);
+	if (oa->oa_length) {
+		memcpy((caddr_t)buf, oa->oa_base, oa->oa_length);
+		buf += RNDUP(oa->oa_length) / sizeof(int32_t);
+	}
+	rpcbuf.value = rpchdr;
+	rpcbuf.length = (u_char *)buf - (u_char *)rpchdr;
+
+	checksum.value = msg->rm_call.cb_verf.oa_base;
+	checksum.length = msg->rm_call.cb_verf.oa_length;
+	
+	maj_stat = gss_verify_mic(&min_stat, client->cl_ctx, &rpcbuf, &checksum,
+				  &qop_state);
+	
+	if (maj_stat != GSS_S_COMPLETE) {
+		rpc_gss_log_status("gss_verify_mic", client->cl_mech,
+		    maj_stat, min_stat);
+		client->cl_state = CLIENT_STALE;
+		return (FALSE);
+	}
+
+	*qop = qop_state;
+	return (TRUE);
+}
+
+static bool_t
+svc_rpc_gss_nextverf(struct svc_rpc_gss_client *client,
+    struct svc_req *rqst, u_int seq)
+{
+	gss_buffer_desc		signbuf;
+	gss_buffer_desc		mic;
+	OM_uint32		maj_stat, min_stat;
+	uint32_t		nseq;       
+
+	rpc_gss_log_debug("in svc_rpc_gss_nextverf()");
+
+	nseq = htonl(seq);
+	signbuf.value = &nseq;
+	signbuf.length = sizeof(nseq);
+
+	maj_stat = gss_get_mic(&min_stat, client->cl_ctx, client->cl_qop,
+	    &signbuf, &mic);
+
+	if (maj_stat != GSS_S_COMPLETE) {
+		rpc_gss_log_status("gss_get_mic", client->cl_mech, maj_stat, min_stat);
+		client->cl_state = CLIENT_STALE;
+		return (FALSE);
+	}
+
+	KASSERT(mic.length <= MAX_AUTH_BYTES,
+	    ("MIC too large for RPCSEC_GSS"));
+
+	rqst->rq_verf.oa_flavor = RPCSEC_GSS;
+	rqst->rq_verf.oa_length = mic.length;
+	bcopy(mic.value, rqst->rq_verf.oa_base, mic.length);
+
+	gss_release_buffer(&min_stat, &mic);
+	
+	return (TRUE);
+}
+
+static bool_t
+svc_rpc_gss_callback(struct svc_rpc_gss_client *client, struct svc_req *rqst)
+{
+	struct svc_rpc_gss_callback *scb;
+	rpc_gss_lock_t	lock;
+	void		*cookie;
+	bool_t		cb_res;
+	bool_t		result;
+
+	/*
+	 * See if we have a callback for this guy.
+	 */
+	result = TRUE;
+	SLIST_FOREACH(scb, &svc_rpc_gss_callbacks, cb_link) {
+		if (scb->cb_callback.program == rqst->rq_prog
+		    && scb->cb_callback.version == rqst->rq_vers) {
+			/*
+			 * This one matches. Call the callback and see
+			 * if it wants to veto or something.
+			 */
+			lock.locked = FALSE;
+			lock.raw_cred = &client->cl_rawcred;
+			cb_res = scb->cb_callback.callback(rqst,
+			    client->cl_creds,
+			    client->cl_ctx,
+			    &lock,
+			    &cookie);
+
+			if (!cb_res) {
+				client->cl_state = CLIENT_STALE;
+				result = FALSE;
+				break;
+			}
+
+			/*
+			 * The callback accepted the connection - it
+			 * is responsible for freeing client->cl_creds
+			 * now.
+			 */
+			client->cl_creds = GSS_C_NO_CREDENTIAL;
+			client->cl_locked = lock.locked;
+			client->cl_cookie = cookie;
+			return (TRUE);
+		}
+	}
+
+	/*
+	 * Either no callback exists for this program/version or one
+	 * of the callbacks rejected the connection. We just need to
+	 * clean up the delegated client creds, if any.
+	 */
+	if (client->cl_creds) {
+		OM_uint32 min_ver;
+		gss_release_cred(&min_ver, &client->cl_creds);
+	}
+	return (result);
+}
+
+static bool_t
+svc_rpc_gss_check_replay(struct svc_rpc_gss_client *client, uint32_t seq)
+{
+	u_int32_t offset;
+	int word, bit;
+	bool_t result;
+
+	sx_xlock(&client->cl_lock);
+	if (seq <= client->cl_seqlast) {
+		/*
+		 * The request sequence number is less than
+		 * the largest we have seen so far. If it is
+		 * outside the window or if we have seen a
+		 * request with this sequence before, silently
+		 * discard it.
+		 */
+		offset = client->cl_seqlast - seq;
+		if (offset >= SVC_RPC_GSS_SEQWINDOW) {
+			result = FALSE;
+			goto out;
+		}
+		word = offset / 32;
+		bit = offset % 32;
+		if (client->cl_seqmask[word] & (1 << bit)) {
+			result = FALSE;
+			goto out;
+		}
+	}
+
+	result = TRUE;
+out:
+	sx_xunlock(&client->cl_lock);
+	return (result);
+}
+
+static void
+svc_rpc_gss_update_seq(struct svc_rpc_gss_client *client, uint32_t seq)
+{
+	int offset, i, word, bit;
+	uint32_t carry, newcarry;
+
+	sx_xlock(&client->cl_lock);
+	if (seq > client->cl_seqlast) {
+		/*
+		 * This request has a sequence number greater
+		 * than any we have seen so far. Advance the
+		 * seq window and set bit zero of the window
+		 * (which corresponds to the new sequence
+		 * number)
+		 */
+		offset = seq - client->cl_seqlast;
+		while (offset > 32) {
+			for (i = (SVC_RPC_GSS_SEQWINDOW / 32) - 1;
+			     i > 0; i--) {
+				client->cl_seqmask[i] = client->cl_seqmask[i-1];
+			}
+			client->cl_seqmask[0] = 0;
+			offset -= 32;
+		}
+		carry = 0;
+		for (i = 0; i < SVC_RPC_GSS_SEQWINDOW / 32; i++) {
+			newcarry = client->cl_seqmask[i] >> (32 - offset);
+			client->cl_seqmask[i] =
+				(client->cl_seqmask[i] << offset) | carry;
+			carry = newcarry;
+		}
+		client->cl_seqmask[0] |= 1;
+		client->cl_seqlast = seq;
+	} else {
+		offset = client->cl_seqlast - seq;
+		word = offset / 32;
+		bit = offset % 32;
+		client->cl_seqmask[word] |= (1 << bit);
+	}
+	sx_xunlock(&client->cl_lock);
+}
+
+enum auth_stat
+svc_rpc_gss(struct svc_req *rqst, struct rpc_msg *msg)
+
+{
+	OM_uint32		 min_stat;
+	XDR	 		 xdrs;
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+	struct rpc_gss_cred	 gc;
+	struct rpc_gss_init_res	 gr;
+	gss_qop_t		 qop;
+	int			 call_stat;
+	enum auth_stat		 result;
+	
+	rpc_gss_log_debug("in svc_rpc_gss()");
+	
+	/* Garbage collect old clients. */
+	svc_rpc_gss_timeout_clients();
+
+	/* Initialize reply. */
+	rqst->rq_verf = _null_auth;
+
+	/* Deserialize client credentials. */
+	if (rqst->rq_cred.oa_length <= 0)
+		return (AUTH_BADCRED);
+	
+	memset(&gc, 0, sizeof(gc));
+	
+	xdrmem_create(&xdrs, rqst->rq_cred.oa_base,
+	    rqst->rq_cred.oa_length, XDR_DECODE);
+	
+	if (!xdr_rpc_gss_cred(&xdrs, &gc)) {
+		XDR_DESTROY(&xdrs);
+		return (AUTH_BADCRED);
+	}
+	XDR_DESTROY(&xdrs);
+
+	client = NULL;
+
+	/* Check version. */
+	if (gc.gc_version != RPCSEC_GSS_VERSION) {
+		result = AUTH_BADCRED;
+		goto out;
+	}
+
+	/* Check the proc and find the client (or create it) */
+	if (gc.gc_proc == RPCSEC_GSS_INIT) {
+		if (gc.gc_handle.length != 0) {
+			result = AUTH_BADCRED;
+			goto out;
+		}
+		client = svc_rpc_gss_create_client();
+		refcount_acquire(&client->cl_refs);
+	} else {
+		struct svc_rpc_gss_clientid *p;
+		if (gc.gc_handle.length != sizeof(*p)) {
+			result = AUTH_BADCRED;
+			goto out;
+		}
+		p = gc.gc_handle.value;
+		client = svc_rpc_gss_find_client(p);
+		if (!client) {
+			/*
+			 * Can't find the client - we may have
+			 * destroyed it - tell the other side to
+			 * re-authenticate.
+			 */
+			result = RPCSEC_GSS_CREDPROBLEM;
+			goto out;
+		}
+	}
+	cc = rqst->rq_clntcred;
+	cc->cc_client = client;
+	cc->cc_service = gc.gc_svc;
+	cc->cc_seq = gc.gc_seq;
+
+	/*
+	 * The service and sequence number must be ignored for
+	 * RPCSEC_GSS_INIT and RPCSEC_GSS_CONTINUE_INIT.
+	 */
+	if (gc.gc_proc != RPCSEC_GSS_INIT
+	    && gc.gc_proc != RPCSEC_GSS_CONTINUE_INIT) {
+		/*
+		 * Check for sequence number overflow.
+		 */
+		if (gc.gc_seq >= MAXSEQ) {
+			result = RPCSEC_GSS_CTXPROBLEM;
+			goto out;
+		}
+
+		/*
+		 * Check for valid service.
+		 */
+		if (gc.gc_svc != rpc_gss_svc_none &&
+		    gc.gc_svc != rpc_gss_svc_integrity &&
+		    gc.gc_svc != rpc_gss_svc_privacy) {
+			result = AUTH_BADCRED;
+			goto out;
+		}
+	}
+
+	/* Handle RPCSEC_GSS control procedure. */
+	switch (gc.gc_proc) {
+
+	case RPCSEC_GSS_INIT:
+	case RPCSEC_GSS_CONTINUE_INIT:
+		if (rqst->rq_proc != NULLPROC) {
+			result = AUTH_REJECTEDCRED;
+			break;
+		}
+
+		memset(&gr, 0, sizeof(gr));
+		if (!svc_rpc_gss_accept_sec_context(client, rqst, &gr, &gc)) {
+			result = AUTH_REJECTEDCRED;
+			break;
+		}
+
+		if (gr.gr_major == GSS_S_COMPLETE) {
+			/*
+			 * We borrow the space for the call verf to
+			 * pack our reply verf.
+			 */
+			rqst->rq_verf = msg->rm_call.cb_verf;
+			if (!svc_rpc_gss_nextverf(client, rqst, gr.gr_win)) {
+				result = AUTH_REJECTEDCRED;
+				break;
+			}
+		} else {
+			rqst->rq_verf = _null_auth;
+		}
+		
+		call_stat = svc_sendreply(rqst,
+		    (xdrproc_t) xdr_rpc_gss_init_res,
+		    (caddr_t) &gr);
+
+		gss_release_buffer(&min_stat, &gr.gr_token);
+
+		if (!call_stat) {
+			result = AUTH_FAILED;
+			break;
+		}
+
+		if (gr.gr_major == GSS_S_COMPLETE)
+			client->cl_state = CLIENT_ESTABLISHED;
+
+		result = RPCSEC_GSS_NODISPATCH;
+		break;
+		
+	case RPCSEC_GSS_DATA:
+	case RPCSEC_GSS_DESTROY:
+		if (!svc_rpc_gss_check_replay(client, gc.gc_seq)) {
+			result = RPCSEC_GSS_NODISPATCH;
+			break;
+		}
+
+		if (!svc_rpc_gss_validate(client, msg, &qop)) {
+			result = RPCSEC_GSS_CREDPROBLEM;
+			break;
+		}
+		
+		/*
+		 * We borrow the space for the call verf to pack our
+		 * reply verf.
+		 */
+		rqst->rq_verf = msg->rm_call.cb_verf;
+		if (!svc_rpc_gss_nextverf(client, rqst, gc.gc_seq)) {
+			result = RPCSEC_GSS_CTXPROBLEM;
+			break;
+		}
+
+		svc_rpc_gss_update_seq(client, gc.gc_seq);
+
+		/*
+		 * Change the SVCAUTH ops on the request to point at
+		 * our own code so that we can unwrap the arguments
+		 * and wrap the result. The caller will re-set this on
+		 * every request to point to a set of null wrap/unwrap
+		 * methods. Acquire an extra reference to the client
+		 * which will be released by svc_rpc_gss_release()
+		 * after the request has finished processing.
+		 */
+		refcount_acquire(&client->cl_refs);
+		rqst->rq_auth.svc_ah_ops = &svc_auth_gss_ops;
+		rqst->rq_auth.svc_ah_private = cc;
+
+		if (gc.gc_proc == RPCSEC_GSS_DATA) {
+			/*
+			 * We might be ready to do a callback to the server to
+			 * see if it wants to accept/reject the connection.
+			 */
+			sx_xlock(&client->cl_lock);
+			if (!client->cl_done_callback) {
+				client->cl_done_callback = TRUE;
+				client->cl_qop = qop;
+				client->cl_rawcred.qop = _rpc_gss_num_to_qop(
+					client->cl_rawcred.mechanism, qop);
+				if (!svc_rpc_gss_callback(client, rqst)) {
+					result = AUTH_REJECTEDCRED;
+					sx_xunlock(&client->cl_lock);
+					break;
+				}
+			}
+			sx_xunlock(&client->cl_lock);
+
+			/*
+			 * If the server has locked this client to a
+			 * particular service+qop pair, enforce that
+			 * restriction now.
+			 */
+			if (client->cl_locked) {
+				if (client->cl_rawcred.service != gc.gc_svc) {
+					result = AUTH_FAILED;
+					break;
+				} else if (client->cl_qop != qop) {
+					result = AUTH_BADVERF;
+					break;
+				}
+			}
+
+			/*
+			 * If the qop changed, look up the new qop
+			 * name for rawcred.
+			 */
+			if (client->cl_qop != qop) {
+				client->cl_qop = qop;
+				client->cl_rawcred.qop = _rpc_gss_num_to_qop(
+					client->cl_rawcred.mechanism, qop);
+			}
+
+			/*
+			 * Make sure we use the right service value
+			 * for unwrap/wrap.
+			 */
+			if (client->cl_rawcred.service != gc.gc_svc) {
+				client->cl_rawcred.service = gc.gc_svc;
+				svc_rpc_gss_set_flavor(client);
+			}
+
+			result = AUTH_OK;
+		} else {
+			if (rqst->rq_proc != NULLPROC) {
+				result = AUTH_REJECTEDCRED;
+				break;
+			}
+
+			call_stat = svc_sendreply(rqst,
+			    (xdrproc_t) xdr_void, (caddr_t) NULL);
+
+			if (!call_stat) {
+				result = AUTH_FAILED;
+				break;
+			}
+
+			svc_rpc_gss_forget_client(client);
+
+			result = RPCSEC_GSS_NODISPATCH;
+			break;
+		}
+		break;
+
+	default:
+		result = AUTH_BADCRED;
+		break;
+	}
+out:
+	if (client)
+		svc_rpc_gss_release_client(client);
+
+	xdr_free((xdrproc_t) xdr_rpc_gss_cred, (char *) &gc);
+	return (result);
+}
+
+static bool_t
+svc_rpc_gss_wrap(SVCAUTH *auth, struct mbuf **mp)
+{
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+	
+	rpc_gss_log_debug("in svc_rpc_gss_wrap()");
+
+	cc = (struct svc_rpc_gss_cookedcred *) auth->svc_ah_private;
+	client = cc->cc_client;
+	if (client->cl_state != CLIENT_ESTABLISHED
+	    || cc->cc_service == rpc_gss_svc_none) {
+		return (TRUE);
+	}
+	
+	return (xdr_rpc_gss_wrap_data(mp,
+		client->cl_ctx, client->cl_qop,
+		cc->cc_service, cc->cc_seq));
+}
+
+static bool_t
+svc_rpc_gss_unwrap(SVCAUTH *auth, struct mbuf **mp)
+{
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+
+	rpc_gss_log_debug("in svc_rpc_gss_unwrap()");
+	
+	cc = (struct svc_rpc_gss_cookedcred *) auth->svc_ah_private;
+	client = cc->cc_client;
+	if (client->cl_state != CLIENT_ESTABLISHED
+	    || cc->cc_service == rpc_gss_svc_none) {
+		return (TRUE);
+	}
+
+	return (xdr_rpc_gss_unwrap_data(mp,
+		client->cl_ctx, client->cl_qop,
+		cc->cc_service, cc->cc_seq));
+}
+
+static void
+svc_rpc_gss_release(SVCAUTH *auth)
+{
+	struct svc_rpc_gss_cookedcred *cc;
+	struct svc_rpc_gss_client *client;
+
+	rpc_gss_log_debug("in svc_rpc_gss_release()");
+
+	cc = (struct svc_rpc_gss_cookedcred *) auth->svc_ah_private;
+	client = cc->cc_client;
+	svc_rpc_gss_release_client(client);
+}