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
!= 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) {
1144 if ((fsb
.f_flags
& MNT_AUTOMOUNTED
) != 0)
1145 syslog(LOG_ERR
, "Warning: exporting of "
1146 "automounted fs %s not supported", cp
);
1148 syslog(LOG_ERR
, "dirs must be first");
1149 getexp_err(ep
, tgrp
);
1153 if (ep
->ex_fs
.val
[0] != fsb
.f_fsid
.val
[0] ||
1154 ep
->ex_fs
.val
[1] != fsb
.f_fsid
.val
[1]) {
1155 getexp_err(ep
, tgrp
);
1160 * See if this directory is already
1163 ep
= ex_search(&fsb
.f_fsid
);
1166 ep
->ex_fs
= fsb
.f_fsid
;
1167 ep
->ex_fsdir
= (char *)
1168 malloc(strlen(fsb
.f_mntonname
) + 1);
1170 strcpy(ep
->ex_fsdir
,
1175 warnx("making new ep fs=0x%x,0x%x",
1179 warnx("found ep fs=0x%x,0x%x",
1185 * Add dirpath to export mount point.
1187 dirp
= add_expdir(&dirhead
, cp
, len
);
1190 getexp_err(ep
, tgrp
);
1199 getexp_err(ep
, tgrp
);
1204 * Get the host or netgroup.
1207 netgrp
= getnetgrent(&hst
, &usr
, &dom
);
1210 grp
->gr_next
= get_grp();
1216 "null hostname in netgroup %s, skipping", cp
);
1217 grp
->gr_type
= GT_IGNORE
;
1218 } else if (get_host(hst
, grp
, tgrp
)) {
1220 "bad host %s in netgroup %s, skipping", hst
, cp
);
1221 grp
->gr_type
= GT_IGNORE
;
1223 } else if (get_host(cp
, grp
, tgrp
)) {
1224 syslog(LOG_ERR
, "bad host %s, skipping", cp
);
1225 grp
->gr_type
= GT_IGNORE
;
1228 } while (netgrp
&& getnetgrent(&hst
, &usr
, &dom
));
1233 nextfield(&cp
, &endcp
);
1236 if (check_options(dirhead
)) {
1237 getexp_err(ep
, tgrp
);
1241 grp
->gr_type
= GT_DEFAULT
;
1243 warnx("adding a default entry");
1246 * Don't allow a network export coincide with a list of
1247 * host(s) on the same line.
1249 } else if ((opt_flags
& OP_NET
) && tgrp
->gr_next
) {
1250 syslog(LOG_ERR
, "network/host conflict");
1251 getexp_err(ep
, tgrp
);
1255 * If an export list was specified on this line, make sure
1256 * that we have at least one valid entry, otherwise skip it.
1260 while (grp
&& grp
->gr_type
== GT_IGNORE
)
1263 getexp_err(ep
, tgrp
);
1269 * Loop through hosts, pushing the exports into the kernel.
1270 * After loop, tgrp points to the start of the list and
1271 * grp points to the last entry in the list.
1275 if (do_mount(ep
, grp
, exflags
, &anon
, dirp
, dirplen
,
1277 getexp_err(ep
, tgrp
);
1280 } while (grp
->gr_next
&& (grp
= grp
->gr_next
));
1283 * Success. Update the data structures.
1286 hang_dirp(dirhead
, tgrp
, ep
, opt_flags
);
1287 grp
->gr_next
= grphead
;
1290 hang_dirp(dirhead
, NULL
, ep
,
1295 if ((ep
->ex_flag
& EX_LINKED
) == 0) {
1300 * Insert in the list in alphabetical order.
1302 while (ep2
&& strcmp(ep2
->ex_fsdir
, ep
->ex_fsdir
) < 0) {
1303 epp
= &ep2
->ex_next
;
1309 ep
->ex_flag
|= EX_LINKED
;
1321 * Get the export list from all specified files
1324 get_exportlist(void)
1326 struct exportlist
*ep
, *ep2
;
1327 struct grouplist
*grp
, *tgrp
;
1328 struct statfs
*fsp
, *mntbufp
;
1337 * First, get rid of the old list
1356 * And delete exports that are in the kernel for all local
1358 * XXX: Should know how to handle all local exportable filesystems.
1360 num
= getmntinfo(&mntbufp
, MNT_NOWAIT
);
1361 for (i
= 0; i
< num
; i
++) {
1366 struct msdosfs_args da
;
1367 struct ntfs_args na
;
1369 struct export_args export
;
1372 if (getvfsbyname(fsp
->f_fstypename
, &vfc
) != 0) {
1373 syslog(LOG_ERR
, "getvfsbyname() failed for %s",
1379 * Do not delete export for network filesystem by
1380 * passing "export" arg to mount().
1381 * It only makes sense to do this for local filesystems.
1383 if (vfc
.vfc_flags
& VFCF_NETWORK
)
1386 export
.ex_flags
= MNT_DELEXPORT
;
1387 if (mountctl(fsp
->f_mntonname
, MOUNTCTL_SET_EXPORT
, -1,
1388 &export
, sizeof(export
), NULL
, 0) == 0) {
1389 } else if (!strcmp(fsp
->f_fstypename
, "mfs") ||
1390 !strcmp(fsp
->f_fstypename
, "ufs") ||
1391 !strcmp(fsp
->f_fstypename
, "msdos") ||
1392 !strcmp(fsp
->f_fstypename
, "ntfs") ||
1393 !strcmp(fsp
->f_fstypename
, "cd9660")) {
1394 bzero(&targs
, sizeof targs
);
1395 targs
.ua
.fspec
= NULL
;
1396 targs
.ua
.export
.ex_flags
= MNT_DELEXPORT
;
1397 if (mount(fsp
->f_fstypename
, fsp
->f_mntonname
,
1398 fsp
->f_flags
| MNT_UPDATE
,
1399 (caddr_t
)&targs
) < 0)
1400 syslog(LOG_ERR
, "can't delete exports for %s",
1406 * Read in the exports file and build the list, calling
1407 * nmount() as we go along to push the export rules into the kernel.
1410 for (i
= 0; exnames
[i
] != NULL
; i
++) {
1412 warnx("reading exports from %s", exnames
[i
]);
1413 if ((exp_file
= fopen(exnames
[i
], "r")) == NULL
) {
1414 syslog(LOG_WARNING
, "can't open %s", exnames
[i
]);
1417 get_exportlist_one();
1422 syslog(LOG_ERR
, "can't open any exports file");
1428 * Allocate an export list element
1433 struct exportlist
*ep
;
1435 ep
= (struct exportlist
*)malloc(sizeof (struct exportlist
));
1438 memset(ep
, 0, sizeof(struct exportlist
));
1443 * Allocate a group list element
1448 struct grouplist
*gp
;
1450 gp
= (struct grouplist
*)malloc(sizeof (struct grouplist
));
1453 memset(gp
, 0, sizeof(struct grouplist
));
1458 * Clean up upon an error in get_exportlist().
1461 getexp_err(struct exportlist
*ep
, struct grouplist
*grp
)
1463 struct grouplist
*tgrp
;
1465 if (!(opt_flags
& OP_QUIET
))
1466 syslog(LOG_ERR
, "bad exports list line %s", line
);
1467 if (ep
&& (ep
->ex_flag
& EX_LINKED
) == 0)
1477 * Search the export list for a matching fs.
1480 ex_search(fsid_t
*fsid
)
1482 struct exportlist
*ep
;
1486 if (ep
->ex_fs
.val
[0] == fsid
->val
[0] &&
1487 ep
->ex_fs
.val
[1] == fsid
->val
[1])
1495 * Add a directory path to the list.
1498 add_expdir(struct dirlist
**dpp
, char *cp
, int len
)
1502 dp
= (struct dirlist
*)malloc(sizeof (struct dirlist
) + len
);
1506 dp
->dp_right
= NULL
;
1508 dp
->dp_hosts
= NULL
;
1509 strcpy(dp
->dp_dirp
, cp
);
1511 return (dp
->dp_dirp
);
1515 * Hang the dir list element off the dirpath binary tree as required
1516 * and update the entry for host.
1519 hang_dirp(struct dirlist
*dp
, struct grouplist
*grp
, struct exportlist
*ep
,
1522 struct hostlist
*hp
;
1523 struct dirlist
*dp2
;
1525 if (flags
& OP_ALLDIRS
) {
1531 ep
->ex_defdir
->dp_flag
|= DP_DEFSET
;
1532 } else while (grp
) {
1535 hp
->ht_next
= ep
->ex_defdir
->dp_hosts
;
1536 ep
->ex_defdir
->dp_hosts
= hp
;
1542 * Loop through the directories adding them to the tree.
1546 add_dlist(&ep
->ex_dirl
, dp
, grp
, flags
);
1553 * Traverse the binary tree either updating a node that is already there
1554 * for the new directory or adding the new node.
1557 add_dlist(struct dirlist
**dpp
, struct dirlist
*newdp
, struct grouplist
*grp
,
1561 struct hostlist
*hp
;
1566 cmp
= strcmp(dp
->dp_dirp
, newdp
->dp_dirp
);
1568 add_dlist(&dp
->dp_left
, newdp
, grp
, flags
);
1570 } else if (cmp
< 0) {
1571 add_dlist(&dp
->dp_right
, newdp
, grp
, flags
);
1574 free((caddr_t
)newdp
);
1583 * Hang all of the host(s) off of the directory point.
1588 hp
->ht_next
= dp
->dp_hosts
;
1593 dp
->dp_flag
|= DP_DEFSET
;
1598 * Search for a dirpath on the export point.
1601 dirp_search(struct dirlist
*dp
, char *dirp
)
1606 cmp
= strcmp(dp
->dp_dirp
, dirp
);
1608 return (dirp_search(dp
->dp_left
, dirp
));
1610 return (dirp_search(dp
->dp_right
, dirp
));
1618 * Scan for a host match in a directory tree.
1621 chk_host(struct dirlist
*dp
, struct sockaddr
*saddr
, int *defsetp
,
1624 struct hostlist
*hp
;
1625 struct grouplist
*grp
;
1626 struct addrinfo
*ai
;
1629 if (dp
->dp_flag
& DP_DEFSET
)
1630 *defsetp
= dp
->dp_flag
;
1634 switch (grp
->gr_type
) {
1636 ai
= grp
->gr_ptr
.gt_addrinfo
;
1637 for (; ai
; ai
= ai
->ai_next
) {
1638 if (!sacmp(ai
->ai_addr
, saddr
, NULL
)) {
1640 (hp
->ht_flag
| DP_HOSTSET
);
1646 if (!sacmp(saddr
, (struct sockaddr
*)
1647 &grp
->gr_ptr
.gt_net
.nt_net
,
1649 &grp
->gr_ptr
.gt_net
.nt_mask
)) {
1650 *hostsetp
= (hp
->ht_flag
| DP_HOSTSET
);
1662 * Scan tree for a host that matches the address.
1665 scan_tree(struct dirlist
*dp
, struct sockaddr
*saddr
)
1667 int defset
, hostset
;
1670 if (scan_tree(dp
->dp_left
, saddr
))
1672 if (chk_host(dp
, saddr
, &defset
, &hostset
))
1674 if (scan_tree(dp
->dp_right
, saddr
))
1681 * Traverse the dirlist tree and free it up.
1684 free_dir(struct dirlist
*dp
)
1688 free_dir(dp
->dp_left
);
1689 free_dir(dp
->dp_right
);
1690 free_host(dp
->dp_hosts
);
1696 * Parse the option string and update fields.
1697 * Option arguments may either be -<option>=<value> or
1701 do_opt(char **cpp
, char **endcpp
, struct exportlist
*ep
, struct grouplist
*grp
,
1702 int *has_hostp
, int *exflagsp
, struct ucred
*cr
)
1704 char *cpoptarg
, *cpoptend
;
1705 char *cp
, *endcp
, *cpopt
, savedc
, savedc2
;
1706 int allflag
, usedarg
;
1714 while (cpopt
&& *cpopt
) {
1717 if ((cpoptend
= strchr(cpopt
, ','))) {
1719 if ((cpoptarg
= strchr(cpopt
, '=')))
1722 if ((cpoptarg
= strchr(cpopt
, '=')))
1726 nextfield(&cp
, &endcp
);
1728 if (endcp
> cp
&& *cp
!= '-') {
1736 if (!strcmp(cpopt
, "ro") || !strcmp(cpopt
, "o")) {
1737 *exflagsp
|= MNT_EXRDONLY
;
1738 } else if (cpoptarg
&& (!strcmp(cpopt
, "maproot") ||
1739 !(allflag
= strcmp(cpopt
, "mapall")) ||
1740 !strcmp(cpopt
, "root") || !strcmp(cpopt
, "r"))) {
1742 parsecred(cpoptarg
, cr
);
1744 *exflagsp
|= MNT_EXPORTANON
;
1745 opt_flags
|= OP_MAPALL
;
1747 opt_flags
|= OP_MAPROOT
;
1748 } else if (cpoptarg
&& (!strcmp(cpopt
, "mask") ||
1749 !strcmp(cpopt
, "m"))) {
1750 if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 1)) {
1751 syslog(LOG_ERR
, "bad mask: %s", cpoptarg
);
1755 opt_flags
|= OP_MASK
;
1756 } else if (cpoptarg
&& (!strcmp(cpopt
, "network") ||
1757 !strcmp(cpopt
, "n"))) {
1758 if (strchr(cpoptarg
, '/') != NULL
) {
1760 fprintf(stderr
, "setting OP_MASKLEN\n");
1761 opt_flags
|= OP_MASKLEN
;
1763 if (grp
->gr_type
!= GT_NULL
) {
1764 syslog(LOG_ERR
, "network/host conflict");
1766 } else if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 0)) {
1767 syslog(LOG_ERR
, "bad net: %s", cpoptarg
);
1770 grp
->gr_type
= GT_NET
;
1773 opt_flags
|= OP_NET
;
1774 } else if (!strcmp(cpopt
, "alldirs")) {
1775 opt_flags
|= OP_ALLDIRS
;
1776 } else if (!strcmp(cpopt
, "public")) {
1777 *exflagsp
|= MNT_EXPUBLIC
;
1778 } else if (!strcmp(cpopt
, "webnfs")) {
1779 *exflagsp
|= (MNT_EXPUBLIC
|MNT_EXRDONLY
|MNT_EXPORTANON
);
1780 opt_flags
|= OP_MAPALL
;
1781 } else if (cpoptarg
&& !strcmp(cpopt
, "index")) {
1782 ep
->ex_indexfile
= strdup(cpoptarg
);
1783 } else if (!strcmp(cpopt
, "quiet")) {
1784 opt_flags
|= OP_QUIET
;
1786 syslog(LOG_ERR
, "bad opt %s", cpopt
);
1805 * Translate a character string to the corresponding list of network
1806 * addresses for a hostname.
1809 get_host(char *cp
, struct grouplist
*grp
, struct grouplist
*tgrp
)
1811 struct grouplist
*checkgrp
;
1812 struct addrinfo
*ai
, *tai
, hints
;
1814 char host
[NI_MAXHOST
];
1816 if (grp
->gr_type
!= GT_NULL
) {
1817 syslog(LOG_ERR
, "Bad netgroup type for ip host %s", cp
);
1820 memset(&hints
, 0, sizeof hints
);
1821 hints
.ai_flags
= AI_CANONNAME
;
1822 hints
.ai_protocol
= IPPROTO_UDP
;
1823 ecode
= getaddrinfo(cp
, NULL
, &hints
, &ai
);
1825 syslog(LOG_ERR
,"can't get address info for host %s", cp
);
1828 grp
->gr_ptr
.gt_addrinfo
= ai
;
1829 while (ai
!= NULL
) {
1830 if (ai
->ai_canonname
== NULL
) {
1831 if (getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, host
,
1832 sizeof host
, NULL
, 0, NI_NUMERICHOST
) != 0)
1833 strlcpy(host
, "?", sizeof(host
));
1834 ai
->ai_canonname
= strdup(host
);
1835 ai
->ai_flags
|= AI_CANONNAME
;
1838 fprintf(stderr
, "got host %s\n", ai
->ai_canonname
);
1840 * Sanity check: make sure we don't already have an entry
1841 * for this host in the grouplist.
1843 for (checkgrp
= tgrp
; checkgrp
!= NULL
;
1844 checkgrp
= checkgrp
->gr_next
) {
1845 if (checkgrp
->gr_type
!= GT_HOST
)
1847 for (tai
= checkgrp
->gr_ptr
.gt_addrinfo
; tai
!= NULL
;
1848 tai
= tai
->ai_next
) {
1849 if (sacmp(tai
->ai_addr
, ai
->ai_addr
, NULL
) != 0)
1853 "ignoring duplicate host %s\n",
1855 grp
->gr_type
= GT_IGNORE
;
1861 grp
->gr_type
= GT_HOST
;
1866 * Free up an exports list component
1869 free_exp(struct exportlist
*ep
)
1872 if (ep
->ex_defdir
) {
1873 free_host(ep
->ex_defdir
->dp_hosts
);
1874 free((caddr_t
)ep
->ex_defdir
);
1878 if (ep
->ex_indexfile
)
1879 free(ep
->ex_indexfile
);
1880 free_dir(ep
->ex_dirl
);
1888 free_host(struct hostlist
*hp
)
1890 struct hostlist
*hp2
;
1902 struct hostlist
*hp
;
1904 hp
= (struct hostlist
*)malloc(sizeof (struct hostlist
));
1913 * Out of memory, fatal
1919 syslog(LOG_ERR
, "out of memory");
1924 * Do the mount syscall with the update flag to push the export info into
1928 do_mount(struct exportlist
*ep
, struct grouplist
*grp
, int exflags
,
1929 struct ucred
*anoncrp
, char *dirp
, int dirplen
, struct statfs
*fsb
)
1932 struct addrinfo
*ai
;
1933 struct export_args
*eap
;
1941 struct msdosfs_args da
;
1942 struct ntfs_args na
;
1945 bzero(&args
, sizeof args
);
1946 /* XXX, we assume that all xx_args look like ufs_args. */
1948 eap
= &args
.ua
.export
;
1950 eap
->ex_flags
= exflags
;
1951 eap
->ex_anon
= *anoncrp
;
1952 eap
->ex_indexfile
= ep
->ex_indexfile
;
1953 if (grp
->gr_type
== GT_HOST
)
1954 ai
= grp
->gr_ptr
.gt_addrinfo
;
1959 switch (grp
->gr_type
) {
1961 if (ai
->ai_addr
->sa_family
== AF_INET6
&& have_v6
== 0)
1963 eap
->ex_addr
= ai
->ai_addr
;
1964 eap
->ex_addrlen
= ai
->ai_addrlen
;
1965 eap
->ex_masklen
= 0;
1968 if (grp
->gr_ptr
.gt_net
.nt_net
.ss_family
== AF_INET6
&&
1972 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_net
;
1973 eap
->ex_addrlen
= args
.ua
.export
.ex_addr
->sa_len
;
1975 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_mask
;
1976 eap
->ex_masklen
= args
.ua
.export
.ex_mask
->sa_len
;
1979 eap
->ex_addr
= NULL
;
1980 eap
->ex_addrlen
= 0;
1981 eap
->ex_mask
= NULL
;
1982 eap
->ex_masklen
= 0;
1988 syslog(LOG_ERR
, "bad grouptype");
1996 * Maybe I should just use the fsb->f_mntonname path instead
1997 * of looping back up the dirp to the mount point??
1998 * Also, needs to know how to export all types of local
1999 * exportable filesystems and not just "ufs".
2004 r
= mountctl(fsb
->f_mntonname
, MOUNTCTL_SET_EXPORT
,
2006 &args
.ua
.export
, sizeof(args
.ua
.export
),
2008 if (r
< 0 && errno
== EOPNOTSUPP
) {
2009 r
= mount(fsb
->f_fstypename
, dirp
,
2010 fsb
->f_flags
| MNT_UPDATE
,
2018 cp
= dirp
+ dirplen
- 1;
2019 if (opt_flags
& OP_QUIET
)
2021 if (errno
== EPERM
) {
2023 warnx("can't change attributes for %s",
2026 "can't change attributes for %s", dirp
);
2029 if (opt_flags
& OP_ALLDIRS
) {
2030 if (errno
== EINVAL
)
2032 "-alldirs requested but %s is not a filesystem mountpoint",
2036 "could not remount %s: %m",
2040 /* back up over the last component */
2041 while (*cp
== '/' && cp
> dirp
)
2043 while (*(cp
- 1) != '/' && cp
> dirp
)
2047 warnx("mnt unsucc");
2048 syslog(LOG_ERR
, "can't export %s", dirp
);
2053 /* Check that we're still on the same filesystem. */
2054 if (statfs(dirp
, &fsb1
) != 0 || bcmp(&fsb1
.f_fsid
,
2055 &fsb
->f_fsid
, sizeof(fsb1
.f_fsid
)) != 0) {
2057 syslog(LOG_ERR
, "can't export %s", dirp
);
2073 * Translate a net address.
2075 * If `maskflg' is nonzero, then `cp' is a netmask, not a network address.
2078 get_net(char *cp
, struct netmsk
*net
, int maskflg
)
2080 struct netent
*np
= NULL
;
2081 char *name
, *p
, *prefp
;
2082 struct sockaddr_in sin
;
2083 struct sockaddr
*sa
= NULL
;
2084 struct addrinfo hints
, *ai
= NULL
;
2085 char netname
[NI_MAXHOST
];
2089 if ((opt_flags
& OP_MASKLEN
) && !maskflg
) {
2090 p
= strchr(cp
, '/');
2096 * Check for a numeric address first. We wish to avoid
2097 * possible DNS lookups in getnetbyname().
2099 if (isxdigit(*cp
) || *cp
== ':') {
2100 memset(&hints
, 0, sizeof hints
);
2101 /* Ensure the mask and the network have the same family. */
2102 if (maskflg
&& (opt_flags
& OP_NET
))
2103 hints
.ai_family
= net
->nt_net
.ss_family
;
2104 else if (!maskflg
&& (opt_flags
& OP_HAVEMASK
))
2105 hints
.ai_family
= net
->nt_mask
.ss_family
;
2107 hints
.ai_family
= AF_UNSPEC
;
2108 hints
.ai_flags
= AI_NUMERICHOST
;
2109 if (getaddrinfo(cp
, NULL
, &hints
, &ai
) == 0)
2111 if (sa
!= NULL
&& ai
->ai_family
== AF_INET
) {
2113 * The address in `cp' is really a network address, so
2114 * use inet_network() to re-interpret this correctly.
2115 * e.g. "127.1" means 127.1.0.0, not 127.0.0.1.
2117 bzero(&sin
, sizeof sin
);
2118 sin
.sin_family
= AF_INET
;
2119 sin
.sin_len
= sizeof sin
;
2120 sin
.sin_addr
= inet_makeaddr(inet_network(cp
), 0);
2122 fprintf(stderr
, "get_net: v4 addr %s\n",
2123 inet_ntoa(sin
.sin_addr
));
2124 sa
= (struct sockaddr
*)&sin
;
2127 if (sa
== NULL
&& (np
= getnetbyname(cp
)) != NULL
) {
2128 bzero(&sin
, sizeof sin
);
2129 sin
.sin_family
= AF_INET
;
2130 sin
.sin_len
= sizeof sin
;
2131 sin
.sin_addr
= inet_makeaddr(np
->n_net
, 0);
2132 sa
= (struct sockaddr
*)&sin
;
2138 /* The specified sockaddr is a mask. */
2139 if (checkmask(sa
) != 0)
2141 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2142 opt_flags
|= OP_HAVEMASK
;
2144 /* The specified sockaddr is a network address. */
2145 bcopy(sa
, &net
->nt_net
, sa
->sa_len
);
2147 /* Get a network name for the export list. */
2150 } else if (getnameinfo(sa
, sa
->sa_len
, netname
, sizeof netname
,
2151 NULL
, 0, NI_NUMERICHOST
) == 0) {
2156 if ((net
->nt_name
= strdup(name
)) == NULL
)
2160 * Extract a mask from either a "/<masklen>" suffix, or
2161 * from the class of an IPv4 address.
2163 if (opt_flags
& OP_MASKLEN
) {
2164 preflen
= strtol(prefp
, NULL
, 10);
2165 if (preflen
< 0L || preflen
== LONG_MAX
)
2167 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2168 if (makemask(&net
->nt_mask
, (int)preflen
) != 0)
2170 opt_flags
|= OP_HAVEMASK
;
2172 } else if (sa
->sa_family
== AF_INET
&&
2173 (opt_flags
& OP_MASK
) == 0) {
2176 addr
= ((struct sockaddr_in
*)sa
)->sin_addr
.s_addr
;
2177 if (IN_CLASSA(addr
))
2179 else if (IN_CLASSB(addr
))
2181 else if (IN_CLASSC(addr
))
2183 else if (IN_CLASSD(addr
))
2186 preflen
= 32; /* XXX */
2188 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2189 makemask(&net
->nt_mask
, (int)preflen
);
2190 opt_flags
|= OP_HAVEMASK
;
2205 * Parse out the next white space separated field
2208 nextfield(char **cp
, char **endcp
)
2213 while (*p
== ' ' || *p
== '\t')
2215 if (*p
== '\n' || *p
== '\0')
2219 while (*p
!= ' ' && *p
!= '\t' && *p
!= '\n' && *p
!= '\0')
2226 * Get an exports file line. Skip over blank lines and handle line
2234 int totlen
, cont_line
;
2237 * Loop around ignoring blank lines and getting all continuation lines.
2242 if ((p
= fgetln(exp_file
, &len
)) == NULL
)
2247 (*cp
== ' ' || *cp
== '\t' || *cp
== '\n' || *cp
== '\\')) {
2257 if (linesize
< len
+ totlen
+ 1) {
2258 linesize
= len
+ totlen
+ 1;
2259 line
= realloc(line
, linesize
);
2263 memcpy(line
+ totlen
, p
, len
);
2265 line
[totlen
] = '\0';
2266 } while (totlen
== 0 || cont_line
);
2271 * Parse a description of a credential.
2274 parsecred(char *namelist
, struct ucred
*cr
)
2281 gid_t ngroups
, groups
[NGROUPS
+ 1];
2284 * Set up the unprivileged user.
2288 cr
->cr_groups
[0] = -2;
2291 * Get the user's password table entry.
2293 names
= strsep(&namelist
, " \t\n");
2294 name
= strsep(&names
, ":");
2295 if (isdigit(*name
) || *name
== '-')
2296 pw
= getpwuid(atoi(name
));
2298 pw
= getpwnam(name
);
2300 * Credentials specified as those of a user.
2302 if (names
== NULL
) {
2304 syslog(LOG_ERR
, "unknown user: %s", name
);
2307 cr
->cr_uid
= pw
->pw_uid
;
2308 ngroups
= NGROUPS
+ 1;
2309 if (getgrouplist(pw
->pw_name
, pw
->pw_gid
, groups
, &ngroups
))
2310 syslog(LOG_ERR
, "too many groups");
2312 * Compress out duplicate
2314 cr
->cr_ngroups
= ngroups
- 1;
2315 cr
->cr_groups
[0] = groups
[0];
2316 for (cnt
= 2; cnt
< ngroups
; cnt
++)
2317 cr
->cr_groups
[cnt
- 1] = groups
[cnt
];
2321 * Explicit credential specified as a colon separated list:
2325 cr
->cr_uid
= pw
->pw_uid
;
2326 else if (isdigit(*name
) || *name
== '-')
2327 cr
->cr_uid
= atoi(name
);
2329 syslog(LOG_ERR
, "unknown user: %s", name
);
2333 while (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
< NGROUPS
) {
2334 name
= strsep(&names
, ":");
2335 if (isdigit(*name
) || *name
== '-') {
2336 cr
->cr_groups
[cr
->cr_ngroups
++] = atoi(name
);
2338 if ((gr
= getgrnam(name
)) == NULL
) {
2339 syslog(LOG_ERR
, "unknown group: %s", name
);
2342 cr
->cr_groups
[cr
->cr_ngroups
++] = gr
->gr_gid
;
2345 if (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
== NGROUPS
)
2346 syslog(LOG_ERR
, "too many groups");
2349 #define STRSIZ (RPCMNT_NAMELEN+RPCMNT_PATHLEN+50)
2351 * Routines that maintain the remote mounttab
2356 struct mountlist
*mlp
, **mlpp
;
2357 char *host
, *dirp
, *cp
;
2361 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "r")) == NULL
) {
2362 if (errno
== ENOENT
)
2365 syslog(LOG_ERR
, "can't open %s", _PATH_RMOUNTLIST
);
2370 while (fgets(str
, STRSIZ
, mlfile
) != NULL
) {
2372 host
= strsep(&cp
, " \t\n");
2373 dirp
= strsep(&cp
, " \t\n");
2374 if (host
== NULL
|| dirp
== NULL
)
2376 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2379 strncpy(mlp
->ml_host
, host
, RPCMNT_NAMELEN
);
2380 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2381 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2382 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2383 mlp
->ml_next
= NULL
;
2385 mlpp
= &mlp
->ml_next
;
2391 del_mlist(char *hostp
, char *dirp
)
2393 struct mountlist
*mlp
, **mlpp
;
2394 struct mountlist
*mlp2
;
2401 if (!strcmp(mlp
->ml_host
, hostp
) &&
2402 (!dirp
|| !strcmp(mlp
->ml_dirp
, dirp
))) {
2405 *mlpp
= mlp
= mlp
->ml_next
;
2406 free((caddr_t
)mlp2
);
2408 mlpp
= &mlp
->ml_next
;
2413 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "w")) == NULL
) {
2414 syslog(LOG_ERR
,"can't update %s", _PATH_RMOUNTLIST
);
2419 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2427 add_mlist(char *hostp
, char *dirp
)
2429 struct mountlist
*mlp
, **mlpp
;
2435 if (!strcmp(mlp
->ml_host
, hostp
) && !strcmp(mlp
->ml_dirp
, dirp
))
2437 mlpp
= &mlp
->ml_next
;
2440 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2443 strncpy(mlp
->ml_host
, hostp
, RPCMNT_NAMELEN
);
2444 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2445 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2446 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2447 mlp
->ml_next
= NULL
;
2449 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "a")) == NULL
) {
2450 syslog(LOG_ERR
, "can't update %s", _PATH_RMOUNTLIST
);
2453 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2458 * Free up a group list.
2461 free_grp(struct grouplist
*grp
)
2463 if (grp
->gr_type
== GT_HOST
) {
2464 if (grp
->gr_ptr
.gt_addrinfo
!= NULL
)
2465 freeaddrinfo(grp
->gr_ptr
.gt_addrinfo
);
2466 } else if (grp
->gr_type
== GT_NET
) {
2467 if (grp
->gr_ptr
.gt_net
.nt_name
)
2468 free(grp
->gr_ptr
.gt_net
.nt_name
);
2475 SYSLOG(int pri
, const char *fmt
, ...)
2480 vfprintf(stderr
, fmt
, ap
);
2486 * Check options for consistency.
2489 check_options(struct dirlist
*dp
)
2494 if ((opt_flags
& (OP_MAPROOT
| OP_MAPALL
)) == (OP_MAPROOT
| OP_MAPALL
)) {
2495 syslog(LOG_ERR
, "-mapall and -maproot mutually exclusive");
2498 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_NET
) == 0) {
2499 syslog(LOG_ERR
, "-mask requires -network");
2502 if ((opt_flags
& OP_NET
) && (opt_flags
& OP_HAVEMASK
) == 0) {
2503 syslog(LOG_ERR
, "-network requires mask specification");
2506 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_MASKLEN
)) {
2507 syslog(LOG_ERR
, "-mask and /masklen are mutually exclusive");
2510 if ((opt_flags
& OP_ALLDIRS
) && dp
->dp_left
) {
2511 syslog(LOG_ERR
, "-alldirs has multiple directories");
2518 * Check an absolute directory path for any symbolic links. Return true
2521 check_dirpath(char *dirp
)
2528 while (*cp
&& ret
) {
2531 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2537 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2543 * Make a netmask according to the specified prefix length. The ss_family
2544 * and other non-address fields must be initialised before calling this.
2547 makemask(struct sockaddr_storage
*ssp
, int bitlen
)
2552 if ((p
= sa_rawaddr((struct sockaddr
*)ssp
, &len
)) == NULL
)
2554 if (bitlen
> len
* CHAR_BIT
)
2556 for (i
= 0; i
< len
; i
++) {
2557 bits
= (bitlen
> CHAR_BIT
) ? CHAR_BIT
: bitlen
;
2558 *p
++ = (1 << bits
) - 1;
2565 * Check that the sockaddr is a valid netmask. Returns 0 if the mask
2566 * is acceptable (i.e. of the form 1...10....0).
2569 checkmask(struct sockaddr
*sa
)
2574 if ((mask
= sa_rawaddr(sa
, &len
)) == NULL
)
2577 for (i
= 0; i
< len
; i
++)
2578 if (mask
[i
] != 0xff)
2581 if (~mask
[i
] & (u_char
)(~mask
[i
] + 1))
2585 for (; i
< len
; i
++)
2592 * Compare two sockaddrs according to a specified mask. Return zero if
2593 * `sa1' matches `sa2' when filtered by the netmask in `samask'.
2594 * If samask is NULL, perform a full comparision.
2597 sacmp(struct sockaddr
*sa1
, struct sockaddr
*sa2
, struct sockaddr
*samask
)
2599 unsigned char *p1
, *p2
, *mask
;
2602 if (sa1
->sa_family
!= sa2
->sa_family
||
2603 (p1
= sa_rawaddr(sa1
, &len
)) == NULL
||
2604 (p2
= sa_rawaddr(sa2
, NULL
)) == NULL
)
2607 switch (sa1
->sa_family
) {
2609 if (((struct sockaddr_in6
*)sa1
)->sin6_scope_id
!=
2610 ((struct sockaddr_in6
*)sa2
)->sin6_scope_id
)
2615 /* Simple binary comparison if no mask specified. */
2617 return (memcmp(p1
, p2
, len
));
2619 /* Set up the mask, and do a mask-based comparison. */
2620 if (sa1
->sa_family
!= samask
->sa_family
||
2621 (mask
= sa_rawaddr(samask
, NULL
)) == NULL
)
2624 for (i
= 0; i
< len
; i
++)
2625 if ((p1
[i
] & mask
[i
]) != (p2
[i
] & mask
[i
]))
2631 * Return a pointer to the part of the sockaddr that contains the
2632 * raw address, and set *nbytes to its length in bytes. Returns
2633 * NULL if the address family is unknown.
2636 sa_rawaddr(struct sockaddr
*sa
, int *nbytes
) {
2640 switch (sa
->sa_family
) {
2642 len
= sizeof(((struct sockaddr_in
*)sa
)->sin_addr
);
2643 p
= &((struct sockaddr_in
*)sa
)->sin_addr
;
2646 len
= sizeof(((struct sockaddr_in6
*)sa
)->sin6_addr
);
2647 p
= &((struct sockaddr_in6
*)sa
)->sin6_addr
;
2665 void terminate(int sig
)
2667 pidfile_remove(pfh
);
2668 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER1
, NULL
);
2669 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER3
, NULL
);