diff options
| -rw-r--r-- | sbin/idmapd/Makefile | 14 | ||||
| -rw-r--r-- | sbin/idmapd/idmapd.8 | 2 | ||||
| -rw-r--r-- | sbin/idmapd/idmapd.c | 431 | ||||
| -rw-r--r-- | sbin/mount_nfs4/Makefile | 16 | ||||
| -rw-r--r-- | sbin/mount_nfs4/mount_nfs4.8 | 351 | ||||
| -rw-r--r-- | sbin/mount_nfs4/mount_nfs4.c | 873 |
6 files changed, 1687 insertions, 0 deletions
diff --git a/sbin/idmapd/Makefile b/sbin/idmapd/Makefile new file mode 100644 index 0000000..6592157 --- /dev/null +++ b/sbin/idmapd/Makefile @@ -0,0 +1,14 @@ +# @(#)Makefile 8.2 (Berkeley) 3/27/94 +# +# $FreeBSD$ + +PROG= idmapd +SRCS= idmapd.c +MAN= idmapd.8 + +CFLAGS+= -DNFS -I/usr/src/sys +WARNS= 2 + +.PATH: + +.include <bsd.prog.mk> diff --git a/sbin/idmapd/idmapd.8 b/sbin/idmapd/idmapd.8 new file mode 100644 index 0000000..26c2c28 --- /dev/null +++ b/sbin/idmapd/idmapd.8 @@ -0,0 +1,2 @@ +.\" $FreeBSD$ +man diff --git a/sbin/idmapd/idmapd.c b/sbin/idmapd/idmapd.c new file mode 100644 index 0000000..0cccde8 --- /dev/null +++ b/sbin/idmapd/idmapd.c @@ -0,0 +1,431 @@ +/* $FreeBSD$ */ +/* $Id: idmapd.c,v 1.5 2003/11/05 14:58:58 rees Exp $ */ + +/* + * copyright (c) 2003 + * the regents of the university of michigan + * all rights reserved + * + * permission is granted to use, copy, create derivative works and redistribute + * this software and such derivative works for any purpose, so long as the name + * of the university of michigan is not used in any advertising or publicity + * pertaining to the use or distribution of this software without specific, + * written prior authorization. if the above copyright notice or any other + * identification of the university of michigan is included in any copy of any + * portion of this software, then the disclaimer below must also be included. + * + * this software is provided as is, without representation from the university + * of michigan as to its fitness for any purpose, and without warranty by the + * university of michigan of any kind, either express or implied, including + * without limitation the implied warranties of merchantability and fitness for + * a particular purpose. the regents of the university of michigan shall not be + * liable for any damages, including special, indirect, incidental, or + * consequential damages, with respect to any claim arising out of or in + * connection with the use of the software, even if it has been or is hereafter + * advised of the possibility of such damages. + */ + +/* XXX ignores the domain of recieved names. */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/syscall.h> +#include <sys/errno.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/queue.h> + +#include <stdio.h> +#include <fcntl.h> +#include <assert.h> +#include <string.h> +#include <stdlib.h> +#include <unistd.h> +#include <pwd.h> +#include <grp.h> + +#include <nfs4client/nfs4_dev.h> +#include <nfs4client/nfs4_idmap.h> + +/* #include "idmap.h" */ + +#define DEV_PATH "/dev/nfs4" + +#define DOMAIN "@citi.umich.edu" +#define BADUSER "nobody" +#define BADGROUP "nogroup" +#define BADUID (-2) +#define BADGID (-2) + +struct idmap_e { + struct nfs4dev_msg msg; + + TAILQ_ENTRY(idmap_e) next; +}; + +int fd, verbose; +char *domain = DOMAIN; + +TAILQ_HEAD(, idmap_e) upcall_q; + +#define add_idmap_e(E) do { \ + assert(E != NULL); \ + TAILQ_INSERT_TAIL(&upcall_q, E, next); \ +} while(0) + +#define remove_idmap_e(E) do { \ + assert(E != NULL && !TAILQ_EMPTY(&upcall_q)); \ + E = TAILQ_FIRST(&upcall_q); \ + TAILQ_REMOVE(&upcall_q, E, next); \ +} while(0) + +#define get_idmap_e(E) do { \ + if ((E = (struct idmap_e *) malloc(sizeof(struct idmap_e))) == NULL) {\ + fprintf(stderr, "get_idmap_e(): error in malloc\n");\ + } } while(0) + +#define put_idmap_e(E) free(E) + +/* from marius */ +int +validateascii(char *string, u_int32_t len) +{ + int i; + + for (i = 0; i < len; i++) { + if (string[i] == '\0') + break; + if (string[i] & 0x80) + return (-1); + } + + if (string[i] != '\0') + return (-1); + return (i + 1); +} + +char * +idmap_prune_domain(struct idmap_msg * m) +{ + size_t i; + size_t len; + char * ret = NULL; + + if (m == NULL) + return NULL; + + len = m->id_namelen; + + if (validateascii(m->id_name, len) < 0) { + fprintf(stderr, "msg has invalid ascii\n"); + return NULL; + } + + for (i=0; i < len && m->id_name[i] != '@' ; i++); + + ret = (char *)malloc(i+1); + if (ret == NULL) + return NULL; + + bcopy(m->id_name, ret, i); + ret[i] = '\0'; + + return ret; +} + +int +idmap_add_domain(struct idmap_msg * m, char * name) +{ + size_t len, nlen; + + if (m == NULL || name == NULL) + return -1; + + len = strlen(name); + + nlen = len + strlen(domain); + + if (nlen > IDMAP_MAXNAMELEN) + return -1; + + bcopy(name, &m->id_name[0], len); + bcopy(domain, &m->id_name[len], strlen(domain)); + + m->id_name[nlen] = '\0'; + m->id_namelen = nlen; + + return 0; +} + +int +idmap_name(struct idmap_msg * m, char *name) +{ + if (m == NULL || name == NULL || m->id_namelen != 0) + return -1; + + if (idmap_add_domain(m, name)) + return -1; + + return 0; +} + +int +idmap_id(struct idmap_msg * m, ident_t id) +{ + if (m == NULL || m->id_namelen == 0) { + fprintf(stderr, "idmap_id: bad msg\n"); + return -1; + } + + switch(m->id_type) { + case IDMAP_TYPE_UID: + m->id_id.uid = id.uid; + break; + case IDMAP_TYPE_GID: + m->id_id.gid = id.gid; + break; + default: + return -1; + break; + }; + + return 0; +} + +int +idmap_service(struct idmap_e * e) +{ + struct idmap_msg * m; + struct passwd * pwd; + struct group * grp; + ident_t id; + char * name; + + if (e == NULL) { + fprintf(stderr, "bad entry\n"); + return -1; + } + + if (e->msg.msg_vers != NFS4DEV_VERSION) { + fprintf(stderr, "kernel/userland version mismatch! %d/%d\n", + e->msg.msg_vers, NFS4DEV_VERSION); + return -1; + } + + if (e->msg.msg_type != NFS4DEV_TYPE_IDMAP) { + fprintf(stderr, "bad type!\n"); + return -1; + } + + if (e->msg.msg_len != sizeof(struct idmap_msg)) { + fprintf(stderr, "bad message length: %d/%d\n", e->msg.msg_len, + sizeof(struct idmap_msg)); + return -1; + } + + if (verbose) + printf("servicing msg xid: %x\n", e->msg.msg_xid); + + + m = (struct idmap_msg *)e->msg.msg_data; + + if (m->id_namelen != 0 && m->id_namelen != strlen(m->id_name)) { + fprintf(stderr, "bad name length in idmap_msg\n"); + return -1; + } + + switch (m->id_type) { + case IDMAP_TYPE_UID: + if (m->id_namelen == 0) { + /* id to name */ + pwd = getpwuid(m->id_id.uid); + + if (pwd == NULL) { + fprintf(stderr, "unknown uid %d!\n", + (uint32_t)m->id_id.uid); + name = BADUSER; + } else + name = pwd->pw_name; + + if (idmap_name(m, name)) + return -1; + + } else { + /* name to id */ + name = idmap_prune_domain(m); + if (name == NULL) + return -1; + + pwd = getpwnam(name); + + if (pwd == NULL) { + fprintf(stderr, "unknown username %s!\n", name); + + id.uid = (uid_t)BADUID; + } else + id.uid = pwd->pw_uid; + + free(name); + + if (idmap_id(m, id)) + return -1; + } + break; + case IDMAP_TYPE_GID: + if (m->id_namelen == 0) { + /* id to name */ + grp = getgrgid(m->id_id.gid); + + if (grp == NULL) { + fprintf(stderr, "unknown gid %d!\n", + (uint32_t)m->id_id.gid); + name = BADGROUP; + } else + name = grp->gr_name; + + if (idmap_name(m, name)) + return -1; + } else { + /* name to id */ + name = idmap_prune_domain(m); + if (name == NULL) + return -1; + + grp = getgrnam(name); + + if (grp == NULL) { + fprintf(stderr, "unknown groupname %s!\n", name); + + id.gid = (gid_t)BADGID; + } else + id.gid = grp->gr_gid; + + free(name); + + if (idmap_id(m, id)) + return -1; + } + break; + default: + fprintf(stderr, "bad idmap type: %d\n", m->id_type); + return -1; + break; + } + + return 0; +} + +int +main(int argc, char ** argv) +{ + int error = 0; + struct idmap_e * entry; + fd_set read_fds, write_fds; + int maxfd; + int ret, ch; + + while ((ch = getopt(argc, argv, "d:v")) != -1) { + switch (ch) { + case 'd': + domain = optarg; + break; + case 'v': + verbose = 1; + break; + default: + fprintf(stderr, "usage: %s [-v] [-d domain]\n", argv[0]); + exit(1); + break; + } + } + + + TAILQ_INIT(&upcall_q); + + if (error) { + perror("sigaction"); + exit(1); + } + + + fd = open(DEV_PATH, O_RDWR, S_IRUSR | S_IWUSR); + + if (fd < 0) { + perror(DEV_PATH); + exit(1); + } + + if (!verbose) + daemon(0,0); + + if (verbose) + printf("sizeof nfs4dev_msg: %d\n", sizeof(struct nfs4dev_msg)); + + maxfd = fd; + for (;;) { + struct timeval timo = {1, 0}; + do { + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + + FD_SET(fd, &read_fds); + FD_SET(fd, &write_fds); + + ret = select(maxfd+1, &read_fds, &write_fds, NULL, &timo); + } while (ret < 0 && errno == EINTR); + + if (ret <= 0) { + if (ret != 0) + perror("select"); + continue; + } + + + if (FD_ISSET(fd, &read_fds)) { + for (;;) { + get_idmap_e(entry); + + error = ioctl(fd, NFS4DEVIOCGET, &entry->msg); + + if (error == -1) { + if (errno != EAGAIN) + perror("get ioctl:"); + put_idmap_e(entry); + break; + } + + switch (entry->msg.msg_type ) { + case NFS4DEV_TYPE_IDMAP: + if (idmap_service(entry)) + entry->msg.msg_error = EIO; + break; + default: + fprintf(stderr, "unknown nfs4dev_msg type\n"); + entry->msg.msg_error = EIO; + break; + } + + add_idmap_e(entry); + } + } + + if (FD_ISSET(fd, &write_fds)) { + while (!TAILQ_EMPTY(&upcall_q)) { + remove_idmap_e(entry); + + error = ioctl(fd, NFS4DEVIOCPUT, &entry->msg); + + if (error == -1) { + if (errno != EAGAIN) + perror("put ioctl"); + break; + } + put_idmap_e(entry); + } + } + } + + /* never reached */ + exit(1); +} diff --git a/sbin/mount_nfs4/Makefile b/sbin/mount_nfs4/Makefile new file mode 100644 index 0000000..c418b72 --- /dev/null +++ b/sbin/mount_nfs4/Makefile @@ -0,0 +1,16 @@ +# ${.CURDIR}(#)Makefile 8.2 (Berkeley) 3/27/94 +# +# $FreeBSD$ + +PROG= mount_nfs4 +SRCS= mount_nfs4.c getmntopts.c mounttab.c +MAN= mount_nfs4.8 + +MOUNT= ${.CURDIR}/../mount +UMNTALL= ${.CURDIR}/../../usr.sbin/rpc.umntall +CFLAGS+= -DNFS -I${MOUNT} -I${UMNTALL} +WARNS= 2 + +.PATH: ${MOUNT} ${UMNTALL} + +.include <bsd.prog.mk> diff --git a/sbin/mount_nfs4/mount_nfs4.8 b/sbin/mount_nfs4/mount_nfs4.8 new file mode 100644 index 0000000..4d5577f --- /dev/null +++ b/sbin/mount_nfs4/mount_nfs4.8 @@ -0,0 +1,351 @@ +.\" Copyright (c) 1992, 1993, 1994, 1995 +.\" The Regents of the University of California. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. Neither the name of the University nor the names of its contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" @(#)mount_nfs.8 8.3 (Berkeley) 3/29/95 +.\" $FreeBSD$ +.\" +.Dd May 11, 2003 +.Dt MOUNT_NFS 8 +.Os +.Sh NAME +.Nm mount_nfs +.Nd mount NFS file systems +.Sh SYNOPSIS +.Nm +.Op Fl 23NPTUbcdiLls +.Op Fl D Ar deadthresh +.Op Fl I Ar readdirsize +.Op Fl R Ar retrycnt +.Op Fl a Ar maxreadahead +.Op Fl g Ar maxgroups +.Op Fl o Ar options +.Op Fl r Ar readsize +.Op Fl t Ar timeout +.Op Fl w Ar writesize +.Op Fl x Ar retrans +.Ar rhost : Ns Ar path node +.Sh DESCRIPTION +The +.Nm +utility calls the +.Xr mount 2 +system call to prepare and graft a remote NFS file system +.Pq Ar rhost : Ns Ar path +on to the file system tree at the point +.Ar node . +This command is normally executed by +.Xr mount 8 . +It implements the mount protocol as described in RFC 1094, Appendix A and +.%T "NFS: Network File System Version 3 Protocol Specification" , +Appendix I. +.Pp +By default, +.Nm +keeps retrying until the mount succeeds. +This behaviour is intended for file systems listed in +.Xr fstab 5 +that are critical to the boot process. +For non-critical file systems, the +.Fl b +and +.Fl R +flags provide mechanisms to prevent the boot process from hanging +if the server is unavailable. +.Pp +If the server becomes unresponsive while an NFS file system is +mounted, any new or outstanding file operations on that file system +will hang uninterruptibly until the server comes back. +To modify this default behaviour, see the +.Fl i +and +.Fl s +flags. +.Pp +The options are: +.Bl -tag -width indent +.It Fl 2 +Use the NFS Version 2 protocol (the default is to try version 3 first +then version 2). +Note that NFS version 2 has a file size limit of 2 gigabytes. +.It Fl 3 +Use the NFS Version 3 protocol. +.It Fl D +Set the +.Dq "dead server threshold" +to the specified number of round trip timeout intervals before a +.Dq "server not responding" +message is displayed. +.It Fl I +Set the readdir read size to the specified value. +The value should normally +be a multiple of +.Dv DIRBLKSIZ +that is <= the read size for the mount. +.It Fl L +Do +.Em not +forward +.Xr fcntl 2 +locks over the wire. +All locks will be local and not seen by the server +and likewise not seen by other NFS clients. +This removes the need to run the +.Xr rpcbind 8 +service and the +.Xr rpc.statd 8 +and +.Xr rpc.lockd 8 +servers on the client. +Note that this option will only be honored when performing the +initial mount, it will be silently ignored if used while updating +the mount options. +.It Fl N +Do +.Em not +use a reserved socket port number (see below). +.It Fl P +Use a reserved socket port number. +This flag is obsolete, and only retained for compatibility reasons. +Reserved port numbers are used by default now. +(For the rare case where the client has a trusted root account +but untrustworthy users and the network cables are in secure areas this does +help, but for normal desktop clients this does not apply.) +.It Fl R +Set the mount retry count to the specified value. +The default is a retry count of zero, which means to keep retrying +forever. +There is a 60 second delay between each attempt. +.It Fl T +Use TCP transport instead of UDP. +This is recommended for servers that are not on the same LAN cable as +the client. +(NB: This is NOT supported by most +.No non- Ns Bx +servers.) +.It Fl U +Force the mount protocol to use UDP transport, even for TCP NFS mounts. +(Necessary for some old +.Bx +servers.) +.It Fl a +Set the read-ahead count to the specified value. +This may be in the range of 0 - 4, and determines how many blocks +will be read ahead when a large file is being read sequentially. +Trying a value greater than 1 for this is suggested for +mounts with a large bandwidth * delay product. +.It Fl b +If an initial attempt to contact the server fails, fork off a child to keep +trying the mount in the background. +Useful for +.Xr fstab 5 , +where the file system mount is not critical to multiuser operation. +.It Fl c +For UDP mount points, do not do a +.Xr connect 2 . +This must be used if the server does not reply to requests from the standard +NFS port number 2049 or replies to requests using a different IP address +(which can occur if the server is multi-homed). +Setting the +.Va vfs.nfs.nfs_ip_paranoia +sysctl to 0 will make this option the default. +.It Fl d +Turn off the dynamic retransmit timeout estimator. +This may be useful for UDP mounts that exhibit high retry rates, +since it is possible that the dynamically estimated timeout interval is too +short. +.It Fl g +Set the maximum size of the group list for the credentials to the +specified value. +This should be used for mounts on old servers that cannot handle a +group list size of 16, as specified in RFC 1057. +Try 8, if users in a lot of groups cannot get response from the mount +point. +.It Fl i +Make the mount interruptible, which implies that file system calls that +are delayed due to an unresponsive server will fail with EINTR when a +termination signal is posted for the process. +.It Fl l +Used with NQNFS and NFSV3 to specify that the \fBReaddirPlus\fR RPC should +be used. +This option reduces RPC traffic for cases such as +.Dq "ls -l" , +but tends to flood the attribute and name caches with prefetched entries. +Try this option and see whether performance improves or degrades. +Probably +most useful for client to server network interconnects with a large bandwidth +times delay product. +.It Fl o +Options are specified with a +.Fl o +flag followed by a comma separated string of options. +See the +.Xr mount 8 +man page for possible options and their meanings. +The following NFS specific options are also available: +.Bl -tag -width indent +.It Cm port Ns = Ns Aq Ar port_number +Use specified port number for NFS requests. +The default is to query the portmapper for the NFS port. +.It Cm acregmin Ns = Ns Aq Ar seconds +.It Cm acregmax Ns = Ns Aq Ar seconds +.It Cm acdirmin Ns = Ns Aq Ar seconds +.It Cm acdirmax Ns = Ns Aq Ar seconds +When attributes of files are cached, a timeout calculated to determine +whether a given cache entry has expired. +These four values determine the upper and lower bounds of the timeouts for +.Dq directory +attributes and +.Dq regular +(ie: everything else). +The default values are 3 -> 60 seconds +for regular files, and 30 -> 60 seconds for directories. +The algorithm to calculate the timeout is based on the age of the file. +The older the file, +the longer the cache is considered valid, subject to the limits above. +.It Cm noinet4 , noinet6 +Disables +.Dv AF_INET +or +.Dv AF_INET6 +connections. +Useful for hosts that have +both an A record and an AAAA record for the same name. +.El +.Bl -tag -width ".Cm dumbtimer" +.Ss Historic Fl o Ss Options +Use of these options is deprecated, they are only mentioned here for +compatibility with historic versions of +.Nm . +.It Cm bg +Same as +.Fl b . +.It Cm conn +Same as not specifying +.Fl c . +.It Cm dumbtimer +Same as +.Fl d . +.It Cm intr +Same as +.Fl i . +.It Cm lockd +Same as not specifying +.Fl L . +.It Cm nfsv2 +Same as +.Fl 2 . +.It Cm nfsv3 +Same as +.Fl 3 . +.It Cm rdirplus +Same as +.Fl l . +.It Cm mntudp +Same as +.Fl U . +.It Cm resvport +Same as +.Fl P . +.It Cm soft +Same as +.Fl s . +.It Cm tcp +Same as +.Fl T . +.El +.It Fl r +Set the read data size to the specified value. +It should normally be a power of 2 greater than or equal to 1024. +This should be used for UDP mounts when the +.Dq "fragments dropped due to timeout" +value is getting large while actively using a mount point. +(Use +.Xr netstat 1 +with the +.Fl s +option to see what the +.Dq "fragments dropped due to timeout" +value is.) +See the +.Fl w +option as well. +.It Fl s +A soft mount, which implies that file system calls will fail +after +.Ar retrycnt +round trip timeout intervals. +.It Fl t +Set the initial retransmit timeout to the specified value. +May be useful for fine tuning UDP mounts over internetworks +with high packet loss rates or an overloaded server. +Try increasing the interval if +.Xr nfsstat 1 +shows high retransmit rates while the file system is active or reducing the +value if there is a low retransmit rate but long response delay observed. +(Normally, the +.Fl d +option should be specified when using this option to manually +tune the timeout +interval.) +.It Fl w +Set the write data size to the specified value. +Ditto the comments w.r.t. the +.Fl r +option, but using the +.Dq "fragments dropped due to timeout" +value on the server instead of the client. +Note that both the +.Fl r +and +.Fl w +options should only be used as a last ditch effort at improving performance +when mounting servers that do not support TCP mounts. +.It Fl x +Set the retransmit timeout count for soft mounts to the specified value. +.El +.Sh SEE ALSO +.Xr mount 2 , +.Xr unmount 2 , +.Xr fstab 5 , +.Xr mount 8 , +.Xr nfsd 8 , +.Xr nfsiod 8 , +.Xr showmount 8 +.Sh BUGS +Due to the way that Sun RPC is implemented on top of UDP (unreliable datagram) +transport, tuning such mounts is really a black art that can only be expected +to have limited success. +For clients mounting servers that are not on the same +LAN cable or that tend to be overloaded, +TCP transport is strongly recommended, +but unfortunately this is restricted to mostly +.Bx 4.4 +servers. diff --git a/sbin/mount_nfs4/mount_nfs4.c b/sbin/mount_nfs4/mount_nfs4.c new file mode 100644 index 0000000..118cd11 --- /dev/null +++ b/sbin/mount_nfs4/mount_nfs4.c @@ -0,0 +1,873 @@ +/* $FreeBSD$ */ +/* $Id: mount_nfs.c,v 1.5 2003/11/05 14:58:58 rees Exp $ */ + +/* + * copyright (c) 2003 + * the regents of the university of michigan + * all rights reserved + * + * permission is granted to use, copy, create derivative works and redistribute + * this software and such derivative works for any purpose, so long as the name + * of the university of michigan is not used in any advertising or publicity + * pertaining to the use or distribution of this software without specific, + * written prior authorization. if the above copyright notice or any other + * identification of the university of michigan is included in any copy of any + * portion of this software, then the disclaimer below must also be included. + * + * this software is provided as is, without representation from the university + * of michigan as to its fitness for any purpose, and without warranty by the + * university of michigan of any kind, either express or implied, including + * without limitation the implied warranties of merchantability and fitness for + * a particular purpose. the regents of the university of michigan shall not be + * liable for any damages, including special, indirect, incidental, or + * consequential damages, with respect to any claim arising out of or in + * connection with the use of the software, even if it has been or is hereafter + * advised of the possibility of such damages. + */ + +/* + * Copyright (c) 1992, 1993, 1994 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Rick Macklem at The University of Guelph. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#if 0 +#ifndef lint +static const char copyright[] = +"@(#) Copyright (c) 1992, 1993, 1994\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)mount_nfs.c 8.11 (Berkeley) 5/4/95"; +#endif /* not lint */ +#endif +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/mount.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/syslog.h> + +#include <rpc/rpc.h> +#include <rpc/pmap_clnt.h> +#include <rpc/pmap_prot.h> + +#include <nfs/rpcv2.h> +#include <nfs/nfsproto.h> +#include <nfsclient/nfs.h> +#include <nfsclient/nfsargs.h> + +#include <arpa/inet.h> + +#include <ctype.h> +#include <err.h> +#include <errno.h> +#include <fcntl.h> +#include <netdb.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <strings.h> +#include <sysexits.h> +#include <unistd.h> + +#include "mntopts.h" +#include "mounttab.h" + +#define ALTF_BG 0x1 +#define ALTF_NOCONN 0x2 +#define ALTF_DUMBTIMR 0x4 +#define ALTF_INTR 0x8 +#define ALTF_NFSV3 0x20 +#define ALTF_RDIRPLUS 0x40 +#define ALTF_MNTUDP 0x80 +#define ALTF_RESVPORT 0x100 +#define ALTF_SEQPACKET 0x200 +#define ALTF_SOFT 0x800 +#define ALTF_TCP 0x1000 +#define ALTF_PORT 0x2000 +#define ALTF_NFSV2 0x4000 +#define ALTF_ACREGMIN 0x8000 +#define ALTF_ACREGMAX 0x10000 +#define ALTF_ACDIRMIN 0x20000 +#define ALTF_ACDIRMAX 0x40000 +#define ALTF_NOLOCKD 0x80000 +#define ALTF_NOINET4 0x100000 +#define ALTF_NOINET6 0x200000 + +struct mntopt mopts[] = { + MOPT_STDOPTS, + MOPT_FORCE, + MOPT_UPDATE, + MOPT_ASYNC, + { "bg", 0, ALTF_BG, 1 }, + { "conn", 1, ALTF_NOCONN, 1 }, + { "dumbtimer", 0, ALTF_DUMBTIMR, 1 }, + { "intr", 0, ALTF_INTR, 1 }, + { "nfsv3", 0, ALTF_NFSV3, 1 }, + { "rdirplus", 0, ALTF_RDIRPLUS, 1 }, + { "mntudp", 0, ALTF_MNTUDP, 1 }, + { "resvport", 0, ALTF_RESVPORT, 1 }, + { "soft", 0, ALTF_SOFT, 1 }, + { "tcp", 0, ALTF_TCP, 1 }, + { "port=", 0, ALTF_PORT, 1 }, + { "nfsv2", 0, ALTF_NFSV2, 1 }, + { "acregmin=", 0, ALTF_ACREGMIN, 1 }, + { "acregmax=", 0, ALTF_ACREGMAX, 1 }, + { "acdirmin=", 0, ALTF_ACDIRMIN, 1 }, + { "acdirmax=", 0, ALTF_ACDIRMAX, 1 }, + { "lockd", 1, ALTF_NOLOCKD, 1 }, + { "inet4", 1, ALTF_NOINET4, 1 }, + { "inet6", 1, ALTF_NOINET6, 1 }, + { NULL } +}; + +struct nfs_args nfsdefargs = { + NFS_ARGSVERSION, + NULL, + sizeof (struct sockaddr_in), + SOCK_STREAM, + 0, + NULL, + 0, + NFSMNT_RESVPORT, + NFS_WSIZE, + NFS_RSIZE, + NFS_READDIRSIZE, + 10, + NFS_RETRANS, + NFS_MAXGRPS, + NFS_DEFRAHEAD, + 0, /* was: NQ_DEFLEASE */ + NFS_MAXDEADTHRESH, /* was: NQ_DEADTHRESH */ + NULL, + /* args version 4 */ + NFS_MINATTRTIMO, + NFS_MAXATTRTIMO, + NFS_MINDIRATTRTIMO, + NFS_MAXDIRATTRTIMO, +}; + +/* Table for af,sotype -> netid conversions. */ +struct nc_protos { + char *netid; + int af; + int sotype; +} nc_protos[] = { + {"udp", AF_INET, SOCK_DGRAM}, + {"tcp", AF_INET, SOCK_STREAM}, + {"udp6", AF_INET6, SOCK_DGRAM}, + {"tcp6", AF_INET6, SOCK_STREAM}, + {NULL} +}; + +struct nfhret { + u_long stat; + long vers; + long auth; + long fhsize; + u_char nfh[NFSX_V3FHMAX]; +}; +#define BGRND 1 +#define ISBGRND 2 +#define OF_NOINET4 4 +#define OF_NOINET6 8 +int retrycnt = -1; +int opflags = 0; +int nfsproto = IPPROTO_TCP; +char *portspec = "2049"; /* Server nfs port; "0" means look up via rpcbind. */ +enum mountmode { + ANY, + V2, + V3 +} mountmode = ANY; + +/* Return codes for nfs_tryproto. */ +enum tryret { + TRYRET_SUCCESS, + TRYRET_TIMEOUT, /* No response received. */ + TRYRET_REMOTEERR, /* Error received from remote server. */ + TRYRET_LOCALERR /* Local failure. */ +}; + +int getnfsargs(char *, struct nfs_args *); +/* void set_rpc_maxgrouplist(int); */ +struct netconfig *getnetconf_cached(const char *netid); +char *netidbytype(int af, int sotype); +void usage(void) __dead2; +int xdr_dir(XDR *, char *); +int xdr_fh(XDR *, struct nfhret *); +enum tryret nfs_tryproto(struct nfs_args *nfsargsp, struct addrinfo *ai, + char *hostp, char *spec, char **errstr); +enum tryret returncode(enum clnt_stat stat, struct rpc_err *rpcerr); + +/* + * Used to set mount flags with getmntopts. Call with dir=TRUE to + * initialize altflags from the current mount flags. Call with + * dir=FALSE to update mount flags with the new value of altflags after + * the call to getmntopts. + */ +static void +set_flags(int* altflags, int* nfsflags, int dir) +{ +#define F2(af, nf) \ + if (dir) { \ + if (*nfsflags & NFSMNT_##nf) \ + *altflags |= ALTF_##af; \ + else \ + *altflags &= ~ALTF_##af; \ + } else { \ + if (*altflags & ALTF_##af) \ + *nfsflags |= NFSMNT_##nf; \ + else \ + *nfsflags &= ~NFSMNT_##nf; \ + } +#define F(f) F2(f,f) + + F(NOCONN); + F(DUMBTIMR); + F2(INTR, INT); + F(RDIRPLUS); + F(RESVPORT); + F(SOFT); + F(ACREGMIN); + F(ACREGMAX); + F(ACDIRMIN); + F(ACDIRMAX); + F(NOLOCKD); + +#undef F +#undef F2 +} + +int +main(argc, argv) + int argc; + char *argv[]; +{ + int c; + struct nfs_args *nfsargsp; + struct nfs_args nfsargs; + int mntflags, altflags, num; + char *name, *p, *spec; + char mntpath[MAXPATHLEN]; + + mntflags = 0; + altflags = 0; + nfsargs = nfsdefargs; + nfsargsp = &nfsargs; + while ((c = getopt(argc, argv, + "23a:bcdD:g:I:iLl:No:PR:r:sTt:w:x:U")) != -1) + switch (c) { + case '2': + mountmode = V2; + break; + case '3': + mountmode = V3; + break; + case 'a': + num = strtol(optarg, &p, 10); + if (*p || num < 0) + errx(1, "illegal -a value -- %s", optarg); + nfsargsp->readahead = num; + nfsargsp->flags |= NFSMNT_READAHEAD; + break; + case 'b': + opflags |= BGRND; + break; + case 'c': + nfsargsp->flags |= NFSMNT_NOCONN; + break; + case 'D': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -D value -- %s", optarg); + nfsargsp->deadthresh = num; + nfsargsp->flags |= NFSMNT_DEADTHRESH; + break; + case 'd': + nfsargsp->flags |= NFSMNT_DUMBTIMR; + break; +#if 0 /* XXXX */ + case 'g': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -g value -- %s", optarg); + set_rpc_maxgrouplist(num); + nfsargsp->maxgrouplist = num; + nfsargsp->flags |= NFSMNT_MAXGRPS; + break; +#endif + case 'I': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -I value -- %s", optarg); + nfsargsp->readdirsize = num; + nfsargsp->flags |= NFSMNT_READDIRSIZE; + break; + case 'i': + nfsargsp->flags |= NFSMNT_INT; + break; + case 'L': + nfsargsp->flags |= NFSMNT_NOLOCKD; + break; + case 'l': + nfsargsp->flags |= NFSMNT_RDIRPLUS; + break; + case 'N': + nfsargsp->flags &= ~NFSMNT_RESVPORT; + break; + case 'o': + altflags = 0; + set_flags(&altflags, &nfsargsp->flags, TRUE); + if (mountmode == V2) + altflags |= ALTF_NFSV2; + else if (mountmode == V3) + altflags |= ALTF_NFSV3; + getmntopts(optarg, mopts, &mntflags, &altflags); + set_flags(&altflags, &nfsargsp->flags, FALSE); + /* + * Handle altflags which don't map directly to + * mount flags. + */ + if (altflags & ALTF_BG) + opflags |= BGRND; + if (altflags & ALTF_NOINET4) + opflags |= OF_NOINET4; + if (altflags & ALTF_NOINET6) + opflags |= OF_NOINET6; + if (altflags & ALTF_MNTUDP) { + nfsargsp->sotype = SOCK_DGRAM; + nfsproto = IPPROTO_UDP; + } + if (altflags & ALTF_PORT) { + /* + * XXX Converting from a string to an int + * and back again is silly, and we should + * allow /etc/services names. + */ + p = strstr(optarg, "port="); + if (p) { + asprintf(&portspec, "%d", + atoi(p + 5)); + if (portspec == NULL) + err(1, "asprintf"); + } + } + mountmode = ANY; + if (altflags & ALTF_NFSV2) + mountmode = V2; + if (altflags & ALTF_NFSV3) + mountmode = V3; + if (altflags & ALTF_ACREGMIN) { + p = strstr(optarg, "acregmin="); + if (p) + nfsargsp->acregmin = atoi(p + 9); + } + if (altflags & ALTF_ACREGMAX) { + p = strstr(optarg, "acregmax="); + if (p) + nfsargsp->acregmax = atoi(p + 9); + } + if (altflags & ALTF_ACDIRMIN) { + p = strstr(optarg, "acdirmin="); + if (p) + nfsargsp->acdirmin = atoi(p + 9); + } + if (altflags & ALTF_ACDIRMAX) { + p = strstr(optarg, "acdirmax="); + if (p) + nfsargsp->acdirmax = atoi(p + 9); + } + break; + case 'P': + /* obsolete for NFSMNT_RESVPORT, now default */ + break; + case 'R': + num = strtol(optarg, &p, 10); + if (*p || num < 0) + errx(1, "illegal -R value -- %s", optarg); + retrycnt = num; + break; + case 'r': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -r value -- %s", optarg); + nfsargsp->rsize = num; + nfsargsp->flags |= NFSMNT_RSIZE; + break; + case 's': + nfsargsp->flags |= NFSMNT_SOFT; + break; + case 'T': + nfsargsp->sotype = SOCK_STREAM; + nfsproto = IPPROTO_TCP; + break; + case 't': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -t value -- %s", optarg); + nfsargsp->timeo = num; + nfsargsp->flags |= NFSMNT_TIMEO; + break; + case 'w': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -w value -- %s", optarg); + nfsargsp->wsize = num; + nfsargsp->flags |= NFSMNT_WSIZE; + break; + case 'x': + num = strtol(optarg, &p, 10); + if (*p || num <= 0) + errx(1, "illegal -x value -- %s", optarg); + nfsargsp->retrans = num; + nfsargsp->flags |= NFSMNT_RETRANS; + break; + case 'U': + nfsargsp->sotype = SOCK_DGRAM; + nfsproto = IPPROTO_UDP; + break; + default: + usage(); + break; + } + argc -= optind; + argv += optind; + + if (argc != 2) { + usage(); + /* NOTREACHED */ + } + + spec = *argv++; + name = *argv; + + if (retrycnt == -1) + /* The default is to keep retrying forever. */ + retrycnt = 0; + if (!getnfsargs(spec, nfsargsp)) + exit(1); + + /* resolve the mountpoint with realpath(3) */ + (void)checkpath(name, mntpath); + + if (mount("nfs4", mntpath, mntflags, nfsargsp)) + err(1, "%s", mntpath); + + exit(0); +} + +int +getnfsargs(spec, nfsargsp) + char *spec; + struct nfs_args *nfsargsp; +{ + struct addrinfo hints, *ai_nfs, *ai; + enum tryret ret; + int ecode, speclen, remoteerr; + char *hostp, *delimp, *errstr; + size_t len; + static char nam[MNAMELEN + 1]; + + if ((delimp = strrchr(spec, ':')) != NULL) { + hostp = spec; + spec = delimp + 1; + } else if ((delimp = strrchr(spec, '@')) != NULL) { + warnx("path@server syntax is deprecated, use server:path"); + hostp = delimp + 1; + } else { + warnx("no <host>:<dirpath> nfs-name"); + return (0); + } + *delimp = '\0'; + + /* + * If there has been a trailing slash at mounttime it seems + * that some mountd implementations fail to remove the mount + * entries from their mountlist while unmounting. + */ + for (speclen = strlen(spec); + speclen > 1 && spec[speclen - 1] == '/'; + speclen--) + spec[speclen - 1] = '\0'; + if (strlen(hostp) + strlen(spec) + 1 > MNAMELEN) { + warnx("%s:%s: %s", hostp, spec, strerror(ENAMETOOLONG)); + return (0); + } + /* Make both '@' and ':' notations equal */ + if (*hostp != '\0') { + len = strlen(hostp); + memmove(nam, hostp, len); + nam[len] = ':'; + memmove(nam + len + 1, spec, speclen); + nam[len + speclen + 1] = '\0'; + } + + /* + * Handle an internet host address. + */ + memset(&hints, 0, sizeof hints); + hints.ai_flags = AI_NUMERICHOST; + hints.ai_socktype = nfsargsp->sotype; + if (getaddrinfo(hostp, portspec, &hints, &ai_nfs) != 0) { + hints.ai_flags = 0; + if ((ecode = getaddrinfo(hostp, portspec, &hints, &ai_nfs)) + != 0) { + if (portspec == NULL) + errx(1, "%s: %s", hostp, gai_strerror(ecode)); + else + errx(1, "%s:%s: %s", hostp, portspec, + gai_strerror(ecode)); + return (0); + } + } + + ret = TRYRET_LOCALERR; + for (;;) { + /* + * Try each entry returned by getaddrinfo(). Note the + * occurence of remote errors by setting `remoteerr'. + */ + remoteerr = 0; + for (ai = ai_nfs; ai != NULL; ai = ai->ai_next) { + if ((ai->ai_family == AF_INET6) && + (opflags & OF_NOINET6)) + continue; + if ((ai->ai_family == AF_INET) && + (opflags & OF_NOINET4)) + continue; + ret = nfs_tryproto(nfsargsp, ai, hostp, spec, &errstr); + if (ret == TRYRET_SUCCESS) + break; + if (ret != TRYRET_LOCALERR) + remoteerr = 1; + if ((opflags & ISBGRND) == 0) + fprintf(stderr, "%s\n", errstr); + } + if (ret == TRYRET_SUCCESS) + break; + + /* Exit if all errors were local. */ + if (!remoteerr) + exit(1); + + /* + * If retrycnt == 0, we are to keep retrying forever. + * Otherwise decrement it, and exit if it hits zero. + */ + if (retrycnt != 0 && --retrycnt == 0) + exit(1); + + if ((opflags & (BGRND | ISBGRND)) == BGRND) { + warnx("Cannot immediately mount %s:%s, backgrounding", + hostp, spec); + opflags |= ISBGRND; + if (daemon(0, 0) != 0) + err(1, "daemon"); + } + sleep(60); + } + freeaddrinfo(ai_nfs); + nfsargsp->hostname = nam; + /* Add mounted file system to PATH_MOUNTTAB */ + if (!add_mtab(hostp, spec)) + warnx("can't update %s for %s:%s", PATH_MOUNTTAB, hostp, spec); + return (1); +} + +/* + * Try to set up the NFS arguments according to the address + * family, protocol (and possibly port) specified in `ai'. + * + * Returns TRYRET_SUCCESS if successful, or: + * TRYRET_TIMEOUT The server did not respond. + * TRYRET_REMOTEERR The server reported an error. + * TRYRET_LOCALERR Local failure. + * + * In all error cases, *errstr will be set to a statically-allocated string + * describing the error. + */ +enum tryret +nfs_tryproto(struct nfs_args *nfsargsp, struct addrinfo *ai, char *hostp, + char *spec, char **errstr) +{ + static char errbuf[256]; + struct sockaddr_storage nfs_ss; + struct netbuf nfs_nb; + struct netconfig *nconf; + char *netid; + int nfsvers; + + errbuf[0] = '\0'; + *errstr = errbuf; + + if ((netid = netidbytype(ai->ai_family, nfsargsp->sotype)) == NULL) { + snprintf(errbuf, sizeof errbuf, + "af %d sotype %d not supported", ai->ai_family, + nfsargsp->sotype); + return (TRYRET_LOCALERR); + } + if ((nconf = getnetconf_cached(netid)) == NULL) { + snprintf(errbuf, sizeof errbuf, "%s: %s", netid, nc_sperror()); + return (TRYRET_LOCALERR); + } + + nfsvers = 4; + + if (portspec != NULL && atoi(portspec) != 0) { + /* `ai' contains the complete nfsd sockaddr. */ + nfs_nb.buf = ai->ai_addr; + nfs_nb.len = nfs_nb.maxlen = ai->ai_addrlen; + } else { + /* Ask the remote rpcbind. */ + nfs_nb.buf = &nfs_ss; + nfs_nb.len = nfs_nb.maxlen = sizeof nfs_ss; + + if (!rpcb_getaddr(RPCPROG_NFS, nfsvers, nconf, &nfs_nb, + hostp)) { + snprintf(errbuf, sizeof errbuf, "[%s] %s:%s: %s", + netid, hostp, spec, + clnt_spcreateerror("RPCPROG_NFS")); + return (returncode(rpc_createerr.cf_stat, + &rpc_createerr.cf_error)); + } + } + +#if 0 + /* Check that the server (nfsd) responds on the port we have chosen. */ + clp = clnt_tli_create(RPC_ANYFD, nconf, &nfs_nb, RPCPROG_NFS, nfsvers, + 0, 0); + if (clp == NULL) { + snprintf(errbuf, sizeof errbuf, "[%s] %s:%s: %s", netid, + hostp, spec, clnt_spcreateerror("nfsd: RPCPROG_NFS")); + return (returncode(rpc_createerr.cf_stat, + &rpc_createerr.cf_error)); + } + if (nfsargsp->sotype == SOCK_DGRAM && + !(nfsargsp->flags & NFSMNT_NOCONN)) { + /* + * Use connect(), to match what the kernel does. This + * catches cases where the server responds from the + * wrong source address. + */ + doconnect = 1; + if (!clnt_control(clp, CLSET_CONNECT, (char *)&doconnect)) { + clnt_destroy(clp); + snprintf(errbuf, sizeof errbuf, + "[%s] %s:%s: CLSET_CONNECT failed", netid, hostp, + spec); + return (TRYRET_LOCALERR); + } + } + + try.tv_sec = 10; + try.tv_usec = 0; + stat = clnt_call(clp, NFSPROC_NULL, (xdrproc_t)xdr_void, NULL, + (xdrproc_t)xdr_void, NULL, try); + if (stat != RPC_SUCCESS) { + clnt_geterr(clp, &rpcerr); + snprintf(errbuf, sizeof errbuf, "[%s] %s:%s: %s", netid, + hostp, spec, clnt_sperror(clp, "NFSPROC_NULL")); + clnt_destroy(clp); + return (returncode(stat, &rpcerr)); + } + clnt_destroy(clp); +#endif + + /* + * Store the filehandle and server address in nfsargsp, making + * sure to copy any locally allocated structures. + */ + nfsargsp->addrlen = nfs_nb.len; + nfsargsp->addr = malloc(nfsargsp->addrlen); + + if (nfsargsp->addr == NULL) + err(1, "malloc"); + bcopy(nfs_nb.buf, nfsargsp->addr, nfsargsp->addrlen); + + /* XXX hack */ + nfsargsp->flags |= (NFSMNT_NFSV3 | NFSMNT_NFSV4); + + return (TRYRET_SUCCESS); +} + + +/* + * Catagorise a RPC return status and error into an `enum tryret' + * return code. + */ +enum tryret +returncode(enum clnt_stat stat, struct rpc_err *rpcerr) +{ + switch (stat) { + case RPC_TIMEDOUT: + return (TRYRET_TIMEOUT); + case RPC_PMAPFAILURE: + case RPC_PROGNOTREGISTERED: + case RPC_PROGVERSMISMATCH: + /* XXX, these can be local or remote. */ + case RPC_CANTSEND: + case RPC_CANTRECV: + return (TRYRET_REMOTEERR); + case RPC_SYSTEMERROR: + switch (rpcerr->re_errno) { + case ETIMEDOUT: + return (TRYRET_TIMEOUT); + case ENOMEM: + break; + default: + return (TRYRET_REMOTEERR); + } + /* FALLTHROUGH */ + default: + break; + } + return (TRYRET_LOCALERR); +} + +/* + * Look up a netid based on an address family and socket type. + * `af' is the address family, and `sotype' is SOCK_DGRAM or SOCK_STREAM. + * + * XXX there should be a library function for this. + */ +char * +netidbytype(int af, int sotype) { + struct nc_protos *p; + + for (p = nc_protos; p->netid != NULL; p++) { + if (af != p->af || sotype != p->sotype) + continue; + return (p->netid); + } + return (NULL); +} + +/* + * Look up a netconfig entry based on a netid, and cache the result so + * that we don't need to remember to call freenetconfigent(). + * + * Otherwise it behaves just like getnetconfigent(), so nc_*error() + * work on failure. + */ +struct netconfig * +getnetconf_cached(const char *netid) { + static struct nc_entry { + struct netconfig *nconf; + struct nc_entry *next; + } *head; + struct nc_entry *p; + struct netconfig *nconf; + + for (p = head; p != NULL; p = p->next) + if (strcmp(netid, p->nconf->nc_netid) == 0) + return (p->nconf); + + if ((nconf = getnetconfigent(netid)) == NULL) + return (NULL); + if ((p = malloc(sizeof(*p))) == NULL) + err(1, "malloc"); + p->nconf = nconf; + p->next = head; + head = p; + + return (p->nconf); +} + +/* + * xdr routines for mount rpc's + */ +int +xdr_dir(xdrsp, dirp) + XDR *xdrsp; + char *dirp; +{ + return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN)); +} + +int +xdr_fh(xdrsp, np) + XDR *xdrsp; + struct nfhret *np; +{ + int i; + long auth, authcnt, authfnd = 0; + + if (!xdr_u_long(xdrsp, &np->stat)) + return (0); + if (np->stat) + return (1); + switch (np->vers) { + case 1: + np->fhsize = NFSX_V2FH; + return (xdr_opaque(xdrsp, (caddr_t)np->nfh, NFSX_V2FH)); + case 3: + if (!xdr_long(xdrsp, &np->fhsize)) + return (0); + if (np->fhsize <= 0 || np->fhsize > NFSX_V3FHMAX) + return (0); + if (!xdr_opaque(xdrsp, (caddr_t)np->nfh, np->fhsize)) + return (0); + if (!xdr_long(xdrsp, &authcnt)) + return (0); + for (i = 0; i < authcnt; i++) { + if (!xdr_long(xdrsp, &auth)) + return (0); + if (auth == np->auth) + authfnd++; + } + /* + * Some servers, such as DEC's OSF/1 return a nil authenticator + * list to indicate RPCAUTH_UNIX. + */ + if (!authfnd && (authcnt > 0 || np->auth != RPCAUTH_UNIX)) + np->stat = EAUTH; + return (1); + }; + return (0); +} + +void +usage() +{ + (void)fprintf(stderr, "%s\n%s\n%s\n%s\n", +"usage: mount_nfs [-23KNPTUbcdilqs] [-D deadthresh] [-I readdirsize]", +" [-R retrycnt] [-a maxreadahead]", +" [-g maxgroups] [-m realm] [-o options] [-r readsize]", +" [-t timeout] [-w writesize] [-x retrans] rhost:path node"); + exit(1); +} |
