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

7 files changed, 903 insertions, 40 deletions

diff --git a/usr.sbin/Makefile b/usr.sbin/Makefile
index 7b10edb..993eb8a 100644
--- a/usr.sbin/Makefile
+++ b/usr.sbin/Makefile
@@ -63,6 +63,7 @@ SUBDIR=	${_ac} \
 	getfmac \
 	getpmac \
 	gstat \
+	${_gssd} \
 	ifmcstat \
 	inetd \
 	iostat \
@@ -256,6 +257,10 @@ _fdwrite=	fdwrite
 _freebsd-update= freebsd-update
 .endif
 
+.if ${MK_GSSAPI} != no
+_gssd=		gssd
+.endif
+
 .if ${MK_INET6} != "no"
 _faithd=	faithd
 _ip6addrctl=	ip6addrctl
diff --git a/usr.sbin/gssd/Makefile b/usr.sbin/gssd/Makefile
new file mode 100644
index 0000000..ffdb5aa
--- /dev/null
+++ b/usr.sbin/gssd/Makefile
@@ -0,0 +1,29 @@
+# $FreeBSD$
+
+PROG=	gssd
+MAN=	gssd.8
+SRCS=	gssd.c gssd_svc.c gssd_xdr.c gssd_prot.c
+
+CFLAGS+= -I.
+WARNS?= 1
+
+DPADD=	${LIBGSSAPI}
+LDADD=	-lgssapi
+
+CLEANFILES= gssd_svc.c gssd.h
+
+RPCSRC=	${.CURDIR}/../../sys/kgssapi/gssd.x
+RPCGEN= rpcgen -L -C -M
+
+gssd_svc.c: ${RPCSRC} gssd.h
+	${RPCGEN} -m -o ${.TARGET} ${RPCSRC}
+
+gssd_xdr.c: ${RPCSRC} gssd.h
+	${RPCGEN} -c -o ${.TARGET} ${RPCSRC}
+
+gssd.h: ${RPCSRC}
+	${RPCGEN} -h -o ${.TARGET} ${RPCSRC}
+
+.PATH:	${.CURDIR}/../../sys/kgssapi
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/gssd/gssd.8 b/usr.sbin/gssd/gssd.8
new file mode 100644
index 0000000..20a9a96
--- /dev/null
+++ b/usr.sbin/gssd/gssd.8
@@ -0,0 +1,70 @@
+.\" Copyright (c) 2008 Isilon Inc http://www.isilon.com/
+.\" Authors: Doug Rabson <dfr@rabson.org>
+.\" Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
+.\"
+.\" 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.
+.\"
+.\" $FreeBSD$
+.\"
+.\" Note: The date here should be updated whenever a non-trivial
+.\" change is made to the manual page.
+.Dd August 25, 2008
+.Dt GSSD 8
+.Os
+.Sh NAME
+.Nm gssd
+.Nd "Generic Security Services Daemon"
+.Sh SYNOPSIS
+.Nm
+.Op Fl d
+.Sh DESCRIPTION
+The
+.Nm
+program provides support for the kernel GSS-API implementation.
+.Pp
+The options are as follows:
+.Bl -tag
+.It Fl d
+Run in debug mode.
+In this mode,
+.Nm
+will not for when it starts.
+.El
+.Sh FILES
+.Bl -tag -width ".Pa /etc/krb5.keytab" -compact
+.It Pa /etc/krb5.keytab
+Contains Kerberos service principals which may be used as credentials
+by kernel GSS-API services.
+.El
+.Sh EXIT STATUS
+.Ex -std
+.Sh SEE ALSO
+.Xr gssapi 3
+.Sh HISTORY
+The
+.Nm
+manual page example first appeared in
+.Fx 8.0 .
+.Sh AUTHORS
+This
+manual page was written by
+.An Doug Rabson Aq dfr@FreeBSD.org .
diff --git a/usr.sbin/gssd/gssd.c b/usr.sbin/gssd/gssd.c
new file mode 100644
index 0000000..ba2805b
--- /dev/null
+++ b/usr.sbin/gssd/gssd.c
@@ -0,0 +1,610 @@
+/*-
+ * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
+ * Authors: Doug Rabson <dfr@rabson.org>
+ * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
+ *
+ * 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/stat.h>
+#include <sys/linker.h>
+#include <sys/module.h>
+#include <sys/queue.h>
+#include <ctype.h>
+#include <err.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <gssapi/gssapi.h>
+#include <rpc/rpc.h>
+#include <rpc/rpc_com.h>
+
+#include "gssd.h"
+
+#ifndef _PATH_GSS_MECH
+#define _PATH_GSS_MECH	"/etc/gss/mech"
+#endif
+#ifndef _PATH_GSSDSOCK
+#define _PATH_GSSDSOCK	"/var/run/gssd.sock"
+#endif
+
+struct gss_resource {
+	LIST_ENTRY(gss_resource) gr_link;
+	uint64_t	gr_id;	/* indentifier exported to kernel */
+	void*		gr_res;	/* GSS-API resource pointer */
+};
+LIST_HEAD(gss_resource_list, gss_resource) gss_resources;
+int gss_resource_count;
+uint32_t gss_next_id;
+uint32_t gss_start_time;
+int debug_level;
+
+static void gssd_load_mech(void);
+
+extern void gssd_1(struct svc_req *rqstp, SVCXPRT *transp);
+extern int gssd_syscall(char *path);
+
+int
+main(int argc, char **argv)
+{
+	/*
+	 * We provide an RPC service on a local-domain socket. The
+	 * kernel's GSS-API code will pass what it can't handle
+	 * directly to us.
+	 */
+	struct sockaddr_un sun;
+	int fd, oldmask, ch, debug;
+	SVCXPRT *xprt;
+
+	debug = 0;
+	while ((ch = getopt(argc, argv, "d")) != -1) {
+		switch (ch) {
+		case 'd':
+			debug_level++;
+			break;
+		default:
+			fprintf(stderr, "usage: %s [-d]\n", argv[0]);
+			exit(1);
+			break;
+		}
+	}
+
+	gssd_load_mech();
+
+	if (!debug_level)
+		daemon(0, 0);
+
+	memset(&sun, 0, sizeof sun);
+	sun.sun_family = AF_LOCAL;
+	unlink(_PATH_GSSDSOCK);
+	strcpy(sun.sun_path, _PATH_GSSDSOCK);
+	sun.sun_len = SUN_LEN(&sun);
+	fd = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (!fd) {
+		err(1, "Can't create local gssd socket");
+	}
+	oldmask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
+	if (bind(fd, (struct sockaddr *) &sun, sun.sun_len) < 0) {
+		err(1, "Can't bind local gssd socket");
+	}
+	umask(oldmask);
+	if (listen(fd, SOMAXCONN) < 0) {
+		err(1, "Can't listen on local gssd socket");
+	}
+	xprt = svc_vc_create(fd, RPC_MAXDATASIZE, RPC_MAXDATASIZE);
+	if (!xprt) {
+		err(1, "Can't create transport for local gssd socket");
+	}
+	if (!svc_reg(xprt, GSSD, GSSDVERS, gssd_1, NULL)) {
+		err(1, "Can't register service for local gssd socket");
+	}
+
+	LIST_INIT(&gss_resources);
+	gss_next_id = 1;
+	gss_start_time = time(0);
+
+	gssd_syscall(_PATH_GSSDSOCK);
+	svc_run();
+
+	return (0);
+}
+
+static void
+gssd_load_mech(void)
+{
+	FILE		*fp;
+	char		buf[256];
+	char		*p;
+	char		*name, *oid, *lib, *kobj;
+
+	fp = fopen(_PATH_GSS_MECH, "r");
+	if (!fp)
+		return;
+
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (*buf == '#')
+			continue;
+		p = buf;
+		name = strsep(&p, "\t\n ");
+		if (p) while (isspace(*p)) p++;
+		oid = strsep(&p, "\t\n ");
+		if (p) while (isspace(*p)) p++;
+		lib = strsep(&p, "\t\n ");
+		if (p) while (isspace(*p)) p++;
+		kobj = strsep(&p, "\t\n ");
+		if (!name || !oid || !lib || !kobj)
+			continue;
+
+		if (strcmp(kobj, "-")) {
+			/*
+			 * Attempt to load the kernel module if its
+			 * not already present.
+			 */
+			if (modfind(kobj) < 0) {
+				if (kldload(kobj) < 0) {
+					fprintf(stderr,
+			"%s: can't find or load kernel module %s for %s\n",
+					    getprogname(), kobj, name);
+				}
+			}
+		}
+	}
+	fclose(fp);
+}
+
+static void *
+gssd_find_resource(uint64_t id)
+{
+	struct gss_resource *gr;
+
+	if (!id)
+		return (NULL);
+
+	LIST_FOREACH(gr, &gss_resources, gr_link)
+		if (gr->gr_id == id)
+			return (gr->gr_res);
+
+	return (NULL);
+}
+
+static uint64_t
+gssd_make_resource(void *res)
+{
+	struct gss_resource *gr;
+
+	if (!res)
+		return (0);
+
+	gr = malloc(sizeof(struct gss_resource));
+	if (!gr)
+		return (0);
+	gr->gr_id = (gss_next_id++) + ((uint64_t) gss_start_time << 32);
+	gr->gr_res = res;
+	LIST_INSERT_HEAD(&gss_resources, gr, gr_link);
+	gss_resource_count++;
+	if (debug_level > 1)
+		printf("%d resources allocated\n", gss_resource_count);
+
+	return (gr->gr_id);
+}
+
+static void
+gssd_delete_resource(uint64_t id)
+{
+	struct gss_resource *gr;
+
+	LIST_FOREACH(gr, &gss_resources, gr_link) {
+		if (gr->gr_id == id) {
+			LIST_REMOVE(gr, gr_link);
+			free(gr);
+			gss_resource_count--;
+			if (debug_level > 1)
+				printf("%d resources allocated\n",
+				    gss_resource_count);
+			return;
+		}
+	}
+}
+
+bool_t
+gssd_null_1_svc(void *argp, void *result, struct svc_req *rqstp)
+{
+
+	return (TRUE);
+}
+
+bool_t
+gssd_init_sec_context_1_svc(init_sec_context_args *argp, init_sec_context_res *result, struct svc_req *rqstp)
+{
+	gss_cred_id_t cred = GSS_C_NO_CREDENTIAL;
+	gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
+	gss_name_t name = GSS_C_NO_NAME;
+	char ccname[strlen("FILE:/tmp/krb5cc_") + 6 + 1];
+
+	snprintf(ccname, sizeof(ccname), "FILE:/tmp/krb5cc_%d",
+	    (int) argp->uid);
+	setenv("KRB5CCNAME", ccname, TRUE);
+
+	memset(result, 0, sizeof(*result));
+	if (argp->cred) {
+		cred = gssd_find_resource(argp->cred);
+		if (!cred) {
+			result->major_status = GSS_S_CREDENTIALS_EXPIRED;
+			return (TRUE);
+		}
+	}
+	if (argp->ctx) {
+		ctx = gssd_find_resource(argp->ctx);
+		if (!ctx) {
+			result->major_status = GSS_S_CONTEXT_EXPIRED;
+			return (TRUE);
+		}
+	}
+	if (argp->name) {
+		name = gssd_find_resource(argp->name);
+		if (!name) {
+			result->major_status = GSS_S_BAD_NAME;
+			return (TRUE);
+		}
+	}
+
+	memset(result, 0, sizeof(*result));
+	result->major_status = gss_init_sec_context(&result->minor_status,
+	    cred, &ctx, name, argp->mech_type,
+	    argp->req_flags, argp->time_req, argp->input_chan_bindings,
+	    &argp->input_token, &result->actual_mech_type,
+	    &result->output_token, &result->ret_flags, &result->time_rec);
+
+	if (result->major_status == GSS_S_COMPLETE
+	    || result->major_status == GSS_S_CONTINUE_NEEDED) {
+		if (argp->ctx)
+			result->ctx = argp->ctx;
+		else
+			result->ctx = gssd_make_resource(ctx);
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_accept_sec_context_1_svc(accept_sec_context_args *argp, accept_sec_context_res *result, struct svc_req *rqstp)
+{
+	gss_ctx_id_t ctx = GSS_C_NO_CONTEXT;
+	gss_cred_id_t cred = GSS_C_NO_CREDENTIAL;
+	gss_name_t src_name;
+	gss_cred_id_t delegated_cred_handle;
+
+	memset(result, 0, sizeof(*result));
+	if (argp->ctx) {
+		ctx = gssd_find_resource(argp->ctx);
+		if (!ctx) {
+			result->major_status = GSS_S_CONTEXT_EXPIRED;
+			return (TRUE);
+		}
+	}
+	if (argp->cred) {
+		cred = gssd_find_resource(argp->cred);
+		if (!cred) {
+			result->major_status = GSS_S_CREDENTIALS_EXPIRED;
+			return (TRUE);
+		}
+	}
+
+	memset(result, 0, sizeof(*result));
+	result->major_status = gss_accept_sec_context(&result->minor_status,
+	    &ctx, cred, &argp->input_token, argp->input_chan_bindings,
+	    &src_name, &result->mech_type, &result->output_token,
+	    &result->ret_flags, &result->time_rec,
+	    &delegated_cred_handle);
+
+	if (result->major_status == GSS_S_COMPLETE
+	    || result->major_status == GSS_S_CONTINUE_NEEDED) {
+		if (argp->ctx)
+			result->ctx = argp->ctx;
+		else
+			result->ctx = gssd_make_resource(ctx);
+		result->src_name = gssd_make_resource(src_name);
+		result->delegated_cred_handle =
+			gssd_make_resource(delegated_cred_handle);
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_delete_sec_context_1_svc(delete_sec_context_args *argp, delete_sec_context_res *result, struct svc_req *rqstp)
+{
+	gss_ctx_id_t ctx = gssd_find_resource(argp->ctx);
+
+	if (ctx) {
+		result->major_status = gss_delete_sec_context(
+			&result->minor_status, &ctx, &result->output_token);
+		gssd_delete_resource(argp->ctx);
+	} else {
+		result->major_status = GSS_S_COMPLETE;
+		result->minor_status = 0;
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_export_sec_context_1_svc(export_sec_context_args *argp, export_sec_context_res *result, struct svc_req *rqstp)
+{
+	gss_ctx_id_t ctx = gssd_find_resource(argp->ctx);
+
+	if (ctx) {
+		result->major_status = gss_export_sec_context(
+			&result->minor_status, &ctx,
+			&result->interprocess_token);
+		result->format = KGSS_HEIMDAL_1_1;
+		gssd_delete_resource(argp->ctx);
+	} else {
+		result->major_status = GSS_S_FAILURE;
+		result->minor_status = 0;
+		result->interprocess_token.length = 0;
+		result->interprocess_token.value = NULL;
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_import_name_1_svc(import_name_args *argp, import_name_res *result, struct svc_req *rqstp)
+{
+	gss_name_t name;
+
+	result->major_status = gss_import_name(&result->minor_status,
+	    &argp->input_name_buffer, argp->input_name_type, &name);
+
+	if (result->major_status == GSS_S_COMPLETE)
+		result->output_name = gssd_make_resource(name);
+	else
+		result->output_name = 0;
+
+	return (TRUE);
+}
+
+bool_t
+gssd_canonicalize_name_1_svc(canonicalize_name_args *argp, canonicalize_name_res *result, struct svc_req *rqstp)
+{
+	gss_name_t name = gssd_find_resource(argp->input_name);
+	gss_name_t output_name;
+
+	memset(result, 0, sizeof(*result));
+	if (!name) {
+		result->major_status = GSS_S_BAD_NAME;
+		return (TRUE);
+	}
+
+	result->major_status = gss_canonicalize_name(&result->minor_status,
+	    name, argp->mech_type, &output_name);
+
+	if (result->major_status == GSS_S_COMPLETE)
+		result->output_name = gssd_make_resource(output_name);
+	else
+		result->output_name = 0;
+
+	return (TRUE);
+}
+
+bool_t
+gssd_export_name_1_svc(export_name_args *argp, export_name_res *result, struct svc_req *rqstp)
+{
+	gss_name_t name = gssd_find_resource(argp->input_name);
+
+	memset(result, 0, sizeof(*result));
+	if (!name) {
+		result->major_status = GSS_S_BAD_NAME;
+		return (TRUE);
+	}
+
+	result->major_status = gss_export_name(&result->minor_status,
+	    name, &result->exported_name);
+
+	return (TRUE);
+}
+
+bool_t
+gssd_release_name_1_svc(release_name_args *argp, release_name_res *result, struct svc_req *rqstp)
+{
+	gss_name_t name = gssd_find_resource(argp->input_name);
+
+	if (name) {
+		result->major_status = gss_release_name(&result->minor_status,
+		    &name);
+		gssd_delete_resource(argp->input_name);
+	} else {
+		result->major_status = GSS_S_COMPLETE;
+		result->minor_status = 0;
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_pname_to_uid_1_svc(pname_to_uid_args *argp, pname_to_uid_res *result, struct svc_req *rqstp)
+{
+	gss_name_t name = gssd_find_resource(argp->pname);
+	uid_t uid;
+	char buf[128];
+	struct passwd pwd, *pw;
+
+	memset(result, 0, sizeof(*result));
+	if (name) {
+		result->major_status =
+			gss_pname_to_uid(&result->minor_status,
+			    name, argp->mech, &uid);
+		if (result->major_status == GSS_S_COMPLETE) {
+			result->uid = uid;
+			getpwuid_r(uid, &pwd, buf, sizeof(buf), &pw);
+			if (pw) {
+				int len = NGRPS;
+				int groups[NGRPS];
+				result->gid = pw->pw_gid;
+				getgrouplist(pw->pw_name, pw->pw_gid,
+				    groups, &len);
+				result->gidlist.gidlist_len = len;
+				result->gidlist.gidlist_val =
+					mem_alloc(len * sizeof(int));
+				memcpy(result->gidlist.gidlist_val, groups,
+				    len * sizeof(int));
+			} else {
+				result->gid = 65534;
+				result->gidlist.gidlist_len = 0;
+				result->gidlist.gidlist_val = NULL;
+			}
+		}
+	} else {
+		result->major_status = GSS_S_BAD_NAME;
+		result->minor_status = 0;
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_acquire_cred_1_svc(acquire_cred_args *argp, acquire_cred_res *result, struct svc_req *rqstp)
+{
+	gss_name_t desired_name = GSS_C_NO_NAME;
+	gss_cred_id_t cred;
+	char ccname[strlen("FILE:/tmp/krb5cc_") + 6 + 1];
+
+	snprintf(ccname, sizeof(ccname), "FILE:/tmp/krb5cc_%d",
+	    (int) argp->uid);
+	setenv("KRB5CCNAME", ccname, TRUE);
+
+	memset(result, 0, sizeof(*result));
+	if (argp->desired_name) {
+		desired_name = gssd_find_resource(argp->desired_name);
+		if (!desired_name) {
+			result->major_status = GSS_S_BAD_NAME;
+			return (TRUE);
+		}
+	}
+
+	result->major_status = gss_acquire_cred(&result->minor_status,
+	    desired_name, argp->time_req, argp->desired_mechs,
+	    argp->cred_usage, &cred, &result->actual_mechs, &result->time_rec);
+
+	if (result->major_status == GSS_S_COMPLETE)
+		result->output_cred = gssd_make_resource(cred);
+	else
+		result->output_cred = 0;
+
+	return (TRUE);
+}
+
+bool_t
+gssd_set_cred_option_1_svc(set_cred_option_args *argp, set_cred_option_res *result, struct svc_req *rqstp)
+{
+	gss_cred_id_t cred = gssd_find_resource(argp->cred);
+
+	memset(result, 0, sizeof(*result));
+	if (!cred) {
+		result->major_status = GSS_S_CREDENTIALS_EXPIRED;
+		return (TRUE);
+	}
+
+	result->major_status = gss_set_cred_option(&result->minor_status,
+	    &cred, argp->option_name, &argp->option_value);
+
+	return (TRUE);
+}
+
+bool_t
+gssd_release_cred_1_svc(release_cred_args *argp, release_cred_res *result, struct svc_req *rqstp)
+{
+	gss_cred_id_t cred = gssd_find_resource(argp->cred);
+
+	if (cred) {
+		result->major_status = gss_release_cred(&result->minor_status,
+		    &cred);
+		gssd_delete_resource(argp->cred);
+	} else {
+		result->major_status = GSS_S_COMPLETE;
+		result->minor_status = 0;
+	}
+
+	return (TRUE);
+}
+
+bool_t
+gssd_display_status_1_svc(display_status_args *argp, display_status_res *result, struct svc_req *rqstp)
+{
+
+	result->message_context = argp->message_context;
+	result->major_status = gss_display_status(&result->minor_status,
+	    argp->status_value, argp->status_type, argp->mech_type,
+	    &result->message_context, &result->status_string);
+
+	return (TRUE);
+}
+
+int
+gssd_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+	/*
+	 * We don't use XDR to free the results - anything which was
+	 * allocated came from GSS-API. We use xdr_result to figure
+	 * out what to do.
+	 */
+	OM_uint32 junk;
+
+	if (xdr_result == (xdrproc_t) xdr_init_sec_context_res) {
+		init_sec_context_res *p = (init_sec_context_res *) result;
+		gss_release_buffer(&junk, &p->output_token);
+	} else if (xdr_result == (xdrproc_t) xdr_accept_sec_context_res) {
+		accept_sec_context_res *p = (accept_sec_context_res *) result;
+		gss_release_buffer(&junk, &p->output_token);
+	} else if (xdr_result == (xdrproc_t) xdr_delete_sec_context_res) {
+		delete_sec_context_res *p = (delete_sec_context_res *) result;
+		gss_release_buffer(&junk, &p->output_token);
+	} else if (xdr_result == (xdrproc_t) xdr_export_sec_context_res) {
+		export_sec_context_res *p = (export_sec_context_res *) result;
+		if (p->interprocess_token.length)
+			memset(p->interprocess_token.value, 0,
+			    p->interprocess_token.length);
+		gss_release_buffer(&junk, &p->interprocess_token);
+	} else if (xdr_result == (xdrproc_t) xdr_export_name_res) {
+		export_name_res *p = (export_name_res *) result;
+		gss_release_buffer(&junk, &p->exported_name);
+	} else if (xdr_result == (xdrproc_t) xdr_acquire_cred_res) {
+		acquire_cred_res *p = (acquire_cred_res *) result;
+		gss_release_oid_set(&junk, &p->actual_mechs);
+	} else if (xdr_result == (xdrproc_t) xdr_pname_to_uid_res) {
+		pname_to_uid_res *p = (pname_to_uid_res *) result;
+		if (p->gidlist.gidlist_val)
+			free(p->gidlist.gidlist_val);
+	} else if (xdr_result == (xdrproc_t) xdr_display_status_res) {
+		display_status_res *p = (display_status_res *) result;
+		gss_release_buffer(&junk, &p->status_string);
+	}
+
+	return (TRUE);
+}
diff --git a/usr.sbin/mountd/exports.5 b/usr.sbin/mountd/exports.5
index f04b6b1..dca4f2d 100644
--- a/usr.sbin/mountd/exports.5
+++ b/usr.sbin/mountd/exports.5
@@ -149,6 +149,17 @@ option is given,
 all users (including root) will be mapped to that credential in
 place of their own.
 .Pp
+.Sm off
+.Fl sec Li = Sy flavor1:flavor2...
+.Sm on
+specifies a colon separated list of acceptable security flavors to be
+used for remote access.
+Supported security flavors are sys, krb5, krb5i and krb5p.
+If multiple flavors are listed, they should be ordered with the most
+preferred flavor first.
+If this option is not present,
+the default security flavor list of just sys is used.
+.Pp
 The
 .Fl ro
 option specifies that the file system should be exported read-only
@@ -305,6 +316,8 @@ the default remote mount-point file
 /u2 -maproot=root friends
 /u2 -alldirs -network cis-net -mask cis-mask
 /cdrom -alldirs,quiet,ro -network 192.168.33.0 -mask 255.255.255.0
+/private -sec=krb5i
+/secret -sec=krb5p
 .Ed
 .Pp
 Given that
@@ -411,6 +424,15 @@ While there is no CD-ROM medium mounted under
 it would export the (normally empty) directory
 .Pa /cdrom
 of the root file system instead.
+.Pp
+The file system rooted at
+.Pa /private
+will be exported using Kerberos 5 authentication and will require
+integrity protected messages for all accesses.
+The file system rooted at
+.Pa /secret
+will also be exported using Kerberos 5 authentication and all messages
+used to access it will be encrypted.
 .Sh SEE ALSO
 .Xr netgroup 5 ,
 .Xr mountd 8 ,
diff --git a/usr.sbin/mountd/mountd.c b/usr.sbin/mountd/mountd.c
index fbcb4ec..82ab1b8 100644
--- a/usr.sbin/mountd/mountd.c
+++ b/usr.sbin/mountd/mountd.c
@@ -113,6 +113,8 @@ struct exportlist {
 	fsid_t		ex_fs;
 	char		*ex_fsdir;
 	char		*ex_indexfile;
+	int		ex_numsecflavors;
+	int		ex_secflavors[MAXSECFLAVORS];
 };
 /* ex_flag bits */
 #define	EX_LINKED	0x1
@@ -150,6 +152,8 @@ struct fhreturn {
 	int	fhr_flag;
 	int	fhr_vers;
 	nfsfh_t	fhr_fh;
+	int	fhr_numsecflavors;
+	int	*fhr_secflavors;
 };
 
 /* Global defs */
@@ -240,6 +244,7 @@ struct pidfh *pfh = NULL;
 #define	OP_HAVEMASK	0x80	/* A mask was specified or inferred. */
 #define	OP_QUIET	0x100
 #define OP_MASKLEN	0x200
+#define OP_SEC		0x400
 
 #ifdef DEBUG
 int debug = 1;
@@ -817,6 +822,8 @@ mntsrv(rqstp, transp)
 				sigprocmask(SIG_UNBLOCK, &sighup_mask, NULL);
 				return;
 			}
+			fhr.fhr_numsecflavors = ep->ex_numsecflavors;
+			fhr.fhr_secflavors = ep->ex_secflavors;
 			if (!svc_sendreply(transp, (xdrproc_t)xdr_fhs,
 			    (caddr_t)&fhr))
 				syslog(LOG_ERR, "can't send reply");
@@ -934,6 +941,7 @@ xdr_fhs(xdrsp, cp)
 {
 	struct fhreturn *fhrp = (struct fhreturn *)cp;
 	u_long ok = 0, len, auth;
+	int i;
 
 	if (!xdr_long(xdrsp, &ok))
 		return (0);
@@ -946,11 +954,20 @@ xdr_fhs(xdrsp, cp)
 			return (0);
 		if (!xdr_opaque(xdrsp, (caddr_t)&fhrp->fhr_fh, len))
 			return (0);
-		auth = RPCAUTH_UNIX;
-		len = 1;
-		if (!xdr_long(xdrsp, &len))
-			return (0);
-		return (xdr_long(xdrsp, &auth));
+		if (fhrp->fhr_numsecflavors) {
+			if (!xdr_int(xdrsp, &fhrp->fhr_numsecflavors))
+				return (0);
+			for (i = 0; i < fhrp->fhr_numsecflavors; i++)
+				if (!xdr_int(xdrsp, &fhrp->fhr_secflavors[i]))
+					return (0);
+			return (1);
+		} else {
+			auth = AUTH_SYS;
+			len = 1;
+			if (!xdr_long(xdrsp, &len))
+				return (0);
+			return (xdr_long(xdrsp, &auth));
+		}
 	};
 	return (0);
 }
@@ -1765,6 +1782,57 @@ free_dir(dp)
 }
 
 /*
+ * Parse a colon separated list of security flavors
+ */
+int
+parsesec(seclist, ep)
+	char *seclist;
+	struct exportlist *ep;
+{
+	char *cp, savedc;
+	int flavor;
+
+	ep->ex_numsecflavors = 0;
+	for (;;) {
+		cp = strchr(seclist, ':');
+		if (cp) {
+			savedc = *cp;
+			*cp = '\0';
+		}
+
+		if (!strcmp(seclist, "sys"))
+			flavor = AUTH_SYS;
+		else if (!strcmp(seclist, "krb5"))
+			flavor = RPCSEC_GSS_KRB5;
+		else if (!strcmp(seclist, "krb5i"))
+			flavor = RPCSEC_GSS_KRB5I;
+		else if (!strcmp(seclist, "krb5p"))
+			flavor = RPCSEC_GSS_KRB5P;
+		else {
+			if (cp)
+				*cp = savedc;
+			syslog(LOG_ERR, "bad sec flavor: %s", seclist);
+			return (1);
+		}
+		if (ep->ex_numsecflavors == MAXSECFLAVORS) {
+			if (cp)
+				*cp = savedc;
+			syslog(LOG_ERR, "too many sec flavors: %s", seclist);
+			return (1);
+		}
+		ep->ex_secflavors[ep->ex_numsecflavors] = flavor;
+		ep->ex_numsecflavors++;
+		if (cp) {
+			*cp = savedc;
+			seclist = cp + 1;
+		} else {
+			break;
+		}
+	}
+	return (0);
+}
+
+/*
  * Parse the option string and update fields.
  * Option arguments may either be -<option>=<value> or
  * -<option> <value>
@@ -1859,6 +1927,11 @@ do_opt(cpp, endcpp, ep, grp, has_hostp, exflagsp, cr)
 			ep->ex_indexfile = strdup(cpoptarg);
 		} else if (!strcmp(cpopt, "quiet")) {
 			opt_flags |= OP_QUIET;
+		} else if (!strcmp(cpopt, "sec")) {
+			if (parsesec(cpoptarg, ep))
+				return (1);
+			opt_flags |= OP_SEC;
+			usedarg++;
 		} else {
 			syslog(LOG_ERR, "bad opt %s", cpopt);
 			return (1);
@@ -2018,7 +2091,7 @@ do_mount(struct exportlist *ep, struct grouplist *grp, int exflags,
 	int done;
 	char savedc;
 	struct iovec *iov;
-	int iovlen;
+	int i, iovlen;
 	int ret;
 
 	cp = NULL;
@@ -2036,6 +2109,13 @@ do_mount(struct exportlist *ep, struct grouplist *grp, int exflags,
 		ai = grp->gr_ptr.gt_addrinfo;
 	else
 		ai = NULL;
+	eap.ex_numsecflavors = ep->ex_numsecflavors;
+	for (i = 0; i < eap.ex_numsecflavors; i++)
+		eap.ex_secflavors[i] = ep->ex_secflavors[i];
+	if (eap.ex_numsecflavors == 0) {
+		eap.ex_numsecflavors = 1;
+		eap.ex_secflavors[0] = AUTH_SYS;
+	}
 	done = FALSE;
 
 	build_iovec(&iov, &iovlen, "fstype", NULL, 0);
diff --git a/usr.sbin/nfsd/nfsd.c b/usr.sbin/nfsd/nfsd.c
index 09795ec8..788d1c2 100644
--- a/usr.sbin/nfsd/nfsd.c
+++ b/usr.sbin/nfsd/nfsd.c
@@ -81,6 +81,7 @@ int	debug = 0;
 #define	DEFNFSDCNT	 4
 pid_t	children[MAXNFSDCNT];	/* PIDs of children */
 int	nfsdcnt;		/* number of children */
+int	new_syscall;
 
 void	cleanup(int);
 void	child_cleanup(int);
@@ -116,7 +117,7 @@ void	usage(void);
 int
 main(int argc, char **argv)
 {
-	struct nfsd_args nfsdargs;
+	struct nfsd_addsock_args addsockargs;
 	struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints;
 	struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6;
 	struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6;
@@ -326,23 +327,54 @@ main(int argc, char **argv)
 
 	openlog("nfsd", LOG_PID, LOG_DAEMON);
 
-	/* If we use UDP only, we start the last server below. */
-	srvcnt = tcpflag ? nfsdcnt : nfsdcnt - 1;
-	for (i = 0; i < srvcnt; i++) {
-		switch ((pid = fork())) {
-		case -1:
+	/*
+	 * Figure out if the kernel supports the new-style
+	 * NFSSVC_NFSD. Old kernels will return ENXIO because they
+	 * don't recognise the flag value, new ones will return EINVAL
+	 * because argp is NULL.
+	 */
+	new_syscall = FALSE;
+	if (nfssvc(NFSSVC_NFSD, NULL) < 0 && errno == EINVAL)
+		new_syscall = TRUE;
+	new_syscall = FALSE;
+
+	if (!new_syscall) {
+		/* If we use UDP only, we start the last server below. */
+		srvcnt = tcpflag ? nfsdcnt : nfsdcnt - 1;
+		for (i = 0; i < srvcnt; i++) {
+			switch ((pid = fork())) {
+			case -1:
+				syslog(LOG_ERR, "fork: %m");
+				nfsd_exit(1);
+			case 0:
+				break;
+			default:
+				children[i] = pid;
+				continue;
+			}
+			(void)signal(SIGUSR1, child_cleanup);
+			setproctitle("server");
+
+			start_server(0);
+		}
+	} else if (tcpflag) {
+		/*
+		 * For TCP mode, we fork once to start the first
+		 * kernel nfsd thread. The kernel will add more
+		 * threads as needed.
+		 */
+		pid = fork();
+		if (pid == -1) {
 			syslog(LOG_ERR, "fork: %m");
 			nfsd_exit(1);
-		case 0:
-			break;
-		default:
-			children[i] = pid;
-			continue;
 		}
-		(void)signal(SIGUSR1, child_cleanup);
-		setproctitle("server");
-
-		start_server(0);
+		if (pid) {
+			children[0] = pid;
+		} else {
+			(void)signal(SIGUSR1, child_cleanup);
+			setproctitle("server");
+			start_server(0);
+		}
 	}
 
 	(void)signal(SIGUSR1, cleanup);
@@ -378,10 +410,10 @@ main(int argc, char **argv)
 					nfsd_exit(1);
 				}
 				freeaddrinfo(ai_udp);
-				nfsdargs.sock = sock;
-				nfsdargs.name = NULL;
-				nfsdargs.namelen = 0;
-				if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) {
+				addsockargs.sock = sock;
+				addsockargs.name = NULL;
+				addsockargs.namelen = 0;
+				if (nfssvc(NFSSVC_ADDSOCK, &addsockargs) < 0) {
 					syslog(LOG_ERR, "can't Add UDP socket");
 					nfsd_exit(1);
 				}
@@ -446,10 +478,10 @@ main(int argc, char **argv)
 					nfsd_exit(1);
 				}
 				freeaddrinfo(ai_udp6);
-				nfsdargs.sock = sock;
-				nfsdargs.name = NULL;
-				nfsdargs.namelen = 0;
-				if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) {
+				addsockargs.sock = sock;
+				addsockargs.name = NULL;
+				addsockargs.namelen = 0;
+				if (nfssvc(NFSSVC_ADDSOCK, &addsockargs) < 0) {
 					syslog(LOG_ERR,
 					    "can't add UDP6 socket");
 					nfsd_exit(1);
@@ -676,10 +708,10 @@ main(int argc, char **argv)
 					    SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0)
 						syslog(LOG_ERR,
 						    "setsockopt SO_KEEPALIVE: %m");
-					nfsdargs.sock = msgsock;
-					nfsdargs.name = (caddr_t)&inetpeer;
-					nfsdargs.namelen = len;
-					nfssvc(NFSSVC_ADDSOCK, &nfsdargs);
+					addsockargs.sock = msgsock;
+					addsockargs.name = (caddr_t)&inetpeer;
+					addsockargs.namelen = len;
+					nfssvc(NFSSVC_ADDSOCK, &addsockargs);
 					(void)close(msgsock);
 				} else if (FD_ISSET(tcpsock, &v6bits)) {
 					len = sizeof(inet6peer);
@@ -698,10 +730,10 @@ main(int argc, char **argv)
 					    sizeof(on)) < 0)
 						syslog(LOG_ERR, "setsockopt "
 						    "SO_KEEPALIVE: %m");
-					nfsdargs.sock = msgsock;
-					nfsdargs.name = (caddr_t)&inet6peer;
-					nfsdargs.namelen = len;
-					nfssvc(NFSSVC_ADDSOCK, &nfsdargs);
+					addsockargs.sock = msgsock;
+					addsockargs.name = (caddr_t)&inet6peer;
+					addsockargs.namelen = len;
+					nfssvc(NFSSVC_ADDSOCK, &addsockargs);
 					(void)close(msgsock);
 				}
 			}
@@ -829,12 +861,27 @@ nfsd_exit(int status)
 void
 start_server(int master)
 {
+	char principal[128];
+	char hostname[128];
+	struct nfsd_nfsd_args nfsdargs;
 	int status;
 
 	status = 0;
-	if (nfssvc(NFSSVC_NFSD, NULL) < 0) {
-		syslog(LOG_ERR, "nfssvc: %m");
-		status = 1;
+	if (new_syscall) {
+		gethostname(hostname, sizeof(hostname));
+		snprintf(principal, sizeof(principal), "nfs@%s", hostname);
+		nfsdargs.principal = principal;
+		nfsdargs.minthreads = nfsdcnt;
+		nfsdargs.maxthreads = nfsdcnt;
+		if (nfssvc(NFSSVC_NFSD, &nfsdargs) < 0) {
+			syslog(LOG_ERR, "nfssvc: %m");
+			status = 1;
+		}
+	} else {
+		if (nfssvc(NFSSVC_OLDNFSD, NULL) < 0) {
+			syslog(LOG_ERR, "nfssvc: %m");
+			status = 1;
+		}
 	}
 	if (master)
 		nfsd_exit(status);