mountd.c revision 1.1
1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 #ifndef lint 38 char copyright[] = 39 "@(#) Copyright (c) 1989 Regents of the University of California.\n\ 40 All rights reserved.\n"; 41 #endif not lint 42 43 #ifndef lint 44 static char sccsid[] = "@(#)mountd.c 5.14 (Berkeley) 2/26/91"; 45 #endif not lint 46 47 #include <sys/param.h> 48 #include <sys/ioctl.h> 49 #include <sys/stat.h> 50 #include <sys/file.h> 51 #include <sys/mount.h> 52 #include <sys/socket.h> 53 #include <sys/errno.h> 54 #include <sys/signal.h> 55 #include <stdio.h> 56 #include <string.h> 57 #include <syslog.h> 58 #include <netdb.h> 59 #include <rpc/rpc.h> 60 #include <rpc/pmap_clnt.h> 61 #include <rpc/pmap_prot.h> 62 #include <nfs/rpcv2.h> 63 #include <nfs/nfsv2.h> 64 #include "pathnames.h" 65 66 struct ufid { 67 u_short ufid_len; 68 ino_t ufid_ino; 69 long ufid_gen; 70 }; 71 /* 72 * Structures for keeping the mount list and export list 73 */ 74 struct mountlist { 75 struct mountlist *ml_next; 76 char ml_host[RPCMNT_NAMELEN+1]; 77 char ml_dirp[RPCMNT_PATHLEN+1]; 78 }; 79 80 struct exportlist { 81 struct exportlist *ex_next; 82 struct exportlist *ex_prev; 83 struct grouplist *ex_groups; 84 int ex_rootuid; 85 int ex_exflags; 86 dev_t ex_dev; 87 char ex_dirp[RPCMNT_PATHLEN+1]; 88 }; 89 90 struct grouplist { 91 struct grouplist *gr_next; 92 struct hostent *gr_hp; 93 }; 94 95 /* Global defs */ 96 int mntsrv(), umntall_each(), xdr_fhs(), xdr_mlist(), xdr_dir(), xdr_explist(); 97 void add_mlist(), del_mlist(), get_exportlist(), get_mountlist(); 98 void send_umntall(); 99 struct exportlist exphead; 100 struct mountlist *mlhead; 101 char exname[MAXPATHLEN]; 102 int def_rootuid = -2; 103 int root_only = 1; 104 extern int errno; 105 #ifdef DEBUG 106 int debug = 1; 107 #else 108 int debug = 0; 109 #endif 110 111 /* 112 * Mountd server for NFS mount protocol as described in: 113 * NFS: Network File System Protocol Specification, RFC1094, Appendix A 114 * The optional arguments are the exports file name 115 * default: _PATH_EXPORTS 116 * and "-n" to allow nonroot mount. 117 */ 118 main(argc, argv) 119 int argc; 120 char **argv; 121 { 122 SVCXPRT *transp; 123 int c; 124 extern int optind; 125 extern char *optarg; 126 127 while ((c = getopt(argc, argv, "n")) != EOF) 128 switch (c) { 129 case 'n': 130 root_only = 0; 131 break; 132 default: 133 fprintf(stderr, "Usage: mountd [-n] [export_file]\n"); 134 exit(1); 135 }; 136 argc -= optind; 137 argv += optind; 138 exphead.ex_next = exphead.ex_prev = (struct exportlist *)0; 139 mlhead = (struct mountlist *)0; 140 if (argc == 1) { 141 strncpy(exname, *argv, MAXPATHLEN-1); 142 exname[MAXPATHLEN-1] = '\0'; 143 } else 144 strcpy(exname, _PATH_EXPORTS); 145 openlog("mountd:", LOG_PID, LOG_DAEMON); 146 get_exportlist(); 147 get_mountlist(); 148 if (debug == 0) { 149 daemon(0, 0); 150 signal(SIGINT, SIG_IGN); 151 signal(SIGQUIT, SIG_IGN); 152 } 153 signal(SIGHUP, get_exportlist); 154 signal(SIGTERM, send_umntall); 155 { FILE *pidfile = fopen(_PATH_MOUNTDPID, "w"); 156 if (pidfile != NULL) { 157 fprintf(pidfile, "%d\n", getpid()); 158 fclose(pidfile); 159 } 160 } 161 if ((transp = svcudp_create(RPC_ANYSOCK)) == NULL) { 162 syslog(LOG_ERR, "Can't create socket"); 163 exit(1); 164 } 165 pmap_unset(RPCPROG_MNT, RPCMNT_VER1); 166 if (!svc_register(transp, RPCPROG_MNT, RPCMNT_VER1, mntsrv, IPPROTO_UDP)) { 167 syslog(LOG_ERR, "Can't register mount"); 168 exit(1); 169 } 170 svc_run(); 171 syslog(LOG_ERR, "Mountd died"); 172 exit(1); 173 } 174 175 /* 176 * The mount rpc service 177 */ 178 mntsrv(rqstp, transp) 179 register struct svc_req *rqstp; 180 register SVCXPRT *transp; 181 { 182 register struct grouplist *grp; 183 register u_long **addrp; 184 register struct exportlist *ep; 185 nfsv2fh_t nfh; 186 struct authunix_parms *ucr; 187 struct stat stb; 188 struct hostent *hp; 189 u_long saddr; 190 char dirpath[RPCMNT_PATHLEN+1]; 191 int bad = ENOENT; 192 int omask; 193 uid_t uid = -2; 194 195 /* Get authorization */ 196 switch (rqstp->rq_cred.oa_flavor) { 197 case AUTH_UNIX: 198 ucr = (struct authunix_parms *)rqstp->rq_clntcred; 199 uid = ucr->aup_uid; 200 break; 201 case AUTH_NULL: 202 default: 203 break; 204 } 205 206 saddr = transp->xp_raddr.sin_addr.s_addr; 207 hp = (struct hostent *)0; 208 switch (rqstp->rq_proc) { 209 case NULLPROC: 210 if (!svc_sendreply(transp, xdr_void, (caddr_t)0)) 211 syslog(LOG_ERR, "Can't send reply"); 212 return; 213 case RPCMNT_MOUNT: 214 if (uid != 0 && root_only) { 215 svcerr_weakauth(transp); 216 return; 217 } 218 if (!svc_getargs(transp, xdr_dir, dirpath)) { 219 svcerr_decode(transp); 220 return; 221 } 222 223 /* Check to see if it's a valid dirpath */ 224 if (stat(dirpath, &stb) < 0 || (stb.st_mode&S_IFMT) != 225 S_IFDIR) { 226 if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad)) 227 syslog(LOG_ERR, "Can't send reply"); 228 return; 229 } 230 231 /* Check in the exports list */ 232 omask = sigblock(sigmask(SIGHUP)); 233 ep = exphead.ex_next; 234 while (ep != NULL) { 235 if (!strcmp(ep->ex_dirp, dirpath)) { 236 grp = ep->ex_groups; 237 if (grp == NULL) 238 break; 239 240 /* Check for a host match */ 241 addrp = (u_long **)grp->gr_hp->h_addr_list; 242 for (;;) { 243 if (**addrp == saddr) 244 break; 245 if (*++addrp == NULL) 246 if (grp = grp->gr_next) { 247 addrp = (u_long **) 248 grp->gr_hp->h_addr_list; 249 } else { 250 bad = EACCES; 251 if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad)) 252 syslog(LOG_ERR, "Can't send reply"); 253 sigsetmask(omask); 254 return; 255 } 256 } 257 hp = grp->gr_hp; 258 break; 259 } 260 ep = ep->ex_next; 261 } 262 sigsetmask(omask); 263 if (ep == NULL) { 264 bad = EACCES; 265 if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad)) 266 syslog(LOG_ERR, "Can't send reply"); 267 return; 268 } 269 270 /* Get the file handle */ 271 bzero((caddr_t)&nfh, sizeof(nfh)); 272 if (getfh(dirpath, (fhandle_t *)&nfh) < 0) { 273 bad = errno; 274 if (!svc_sendreply(transp, xdr_long, (caddr_t)&bad)) 275 syslog(LOG_ERR, "Can't send reply"); 276 return; 277 } 278 if (!svc_sendreply(transp, xdr_fhs, (caddr_t)&nfh)) 279 syslog(LOG_ERR, "Can't send reply"); 280 if (hp == NULL) 281 hp = gethostbyaddr((caddr_t)&saddr, sizeof(saddr), AF_INET); 282 if (hp) 283 add_mlist(hp->h_name, dirpath); 284 return; 285 case RPCMNT_DUMP: 286 if (!svc_sendreply(transp, xdr_mlist, (caddr_t)0)) 287 syslog(LOG_ERR, "Can't send reply"); 288 return; 289 case RPCMNT_UMOUNT: 290 if (uid != 0 && root_only) { 291 svcerr_weakauth(transp); 292 return; 293 } 294 if (!svc_getargs(transp, xdr_dir, dirpath)) { 295 svcerr_decode(transp); 296 return; 297 } 298 if (!svc_sendreply(transp, xdr_void, (caddr_t)0)) 299 syslog(LOG_ERR, "Can't send reply"); 300 hp = gethostbyaddr((caddr_t)&saddr, sizeof(saddr), AF_INET); 301 if (hp) 302 del_mlist(hp->h_name, dirpath); 303 return; 304 case RPCMNT_UMNTALL: 305 if (uid != 0 && root_only) { 306 svcerr_weakauth(transp); 307 return; 308 } 309 if (!svc_sendreply(transp, xdr_void, (caddr_t)0)) 310 syslog(LOG_ERR, "Can't send reply"); 311 hp = gethostbyaddr((caddr_t)&saddr, sizeof(saddr), AF_INET); 312 if (hp) 313 del_mlist(hp->h_name, (char *)0); 314 return; 315 case RPCMNT_EXPORT: 316 if (!svc_sendreply(transp, xdr_explist, (caddr_t)0)) 317 syslog(LOG_ERR, "Can't send reply"); 318 return; 319 default: 320 svcerr_noproc(transp); 321 return; 322 } 323 } 324 325 /* 326 * Xdr conversion for a dirpath string 327 */ 328 xdr_dir(xdrsp, dirp) 329 XDR *xdrsp; 330 char *dirp; 331 { 332 return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN)); 333 } 334 335 /* 336 * Xdr routine to generate fhstatus 337 */ 338 xdr_fhs(xdrsp, nfh) 339 XDR *xdrsp; 340 nfsv2fh_t *nfh; 341 { 342 int ok = 0; 343 344 if (!xdr_long(xdrsp, &ok)) 345 return (0); 346 return (xdr_opaque(xdrsp, (caddr_t)nfh, NFSX_FH)); 347 } 348 349 xdr_mlist(xdrsp, cp) 350 XDR *xdrsp; 351 caddr_t cp; 352 { 353 register struct mountlist *mlp; 354 int true = 1; 355 int false = 0; 356 char *strp; 357 358 mlp = mlhead; 359 while (mlp) { 360 if (!xdr_bool(xdrsp, &true)) 361 return (0); 362 strp = &mlp->ml_host[0]; 363 if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN)) 364 return (0); 365 strp = &mlp->ml_dirp[0]; 366 if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN)) 367 return (0); 368 mlp = mlp->ml_next; 369 } 370 if (!xdr_bool(xdrsp, &false)) 371 return (0); 372 return (1); 373 } 374 375 /* 376 * Xdr conversion for export list 377 */ 378 xdr_explist(xdrsp, cp) 379 XDR *xdrsp; 380 caddr_t cp; 381 { 382 register struct exportlist *ep; 383 register struct grouplist *grp; 384 int true = 1; 385 int false = 0; 386 char *strp; 387 int omask; 388 389 omask = sigblock(sigmask(SIGHUP)); 390 ep = exphead.ex_next; 391 while (ep != NULL) { 392 if (!xdr_bool(xdrsp, &true)) 393 goto errout; 394 strp = &ep->ex_dirp[0]; 395 if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN)) 396 goto errout; 397 grp = ep->ex_groups; 398 while (grp != NULL) { 399 if (!xdr_bool(xdrsp, &true)) 400 goto errout; 401 strp = grp->gr_hp->h_name; 402 if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN)) 403 goto errout; 404 grp = grp->gr_next; 405 } 406 if (!xdr_bool(xdrsp, &false)) 407 goto errout; 408 ep = ep->ex_next; 409 } 410 sigsetmask(omask); 411 if (!xdr_bool(xdrsp, &false)) 412 return (0); 413 return (1); 414 errout: 415 sigsetmask(omask); 416 return (0); 417 } 418 419 #define LINESIZ 10240 420 char line[LINESIZ]; 421 422 /* 423 * Get the export list 424 */ 425 void 426 get_exportlist() 427 { 428 register struct hostent *hp, *nhp; 429 register char **addrp, **naddrp; 430 register int i; 431 register struct grouplist *grp; 432 register struct exportlist *ep, *ep2; 433 struct statfs stfsbuf; 434 struct ufs_args args; 435 struct stat sb; 436 FILE *inf; 437 char *cp, *endcp; 438 char savedc; 439 int len, dirplen; 440 int rootuid, exflags; 441 u_long saddr; 442 struct exportlist *fep; 443 444 /* 445 * First, get rid of the old list 446 */ 447 ep = exphead.ex_next; 448 while (ep != NULL) { 449 ep2 = ep; 450 ep = ep->ex_next; 451 free_exp(ep2); 452 } 453 454 /* 455 * Read in the exports file and build the list, calling 456 * exportfs() as we go along 457 */ 458 exphead.ex_next = exphead.ex_prev = (struct exportlist *)0; 459 if ((inf = fopen(exname, "r")) == NULL) { 460 syslog(LOG_ERR, "Can't open %s", exname); 461 exit(2); 462 } 463 while (fgets(line, LINESIZ, inf)) { 464 exflags = MNT_EXPORTED; 465 rootuid = def_rootuid; 466 cp = line; 467 nextfield(&cp, &endcp); 468 469 /* 470 * Get file system devno and see if an entry for this 471 * file system already exists. 472 */ 473 savedc = *endcp; 474 *endcp = '\0'; 475 if (stat(cp, &sb) < 0 || (sb.st_mode & S_IFMT) != S_IFDIR) { 476 syslog(LOG_ERR, 477 "Bad Exports File, %s: %s, mountd Failed", 478 cp, "Not a directory"); 479 exit(2); 480 } 481 fep = (struct exportlist *)0; 482 ep = exphead.ex_next; 483 while (ep) { 484 if (ep->ex_dev == sb.st_dev) { 485 fep = ep; 486 break; 487 } 488 ep = ep->ex_next; 489 } 490 *endcp = savedc; 491 492 /* 493 * Create new exports list entry 494 */ 495 len = endcp-cp; 496 if (len <= RPCMNT_PATHLEN && len > 0) { 497 ep = (struct exportlist *)malloc(sizeof(*ep)); 498 if (ep == NULL) 499 goto err; 500 ep->ex_next = ep->ex_prev = (struct exportlist *)0; 501 ep->ex_groups = (struct grouplist *)0; 502 bcopy(cp, ep->ex_dirp, len); 503 ep->ex_dirp[len] = '\0'; 504 dirplen = len; 505 } else { 506 syslog(LOG_ERR, "Bad Exports File, mountd Failed"); 507 exit(2); 508 } 509 cp = endcp; 510 nextfield(&cp, &endcp); 511 len = endcp-cp; 512 while (len > 0) { 513 savedc = *endcp; 514 *endcp = '\0'; 515 if (len > RPCMNT_NAMELEN) 516 goto more; 517 if (*cp == '-') { 518 do_opt(cp + 1, fep, ep, &exflags, &rootuid); 519 goto more; 520 } 521 if (isdigit(*cp)) { 522 saddr = inet_addr(cp); 523 if (saddr == -1 || 524 (hp = gethostbyaddr((caddr_t)&saddr, 525 sizeof(saddr), AF_INET)) == NULL) { 526 syslog(LOG_ERR, 527 "Bad Exports File, %s: %s", cp, 528 "Gethostbyaddr failed, ignored"); 529 goto more; 530 } 531 } else if ((hp = gethostbyname(cp)) == NULL) { 532 syslog(LOG_ERR, "Bad Exports File, %s: %s", 533 cp, "Gethostbyname failed, ignored"); 534 goto more; 535 } 536 grp = (struct grouplist *) 537 malloc(sizeof(struct grouplist)); 538 if (grp == NULL) 539 goto err; 540 nhp = grp->gr_hp = (struct hostent *) 541 malloc(sizeof(struct hostent)); 542 if (nhp == NULL) 543 goto err; 544 bcopy((caddr_t)hp, (caddr_t)nhp, 545 sizeof(struct hostent)); 546 i = strlen(hp->h_name)+1; 547 nhp->h_name = (char *)malloc(i); 548 if (nhp->h_name == NULL) 549 goto err; 550 bcopy(hp->h_name, nhp->h_name, i); 551 addrp = hp->h_addr_list; 552 i = 1; 553 while (*addrp++) 554 i++; 555 naddrp = nhp->h_addr_list = (char **) 556 malloc(i*sizeof(char *)); 557 if (naddrp == NULL) 558 goto err; 559 addrp = hp->h_addr_list; 560 while (*addrp) { 561 *naddrp = (char *) 562 malloc(hp->h_length); 563 if (*naddrp == NULL) 564 goto err; 565 bcopy(*addrp, *naddrp, 566 hp->h_length); 567 addrp++; 568 naddrp++; 569 } 570 *naddrp = (char *)0; 571 grp->gr_next = ep->ex_groups; 572 ep->ex_groups = grp; 573 more: 574 cp = endcp; 575 *cp = savedc; 576 nextfield(&cp, &endcp); 577 len = endcp - cp; 578 } 579 if (fep == NULL) { 580 args.fspec = 0; 581 args.exflags = exflags; 582 args.exroot = rootuid; 583 cp = (char *)0; 584 while (statfs(ep->ex_dirp, &stfsbuf) < 0 || 585 mount(MOUNT_UFS, ep->ex_dirp, 586 stfsbuf.f_flags|MNT_UPDATE, &args) < 0) { 587 if (cp == NULL) 588 cp = ep->ex_dirp + dirplen - 1; 589 else 590 *cp = savedc; 591 /* back up over the last component */ 592 while (*cp == '/' && cp > ep->ex_dirp) 593 cp--; 594 while (*(cp - 1) != '/' && cp > ep->ex_dirp) 595 cp--; 596 if (cp == ep->ex_dirp) { 597 syslog(LOG_WARNING, 598 "Can't export %s", ep->ex_dirp); 599 free_exp(ep); 600 goto nextline; 601 } 602 savedc = *cp; 603 *cp = '\0'; 604 } 605 if (cp) 606 *cp = savedc; 607 ep->ex_rootuid = rootuid; 608 ep->ex_exflags = exflags; 609 } else { 610 ep->ex_rootuid = fep->ex_rootuid; 611 ep->ex_exflags = fep->ex_exflags; 612 } 613 ep->ex_dev = sb.st_dev; 614 ep->ex_next = exphead.ex_next; 615 ep->ex_prev = &exphead; 616 if (ep->ex_next != NULL) 617 ep->ex_next->ex_prev = ep; 618 exphead.ex_next = ep; 619 nextline: 620 ; 621 } 622 fclose(inf); 623 return; 624 err: 625 syslog(LOG_ERR, "No more memory: mountd Failed"); 626 exit(2); 627 } 628 629 /* 630 * Parse out the next white space separated field 631 */ 632 nextfield(cp, endcp) 633 char **cp; 634 char **endcp; 635 { 636 register char *p; 637 638 p = *cp; 639 while (*p == ' ' || *p == '\t') 640 p++; 641 if (*p == '\n' || *p == '\0') { 642 *cp = *endcp = p; 643 return; 644 } 645 *cp = p++; 646 while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0') 647 p++; 648 *endcp = p; 649 } 650 651 /* 652 * Parse the option string 653 */ 654 do_opt(cpopt, fep, ep, exflagsp, rootuidp) 655 register char *cpopt; 656 struct exportlist *fep, *ep; 657 int *exflagsp, *rootuidp; 658 { 659 register char *cpoptarg, *cpoptend; 660 661 while (cpopt && *cpopt) { 662 if (cpoptend = index(cpopt, ',')) 663 *cpoptend++ = '\0'; 664 if (cpoptarg = index(cpopt, '=')) 665 *cpoptarg++ = '\0'; 666 if (!strcmp(cpopt, "ro") || !strcmp(cpopt, "o")) { 667 if (fep && (fep->ex_exflags & MNT_EXRDONLY) == 0) 668 syslog(LOG_WARNING, "ro failed for %s", 669 ep->ex_dirp); 670 else 671 *exflagsp |= MNT_EXRDONLY; 672 } else if (!strcmp(cpopt, "root") || !strcmp(cpopt, "r")) { 673 if (cpoptarg && isdigit(*cpoptarg)) { 674 *rootuidp = atoi(cpoptarg); 675 if (fep && fep->ex_rootuid != *rootuidp) 676 syslog(LOG_WARNING, 677 "uid failed for %s", 678 ep->ex_dirp); 679 } else 680 syslog(LOG_WARNING, 681 "uid failed for %s", 682 ep->ex_dirp); 683 } else 684 syslog(LOG_WARNING, "opt %s ignored for %s", cpopt, 685 ep->ex_dirp); 686 cpopt = cpoptend; 687 } 688 } 689 690 #define STRSIZ (RPCMNT_NAMELEN+RPCMNT_PATHLEN+50) 691 /* 692 * Routines that maintain the remote mounttab 693 */ 694 void get_mountlist() 695 { 696 register struct mountlist *mlp, **mlpp; 697 register char *eos, *dirp; 698 int len; 699 char str[STRSIZ]; 700 FILE *mlfile; 701 702 if (((mlfile = fopen(_PATH_RMOUNTLIST, "r")) == NULL) && 703 ((mlfile = fopen(_PATH_RMOUNTLIST, "w")) == NULL)) { 704 syslog(LOG_WARNING, "Can't open %s", _PATH_RMOUNTLIST); 705 return; 706 } 707 mlpp = &mlhead; 708 while (fgets(str, STRSIZ, mlfile) != NULL) { 709 if ((dirp = index(str, '\t')) == NULL && 710 (dirp = index(str, ' ')) == NULL) 711 continue; 712 mlp = (struct mountlist *)malloc(sizeof (*mlp)); 713 len = dirp-str; 714 if (len > RPCMNT_NAMELEN) 715 len = RPCMNT_NAMELEN; 716 bcopy(str, mlp->ml_host, len); 717 mlp->ml_host[len] = '\0'; 718 while (*dirp == '\t' || *dirp == ' ') 719 dirp++; 720 if ((eos = index(dirp, '\t')) == NULL && 721 (eos = index(dirp, ' ')) == NULL && 722 (eos = index(dirp, '\n')) == NULL) 723 len = strlen(dirp); 724 else 725 len = eos-dirp; 726 if (len > RPCMNT_PATHLEN) 727 len = RPCMNT_PATHLEN; 728 bcopy(dirp, mlp->ml_dirp, len); 729 mlp->ml_dirp[len] = '\0'; 730 mlp->ml_next = (struct mountlist *)0; 731 *mlpp = mlp; 732 mlpp = &mlp->ml_next; 733 } 734 fclose(mlfile); 735 } 736 737 void del_mlist(hostp, dirp) 738 register char *hostp, *dirp; 739 { 740 register struct mountlist *mlp, **mlpp; 741 FILE *mlfile; 742 int fnd = 0; 743 744 mlpp = &mlhead; 745 mlp = mlhead; 746 while (mlp) { 747 if (!strcmp(mlp->ml_host, hostp) && 748 (!dirp || !strcmp(mlp->ml_dirp, dirp))) { 749 fnd = 1; 750 *mlpp = mlp->ml_next; 751 free((caddr_t)mlp); 752 } 753 mlpp = &mlp->ml_next; 754 mlp = mlp->ml_next; 755 } 756 if (fnd) { 757 if ((mlfile = fopen(_PATH_RMOUNTLIST, "w")) == NULL) { 758 syslog(LOG_WARNING, "Can't update %s", _PATH_RMOUNTLIST); 759 return; 760 } 761 mlp = mlhead; 762 while (mlp) { 763 fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp); 764 mlp = mlp->ml_next; 765 } 766 fclose(mlfile); 767 } 768 } 769 770 void add_mlist(hostp, dirp) 771 register char *hostp, *dirp; 772 { 773 register struct mountlist *mlp, **mlpp; 774 FILE *mlfile; 775 776 mlpp = &mlhead; 777 mlp = mlhead; 778 while (mlp) { 779 if (!strcmp(mlp->ml_host, hostp) && !strcmp(mlp->ml_dirp, dirp)) 780 return; 781 mlpp = &mlp->ml_next; 782 mlp = mlp->ml_next; 783 } 784 mlp = (struct mountlist *)malloc(sizeof (*mlp)); 785 strncpy(mlp->ml_host, hostp, RPCMNT_NAMELEN); 786 mlp->ml_host[RPCMNT_NAMELEN] = '\0'; 787 strncpy(mlp->ml_dirp, dirp, RPCMNT_PATHLEN); 788 mlp->ml_dirp[RPCMNT_PATHLEN] = '\0'; 789 mlp->ml_next = (struct mountlist *)0; 790 *mlpp = mlp; 791 if ((mlfile = fopen(_PATH_RMOUNTLIST, "a")) == NULL) { 792 syslog(LOG_WARNING, "Can't update %s", _PATH_RMOUNTLIST); 793 return; 794 } 795 fprintf(mlfile, "%s %s\n", mlp->ml_host, mlp->ml_dirp); 796 fclose(mlfile); 797 } 798 799 /* 800 * This function is called via. SIGTERM when the system is going down. 801 * It sends a broadcast RPCMNT_UMNTALL. 802 */ 803 void 804 send_umntall() 805 { 806 (void) clnt_broadcast(RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMNTALL, 807 xdr_void, (caddr_t)0, xdr_void, (caddr_t)0, umntall_each); 808 exit(); 809 } 810 811 umntall_each(resultsp, raddr) 812 caddr_t resultsp; 813 struct sockaddr_in *raddr; 814 { 815 return (1); 816 } 817 818 /* 819 * Free up an exports list component 820 */ 821 free_exp(ep) 822 register struct exportlist *ep; 823 { 824 register struct grouplist *grp; 825 register char **addrp; 826 struct grouplist *grp2; 827 828 grp = ep->ex_groups; 829 while (grp != NULL) { 830 addrp = grp->gr_hp->h_addr_list; 831 while (*addrp) 832 free(*addrp++); 833 free((caddr_t)grp->gr_hp->h_addr_list); 834 free(grp->gr_hp->h_name); 835 free((caddr_t)grp->gr_hp); 836 grp2 = grp; 837 grp = grp->gr_next; 838 free((caddr_t)grp2); 839 } 840 free((caddr_t)ep); 841 } 842
Indexes created Thu Sep 25 16:09:42 GMT 2025