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 */
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(int incremental
);
169 int get_host(char *, struct grouplist
*, struct grouplist
*);
170 struct hostlist
*get_ht(void);
172 void get_mountlist(void);
173 static void delete_export(struct statfs
*fsp
);
174 int get_net(char *, struct netmsk
*, int);
175 void getexp_err(struct exportlist
*, struct grouplist
*);
176 struct grouplist
*get_grp(void);
177 void hang_dirp(struct dirlist
*, struct grouplist
*,
178 struct exportlist
*, int);
179 void huphandler1(int sig
);
180 void huphandler2(int sig
);
181 int makemask(struct sockaddr_storage
*ssp
, int bitlen
);
182 void mntsrv(struct svc_req
*, SVCXPRT
*);
183 void nextfield(char **, char **);
184 void out_of_mem(void) __dead2
;
185 void parsecred(char *, struct ucred
*);
186 int put_exlist(struct dirlist
*, XDR
*, struct dirlist
*, int *, int);
187 void *sa_rawaddr(struct sockaddr
*sa
, int *nbytes
);
188 int sacmp(struct sockaddr
*sa1
, struct sockaddr
*sa2
,
189 struct sockaddr
*samask
);
190 int scan_tree(struct dirlist
*, struct sockaddr
*);
191 static void usage(void);
192 int xdr_dir(XDR
*, char *);
193 int xdr_explist(XDR
*, caddr_t
);
194 int xdr_explist_brief(XDR
*, caddr_t
);
195 int xdr_explist_common(XDR
*, caddr_t
, int);
196 int xdr_fhs(XDR
*, caddr_t
);
197 int xdr_mlist(XDR
*, caddr_t
);
198 void terminate(int) __dead2
;
200 struct exportlist
*exphead
;
201 struct mountlist
*mlhead
;
202 struct grouplist
*grphead
;
203 char *exnames_default
[2] = { _PATH_EXPORTS
, NULL
};
206 struct ucred def_anon
;
208 int resvport_only
= 1;
216 char *svcport_str
= NULL
;
218 static int have_v6
= 1;
220 struct pidfh
*pfh
= NULL
;
221 /* Bits for the opt_flags above */
222 #define OP_MAPROOT 0x01
223 #define OP_MAPALL 0x02
227 #define OP_ALLDIRS 0x40
228 #define OP_HAVEMASK 0x80 /* A mask was specified or inferred. */
229 #define OP_QUIET 0x100
230 #define OP_MASKLEN 0x200
234 void SYSLOG(int, const char *, ...);
235 #define syslog SYSLOG
241 * Mountd server for NFS mount protocol as described in:
242 * NFS: Network File System Protocol Specification, RFC1094, Appendix A
243 * The optional arguments are the exports file name
244 * default: _PATH_EXPORTS
245 * and "-n" to allow nonroot mount.
248 main(int argc
, char **argv
)
251 struct netconfig
*nconf
;
252 char *endptr
, **hosts_bak
;
257 int maxrec
= RPC_MAXDATASIZE
;
260 def_anon
.cr_uid
= (uid_t
)65534;
261 def_anon
.cr_ngroups
= 1;
262 def_anon
.cr_groups
[0] = (gid_t
)65533;
264 /* Check that another mountd isn't already running. */
265 pfh
= pidfile_open(_PATH_MOUNTDPID
, 0600, &otherpid
);
268 errx(1, "mountd already running, pid: %d.", otherpid
);
269 warn("cannot open or create pidfile");
272 s
= socket(AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
277 if (modfind("nfs") < 0) {
278 /* Not present in kernel, try loading it */
279 if (kldload("nfs") < 0 || modfind("nfs") < 0)
280 errx(1, "NFS server is not available or loadable");
283 while ((c
= getopt(argc
, argv
, "2dh:lnp:r")) != -1) {
295 debug
= debug
? 0 : 1;
302 svcport
= (in_port_t
)strtoul(optarg
, &endptr
, 10);
303 if (endptr
== NULL
|| *endptr
!= '\0' ||
304 svcport
== 0 || svcport
>= IPPORT_MAX
)
306 svcport_str
= strdup(optarg
);
311 hosts_bak
= realloc(hosts
, nhosts
* sizeof(char *));
312 if (hosts_bak
== NULL
) {
314 for (k
= 0; k
< nhosts
; k
++)
321 hosts
[nhosts
- 1] = strdup(optarg
);
322 if (hosts
[nhosts
- 1] == NULL
) {
323 for (k
= 0; k
< (nhosts
- 1); k
++)
335 signal(SIGINT
, SIG_IGN
);
336 signal(SIGQUIT
, SIG_IGN
);
346 exnames
= exnames_default
;
347 openlog("mountd", LOG_PID
, LOG_DAEMON
);
349 warnx("getting export list");
352 warnx("getting mount list");
356 signal(SIGHUP
, huphandler1
);
357 signal(SIGUSR1
, huphandler2
);
358 signal(SIGTERM
, terminate
);
359 signal(SIGPIPE
, SIG_IGN
);
363 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER1
, NULL
);
364 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER3
, NULL
);
366 rpc_control(RPC_SVC_CONNMAXREC_SET
, &maxrec
);
368 if (!resvport_only
) {
369 if (sysctlbyname("vfs.nfs.nfs_privport", NULL
, NULL
,
370 &resvport_only
, sizeof(resvport_only
)) != 0 &&
372 syslog(LOG_ERR
, "sysctl: %m");
378 * If no hosts were specified, add a wildcard entry to bind to
379 * INADDR_ANY. Otherwise make sure 127.0.0.1 and ::1 are added to the
383 hosts
= malloc(sizeof(char *));
391 hosts_bak
= realloc(hosts
, (nhosts
+ 2) *
393 if (hosts_bak
== NULL
) {
394 for (k
= 0; k
< nhosts
; k
++)
401 hosts
[nhosts
- 2] = "::1";
403 hosts_bak
= realloc(hosts
, (nhosts
+ 1) * sizeof(char *));
404 if (hosts_bak
== NULL
) {
405 for (k
= 0; k
< nhosts
; k
++)
414 hosts
[nhosts
- 1] = "127.0.0.1";
417 nc_handle
= setnetconfig();
418 while ((nconf
= getnetconfig(nc_handle
))) {
419 if (nconf
->nc_flag
& NC_VISIBLE
) {
420 if (have_v6
== 0 && strcmp(nconf
->nc_protofmly
,
424 create_service(nconf
);
427 endnetconfig(nc_handle
);
430 syslog(LOG_ERR
, "could not create any services");
434 /* Expand svc_run() here so that we can call get_exportlist(). */
445 switch (select(svc_maxfd
+ 1, &readfds
, NULL
, NULL
, NULL
)) {
449 syslog(LOG_ERR
, "mountd died: select: %m");
454 svc_getreqset(&readfds
);
460 * This routine creates and binds sockets on the appropriate
461 * addresses. It gets called one time for each transport and
462 * registrates the service with rpcbind on that trasport.
465 create_service(struct netconfig
*nconf
)
467 struct addrinfo hints
, *res
= NULL
;
468 struct sockaddr_in
*sin
;
469 struct sockaddr_in6
*sin6
;
470 struct __rpc_sockinfo si
;
471 struct netbuf servaddr
;
472 SVCXPRT
*transp
= NULL
;
479 u_int32_t host_addr
[4]; /* IPv4 or IPv6 */
481 if ((nconf
->nc_semantics
!= NC_TPI_CLTS
) &&
482 (nconf
->nc_semantics
!= NC_TPI_COTS
) &&
483 (nconf
->nc_semantics
!= NC_TPI_COTS_ORD
))
484 return; /* not my type */
487 * XXX - using RPC library internal functions.
489 if (!__rpc_nconf2sockinfo(nconf
, &si
)) {
490 syslog(LOG_ERR
, "cannot get information for %s",
495 /* Get mountd's address on this transport */
496 memset(&hints
, 0, sizeof hints
);
497 hints
.ai_flags
= AI_PASSIVE
;
498 hints
.ai_family
= si
.si_af
;
499 hints
.ai_socktype
= si
.si_socktype
;
500 hints
.ai_protocol
= si
.si_proto
;
503 * Bind to specific IPs if asked to
506 while (nhostsbak
> 0) {
509 * XXX - using RPC library internal functions.
511 if ((fd
= __rpc_nconf2fd(nconf
)) < 0) {
513 if (errno
== EPROTONOSUPPORT
&&
514 nconf
->nc_semantics
!= NC_TPI_CLTS
)
517 syslog(non_fatal
? LOG_DEBUG
: LOG_ERR
,
518 "cannot create socket for %s", nconf
->nc_netid
);
522 switch (hints
.ai_family
) {
524 if (inet_pton(AF_INET
, hosts
[nhostsbak
],
526 hints
.ai_flags
&= AI_NUMERICHOST
;
529 * Skip if we have an AF_INET6 address.
531 if (inet_pton(AF_INET6
, hosts
[nhostsbak
],
539 if (inet_pton(AF_INET6
, hosts
[nhostsbak
],
541 hints
.ai_flags
&= AI_NUMERICHOST
;
544 * Skip if we have an AF_INET address.
546 if (inet_pton(AF_INET
, hosts
[nhostsbak
],
554 * We're doing host-based access checks here, so don't
555 * allow v4-in-v6 to confuse things. The kernel will
556 * disable it by default on NFS sockets too.
558 if (setsockopt(fd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &one
,
561 "can't disable v4-in-v6 on IPv6 socket");
570 * If no hosts were specified, just bind to INADDR_ANY
572 if (strcmp("*", hosts
[nhostsbak
]) == 0) {
573 if (svcport_str
== NULL
) {
574 res
= malloc(sizeof(struct addrinfo
));
577 res
->ai_flags
= hints
.ai_flags
;
578 res
->ai_family
= hints
.ai_family
;
579 res
->ai_protocol
= hints
.ai_protocol
;
580 switch (res
->ai_family
) {
582 sin
= malloc(sizeof(struct sockaddr_in
));
585 sin
->sin_family
= AF_INET
;
586 sin
->sin_port
= htons(0);
587 sin
->sin_addr
.s_addr
= htonl(INADDR_ANY
);
588 res
->ai_addr
= (struct sockaddr
*) sin
;
589 res
->ai_addrlen
= (socklen_t
)
590 sizeof(res
->ai_addr
);
593 sin6
= malloc(sizeof(struct sockaddr_in6
));
596 sin6
->sin6_family
= AF_INET6
;
597 sin6
->sin6_port
= htons(0);
598 sin6
->sin6_addr
= in6addr_any
;
599 res
->ai_addr
= (struct sockaddr
*) sin6
;
600 res
->ai_addrlen
= (socklen_t
)
601 sizeof(res
->ai_addr
);
607 if ((aicode
= getaddrinfo(NULL
, svcport_str
,
608 &hints
, &res
)) != 0) {
610 "cannot get local address for %s: %s",
612 gai_strerror(aicode
));
617 if ((aicode
= getaddrinfo(hosts
[nhostsbak
], svcport_str
,
618 &hints
, &res
)) != 0) {
620 "cannot get local address for %s: %s",
621 nconf
->nc_netid
, gai_strerror(aicode
));
629 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
630 (char *)&on
, sizeof(on
));
633 r
= bindresvport_sa(fd
, res
->ai_addr
);
635 syslog(LOG_ERR
, "bindresvport_sa: %m");
639 if (nconf
->nc_semantics
!= NC_TPI_CLTS
)
640 listen(fd
, SOMAXCONN
);
642 if (nconf
->nc_semantics
== NC_TPI_CLTS
)
643 transp
= svc_dg_create(fd
, 0, 0);
645 transp
= svc_vc_create(fd
, RPC_MAXDATASIZE
,
648 if (transp
!= NULL
) {
649 if (!svc_reg(transp
, RPCPROG_MNT
, RPCMNT_VER1
, mntsrv
,
652 "can't register %s RPCMNT_VER1 service",
655 if (!svc_reg(transp
, RPCPROG_MNT
, RPCMNT_VER3
,
658 "can't register %s RPCMNT_VER3 service",
662 syslog(LOG_WARNING
, "can't create %s services",
665 if (registered
== 0) {
667 memset(&hints
, 0, sizeof hints
);
668 hints
.ai_flags
= AI_PASSIVE
;
669 hints
.ai_family
= si
.si_af
;
670 hints
.ai_socktype
= si
.si_socktype
;
671 hints
.ai_protocol
= si
.si_proto
;
673 if (svcport_str
== NULL
) {
674 svcport_str
= malloc(NI_MAXSERV
* sizeof(char));
675 if (svcport_str
== NULL
)
678 if (getnameinfo(res
->ai_addr
,
679 res
->ai_addr
->sa_len
, NULL
, NI_MAXHOST
,
680 svcport_str
, NI_MAXSERV
* sizeof(char),
681 NI_NUMERICHOST
| NI_NUMERICSERV
))
682 errx(1, "Cannot get port number");
685 if((aicode
= getaddrinfo(NULL
, svcport_str
, &hints
,
687 syslog(LOG_ERR
, "cannot get local address: %s",
688 gai_strerror(aicode
));
692 servaddr
.buf
= malloc(res
->ai_addrlen
);
693 memcpy(servaddr
.buf
, res
->ai_addr
, res
->ai_addrlen
);
694 servaddr
.len
= res
->ai_addrlen
;
696 rpcb_set(RPCPROG_MNT
, RPCMNT_VER1
, nconf
, &servaddr
);
697 rpcb_set(RPCPROG_MNT
, RPCMNT_VER3
, nconf
, &servaddr
);
709 "usage: mountd [-2] [-d] [-l] [-n] [-p <port>] [-r] "
710 "[-h <bindip>] [export_file ...]\n");
715 * The mount rpc service
718 mntsrv(struct svc_req
*rqstp
, SVCXPRT
*transp
)
720 struct exportlist
*ep
;
725 char host
[NI_MAXHOST
], numerichost
[NI_MAXHOST
];
726 int lookup_failed
= 1;
727 struct sockaddr
*saddr
;
729 char rpcpath
[RPCMNT_PATHLEN
+ 1], dirpath
[MAXPATHLEN
];
730 int bad
= 0, defset
, hostset
;
731 sigset_t sighup_mask
;
733 sigemptyset(&sighup_mask
);
734 sigaddset(&sighup_mask
, SIGHUP
);
736 saddr
= svc_getrpccaller(transp
)->buf
;
737 switch (saddr
->sa_family
) {
739 sport
= ntohs(((struct sockaddr_in6
*)saddr
)->sin6_port
);
742 sport
= ntohs(((struct sockaddr_in
*)saddr
)->sin_port
);
745 syslog(LOG_ERR
, "request from unknown address family");
748 lookup_failed
= getnameinfo(saddr
, saddr
->sa_len
, host
, sizeof host
,
750 getnameinfo(saddr
, saddr
->sa_len
, numerichost
,
751 sizeof numerichost
, NULL
, 0, NI_NUMERICHOST
);
752 switch (rqstp
->rq_proc
) {
754 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
755 syslog(LOG_ERR
, "can't send reply");
758 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
760 "mount request from %s from unprivileged port",
762 svcerr_weakauth(transp
);
765 if (!svc_getargs(transp
, (xdrproc_t
)xdr_dir
, rpcpath
)) {
766 syslog(LOG_NOTICE
, "undecodable mount request from %s",
768 svcerr_decode(transp
);
773 * Get the real pathname and make sure it is a directory
774 * or a regular file if the -r option was specified
777 if (realpath(rpcpath
, dirpath
) == NULL
||
778 stat(dirpath
, &stb
) < 0 ||
779 (!S_ISDIR(stb
.st_mode
) &&
780 (dir_only
|| !S_ISREG(stb
.st_mode
))) ||
781 statfs(dirpath
, &fsb
) < 0) {
782 chdir("/"); /* Just in case realpath doesn't */
784 "mount request from %s for non existent path %s",
785 numerichost
, dirpath
);
787 warnx("stat failed on %s", dirpath
);
788 bad
= ENOENT
; /* We will send error reply later */
791 /* Check in the exports list */
792 sigprocmask(SIG_BLOCK
, &sighup_mask
, NULL
);
793 ep
= ex_search(&fsb
.f_fsid
);
794 hostset
= defset
= 0;
795 if (ep
&& (chk_host(ep
->ex_defdir
, saddr
, &defset
, &hostset
) ||
796 ((dp
= dirp_search(ep
->ex_dirl
, dirpath
)) &&
797 chk_host(dp
, saddr
, &defset
, &hostset
)) ||
798 (defset
&& scan_tree(ep
->ex_defdir
, saddr
) == 0 &&
799 scan_tree(ep
->ex_dirl
, saddr
) == 0))) {
801 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_long
,
803 syslog(LOG_ERR
, "can't send reply");
804 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
807 if (hostset
& DP_HOSTSET
)
808 fhr
.fhr_flag
= hostset
;
810 fhr
.fhr_flag
= defset
;
811 fhr
.fhr_vers
= rqstp
->rq_vers
;
812 /* Get the file handle */
813 memset(&fhr
.fhr_fh
, 0, sizeof(nfsfh_t
));
814 if (getfh(dirpath
, (fhandle_t
*)&fhr
.fhr_fh
) < 0) {
816 syslog(LOG_ERR
, "can't get fh for %s", dirpath
);
817 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_long
,
819 syslog(LOG_ERR
, "can't send reply");
820 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
823 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_fhs
, &fhr
))
824 syslog(LOG_ERR
, "can't send reply");
826 add_mlist(host
, dirpath
);
828 add_mlist(numerichost
, dirpath
);
830 warnx("mount successful");
833 "mount request succeeded from %s for %s",
834 numerichost
, dirpath
);
838 "mount request denied from %s for %s",
839 numerichost
, dirpath
);
842 if (bad
&& !svc_sendreply(transp
, (xdrproc_t
)xdr_long
, &bad
))
843 syslog(LOG_ERR
, "can't send reply");
844 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
847 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_mlist
, NULL
))
848 syslog(LOG_ERR
, "can't send reply");
851 "dump request succeeded from %s",
855 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
857 "umount request from %s from unprivileged port",
859 svcerr_weakauth(transp
);
862 if (!svc_getargs(transp
, (xdrproc_t
)xdr_dir
, rpcpath
)) {
863 syslog(LOG_NOTICE
, "undecodable umount request from %s",
865 svcerr_decode(transp
);
868 if (realpath(rpcpath
, dirpath
) == NULL
) {
869 syslog(LOG_NOTICE
, "umount request from %s "
870 "for non existent path %s",
871 numerichost
, dirpath
);
873 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
874 syslog(LOG_ERR
, "can't send reply");
876 del_mlist(host
, dirpath
);
877 del_mlist(numerichost
, dirpath
);
880 "umount request succeeded from %s for %s",
881 numerichost
, dirpath
);
884 if (sport
>= IPPORT_RESERVED
&& resvport_only
) {
886 "umountall request from %s from unprivileged port",
888 svcerr_weakauth(transp
);
891 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_void
, NULL
))
892 syslog(LOG_ERR
, "can't send reply");
894 del_mlist(host
, NULL
);
895 del_mlist(numerichost
, NULL
);
898 "umountall request succeeded from %s",
902 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_explist
, NULL
))
903 if (!svc_sendreply(transp
, (xdrproc_t
)xdr_explist_brief
, NULL
))
904 syslog(LOG_ERR
, "can't send reply");
907 "export request succeeded from %s",
911 svcerr_noproc(transp
);
917 * Xdr conversion for a dirpath string
920 xdr_dir(XDR
*xdrsp
, char *dirp
)
922 return (xdr_string(xdrsp
, &dirp
, RPCMNT_PATHLEN
));
926 * Xdr routine to generate file handle reply
929 xdr_fhs(XDR
*xdrsp
, caddr_t cp
)
931 struct fhreturn
*fhrp
= (struct fhreturn
*)cp
;
932 long ok
= 0, len
, auth
;
934 if (!xdr_long(xdrsp
, &ok
))
936 switch (fhrp
->fhr_vers
) {
938 return (xdr_opaque(xdrsp
, (caddr_t
)&fhrp
->fhr_fh
, NFSX_V2FH
));
941 if (!xdr_long(xdrsp
, &len
))
943 if (!xdr_opaque(xdrsp
, (caddr_t
)&fhrp
->fhr_fh
, len
))
947 if (!xdr_long(xdrsp
, &len
))
949 return (xdr_long(xdrsp
, &auth
));
955 xdr_mlist(XDR
*xdrsp
, caddr_t cp __unused
)
957 struct mountlist
*mlp
;
964 if (!xdr_bool(xdrsp
, &true))
966 strp
= &mlp
->ml_host
[0];
967 if (!xdr_string(xdrsp
, &strp
, RPCMNT_NAMELEN
))
969 strp
= &mlp
->ml_dirp
[0];
970 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
974 if (!xdr_bool(xdrsp
, &false))
980 * Xdr conversion for export list
983 xdr_explist_common(XDR
*xdrsp
, caddr_t cp __unused
, int brief
)
985 struct exportlist
*ep
;
988 sigset_t sighup_mask
;
990 sigemptyset(&sighup_mask
);
991 sigaddset(&sighup_mask
, SIGHUP
);
992 sigaddset(&sighup_mask
, SIGUSR1
);
993 sigprocmask(SIG_BLOCK
, &sighup_mask
, NULL
);
997 if (put_exlist(ep
->ex_dirl
, xdrsp
, ep
->ex_defdir
,
1000 if (ep
->ex_defdir
&& putdef
== 0 &&
1001 put_exlist(ep
->ex_defdir
, xdrsp
, NULL
,
1006 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
1007 if (!xdr_bool(xdrsp
, &false))
1011 sigprocmask(SIG_UNBLOCK
, &sighup_mask
, NULL
);
1016 * Called from xdr_explist() to traverse the tree and export the
1020 put_exlist(struct dirlist
*dp
, XDR
*xdrsp
, struct dirlist
*adp
, int *putdefp
, int brief
)
1022 struct grouplist
*grp
;
1023 struct hostlist
*hp
;
1030 if (put_exlist(dp
->dp_left
, xdrsp
, adp
, putdefp
, brief
))
1032 if (!xdr_bool(xdrsp
, &true))
1035 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
1037 if (adp
&& !strcmp(dp
->dp_dirp
, adp
->dp_dirp
)) {
1042 if (!xdr_bool(xdrsp
, &true))
1045 if (!xdr_string(xdrsp
, &strp
, RPCMNT_PATHLEN
))
1047 } else if ((dp
->dp_flag
& DP_DEFSET
) == 0 &&
1048 (gotalldir
== 0 || (adp
->dp_flag
& DP_DEFSET
) == 0)) {
1052 if (grp
->gr_type
== GT_HOST
) {
1053 if (!xdr_bool(xdrsp
, &true))
1055 strp
= grp
->gr_ptr
.gt_addrinfo
->ai_canonname
;
1056 if (!xdr_string(xdrsp
, &strp
,
1059 } else if (grp
->gr_type
== GT_NET
) {
1060 if (!xdr_bool(xdrsp
, &true))
1062 strp
= grp
->gr_ptr
.gt_net
.nt_name
;
1063 if (!xdr_string(xdrsp
, &strp
,
1068 if (gotalldir
&& hp
== NULL
) {
1074 if (!xdr_bool(xdrsp
, &false))
1076 if (put_exlist(dp
->dp_right
, xdrsp
, adp
, putdefp
, brief
))
1083 xdr_explist(XDR
*xdrsp
, caddr_t cp
)
1086 return xdr_explist_common(xdrsp
, cp
, 0);
1090 xdr_explist_brief(XDR
*xdrsp
, caddr_t cp
)
1093 return xdr_explist_common(xdrsp
, cp
, 1);
1101 * Get the export list from one, currently open file
1104 get_exportlist_one(void)
1106 struct exportlist
*ep
, *ep2
;
1107 struct grouplist
*grp
, *tgrp
;
1108 struct exportlist
**epp
;
1109 struct dirlist
*dirhead
;
1112 char *cp
, *endcp
, *dirp
, *hst
, *usr
, *dom
, savedc
;
1113 int len
, has_host
, exflags
, got_nondir
, dirplen
, netgrp
;
1115 dirhead
= (struct dirlist
*)NULL
;
1116 while (get_line()) {
1118 warnx("got line %s", line
);
1120 nextfield(&cp
, &endcp
);
1129 exflags
= MNT_EXPORTED
;
1135 * Create new exports list entry
1138 tgrp
= grp
= get_grp();
1140 if (len
> RPCMNT_NAMELEN
) {
1141 getexp_err(ep
, tgrp
);
1146 getexp_err(ep
, tgrp
);
1150 warnx("doing opt %s", cp
);
1152 if (do_opt(&cp
, &endcp
, ep
, grp
, &has_host
,
1154 getexp_err(ep
, tgrp
);
1157 } else if (*cp
== '/') {
1160 if (check_dirpath(cp
) &&
1161 statfs(cp
, &fsb
) >= 0) {
1162 if ((fsb
.f_flags
& MNT_AUTOMOUNTED
) != 0)
1163 syslog(LOG_ERR
, "Warning: exporting of "
1164 "automounted fs %s not supported", cp
);
1166 syslog(LOG_ERR
, "dirs must be first");
1167 getexp_err(ep
, tgrp
);
1171 if (ep
->ex_fs
.val
[0] != fsb
.f_fsid
.val
[0] ||
1172 ep
->ex_fs
.val
[1] != fsb
.f_fsid
.val
[1]) {
1173 getexp_err(ep
, tgrp
);
1178 * See if this directory is already
1181 ep
= ex_search(&fsb
.f_fsid
);
1184 ep
->ex_fs
= fsb
.f_fsid
;
1185 ep
->ex_fsdir
= strdup(fsb
.f_mntonname
);
1186 if (ep
->ex_fsdir
== NULL
)
1189 delete_export(&fsb
);
1192 warnx("making new ep fs=0x%x,0x%x",
1196 warnx("found ep fs=0x%x,0x%x",
1202 * Add dirpath to export mount point.
1204 dirp
= add_expdir(&dirhead
, cp
, len
);
1207 getexp_err(ep
, tgrp
);
1216 getexp_err(ep
, tgrp
);
1221 * Get the host or netgroup.
1224 netgrp
= getnetgrent(&hst
, &usr
, &dom
);
1227 grp
->gr_next
= get_grp();
1233 "null hostname in netgroup %s, skipping", cp
);
1234 grp
->gr_type
= GT_IGNORE
;
1235 } else if (get_host(hst
, grp
, tgrp
)) {
1237 "bad host %s in netgroup %s, skipping", hst
, cp
);
1238 grp
->gr_type
= GT_IGNORE
;
1240 } else if (get_host(cp
, grp
, tgrp
)) {
1241 syslog(LOG_ERR
, "bad host %s, skipping", cp
);
1242 grp
->gr_type
= GT_IGNORE
;
1245 } while (netgrp
&& getnetgrent(&hst
, &usr
, &dom
));
1250 nextfield(&cp
, &endcp
);
1253 if (check_options(dirhead
)) {
1254 getexp_err(ep
, tgrp
);
1258 grp
->gr_type
= GT_DEFAULT
;
1260 warnx("adding a default entry");
1263 * Don't allow a network export coincide with a list of
1264 * host(s) on the same line.
1266 } else if ((opt_flags
& OP_NET
) && tgrp
->gr_next
) {
1267 syslog(LOG_ERR
, "network/host conflict");
1268 getexp_err(ep
, tgrp
);
1272 * If an export list was specified on this line, make sure
1273 * that we have at least one valid entry, otherwise skip it.
1277 while (grp
&& grp
->gr_type
== GT_IGNORE
)
1280 getexp_err(ep
, tgrp
);
1286 * Loop through hosts, pushing the exports into the kernel.
1287 * After loop, tgrp points to the start of the list and
1288 * grp points to the last entry in the list.
1292 if (do_mount(ep
, grp
, exflags
, &anon
, dirp
, dirplen
,
1294 getexp_err(ep
, tgrp
);
1297 } while (grp
->gr_next
&& (grp
= grp
->gr_next
));
1300 * Success. Update the data structures.
1303 hang_dirp(dirhead
, tgrp
, ep
, opt_flags
);
1304 grp
->gr_next
= grphead
;
1307 hang_dirp(dirhead
, NULL
, ep
,
1312 if ((ep
->ex_flag
& EX_LINKED
) == 0) {
1317 * Insert in the list in alphabetical order.
1319 while (ep2
&& strcmp(ep2
->ex_fsdir
, ep
->ex_fsdir
) < 0) {
1320 epp
= &ep2
->ex_next
;
1326 ep
->ex_flag
|= EX_LINKED
;
1338 * Get the export list from all specified files.
1340 * If incremental is non-zero we were signalled by mount and we do not
1341 * call mountctl() to blow away existing exports.
1344 get_exportlist(int incremental
)
1346 struct exportlist
*ep
, *ep2
;
1347 struct grouplist
*grp
, *tgrp
;
1348 struct statfs
*fsp
, *mntbufp
;
1354 * First, get rid of the old list
1373 * And delete exports that are in the kernel for all local
1375 * XXX: Should know how to handle all local exportable filesystems.
1377 num
= getmntinfo(&mntbufp
, MNT_NOWAIT
);
1378 for (i
= 0; i
< num
; i
++) {
1380 if (getvfsbyname(fsp
->f_fstypename
, &vfc
) != 0) {
1381 syslog(LOG_ERR
, "getvfsbyname() failed for %s",
1387 * Do not delete export for network filesystem by
1388 * passing "export" arg to mount().
1389 * It only makes sense to do this for local filesystems.
1391 if (vfc
.vfc_flags
& VFCF_NETWORK
)
1394 if (incremental
== 0)
1399 * Read in the exports file and build the list, calling
1400 * nmount() as we go along to push the export rules into the kernel.
1403 for (i
= 0; exnames
[i
] != NULL
; i
++) {
1405 warnx("reading exports from %s", exnames
[i
]);
1406 if ((exp_file
= fopen(exnames
[i
], "r")) == NULL
) {
1407 syslog(LOG_WARNING
, "can't open %s", exnames
[i
]);
1410 get_exportlist_one();
1415 syslog(LOG_ERR
, "can't open any exports file");
1421 * Allocate an export list element
1426 struct exportlist
*ep
;
1428 ep
= (struct exportlist
*)malloc(sizeof (struct exportlist
));
1431 memset(ep
, 0, sizeof(struct exportlist
));
1436 * Allocate a group list element
1441 struct grouplist
*gp
;
1443 gp
= (struct grouplist
*)malloc(sizeof (struct grouplist
));
1446 memset(gp
, 0, sizeof(struct grouplist
));
1451 * Clean up upon an error in get_exportlist().
1454 getexp_err(struct exportlist
*ep
, struct grouplist
*grp
)
1456 struct grouplist
*tgrp
;
1458 if (!(opt_flags
& OP_QUIET
))
1459 syslog(LOG_ERR
, "bad exports list line %s", line
);
1460 if (ep
&& (ep
->ex_flag
& EX_LINKED
) == 0)
1470 * Search the export list for a matching fs.
1473 ex_search(fsid_t
*fsid
)
1475 struct exportlist
*ep
;
1479 if (ep
->ex_fs
.val
[0] == fsid
->val
[0] &&
1480 ep
->ex_fs
.val
[1] == fsid
->val
[1])
1488 * Add a directory path to the list.
1491 add_expdir(struct dirlist
**dpp
, char *cp
, int len
)
1495 dp
= malloc(sizeof (struct dirlist
));
1496 if (dp
== (struct dirlist
*)NULL
)
1499 dp
->dp_right
= (struct dirlist
*)NULL
;
1501 dp
->dp_hosts
= (struct hostlist
*)NULL
;
1502 dp
->dp_dirp
= strndup(cp
, len
);
1503 if (dp
->dp_dirp
== NULL
)
1506 return (dp
->dp_dirp
);
1510 * Hang the dir list element off the dirpath binary tree as required
1511 * and update the entry for host.
1514 hang_dirp(struct dirlist
*dp
, struct grouplist
*grp
, struct exportlist
*ep
,
1517 struct hostlist
*hp
;
1518 struct dirlist
*dp2
;
1520 if (flags
& OP_ALLDIRS
) {
1526 ep
->ex_defdir
->dp_flag
|= DP_DEFSET
;
1527 } else while (grp
) {
1530 hp
->ht_next
= ep
->ex_defdir
->dp_hosts
;
1531 ep
->ex_defdir
->dp_hosts
= hp
;
1537 * Loop through the directories adding them to the tree.
1541 add_dlist(&ep
->ex_dirl
, dp
, grp
, flags
);
1548 * Traverse the binary tree either updating a node that is already there
1549 * for the new directory or adding the new node.
1552 add_dlist(struct dirlist
**dpp
, struct dirlist
*newdp
, struct grouplist
*grp
,
1556 struct hostlist
*hp
;
1561 cmp
= strcmp(dp
->dp_dirp
, newdp
->dp_dirp
);
1563 add_dlist(&dp
->dp_left
, newdp
, grp
, flags
);
1565 } else if (cmp
< 0) {
1566 add_dlist(&dp
->dp_right
, newdp
, grp
, flags
);
1569 free((caddr_t
)newdp
);
1578 * Hang all of the host(s) off of the directory point.
1583 hp
->ht_next
= dp
->dp_hosts
;
1588 dp
->dp_flag
|= DP_DEFSET
;
1593 * Search for a dirpath on the export point.
1596 dirp_search(struct dirlist
*dp
, char *dirp
)
1601 cmp
= strcmp(dp
->dp_dirp
, dirp
);
1603 return (dirp_search(dp
->dp_left
, dirp
));
1605 return (dirp_search(dp
->dp_right
, dirp
));
1613 * Scan for a host match in a directory tree.
1616 chk_host(struct dirlist
*dp
, struct sockaddr
*saddr
, int *defsetp
,
1619 struct hostlist
*hp
;
1620 struct grouplist
*grp
;
1621 struct addrinfo
*ai
;
1624 if (dp
->dp_flag
& DP_DEFSET
)
1625 *defsetp
= dp
->dp_flag
;
1629 switch (grp
->gr_type
) {
1631 ai
= grp
->gr_ptr
.gt_addrinfo
;
1632 for (; ai
; ai
= ai
->ai_next
) {
1633 if (!sacmp(ai
->ai_addr
, saddr
, NULL
)) {
1635 (hp
->ht_flag
| DP_HOSTSET
);
1641 if (!sacmp(saddr
, (struct sockaddr
*)
1642 &grp
->gr_ptr
.gt_net
.nt_net
,
1644 &grp
->gr_ptr
.gt_net
.nt_mask
)) {
1645 *hostsetp
= (hp
->ht_flag
| DP_HOSTSET
);
1657 * Scan tree for a host that matches the address.
1660 scan_tree(struct dirlist
*dp
, struct sockaddr
*saddr
)
1662 int defset
, hostset
;
1665 if (scan_tree(dp
->dp_left
, saddr
))
1667 if (chk_host(dp
, saddr
, &defset
, &hostset
))
1669 if (scan_tree(dp
->dp_right
, saddr
))
1676 * Traverse the dirlist tree and free it up.
1679 free_dir(struct dirlist
*dp
)
1683 free_dir(dp
->dp_left
);
1684 free_dir(dp
->dp_right
);
1685 free_host(dp
->dp_hosts
);
1692 * Parse the option string and update fields.
1693 * Option arguments may either be -<option>=<value> or
1697 do_opt(char **cpp
, char **endcpp
, struct exportlist
*ep
, struct grouplist
*grp
,
1698 int *has_hostp
, int *exflagsp
, struct ucred
*cr
)
1700 char *cpoptarg
, *cpoptend
;
1701 char *cp
, *endcp
, *cpopt
, savedc
, savedc2
;
1702 int allflag
, usedarg
;
1710 while (cpopt
&& *cpopt
) {
1713 if ((cpoptend
= strchr(cpopt
, ','))) {
1715 if ((cpoptarg
= strchr(cpopt
, '=')))
1718 if ((cpoptarg
= strchr(cpopt
, '=')))
1722 nextfield(&cp
, &endcp
);
1724 if (endcp
> cp
&& *cp
!= '-') {
1732 if (!strcmp(cpopt
, "ro") || !strcmp(cpopt
, "o")) {
1733 *exflagsp
|= MNT_EXRDONLY
;
1734 } else if (cpoptarg
&& (!strcmp(cpopt
, "maproot") ||
1735 !(allflag
= strcmp(cpopt
, "mapall")) ||
1736 !strcmp(cpopt
, "root") || !strcmp(cpopt
, "r"))) {
1738 parsecred(cpoptarg
, cr
);
1740 *exflagsp
|= MNT_EXPORTANON
;
1741 opt_flags
|= OP_MAPALL
;
1743 opt_flags
|= OP_MAPROOT
;
1744 } else if (cpoptarg
&& (!strcmp(cpopt
, "mask") ||
1745 !strcmp(cpopt
, "m"))) {
1746 if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 1)) {
1747 syslog(LOG_ERR
, "bad mask: %s", cpoptarg
);
1751 opt_flags
|= OP_MASK
;
1752 } else if (cpoptarg
&& (!strcmp(cpopt
, "network") ||
1753 !strcmp(cpopt
, "n"))) {
1754 if (strchr(cpoptarg
, '/') != NULL
) {
1756 fprintf(stderr
, "setting OP_MASKLEN\n");
1757 opt_flags
|= OP_MASKLEN
;
1759 if (grp
->gr_type
!= GT_NULL
) {
1760 syslog(LOG_ERR
, "network/host conflict");
1762 } else if (get_net(cpoptarg
, &grp
->gr_ptr
.gt_net
, 0)) {
1763 syslog(LOG_ERR
, "bad net: %s", cpoptarg
);
1766 grp
->gr_type
= GT_NET
;
1769 opt_flags
|= OP_NET
;
1770 } else if (!strcmp(cpopt
, "alldirs")) {
1771 opt_flags
|= OP_ALLDIRS
;
1772 } else if (!strcmp(cpopt
, "public")) {
1773 *exflagsp
|= MNT_EXPUBLIC
;
1774 } else if (!strcmp(cpopt
, "webnfs")) {
1775 *exflagsp
|= (MNT_EXPUBLIC
|MNT_EXRDONLY
|MNT_EXPORTANON
);
1776 opt_flags
|= OP_MAPALL
;
1777 } else if (cpoptarg
&& !strcmp(cpopt
, "index")) {
1778 ep
->ex_indexfile
= strdup(cpoptarg
);
1779 } else if (!strcmp(cpopt
, "quiet")) {
1780 opt_flags
|= OP_QUIET
;
1782 syslog(LOG_ERR
, "bad opt %s", cpopt
);
1801 * Translate a character string to the corresponding list of network
1802 * addresses for a hostname.
1805 get_host(char *cp
, struct grouplist
*grp
, struct grouplist
*tgrp
)
1807 struct grouplist
*checkgrp
;
1808 struct addrinfo
*ai
, *tai
, hints
;
1810 char host
[NI_MAXHOST
];
1812 if (grp
->gr_type
!= GT_NULL
) {
1813 syslog(LOG_ERR
, "Bad netgroup type for ip host %s", cp
);
1816 memset(&hints
, 0, sizeof hints
);
1817 hints
.ai_flags
= AI_CANONNAME
;
1818 hints
.ai_protocol
= IPPROTO_UDP
;
1819 ecode
= getaddrinfo(cp
, NULL
, &hints
, &ai
);
1821 syslog(LOG_ERR
,"can't get address info for host %s", cp
);
1824 grp
->gr_ptr
.gt_addrinfo
= ai
;
1825 while (ai
!= NULL
) {
1826 if (ai
->ai_canonname
== NULL
) {
1827 if (getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, host
,
1828 sizeof host
, NULL
, 0, NI_NUMERICHOST
) != 0)
1829 strlcpy(host
, "?", sizeof(host
));
1830 ai
->ai_canonname
= strdup(host
);
1831 ai
->ai_flags
|= AI_CANONNAME
;
1834 fprintf(stderr
, "got host %s\n", ai
->ai_canonname
);
1836 * Sanity check: make sure we don't already have an entry
1837 * for this host in the grouplist.
1839 for (checkgrp
= tgrp
; checkgrp
!= NULL
;
1840 checkgrp
= checkgrp
->gr_next
) {
1841 if (checkgrp
->gr_type
!= GT_HOST
)
1843 for (tai
= checkgrp
->gr_ptr
.gt_addrinfo
; tai
!= NULL
;
1844 tai
= tai
->ai_next
) {
1845 if (sacmp(tai
->ai_addr
, ai
->ai_addr
, NULL
) != 0)
1849 "ignoring duplicate host %s\n",
1851 grp
->gr_type
= GT_IGNORE
;
1857 grp
->gr_type
= GT_HOST
;
1862 * Free up an exports list component
1865 free_exp(struct exportlist
*ep
)
1868 if (ep
->ex_defdir
) {
1869 free_host(ep
->ex_defdir
->dp_hosts
);
1870 free((caddr_t
)ep
->ex_defdir
);
1874 if (ep
->ex_indexfile
)
1875 free(ep
->ex_indexfile
);
1876 free_dir(ep
->ex_dirl
);
1884 free_host(struct hostlist
*hp
)
1886 struct hostlist
*hp2
;
1898 struct hostlist
*hp
;
1900 hp
= (struct hostlist
*)malloc(sizeof (struct hostlist
));
1909 * Out of memory, fatal
1915 syslog(LOG_ERR
, "out of memory");
1920 * Do the mount syscall with the update flag to push the export info into
1924 do_mount(struct exportlist
*ep
, struct grouplist
*grp
, int exflags
,
1925 struct ucred
*anoncrp
, char *dirp
, int dirplen
, struct statfs
*fsb
)
1928 struct addrinfo
*ai
;
1929 struct export_args
*eap
;
1937 struct msdosfs_args da
;
1938 struct ntfs_args na
;
1941 bzero(&args
, sizeof args
);
1942 /* XXX, we assume that all xx_args look like ufs_args. */
1944 eap
= &args
.ua
.export
;
1946 eap
->ex_flags
= exflags
;
1947 eap
->ex_anon
= *anoncrp
;
1948 eap
->ex_indexfile
= ep
->ex_indexfile
;
1949 if (grp
->gr_type
== GT_HOST
)
1950 ai
= grp
->gr_ptr
.gt_addrinfo
;
1955 switch (grp
->gr_type
) {
1957 if (ai
->ai_addr
->sa_family
== AF_INET6
&& have_v6
== 0)
1959 eap
->ex_addr
= ai
->ai_addr
;
1960 eap
->ex_addrlen
= ai
->ai_addrlen
;
1961 eap
->ex_masklen
= 0;
1964 if (grp
->gr_ptr
.gt_net
.nt_net
.ss_family
== AF_INET6
&&
1968 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_net
;
1969 eap
->ex_addrlen
= args
.ua
.export
.ex_addr
->sa_len
;
1971 (struct sockaddr
*)&grp
->gr_ptr
.gt_net
.nt_mask
;
1972 eap
->ex_masklen
= args
.ua
.export
.ex_mask
->sa_len
;
1975 eap
->ex_addr
= NULL
;
1976 eap
->ex_addrlen
= 0;
1977 eap
->ex_mask
= NULL
;
1978 eap
->ex_masklen
= 0;
1984 syslog(LOG_ERR
, "bad grouptype");
1992 * Maybe I should just use the fsb->f_mntonname path instead
1993 * of looping back up the dirp to the mount point??
1994 * Also, needs to know how to export all types of local
1995 * exportable filesystems and not just "ufs".
2000 r
= mountctl(fsb
->f_mntonname
, MOUNTCTL_SET_EXPORT
,
2002 &args
.ua
.export
, sizeof(args
.ua
.export
),
2004 if (r
< 0 && errno
== EOPNOTSUPP
) {
2005 r
= mount(fsb
->f_fstypename
, dirp
,
2006 fsb
->f_flags
| MNT_UPDATE
,
2014 cp
= dirp
+ dirplen
- 1;
2015 if (opt_flags
& OP_QUIET
)
2017 if (errno
== EPERM
) {
2019 warnx("can't change attributes for %s",
2022 "can't change attributes for %s", dirp
);
2025 if (opt_flags
& OP_ALLDIRS
) {
2026 if (errno
== EINVAL
)
2028 "-alldirs requested but %s is not a filesystem mountpoint",
2032 "could not remount %s: %m",
2036 /* back up over the last component */
2037 while (*cp
== '/' && cp
> dirp
)
2039 while (*(cp
- 1) != '/' && cp
> dirp
)
2043 warnx("mnt unsucc");
2044 syslog(LOG_ERR
, "can't export %s", dirp
);
2049 /* Check that we're still on the same filesystem. */
2050 if (statfs(dirp
, &fsb1
) != 0 || bcmp(&fsb1
.f_fsid
,
2051 &fsb
->f_fsid
, sizeof(fsb1
.f_fsid
)) != 0) {
2053 syslog(LOG_ERR
, "can't export %s", dirp
);
2069 * Translate a net address.
2071 * If `maskflg' is nonzero, then `cp' is a netmask, not a network address.
2074 get_net(char *cp
, struct netmsk
*net
, int maskflg
)
2076 struct netent
*np
= NULL
;
2077 char *name
, *p
, *prefp
;
2078 struct sockaddr_in sin
;
2079 struct sockaddr
*sa
= NULL
;
2080 struct addrinfo hints
, *ai
= NULL
;
2081 char netname
[NI_MAXHOST
];
2085 if ((opt_flags
& OP_MASKLEN
) && !maskflg
) {
2086 p
= strchr(cp
, '/');
2092 * Check for a numeric address first. We wish to avoid
2093 * possible DNS lookups in getnetbyname().
2095 if (isxdigit(*cp
) || *cp
== ':') {
2096 memset(&hints
, 0, sizeof hints
);
2097 /* Ensure the mask and the network have the same family. */
2098 if (maskflg
&& (opt_flags
& OP_NET
))
2099 hints
.ai_family
= net
->nt_net
.ss_family
;
2100 else if (!maskflg
&& (opt_flags
& OP_HAVEMASK
))
2101 hints
.ai_family
= net
->nt_mask
.ss_family
;
2103 hints
.ai_family
= AF_UNSPEC
;
2104 hints
.ai_flags
= AI_NUMERICHOST
;
2105 if (getaddrinfo(cp
, NULL
, &hints
, &ai
) == 0)
2107 if (sa
!= NULL
&& ai
->ai_family
== AF_INET
) {
2109 * The address in `cp' is really a network address, so
2110 * use inet_network() to re-interpret this correctly.
2111 * e.g. "127.1" means 127.1.0.0, not 127.0.0.1.
2113 bzero(&sin
, sizeof sin
);
2114 sin
.sin_family
= AF_INET
;
2115 sin
.sin_len
= sizeof sin
;
2116 sin
.sin_addr
= inet_makeaddr(inet_network(cp
), 0);
2118 fprintf(stderr
, "get_net: v4 addr %s\n",
2119 inet_ntoa(sin
.sin_addr
));
2120 sa
= (struct sockaddr
*)&sin
;
2123 if (sa
== NULL
&& (np
= getnetbyname(cp
)) != NULL
) {
2124 bzero(&sin
, sizeof sin
);
2125 sin
.sin_family
= AF_INET
;
2126 sin
.sin_len
= sizeof sin
;
2127 sin
.sin_addr
= inet_makeaddr(np
->n_net
, 0);
2128 sa
= (struct sockaddr
*)&sin
;
2134 /* The specified sockaddr is a mask. */
2135 if (checkmask(sa
) != 0)
2137 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2138 opt_flags
|= OP_HAVEMASK
;
2140 /* The specified sockaddr is a network address. */
2141 bcopy(sa
, &net
->nt_net
, sa
->sa_len
);
2143 /* Get a network name for the export list. */
2146 } else if (getnameinfo(sa
, sa
->sa_len
, netname
, sizeof netname
,
2147 NULL
, 0, NI_NUMERICHOST
) == 0) {
2152 if ((net
->nt_name
= strdup(name
)) == NULL
)
2156 * Extract a mask from either a "/<masklen>" suffix, or
2157 * from the class of an IPv4 address.
2159 if (opt_flags
& OP_MASKLEN
) {
2160 preflen
= strtol(prefp
, NULL
, 10);
2161 if (preflen
< 0L || preflen
== LONG_MAX
)
2163 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2164 if (makemask(&net
->nt_mask
, (int)preflen
) != 0)
2166 opt_flags
|= OP_HAVEMASK
;
2168 } else if (sa
->sa_family
== AF_INET
&&
2169 (opt_flags
& OP_MASK
) == 0) {
2172 addr
= ((struct sockaddr_in
*)sa
)->sin_addr
.s_addr
;
2173 if (IN_CLASSA(addr
))
2175 else if (IN_CLASSB(addr
))
2177 else if (IN_CLASSC(addr
))
2179 else if (IN_CLASSD(addr
))
2182 preflen
= 32; /* XXX */
2184 bcopy(sa
, &net
->nt_mask
, sa
->sa_len
);
2185 makemask(&net
->nt_mask
, (int)preflen
);
2186 opt_flags
|= OP_HAVEMASK
;
2201 * Parse out the next white space separated field
2204 nextfield(char **cp
, char **endcp
)
2209 while (*p
== ' ' || *p
== '\t')
2211 if (*p
== '\n' || *p
== '\0')
2215 while (*p
!= ' ' && *p
!= '\t' && *p
!= '\n' && *p
!= '\0')
2222 * Get an exports file line. Skip over blank lines and handle line
2230 int totlen
, cont_line
;
2233 * Loop around ignoring blank lines and getting all continuation lines.
2238 if ((p
= fgetln(exp_file
, &len
)) == NULL
)
2243 (*cp
== ' ' || *cp
== '\t' || *cp
== '\n' || *cp
== '\\')) {
2253 if (linesize
< len
+ totlen
+ 1) {
2254 linesize
= len
+ totlen
+ 1;
2255 line
= realloc(line
, linesize
);
2259 memcpy(line
+ totlen
, p
, len
);
2261 line
[totlen
] = '\0';
2262 } while (totlen
== 0 || cont_line
);
2267 * Parse a description of a credential.
2270 parsecred(char *namelist
, struct ucred
*cr
)
2277 gid_t groups
[NGROUPS
+ 1];
2281 * Set up the unprivileged user.
2285 cr
->cr_groups
[0] = 65533;
2288 * Get the user's password table entry.
2290 names
= strsep(&namelist
, " \t\n");
2291 name
= strsep(&names
, ":");
2292 if (isdigit(*name
) || *name
== '-')
2293 pw
= getpwuid(atoi(name
));
2295 pw
= getpwnam(name
);
2297 * Credentials specified as those of a user.
2299 if (names
== NULL
) {
2301 syslog(LOG_ERR
, "unknown user: %s", name
);
2304 cr
->cr_uid
= pw
->pw_uid
;
2305 ngroups
= NGROUPS
+ 1;
2306 if (getgrouplist(pw
->pw_name
, pw
->pw_gid
, groups
, &ngroups
))
2307 syslog(LOG_ERR
, "too many groups");
2309 * Compress out duplicate
2311 cr
->cr_ngroups
= ngroups
- 1;
2312 cr
->cr_groups
[0] = groups
[0];
2313 for (cnt
= 2; cnt
< ngroups
; cnt
++)
2314 cr
->cr_groups
[cnt
- 1] = groups
[cnt
];
2318 * Explicit credential specified as a colon separated list:
2322 cr
->cr_uid
= pw
->pw_uid
;
2323 else if (isdigit(*name
) || *name
== '-')
2324 cr
->cr_uid
= atoi(name
);
2326 syslog(LOG_ERR
, "unknown user: %s", name
);
2330 while (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
< NGROUPS
) {
2331 name
= strsep(&names
, ":");
2332 if (isdigit(*name
) || *name
== '-') {
2333 cr
->cr_groups
[cr
->cr_ngroups
++] = atoi(name
);
2335 if ((gr
= getgrnam(name
)) == NULL
) {
2336 syslog(LOG_ERR
, "unknown group: %s", name
);
2339 cr
->cr_groups
[cr
->cr_ngroups
++] = gr
->gr_gid
;
2342 if (names
!= NULL
&& *names
!= '\0' && cr
->cr_ngroups
== NGROUPS
)
2343 syslog(LOG_ERR
, "too many groups");
2346 #define STRSIZ (RPCMNT_NAMELEN+RPCMNT_PATHLEN+50)
2348 * Routines that maintain the remote mounttab
2353 struct mountlist
*mlp
, **mlpp
;
2354 char *host
, *dirp
, *cp
;
2358 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "r")) == NULL
) {
2359 if (errno
== ENOENT
)
2362 syslog(LOG_ERR
, "can't open %s", _PATH_RMOUNTLIST
);
2367 while (fgets(str
, STRSIZ
, mlfile
) != NULL
) {
2369 host
= strsep(&cp
, " \t\n");
2370 dirp
= strsep(&cp
, " \t\n");
2371 if (host
== NULL
|| dirp
== NULL
)
2373 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2376 strncpy(mlp
->ml_host
, host
, RPCMNT_NAMELEN
);
2377 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2378 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2379 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2380 mlp
->ml_next
= NULL
;
2382 mlpp
= &mlp
->ml_next
;
2389 delete_export(struct statfs
*fsp
)
2395 struct msdosfs_args da
;
2396 struct ntfs_args na
;
2398 struct export_args export
;
2400 export
.ex_flags
= MNT_DELEXPORT
;
2401 if (mountctl(fsp
->f_mntonname
, MOUNTCTL_SET_EXPORT
, -1,
2402 &export
, sizeof(export
), NULL
, 0) == 0) {
2404 } else if (!strcmp(fsp
->f_fstypename
, "mfs") ||
2405 !strcmp(fsp
->f_fstypename
, "ufs") ||
2406 !strcmp(fsp
->f_fstypename
, "msdos") ||
2407 !strcmp(fsp
->f_fstypename
, "ntfs") ||
2408 !strcmp(fsp
->f_fstypename
, "cd9660")) {
2409 bzero(&targs
, sizeof targs
);
2410 targs
.ua
.fspec
= NULL
;
2411 targs
.ua
.export
.ex_flags
= MNT_DELEXPORT
;
2412 if (mount(fsp
->f_fstypename
, fsp
->f_mntonname
,
2413 fsp
->f_flags
| MNT_UPDATE
,
2414 (caddr_t
)&targs
) < 0)
2415 syslog(LOG_ERR
, "can't delete exports for %s",
2422 del_mlist(char *hostp
, char *dirp
)
2424 struct mountlist
*mlp
, **mlpp
;
2425 struct mountlist
*mlp2
;
2432 if (!strcmp(mlp
->ml_host
, hostp
) &&
2433 (!dirp
|| !strcmp(mlp
->ml_dirp
, dirp
))) {
2436 *mlpp
= mlp
= mlp
->ml_next
;
2437 free((caddr_t
)mlp2
);
2439 mlpp
= &mlp
->ml_next
;
2444 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "w")) == NULL
) {
2445 syslog(LOG_ERR
,"can't update %s", _PATH_RMOUNTLIST
);
2450 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2458 add_mlist(char *hostp
, char *dirp
)
2460 struct mountlist
*mlp
, **mlpp
;
2466 if (!strcmp(mlp
->ml_host
, hostp
) && !strcmp(mlp
->ml_dirp
, dirp
))
2468 mlpp
= &mlp
->ml_next
;
2471 mlp
= (struct mountlist
*)malloc(sizeof (*mlp
));
2474 strncpy(mlp
->ml_host
, hostp
, RPCMNT_NAMELEN
);
2475 mlp
->ml_host
[RPCMNT_NAMELEN
] = '\0';
2476 strncpy(mlp
->ml_dirp
, dirp
, RPCMNT_PATHLEN
);
2477 mlp
->ml_dirp
[RPCMNT_PATHLEN
] = '\0';
2478 mlp
->ml_next
= NULL
;
2480 if ((mlfile
= fopen(_PATH_RMOUNTLIST
, "a")) == NULL
) {
2481 syslog(LOG_ERR
, "can't update %s", _PATH_RMOUNTLIST
);
2484 fprintf(mlfile
, "%s %s\n", mlp
->ml_host
, mlp
->ml_dirp
);
2489 * Free up a group list.
2492 free_grp(struct grouplist
*grp
)
2494 if (grp
->gr_type
== GT_HOST
) {
2495 if (grp
->gr_ptr
.gt_addrinfo
!= NULL
)
2496 freeaddrinfo(grp
->gr_ptr
.gt_addrinfo
);
2497 } else if (grp
->gr_type
== GT_NET
) {
2498 if (grp
->gr_ptr
.gt_net
.nt_name
)
2499 free(grp
->gr_ptr
.gt_net
.nt_name
);
2506 SYSLOG(int pri
, const char *fmt
, ...)
2511 vfprintf(stderr
, fmt
, ap
);
2517 * Check options for consistency.
2520 check_options(struct dirlist
*dp
)
2525 if ((opt_flags
& (OP_MAPROOT
| OP_MAPALL
)) == (OP_MAPROOT
| OP_MAPALL
)) {
2526 syslog(LOG_ERR
, "-mapall and -maproot mutually exclusive");
2529 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_NET
) == 0) {
2530 syslog(LOG_ERR
, "-mask requires -network");
2533 if ((opt_flags
& OP_NET
) && (opt_flags
& OP_HAVEMASK
) == 0) {
2534 syslog(LOG_ERR
, "-network requires mask specification");
2537 if ((opt_flags
& OP_MASK
) && (opt_flags
& OP_MASKLEN
)) {
2538 syslog(LOG_ERR
, "-mask and /masklen are mutually exclusive");
2541 if ((opt_flags
& OP_ALLDIRS
) && dp
->dp_left
) {
2542 syslog(LOG_ERR
, "-alldirs has multiple directories");
2549 * Check an absolute directory path for any symbolic links. Return true
2552 check_dirpath(char *dirp
)
2559 while (*cp
&& ret
) {
2562 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2568 if (lstat(dirp
, &sb
) < 0 || !S_ISDIR(sb
.st_mode
))
2574 * Make a netmask according to the specified prefix length. The ss_family
2575 * and other non-address fields must be initialised before calling this.
2578 makemask(struct sockaddr_storage
*ssp
, int bitlen
)
2583 if ((p
= sa_rawaddr((struct sockaddr
*)ssp
, &len
)) == NULL
)
2585 if (bitlen
> len
* CHAR_BIT
)
2587 for (i
= 0; i
< len
; i
++) {
2588 bits
= (bitlen
> CHAR_BIT
) ? CHAR_BIT
: bitlen
;
2589 *p
++ = (u_char
)~0 << (CHAR_BIT
- bits
);
2596 * Check that the sockaddr is a valid netmask. Returns 0 if the mask
2597 * is acceptable (i.e. of the form 1...10....0).
2600 checkmask(struct sockaddr
*sa
)
2605 if ((mask
= sa_rawaddr(sa
, &len
)) == NULL
)
2608 for (i
= 0; i
< len
; i
++)
2609 if (mask
[i
] != 0xff)
2612 if (~mask
[i
] & (u_char
)(~mask
[i
] + 1))
2616 for (; i
< len
; i
++)
2623 * Compare two sockaddrs according to a specified mask. Return zero if
2624 * `sa1' matches `sa2' when filtered by the netmask in `samask'.
2625 * If samask is NULL, perform a full comparision.
2628 sacmp(struct sockaddr
*sa1
, struct sockaddr
*sa2
, struct sockaddr
*samask
)
2630 unsigned char *p1
, *p2
, *mask
;
2633 if (sa1
->sa_family
!= sa2
->sa_family
||
2634 (p1
= sa_rawaddr(sa1
, &len
)) == NULL
||
2635 (p2
= sa_rawaddr(sa2
, NULL
)) == NULL
)
2638 switch (sa1
->sa_family
) {
2640 if (((struct sockaddr_in6
*)sa1
)->sin6_scope_id
!=
2641 ((struct sockaddr_in6
*)sa2
)->sin6_scope_id
)
2646 /* Simple binary comparison if no mask specified. */
2648 return (memcmp(p1
, p2
, len
));
2650 /* Set up the mask, and do a mask-based comparison. */
2651 if (sa1
->sa_family
!= samask
->sa_family
||
2652 (mask
= sa_rawaddr(samask
, NULL
)) == NULL
)
2655 for (i
= 0; i
< len
; i
++)
2656 if ((p1
[i
] & mask
[i
]) != (p2
[i
] & mask
[i
]))
2662 * Return a pointer to the part of the sockaddr that contains the
2663 * raw address, and set *nbytes to its length in bytes. Returns
2664 * NULL if the address family is unknown.
2667 sa_rawaddr(struct sockaddr
*sa
, int *nbytes
) {
2671 switch (sa
->sa_family
) {
2673 len
= sizeof(((struct sockaddr_in
*)sa
)->sin_addr
);
2674 p
= &((struct sockaddr_in
*)sa
)->sin_addr
;
2677 len
= sizeof(((struct sockaddr_in6
*)sa
)->sin6_addr
);
2678 p
= &((struct sockaddr_in6
*)sa
)->sin6_addr
;
2691 huphandler1(int sig __unused
)
2697 huphandler2(int sig __unused
)
2702 void terminate(int sig __unused
)
2704 pidfile_remove(pfh
);
2705 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER1
, NULL
);
2706 rpcb_unset(RPCPROG_MNT
, RPCMNT_VER3
, NULL
);