349 lines
8.6 KiB
C
349 lines
8.6 KiB
C
/* $NetBSD: getnfsargs.c,v 1.18 2017/02/05 00:24:24 christos Exp $ */
|
|
|
|
/*
|
|
* 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. 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.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__COPYRIGHT("@(#) Copyright (c) 1992, 1993, 1994\
|
|
The Regents of the University of California. All rights reserved.");
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)mount_nfs.c 8.11 (Berkeley) 5/4/95";
|
|
#else
|
|
__RCSID("$NetBSD: getnfsargs.c,v 1.18 2017/02/05 00:24:24 christos Exp $");
|
|
#endif
|
|
#endif /* not lint */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <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 <nfs/nfs.h>
|
|
#include <nfs/nfsmount.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <netdb.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <util.h>
|
|
|
|
#include "mount_nfs.h"
|
|
|
|
int retrycnt = DEF_RETRY;
|
|
int opflags = 0;
|
|
int force2 = 0;
|
|
int force3 = 0;
|
|
int mnttcp_ok = 1;
|
|
int port = 0;
|
|
|
|
struct nfhret {
|
|
u_long stat;
|
|
long vers;
|
|
long auth;
|
|
long fhsize;
|
|
u_char nfh[NFSX_V3FHMAX];
|
|
};
|
|
|
|
static int xdr_dir(XDR *, char *);
|
|
static int xdr_fh(XDR *, struct nfhret *);
|
|
|
|
#ifndef MOUNTNFS_RETRYRPC
|
|
#define MOUNTNFS_RETRYRPC 60
|
|
#endif
|
|
|
|
int
|
|
getnfsargs(char *spec, struct nfs_args *nfsargsp)
|
|
{
|
|
CLIENT *clp;
|
|
struct addrinfo hints, *ai_nfs, *ai;
|
|
int ecode;
|
|
static struct netbuf nfs_nb;
|
|
static struct sockaddr_storage nfs_ss;
|
|
struct netconfig *nconf;
|
|
const char *netid;
|
|
struct timeval pertry, try;
|
|
enum clnt_stat clnt_stat;
|
|
int i, nfsvers, mntvers;
|
|
int retryleft;
|
|
char *hostp, *delimp;
|
|
static struct nfhret nfhret;
|
|
static char nam[MNAMELEN + 1];
|
|
|
|
strlcpy(nam, spec, sizeof(nam));
|
|
if ((delimp = strchr(spec, '@')) != NULL) {
|
|
hostp = delimp + 1;
|
|
} else if ((delimp = strrchr(spec, ':')) != NULL) {
|
|
hostp = spec;
|
|
spec = delimp + 1;
|
|
} else {
|
|
warnx("no <host>:<dirpath> or <dirpath>@<host> spec");
|
|
return (0);
|
|
}
|
|
*delimp = '\0';
|
|
|
|
/*
|
|
* Handle an internet host address.
|
|
*/
|
|
memset(&hints, 0, sizeof hints);
|
|
hints.ai_flags = AI_NUMERICHOST;
|
|
hints.ai_socktype = nfsargsp->sotype;
|
|
if (getaddrinfo(hostp, "nfs", &hints, &ai_nfs) != 0) {
|
|
hints.ai_flags = 0;
|
|
if ((ecode = getaddrinfo(hostp, "nfs", &hints, &ai_nfs)) != 0) {
|
|
warnx("can't get net id for host \"%s\": %s", hostp,
|
|
gai_strerror(ecode));
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
if ((nfsargsp->flags & NFSMNT_NFSV3) != 0) {
|
|
nfsvers = NFS_VER3;
|
|
mntvers = RPCMNT_VER3;
|
|
} else {
|
|
nfsvers = NFS_VER2;
|
|
mntvers = RPCMNT_VER1;
|
|
}
|
|
nfhret.stat = EACCES; /* Mark not yet successful */
|
|
|
|
for (ai = ai_nfs; ai; ai = ai->ai_next) {
|
|
/*
|
|
* XXX. Need a generic (family, type, proto) -> nconf interface.
|
|
* __rpc_*2nconf exist, maybe they should be exported.
|
|
*/
|
|
if (nfsargsp->sotype == SOCK_STREAM) {
|
|
if (ai->ai_family == AF_INET6)
|
|
netid = "tcp6";
|
|
else
|
|
netid = "tcp";
|
|
} else {
|
|
if (ai->ai_family == AF_INET6)
|
|
netid = "udp6";
|
|
else
|
|
netid = "udp";
|
|
}
|
|
|
|
nconf = getnetconfigent(netid);
|
|
|
|
tryagain:
|
|
retryleft = retrycnt;
|
|
|
|
while (retryleft > 0) {
|
|
nfs_nb.buf = &nfs_ss;
|
|
nfs_nb.maxlen = sizeof nfs_ss;
|
|
if (!rpcb_getaddr(RPCPROG_NFS, nfsvers, nconf, &nfs_nb, hostp)){
|
|
if (rpc_createerr.cf_stat == RPC_SYSTEMERROR) {
|
|
nfhret.stat = rpc_createerr.cf_error.re_errno;
|
|
break;
|
|
}
|
|
if (rpc_createerr.cf_stat == RPC_UNKNOWNPROTO) {
|
|
nfhret.stat = EPROTONOSUPPORT;
|
|
break;
|
|
}
|
|
if ((opflags & ISBGRND) == 0) {
|
|
char buf[64];
|
|
|
|
snprintf(buf, sizeof(buf),
|
|
"%s: rpcbind to nfs on server",
|
|
getprogname());
|
|
clnt_pcreateerror(buf);
|
|
}
|
|
} else {
|
|
pertry.tv_sec = 30;
|
|
pertry.tv_usec = 0;
|
|
/*
|
|
* XXX relies on clnt_tcp_create to bind to a reserved
|
|
* socket.
|
|
*/
|
|
clp = clnt_tp_create(hostp, RPCPROG_MNT, mntvers,
|
|
mnttcp_ok ? nconf : getnetconfigent(netid));
|
|
if (clp == NULL) {
|
|
if ((opflags & ISBGRND) == 0) {
|
|
clnt_pcreateerror(
|
|
"Cannot MNT RPC (mountd)");
|
|
}
|
|
} else {
|
|
CLNT_CONTROL(clp, CLSET_RETRY_TIMEOUT,
|
|
(char *)&pertry);
|
|
clp->cl_auth = authsys_create_default();
|
|
try.tv_sec = 30;
|
|
try.tv_usec = 0;
|
|
nfhret.auth = RPCAUTH_UNIX;
|
|
nfhret.vers = mntvers;
|
|
clnt_stat = clnt_call(clp, RPCMNT_MOUNT,
|
|
xdr_dir, spec, xdr_fh, &nfhret, try);
|
|
switch (clnt_stat) {
|
|
case RPC_PROGVERSMISMATCH:
|
|
if (nfsvers == NFS_VER3 && !force3) {
|
|
nfsvers = NFS_VER2;
|
|
mntvers = RPCMNT_VER1;
|
|
nfsargsp->flags &=
|
|
~NFSMNT_NFSV3;
|
|
goto tryagain;
|
|
} else {
|
|
errx(1, "%s", clnt_sperror(clp,
|
|
"MNT RPC"));
|
|
}
|
|
case RPC_SUCCESS:
|
|
auth_destroy(clp->cl_auth);
|
|
clnt_destroy(clp);
|
|
retryleft = 0;
|
|
break;
|
|
default:
|
|
/* XXX should give up on some errors */
|
|
if ((opflags & ISBGRND) == 0)
|
|
warnx("%s", clnt_sperror(clp,
|
|
"bad MNT RPC"));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (--retryleft > 0) {
|
|
if (opflags & BGRND) {
|
|
opflags &= ~BGRND;
|
|
if ((i = fork()) != 0) {
|
|
if (i == -1)
|
|
err(1, "fork");
|
|
exit(0);
|
|
}
|
|
(void) setsid();
|
|
(void) close(STDIN_FILENO);
|
|
(void) close(STDOUT_FILENO);
|
|
(void) close(STDERR_FILENO);
|
|
(void) chdir("/");
|
|
opflags |= ISBGRND;
|
|
}
|
|
sleep(MOUNTNFS_RETRYRPC);
|
|
}
|
|
}
|
|
if (nfhret.stat == 0)
|
|
break;
|
|
}
|
|
freeaddrinfo(ai_nfs);
|
|
if (nfhret.stat) {
|
|
if (opflags & ISBGRND)
|
|
exit(1);
|
|
errno = nfhret.stat;
|
|
warnx("can't access %s: %s", spec, strerror(nfhret.stat));
|
|
return (0);
|
|
} else {
|
|
nfsargsp->addr = (struct sockaddr *) nfs_nb.buf;
|
|
nfsargsp->addrlen = nfs_nb.len;
|
|
if (port != 0) {
|
|
struct sockaddr *sa = nfsargsp->addr;
|
|
switch (sa->sa_family) {
|
|
case AF_INET:
|
|
((struct sockaddr_in *)sa)->sin_port = port;
|
|
break;
|
|
#ifdef INET6
|
|
case AF_INET6:
|
|
((struct sockaddr_in6 *)sa)->sin6_port = port;
|
|
break;
|
|
#endif
|
|
default:
|
|
errx(1, "Unsupported socket family %d",
|
|
sa->sa_family);
|
|
}
|
|
}
|
|
}
|
|
nfsargsp->fh = nfhret.nfh;
|
|
nfsargsp->fhsize = nfhret.fhsize;
|
|
nfsargsp->hostname = nam;
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* xdr routines for mount rpc's
|
|
*/
|
|
static int
|
|
xdr_dir(XDR *xdrsp, char *dirp)
|
|
{
|
|
return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
|
|
}
|
|
|
|
static int
|
|
xdr_fh(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);
|
|
}
|