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