/* ----------------------------------------------------------------------- *

 *   

 * mount_nfs.c - Module for Linux automountd to mount an NFS filesystem,

 *               with fallback to symlinking if the path is local

 *

 *   Copyright 1997 Transmeta Corporation - All Rights Reserved

 *   Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,

 *   USA; either version 2 of the License, or (at your option) any later

 *   version; incorporated herein by reference.

 *

 * ----------------------------------------------------------------------- */

#include <stdio.h>

#include <malloc.h>

#include <netdb.h>

#include <stdlib.h>

#include <string.h>

#include <sys/param.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/vfs.h>

#include <netinet/in.h>

#include <linux/nfs.h>

#include <linux/nfs2.h>

#include <ctype.h>

#define MODULE_MOUNT

#include "automount.h"

#include "replicated.h"

#define MODPREFIX "mount(nfs): "

int mount_version = AUTOFS_MOUNT_VERSION;	/* Required by protocol */

static struct mount_mod *mount_bind = NULL;

static int init_ctr = 0;

int mount_init(void **context)

{

	/* Make sure we have the local mount method available */

	if (!mount_bind) {

		if ((mount_bind = open_mount("bind", MODPREFIX)))

			init_ctr++;

	} else

		init_ctr++;

	seed_random();

	return !mount_bind;

}

int mount_reinit(void **context)

{

	return 0;

}

int mount_mount(struct autofs_point *ap, const char *root, const char *name, int name_len,

		const char *what, const char *fstype, const char *options,

		void *context)

{

	char fullpath[PATH_MAX];

	char buf[MAX_ERR_BUF];

	struct host *this, *hosts = NULL;

	unsigned int mount_default_proto, vers;

	char *nfsoptions = NULL;

	unsigned int flags = ap->flags &

			(MOUNT_FLAG_RANDOM_SELECT | MOUNT_FLAG_USE_WEIGHT_ONLY);

	int symlink = (*name != '/' && (ap->flags & MOUNT_FLAG_SYMLINK));

	int nobind = ap->flags & MOUNT_FLAG_NOBIND;

	int len, status, err, existed = 1;

	int nosymlink = 0;

	int port = -1;

	int ro = 0;            /* Set if mount bind should be read-only */

	int rdma = 0;

	void (*mountlog)(unsigned int, const char*, ...) = &log_debug;

	if (ap->flags & MOUNT_FLAG_REMOUNT)

		return 0;

	if (defaults_get_mount_verbose())

		mountlog = &log_info;

	mountlog(ap->logopt,

		 MODPREFIX "root=%s name=%s what=%s, fstype=%s, options=%s",

		 root, name, what, fstype, options);

	mount_default_proto = defaults_get_mount_nfs_default_proto();

	vers = NFS_VERS_DEFAULT | NFS_PROTO_DEFAULT;

	if (strcmp(fstype, "nfs4") == 0)

		vers = NFS4_VERS_DEFAULT | TCP_SUPPORTED;

	else if (mount_default_proto == 4)

		vers = vers | NFS4_VERS_DEFAULT;

	/* Extract "nosymlink" pseudo-option which stops local filesystems

	 * from being symlinked.

	 *

	 * "nosymlink" is not used anymore. It is left for compatibility

	 * only (so we don't choke on it).

	 */

	if (options) {

		const char *comma;

		char *nfsp;

		int o_len = strlen(options) + 1;

		nfsp = nfsoptions = alloca(o_len + 1);

		if (!nfsoptions)

			return 1;

		memset(nfsoptions, '\0', o_len + 1);

		for (comma = options; *comma != '\0';) {

			const char *cp;

			const char *end;

			while (*comma == ',')

				comma++;

			/* Skip leading white space */

			while (*comma == ' ' || *comma == '\t')

				comma++;

			cp = comma;

			while (*comma != '\0' && *comma != ',')

				comma++;

			/* Skip trailing white space */

			end = comma - 1;

			while (*comma == ' ' || *comma == '\t')

				end--;

			o_len = end - cp + 1;

			if (_strncmp("proto=rdma", cp, o_len) == 0 ||

				   _strncmp("rdma", cp, o_len) == 0)

				rdma = 1;

			if (_strncmp("nosymlink", cp, o_len) == 0) {

				warn(ap->logopt, MODPREFIX

				     "the \"nosymlink\" option is depricated "

				     "and will soon be removed, "

				     "use the \"nobind\" option instead");

				nosymlink = 1;

			} else if (_strncmp("symlink", cp, o_len) == 0) {

				if (*name != '/')

					symlink = 1;

			} else if (_strncmp("nobind", cp, o_len) == 0) {

				nobind = 1;

			} else if (_strncmp("no-use-weight-only", cp, o_len) == 0) {

				flags &= ~MOUNT_FLAG_USE_WEIGHT_ONLY;

			} else if (_strncmp("use-weight-only", cp, o_len) == 0) {

				flags |= MOUNT_FLAG_USE_WEIGHT_ONLY;

			} else {

				/* Is any version of NFSv4 in the options */

				if (_strncmp("vers=4", cp, 6) == 0 ||

				    _strncmp("nfsvers=4", cp, 9) == 0)

					vers = NFS4_VERS_MASK | TCP_SUPPORTED;

				else if (_strncmp("vers=3", cp, o_len) == 0 ||

					 _strncmp("nfsvers=3", cp, o_len) == 0) {

					vers &= ~(NFS4_VERS_MASK | NFS_VERS_MASK);

					vers |= NFS3_REQUESTED;

				} else if (_strncmp("vers=2", cp, o_len) == 0 ||

					 _strncmp("nfsvers=2", cp, o_len) == 0) {

					vers &= ~(NFS4_VERS_MASK | NFS_VERS_MASK);

					vers |= NFS2_REQUESTED;

				} else if (strstr(cp, "port=") == cp &&

					 o_len - 5 < 25) {

					char optport[25];

					strncpy(optport, cp + 5, o_len - 5);

					optport[o_len - 5] = '\0';

					port = atoi(optport);

					if (port < 0)

						port = 0;

				} else if (_strncmp("proto=udp", cp, o_len) == 0 ||

					   _strncmp("udp", cp, o_len) == 0) {

					vers &= ~TCP_SUPPORTED;

				} else if (_strncmp("proto=udp6", cp, o_len) == 0 ||

					   _strncmp("udp6", cp, o_len) == 0) {

					vers &= ~TCP_SUPPORTED;

					vers |= UDP6_REQUESTED;

				} else if (_strncmp("proto=tcp", cp, o_len) == 0 ||

					   _strncmp("tcp", cp, o_len) == 0) {

					vers &= ~UDP_SUPPORTED;

				} else if (_strncmp("proto=tcp6", cp, o_len) == 0 ||

					   _strncmp("tcp6", cp, o_len) == 0) {

					vers &= ~UDP_SUPPORTED;

					vers |= TCP6_REQUESTED;

				}

				/* Check for options that also make sense

				   with bind mounts */

				else if (_strncmp("ro", cp, o_len) == 0)

					ro = 1;

				else if (_strncmp("rw", cp, o_len) == 0)

					ro = 0;

				/* and jump over trailing white space */

				memcpy(nfsp, cp, comma - cp + 1);

				nfsp += comma - cp + 1;

			}

		}

		/* In case both tcp and udp options were given */

		if ((vers & NFS_PROTO_MASK) == 0)

			vers |= NFS_PROTO_MASK;

		mountlog(ap->logopt, MODPREFIX

			 "nfs options=\"%s\", nobind=%d, nosymlink=%d, ro=%d",

			 nfsoptions, nobind, nosymlink, ro);

	}

	/* Construct mount point directory */

	len = mount_fullpath(fullpath, PATH_MAX, root, 0, name);

	if (!len) {

		error(ap->logopt,

		      MODPREFIX "mount point path too long");

		return 1;

	}

	if (!parse_location(ap->logopt, &hosts, what, flags)) {

		info(ap->logopt, MODPREFIX "no hosts available");

		return 1;

	}

	/*

	 * We can't probe protocol rdma so leave it to mount.nfs(8)

	 * and and suffer the delay if a server isn't available.

	 */

	if (rdma)

		goto dont_probe;

	/*

	 * If this is a singleton mount, and NFSv4 only hasn't been asked

	 * for, and the default NFS protocol is set to v4 in the autofs

	 * configuration only probe NFSv4 and let mount.nfs(8) do fallback

	 * to NFSv3 (if it can). If the NFSv4 probe fails then probe as

	 * normal.

	 *

	 * Note: some NFS servers consider it a protocol violation to use

	 * NFSv4 over UDP so if it has been requested in the mount options

	 * we can't use this at all.

	 */

	if ((hosts && !hosts->next) &&

	    mount_default_proto == 4 &&

	    (vers & NFS_VERS_MASK) != 0 &&

	    (vers & NFS4_VERS_MASK) != 0 &&

	    !(vers & UDP6_REQUESTED)) {

		unsigned int v4_probe_ok = 0;

		struct host *tmp = new_host(hosts->name, 0,

					    hosts->addr, hosts->addr_len,

					    hosts->proximity,

					    hosts->weight, hosts->options);

		if (tmp) {

			tmp->rr = hosts->rr;

			prune_host_list(ap->logopt, &tmp,

					NFS4_VERS_MASK|TCP_SUPPORTED, port);

			/* If probe succeeds just try the mount with host in hosts */

			if (tmp) {

				v4_probe_ok = 1;

				free_host_list(&tmp);

			}

		}

		if (!v4_probe_ok)

			prune_host_list(ap->logopt, &hosts, vers, port);

	} else {

		prune_host_list(ap->logopt, &hosts, vers, port);

	}

dont_probe:

	if (!hosts) {

		info(ap->logopt, MODPREFIX "no hosts available");

		return 1;

	}

	debug(ap->logopt, MODPREFIX "calling mkdir_path %s", fullpath);

	status = mkdir_path(fullpath, mp_mode);

	if (status && errno != EEXIST) {

		char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

		error(ap->logopt,

		      MODPREFIX "mkdir_path %s failed: %s", fullpath, estr);

		free_host_list(&hosts);

		return 1;

	}

	if (!status)

		existed = 0;

	this = hosts;

	while (this) {

		char *loc;

		/* Port option specified, don't try to bind */

		if (!(nosymlink || nobind) &&

		    this->proximity == PROXIMITY_LOCAL) {

			/* Local host -- do a "bind" */

			const char *bind_options;

			debug(ap->logopt,

			      MODPREFIX "%s is local, attempt bind mount",

			      name);

			bind_options = symlink ? "symlink" : ro ? "ro" : "";

			err = mount_bind->mount_mount(ap, root, name, name_len,

					       this->path, "bind", bind_options,

					       mount_bind->context);

			/* Success - we're done */

			if (!err) {

				free_host_list(&hosts);

				return 0;

			}

			/* Failed to update mtab, don't try any more */

			if (err == MNT_FORCE_FAIL)

				goto forced_fail;

			/* No hostname, can't be NFS */

			if (!this->name) {

				this = this->next;

				continue;

			}

		}

		/* Not a local host - do an NFS mount */

		if (this->rr && this->addr &&

		    !defaults_use_hostname_for_mounts()) {

			socklen_t len = INET6_ADDRSTRLEN;

			char n_buf[len + 1];

			const char *n_addr;

			n_addr = get_addr_string(this->addr, n_buf, len);

			if (!n_addr) {

				char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

				error(ap->logopt, "get_addr_string: %s", estr);

				goto forced_fail;

			}

			loc = malloc(strlen(n_addr) + strlen(this->path) + 4);

			if (!loc) {

				char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

				error(ap->logopt, "malloc: %s", estr);

				goto forced_fail;

			}

			if (this->addr->sa_family == AF_INET6) {

				strcpy(loc, "[");

				strcat(loc, n_addr);

				strcat(loc, "]");

			} else

				strcpy(loc, n_addr);

		} else {

			char *host = this->name ? this->name : "localhost";

			loc = malloc(strlen(host) + strlen(this->path) + 2);

			if (!loc) {

				char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

				error(ap->logopt, "malloc: %s", estr);

				goto forced_fail;

			}

			strcpy(loc, host);

		}

		strcat(loc, ":");

		strcat(loc, this->path);

		/* If this is a fallback from a bind mount failure

		 * check if the local NFS server is available to try

		 * and prevent lengthy mount failure waits.

		 */

		if (this->proximity == PROXIMITY_LOCAL) {

			char *host = this->name ? this->name : "localhost";

			int ret = 1;

			/* If we're using RDMA, rpc_ping will fail when

			 * nfs-server is local. Therefore, don't probe

			 * when we're using RDMA.

			 */

			if(!rdma)

				ret = rpc_ping(host, port, vers, 2, 0, RPC_CLOSE_DEFAULT);

			if (ret <= 0)

				goto next;

		}

		if (nfsoptions && *nfsoptions) {

			mountlog(ap->logopt,

				 MODPREFIX "calling mount -t %s " SLOPPY

				 "-o %s %s %s", fstype, nfsoptions, loc,

				 fullpath);

			err = spawn_mount(ap->logopt,

					  "-t", fstype, SLOPPYOPT "-o",

					  nfsoptions, loc, fullpath, NULL);

		} else {

			mountlog(ap->logopt,

				 MODPREFIX "calling mount -t %s %s %s",

				 fstype, loc, fullpath);

			err = spawn_mount(ap->logopt,

					  "-t", fstype, loc, fullpath, NULL);

		}

		if (!err) {

			debug(ap->logopt, MODPREFIX "mounted %s on %s", loc, fullpath);

			free(loc);

			free_host_list(&hosts);

			return 0;

		}

next:

		free(loc);

		this = this->next;

	}

forced_fail:

	free_host_list(&hosts);

	/* If we get here we've failed to complete the mount */

	info(ap->logopt, MODPREFIX "nfs: mount failure %s on %s", what, fullpath);

	if (ap->type != LKP_INDIRECT)

		return 1;

	if ((!(ap->flags & MOUNT_FLAG_GHOST) && name_len) || !existed)

		rmdir_path(ap, fullpath, ap->dev);

	return 1;

}

int mount_done(void *context)

{

	int rv = 0;

	if (--init_ctr == 0) {

		rv = close_mount(mount_bind);

		mount_bind = NULL;

	}

	return rv;

}