Implement client side NFS locks.

Obtained from: BSD/os
Import Ok'd by: mckusick, jkh, motd on builder.freebsd.org

6 files changed, 672 insertions, 9 deletions

diff --git a/usr.sbin/rpc.lockd/Makefile b/usr.sbin/rpc.lockd/Makefile
index 6f089b4..2e8aa47 100644
--- a/usr.sbin/rpc.lockd/Makefile
+++ b/usr.sbin/rpc.lockd/Makefile
@@ -2,11 +2,11 @@
 #	$NetBSD: Makefile,v 1.12 2000/08/07 16:23:31 thorpej Exp $
 
 PROG=	rpc.lockd
-SRCS=	nlm_prot_svc.c lockd.c lock_proc.c lockd_lock.c
+SRCS=	kern.c nlm_prot_svc.c lockd.c lock_proc.c lockd_lock.c
 MAN=	rpc.lockd.8
 MLINKS=	rpc.lockd.8 lockd.8
 
-CFLAGS+= -I. -I${DESTDIR}/usr/include/rpcsvc
+CFLAGS+= -I. -I${DESTDIR}/usr/include/rpcsvc -g
 
 DPADD=	${LIBRPCSVC} ${LIBUTIL}
 LDADD=	-lrpcsvc -lutil
diff --git a/usr.sbin/rpc.lockd/kern.c b/usr.sbin/rpc.lockd/kern.c
new file mode 100644
index 0000000..59f035d
--- /dev/null
+++ b/usr.sbin/rpc.lockd/kern.c
@@ -0,0 +1,586 @@
+/*-
+ * Copyright (c) 1997 Berkeley Software Design, Inc. 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.
+ * 3. Berkeley Software Design Inc's name may not be used to endorse or
+ *    promote products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``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 BERKELEY SOFTWARE DESIGN INC 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.
+ *
+ *      from BSDI kern.c,v 1.2 1998/11/25 22:38:27 don Exp
+ * $FreeBSD$
+ */
+
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/queue.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <unistd.h>
+
+#include "nlm_prot.h"
+#include "nfs/nfs_lock.h"
+
+#include "lockd.h"
+#include "lockd_lock.h"
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfs/nfs.h>
+
+#define nfslockdans(_v, _ansp)	\
+	((_ansp)->la_vers = _v, \
+	nfssvc(NFSSVC_LOCKDANS, _ansp))
+
+/* Lock request owner. */
+typedef struct __owner {
+	pid_t	 pid;				/* Process ID. */
+	time_t	 tod;				/* Time-of-day. */
+} OWNER;
+static OWNER owner;
+
+static char hostname[MAXHOSTNAMELEN + 1];	/* Hostname. */
+
+int	lock_request(LOCKD_MSG *);
+int	test_request(LOCKD_MSG *);
+void	show(LOCKD_MSG *);
+int	unlock_request(LOCKD_MSG *);
+
+/*
+ * will break because fifo needs to be repopened when EOF'd
+ */
+#ifdef SETUID_DAEMON
+#define lockd_seteuid(uid)	seteuid(uid)
+#else
+#define lockd_seteuid(uid)	(1)
+#endif
+
+#define d_calls 0
+#define d_args 0
+
+void
+client_cleanup(sig, code)
+	int sig;
+	int code;
+{
+	(void)lockd_seteuid(0);
+	(void)unlink(_PATH_LCKFIFO);
+	exit(-1);
+}
+
+/*
+ * client_request --
+ *	Loop around messages from the kernel, forwarding them off to
+ *	NLM servers.
+ */
+pid_t
+client_request(void)
+{
+	LOCKD_MSG msg;
+	fd_set rdset;
+	int fd, nr, ret;
+	pid_t child;
+
+	/* Recreate the NLM fifo. */
+	(void)unlink(_PATH_LCKFIFO);
+	(void)umask(S_IXGRP|S_IXOTH);
+	if (mkfifo(_PATH_LCKFIFO, S_IWUSR | S_IRUSR)) {
+		syslog(LOG_ERR, "mkfifo: %s: %m", _PATH_LCKFIFO);
+		exit (1);
+	}
+#define linebug syslog(LOG_ERR, "lockd: %d", __LINE__);
+linebug
+
+	/*
+	 * Create a separate process, the client code is really a separate
+	 * daemon that shares a lot of code.
+	 */
+	switch (child = fork()) {
+	case -1:
+		err(1, "fork");
+	case 0:
+		break;
+	default:
+		return (child);
+	}
+
+linebug
+	signal(SIGHUP, client_cleanup);
+	signal(SIGTERM, client_cleanup);
+
+	/* Setup. */
+	(void)time(&owner.tod);
+	owner.pid = getpid();
+	(void)gethostname(hostname, sizeof(hostname) - 1);
+
+linebug
+reopen:
+	/* Open the fifo for reading. */
+	if ((fd = open(_PATH_LCKFIFO, O_RDONLY /* | O_NONBLOCK */)) < 0)
+		syslog(LOG_ERR, "open: %s: %m", _PATH_LCKFIFO);
+
+	/* drop our root priviledges */
+	(void)lockd_seteuid(daemon_uid);
+
+	/* Set up the select. */
+	FD_ZERO(&rdset);
+
+	for (;;) {
+linebug
+		/* Wait for contact... fifo's return EAGAIN when read with 
+		 * no data
+		 */
+		FD_SET(fd, &rdset);
+		(void)select(fd + 1, &rdset, NULL, NULL, NULL);
+
+linebug
+		/* Read the fixed length message. */
+		if ((nr = read(fd, &msg, sizeof(msg))) == sizeof(msg)) {
+			if (d_args)
+				show(&msg);
+
+			if (msg.lm_version != LOCKD_MSG_VERSION) {
+				syslog(LOG_ERR,
+				    "unknown msg type: %d", msg.lm_version);
+			}
+			/*
+			 * Send it to the NLM server and don't grant the lock
+			 * if we fail for any reason.
+			 */
+			switch (msg.lm_fl.l_type) {
+			case F_RDLCK:
+			case F_WRLCK:
+				if (msg.lm_getlk)
+					ret = test_request(&msg);
+				else
+					ret = lock_request(&msg);
+				break;
+			case F_UNLCK:
+				ret = unlock_request(&msg);
+				break;
+			default:
+				ret = 1;
+				syslog(LOG_ERR,
+				    "unknown lock type: %d", msg.lm_fl.l_type);
+				break;
+			}
+			if (ret) {
+				struct lockd_ans ans;
+
+				ans.la_msg_ident = msg.lm_msg_ident;
+				ans.la_errno = EHOSTUNREACH;
+
+				if (nfslockdans(LOCKD_ANS_VERSION, &ans)) {
+					syslog((errno == EPIPE ? LOG_INFO : 
+						LOG_ERR), "process %lu: %m",
+						(u_long)msg.lm_msg_ident.pid);
+				}
+			}
+		} else if (nr == -1) {
+linebug
+			if (errno != EAGAIN) {
+				syslog(LOG_ERR, "read: %s: %m", _PATH_LCKFIFO);
+				goto err;
+			}
+		} else if (nr != 0) {
+			syslog(LOG_ERR,
+			    "%s: discard %d bytes", _PATH_LCKFIFO, nr);
+		} if (nr == 0) {
+			close (fd);
+			goto reopen;
+		}
+	}
+
+	/* Reached only on error. */
+err:
+	(void)lockd_seteuid(0);
+	(void)unlink(_PATH_LCKFIFO);
+	_exit (1);
+}
+
+void
+set_auth(
+	CLIENT *cl,
+	struct ucred *ucred
+)
+{
+        if (cl->cl_auth != NULL)
+                cl->cl_auth->ah_ops->ah_destroy(cl->cl_auth);
+        cl->cl_auth = authunix_create(hostname,
+                        ucred->cr_uid,
+                        ucred->cr_groups[0],
+                        ucred->cr_ngroups-1,
+                        &ucred->cr_groups[1]);
+}
+
+
+/*
+ * test_request --
+ *	Convert a lock LOCKD_MSG into an NLM request, and send it off.
+ */
+int
+test_request(LOCKD_MSG *msg)
+{
+	CLIENT *cli;
+	struct timeval timeout = {0, 0};	/* No timeout, no response. */
+	char dummy;
+
+	if (d_calls)
+		syslog(LOG_DEBUG, "test request: %s: %s to %s",
+		    msg->lm_nfsv3 ? "V4" : "V1/3",
+		    msg->lm_fl.l_type == F_WRLCK ? "write" : "read",
+		    from_addr((struct sockaddr_in *)&msg->lm_addr));
+
+	if (msg->lm_nfsv3) {
+		struct nlm4_testargs arg4;
+
+		arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg4.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0;
+		arg4.alock.caller_name = hostname;
+		arg4.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg4.alock.fh.n_len = msg->lm_fh_len;
+		arg4.alock.oh.n_bytes = (char *)&owner;
+		arg4.alock.oh.n_len = sizeof(owner);
+		arg4.alock.svid = msg->lm_msg_ident.pid;
+		arg4.alock.l_offset = msg->lm_fl.l_start;
+		arg4.alock.l_len = msg->lm_fl.l_len;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS4)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_TEST_MSG,
+		    xdr_nlm4_testargs, &arg4, xdr_void, &dummy, timeout);
+	} else {
+		struct nlm_testargs arg;
+
+		arg.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0;
+		arg.alock.caller_name = hostname;
+		arg.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg.alock.fh.n_len = msg->lm_fh_len;
+		arg.alock.oh.n_bytes = (char *)&owner;
+		arg.alock.oh.n_len = sizeof(owner);
+		arg.alock.svid = msg->lm_msg_ident.pid;
+		arg.alock.l_offset = msg->lm_fl.l_start;
+		arg.alock.l_len = msg->lm_fl.l_len;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_TEST_MSG,
+		    xdr_nlm_testargs, &arg, xdr_void, &dummy, timeout);
+	}
+	return (0);
+}
+
+/*
+ * lock_request --
+ *	Convert a lock LOCKD_MSG into an NLM request, and send it off.
+ */
+int
+lock_request(LOCKD_MSG *msg)
+{
+	CLIENT *cli;
+	struct nlm4_lockargs arg4;
+	struct nlm_lockargs arg;
+	struct timeval timeout = {0, 0};	/* No timeout, no response. */
+	char dummy;
+
+	if (d_calls)
+		syslog(LOG_DEBUG, "lock request: %s: %s to %s",
+		    msg->lm_nfsv3 ? "V4" : "V1/3",
+		    msg->lm_fl.l_type == F_WRLCK ? "write" : "read",
+		    from_addr((struct sockaddr_in *)&msg->lm_addr));
+
+	if (msg->lm_nfsv3) {
+		arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg4.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg4.block = msg->lm_wait ? 1 : 0;
+		arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0;
+		arg4.alock.caller_name = hostname;
+		arg4.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg4.alock.fh.n_len = msg->lm_fh_len;
+		arg4.alock.oh.n_bytes = (char *)&owner;
+		arg4.alock.oh.n_len = sizeof(owner);
+		arg4.alock.svid = msg->lm_msg_ident.pid;
+		arg4.alock.l_offset = msg->lm_fl.l_start;
+		arg4.alock.l_len = msg->lm_fl.l_len;
+		arg4.reclaim = 0;
+		arg4.state = nsm_state;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS4)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_LOCK_MSG,
+		    xdr_nlm4_lockargs, &arg4, xdr_void, &dummy, timeout);
+	} else {
+		arg.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg.block = msg->lm_wait ? 1 : 0;
+		arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0;
+		arg.alock.caller_name = hostname;
+		arg.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg.alock.fh.n_len = msg->lm_fh_len;
+		arg.alock.oh.n_bytes = (char *)&owner;
+		arg.alock.oh.n_len = sizeof(owner);
+		arg.alock.svid = msg->lm_msg_ident.pid;
+		arg.alock.l_offset = msg->lm_fl.l_start;
+		arg.alock.l_len = msg->lm_fl.l_len;
+		arg.reclaim = 0;
+		arg.state = nsm_state;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_LOCK_MSG,
+		    xdr_nlm_lockargs, &arg, xdr_void, &dummy, timeout);
+	}
+	return (0);
+}
+
+/*
+ * unlock_request --
+ *	Convert an unlock LOCKD_MSG into an NLM request, and send it off.
+ */
+int
+unlock_request(LOCKD_MSG *msg)
+{
+	CLIENT *cli;
+	struct nlm4_unlockargs arg4;
+	struct nlm_unlockargs arg;
+	struct timeval timeout = {0, 0};	/* No timeout, no response. */
+	char dummy;
+
+	if (d_calls)
+		syslog(LOG_DEBUG, "unlock request: %s: to %s",
+		    msg->lm_nfsv3 ? "V4" : "V1/3",
+		    from_addr((struct sockaddr_in *)&msg->lm_addr));
+
+	if (msg->lm_nfsv3) {
+		arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg4.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg4.alock.caller_name = hostname;
+		arg4.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg4.alock.fh.n_len = msg->lm_fh_len;
+		arg4.alock.oh.n_bytes = (char *)&owner;
+		arg4.alock.oh.n_len = sizeof(owner);
+		arg4.alock.svid = msg->lm_msg_ident.pid;
+		arg4.alock.l_offset = msg->lm_fl.l_start;
+		arg4.alock.l_len = msg->lm_fl.l_len;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS4)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_UNLOCK_MSG,
+		    xdr_nlm4_unlockargs, &arg4, xdr_void, &dummy, timeout);
+	} else {
+		arg.cookie.n_bytes = (char *)&msg->lm_msg_ident;
+		arg.cookie.n_len = sizeof(msg->lm_msg_ident);
+		arg.alock.caller_name = hostname;
+		arg.alock.fh.n_bytes = (char *)&msg->lm_fh;
+		arg.alock.fh.n_len = msg->lm_fh_len;
+		arg.alock.oh.n_bytes = (char *)&owner;
+		arg.alock.oh.n_len = sizeof(owner);
+		arg.alock.svid = msg->lm_msg_ident.pid;
+		arg.alock.l_offset = msg->lm_fl.l_start;
+		arg.alock.l_len = msg->lm_fl.l_len;
+
+		if ((cli = get_client(
+		    (struct sockaddr *)&msg->lm_addr,
+		    NLM_VERS)) == NULL)
+			return (1);
+
+		set_auth(cli, &msg->lm_cred);
+		(void)clnt_call(cli, NLM_UNLOCK_MSG,
+		    xdr_nlm_unlockargs, &arg, xdr_void, &dummy, timeout);
+	}
+
+	return (0);
+}
+
+int
+lock_answer(int pid, netobj *netcookie, int result, int *pid_p, int version)
+{
+	struct lockd_ans ans;
+
+	if (netcookie->n_len != sizeof(ans.la_msg_ident)) {
+		if (pid == -1) {	/* we're screwed */
+			syslog(LOG_ERR, "inedible nlm cookie");
+			return -1;
+		}
+		ans.la_msg_ident.pid = pid;
+		ans.la_msg_ident.msg_seq = -1;
+	} else {
+		memcpy(&ans.la_msg_ident, netcookie->n_bytes, 
+							sizeof(ans.la_msg_ident));
+	}
+
+	if (d_calls)
+		syslog(LOG_DEBUG, "lock answer: pid %lu: %s",
+		    ans.la_msg_ident.pid, version == NLM_VERS4 ?
+		    show_4state(result) : show_state(result));
+
+	ans.la_set_getlk_pid = 0;
+	if (version == NLM_VERS4)
+		switch (result) {
+		case nlm4_granted:
+			ans.la_errno = 0;
+			break;
+		default:
+			ans.la_errno = EACCES;
+			break;
+		case nlm4_denied:
+			if (pid_p == NULL)
+				ans.la_errno = EACCES;
+			else {
+				/* this is an answer to a nlm_test msg */
+				ans.la_set_getlk_pid = 1;
+				ans.la_getlk_pid = *pid_p;
+				ans.la_errno = 0;
+			}
+			break;
+		case nlm4_denied_nolocks:
+			ans.la_errno = EAGAIN;
+			break;
+		case nlm4_blocked:
+			return -1;
+			/* NOTREACHED */
+		case nlm4_denied_grace_period:
+			ans.la_errno = EAGAIN;
+			break;
+		case nlm4_deadlck:
+			ans.la_errno = EDEADLK;
+			break;
+		case nlm4_rofs:
+			ans.la_errno = EROFS;
+			break;
+		case nlm4_stale_fh:
+			ans.la_errno = ESTALE;
+			break;
+		case nlm4_fbig:
+			ans.la_errno = EFBIG;
+			break;
+		case nlm4_failed:
+			ans.la_errno = EACCES;
+			break;
+		}
+	else
+		switch (result) {
+		case nlm_granted:
+			ans.la_errno = 0;
+			break;
+		default:
+			ans.la_errno = EACCES;
+			break;
+		case nlm_denied:
+			if (pid_p == NULL)
+				ans.la_errno = EACCES;
+			else {
+				/* this is an answer to a nlm_test msg */
+				ans.la_set_getlk_pid = 1;
+				ans.la_getlk_pid = *pid_p;
+				ans.la_errno = 0;
+			}
+			break;
+		case nlm_denied_nolocks:
+			ans.la_errno = EAGAIN;
+			break;
+		case nlm_blocked:
+			return -1;
+			/* NOTREACHED */
+		case nlm_denied_grace_period:
+			ans.la_errno = EAGAIN;
+			break;
+		case nlm_deadlck:
+			ans.la_errno = EDEADLK;
+			break;
+		}
+
+	if (nfslockdans(LOCKD_ANS_VERSION, &ans)) {
+		syslog(((errno == EPIPE || errno == ESRCH) ? 
+			LOG_INFO : LOG_ERR), 
+			"process %lu: %m", (u_long)ans.la_msg_ident.pid);
+		return -1;
+	}
+	return 0;
+}
+
+/*
+ * show --
+ *	Display the contents of a kernel LOCKD_MSG structure.
+ */
+void
+show(LOCKD_MSG *mp)
+{
+	static char hex[] = "0123456789abcdef";
+	struct fid *fidp;
+	fsid_t *fsidp;
+	size_t len;
+	u_int8_t *p, *t, buf[NFS_SMALLFH*3+1];
+
+	printf("process ID: %lu\n", (long)mp->lm_msg_ident.pid);
+
+	fsidp = (fsid_t *)&mp->lm_fh;
+	fidp = (struct fid *)((u_int8_t *)&mp->lm_fh + sizeof(fsid_t));
+
+	for (t = buf, p = (u_int8_t *)mp->lm_fh,
+	    len = mp->lm_fh_len;
+	    len > 0; ++p, --len) {
+		*t++ = '\\';
+		*t++ = hex[(*p & 0xf0) >> 4];
+		*t++ = hex[*p & 0x0f];
+	}
+	*t = '\0';
+
+	printf("fh_len %d, fh %s\n", mp->lm_fh_len, buf);
+
+	/* Show flock structure. */
+	printf("start %qu; len %qu; pid %lu; type %d; whence %d\n",
+	    mp->lm_fl.l_start, mp->lm_fl.l_len, (u_long)mp->lm_fl.l_pid,
+	    mp->lm_fl.l_type, mp->lm_fl.l_whence);
+
+	/* Show wait flag. */
+	printf("wait was %s\n", mp->lm_wait ? "set" : "not set");
+}
diff --git a/usr.sbin/rpc.lockd/lock_proc.c b/usr.sbin/rpc.lockd/lock_proc.c
index 8b08fd0..4dbb6dc 100644
--- a/usr.sbin/rpc.lockd/lock_proc.c
+++ b/usr.sbin/rpc.lockd/lock_proc.c
@@ -634,10 +634,13 @@ nlm_granted_1_svc(arg, rqstp)
 	if (debug_level)
 		log_from_addr("nlm_granted", rqstp);
 
+	res.stat.stat = lock_answer(arg->alock.svid, &arg->cookie,
+		nlm_granted, NULL, NLM_VERS) == 0 ?
+		nlm_granted : nlm_denied;
+
 	/* copy cookie from arg to result.  See comment in nlm_test_1() */
 	res.cookie = arg->cookie;
 
-	res.stat.stat = nlm_granted;
 	return (&res);
 }
 
@@ -670,6 +673,8 @@ nlm_test_res_1_svc(arg, rqstp)
 {
 	if (debug_level)
 		log_from_addr("nlm_test_res", rqstp);
+	(void)lock_answer(-1, &arg->cookie, arg->stat.stat, 
+		&arg->stat.nlm_testrply_u.holder.svid, NLM_VERS);
 	return (NULL);
 }
 
@@ -686,6 +691,8 @@ nlm_lock_res_1_svc(arg, rqstp)
 	if (debug_level)
 		log_from_addr("nlm_lock_res", rqstp);
 
+	(void)lock_answer(-1, &arg->cookie, arg->stat.stat, NULL, NLM_VERS);
+
 	return (NULL);
 }
 
@@ -716,6 +723,9 @@ nlm_unlock_res_1_svc(arg, rqstp)
 {
 	if (debug_level)
 		log_from_addr("nlm_unlock_res", rqstp);
+
+	lock_answer(&arg->cookie, arg->stat.stat, NLM_VERS);
+
 	return (NULL);
 }
 
@@ -1077,10 +1087,13 @@ nlm4_granted_4_svc(arg, rqstp)
 	if (debug_level)
 		log_from_addr("nlm4_granted", rqstp);
 
+	res.stat.stat = lock_answer(arg->alock.svid, &arg->cookie,
+		nlm4_granted, NULL, NLM_VERS4) == 0 ?
+		nlm4_granted : nlm4_denied;
+
 	/* copy cookie from arg to result.  See comment in nlm_test_1() */
 	res.cookie = arg->cookie;
 
-	res.stat.stat = nlm4_granted;
 	return (&res);
 }
 
@@ -1113,6 +1126,10 @@ nlm4_test_res_4_svc(arg, rqstp)
 {
 	if (debug_level)
 		log_from_addr("nlm4_test_res", rqstp);
+
+	(void)lock_answer(-1, &arg->cookie, arg->stat.stat,
+		(int *)&arg->stat.nlm4_testrply_u.holder.svid,
+		NLM_VERS4);
 	return (NULL);
 }
 
@@ -1129,6 +1146,8 @@ nlm4_lock_res_4_svc(arg, rqstp)
 	if (debug_level)
 		log_from_addr("nlm4_lock_res", rqstp);
 
+	(void)lock_answer(-1, &arg->cookie, arg->stat.stat, NULL, NLM_VERS4);
+
 	return (NULL);
 }
 
@@ -1268,7 +1287,7 @@ nlm4_nm_lock_4_svc(arg, rqstp)
  */
 void *
 nlm4_free_all_4_svc(arg, rqstp)
-	nlm_notify *arg;
+	struct nlm4_notify *arg;
 	struct svc_req *rqstp;
 {
 	static char dummy;
diff --git a/usr.sbin/rpc.lockd/lockd.c b/usr.sbin/rpc.lockd/lockd.c
index e0ac5cf..cd08f55 100644
--- a/usr.sbin/rpc.lockd/lockd.c
+++ b/usr.sbin/rpc.lockd/lockd.c
@@ -70,7 +70,11 @@ int		debug_level = 0;	/* 0 = no debugging syslog() calls */
 int		_rpcsvcdirty = 0;
 
 int grace_expired;
+int nsm_state;
+pid_t client_pid;
+struct mon mon_host;
 
+void	init_nsm(void);
 int	main __P((int, char **));
 void	nlm_prog_0 __P((struct svc_req *, SVCXPRT *));
 void	nlm_prog_1 __P((struct svc_req *, SVCXPRT *));
@@ -208,6 +212,10 @@ main(argc, argv)
 		exit(1);
 	}
 
+	init_nsm();
+
+	client_pid = client_request();
+
 	svc_run();		/* Should never return */
 	exit(1);
 }
@@ -224,3 +232,50 @@ usage()
 {
 	errx(1, "usage: rpc.lockd [-d <debuglevel>] [-g <grace period>]");
 }
+
+/*
+ * init_nsm --
+ *	Reset the NSM state-of-the-world and acquire its state.
+ */
+void
+init_nsm(void)
+{
+	enum clnt_stat ret;
+	my_id id;
+	sm_stat stat;
+
+	/*
+	 * !!!
+	 * The my_id structure isn't used by the SM_UNMON_ALL call, as far
+	 * as I know.  Leave it empty for now.
+	 */
+	memset(&id, 0, sizeof(id));
+	id.my_name = "NFS NLM";
+
+	/*
+	 * !!!
+	 * The statd program must already be registered when lockd runs.
+	 */
+	do {
+		ret = callrpc("localhost", SM_PROG, SM_VERS, SM_UNMON_ALL,
+		    xdr_my_id, &id, xdr_sm_stat, &stat);
+		if (ret == RPC_PROGUNAVAIL) {
+			warnx("%lu %s", SM_PROG, clnt_sperrno(ret));
+			sleep(2);
+			continue;
+		}
+		break;
+	} while (0);
+
+	if (ret != 0) {
+		errx(1, "%lu %s", SM_PROG, clnt_sperrno(ret));
+	}
+
+	nsm_state = stat.state;
+
+	/* setup constant data for SM_MON calls */
+	mon_host.mon_id.my_id.my_name = "localhost";
+	mon_host.mon_id.my_id.my_prog = NLM_PROG;
+	mon_host.mon_id.my_id.my_vers = NLM_SM;
+	mon_host.mon_id.my_id.my_proc = NLM_SM_NOTIFY;  /* bsdi addition */
+}
diff --git a/usr.sbin/rpc.lockd/lockd.h b/usr.sbin/rpc.lockd/lockd.h
index 42f14f1..464ac3a 100644
--- a/usr.sbin/rpc.lockd/lockd.h
+++ b/usr.sbin/rpc.lockd/lockd.h
@@ -37,3 +37,6 @@
 extern int	debug_level;
 extern int	grace_expired;
 void sigchild_handler __P((int));
+pid_t	client_request(void);
+extern int nsm_state;
+extern pid_t client_pid;
diff --git a/usr.sbin/rpc.lockd/lockd_lock.c b/usr.sbin/rpc.lockd/lockd_lock.c
index 998a200..7a6c00d 100644
--- a/usr.sbin/rpc.lockd/lockd_lock.c
+++ b/usr.sbin/rpc.lockd/lockd_lock.c
@@ -162,7 +162,7 @@ getlock(lckarg, rqstp, flags)
 		syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
 		/* failed */
 		return (flags & LOCK_V4) ?
-		    nlm4_denied_nolock : nlm_denied_nolocks;
+		    nlm4_denied_nolocks : nlm_denied_nolocks;
 	}
 	if (lckarg->alock.fh.n_len != sizeof(fhandle_t)) {
 		syslog(LOG_DEBUG, "recieved fhandle size %d, local size %d",
@@ -177,7 +177,7 @@ getlock(lckarg, rqstp, flags)
 		syslog(LOG_NOTICE, "malloc failed: %s", strerror(errno));
 		free(newfl);
 		return (flags & LOCK_V4) ?
-		    nlm4_denied_nolock : nlm_denied_nolocks;
+		    nlm4_denied_nolocks : nlm_denied_nolocks;
 	}
 	newfl->client.oh.n_len = lckarg->alock.oh.n_len;
 	memcpy(newfl->client.oh.n_bytes, lckarg->alock.oh.n_bytes,
@@ -191,7 +191,7 @@ getlock(lckarg, rqstp, flags)
 		free(newfl->client.oh.n_bytes);
 		free(newfl);
 		return (flags & LOCK_V4) ? 
-		    nlm4_denied_nolock : nlm_denied_nolocks;
+		    nlm4_denied_nolocks : nlm_denied_nolocks;
 	}
 	memcpy(newfl->client_cookie.n_bytes, lckarg->cookie.n_bytes,
 	    lckarg->cookie.n_len);
@@ -462,7 +462,7 @@ do_lock(fl, block)
 			LIST_REMOVE(fl, lcklst);
 			close(fl->fd);
 			return (fl->flags & LOCK_V4) ?
-			    nlm4_denied_nolock : nlm_denied_nolocks;
+			    nlm4_denied_nolocks : nlm_denied_nolocks;
 		case 0:
 			/*
 			 * Attempt a blocking lock. Will have to call