/*
* Handle "foreground" NFS mounts.
*
* Retry the mount request for as long as the 'retry=' option says.
*
* Returns a valid mount command exit code.
*/
static int nfsmount_fg(struct nfsmount_info *mi)
{
unsigned int secs = 1;
time_t timeout;
timeout = nfs_parse_retry_option(mi->options,
NFS_DEF_FG_TIMEOUT_MINUTES);
if (verbose)
printf(_("%s: timeout set for %s"),
progname, ctime(&timeout));
for (;;) {
if (nfs_try_mount(mi))
return EX_SUCCESS;
if (nfs_is_permanent_error(errno))
break;
if (time(NULL) > timeout) {
errno = ETIMEDOUT;
break;
}
if (errno != ETIMEDOUT) {
if (sleep(secs))
break;
secs <<= 1;
if (secs > 10)
secs = 10;
}
};
mount_error(mi->spec, mi->node, errno);
return EX_FAIL;
}
/*
* Usually all that is needed for an NFS remount is to change
* generic mount options like "sync" or "ro". These generic
* options are controlled by mi->flags, not by text-based
* options, and no contact with the server is needed.
*
* Take care with the /etc/mtab entry for this mount; just
* calling update_mtab() will change an "-t nfs -o vers=4"
* mount to an "-t nfs -o remount" mount, and that will
* confuse umount.nfs.
*
* Returns a valid mount command exit code.
*/
static int nfs_remount(struct nfsmount_info *mi)
{
if (nfs_sys_mount(mi, mi->options))
return EX_SUCCESS;
mount_error(mi->spec, mi->node, errno);
return EX_FAIL;
}
/*
* Handle "background" NFS mount [first try]
*
* Returns a valid mount command exit code.
*
* EX_BG should cause the caller to fork and invoke nfsmount_child.
*/
static int nfsmount_parent(struct nfsmount_info *mi)
{
if (nfs_try_mount(mi))
return EX_SUCCESS;
if (nfs_is_permanent_error(errno)) {
mount_error(mi->spec, mi->node, errno);
return EX_FAIL;
}
sys_mount_errors(mi->hostname, errno, 1, 1);
return EX_BG;
}
/*
* Handle "background" NFS mount [first try]
*
* Returns a valid mount command exit code.
*
* EX_BG should cause the caller to fork and invoke nfsmount_child.
*/
static int nfsmount_parent(struct nfsmount_info *mi)
{
if (nfs_try_mount(mi))
return EX_SUCCESS;
/* retry background mounts when the server is not up */
if (nfs_is_permanent_error(errno) && errno != EOPNOTSUPP) {
mount_error(mi->spec, mi->node, errno);
return EX_FAIL;
}
sys_mount_errors(mi->hostname, errno, 1, 1);
return EX_BG;
}
int nfs4mount(const char *spec, const char *node, int flags,
char **extra_opts, int fake, int running_bg)
{
static struct nfs4_mount_data data;
static char hostdir[1024];
static char ip_addr[16] = "127.0.0.1";
static struct sockaddr_in server_addr, client_addr;
static int pseudoflavour[MAX_USER_FLAVOUR];
int num_flavour = 0;
int ip_addr_in_opts = 0;
char *hostname, *dirname, *old_opts;
char new_opts[1024];
char *opt, *opteq;
char *s;
int val;
int bg, soft, intr;
int nocto, noac, unshared;
int retry;
int retval = EX_FAIL;
time_t timeout, t;
if (strlen(spec) >= sizeof(hostdir)) {
nfs_error(_("%s: excessively long host:dir argument\n"),
progname);
goto fail;
}
strcpy(hostdir, spec);
if (parse_devname(hostdir, &hostname, &dirname))
goto fail;
if (fill_ipv4_sockaddr(hostname, &server_addr))
goto fail;
if (get_my_ipv4addr(ip_addr, sizeof(ip_addr)))
goto fail;
/* add IP address to mtab options for use when unmounting */
s = inet_ntoa(server_addr.sin_addr);
old_opts = *extra_opts;
if (!old_opts)
old_opts = "";
if (strlen(old_opts) + strlen(s) + 10 >= sizeof(new_opts)) {
nfs_error(_("%s: excessively long option argument\n"),
progname);
goto fail;
}
snprintf(new_opts, sizeof(new_opts), "%s%saddr=%s",
old_opts, *old_opts ? "," : "", s);
*extra_opts = xstrdup(new_opts);
/* Set default options.
* rsize/wsize and timeo are left 0 in order to
* let the kernel decide.
*/
memset(&data, 0, sizeof(data));
data.retrans = 3;
data.acregmin = 3;
data.acregmax = 60;
data.acdirmin = 30;
data.acdirmax = 60;
data.proto = IPPROTO_TCP;
bg = 0;
soft = 0;
intr = NFS4_MOUNT_INTR;
nocto = 0;
noac = 0;
unshared = 0;
retry = -1;
/*
* NFSv4 specifies that the default port should be 2049
*/
server_addr.sin_port = htons(NFS_PORT);
/* parse options */
for (opt = strtok(old_opts, ","); opt; opt = strtok(NULL, ",")) {
if ((opteq = strchr(opt, '='))) {
val = atoi(opteq + 1);
*opteq = '\0';
if (!strcmp(opt, "rsize"))
data.rsize = val;
else if (!strcmp(opt, "wsize"))
data.wsize = val;
else if (!strcmp(opt, "timeo"))
data.timeo = val;
else if (!strcmp(opt, "retrans"))
data.retrans = val;
else if (!strcmp(opt, "acregmin"))
data.acregmin = val;
else if (!strcmp(opt, "acregmax"))
data.acregmax = val;
else if (!strcmp(opt, "acdirmin"))
data.acdirmin = val;
else if (!strcmp(opt, "acdirmax"))
data.acdirmax = val;
else if (!strcmp(opt, "actimeo")) {
data.acregmin = val;
data.acregmax = val;
data.acdirmin = val;
data.acdirmax = val;
}
else if (!strcmp(opt, "retry"))
retry = val;
else if (!strcmp(opt, "port"))
server_addr.sin_port = htons(val);
else if (!strcmp(opt, "proto")) {
if (!strncmp(opteq+1, "tcp", 3))
data.proto = IPPROTO_TCP;
else if (!strncmp(opteq+1, "udp", 3))
data.proto = IPPROTO_UDP;
else
printf(_("Warning: Unrecognized proto= option.\n"));
} else if (!strcmp(opt, "clientaddr")) {
if (strlen(opteq+1) >= sizeof(ip_addr))
printf(_("Invalid client address %s"),
opteq+1);
strncpy(ip_addr,opteq+1, sizeof(ip_addr));
ip_addr[sizeof(ip_addr)-1] = '\0';
ip_addr_in_opts = 1;
} else if (!strcmp(opt, "sec")) {
num_flavour = parse_sec(opteq+1, pseudoflavour);
if (!num_flavour)
goto fail;
} else if (!strcmp(opt, "addr") || sloppy) {
/* ignore */;
} else {
printf(_("unknown nfs mount parameter: "
"%s=%d\n"), opt, val);
goto fail;
}
} else {
val = 1;
if (!strncmp(opt, "no", 2)) {
val = 0;
opt += 2;
}
if (!strcmp(opt, "bg"))
bg = val;
else if (!strcmp(opt, "fg"))
bg = !val;
else if (!strcmp(opt, "soft"))
soft = val;
else if (!strcmp(opt, "hard"))
soft = !val;
else if (!strcmp(opt, "intr"))
intr = val;
else if (!strcmp(opt, "cto"))
nocto = !val;
else if (!strcmp(opt, "ac"))
noac = !val;
else if (!strcmp(opt, "sharecache"))
unshared = !val;
else if (!sloppy) {
printf(_("unknown nfs mount option: %s%s\n"),
val ? "" : "no", opt);
goto fail;
}
}
}
/* if retry is still -1, then it wasn't set via an option */
if (retry == -1) {
if (bg)
retry = 10000; /* 10000 mins == ~1 week */
else
retry = 2; /* 2 min default on fg mounts */
}
data.flags = (soft ? NFS4_MOUNT_SOFT : 0)
| (intr ? NFS4_MOUNT_INTR : 0)
| (nocto ? NFS4_MOUNT_NOCTO : 0)
| (noac ? NFS4_MOUNT_NOAC : 0)
| (unshared ? NFS4_MOUNT_UNSHARED : 0);
/*
* Give a warning if the rpc.idmapd daemon is not running
*/
#if 0
/* We shouldn't have these checks as nothing in this package
* creates the files that are checked
*/
idmapd_check();
if (num_flavour == 0)
pseudoflavour[num_flavour++] = AUTH_UNIX;
else {
/*
* ditto with rpc.gssd daemon
*/
gssd_check();
}
#endif
data.auth_flavourlen = num_flavour;
data.auth_flavours = pseudoflavour;
data.client_addr.data = ip_addr;
data.client_addr.len = strlen(ip_addr);
data.mnt_path.data = dirname;
data.mnt_path.len = strlen(dirname);
data.hostname.data = hostname;
data.hostname.len = strlen(hostname);
data.host_addr = (struct sockaddr *)&server_addr;
data.host_addrlen = sizeof(server_addr);
#ifdef NFS_MOUNT_DEBUG
printf(_("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n"),
data.rsize, data.wsize, data.timeo, data.retrans);
printf(_("acreg (min, max) = (%d, %d), acdir (min, max) = (%d, %d)\n"),
data.acregmin, data.acregmax, data.acdirmin, data.acdirmax);
printf(_("port = %d, bg = %d, retry = %d, flags = %.8x\n"),
ntohs(server_addr.sin_port), bg, retry, data.flags);
printf(_("soft = %d, intr = %d, nocto = %d, noac = %d, "
"nosharecache = %d\n"),
(data.flags & NFS4_MOUNT_SOFT) != 0,
(data.flags & NFS4_MOUNT_INTR) != 0,
(data.flags & NFS4_MOUNT_NOCTO) != 0,
(data.flags & NFS4_MOUNT_NOAC) != 0,
(data.flags & NFS4_MOUNT_UNSHARED) != 0);
if (num_flavour > 0) {
int pf_cnt, i;
printf(_("sec = "));
for (pf_cnt = 0; pf_cnt < num_flavour; pf_cnt++) {
for (i = 0; i < flav_map_size; i++) {
if (flav_map[i].fnum == pseudoflavour[pf_cnt]) {
printf("%s", flav_map[i].flavour);
break;
}
}
printf("%s", (pf_cnt < num_flavour-1) ? ":" : "\n");
}
}
printf(_("proto = %s\n"), (data.proto == IPPROTO_TCP) ? _("tcp") : _("udp"));
#endif
timeout = time(NULL) + 60 * retry;
data.version = NFS4_MOUNT_VERSION;
for (;;) {
if (verbose) {
printf(_("%s: pinging: prog %d vers %d prot %s port %d\n"),
progname, NFS_PROGRAM, 4,
data.proto == IPPROTO_UDP ? "udp" : "tcp",
ntohs(server_addr.sin_port));
}
client_addr.sin_family = 0;
client_addr.sin_addr.s_addr = 0;
clnt_ping(&server_addr, NFS_PROGRAM, 4, data.proto, &client_addr);
if (rpc_createerr.cf_stat == RPC_SUCCESS) {
if (!ip_addr_in_opts &&
client_addr.sin_family != 0 &&
client_addr.sin_addr.s_addr != 0) {
snprintf(ip_addr, sizeof(ip_addr), "%s",
inet_ntoa(client_addr.sin_addr));
data.client_addr.len = strlen(ip_addr);
}
break;
}
switch(rpc_createerr.cf_stat){
case RPC_TIMEDOUT:
break;
case RPC_SYSTEMERROR:
if (errno == ETIMEDOUT)
break;
default:
rpc_mount_errors(hostname, 0, bg);
goto fail;
}
if (bg && !running_bg) {
if (retry > 0)
retval = EX_BG;
goto fail;
}
t = time(NULL);
if (t >= timeout) {
rpc_mount_errors(hostname, 0, bg);
goto fail;
}
rpc_mount_errors(hostname, 1, bg);
continue;
}
if (!fake) {
if (mount(spec, node, "nfs4",
flags & ~(MS_USER|MS_USERS), &data)) {
mount_error(spec, node, errno);
goto fail;
}
}
return EX_SUCCESS;
fail:
return retval;
}
int
nfsmount(const char *spec, const char *node, int flags,
char **extra_opts, int fake, int running_bg)
{
char hostdir[1024];
char *hostname, *dirname, *old_opts, *mounthost = NULL;
char new_opts[1024], cbuf[1024];
static struct nfs_mount_data data;
int val;
static int doonce = 0;
clnt_addr_t mnt_server = { &mounthost, };
clnt_addr_t nfs_server = { &hostname, };
struct sockaddr_in *nfs_saddr = &nfs_server.saddr;
struct pmap *mnt_pmap = &mnt_server.pmap,
*nfs_pmap = &nfs_server.pmap;
struct pmap save_mnt, save_nfs;
int fsock = -1;
mntres_t mntres;
struct stat statbuf;
char *s;
int bg, retry;
int retval = EX_FAIL;
time_t t;
time_t prevt;
time_t timeout;
if (strlen(spec) >= sizeof(hostdir)) {
nfs_error(_("%s: excessively long host:dir argument"),
progname);
goto fail;
}
strcpy(hostdir, spec);
if ((s = strchr(hostdir, ':'))) {
hostname = hostdir;
dirname = s + 1;
*s = '\0';
/* Ignore all but first hostname in replicated mounts
until they can be fully supported. ([email protected]) */
if ((s = strchr(hostdir, ','))) {
*s = '\0';
nfs_error(_("%s: warning: "
"multiple hostnames not supported"),
progname);
}
} else {
nfs_error(_("%s: directory to mount not in host:dir format"),
progname);
goto fail;
}
if (!nfs_gethostbyname(hostname, nfs_saddr))
goto fail;
mounthost = hostname;
memcpy (&mnt_server.saddr, nfs_saddr, sizeof (mnt_server.saddr));
/* add IP address to mtab options for use when unmounting */
s = inet_ntoa(nfs_saddr->sin_addr);
old_opts = *extra_opts;
if (!old_opts)
old_opts = "";
/* Set default options.
* rsize/wsize (and bsize, for ver >= 3) are left 0 in order to
* let the kernel decide.
* timeo is filled in after we know whether it'll be TCP or UDP. */
memset(&data, 0, sizeof(data));
data.acregmin = 3;
data.acregmax = 60;
data.acdirmin = 30;
data.acdirmax = 60;
#if NFS_MOUNT_VERSION >= 2
data.namlen = NAME_MAX;
#endif
bg = 0;
retry = -1;
memset(mnt_pmap, 0, sizeof(*mnt_pmap));
mnt_pmap->pm_prog = MOUNTPROG;
memset(nfs_pmap, 0, sizeof(*nfs_pmap));
nfs_pmap->pm_prog = NFS_PROGRAM;
/* parse options */
new_opts[0] = 0;
if (!parse_options(old_opts, &data, &bg, &retry, &mnt_server, &nfs_server,
new_opts, sizeof(new_opts)))
goto fail;
if (!nfsmnt_check_compat(nfs_pmap, mnt_pmap))
goto fail;
if (retry == -1) {
if (bg)
retry = 10000; /* 10000 mins == ~1 week*/
else
retry = 2; /* 2 min default on fg mounts */
}
#ifdef NFS_MOUNT_DEBUG
printf(_("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n"),
data.rsize, data.wsize, data.timeo, data.retrans);
printf(_("acreg (min, max) = (%d, %d), acdir (min, max) = (%d, %d)\n"),
data.acregmin, data.acregmax, data.acdirmin, data.acdirmax);
printf(_("port = %lu, bg = %d, retry = %d, flags = %.8x\n"),
nfs_pmap->pm_port, bg, retry, data.flags);
printf(_("mountprog = %lu, mountvers = %lu, nfsprog = %lu, nfsvers = %lu\n"),
mnt_pmap->pm_prog, mnt_pmap->pm_vers,
nfs_pmap->pm_prog, nfs_pmap->pm_vers);
printf(_("soft = %d, intr = %d, posix = %d, nocto = %d, noac = %d"),
(data.flags & NFS_MOUNT_SOFT) != 0,
(data.flags & NFS_MOUNT_INTR) != 0,
(data.flags & NFS_MOUNT_POSIX) != 0,
(data.flags & NFS_MOUNT_NOCTO) != 0,
(data.flags & NFS_MOUNT_NOAC) != 0);
#if NFS_MOUNT_VERSION >= 2
printf(_(", tcp = %d"),
(data.flags & NFS_MOUNT_TCP) != 0);
#endif
#if NFS_MOUNT_VERSION >= 4
printf(_(", noacl = %d"), (data.flags & NFS_MOUNT_NOACL) != 0);
#endif
#if NFS_MOUNT_VERSION >= 5
printf(_(", sec = %u"), data.pseudoflavor);
printf(_(", readdirplus = %d"), (data.flags & NFS_MOUNT_NORDIRPLUS) != 0);
#endif
printf("\n");
#endif
data.version = nfs_mount_data_version;
if (flags & MS_REMOUNT)
goto out_ok;
/* create mount deamon client */
/*
* The following loop implements the mount retries. On the first
* call, "running_bg" is 0. When the mount times out, and the
* "bg" option is set, the exit status EX_BG will be returned.
* For a backgrounded mount, there will be a second call by the
* child process with "running_bg" set to 1.
*
* The case where the mount point is not present and the "bg"
* option is set, is treated as a timeout. This is done to
* support nested mounts.
*
* The "retry" count specified by the user is the number of
* minutes to retry before giving up.
*
* Only the first error message will be displayed.
*/
timeout = time(NULL) + 60 * retry;
prevt = 0;
t = 30;
val = 1;
memcpy(&save_nfs, nfs_pmap, sizeof(save_nfs));
memcpy(&save_mnt, mnt_pmap, sizeof(save_mnt));
for (;;) {
if (bg && stat(node, &statbuf) == -1) {
/* no mount point yet - sleep */
if (running_bg) {
sleep(val); /* 1, 2, 4, 8, 16, 30, ... */
val *= 2;
if (val > 30)
val = 30;
}
} else {
int stat;
/* be careful not to use too many CPU cycles */
if (t - prevt < 30)
sleep(30);
stat = nfs_call_mount(&mnt_server, &nfs_server,
&dirname, &mntres);
if (stat)
break;
memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
prevt = t;
}
if (!bg) {
switch(rpc_createerr.cf_stat){
case RPC_TIMEDOUT:
break;
case RPC_SYSTEMERROR:
if (errno == ETIMEDOUT)
break;
default:
rpc_mount_errors(*nfs_server.hostname, 0, bg);
goto fail;
}
t = time(NULL);
if (t >= timeout) {
rpc_mount_errors(*nfs_server.hostname, 0, bg);
goto fail;
}
rpc_mount_errors(*nfs_server.hostname, 1, bg);
continue;
}
if (!running_bg) {
if (retry > 0)
retval = EX_BG;
goto fail;
}
t = time(NULL);
if (t >= timeout) {
rpc_mount_errors(*nfs_server.hostname, 0, bg);
goto fail;
}
if (doonce++ < 1)
rpc_mount_errors(*nfs_server.hostname, 1, bg);
}
if (mnt_pmap->pm_vers <= 2) {
if (mntres.nfsv2.fhs_status != 0) {
nfs_error(_("%s: %s:%s failed, reason given by server: %s"),
progname, hostname, dirname,
nfs_strerror(mntres.nfsv2.fhs_status));
goto fail;
}
memcpy(data.root.data,
(char *) mntres.nfsv2.fhstatus_u.fhs_fhandle,
NFS_FHSIZE);
#if NFS_MOUNT_VERSION >= 4
data.root.size = NFS_FHSIZE;
memcpy(data.old_root.data,
(char *) mntres.nfsv2.fhstatus_u.fhs_fhandle,
NFS_FHSIZE);
#endif
} else {
#if NFS_MOUNT_VERSION >= 4
mountres3_ok *mountres;
fhandle3 *fhandle;
int i, n_flavors, *flavor, yum = 0;
if (mntres.nfsv3.fhs_status != 0) {
nfs_error(_("%s: %s:%s failed, reason given by server: %s"),
progname, hostname, dirname,
nfs_strerror(mntres.nfsv3.fhs_status));
goto fail;
}
#if NFS_MOUNT_VERSION >= 5
mountres = &mntres.nfsv3.mountres3_u.mountinfo;
n_flavors = mountres->auth_flavors.auth_flavors_len;
if (n_flavors <= 0)
goto noauth_flavors;
flavor = mountres->auth_flavors.auth_flavors_val;
for (i = 0; i < n_flavors; ++i) {
/*
* Per RFC2623, section 2.7, we should prefer the
* flavour listed first.
* If no flavour requested, use the first simple
* flavour that is offered.
*/
if (! (data.flags & NFS_MOUNT_SECFLAVOUR) &&
(flavor[i] == AUTH_SYS ||
flavor[i] == AUTH_NONE)) {
data.pseudoflavor = flavor[i];
data.flags |= NFS_MOUNT_SECFLAVOUR;
}
if (flavor[i] == data.pseudoflavor)
yum = 1;
#ifdef NFS_MOUNT_DEBUG
printf(_("auth flavor %d: %d\n"), i, flavor[i]);
#endif
}
if (!yum) {
nfs_error(_("%s: %s:%s failed, security flavor "
"not supported"),
progname, hostname, dirname);
/* server has registered us in rmtab, send umount */
nfs_call_umount(&mnt_server, &dirname);
goto fail;
}
noauth_flavors:
#endif
fhandle = &mntres.nfsv3.mountres3_u.mountinfo.fhandle;
memset(data.old_root.data, 0, NFS_FHSIZE);
memset(&data.root, 0, sizeof(data.root));
data.root.size = fhandle->fhandle3_len;
memcpy(data.root.data,
(char *) fhandle->fhandle3_val,
fhandle->fhandle3_len);
data.flags |= NFS_MOUNT_VER3;
#endif
}
if (nfs_mount_data_version == 1) {
/* create nfs socket for kernel */
if (nfs_pmap->pm_prot == IPPROTO_TCP)
fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
else
fsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fsock < 0) {
perror(_("nfs socket"));
goto fail;
}
if (bindresvport(fsock, 0) < 0) {
perror(_("nfs bindresvport"));
goto fail;
}
}
#ifdef NFS_MOUNT_DEBUG
printf(_("using port %lu for nfs deamon\n"), nfs_pmap->pm_port);
#endif
nfs_saddr->sin_port = htons(nfs_pmap->pm_port);
/*
* connect() the socket for kernels 1.3.10 and below only,
* to avoid problems with multihomed hosts.
* --Swen
*/
if (linux_version_code() <= MAKE_VERSION(1, 3, 10) && fsock != -1
&& connect(fsock, (struct sockaddr *) nfs_saddr,
sizeof (*nfs_saddr)) < 0) {
perror(_("nfs connect"));
goto fail;
}
#if NFS_MOUNT_VERSION >= 2
if (nfs_pmap->pm_prot == IPPROTO_TCP)
data.flags |= NFS_MOUNT_TCP;
else
data.flags &= ~NFS_MOUNT_TCP;
#endif
/* prepare data structure for kernel */
data.fd = fsock;
memcpy((char *) &data.addr, (char *) nfs_saddr, sizeof(data.addr));
strncpy(data.hostname, hostname, sizeof(data.hostname));
out_ok:
/* Ensure we have enough padding for the following strcat()s */
if (strlen(new_opts) + strlen(s) + 30 >= sizeof(new_opts)) {
nfs_error(_("%s: excessively long option argument"),
progname);
goto fail;
}
snprintf(cbuf, sizeof(cbuf)-1, "addr=%s", s);
strcat(new_opts, cbuf);
*extra_opts = xstrdup(new_opts);
if (!fake && !(data.flags & NFS_MOUNT_NONLM)) {
if (!start_statd()) {
nfs_error(_("%s: rpc.statd is not running but is "
"required for remote locking.\n"
" Either use '-o nolock' to keep "
"locks local, or start statd."),
progname);
goto fail;
}
}
if (!fake) {
if (mount(spec, node, "nfs",
flags & ~(MS_USER|MS_USERS), &data)) {
mount_error(spec, node, errno);
goto fail;
}
}
return EX_SUCCESS;
/* abort */
fail:
if (fsock != -1)
close(fsock);
return retval;
}