2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Herb Hasler and Rick Macklem at The University of Guelph.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * @(#) Copyright (c) 1989, 1993 The Regents of the University of California. All rights reserved.
33 * @(#)mountd.c 8.15 (Berkeley) 5/1/95
34 * $FreeBSD: head/usr.sbin/mountd/mountd.c 173056 2007-10-27 12:24:47Z simon $
37 #include <sys/param.h>
38 #include <sys/module.h>
39 #include <sys/mount.h>
40 #include <sys/mountctl.h>
41 #include <sys/fcntl.h>
42 #include <sys/linker.h>
44 #include <sys/syslog.h>
45 #include <sys/sysctl.h>
48 #include <rpc/rpc_com.h>
49 #include <rpcsvc/mount.h>
50 #include <vfs/nfs/rpcv2.h>
51 #include <vfs/nfs/nfsproto.h>
52 #include <vfs/nfs/nfs.h>
53 #include <vfs/ufs/ufsmount.h>
54 #include <vfs/msdosfs/msdosfsmount.h>
55 #include <vfs/ntfs/ntfsmount.h>
56 #include <vfs/isofs/cd9660/cd9660_mount.h> /* XXX need isofs in include */
58 #include <arpa/inet.h>
73 #include "pathnames.h"
80 * Structures for keeping the mount list and export list
83 struct mountlist
*ml_next
;
84 char ml_host
[RPCMNT_NAMELEN
+1];
85 char ml_dirp
[RPCMNT_PATHLEN
+1];
89 struct dirlist
*dp_left
;
90 struct dirlist
*dp_right
;
92 struct hostlist
*dp_hosts
; /* List of hosts this dir exported to */
93 char dp_dirp
[1]; /* Actually malloc'd to size of dir */
97 #define DP_HOSTSET 0x2
100 struct exportlist
*ex_next
;
101 struct dirlist
*ex_dirl
;
102 struct dirlist
*ex_defdir
;
109 #define EX_LINKED 0x1
112 struct sockaddr_storage nt_net
;
113 struct sockaddr_storage nt_mask
;
118 struct addrinfo
*gt_addrinfo
;
119 struct netmsk gt_net
;
124 union grouptypes gr_ptr
;
125 struct grouplist
*gr_next
;
131 #define GT_DEFAULT 0x3
132 #define GT_IGNORE 0x5
135 int ht_flag
; /* Uses DP_xx bits */
136 struct grouplist
*ht_grp
;
137 struct hostlist
*ht_next
;
147 char *add_expdir(struct dirlist
**, char *, int);
148 void add_dlist(struct dirlist
**, struct dirlist
*,
149 struct grouplist
*, int);
150 void add_mlist(char *, char *);
151 int check_dirpath(char *);
152 int check_options(struct dirlist
*);
153 int checkmask(struct sockaddr
*sa
);
154 int chk_host(struct dirlist
*, struct sockaddr
*, int *, int *);
155 void create_service(struct netconfig
*nconf
);
156 void del_mlist(char *, char *);
157 struct dirlist
*dirp_search(struct dirlist
*, char *);
158 int do_mount(struct exportlist
*, struct grouplist
*, int,
159 struct ucred
*, char *, int, struct statfs
*);
160 int do_opt(char **, char **, struct exportlist
*, struct grouplist
*,
161 int *, int *, struct ucred
*);
162 struct exportlist
*ex_search(fsid_t
*);
163 struct exportlist
*get_exp(void);
164 void free_dir(struct dirlist
*);
165 void free_exp(struct exportlist
*);
166 void free_grp(struct grouplist
*);
167 void free_host(struct hostlist
*);
168 void get_exportlist(void);
169 int get_host(char *, struct grouplist
*, struct grouplist
*);
170 struct hostlist
*get_ht(void);
172 void get_mountlist(void);
173 int get_net(char *, struct netmsk
*, int);
174 void getexp_err(struct exportlist
*, struct grouplist
*);
175 struct grouplist
*get_grp(void);
176 void hang_dirp(struct dirlist
*, struct grouplist
*,
177 struct exportlist
*, int);
178 void huphandler(int sig
);
179 int makemask(struct sockaddr_storage
*ssp
, int bitlen
);
180 void mntsrv(struct svc_req
*, SVCXPRT
*);
181 void nextfield(char **, char **);
182 void out_of_mem(void);
183 void parsecred(char *, struct ucred
*);
184 int put_exlist(struct dirlist
*, XDR
*, struct dirlist
*, int *, int);
185 void *sa_rawaddr(struct sockaddr
*sa
, int *nbytes
);
186 int sacmp(struct sockaddr
*sa1
, struct sockaddr
*sa2
,
187 struct sockaddr
*samask
);
188 int scan_tree(struct dirlist
*, struct sockaddr
*);
189 static void usage(void);
190 int xdr_dir(XDR
*, char *);
191 int xdr_explist(XDR
*, caddr_t
);
192 int xdr_explist_brief(XDR
*, caddr_t
);
193 int xdr_fhs(XDR
*, caddr_t
);
194 int xdr_mlist(XDR
*, caddr_t
);
197 struct exportlist
*exphead
;
198 struct mountlist
*mlhead
;
199 struct grouplist
*grphead
;
200 char *exnames_default
[2] = { _PATH_EXPORTS
, NULL
};
203 struct ucred def_anon
= {
210 int resvport_only
= 1;
217 char *svcport_str
= NULL
;
219 static int have_v6
= 1;
221 struct pidfh
*pfh
= NULL
;
222 /* Bits for the opt_flags above */
223 #define OP_MAPROOT 0x01
224 #define OP_MAPALL 0x02
228 #define OP_ALLDIRS 0x40
229 #define OP_HAVEMASK 0x80 /* A mask was specified or inferred. */
230 #define OP_QUIET 0x100
231 #define OP_MASKLEN 0x200
235 void SYSLOG(int, const char *, ...);
236 #define syslog SYSLOG
242 * Mountd server for NFS mount protocol as described in:
243 * NFS: Network File System Protocol Specification, RFC1094, Appendix A
244 * The optional arguments are the exports file name
245 * default: _PATH_EXPORTS
246 * and "-n" to allow nonroot mount.
249 main(int argc
, char **argv
)
252 struct netconfig
*nconf
;
253 char *endptr
, **hosts_bak
;
258 int maxrec
= RPC_MAXDATASIZE
;
260 /* Check that another mountd isn't already running. */
261 pfh
= pidfile_open(_PATH_MOUNTDPID
, 0600, &otherpid
);
264 errx(1, "mountd already running, pid: %d.", otherpid
);
265 warn("cannot open or create pidfile");
268 s
= socket(AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
273 if (modfind("nfs") < 0) {
274 /* Not present in kernel, try loading it */
275 if (kldload("nfs") < 0 || modfind("nfs") < 0)
276 errx(1, "NFS server is not available or loadable");
279 while ((c
= getopt(argc
, argv
, "2dh:lnp:r")) != -1) {
291 debug
= debug
? 0 : 1;
298 svcport
= (in_port_t
)strtoul(optarg
, &endptr
, 10);
299 if (endptr
== NULL
|| *endptr
!= '\0' ||
300 svcport
== 0 || svcport
>= IPPORT_MAX
)
302 svcport_str
= strdup(optarg
);
307 hosts_bak
= realloc(hosts
, nhosts
* sizeof(char *));
308 if (hosts_bak
== NULL
) {
310 for (k
= 0; k
< nhosts
; k
++)
317 hosts
[nhosts
- 1] = strdup(optarg
);
318 if (hosts
[nhosts
- 1] == NULL
) {
319 for (k
= 0; k
< (nhosts
- 1); k
++)
331 signal(SIGINT
, SIG_IGN
);
332 signal(SIGQUIT
, SIG_IGN
);
342 exnames
= exnames_default
;
343 openlog("mountd", LOG_PID
, LOG_DAEMON
);
345 warnx("getting export list");
348 warnx("getting mount list");
352 signal(SIGHUP
, huphandler
);
353 signal(SIGTERM
, terminate
);
354 signal(SIGPIPE
, SIG_IGN
);
358 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER1
, NULL
);
359 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER3
, NULL
);
361 rpc_control(RPC_SVC_CONNMAXREC_SET
, &maxrec
);
363 if (!resvport_only
) {
364 if (sysctlbyname("vfs.nfs.nfs_privport", NULL
, NULL
,
365 &resvport_only
, sizeof(resvport_only
)) != 0 &&
367 syslog(LOG_ERR
, "sysctl: %m");
373 * If no hosts were specified, add a wildcard entry to bind to
374 * INADDR_ANY. Otherwise make sure 127.0.0.1 and ::1 are added to the
378 hosts
= malloc(sizeof(char**));
386 hosts_bak
= realloc(hosts
, (nhosts
+ 2) *
388 if (hosts_bak
== NULL
) {
389 for (k
= 0; k
< nhosts
; k
++)
396 hosts
[nhosts
- 2] = "::1";
398 hosts_bak
= realloc(hosts
, (nhosts
+ 1) * sizeof(char *));
399 if (hosts_bak
== NULL
) {
400 for (k
= 0; k
< nhosts
; k
++)
409 hosts
[nhosts
- 1] = "127.0.0.1";
412 nc_handle
= setnetconfig();
413 while ((nconf
= getnetconfig(nc_handle
))) {
414 if (nconf
->nc_flag
& NC_VISIBLE
) {
415 if (have_v6
== 0 && strcmp(nconf
->nc_protofmly
,
419 create_service(nconf
);
422 endnetconfig(nc_handle
);
425 syslog(LOG_ERR
, "could not create any services");
429 /* Expand svc_run() here so that we can call get_exportlist(). */
436 switch (select(svc_maxfd
+ 1, &readfds
, NULL
, NULL
, NULL
)) {
440 syslog(LOG_ERR
, "mountd died: select: %m");
445 svc_getreqset(&readfds
);
451 * This routine creates and binds sockets on the appropriate
452 * addresses. It gets called one time for each transport and
453 * registrates the service with rpcbind on that trasport.
456 create_service(struct netconfig
*nconf
)
458 struct addrinfo hints
, *res
= NULL
;
459 struct sockaddr_in
*sin
;
460 struct sockaddr_in6
*sin6
;
461 struct __rpc_sockinfo si
;
462 struct netbuf servaddr
;
463 SVCXPRT
*transp
= NULL
;
470 u_int32_t host_addr
[4]; /* IPv4 or IPv6 */
472 if ((nconf
->nc_semantics
!= NC_TPI_CLTS
) &&
473 (nconf
->nc_semantics
!= NC_TPI_COTS
) &&
474 (nconf
->nc_semantics
!= NC_TPI_COTS_ORD
))
475 return; /* not my type */
478 * XXX - using RPC library internal functions.
480 if (!__rpc_nconf2sockinfo(nconf
, &si
)) {
481 syslog(LOG_ERR
, "cannot get information for %s",
486 /* Get mountd's address on this transport */
487 memset(&hints
, 0, sizeof hints
);
488 hints
.ai_flags
= AI_PASSIVE
;
489 hints
.ai_family
= si
.si_af
;
490 hints
.ai_socktype
= si
.si_socktype
;
491 hints
.ai_protocol
= si
.si_proto
;
494 * Bind to specific IPs if asked to
497 while (nhostsbak
> 0) {
500 * XXX - using RPC library internal functions.
502 if ((fd
= __rpc_nconf2fd(nconf
)) < 0) {
504 if (errno
== EPROTONOSUPPORT
&&
505 nconf
->nc_semantics
!= NC_TPI_CLTS
)
508 syslog(non_fatal
? LOG_DEBUG
: LOG_ERR
,
509 "cannot create socket for %s", nconf
->nc_netid
);
513 switch (hints
.ai_family
) {
515 if (inet_pton(AF_INET
, hosts
[nhostsbak
],
517 hints
.ai_flags
&= AI_NUMERICHOST
;
520 * Skip if we have an AF_INET6 address.
522 if (inet_pton(AF_INET6
, hosts
[nhostsbak
],
530 if (inet_pton(AF_INET6
, hosts
[nhostsbak
],
532 hints
.ai_flags
&= AI_NUMERICHOST
;
535 * Skip if we have an AF_INET address.
537 if (inet_pton(AF_INET
, hosts
[nhostsbak
],
545 * We're doing host-based access checks here, so don't
546 * allow v4-in-v6 to confuse things. The kernel will
547 * disable it by default on NFS sockets too.
549 if (setsockopt(fd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &one
,
552 "can't disable v4-in-v6 on IPv6 socket");
561 * If no hosts were specified, just bind to INADDR_ANY
563 if (strcmp("*", hosts
[nhostsbak
]) == 0) {
564 if (svcport_str
== NULL
) {
565 res
= malloc(sizeof(struct addrinfo
));
568 res
->ai_flags
= hints
.ai_flags
;
569 res
->ai_family
= hints
.ai_family
;
570 res
->ai_protocol
= hints
.ai_protocol
;
571 switch (res
->ai_family
) {
573 sin
= malloc(sizeof(struct sockaddr_in
));
576 sin
->sin_family
= AF_INET
;
577 sin
->sin_port
= htons(0);
578 sin
->sin_addr
.s_addr
= htonl(INADDR_ANY
);
579 res
->ai_addr
= (struct sockaddr
*) sin
;
580 res
->ai_addrlen
= (socklen_t
)
581 sizeof(res
->ai_addr
);
584 sin6
= malloc(sizeof(struct sockaddr_in6
));
587 sin6
->sin6_family
= AF_INET6
;
588 sin6
->sin6_port
= htons(0);
589 sin6
->sin6_addr
= in6addr_any
;
590 res
->ai_addr
= (struct sockaddr
*) sin6
;
591 res
->ai_addrlen
= (socklen_t
)
592 sizeof(res
->ai_addr
);
598 if ((aicode
= getaddrinfo(NULL
, svcport_str
,
599 &hints
, &res
)) != 0) {
601 "cannot get local address for %s: %s",
603 gai_strerror(aicode
));
608 if ((aicode
= getaddrinfo(hosts
[nhostsbak
], svcport_str
,
609 &hints
, &res
)) != 0) {
611 "cannot get local address for %s: %s",
612 nconf
->nc_netid
, gai_strerror(aicode
));
617 r
= bindresvport_sa(fd
, res
->ai_addr
);
619 syslog(LOG_ERR
, "bindresvport_sa: %m");
623 if (nconf
->nc_semantics
!= NC_TPI_CLTS
)
624 listen(fd
, SOMAXCONN
);
626 if (nconf
->nc_semantics
== NC_TPI_CLTS
)
627 transp
= svc_dg_create(fd
, 0, 0);
629 transp
= svc_vc_create(fd
, RPC_MAXDATASIZE
,
632 if (transp
!= (SVCXPRT
*) NULL
) {
633 if (!svc_reg(transp
, RPCPROG_MNT
, RPCMNT_VER1
, mntsrv
,
636 "can't register %s RPCMNT_VER1 service",
639 if (!svc_reg(transp
, RPCPROG_MNT
, RPCMNT_VER3
,
642 "can't register %s RPCMNT_VER3 service",
646 syslog(LOG_WARNING
, "can't create %s services",
649 if (registered
== 0) {
651 memset(&hints
, 0, sizeof hints
);
652 hints
.ai_flags
= AI_PASSIVE
;
653 hints
.ai_family
= si
.si_af
;
654 hints
.ai_socktype
= si
.si_socktype
;
655 hints
.ai_protocol
= si
.si_proto
;
657 if (svcport_str
== NULL
) {
658 svcport_str
= malloc(NI_MAXSERV
* sizeof(char));
659 if (svcport_str
== NULL
)
662 if (getnameinfo(res
->ai_addr
,
663 res
->ai_addr
->sa_len
, NULL
, NI_MAXHOST
,
664 svcport_str
, NI_MAXSERV
* sizeof(char),
665 NI_NUMERICHOST
| NI_NUMERICSERV
))
666 errx(1, "Cannot get port number");
669 if((aicode
= getaddrinfo(NULL
, svcport_str
, &hints
,
671 syslog(LOG_ERR
, "cannot get local address: %s",
672 gai_strerror(aicode
));
676 servaddr
.buf
= malloc(res
->ai_addrlen
);
677 memcpy(servaddr
.buf
, res
->ai_addr
, res
->ai_addrlen
);
678 servaddr
.len
= res
->ai_addrlen
;
680 rpcb_set(RPCPROG_MNT
, RPCMNT_VER1
, nconf
, &servaddr
);
681 rpcb_set(RPCPROG_MNT
, RPCMNT_VER3
, nconf
, &servaddr
);
693 "usage: mountd [-2] [-d] [-l] [-n] [-p <port>] [-r] "
694 "[-h <bindip>] [export_file ...]\n");
699 * The mount rpc service
702 mntsrv(struct svc_req
*rqstp
, SVCXPRT
*transp
)
704 struct exportlist
*ep
;
709 char host
[NI_MAXHOST
], numerichost
[NI_MAXHOST
];
710 int lookup_failed
= 1;
711 struct sockaddr
*saddr
;
713 char rpcpath
[RPCMNT_PATHLEN
+ 1], dirpath
[MAXPATHLEN
];
714 int bad
= 0, defset
, hostset
;
715 sigset_t sighup_mask
;
717 sigemptyset(&sighup_mask
);
718 sigaddset(&sighup_mask
, SIGHUP
);
719 saddr
= svc_getrpccaller(transp
)->buf
;
720 switch (saddr
->sa_family
) {
722 sport
= ntohs(((struct sockaddr_in6
*)saddr
)->sin6_port
);
725 sport
= ntohs(((struct sockaddr_in
*)saddr
)->sin_port
);
728 syslog(LOG_ERR
, "request from unknown address family");
731 lookup_failed
= getnameinfo(saddr
, saddr
->sa_len
, host
, sizeof host
,
733 getnameinfo(saddr
, saddr
->sa_len
, numerichost
,
734 sizeof numerichost
, NULL
, 0, NI_NUMERICHOST
);
735 switch (rqstp
->rq_proc
) {
737 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
738 syslog(LOG_ERR
, "can't send reply");
741 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
743 "mount request from %s from unprivileged port",
745 svcerr_weakauth(transp
);
748 if (!svc_getargs(transp
, (xdrproc_t
)xdr_dir
, rpcpath
)) {
749 syslog(LOG_NOTICE
, "undecodable mount request from %s",
751 svcerr_decode(transp
);
756 * Get the real pathname and make sure it is a directory
757 * or a regular file if the -r option was specified
760 if (realpath(rpcpath
, dirpath
) == NULL
||
761 stat(dirpath
, &stb
) < 0 ||
762 (!S_ISDIR(stb
.st_mode
) &&
763 (dir_only
|| !S_ISREG(stb
.st_mode
))) ||
764 statfs(dirpath
, &fsb
) < 0) {
765 chdir("/"); /* Just in case realpath doesn't */
767 "mount request from %s for non existent path %s",
768 numerichost
, dirpath
);
770 warnx("stat failed on %s", dirpath
);
771 bad
= ENOENT
; /* We will send error reply later */
774 /* Check in the exports list */
775 sigprocmask(SIG_BLOCK
, &sighup_mask
, NULL
);
776 ep
= ex_search(&fsb
.f_fsid
);
777 hostset
= defset
= 0;
778 if (ep
&& (chk_host(ep
->ex_defdir
, saddr
, &defset
, &hostset
) ||
779 ((dp
= dirp_search(ep
->ex_dirl
, dirpath
)) &&
780 chk_host(dp
, saddr
, &defset
, &hostset
)) ||
781 (defset
&& scan_tree(ep
->ex_defdir
, saddr
) == 0 &&
782 scan_tree(ep
->ex_dirl
, saddr
) == 0))) {
784 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_long
,
786 syslog(LOG_ERR
, "can't send reply");
787 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
790 if (hostset
& DP_HOSTSET
)
791 fhr
.fhr_flag
= hostset
;
793 fhr
.fhr_flag
= defset
;
794 fhr
.fhr_vers
= rqstp
->rq_vers
;
795 /* Get the file handle */
796 memset(&fhr
.fhr_fh
, 0, sizeof(nfsfh_t
));
797 if (getfh(dirpath
, (fhandle_t
*)&fhr
.fhr_fh
) < 0) {
799 syslog(LOG_ERR
, "can't get fh for %s", dirpath
);
800 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_long
,
802 syslog(LOG_ERR
, "can't send reply");
803 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
806 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_fhs
, &fhr
))
807 syslog(LOG_ERR
, "can't send reply");
809 add_mlist(host
, dirpath
);
811 add_mlist(numerichost
, dirpath
);
813 warnx("mount successful");
816 "mount request succeeded from %s for %s",
817 numerichost
, dirpath
);
821 "mount request denied from %s for %s",
822 numerichost
, dirpath
);
825 if (bad
&& !svc_sendreply(transp
, (xdrproc_t
)xdr_long
, &bad
))
826 syslog(LOG_ERR
, "can't send reply");
827 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
830 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_mlist
, NULL
))
831 syslog(LOG_ERR
, "can't send reply");
834 "dump request succeeded from %s",
838 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
840 "umount request from %s from unprivileged port",
842 svcerr_weakauth(transp
);
845 if (!svc_getargs(transp
, (xdrproc_t
)xdr_dir
, rpcpath
)) {
846 syslog(LOG_NOTICE
, "undecodable umount request from %s",
848 svcerr_decode(transp
);
851 if (realpath(rpcpath
, dirpath
) == NULL
) {
852 syslog(LOG_NOTICE
, "umount request from %s "
853 "for non existent path %s",
854 numerichost
, dirpath
);
856 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
857 syslog(LOG_ERR
, "can't send reply");
859 del_mlist(host
, dirpath
);
860 del_mlist(numerichost
, dirpath
);
863 "umount request succeeded from %s for %s",
864 numerichost
, dirpath
);
867 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
869 "umountall request from %s from unprivileged port",
871 svcerr_weakauth(transp
);
874 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
875 syslog(LOG_ERR
, "can't send reply");
877 del_mlist(host
, NULL
);
878 del_mlist(numerichost
, NULL
);
881 "umountall request succeeded from %s",
885 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_explist
, NULL
))
886 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_explist_brief
, NULL
))
887 syslog(LOG_ERR
, "can't send reply");
890 "export request succeeded from %s",
894 svcerr_noproc(transp
);
900 * Xdr conversion for a dirpath string
903 xdr_dir(XDR
*xdrsp
, char *dirp
)
905 return (xdr_string(xdrsp
, &dirp
, RPCMNT_PATHLEN
));
909 * Xdr routine to generate file handle reply
912 xdr_fhs(XDR
*xdrsp
, caddr_t cp
)
914 struct fhreturn
*fhrp
= (struct fhreturn
*)cp
;
915 u_long ok
= 0, len
, auth
;
917 if (!xdr_long(xdrsp
, &ok
))
919 switch (fhrp
->fhr_vers
) {
921 return (xdr_opaque(xdrsp
, (caddr_t
)&fhrp
->fhr_fh
, NFSX_V2FH
));
924 if (!xdr_long(xdrsp
, &len
))
926 if (!xdr_opaque(xdrsp
, (caddr_t
)&fhrp
->fhr_fh
, len
))
930 if (!xdr_long(xdrsp
, &len
))
932 return (xdr_long(xdrsp
, &auth
));
938 xdr_mlist(XDR
*xdrsp
, caddr_t cp
)
940 struct mountlist
*mlp
;
947 if (!xdr_bool(xdrsp
, &true))
949 strp
= &mlp
->ml_host
[0];
950 if (!xdr_string(xdrsp
, &strp
, RPCMNT_NAMELEN
))
952 strp
= &mlp
->ml_dirp
[0];
953 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
957 if (!xdr_bool(xdrsp
, &false))
963 * Xdr conversion for export list
966 xdr_explist_common(XDR
*xdrsp
, caddr_t cp
, int brief
)
968 struct exportlist
*ep
;
971 sigset_t sighup_mask
;
973 sigemptyset(&sighup_mask
);
974 sigaddset(&sighup_mask
, SIGHUP
);
975 sigprocmask(SIG_BLOCK
, &sighup_mask
, NULL
);
979 if (put_exlist(ep
->ex_dirl
, xdrsp
, ep
->ex_defdir
,
982 if (ep
->ex_defdir
&& putdef
== 0 &&
983 put_exlist(ep
->ex_defdir
, xdrsp
, NULL
,
988 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
989 if (!xdr_bool(xdrsp
, &false))
993 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
998 * Called from xdr_explist() to traverse the tree and export the
1002 put_exlist(struct dirlist
*dp
, XDR
*xdrsp
, struct dirlist
*adp
, int *putdefp
, int brief
)
1004 struct grouplist
*grp
;
1005 struct hostlist
*hp
;
1012 if (put_exlist(dp
->dp_left
, xdrsp
, adp
, putdefp
, brief
))
1014 if (!xdr_bool(xdrsp
, &true))
1017 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
1019 if (adp
&& !strcmp(dp
->dp_dirp
, adp
->dp_dirp
)) {
1024 if (!xdr_bool(xdrsp
, &true))
1027 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
1029 } else if ((dp
->dp_flag
& DP_DEFSET
) == 0 &&
1030 (gotalldir
== 0 || (adp
->dp_flag
& DP_DEFSET
) == 0)) {
1034 if (grp
->gr_type
== GT_HOST
) {
1035 if (!xdr_bool(xdrsp
, &true))
1037 strp
= grp
->gr_ptr
.gt_addrinfo
->ai_canonname
;
1038 if (!xdr_string(xdrsp
, &strp
,
1041 } else if (grp
->gr_type
== GT_NET
) {
1042 if (!xdr_bool(xdrsp
, &true))
1044 strp
= grp
->gr_ptr
.gt_net
.nt_name
;
1045 if (!xdr_string(xdrsp
, &strp
,
1050 if (gotalldir
&& hp
== NULL
) {
1056 if (!xdr_bool(xdrsp
, &false))
1058 if (put_exlist(dp
->dp_right
, xdrsp
, adp
, putdefp
, brief
))
1065 xdr_explist(XDR
*xdrsp
, caddr_t cp
)
1068 return xdr_explist_common(xdrsp
, cp
, 0);
1072 xdr_explist_brief(XDR
*xdrsp
, caddr_t cp
)
1075 return xdr_explist_common(xdrsp
, cp
, 1);
1083 * Get the export list from one, currently open file
1086 get_exportlist_one(void)
1088 struct exportlist
*ep
, *ep2
;
1089 struct grouplist
*grp
, *tgrp
;
1090 struct exportlist
**epp
;
1091 struct dirlist
*dirhead
;
1094 char *cp
, *endcp
, *dirp
, *hst
, *usr
, *dom
, savedc
;
1095 int len
, has_host
, exflags
, got_nondir
, dirplen
, netgrp
;
1098 while (get_line()) {
1100 warnx("got line %s", line
);
1102 nextfield(&cp
, &endcp
);
1111 exflags
= MNT_EXPORTED
;
1117 * Create new exports list entry
1120 tgrp
= grp
= get_grp();
1122 if (len
> RPCMNT_NAMELEN
) {
1123 getexp_err(ep
, tgrp
);
1128 getexp_err(ep
, tgrp
);
1132 warnx("doing opt %s", cp
);
1134 if (do_opt(&cp
, &endcp
, ep
, grp
, &has_host
,
1136 getexp_err(ep
, tgrp
);
1139 } else if (*cp
== '/') {
1142 if (check_dirpath(cp
) &&
1143 statfs(cp
, &fsb
) >= 0) {
1145 syslog(LOG_ERR
, "dirs must be first");
1146 getexp_err(ep
, tgrp
);
1150 if (ep
->ex_fs
.val
[0] != fsb
.f_fsid
.val
[0] ||
1151 ep
->ex_fs
.val
[1] != fsb
.f_fsid
.val
[1]) {
1152 getexp_err(ep
, tgrp
);
1157 * See if this directory is already
1160 ep
= ex_search(&fsb
.f_fsid
);
1163 ep
->ex_fs
= fsb
.f_fsid
;
1164 ep
->ex_fsdir
= (char *)
1165 malloc(strlen(fsb
.f_mntonname
) + 1);
1167 strcpy(ep
->ex_fsdir
,
1172 warnx("making new ep fs=0x%x,0x%x",
1176 warnx("found ep fs=0x%x,0x%x",
1182 * Add dirpath to export mount point.
1184 dirp
= add_expdir(&dirhead
, cp
, len
);
1187 getexp_err(ep
, tgrp
);
1196 getexp_err(ep
, tgrp
);
1201 * Get the host or netgroup.
1204 netgrp
= getnetgrent(&hst
, &usr
, &dom
);
1207 grp
->gr_next
= get_grp();
1213 "null hostname in netgroup %s, skipping", cp
);
1214 grp
->gr_type
= GT_IGNORE
;
1215 } else if (get_host(hst
, grp
, tgrp
)) {
1217 "bad host %s in netgroup %s, skipping", hst
, cp
);
1218 grp
->gr_type
= GT_IGNORE
;
1220 } else if (get_host(cp
, grp
, tgrp
)) {
1221 syslog(LOG_ERR
, "bad host %s, skipping", cp
);
1222 grp
->gr_type
= GT_IGNORE
;
1225 } while (netgrp
&& getnetgrent(&hst
, &usr
, &dom
));
1230 nextfield(&cp
, &endcp
);
1233 if (check_options(dirhead
)) {
1234 getexp_err(ep
, tgrp
);
1238 grp
->gr_type
= GT_DEFAULT
;
1240 warnx("adding a default entry");
1243 * Don't allow a network export coincide with a list of
1244 * host(s) on the same line.
1246 } else if ((opt_flags
& OP_NET
) && tgrp
->gr_next
) {
1247 syslog(LOG_ERR
, "network/host conflict");
1248 getexp_err(ep
, tgrp
);
1252 * If an export list was specified on this line, make sure
1253 * that we have at least one valid entry, otherwise skip it.
1257 while (grp
&& grp
->gr_type
== GT_IGNORE
)
1260 getexp_err(ep
, tgrp
);
1266 * Loop through hosts, pushing the exports into the kernel.
1267 * After loop, tgrp points to the start of the list and
1268 * grp points to the last entry in the list.
1272 if (do_mount(ep
, grp
, exflags
, &anon
, dirp
, dirplen
,
1274 getexp_err(ep
, tgrp
);
1277 } while (grp
->gr_next
&& (grp
= grp
->gr_next
));
1280 * Success. Update the data structures.
1283 hang_dirp(dirhead
, tgrp
, ep
, opt_flags
);
1284 grp
->gr_next
= grphead
;
1287 hang_dirp(dirhead
, NULL
, ep
,
1292 if ((ep
->ex_flag
& EX_LINKED
) == 0) {
1297 * Insert in the list in alphabetical order.
1299 while (ep2
&& strcmp(ep2
->ex_fsdir
, ep
->ex_fsdir
) < 0) {
1300 epp
= &ep2
->ex_next
;
1306 ep
->ex_flag
|= EX_LINKED
;
1318 * Get the export list from all specified files
1321 get_exportlist(void)
1323 struct exportlist
*ep
, *ep2
;
1324 struct grouplist
*grp
, *tgrp
;
1325 struct statfs
*fsp
, *mntbufp
;
1328 int dirplen
, num
, i
;
1335 * First, get rid of the old list
1354 * And delete exports that are in the kernel for all local
1356 * XXX: Should know how to handle all local exportable filesystems.
1358 num
= getmntinfo(&mntbufp
, MNT_NOWAIT
);
1359 for (i
= 0; i
< num
; i
++) {
1364 struct msdosfs_args da
;
1365 struct ntfs_args na
;
1367 struct export_args export
;
1370 if (getvfsbyname(fsp
->f_fstypename
, &vfc
) != 0) {
1371 syslog(LOG_ERR
, "getvfsbyname() failed for %s",
1377 * Do not delete export for network filesystem by
1378 * passing "export" arg to mount().
1379 * It only makes sense to do this for local filesystems.
1381 if (vfc
.vfc_flags
& VFCF_NETWORK
)
1384 export
.ex_flags
= MNT_DELEXPORT
;
1385 if (mountctl(fsp
->f_mntonname
, MOUNTCTL_SET_EXPORT
, -1,
1386 &export
, sizeof(export
), NULL
, 0) == 0) {
1387 } else if (!strcmp(fsp
->f_fstypename
, "mfs") ||
1388 !strcmp(fsp
->f_fstypename
, "ufs") ||
1389 !strcmp(fsp
->f_fstypename
, "msdos") ||
1390 !strcmp(fsp
->f_fstypename
, "ntfs") ||
1391 !strcmp(fsp
->f_fstypename
, "cd9660")) {
1392 bzero(&targs
, sizeof targs
);
1393 targs
.ua
.fspec
= NULL
;
1394 targs
.ua
.export
.ex_flags
= MNT_DELEXPORT
;
1395 if (mount(fsp
->f_fstypename
, fsp
->f_mntonname
,
1396 fsp
->f_flags
| MNT_UPDATE
,
1397 (caddr_t
)&targs
) < 0)
1398 syslog(LOG_ERR
, "can't delete exports for %s",
1404 * Read in the exports file and build the list, calling
1405 * nmount() as we go along to push the export rules into the kernel.
1408 for (i
= 0; exnames
[i
] != NULL
; i
++) {
1410 warnx("reading exports from %s", exnames
[i
]);
1411 if ((exp_file
= fopen(exnames
[i
], "r")) == NULL
) {
1412 syslog(LOG_WARNING
, "can't open %s", exnames
[i
]);
1415 get_exportlist_one();
1420 syslog(LOG_ERR
, "can't open any exports file");
1426 * Allocate an export list element
1431 struct exportlist
*ep
;
1433 ep
= (struct exportlist
*)malloc(sizeof (struct exportlist
));
1436 memset(ep
, 0, sizeof(struct exportlist
));
1441 * Allocate a group list element
1446 struct grouplist
*gp
;
1448 gp
= (struct grouplist
*)malloc(sizeof (struct grouplist
));
1451 memset(gp
, 0, sizeof(struct grouplist
));
1456 * Clean up upon an error in get_exportlist().
1459 getexp_err(struct exportlist
*ep
, struct grouplist
*grp
)
1461 struct grouplist
*tgrp
;
1463 if (!(opt_flags
& OP_QUIET
))
1464 syslog(LOG_ERR
, "bad exports list line %s", line
);
1465 if (ep
&& (ep
->ex_flag
& EX_LINKED
) == 0)
1475 * Search the export list for a matching fs.
1478 ex_search(fsid_t
*fsid
)
1480 struct exportlist
*ep
;
1484 if (ep
->ex_fs
.val
[0] == fsid
->val
[0] &&
1485 ep
->ex_fs
.val
[1] == fsid
->val
[1])
1493 * Add a directory path to the list.
1496 add_expdir(struct dirlist
**dpp
, char *cp
, int len
)
1500 dp
= (struct dirlist
*)malloc(sizeof (struct dirlist
) + len
);
1504 dp
->dp_right
= NULL
;
1506 dp
->dp_hosts
= NULL
;
1507 strcpy(dp
->dp_dirp
, cp
);
1509 return (dp
->dp_dirp
);
1513 * Hang the dir list element off the dirpath binary tree as required
1514 * and update the entry for host.
1517 hang_dirp(struct dirlist
*dp
, struct grouplist
*grp
, struct exportlist
*ep
,
1520 struct hostlist
*hp
;
1521 struct dirlist
*dp2
;
1523 if (flags
& OP_ALLDIRS
) {
1529 ep
->ex_defdir
->dp_flag
|= DP_DEFSET
;
1530 } else while (grp
) {
1533 hp
->ht_next
= ep
->ex_defdir
->dp_hosts
;
1534 ep
->ex_defdir
->dp_hosts
= hp
;
1540 * Loop through the directories adding them to the tree.
1544 add_dlist(&ep
->ex_dirl
, dp
, grp
, flags
);
1551 * Traverse the binary tree either updating a node that is already there
1552 * for the new directory or adding the new node.
1555 add_dlist(struct dirlist
**dpp
, struct dirlist
*newdp
, struct grouplist
*grp
,
1559 struct hostlist
*hp
;
1564 cmp
= strcmp(dp
->dp_dirp
, newdp
->dp_dirp
);
1566 add_dlist(&dp
->dp_left
, newdp
, grp
, flags
);
1568 } else if (cmp
< 0) {
1569 add_dlist(&dp
->dp_right
, newdp
, grp
, flags
);
1572 free((caddr_t
)newdp
);
1581 * Hang all of the host(s) off of the directory point.
1586 hp
->ht_next
= dp
->dp_hosts
;
1591 dp
->dp_flag
|= DP_DEFSET
;
1596 * Search for a dirpath on the export point.
1599 dirp_search(struct dirlist
*dp
, char *dirp
)
1604 cmp
= strcmp(dp
->dp_dirp
, dirp
);
1606 return (dirp_search(dp
->dp_left
, dirp
));
1608 return (dirp_search(dp
->dp_right
, dirp
));
1616 * Scan for a host match in a directory tree.
1619 chk_host(struct dirlist
*dp
, struct sockaddr
*saddr
, int *defsetp
,
1622 struct hostlist
*hp
;
1623 struct grouplist
*grp
;
1624 struct addrinfo
*ai
;
1627 if (dp
->dp_flag
& DP_DEFSET
)
1628 *defsetp
= dp
->dp_flag
;
1632 switch (grp
->gr_type
) {
1634 ai
= grp
->gr_ptr
.gt_addrinfo
;
1635 for (; ai
; ai
= ai
->ai_next
) {
1636 if (!sacmp(ai
->ai_addr
, saddr
, NULL
)) {
1638 (hp
->ht_flag
| DP_HOSTSET
);
1644 if (!sacmp(saddr
, (struct sockaddr
*)
1645 &grp
->gr_ptr
.gt_net
.nt_net
,
1647 &grp
->gr_ptr
.gt_net
.nt_mask
)) {
1648 *hostsetp
= (hp
->ht_flag
| DP_HOSTSET
);
1660 * Scan tree for a host that matches the address.
1663 scan_tree(struct dirlist
*dp
, struct sockaddr
*saddr
)
1665 int defset
, hostset
;
1668 if (scan_tree(dp
->dp_left
, saddr
))
1670 if (chk_host(dp
, saddr
, &defset
, &hostset
))
1672 if (scan_tree(dp
->dp_right
, saddr
))
1679 * Traverse the dirlist tree and free it up.
1682 free_dir(struct dirlist
*dp
)
1686 free_dir(dp
->dp_left
);
1687 free_dir(dp
->dp_right
);
1688 free_host(dp
->dp_hosts
);
1694 * Parse the option string and update fields.
1695 * Option arguments may either be -<option>=<value> or
1699 do_opt(char **cpp
, char **endcpp
, struct exportlist
*ep
, struct grouplist
*grp
,
1700 int *has_hostp
, int *exflagsp
, struct ucred
*cr
)
1702 char *cpoptarg
, *cpoptend
;
1703 char *cp
, *endcp
, *cpopt
, savedc
, savedc2
;
1704 int allflag
, usedarg
;
1712 while (cpopt
&& *cpopt
) {
1715 if ((cpoptend
= strchr(cpopt
, ','))) {
1717 if ((cpoptarg
= strchr(cpopt
, '=')))
1720 if ((cpoptarg
= strchr(cpopt
, '=')))
1724 nextfield(&cp
, &endcp
);
1726 if (endcp
> cp
&& *cp
!= '-') {
1734 if (!strcmp(cpopt
, "ro") || !strcmp(cpopt
, "o")) {
1735 *exflagsp
|= MNT_EXRDONLY
;
1736 } else if (cpoptarg
&& (!strcmp(cpopt
, "maproot") ||
1737 !(allflag
= strcmp(cpopt
, "mapall")) ||
1738 !strcmp(cpopt
, "root") || !strcmp(cpopt
, "r"))) {
1740 parsecred(cpoptarg
, cr
);
1742 *exflagsp
|= MNT_EXPORTANON
;
1743 opt_flags
|= OP_MAPALL
;
1745 opt_flags
|= OP_MAPROOT
;
1746 } else if (cpoptarg
&& (!strcmp(cpopt
, "mask") ||
1747 !strcmp(cpopt
, "m"))) {
1748 if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 1)) {
1749 syslog(LOG_ERR
, "bad mask: %s", cpoptarg
);
1753 opt_flags
|= OP_MASK
;
1754 } else if (cpoptarg
&& (!strcmp(cpopt
, "network") ||
1755 !strcmp(cpopt
, "n"))) {
1756 if (strchr(cpoptarg
, '/') != NULL
) {
1758 fprintf(stderr
, "setting OP_MASKLEN\n");
1759 opt_flags
|= OP_MASKLEN
;
1761 if (grp
->gr_type
!= GT_NULL
) {
1762 syslog(LOG_ERR
, "network/host conflict");
1764 } else if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 0)) {
1765 syslog(LOG_ERR
, "bad net: %s", cpoptarg
);
1768 grp
->gr_type
= GT_NET
;
1771 opt_flags
|= OP_NET
;
1772 } else if (!strcmp(cpopt
, "alldirs")) {
1773 opt_flags
|= OP_ALLDIRS
;
1774 } else if (!strcmp(cpopt
, "public")) {
1775 *exflagsp
|= MNT_EXPUBLIC
;
1776 } else if (!strcmp(cpopt
, "webnfs")) {
1777 *exflagsp
|= (MNT_EXPUBLIC
|MNT_EXRDONLY
|MNT_EXPORTANON
);
1778 opt_flags
|= OP_MAPALL
;
1779 } else if (cpoptarg
&& !strcmp(cpopt
, "index")) {
1780 ep
->ex_indexfile
= strdup(cpoptarg
);
1781 } else if (!strcmp(cpopt
, "quiet")) {
1782 opt_flags
|= OP_QUIET
;
1784 syslog(LOG_ERR
, "bad opt %s", cpopt
);
1803 * Translate a character string to the corresponding list of network
1804 * addresses for a hostname.
1807 get_host(char *cp
, struct grouplist
*grp
, struct grouplist
*tgrp
)
1809 struct grouplist
*checkgrp
;
1810 struct addrinfo
*ai
, *tai
, hints
;
1812 char host
[NI_MAXHOST
];
1814 if (grp
->gr_type
!= GT_NULL
) {
1815 syslog(LOG_ERR
, "Bad netgroup type for ip host %s", cp
);
1818 memset(&hints
, 0, sizeof hints
);
1819 hints
.ai_flags
= AI_CANONNAME
;
1820 hints
.ai_protocol
= IPPROTO_UDP
;
1821 ecode
= getaddrinfo(cp
, NULL
, &hints
, &ai
);
1823 syslog(LOG_ERR
,"can't get address info for host %s", cp
);
1826 grp
->gr_ptr
.gt_addrinfo
= ai
;
1827 while (ai
!= NULL
) {
1828 if (ai
->ai_canonname
== NULL
) {
1829 if (getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, host
,
1830 sizeof host
, NULL
, 0, NI_NUMERICHOST
) != 0)
1831 strlcpy(host
, "?", sizeof(host
));
1832 ai
->ai_canonname
= strdup(host
);
1833 ai
->ai_flags
|= AI_CANONNAME
;
1836 fprintf(stderr
, "got host %s\n", ai
->ai_canonname
);
1838 * Sanity check: make sure we don't already have an entry
1839 * for this host in the grouplist.
1841 for (checkgrp
= tgrp
; checkgrp
!= NULL
;
1842 checkgrp
= checkgrp
->gr_next
) {
1843 if (checkgrp
->gr_type
!= GT_HOST
)
1845 for (tai
= checkgrp
->gr_ptr
.gt_addrinfo
; tai
!= NULL
;
1846 tai
= tai
->ai_next
) {
1847 if (sacmp(tai
->ai_addr
, ai
->ai_addr
, NULL
) != 0)
1851 "ignoring duplicate host %s\n",
1853 grp
->gr_type
= GT_IGNORE
;
1859 grp
->gr_type
= GT_HOST
;
1864 * Free up an exports list component
1867 free_exp(struct exportlist
*ep
)
1870 if (ep
->ex_defdir
) {
1871 free_host(ep
->ex_defdir
->dp_hosts
);
1872 free((caddr_t
)ep
->ex_defdir
);
1876 if (ep
->ex_indexfile
)
1877 free(ep
->ex_indexfile
);
1878 free_dir(ep
->ex_dirl
);
1886 free_host(struct hostlist
*hp
)
1888 struct hostlist
*hp2
;
1900 struct hostlist
*hp
;
1902 hp
= (struct hostlist
*)malloc(sizeof (struct hostlist
));
1911 * Out of memory, fatal
1917 syslog(LOG_ERR
, "out of memory");
1922 * Do the mount syscall with the update flag to push the export info into
1926 do_mount(struct exportlist
*ep
, struct grouplist
*grp
, int exflags
,
1927 struct ucred
*anoncrp
, char *dirp
, int dirplen
, struct statfs
*fsb
)
1930 struct addrinfo
*ai
;
1931 struct export_args
*eap
;
1939 struct msdosfs_args da
;
1940 struct ntfs_args na
;
1943 bzero(&args
, sizeof args
);
1944 /* XXX, we assume that all xx_args look like ufs_args. */
1946 eap
= &args
.ua
.export
;
1948 eap
->ex_flags
= exflags
;
1949 eap
->ex_anon
= *anoncrp
;
1950 eap
->ex_indexfile
= ep
->ex_indexfile
;
1951 if (grp
->gr_type
== GT_HOST
)
1952 ai
= grp
->gr_ptr
.gt_addrinfo
;
1957 switch (grp
->gr_type
) {
1959 if (ai
->ai_addr
->sa_family
== AF_INET6
&& have_v6
== 0)
1961 eap
->ex_addr
= ai
->ai_addr
;
1962 eap
->ex_addrlen
= ai
->ai_addrlen
;
1963 eap
->ex_masklen
= 0;
1966 if (grp
->gr_ptr
.gt_net
.nt_net
.ss_family
== AF_INET6
&&
1970 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_net
;
1971 eap
->ex_addrlen
= args
.ua
.export
.ex_addr
->sa_len
;
1973 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_mask
;
1974 eap
->ex_masklen
= args
.ua
.export
.ex_mask
->sa_len
;
1977 eap
->ex_addr
= NULL
;
1978 eap
->ex_addrlen
= 0;
1979 eap
->ex_mask
= NULL
;
1980 eap
->ex_masklen
= 0;
1986 syslog(LOG_ERR
, "bad grouptype");
1994 * Maybe I should just use the fsb->f_mntonname path instead
1995 * of looping back up the dirp to the mount point??
1996 * Also, needs to know how to export all types of local
1997 * exportable filesystems and not just "ufs".
2002 r
= mountctl(fsb
->f_mntonname
, MOUNTCTL_SET_EXPORT
,
2004 &args
.ua
.export
, sizeof(args
.ua
.export
),
2006 if (r
< 0 && errno
== EOPNOTSUPP
) {
2007 r
= mount(fsb
->f_fstypename
, dirp
,
2008 fsb
->f_flags
| MNT_UPDATE
,
2016 cp
= dirp
+ dirplen
- 1;
2017 if (opt_flags
& OP_QUIET
)
2019 if (errno
== EPERM
) {
2021 warnx("can't change attributes for %s",
2024 "can't change attributes for %s", dirp
);
2027 if (opt_flags
& OP_ALLDIRS
) {
2028 if (errno
== EINVAL
)
2030 "-alldirs requested but %s is not a filesystem mountpoint",
2034 "could not remount %s: %m",
2038 /* back up over the last component */
2039 while (*cp
== '/' && cp
> dirp
)
2041 while (*(cp
- 1) != '/' && cp
> dirp
)
2045 warnx("mnt unsucc");
2046 syslog(LOG_ERR
, "can't export %s", dirp
);
2051 /* Check that we're still on the same filesystem. */
2052 if (statfs(dirp
, &fsb1
) != 0 || bcmp(&fsb1
.f_fsid
,
2053 &fsb
->f_fsid
, sizeof(fsb1
.f_fsid
)) != 0) {
2055 syslog(LOG_ERR
, "can't export %s", dirp
);
2071 * Translate a net address.
2073 * If `maskflg' is nonzero, then `cp' is a netmask, not a network address.
2076 get_net(char *cp
, struct netmsk
*net
, int maskflg
)
2078 struct netent
*np
= NULL
;
2079 char *name
, *p
, *prefp
;
2080 struct sockaddr_in sin
;
2081 struct sockaddr
*sa
= NULL
;
2082 struct addrinfo hints
, *ai
= NULL
;
2083 char netname
[NI_MAXHOST
];
2087 if ((opt_flags
& OP_MASKLEN
) && !maskflg
) {
2088 p
= strchr(cp
, '/');
2094 * Check for a numeric address first. We wish to avoid
2095 * possible DNS lookups in getnetbyname().
2097 if (isxdigit(*cp
) || *cp
== ':') {
2098 memset(&hints
, 0, sizeof hints
);
2099 /* Ensure the mask and the network have the same family. */
2100 if (maskflg
&& (opt_flags
& OP_NET
))
2101 hints
.ai_family
= net
->nt_net
.ss_family
;
2102 else if (!maskflg
&& (opt_flags
& OP_HAVEMASK
))
2103 hints
.ai_family
= net
->nt_mask
.ss_family
;
2105 hints
.ai_family
= AF_UNSPEC
;
2106 hints
.ai_flags
= AI_NUMERICHOST
;
2107 if (getaddrinfo(cp
, NULL
, &hints
, &ai
) == 0)
2109 if (sa
!= NULL
&& ai
->ai_family
== AF_INET
) {
2111 * The address in `cp' is really a network address, so
2112 * use inet_network() to re-interpret this correctly.
2113 * e.g. "127.1" means 127.1.0.0, not 127.0.0.1.
2115 bzero(&sin
, sizeof sin
);
2116 sin
.sin_family
= AF_INET
;
2117 sin
.sin_len
= sizeof sin
;
2118 sin
.sin_addr
= inet_makeaddr(inet_network(cp
), 0);
2120 fprintf(stderr
, "get_net: v4 addr %s\n",
2121 inet_ntoa(sin
.sin_addr
));
2122 sa
= (struct sockaddr
*)&sin
;
2125 if (sa
== NULL
&& (np
= getnetbyname(cp
)) != NULL
) {
2126 bzero(&sin
, sizeof sin
);
2127 sin
.sin_family
= AF_INET
;
2128 sin
.sin_len
= sizeof sin
;
2129 sin
.sin_addr
= inet_makeaddr(np
->n_net
, 0);
2130 sa
= (struct sockaddr
*)&sin
;
2136 /* The specified sockaddr is a mask. */
2137 if (checkmask(sa
) != 0)
2139 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2140 opt_flags
|= OP_HAVEMASK
;
2142 /* The specified sockaddr is a network address. */
2143 bcopy(sa
, &net
->nt_net
, sa
->sa_len
);
2145 /* Get a network name for the export list. */
2148 } else if (getnameinfo(sa
, sa
->sa_len
, netname
, sizeof netname
,
2149 NULL
, 0, NI_NUMERICHOST
) == 0) {
2154 if ((net
->nt_name
= strdup(name
)) == NULL
)
2158 * Extract a mask from either a "/<masklen>" suffix, or
2159 * from the class of an IPv4 address.
2161 if (opt_flags
& OP_MASKLEN
) {
2162 preflen
= strtol(prefp
, NULL
, 10);
2163 if (preflen
< 0L || preflen
== LONG_MAX
)
2165 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2166 if (makemask(&net
->nt_mask
, (int)preflen
) != 0)
2168 opt_flags
|= OP_HAVEMASK
;
2170 } else if (sa
->sa_family
== AF_INET
&&
2171 (opt_flags
& OP_MASK
) == 0) {
2174 addr
= ((struct sockaddr_in
*)sa
)->sin_addr
.s_addr
;
2175 if (IN_CLASSA(addr
))
2177 else if (IN_CLASSB(addr
))
2179 else if (IN_CLASSC(addr
))
2181 else if (IN_CLASSD(addr
))
2184 preflen
= 32; /* XXX */
2186 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2187 makemask(&net
->nt_mask
, (int)preflen
);
2188 opt_flags
|= OP_HAVEMASK
;
2203 * Parse out the next white space separated field
2206 nextfield(char **cp
, char **endcp
)
2211 while (*p
== ' ' || *p
== '\t')
2213 if (*p
== '\n' || *p
== '\0')
2217 while (*p
!= ' ' && *p
!= '\t' && *p
!= '\n' && *p
!= '\0')
2224 * Get an exports file line. Skip over blank lines and handle line
2232 int totlen
, cont_line
;
2235 * Loop around ignoring blank lines and getting all continuation lines.
2240 if ((p
= fgetln(exp_file
, &len
)) == NULL
)
2245 (*cp
== ' ' || *cp
== '\t' || *cp
== '\n' || *cp
== '\\')) {
2255 if (linesize
< len
+ totlen
+ 1) {
2256 linesize
= len
+ totlen
+ 1;
2257 line
= realloc(line
, linesize
);
2261 memcpy(line
+ totlen
, p
, len
);
2263 line
[totlen
] = '\0';
2264 } while (totlen
== 0 || cont_line
);
2269 * Parse a description of a credential.
2272 parsecred(char *namelist
, struct ucred
*cr
)
2279 gid_t ngroups
, groups
[NGROUPS
+ 1];
2282 * Set up the unprivileged user.
2286 cr
->cr_groups
[0] = -2;
2289 * Get the user's password table entry.
2291 names
= strsep(&namelist
, " \t\n");
2292 name
= strsep(&names
, ":");
2293 if (isdigit(*name
) || *name
== '-')
2294 pw
= getpwuid(atoi(name
));
2296 pw
= getpwnam(name
);
2298 * Credentials specified as those of a user.
2300 if (names
== NULL
) {
2302 syslog(LOG_ERR
, "unknown user: %s", name
);
2305 cr
->cr_uid
= pw
->pw_uid
;
2306 ngroups
= NGROUPS
+ 1;
2307 if (getgrouplist(pw
->pw_name
, pw
->pw_gid
, groups
, &ngroups
))
2308 syslog(LOG_ERR
, "too many groups");
2310 * Compress out duplicate
2312 cr
->cr_ngroups
= ngroups
- 1;
2313 cr
->cr_groups
[0] = groups
[0];
2314 for (cnt
= 2; cnt
< ngroups
; cnt
++)
2315 cr
->cr_groups
[cnt
- 1] = groups
[cnt
];
2319 * Explicit credential specified as a colon separated list:
2323 cr
->cr_uid
= pw
->pw_uid
;
2324 else if (isdigit(*name
) || *name
== '-')
2325 cr
->cr_uid
= atoi(name
);
2327 syslog(LOG_ERR
, "unknown user: %s", name
);
2331 while (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
< NGROUPS
) {
2332 name
= strsep(&names
, ":");
2333 if (isdigit(*name
) || *name
== '-') {
2334 cr
->cr_groups
[cr
->cr_ngroups
++] = atoi(name
);
2336 if ((gr
= getgrnam(name
)) == NULL
) {
2337 syslog(LOG_ERR
, "unknown group: %s", name
);
2340 cr
->cr_groups
[cr
->cr_ngroups
++] = gr
->gr_gid
;
2343 if (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
== NGROUPS
)
2344 syslog(LOG_ERR
, "too many groups");
2347 #define STRSIZ (RPCMNT_NAMELEN+RPCMNT_PATHLEN+50)
2349 * Routines that maintain the remote mounttab
2354 struct mountlist
*mlp
, **mlpp
;
2355 char *host
, *dirp
, *cp
;
2359 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "r")) == NULL
) {
2360 if (errno
== ENOENT
)
2363 syslog(LOG_ERR
, "can't open %s", _PATH_RMOUNTLIST
);
2368 while (fgets(str
, STRSIZ
, mlfile
) != NULL
) {
2370 host
= strsep(&cp
, " \t\n");
2371 dirp
= strsep(&cp
, " \t\n");
2372 if (host
== NULL
|| dirp
== NULL
)
2374 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2377 strncpy(mlp
->ml_host
, host
, RPCMNT_NAMELEN
);
2378 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2379 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2380 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2381 mlp
->ml_next
= NULL
;
2383 mlpp
= &mlp
->ml_next
;
2389 del_mlist(char *hostp
, char *dirp
)
2391 struct mountlist
*mlp
, **mlpp
;
2392 struct mountlist
*mlp2
;
2399 if (!strcmp(mlp
->ml_host
, hostp
) &&
2400 (!dirp
|| !strcmp(mlp
->ml_dirp
, dirp
))) {
2403 *mlpp
= mlp
= mlp
->ml_next
;
2404 free((caddr_t
)mlp2
);
2406 mlpp
= &mlp
->ml_next
;
2411 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "w")) == NULL
) {
2412 syslog(LOG_ERR
,"can't update %s", _PATH_RMOUNTLIST
);
2417 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2425 add_mlist(char *hostp
, char *dirp
)
2427 struct mountlist
*mlp
, **mlpp
;
2433 if (!strcmp(mlp
->ml_host
, hostp
) && !strcmp(mlp
->ml_dirp
, dirp
))
2435 mlpp
= &mlp
->ml_next
;
2438 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2441 strncpy(mlp
->ml_host
, hostp
, RPCMNT_NAMELEN
);
2442 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2443 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2444 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2445 mlp
->ml_next
= NULL
;
2447 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "a")) == NULL
) {
2448 syslog(LOG_ERR
, "can't update %s", _PATH_RMOUNTLIST
);
2451 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2456 * Free up a group list.
2459 free_grp(struct grouplist
*grp
)
2461 if (grp
->gr_type
== GT_HOST
) {
2462 if (grp
->gr_ptr
.gt_addrinfo
!= NULL
)
2463 freeaddrinfo(grp
->gr_ptr
.gt_addrinfo
);
2464 } else if (grp
->gr_type
== GT_NET
) {
2465 if (grp
->gr_ptr
.gt_net
.nt_name
)
2466 free(grp
->gr_ptr
.gt_net
.nt_name
);
2473 SYSLOG(int pri
, const char *fmt
, ...)
2478 vfprintf(stderr
, fmt
, ap
);
2484 * Check options for consistency.
2487 check_options(struct dirlist
*dp
)
2492 if ((opt_flags
& (OP_MAPROOT
| OP_MAPALL
)) == (OP_MAPROOT
| OP_MAPALL
)) {
2493 syslog(LOG_ERR
, "-mapall and -maproot mutually exclusive");
2496 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_NET
) == 0) {
2497 syslog(LOG_ERR
, "-mask requires -network");
2500 if ((opt_flags
& OP_NET
) && (opt_flags
& OP_HAVEMASK
) == 0) {
2501 syslog(LOG_ERR
, "-network requires mask specification");
2504 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_MASKLEN
)) {
2505 syslog(LOG_ERR
, "-mask and /masklen are mutually exclusive");
2508 if ((opt_flags
& OP_ALLDIRS
) && dp
->dp_left
) {
2509 syslog(LOG_ERR
, "-alldirs has multiple directories");
2516 * Check an absolute directory path for any symbolic links. Return true
2519 check_dirpath(char *dirp
)
2526 while (*cp
&& ret
) {
2529 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2535 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2541 * Make a netmask according to the specified prefix length. The ss_family
2542 * and other non-address fields must be initialised before calling this.
2545 makemask(struct sockaddr_storage
*ssp
, int bitlen
)
2550 if ((p
= sa_rawaddr((struct sockaddr
*)ssp
, &len
)) == NULL
)
2552 if (bitlen
> len
* CHAR_BIT
)
2554 for (i
= 0; i
< len
; i
++) {
2555 bits
= (bitlen
> CHAR_BIT
) ? CHAR_BIT
: bitlen
;
2556 *p
++ = (1 << bits
) - 1;
2563 * Check that the sockaddr is a valid netmask. Returns 0 if the mask
2564 * is acceptable (i.e. of the form 1...10....0).
2567 checkmask(struct sockaddr
*sa
)
2572 if ((mask
= sa_rawaddr(sa
, &len
)) == NULL
)
2575 for (i
= 0; i
< len
; i
++)
2576 if (mask
[i
] != 0xff)
2579 if (~mask
[i
] & (u_char
)(~mask
[i
] + 1))
2583 for (; i
< len
; i
++)
2590 * Compare two sockaddrs according to a specified mask. Return zero if
2591 * `sa1' matches `sa2' when filtered by the netmask in `samask'.
2592 * If samask is NULL, perform a full comparision.
2595 sacmp(struct sockaddr
*sa1
, struct sockaddr
*sa2
, struct sockaddr
*samask
)
2597 unsigned char *p1
, *p2
, *mask
;
2600 if (sa1
->sa_family
!= sa2
->sa_family
||
2601 (p1
= sa_rawaddr(sa1
, &len
)) == NULL
||
2602 (p2
= sa_rawaddr(sa2
, NULL
)) == NULL
)
2605 switch (sa1
->sa_family
) {
2607 if (((struct sockaddr_in6
*)sa1
)->sin6_scope_id
!=
2608 ((struct sockaddr_in6
*)sa2
)->sin6_scope_id
)
2613 /* Simple binary comparison if no mask specified. */
2615 return (memcmp(p1
, p2
, len
));
2617 /* Set up the mask, and do a mask-based comparison. */
2618 if (sa1
->sa_family
!= samask
->sa_family
||
2619 (mask
= sa_rawaddr(samask
, NULL
)) == NULL
)
2622 for (i
= 0; i
< len
; i
++)
2623 if ((p1
[i
] & mask
[i
]) != (p2
[i
] & mask
[i
]))
2629 * Return a pointer to the part of the sockaddr that contains the
2630 * raw address, and set *nbytes to its length in bytes. Returns
2631 * NULL if the address family is unknown.
2634 sa_rawaddr(struct sockaddr
*sa
, int *nbytes
) {
2638 switch (sa
->sa_family
) {
2640 len
= sizeof(((struct sockaddr_in
*)sa
)->sin_addr
);
2641 p
= &((struct sockaddr_in
*)sa
)->sin_addr
;
2644 len
= sizeof(((struct sockaddr_in6
*)sa
)->sin6_addr
);
2645 p
= &((struct sockaddr_in6
*)sa
)->sin6_addr
;
2663 void terminate(int sig
)
2665 pidfile_remove(pfh
);
2666 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER1
, NULL
);
2667 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER3
, NULL
);