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 */ 30603c8667SAlfred Perlstein 317838f9ddSPhilippe Charnier #include <sys/cdefs.h> 327838f9ddSPhilippe Charnier __FBSDID("$FreeBSD$"); 337838f9ddSPhilippe Charnier 34603c8667SAlfred Perlstein #include <sys/param.h> 35603c8667SAlfred Perlstein #include <sys/mount.h> 36603c8667SAlfred Perlstein #include <sys/queue.h> 37603c8667SAlfred Perlstein #include <sys/socket.h> 38603c8667SAlfred Perlstein #include <sys/stat.h> 39603c8667SAlfred Perlstein 40755f5b77SAlfred Perlstein #include <netinet/in.h> 41755f5b77SAlfred Perlstein #include <arpa/inet.h> 42755f5b77SAlfred Perlstein 43603c8667SAlfred Perlstein #include <err.h> 44603c8667SAlfred Perlstein #include <errno.h> 45603c8667SAlfred Perlstein #include <fcntl.h> 460cbf6231SPoul-Henning Kamp #include <paths.h> 4732e9a249SAlfred Perlstein #include <pwd.h> 48603c8667SAlfred Perlstein #include <stdio.h> 49603c8667SAlfred Perlstein #include <stdlib.h> 50603c8667SAlfred Perlstein #include <string.h> 51603c8667SAlfred Perlstein #include <syslog.h> 52603c8667SAlfred Perlstein #include <unistd.h> 5309ce4f7aSAlfred Perlstein #include <netdb.h> 54603c8667SAlfred Perlstein 55603c8667SAlfred Perlstein #include "nlm_prot.h" 5691196234SPeter Wemm #include <nfs/rpcv2.h> 5791196234SPeter Wemm #include <nfs/nfsproto.h> 5891196234SPeter Wemm #include <nfsclient/nfs_lock.h> 59603c8667SAlfred Perlstein 60603c8667SAlfred Perlstein #include "lockd.h" 61603c8667SAlfred Perlstein #include "lockd_lock.h" 6291196234SPeter Wemm #include <nfsclient/nfs.h> 63603c8667SAlfred Perlstein 6432e9a249SAlfred Perlstein #define DAEMON_USERNAME "daemon" 6532e9a249SAlfred Perlstein 66603c8667SAlfred Perlstein /* Lock request owner. */ 67603c8667SAlfred Perlstein typedef struct __owner { 68603c8667SAlfred Perlstein pid_t pid; /* Process ID. */ 69603c8667SAlfred Perlstein time_t tod; /* Time-of-day. */ 70603c8667SAlfred Perlstein } OWNER; 71603c8667SAlfred Perlstein static OWNER owner; 72603c8667SAlfred Perlstein 73603c8667SAlfred Perlstein static char hostname[MAXHOSTNAMELEN + 1]; /* Hostname. */ 747838f9ddSPhilippe Charnier static int devfd; 75603c8667SAlfred Perlstein 76755f5b77SAlfred Perlstein static void client_cleanup(void); 777838f9ddSPhilippe Charnier static const char *from_addr(struct sockaddr *); 78603c8667SAlfred Perlstein int lock_request(LOCKD_MSG *); 797838f9ddSPhilippe Charnier static void set_auth(CLIENT *cl, struct xucred *ucred); 80603c8667SAlfred Perlstein void show(LOCKD_MSG *); 817838f9ddSPhilippe Charnier int test_request(LOCKD_MSG *); 82603c8667SAlfred Perlstein int unlock_request(LOCKD_MSG *); 830cbf6231SPoul-Henning Kamp 840cbf6231SPoul-Henning Kamp static int 850cbf6231SPoul-Henning Kamp nfslockdans(int vers, struct lockd_ans *ansp) 860cbf6231SPoul-Henning Kamp { 870cbf6231SPoul-Henning Kamp 880cbf6231SPoul-Henning Kamp ansp->la_vers = vers; 89d32c3b7dSOlivier Houchard return (write(devfd, ansp, sizeof *ansp) <= 0); 900cbf6231SPoul-Henning Kamp } 91603c8667SAlfred Perlstein 92603c8667SAlfred Perlstein /* 93603c8667SAlfred Perlstein * will break because fifo needs to be repopened when EOF'd 94603c8667SAlfred Perlstein */ 95603c8667SAlfred Perlstein #define lockd_seteuid(uid) seteuid(uid) 96603c8667SAlfred Perlstein 975f8568ecSAlfred Perlstein #define d_calls (debug_level > 1) 985f8568ecSAlfred Perlstein #define d_args (debug_level > 2) 995f8568ecSAlfred Perlstein 10009ce4f7aSAlfred Perlstein static const char * 10109ce4f7aSAlfred Perlstein from_addr(saddr) 10209ce4f7aSAlfred Perlstein struct sockaddr *saddr; 10309ce4f7aSAlfred Perlstein { 10409ce4f7aSAlfred Perlstein static char inet_buf[INET6_ADDRSTRLEN]; 10509ce4f7aSAlfred Perlstein 10609ce4f7aSAlfred Perlstein if (getnameinfo(saddr, saddr->sa_len, inet_buf, sizeof(inet_buf), 10709ce4f7aSAlfred Perlstein NULL, 0, NI_NUMERICHOST) == 0) 10809ce4f7aSAlfred Perlstein return inet_buf; 10909ce4f7aSAlfred Perlstein return "???"; 11009ce4f7aSAlfred Perlstein } 111603c8667SAlfred Perlstein 112603c8667SAlfred Perlstein void 113755f5b77SAlfred Perlstein client_cleanup(void) 114603c8667SAlfred Perlstein { 115603c8667SAlfred Perlstein (void)lockd_seteuid(0); 116603c8667SAlfred Perlstein exit(-1); 117603c8667SAlfred Perlstein } 118603c8667SAlfred Perlstein 119603c8667SAlfred Perlstein /* 120603c8667SAlfred Perlstein * client_request -- 121603c8667SAlfred Perlstein * Loop around messages from the kernel, forwarding them off to 122603c8667SAlfred Perlstein * NLM servers. 123603c8667SAlfred Perlstein */ 124603c8667SAlfred Perlstein pid_t 125603c8667SAlfred Perlstein client_request(void) 126603c8667SAlfred Perlstein { 127603c8667SAlfred Perlstein LOCKD_MSG msg; 1280cbf6231SPoul-Henning Kamp int nr, ret; 129603c8667SAlfred Perlstein pid_t child; 13032e9a249SAlfred Perlstein uid_t daemon_uid; 13132e9a249SAlfred Perlstein struct passwd *pw; 132603c8667SAlfred Perlstein 1330cbf6231SPoul-Henning Kamp /* Open the dev . */ 1340cbf6231SPoul-Henning Kamp devfd = open(_PATH_DEV _PATH_NFSLCKDEV, O_RDWR | O_NONBLOCK); 1350cbf6231SPoul-Henning Kamp if (devfd < 0) { 1360cbf6231SPoul-Henning Kamp syslog(LOG_ERR, "open: %s: %m", _PATH_NFSLCKDEV); 1370cbf6231SPoul-Henning Kamp goto err; 138603c8667SAlfred Perlstein } 139e91db40cSCraig Rodrigues 140e91db40cSCraig Rodrigues signal(SIGPIPE, SIG_IGN); 141e91db40cSCraig Rodrigues 142603c8667SAlfred Perlstein /* 143603c8667SAlfred Perlstein * Create a separate process, the client code is really a separate 144603c8667SAlfred Perlstein * daemon that shares a lot of code. 145603c8667SAlfred Perlstein */ 146603c8667SAlfred Perlstein switch (child = fork()) { 147603c8667SAlfred Perlstein case -1: 148603c8667SAlfred Perlstein err(1, "fork"); 149603c8667SAlfred Perlstein case 0: 150c6d0f16dSThomas Quinot setproctitle ("client"); 151603c8667SAlfred Perlstein break; 152603c8667SAlfred Perlstein default: 153c6d0f16dSThomas Quinot setproctitle ("server"); 154603c8667SAlfred Perlstein return (child); 155603c8667SAlfred Perlstein } 156603c8667SAlfred Perlstein 157755f5b77SAlfred Perlstein signal(SIGHUP, (sig_t)client_cleanup); 158755f5b77SAlfred Perlstein signal(SIGTERM, (sig_t)client_cleanup); 159603c8667SAlfred Perlstein 160603c8667SAlfred Perlstein /* Setup. */ 161603c8667SAlfred Perlstein (void)time(&owner.tod); 162603c8667SAlfred Perlstein owner.pid = getpid(); 163603c8667SAlfred Perlstein (void)gethostname(hostname, sizeof(hostname) - 1); 164603c8667SAlfred Perlstein 16532e9a249SAlfred Perlstein pw = getpwnam(DAEMON_USERNAME); 16632e9a249SAlfred Perlstein if (pw == NULL) { 16732e9a249SAlfred Perlstein syslog(LOG_ERR, "getpwnam: %s: %m", DAEMON_USERNAME); 16832e9a249SAlfred Perlstein goto err; 16932e9a249SAlfred Perlstein } 17032e9a249SAlfred Perlstein daemon_uid = pw->pw_uid; 171603c8667SAlfred Perlstein /* drop our root priviledges */ 172603c8667SAlfred Perlstein (void)lockd_seteuid(daemon_uid); 173603c8667SAlfred Perlstein 174603c8667SAlfred Perlstein for (;;) { 175603c8667SAlfred Perlstein /* Read the fixed length message. */ 1760cbf6231SPoul-Henning Kamp if ((nr = read(devfd, &msg, sizeof(msg))) == sizeof(msg)) { 177603c8667SAlfred Perlstein if (d_args) 178603c8667SAlfred Perlstein show(&msg); 179603c8667SAlfred Perlstein 180603c8667SAlfred Perlstein if (msg.lm_version != LOCKD_MSG_VERSION) { 181603c8667SAlfred Perlstein syslog(LOG_ERR, 182603c8667SAlfred Perlstein "unknown msg type: %d", msg.lm_version); 183603c8667SAlfred Perlstein } 184603c8667SAlfred Perlstein /* 185603c8667SAlfred Perlstein * Send it to the NLM server and don't grant the lock 186603c8667SAlfred Perlstein * if we fail for any reason. 187603c8667SAlfred Perlstein */ 188603c8667SAlfred Perlstein switch (msg.lm_fl.l_type) { 189603c8667SAlfred Perlstein case F_RDLCK: 190603c8667SAlfred Perlstein case F_WRLCK: 191603c8667SAlfred Perlstein if (msg.lm_getlk) 192603c8667SAlfred Perlstein ret = test_request(&msg); 193603c8667SAlfred Perlstein else 194603c8667SAlfred Perlstein ret = lock_request(&msg); 195603c8667SAlfred Perlstein break; 196603c8667SAlfred Perlstein case F_UNLCK: 197603c8667SAlfred Perlstein ret = unlock_request(&msg); 198603c8667SAlfred Perlstein break; 199603c8667SAlfred Perlstein default: 200603c8667SAlfred Perlstein ret = 1; 201603c8667SAlfred Perlstein syslog(LOG_ERR, 202603c8667SAlfred Perlstein "unknown lock type: %d", msg.lm_fl.l_type); 203603c8667SAlfred Perlstein break; 204603c8667SAlfred Perlstein } 205603c8667SAlfred Perlstein if (ret) { 206603c8667SAlfred Perlstein struct lockd_ans ans; 207603c8667SAlfred Perlstein 208603c8667SAlfred Perlstein ans.la_msg_ident = msg.lm_msg_ident; 209603c8667SAlfred Perlstein ans.la_errno = EHOSTUNREACH; 210603c8667SAlfred Perlstein 211603c8667SAlfred Perlstein if (nfslockdans(LOCKD_ANS_VERSION, &ans)) { 212603c8667SAlfred Perlstein syslog((errno == EPIPE ? LOG_INFO : 213603c8667SAlfred Perlstein LOG_ERR), "process %lu: %m", 214603c8667SAlfred Perlstein (u_long)msg.lm_msg_ident.pid); 215603c8667SAlfred Perlstein } 216603c8667SAlfred Perlstein } 217603c8667SAlfred Perlstein } else if (nr == -1) { 218603c8667SAlfred Perlstein if (errno != EAGAIN) { 2190cbf6231SPoul-Henning Kamp syslog(LOG_ERR, "read: %s: %m", _PATH_NFSLCKDEV); 220603c8667SAlfred Perlstein goto err; 221603c8667SAlfred Perlstein } 222603c8667SAlfred Perlstein } else if (nr != 0) { 223603c8667SAlfred Perlstein syslog(LOG_ERR, 2240cbf6231SPoul-Henning Kamp "%s: discard %d bytes", _PATH_NFSLCKDEV, nr); 225603c8667SAlfred Perlstein } 226603c8667SAlfred Perlstein } 227603c8667SAlfred Perlstein 228603c8667SAlfred Perlstein /* Reached only on error. */ 229603c8667SAlfred Perlstein err: 230603c8667SAlfred Perlstein (void)lockd_seteuid(0); 231603c8667SAlfred Perlstein _exit (1); 232603c8667SAlfred Perlstein } 233603c8667SAlfred Perlstein 234603c8667SAlfred Perlstein void 235f898f7c5SAlfred Perlstein set_auth(cl, xucred) 236955e1056SAlfred Perlstein CLIENT *cl; 237f898f7c5SAlfred Perlstein struct xucred *xucred; 238603c8667SAlfred Perlstein { 239251bb62dSHartmut Brandt int ngroups; 240251bb62dSHartmut Brandt 241251bb62dSHartmut Brandt ngroups = xucred->cr_ngroups - 1; 242251bb62dSHartmut Brandt if (ngroups > NGRPS) 243251bb62dSHartmut Brandt ngroups = NGRPS; 244603c8667SAlfred Perlstein if (cl->cl_auth != NULL) 245603c8667SAlfred Perlstein cl->cl_auth->ah_ops->ah_destroy(cl->cl_auth); 246603c8667SAlfred Perlstein cl->cl_auth = authunix_create(hostname, 247f898f7c5SAlfred Perlstein xucred->cr_uid, 248f898f7c5SAlfred Perlstein xucred->cr_groups[0], 249251bb62dSHartmut Brandt ngroups, 250f898f7c5SAlfred Perlstein &xucred->cr_groups[1]); 251603c8667SAlfred Perlstein } 252603c8667SAlfred Perlstein 253603c8667SAlfred Perlstein 254603c8667SAlfred Perlstein /* 255603c8667SAlfred Perlstein * test_request -- 256603c8667SAlfred Perlstein * Convert a lock LOCKD_MSG into an NLM request, and send it off. 257603c8667SAlfred Perlstein */ 258603c8667SAlfred Perlstein int 259603c8667SAlfred Perlstein test_request(LOCKD_MSG *msg) 260603c8667SAlfred Perlstein { 261603c8667SAlfred Perlstein CLIENT *cli; 262603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 263603c8667SAlfred Perlstein char dummy; 264603c8667SAlfred Perlstein 265603c8667SAlfred Perlstein if (d_calls) 266603c8667SAlfred Perlstein syslog(LOG_DEBUG, "test request: %s: %s to %s", 267603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 268603c8667SAlfred Perlstein msg->lm_fl.l_type == F_WRLCK ? "write" : "read", 26909ce4f7aSAlfred Perlstein from_addr((struct sockaddr *)&msg->lm_addr)); 270603c8667SAlfred Perlstein 271603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 272603c8667SAlfred Perlstein struct nlm4_testargs arg4; 273603c8667SAlfred Perlstein 274603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 275603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 276603c8667SAlfred Perlstein arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 277603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 278603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 279603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 280603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 281603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 282603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 283603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 284603c8667SAlfred Perlstein arg4.alock.l_len = msg->lm_fl.l_len; 285603c8667SAlfred Perlstein 286603c8667SAlfred Perlstein if ((cli = get_client( 287603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 288603c8667SAlfred Perlstein NLM_VERS4)) == NULL) 289603c8667SAlfred Perlstein return (1); 290603c8667SAlfred Perlstein 291603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 292603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_TEST_MSG, 29375e40e46SPeter Wemm (xdrproc_t)xdr_nlm4_testargs, &arg4, 29475e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 295603c8667SAlfred Perlstein } else { 296603c8667SAlfred Perlstein struct nlm_testargs arg; 297603c8667SAlfred Perlstein 298603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 299603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 300603c8667SAlfred Perlstein arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 301603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 302603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 303603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 304603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 305603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 306603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 307603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 308603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 309603c8667SAlfred Perlstein 310603c8667SAlfred Perlstein if ((cli = get_client( 311603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 312603c8667SAlfred Perlstein NLM_VERS)) == NULL) 313603c8667SAlfred Perlstein return (1); 314603c8667SAlfred Perlstein 315603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 316603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_TEST_MSG, 31775e40e46SPeter Wemm (xdrproc_t)xdr_nlm_testargs, &arg, 31875e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 319603c8667SAlfred Perlstein } 320603c8667SAlfred Perlstein return (0); 321603c8667SAlfred Perlstein } 322603c8667SAlfred Perlstein 323603c8667SAlfred Perlstein /* 324603c8667SAlfred Perlstein * lock_request -- 325603c8667SAlfred Perlstein * Convert a lock LOCKD_MSG into an NLM request, and send it off. 326603c8667SAlfred Perlstein */ 327603c8667SAlfred Perlstein int 328603c8667SAlfred Perlstein lock_request(LOCKD_MSG *msg) 329603c8667SAlfred Perlstein { 330603c8667SAlfred Perlstein CLIENT *cli; 331603c8667SAlfred Perlstein struct nlm4_lockargs arg4; 332603c8667SAlfred Perlstein struct nlm_lockargs arg; 333603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 334603c8667SAlfred Perlstein char dummy; 335603c8667SAlfred Perlstein 336603c8667SAlfred Perlstein if (d_calls) 337603c8667SAlfred Perlstein syslog(LOG_DEBUG, "lock request: %s: %s to %s", 338603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 339603c8667SAlfred Perlstein msg->lm_fl.l_type == F_WRLCK ? "write" : "read", 34009ce4f7aSAlfred Perlstein from_addr((struct sockaddr *)&msg->lm_addr)); 341603c8667SAlfred Perlstein 342603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 343603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 344603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 345603c8667SAlfred Perlstein arg4.block = msg->lm_wait ? 1 : 0; 346603c8667SAlfred Perlstein arg4.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 347603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 348603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 349603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 350603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 351603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 352603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 353603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 354603c8667SAlfred Perlstein arg4.alock.l_len = msg->lm_fl.l_len; 355603c8667SAlfred Perlstein arg4.reclaim = 0; 356603c8667SAlfred Perlstein arg4.state = nsm_state; 357603c8667SAlfred Perlstein 358603c8667SAlfred Perlstein if ((cli = get_client( 359603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 360603c8667SAlfred Perlstein NLM_VERS4)) == NULL) 361603c8667SAlfred Perlstein return (1); 362603c8667SAlfred Perlstein 363603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 364603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_LOCK_MSG, 36575e40e46SPeter Wemm (xdrproc_t)xdr_nlm4_lockargs, &arg4, 36675e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 367603c8667SAlfred Perlstein } else { 368603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 369603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 370603c8667SAlfred Perlstein arg.block = msg->lm_wait ? 1 : 0; 371603c8667SAlfred Perlstein arg.exclusive = msg->lm_fl.l_type == F_WRLCK ? 1 : 0; 372603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 373603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 374603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 375603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 376603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 377603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 378603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 379603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 380603c8667SAlfred Perlstein arg.reclaim = 0; 381603c8667SAlfred Perlstein arg.state = nsm_state; 382603c8667SAlfred Perlstein 383603c8667SAlfred Perlstein if ((cli = get_client( 384603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 385603c8667SAlfred Perlstein NLM_VERS)) == NULL) 386603c8667SAlfred Perlstein return (1); 387603c8667SAlfred Perlstein 388603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 389603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_LOCK_MSG, 39075e40e46SPeter Wemm (xdrproc_t)xdr_nlm_lockargs, &arg, 39175e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 392603c8667SAlfred Perlstein } 393603c8667SAlfred Perlstein return (0); 394603c8667SAlfred Perlstein } 395603c8667SAlfred Perlstein 396603c8667SAlfred Perlstein /* 397603c8667SAlfred Perlstein * unlock_request -- 398603c8667SAlfred Perlstein * Convert an unlock LOCKD_MSG into an NLM request, and send it off. 399603c8667SAlfred Perlstein */ 400603c8667SAlfred Perlstein int 401603c8667SAlfred Perlstein unlock_request(LOCKD_MSG *msg) 402603c8667SAlfred Perlstein { 403603c8667SAlfred Perlstein CLIENT *cli; 404603c8667SAlfred Perlstein struct nlm4_unlockargs arg4; 405603c8667SAlfred Perlstein struct nlm_unlockargs arg; 406603c8667SAlfred Perlstein struct timeval timeout = {0, 0}; /* No timeout, no response. */ 407603c8667SAlfred Perlstein char dummy; 408603c8667SAlfred Perlstein 409603c8667SAlfred Perlstein if (d_calls) 410603c8667SAlfred Perlstein syslog(LOG_DEBUG, "unlock request: %s: to %s", 411603c8667SAlfred Perlstein msg->lm_nfsv3 ? "V4" : "V1/3", 41209ce4f7aSAlfred Perlstein from_addr((struct sockaddr *)&msg->lm_addr)); 413603c8667SAlfred Perlstein 414603c8667SAlfred Perlstein if (msg->lm_nfsv3) { 415603c8667SAlfred Perlstein arg4.cookie.n_bytes = (char *)&msg->lm_msg_ident; 416603c8667SAlfred Perlstein arg4.cookie.n_len = sizeof(msg->lm_msg_ident); 417603c8667SAlfred Perlstein arg4.alock.caller_name = hostname; 418603c8667SAlfred Perlstein arg4.alock.fh.n_bytes = (char *)&msg->lm_fh; 419603c8667SAlfred Perlstein arg4.alock.fh.n_len = msg->lm_fh_len; 420603c8667SAlfred Perlstein arg4.alock.oh.n_bytes = (char *)&owner; 421603c8667SAlfred Perlstein arg4.alock.oh.n_len = sizeof(owner); 422603c8667SAlfred Perlstein arg4.alock.svid = msg->lm_msg_ident.pid; 423603c8667SAlfred Perlstein arg4.alock.l_offset = msg->lm_fl.l_start; 424603c8667SAlfred Perlstein arg4.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_VERS4)) == NULL) 429603c8667SAlfred Perlstein return (1); 430603c8667SAlfred Perlstein 431603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 432603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_UNLOCK_MSG, 43375e40e46SPeter Wemm (xdrproc_t)xdr_nlm4_unlockargs, &arg4, 43475e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 435603c8667SAlfred Perlstein } else { 436603c8667SAlfred Perlstein arg.cookie.n_bytes = (char *)&msg->lm_msg_ident; 437603c8667SAlfred Perlstein arg.cookie.n_len = sizeof(msg->lm_msg_ident); 438603c8667SAlfred Perlstein arg.alock.caller_name = hostname; 439603c8667SAlfred Perlstein arg.alock.fh.n_bytes = (char *)&msg->lm_fh; 440603c8667SAlfred Perlstein arg.alock.fh.n_len = msg->lm_fh_len; 441603c8667SAlfred Perlstein arg.alock.oh.n_bytes = (char *)&owner; 442603c8667SAlfred Perlstein arg.alock.oh.n_len = sizeof(owner); 443603c8667SAlfred Perlstein arg.alock.svid = msg->lm_msg_ident.pid; 444603c8667SAlfred Perlstein arg.alock.l_offset = msg->lm_fl.l_start; 445603c8667SAlfred Perlstein arg.alock.l_len = msg->lm_fl.l_len; 446603c8667SAlfred Perlstein 447603c8667SAlfred Perlstein if ((cli = get_client( 448603c8667SAlfred Perlstein (struct sockaddr *)&msg->lm_addr, 449603c8667SAlfred Perlstein NLM_VERS)) == NULL) 450603c8667SAlfred Perlstein return (1); 451603c8667SAlfred Perlstein 452603c8667SAlfred Perlstein set_auth(cli, &msg->lm_cred); 453603c8667SAlfred Perlstein (void)clnt_call(cli, NLM_UNLOCK_MSG, 45475e40e46SPeter Wemm (xdrproc_t)xdr_nlm_unlockargs, &arg, 45575e40e46SPeter Wemm (xdrproc_t)xdr_void, &dummy, timeout); 456603c8667SAlfred Perlstein } 457603c8667SAlfred Perlstein 458603c8667SAlfred Perlstein return (0); 459603c8667SAlfred Perlstein } 460603c8667SAlfred Perlstein 461603c8667SAlfred Perlstein int 462603c8667SAlfred Perlstein lock_answer(int pid, netobj *netcookie, int result, int *pid_p, int version) 463603c8667SAlfred Perlstein { 464603c8667SAlfred Perlstein struct lockd_ans ans; 465603c8667SAlfred Perlstein 466603c8667SAlfred Perlstein if (netcookie->n_len != sizeof(ans.la_msg_ident)) { 467603c8667SAlfred Perlstein if (pid == -1) { /* we're screwed */ 468603c8667SAlfred Perlstein syslog(LOG_ERR, "inedible nlm cookie"); 469603c8667SAlfred Perlstein return -1; 470603c8667SAlfred Perlstein } 471603c8667SAlfred Perlstein ans.la_msg_ident.pid = pid; 472603c8667SAlfred Perlstein ans.la_msg_ident.msg_seq = -1; 473603c8667SAlfred Perlstein } else { 474603c8667SAlfred Perlstein memcpy(&ans.la_msg_ident, netcookie->n_bytes, 475603c8667SAlfred Perlstein sizeof(ans.la_msg_ident)); 476603c8667SAlfred Perlstein } 477603c8667SAlfred Perlstein 478603c8667SAlfred Perlstein if (d_calls) 4795f8568ecSAlfred Perlstein syslog(LOG_DEBUG, "lock answer: pid %lu: %s %d", 480755f5b77SAlfred Perlstein (unsigned long)ans.la_msg_ident.pid, 4815f8568ecSAlfred Perlstein version == NLM_VERS4 ? "nlmv4" : "nlmv3", 4825f8568ecSAlfred Perlstein result); 483603c8667SAlfred Perlstein 484603c8667SAlfred Perlstein ans.la_set_getlk_pid = 0; 485603c8667SAlfred Perlstein if (version == NLM_VERS4) 486603c8667SAlfred Perlstein switch (result) { 487603c8667SAlfred Perlstein case nlm4_granted: 488603c8667SAlfred Perlstein ans.la_errno = 0; 489603c8667SAlfred Perlstein break; 490603c8667SAlfred Perlstein default: 491603c8667SAlfred Perlstein ans.la_errno = EACCES; 492603c8667SAlfred Perlstein break; 493603c8667SAlfred Perlstein case nlm4_denied: 494603c8667SAlfred Perlstein if (pid_p == NULL) 495eda8b282SRobert Watson ans.la_errno = EAGAIN; 496603c8667SAlfred Perlstein else { 497603c8667SAlfred Perlstein /* this is an answer to a nlm_test msg */ 498603c8667SAlfred Perlstein ans.la_set_getlk_pid = 1; 499603c8667SAlfred Perlstein ans.la_getlk_pid = *pid_p; 500603c8667SAlfred Perlstein ans.la_errno = 0; 501603c8667SAlfred Perlstein } 502603c8667SAlfred Perlstein break; 503603c8667SAlfred Perlstein case nlm4_denied_nolocks: 504603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 505603c8667SAlfred Perlstein break; 506603c8667SAlfred Perlstein case nlm4_blocked: 507603c8667SAlfred Perlstein return -1; 508603c8667SAlfred Perlstein /* NOTREACHED */ 509603c8667SAlfred Perlstein case nlm4_denied_grace_period: 510603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 511603c8667SAlfred Perlstein break; 512603c8667SAlfred Perlstein case nlm4_deadlck: 513603c8667SAlfred Perlstein ans.la_errno = EDEADLK; 514603c8667SAlfred Perlstein break; 515603c8667SAlfred Perlstein case nlm4_rofs: 516603c8667SAlfred Perlstein ans.la_errno = EROFS; 517603c8667SAlfred Perlstein break; 518603c8667SAlfred Perlstein case nlm4_stale_fh: 519603c8667SAlfred Perlstein ans.la_errno = ESTALE; 520603c8667SAlfred Perlstein break; 521603c8667SAlfred Perlstein case nlm4_fbig: 522603c8667SAlfred Perlstein ans.la_errno = EFBIG; 523603c8667SAlfred Perlstein break; 524603c8667SAlfred Perlstein case nlm4_failed: 525603c8667SAlfred Perlstein ans.la_errno = EACCES; 526603c8667SAlfred Perlstein break; 527603c8667SAlfred Perlstein } 528603c8667SAlfred Perlstein else 529603c8667SAlfred Perlstein switch (result) { 530603c8667SAlfred Perlstein case nlm_granted: 531603c8667SAlfred Perlstein ans.la_errno = 0; 532603c8667SAlfred Perlstein break; 533603c8667SAlfred Perlstein default: 534603c8667SAlfred Perlstein ans.la_errno = EACCES; 535603c8667SAlfred Perlstein break; 536603c8667SAlfred Perlstein case nlm_denied: 537603c8667SAlfred Perlstein if (pid_p == NULL) 538eda8b282SRobert Watson ans.la_errno = EAGAIN; 539603c8667SAlfred Perlstein else { 540603c8667SAlfred Perlstein /* this is an answer to a nlm_test msg */ 541603c8667SAlfred Perlstein ans.la_set_getlk_pid = 1; 542603c8667SAlfred Perlstein ans.la_getlk_pid = *pid_p; 543603c8667SAlfred Perlstein ans.la_errno = 0; 544603c8667SAlfred Perlstein } 545603c8667SAlfred Perlstein break; 546603c8667SAlfred Perlstein case nlm_denied_nolocks: 547603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 548603c8667SAlfred Perlstein break; 549603c8667SAlfred Perlstein case nlm_blocked: 550603c8667SAlfred Perlstein return -1; 551603c8667SAlfred Perlstein /* NOTREACHED */ 552603c8667SAlfred Perlstein case nlm_denied_grace_period: 553603c8667SAlfred Perlstein ans.la_errno = EAGAIN; 554603c8667SAlfred Perlstein break; 555603c8667SAlfred Perlstein case nlm_deadlck: 556603c8667SAlfred Perlstein ans.la_errno = EDEADLK; 557603c8667SAlfred Perlstein break; 558603c8667SAlfred Perlstein } 559603c8667SAlfred Perlstein 560603c8667SAlfred Perlstein if (nfslockdans(LOCKD_ANS_VERSION, &ans)) { 561603c8667SAlfred Perlstein syslog(((errno == EPIPE || errno == ESRCH) ? 562603c8667SAlfred Perlstein LOG_INFO : LOG_ERR), 563603c8667SAlfred Perlstein "process %lu: %m", (u_long)ans.la_msg_ident.pid); 564603c8667SAlfred Perlstein return -1; 565603c8667SAlfred Perlstein } 566603c8667SAlfred Perlstein return 0; 567603c8667SAlfred Perlstein } 568603c8667SAlfred Perlstein 569603c8667SAlfred Perlstein /* 570603c8667SAlfred Perlstein * show -- 571603c8667SAlfred Perlstein * Display the contents of a kernel LOCKD_MSG structure. 572603c8667SAlfred Perlstein */ 573603c8667SAlfred Perlstein void 574603c8667SAlfred Perlstein show(LOCKD_MSG *mp) 575603c8667SAlfred Perlstein { 576603c8667SAlfred Perlstein static char hex[] = "0123456789abcdef"; 577603c8667SAlfred Perlstein struct fid *fidp; 578603c8667SAlfred Perlstein fsid_t *fsidp; 579603c8667SAlfred Perlstein size_t len; 580603c8667SAlfred Perlstein u_int8_t *p, *t, buf[NFS_SMALLFH*3+1]; 581603c8667SAlfred Perlstein 5829529c2d9SAlfred Perlstein syslog(LOG_DEBUG, "process ID: %lu\n", (long)mp->lm_msg_ident.pid); 583603c8667SAlfred Perlstein 584603c8667SAlfred Perlstein fsidp = (fsid_t *)&mp->lm_fh; 585603c8667SAlfred Perlstein fidp = (struct fid *)((u_int8_t *)&mp->lm_fh + sizeof(fsid_t)); 586603c8667SAlfred Perlstein 587603c8667SAlfred Perlstein for (t = buf, p = (u_int8_t *)mp->lm_fh, 588603c8667SAlfred Perlstein len = mp->lm_fh_len; 589603c8667SAlfred Perlstein len > 0; ++p, --len) { 590603c8667SAlfred Perlstein *t++ = '\\'; 591603c8667SAlfred Perlstein *t++ = hex[(*p & 0xf0) >> 4]; 592603c8667SAlfred Perlstein *t++ = hex[*p & 0x0f]; 593603c8667SAlfred Perlstein } 594603c8667SAlfred Perlstein *t = '\0'; 595603c8667SAlfred Perlstein 59675e40e46SPeter Wemm syslog(LOG_DEBUG, "fh_len %d, fh %s\n", (int)mp->lm_fh_len, buf); 597603c8667SAlfred Perlstein 598603c8667SAlfred Perlstein /* Show flock structure. */ 5999529c2d9SAlfred Perlstein syslog(LOG_DEBUG, "start %qu; len %qu; pid %lu; type %d; whence %d\n", 60075e40e46SPeter Wemm (unsigned long long)mp->lm_fl.l_start, 60175e40e46SPeter Wemm (unsigned long long)mp->lm_fl.l_len, (u_long)mp->lm_fl.l_pid, 602603c8667SAlfred Perlstein mp->lm_fl.l_type, mp->lm_fl.l_whence); 603603c8667SAlfred Perlstein 604603c8667SAlfred Perlstein /* Show wait flag. */ 6059529c2d9SAlfred Perlstein syslog(LOG_DEBUG, "wait was %s\n", mp->lm_wait ? "set" : "not set"); 606603c8667SAlfred Perlstein } 607