1603c8667SAlfred Perlstein /*- 2603c8667SAlfred Perlstein * Copyright (c) 1997 Berkeley Software Design, Inc. All rights reserved. 3603c8667SAlfred Perlstein * 4603c8667SAlfred Perlstein * Redistribution and use in source and binary forms, with or without 5603c8667SAlfred Perlstein * modification, are permitted provided that the following conditions 6603c8667SAlfred Perlstein * are met: 7603c8667SAlfred Perlstein * 1. Redistributions of source code must retain the above copyright 8603c8667SAlfred Perlstein * notice, this list of conditions and the following disclaimer. 9603c8667SAlfred Perlstein * 2. Redistributions in binary form must reproduce the above copyright 10603c8667SAlfred Perlstein * notice, this list of conditions and the following disclaimer in the 11603c8667SAlfred Perlstein * documentation and/or other materials provided with the distribution. 12603c8667SAlfred Perlstein * 3. Berkeley Software Design Inc's name may not be used to endorse or 13603c8667SAlfred Perlstein * promote products derived from this software without specific prior 14603c8667SAlfred Perlstein * written permission. 15603c8667SAlfred Perlstein * 16603c8667SAlfred Perlstein * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND 17603c8667SAlfred Perlstein * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18603c8667SAlfred Perlstein * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19603c8667SAlfred Perlstein * ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE 20603c8667SAlfred Perlstein * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21603c8667SAlfred Perlstein * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22603c8667SAlfred Perlstein * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23603c8667SAlfred Perlstein * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24603c8667SAlfred Perlstein * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25603c8667SAlfred Perlstein * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26603c8667SAlfred Perlstein * SUCH DAMAGE. 27603c8667SAlfred Perlstein * 28603c8667SAlfred Perlstein * from BSDI kern.c,v 1.2 1998/11/25 22:38:27 don Exp 29603c8667SAlfred Perlstein * $FreeBSD$ 30603c8667SAlfred Perlstein */ 31603c8667SAlfred Perlstein 32603c8667SAlfred Perlstein #include <sys/param.h> 33603c8667SAlfred Perlstein #include <sys/mount.h> 34603c8667SAlfred Perlstein #include <sys/queue.h> 35603c8667SAlfred Perlstein #include <sys/socket.h> 36603c8667SAlfred Perlstein #include <sys/stat.h> 37603c8667SAlfred Perlstein 38603c8667SAlfred Perlstein #include <err.h> 39603c8667SAlfred Perlstein #include <errno.h> 40603c8667SAlfred Perlstein #include <fcntl.h> 41603c8667SAlfred Perlstein #include <stdio.h> 42603c8667SAlfred Perlstein #include <stdlib.h> 43603c8667SAlfred Perlstein #include <string.h> 44603c8667SAlfred Perlstein #include <syslog.h> 45603c8667SAlfred Perlstein #include <unistd.h> 46603c8667SAlfred Perlstein 47603c8667SAlfred Perlstein #include "nlm_prot.h" 4891196234SPeter Wemm #include <nfs/rpcv2.h> 4991196234SPeter Wemm #include <nfs/nfsproto.h> 5091196234SPeter Wemm #include <nfsclient/nfs_lock.h> 51603c8667SAlfred Perlstein 52603c8667SAlfred Perlstein #include "lockd.h" 53603c8667SAlfred Perlstein #include "lockd_lock.h" 5491196234SPeter Wemm #include <nfsclient/nfs.h> 55603c8667SAlfred Perlstein 56603c8667SAlfred Perlstein #define nfslockdans(_v, _ansp) \ 57603c8667SAlfred Perlstein ((_ansp)->la_vers = _v, \ 5891196234SPeter Wemm nfsclnt(NFSCLNT_LOCKDANS, _ansp)) 59603c8667SAlfred Perlstein 60603c8667SAlfred Perlstein /* Lock request owner. */ 61603c8667SAlfred Perlstein typedef struct __owner { 62603c8667SAlfred Perlstein pid_t pid; /* Process ID. */ 63603c8667SAlfred Perlstein time_t tod; /* Time-of-day. */ 64603c8667SAlfred Perlstein } OWNER; 65603c8667SAlfred Perlstein static OWNER owner; 66603c8667SAlfred Perlstein 67603c8667SAlfred Perlstein static char hostname[MAXHOSTNAMELEN + 1]; /* Hostname. */ 68603c8667SAlfred Perlstein 69603c8667SAlfred Perlstein int lock_request(LOCKD_MSG *); 70603c8667SAlfred Perlstein int test_request(LOCKD_MSG *); 71603c8667SAlfred Perlstein void show(LOCKD_MSG *); 72603c8667SAlfred Perlstein int unlock_request(LOCKD_MSG *); 73603c8667SAlfred Perlstein 74603c8667SAlfred Perlstein /* 75603c8667SAlfred Perlstein * will break because fifo needs to be repopened when EOF'd 76603c8667SAlfred Perlstein */ 77603c8667SAlfred Perlstein #ifdef SETUID_DAEMON 78603c8667SAlfred Perlstein #define lockd_seteuid(uid) seteuid(uid) 79603c8667SAlfred Perlstein #else 80603c8667SAlfred Perlstein #define lockd_seteuid(uid) (1) 81603c8667SAlfred Perlstein #endif 82603c8667SAlfred Perlstein 835f8568ecSAlfred Perlstein #define d_calls (debug_level > 1) 845f8568ecSAlfred Perlstein #define d_args (debug_level > 2) 855f8568ecSAlfred Perlstein 865f8568ecSAlfred Perlstein #define from_addr(sockaddr) \ 875f8568ecSAlfred Perlstein (inet_ntoa((sockaddr)->sin_addr)) 88603c8667SAlfred Perlstein 89603c8667SAlfred Perlstein void 90603c8667SAlfred Perlstein client_cleanup(sig, code) 91603c8667SAlfred Perlstein int sig; 92603c8667SAlfred Perlstein int code; 93603c8667SAlfred Perlstein { 94603c8667SAlfred Perlstein (void)lockd_seteuid(0); 95603c8667SAlfred Perlstein (void)unlink(_PATH_LCKFIFO); 96603c8667SAlfred Perlstein exit(-1); 97603c8667SAlfred Perlstein } 98603c8667SAlfred Perlstein 99603c8667SAlfred Perlstein /* 100603c8667SAlfred Perlstein * client_request -- 101603c8667SAlfred Perlstein * Loop around messages from the kernel, forwarding them off to 102603c8667SAlfred Perlstein * NLM servers. 103603c8667SAlfred Perlstein */ 104603c8667SAlfred Perlstein pid_t 105603c8667SAlfred Perlstein client_request(void) 106603c8667SAlfred Perlstein { 107603c8667SAlfred Perlstein LOCKD_MSG msg; 108603c8667SAlfred Perlstein fd_set rdset; 109603c8667SAlfred Perlstein int fd, nr, ret; 110603c8667SAlfred Perlstein pid_t child; 111603c8667SAlfred Perlstein 112603c8667SAlfred Perlstein /* Recreate the NLM fifo. */ 113603c8667SAlfred Perlstein (void)unlink(_PATH_LCKFIFO); 114603c8667SAlfred Perlstein (void)umask(S_IXGRP|S_IXOTH); 115603c8667SAlfred Perlstein if (mkfifo(_PATH_LCKFIFO, S_IWUSR | S_IRUSR)) { 116603c8667SAlfred Perlstein syslog(LOG_ERR, "mkfifo: %s: %m", _PATH_LCKFIFO); 117603c8667SAlfred Perlstein exit (1); 118603c8667SAlfred Perlstein } 119603c8667SAlfred Perlstein 120603c8667SAlfred Perlstein /* 121603c8667SAlfred Perlstein * Create a separate process, the client code is really a separate 122603c8667SAlfred Perlstein * daemon that shares a lot of code. 123603c8667SAlfred Perlstein */ 124603c8667SAlfred Perlstein switch (child = fork()) { 125603c8667SAlfred Perlstein case -1: 126603c8667SAlfred Perlstein err(1, "fork"); 127603c8667SAlfred Perlstein case 0: 128603c8667SAlfred Perlstein break; 129603c8667SAlfred Perlstein default: 130603c8667SAlfred Perlstein return (child); 131603c8667SAlfred Perlstein } 132603c8667SAlfred Perlstein 133603c8667SAlfred Perlstein signal(SIGHUP, client_cleanup); 134603c8667SAlfred Perlstein signal(SIGTERM, client_cleanup); 135603c8667SAlfred Perlstein 136603c8667SAlfred Perlstein /* Setup. */ 137603c8667SAlfred Perlstein (void)time(&owner.tod); 138603c8667SAlfred Perlstein owner.pid = getpid(); 139603c8667SAlfred Perlstein (void)gethostname(hostname, sizeof(hostname) - 1); 140603c8667SAlfred Perlstein 141603c8667SAlfred Perlstein reopen: 142603c8667SAlfred Perlstein /* Open the fifo for reading. */ 143603c8667SAlfred Perlstein if ((fd = open(_PATH_LCKFIFO, O_RDONLY /* | O_NONBLOCK */)) < 0) 144603c8667SAlfred Perlstein syslog(LOG_ERR, "open: %s: %m", _PATH_LCKFIFO); 145603c8667SAlfred Perlstein 146603c8667SAlfred Perlstein /* drop our root priviledges */ 147603c8667SAlfred Perlstein (void)lockd_seteuid(daemon_uid); 148603c8667SAlfred Perlstein 149603c8667SAlfred Perlstein /* Set up the select. */ 150603c8667SAlfred Perlstein FD_ZERO(&rdset); 151603c8667SAlfred Perlstein 152603c8667SAlfred Perlstein for (;;) { 153603c8667SAlfred Perlstein /* Wait for contact... fifo's return EAGAIN when read with 154603c8667SAlfred Perlstein * no data 155603c8667SAlfred Perlstein */ 156603c8667SAlfred Perlstein FD_SET(fd, &rdset); 157603c8667SAlfred Perlstein (void)select(fd + 1, &rdset, NULL, NULL, NULL); 158603c8667SAlfred Perlstein 159603c8667SAlfred Perlstein /* Read the fixed length message. */ 160603c8667SAlfred Perlstein if ((nr = read(fd, &msg, sizeof(msg))) == sizeof(msg)) { 161603c8667SAlfred Perlstein if (d_args) 162603c8667SAlfred Perlstein show(&msg); 163603c8667SAlfred Perlstein 164603c8667SAlfred Perlstein if (msg.lm_version != LOCKD_MSG_VERSION) { 165603c8667SAlfred Perlstein syslog(LOG_ERR, 166603c8667SAlfred Perlstein "unknown msg type: %d", msg.lm_version); 167603c8667SAlfred Perlstein } 168603c8667SAlfred Perlstein /* 169603c8667SAlfred Perlstein * Send it to the NLM server and don't grant the lock 170603c8667SAlfred Perlstein * if we fail for any reason. 171603c8667SAlfred Perlstein */ 172603c8667SAlfred Perlstein switch (msg.lm_fl.l_type) { 173603c8667SAlfred Perlstein case F_RDLCK: 174603c8667SAlfred Perlstein case F_WRLCK: 175603c8667SAlfred Perlstein if (msg.lm_getlk) 176603c8667SAlfred Perlstein ret = test_request(&msg); 177603c8667SAlfred Perlstein else 178603c8667SAlfred Perlstein ret = lock_request(&msg); 179603c8667SAlfred Perlstein break; 180603c8667SAlfred Perlstein case F_UNLCK: 181603c8667SAlfred Perlstein ret = unlock_request(&msg); 182603c8667SAlfred Perlstein break; 183603c8667SAlfred Perlstein default: 184603c8667SAlfred Perlstein ret = 1; 185603c8667SAlfred Perlstein syslog(LOG_ERR, 186603c8667SAlfred Perlstein "unknown lock type: %d", msg.lm_fl.l_type); 187603c8667SAlfred Perlstein break; 188603c8667SAlfred Perlstein } 189603c8667SAlfred Perlstein if (ret) { 190603c8667SAlfred Perlstein struct lockd_ans ans; 191603c8667SAlfred Perlstein 192603c8667SAlfred Perlstein ans.la_msg_ident = msg.lm_msg_ident; 193603c8667SAlfred Perlstein ans.la_errno = EHOSTUNREACH; 194603c8667SAlfred Perlstein 195603c8667SAlfred Perlstein if (nfslockdans(LOCKD_ANS_VERSION, &ans)) { 196603c8667SAlfred Perlstein syslog((errno == EPIPE ? LOG_INFO : 197603c8667SAlfred Perlstein LOG_ERR), "process %lu: %m", 198603c8667SAlfred Perlstein (u_long)msg.lm_msg_ident.pid); 199603c8667SAlfred Perlstein } 200603c8667SAlfred Perlstein } 201603c8667SAlfred Perlstein } else if (nr == -1) { 202603c8667SAlfred Perlstein if (errno != EAGAIN) { 203603c8667SAlfred Perlstein syslog(LOG_ERR, "read: %s: %m", _PATH_LCKFIFO); 204603c8667SAlfred Perlstein goto err; 205603c8667SAlfred Perlstein } 206603c8667SAlfred Perlstein } else if (nr != 0) { 207603c8667SAlfred Perlstein syslog(LOG_ERR, 208603c8667SAlfred Perlstein "%s: discard %d bytes", _PATH_LCKFIFO, nr); 209603c8667SAlfred Perlstein } if (nr == 0) { 210603c8667SAlfred Perlstein close (fd); 211603c8667SAlfred Perlstein goto reopen; 212603c8667SAlfred Perlstein } 213603c8667SAlfred Perlstein } 214603c8667SAlfred Perlstein 215603c8667SAlfred Perlstein /* Reached only on error. */ 216603c8667SAlfred Perlstein err: 217603c8667SAlfred Perlstein (void)lockd_seteuid(0); 218603c8667SAlfred Perlstein (void)unlink(_PATH_LCKFIFO); 219603c8667SAlfred Perlstein _exit (1); 220603c8667SAlfred Perlstein } 221603c8667SAlfred Perlstein 222603c8667SAlfred Perlstein void 223603c8667SAlfred Perlstein set_auth( 224603c8667SAlfred Perlstein CLIENT *cl, 225603c8667SAlfred Perlstein struct ucred *ucred 226603c8667SAlfred Perlstein ) 227603c8667SAlfred Perlstein { 228603c8667SAlfred Perlstein if (cl->cl_auth != NULL) 229603c8667SAlfred Perlstein cl->cl_auth->ah_ops->ah_destroy(cl->cl_auth); 230603c8667SAlfred Perlstein cl->cl_auth = authunix_create(hostname, 231603c8667SAlfred Perlstein ucred->cr_uid, 232603c8667SAlfred Perlstein ucred->cr_groups[0], 233603c8667SAlfred Perlstein ucred->cr_ngroups-1, 234603c8667SAlfred Perlstein &ucred->cr_groups[1]); 235603c8667SAlfred Perlstein } 236603c8667SAlfred Perlstein 237603c8667SAlfred Perlstein 238603c8667SAlfred Perlstein /* 239603c8667SAlfred Perlstein * test_request -- 240603c8667SAlfred Perlstein * Convert a lock LOCKD_MSG into an NLM request, and send it off. 241603c8667SAlfred Perlstein */ 242603c8667SAlfred Perlstein int 243603c8667SAlfred Perlstein test_request(LOCKD_MSG *msg) 244603c8667SAlfred Perlstein { 245603c8667SAlfred Perlstein CLIENT *cli; 246603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 247603c8667SAlfred Perlstein char dummy; 248603c8667SAlfred Perlstein 249603c8667SAlfred Perlstein if (d_calls) 250603c8667SAlfred Perlstein syslog(LOG_DEBUG, "test request: %s: %s to %s", 251603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 252603c8667SAlfred Perlstein msg->lm_fl.l_type == F_WRLCK ? "write" : "read", 253603c8667SAlfred Perlstein from_addr((struct sockaddr_in *)&msg->lm_addr)); 254603c8667SAlfred Perlstein 255603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 256603c8667SAlfred Perlstein struct nlm4_testargs arg4; 257603c8667SAlfred Perlstein 258603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 259603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 260603c8667SAlfred Perlstein arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 261603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 262603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 263603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 264603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 265603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 266603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 267603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 268603c8667SAlfred Perlstein arg4.alock.l_len = msg->lm_fl.l_len; 269603c8667SAlfred Perlstein 270603c8667SAlfred Perlstein if ((cli = get_client( 271603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 272603c8667SAlfred Perlstein NLM_VERS4)) == NULL) 273603c8667SAlfred Perlstein return (1); 274603c8667SAlfred Perlstein 275603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 276603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_TEST_MSG, 277603c8667SAlfred Perlstein xdr_nlm4_testargs, &arg4, xdr_void, &dummy, timeout); 278603c8667SAlfred Perlstein } else { 279603c8667SAlfred Perlstein struct nlm_testargs arg; 280603c8667SAlfred Perlstein 281603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 282603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 283603c8667SAlfred Perlstein arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 284603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 285603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 286603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 287603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 288603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 289603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 290603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 291603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 292603c8667SAlfred Perlstein 293603c8667SAlfred Perlstein if ((cli = get_client( 294603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 295603c8667SAlfred Perlstein NLM_VERS)) == NULL) 296603c8667SAlfred Perlstein return (1); 297603c8667SAlfred Perlstein 298603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 299603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_TEST_MSG, 300603c8667SAlfred Perlstein xdr_nlm_testargs, &arg, xdr_void, &dummy, timeout); 301603c8667SAlfred Perlstein } 302603c8667SAlfred Perlstein return (0); 303603c8667SAlfred Perlstein } 304603c8667SAlfred Perlstein 305603c8667SAlfred Perlstein /* 306603c8667SAlfred Perlstein * lock_request -- 307603c8667SAlfred Perlstein * Convert a lock LOCKD_MSG into an NLM request, and send it off. 308603c8667SAlfred Perlstein */ 309603c8667SAlfred Perlstein int 310603c8667SAlfred Perlstein lock_request(LOCKD_MSG *msg) 311603c8667SAlfred Perlstein { 312603c8667SAlfred Perlstein CLIENT *cli; 313603c8667SAlfred Perlstein struct nlm4_lockargs arg4; 314603c8667SAlfred Perlstein struct nlm_lockargs arg; 315603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 316603c8667SAlfred Perlstein char dummy; 317603c8667SAlfred Perlstein 318603c8667SAlfred Perlstein if (d_calls) 319603c8667SAlfred Perlstein syslog(LOG_DEBUG, "lock request: %s: %s to %s", 320603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 321603c8667SAlfred Perlstein msg->lm_fl.l_type == F_WRLCK ? "write" : "read", 322603c8667SAlfred Perlstein from_addr((struct sockaddr_in *)&msg->lm_addr)); 323603c8667SAlfred Perlstein 324603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 325603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 326603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 327603c8667SAlfred Perlstein arg4.block = msg->lm_wait ? 1 : 0; 328603c8667SAlfred Perlstein arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 329603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 330603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 331603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 332603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 333603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 334603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 335603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 336603c8667SAlfred Perlstein arg4.alock.l_len = msg->lm_fl.l_len; 337603c8667SAlfred Perlstein arg4.reclaim = 0; 338603c8667SAlfred Perlstein arg4.state = nsm_state; 339603c8667SAlfred Perlstein 340603c8667SAlfred Perlstein if ((cli = get_client( 341603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 342603c8667SAlfred Perlstein NLM_VERS4)) == NULL) 343603c8667SAlfred Perlstein return (1); 344603c8667SAlfred Perlstein 345603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 346603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_LOCK_MSG, 347603c8667SAlfred Perlstein xdr_nlm4_lockargs, &arg4, xdr_void, &dummy, timeout); 348603c8667SAlfred Perlstein } else { 349603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 350603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 351603c8667SAlfred Perlstein arg.block = msg->lm_wait ? 1 : 0; 352603c8667SAlfred Perlstein arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 353603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 354603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 355603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 356603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 357603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 358603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 359603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 360603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 361603c8667SAlfred Perlstein arg.reclaim = 0; 362603c8667SAlfred Perlstein arg.state = nsm_state; 363603c8667SAlfred Perlstein 364603c8667SAlfred Perlstein if ((cli = get_client( 365603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 366603c8667SAlfred Perlstein NLM_VERS)) == NULL) 367603c8667SAlfred Perlstein return (1); 368603c8667SAlfred Perlstein 369603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 370603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_LOCK_MSG, 371603c8667SAlfred Perlstein xdr_nlm_lockargs, &arg, xdr_void, &dummy, timeout); 372603c8667SAlfred Perlstein } 373603c8667SAlfred Perlstein return (0); 374603c8667SAlfred Perlstein } 375603c8667SAlfred Perlstein 376603c8667SAlfred Perlstein /* 377603c8667SAlfred Perlstein * unlock_request -- 378603c8667SAlfred Perlstein * Convert an unlock LOCKD_MSG into an NLM request, and send it off. 379603c8667SAlfred Perlstein */ 380603c8667SAlfred Perlstein int 381603c8667SAlfred Perlstein unlock_request(LOCKD_MSG *msg) 382603c8667SAlfred Perlstein { 383603c8667SAlfred Perlstein CLIENT *cli; 384603c8667SAlfred Perlstein struct nlm4_unlockargs arg4; 385603c8667SAlfred Perlstein struct nlm_unlockargs arg; 386603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 387603c8667SAlfred Perlstein char dummy; 388603c8667SAlfred Perlstein 389603c8667SAlfred Perlstein if (d_calls) 390603c8667SAlfred Perlstein syslog(LOG_DEBUG, "unlock request: %s: to %s", 391603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 392603c8667SAlfred Perlstein from_addr((struct sockaddr_in *)&msg->lm_addr)); 393603c8667SAlfred Perlstein 394603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 395603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 396603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 397603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 398603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 399603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 400603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 401603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 402603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 403603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 404603c8667SAlfred Perlstein arg4.alock.l_len = msg->lm_fl.l_len; 405603c8667SAlfred Perlstein 406603c8667SAlfred Perlstein if ((cli = get_client( 407603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 408603c8667SAlfred Perlstein NLM_VERS4)) == NULL) 409603c8667SAlfred Perlstein return (1); 410603c8667SAlfred Perlstein 411603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 412603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_UNLOCK_MSG, 413603c8667SAlfred Perlstein xdr_nlm4_unlockargs, &arg4, xdr_void, &dummy, timeout); 414603c8667SAlfred Perlstein } else { 415603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 416603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 417603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 418603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 419603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 420603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 421603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 422603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 423603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 424603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 425603c8667SAlfred Perlstein 426603c8667SAlfred Perlstein if ((cli = get_client( 427603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 428603c8667SAlfred Perlstein NLM_VERS)) == NULL) 429603c8667SAlfred Perlstein return (1); 430603c8667SAlfred Perlstein 431603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 432603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_UNLOCK_MSG, 433603c8667SAlfred Perlstein xdr_nlm_unlockargs, &arg, xdr_void, &dummy, timeout); 434603c8667SAlfred Perlstein } 435603c8667SAlfred Perlstein 436603c8667SAlfred Perlstein return (0); 437603c8667SAlfred Perlstein } 438603c8667SAlfred Perlstein 439603c8667SAlfred Perlstein int 440603c8667SAlfred Perlstein lock_answer(int pid, netobj *netcookie, int result, int *pid_p, int version) 441603c8667SAlfred Perlstein { 442603c8667SAlfred Perlstein struct lockd_ans ans; 443603c8667SAlfred Perlstein 444603c8667SAlfred Perlstein if (netcookie->n_len != sizeof(ans.la_msg_ident)) { 445603c8667SAlfred Perlstein if (pid == -1) { /* we're screwed */ 446603c8667SAlfred Perlstein syslog(LOG_ERR, "inedible nlm cookie"); 447603c8667SAlfred Perlstein return -1; 448603c8667SAlfred Perlstein } 449603c8667SAlfred Perlstein ans.la_msg_ident.pid = pid; 450603c8667SAlfred Perlstein ans.la_msg_ident.msg_seq = -1; 451603c8667SAlfred Perlstein } else { 452603c8667SAlfred Perlstein memcpy(&ans.la_msg_ident, netcookie->n_bytes, 453603c8667SAlfred Perlstein sizeof(ans.la_msg_ident)); 454603c8667SAlfred Perlstein } 455603c8667SAlfred Perlstein 456603c8667SAlfred Perlstein if (d_calls) 4575f8568ecSAlfred Perlstein syslog(LOG_DEBUG, "lock answer: pid %lu: %s %d", 4585f8568ecSAlfred Perlstein ans.la_msg_ident.pid, 4595f8568ecSAlfred Perlstein version == NLM_VERS4 ? "nlmv4" : "nlmv3", 4605f8568ecSAlfred Perlstein result); 461603c8667SAlfred Perlstein 462603c8667SAlfred Perlstein ans.la_set_getlk_pid = 0; 463603c8667SAlfred Perlstein if (version == NLM_VERS4) 464603c8667SAlfred Perlstein switch (result) { 465603c8667SAlfred Perlstein case nlm4_granted: 466603c8667SAlfred Perlstein ans.la_errno = 0; 467603c8667SAlfred Perlstein break; 468603c8667SAlfred Perlstein default: 469603c8667SAlfred Perlstein ans.la_errno = EACCES; 470603c8667SAlfred Perlstein break; 471603c8667SAlfred Perlstein case nlm4_denied: 472603c8667SAlfred Perlstein if (pid_p == NULL) 473603c8667SAlfred Perlstein ans.la_errno = EACCES; 474603c8667SAlfred Perlstein else { 475603c8667SAlfred Perlstein /* this is an answer to a nlm_test msg */ 476603c8667SAlfred Perlstein ans.la_set_getlk_pid = 1; 477603c8667SAlfred Perlstein ans.la_getlk_pid = *pid_p; 478603c8667SAlfred Perlstein ans.la_errno = 0; 479603c8667SAlfred Perlstein } 480603c8667SAlfred Perlstein break; 481603c8667SAlfred Perlstein case nlm4_denied_nolocks: 482603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 483603c8667SAlfred Perlstein break; 484603c8667SAlfred Perlstein case nlm4_blocked: 485603c8667SAlfred Perlstein return -1; 486603c8667SAlfred Perlstein /* NOTREACHED */ 487603c8667SAlfred Perlstein case nlm4_denied_grace_period: 488603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 489603c8667SAlfred Perlstein break; 490603c8667SAlfred Perlstein case nlm4_deadlck: 491603c8667SAlfred Perlstein ans.la_errno = EDEADLK; 492603c8667SAlfred Perlstein break; 493603c8667SAlfred Perlstein case nlm4_rofs: 494603c8667SAlfred Perlstein ans.la_errno = EROFS; 495603c8667SAlfred Perlstein break; 496603c8667SAlfred Perlstein case nlm4_stale_fh: 497603c8667SAlfred Perlstein ans.la_errno = ESTALE; 498603c8667SAlfred Perlstein break; 499603c8667SAlfred Perlstein case nlm4_fbig: 500603c8667SAlfred Perlstein ans.la_errno = EFBIG; 501603c8667SAlfred Perlstein break; 502603c8667SAlfred Perlstein case nlm4_failed: 503603c8667SAlfred Perlstein ans.la_errno = EACCES; 504603c8667SAlfred Perlstein break; 505603c8667SAlfred Perlstein } 506603c8667SAlfred Perlstein else 507603c8667SAlfred Perlstein switch (result) { 508603c8667SAlfred Perlstein case nlm_granted: 509603c8667SAlfred Perlstein ans.la_errno = 0; 510603c8667SAlfred Perlstein break; 511603c8667SAlfred Perlstein default: 512603c8667SAlfred Perlstein ans.la_errno = EACCES; 513603c8667SAlfred Perlstein break; 514603c8667SAlfred Perlstein case nlm_denied: 515603c8667SAlfred Perlstein if (pid_p == NULL) 516603c8667SAlfred Perlstein ans.la_errno = EACCES; 517603c8667SAlfred Perlstein else { 518603c8667SAlfred Perlstein /* this is an answer to a nlm_test msg */ 519603c8667SAlfred Perlstein ans.la_set_getlk_pid = 1; 520603c8667SAlfred Perlstein ans.la_getlk_pid = *pid_p; 521603c8667SAlfred Perlstein ans.la_errno = 0; 522603c8667SAlfred Perlstein } 523603c8667SAlfred Perlstein break; 524603c8667SAlfred Perlstein case nlm_denied_nolocks: 525603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 526603c8667SAlfred Perlstein break; 527603c8667SAlfred Perlstein case nlm_blocked: 528603c8667SAlfred Perlstein return -1; 529603c8667SAlfred Perlstein /* NOTREACHED */ 530603c8667SAlfred Perlstein case nlm_denied_grace_period: 531603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 532603c8667SAlfred Perlstein break; 533603c8667SAlfred Perlstein case nlm_deadlck: 534603c8667SAlfred Perlstein ans.la_errno = EDEADLK; 535603c8667SAlfred Perlstein break; 536603c8667SAlfred Perlstein } 537603c8667SAlfred Perlstein 538603c8667SAlfred Perlstein if (nfslockdans(LOCKD_ANS_VERSION, &ans)) { 539603c8667SAlfred Perlstein syslog(((errno == EPIPE || errno == ESRCH) ? 540603c8667SAlfred Perlstein LOG_INFO : LOG_ERR), 541603c8667SAlfred Perlstein "process %lu: %m", (u_long)ans.la_msg_ident.pid); 542603c8667SAlfred Perlstein return -1; 543603c8667SAlfred Perlstein } 544603c8667SAlfred Perlstein return 0; 545603c8667SAlfred Perlstein } 546603c8667SAlfred Perlstein 547603c8667SAlfred Perlstein /* 548603c8667SAlfred Perlstein * show -- 549603c8667SAlfred Perlstein * Display the contents of a kernel LOCKD_MSG structure. 550603c8667SAlfred Perlstein */ 551603c8667SAlfred Perlstein void 552603c8667SAlfred Perlstein show(LOCKD_MSG *mp) 553603c8667SAlfred Perlstein { 554603c8667SAlfred Perlstein static char hex[] = "0123456789abcdef"; 555603c8667SAlfred Perlstein struct fid *fidp; 556603c8667SAlfred Perlstein fsid_t *fsidp; 557603c8667SAlfred Perlstein size_t len; 558603c8667SAlfred Perlstein u_int8_t *p, *t, buf[NFS_SMALLFH*3+1]; 559603c8667SAlfred Perlstein 560603c8667SAlfred Perlstein printf("process ID: %lu\n", (long)mp->lm_msg_ident.pid); 561603c8667SAlfred Perlstein 562603c8667SAlfred Perlstein fsidp = (fsid_t *)&mp->lm_fh; 563603c8667SAlfred Perlstein fidp = (struct fid *)((u_int8_t *)&mp->lm_fh + sizeof(fsid_t)); 564603c8667SAlfred Perlstein 565603c8667SAlfred Perlstein for (t = buf, p = (u_int8_t *)mp->lm_fh, 566603c8667SAlfred Perlstein len = mp->lm_fh_len; 567603c8667SAlfred Perlstein len > 0; ++p, --len) { 568603c8667SAlfred Perlstein *t++ = '\\'; 569603c8667SAlfred Perlstein *t++ = hex[(*p & 0xf0) >> 4]; 570603c8667SAlfred Perlstein *t++ = hex[*p & 0x0f]; 571603c8667SAlfred Perlstein } 572603c8667SAlfred Perlstein *t = '\0'; 573603c8667SAlfred Perlstein 574603c8667SAlfred Perlstein printf("fh_len %d, fh %s\n", mp->lm_fh_len, buf); 575603c8667SAlfred Perlstein 576603c8667SAlfred Perlstein /* Show flock structure. */ 577603c8667SAlfred Perlstein printf("start %qu; len %qu; pid %lu; type %d; whence %d\n", 578603c8667SAlfred Perlstein mp->lm_fl.l_start, mp->lm_fl.l_len, (u_long)mp->lm_fl.l_pid, 579603c8667SAlfred Perlstein mp->lm_fl.l_type, mp->lm_fl.l_whence); 580603c8667SAlfred Perlstein 581603c8667SAlfred Perlstein /* Show wait flag. */ 582603c8667SAlfred Perlstein printf("wait was %s\n", mp->lm_wait ? "set" : "not set"); 583603c8667SAlfred Perlstein } 584