/*

 * Copyright 2011 Oracle.  All rights reserved.

 *

 * This file is part of fedfs-utils.

 *

 * fedfs-utils is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2.0 as

 * published by the Free Software Foundation.

 *

 * fedfs-utils is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License version 2.0 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * version 2.0 along with fedfs-utils.  If not, see:

 *

 *	http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/mount.h>

#include <sys/wait.h>

#include <stdbool.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <stdio.h>

#include <libgen.h>

#include <errno.h>

#include <getopt.h>

#include <locale.h>

#include <netdb.h>

#include <langinfo.h>

#include "fedfs-nls.h"

#include "fedfs-getsrvinfo.h"

#include "fedfs-gpl-boiler.h"

/**

 * Top-level directory on client under which we mount NFSv4 domain roots

 */

#define FEDFS_NFS4_TLDIR		"nfs4"

/**

 * Name of SRV record containing NFSv4 FedFS root

 */

#define FEDFS_NFS_DOMAINROOT	"_nfs-domainroot._tcp"

/**

 * Export path of NFSv4 FedFS root

 */

#define FEDFS_NFS_EXPORTPATH	"/.domainroot"

/**

 * Pathname to mount.nfs

 */

#define MOUNT_NFS_EXECUTABLE		"/sbin/mount.nfs"

/**

 * Mount status values, lifted from util-linux

 */

enum {

	EX_SUCCESS	= 0,

	EX_USAGE	= 1,

	EX_FAIL		= 32,

};

static char *progname;

static int nomtab;

static int verbose;

static _Bool readonly;

static _Bool sloppy;

static _Bool fake;

/**

 * Short form command line options

 */

static const char fedfs_opts[] = "fhno:rsvVw";

/**

 * Long form command line options

 */

static const struct option fedfs_longopts[] =

{

	{ "fake", 0, NULL, 'f' },

	{ "help", 0, NULL, 'h' },

	{ "no-mtab", 0, NULL, 'n' },

	{ "options", 1, NULL, 'o' },

	{ "read-only", 0, NULL, 'r' },

	{ "read-write", 0, NULL, 'w' },

	{ "ro", 0, NULL, 'r' },

	{ "rw", 0, NULL, 'w' },

	{ "sloppy", 0, NULL, 's' },

	{ "verbose", 0, NULL, 'v' },

	{ "version", 0, NULL, 'V' },

	{ NULL, 0, NULL, 0 }

};

/**

 * Display mount.fedfs usage message

 */

static void

mount_usage(void)

{

	printf(_("\nUsage: %s remotedir localdir [-fhnrsvVw]\n\n"), progname);

	printf(_("options:\n"));

	printf(_("\t-f\t\tFake mount, do not actually mount\n"));

	printf(_("\t-h\t\tPrint this help\n"));

	printf(_("\t-n\t\tDo not update /etc/mtab\n"));

	printf(_("\t-r\t\tMount file system readonly\n"));

	printf(_("\t-s\t\tTolerate sloppy mount options\n"));

	printf(_("\t-v\t\tVerbose\n"));

	printf(_("\t-V\t\tPrint version\n"));

	printf(_("\t-w\t\tMount file system read-write\n"));

	printf("%s", fedfs_gpl_boilerplate);

}

/**

 * Concatenate three strings

 *

 * @param s NUL-terminated C string

 * @param t NUL-terminated C string

 * @param u NUL-terminated C string

 * @return pointer to NUL-terminated C string or NULL

 *

 * Caller must free the returned string with free(3).  Always frees

 * its first arg - typical use: s = xstrconcat3(s,t,u);

 *

 * Lifted from util-linux.

 */

static char *

xstrconcat3(char *s, const char *t, const char *u)

{

	_Bool free_s = true;

	char *result;

	if (s == NULL) {

		s = "";

		free_s = false;

	}

	if (t == NULL)

		t = "";

	if (u == NULL)

		u = "";

	result = malloc(strlen(s) + strlen(t) + strlen(u) + 1);

	if (result == NULL)

		goto out;

	strcpy(result, s);

	strcat(result, t);

	strcat(result, u);

out:

	if (free_s)

		free(s);

	return result;

}

/**

 * Exec mount.nfs

 *

 * @param server NUL-terminated C string containing name of NFS server

 * @param port server port to use when mounting

 * @param domainname NUL-terminated C string containing FedFS domain name

 * @param export_path NUL-terminated C string containing server export path

 * @param mounted_on_dir NUL-terminated C string containing local mounted-on directory

 * @param text_options NUL-terminated C string containing user's mount options

 *

 */

static void

exec_mount_nfs4(const char *server, unsigned short port,

		const char *domainname, const char *export_path,

		const char *mounted_on_dir, const char *text_options)

{

	static char special[2048];

	static char options[2048];

	char *args[16];

	int count = 0;

	snprintf(special, sizeof(special), "%s:%s/%s%s", server,

			FEDFS_NFS_EXPORTPATH, domainname, export_path);

	if (text_options != NULL && strcmp(text_options, "") != 0)

		snprintf(options, sizeof(options), "%s,vers=4,fg,port=%u",

				text_options, port);

	else

		snprintf(options, sizeof(options), "vers=4,fg,port=%u", port);

	if (verbose) {

		printf(_("%s: Special device:       %s\n"),

			progname, special);

		printf(_("%s: Mounted-on directory: %s\n"),

			progname, mounted_on_dir);

		printf(_("%s: Mount options:        %s\n"),

			progname, options);

	}

	args[count++] = MOUNT_NFS_EXECUTABLE;

	args[count++] = special;

	args[count++] = (char *)mounted_on_dir;

	if (verbose)

		args[count++] = "-v";

	if (fake)

		args[count++] = "-f";

	if (nomtab)

		args[count++] = "-n";

	if (readonly)

		args[count++] = "-r";

	if (sloppy)

		args[count++] = "-s";

	args[count++] = "-o";

	args[count++] = options;

	args[count] = NULL;

	execv(args[0], args);

}

/**

 * Mount a FedFS domain root via NFSv4

 *

 * @param domainname NUL-terminated C string containing FedFS domain name

 * @param export_path NUL-terminated C string containing server export path

 * @param mounted_on_dir NUL-terminated C string containing local mounted-on directory

 * @param text_options NUL-terminated C string containing user's mount options

 * @return exit status code from the mount.nfs command

 *

 * Construct the server:/export string and the mounted-on directory string

 * based on the DNS SRV query results, then fork and exec mount.nfs to do

 * the actual mount request.

 */

static int

nfs4_mount(const char *domainname, const char *export_path,

		const char *mounted_on_dir, const char *text_options)

{

	struct srvinfo *tmp, *si = NULL;

	int error, status;

	status = EX_FAIL;

	error = getsrvinfo(FEDFS_NFS_DOMAINROOT, domainname, &si);

	switch (error) {

	case ESI_SUCCESS:

		break;

	case ESI_NONAME:

		fprintf(stderr, _("%s: Domain name %s not found\n"),

			progname, domainname);

		goto out;

	case ESI_SERVICE:

		fprintf(stderr, _("%s: No FedFS domain root available for %s\n"),

			progname, domainname);

		goto out;

	default:

		fprintf(stderr, _("%s: Failed to resolve %s: %s\n"),

			progname, domainname, gsi_strerror(error));

		goto out;

	}

	/*

	 * The srvinfo list is already in RFC 2782 sorted order.  Try each

	 * SRV record once, in the foreground.  Go with the first one that

	 * works.

	 */

	for (tmp = si; tmp != NULL; tmp = tmp->si_next) {

		pid_t pid;

		pid = fork();

		switch (pid) {

		case 0:

			exec_mount_nfs4(tmp->si_target, tmp->si_port,

					domainname, export_path, mounted_on_dir,

					text_options);

			/*NOTREACHED*/

			fprintf(stderr, _("%s: Failed to exec: %s\n"),

				progname, strerror(errno));

			exit(EX_FAIL);

		case -1:

			fprintf(stderr, _("%s: Failed to fork: %s\n"),

				progname, strerror(errno));

			goto out;

		default:

			waitpid(pid, &status, 0);

			if (status == EX_SUCCESS)

				goto out;

		}

	}

out:

	freesrvinfo(si);

	return status;

}

/**

 * Try one mount request

 *

 * @param source NUL-terminated C string containing name of "special device"

 * @param target NUL-terminated C string containing local mounted-on directory

 * @param text_options NUL-terminated C string containing user's mount options

 * @return an exit status code

 *

 * Parse the pathname in "source."  It contains the file system protocol

 * and FedFS domain name.  Then pass these arguments to the appropriate

 * mount helper subcommand.

 */

static int

try_mount(const char *source, const char *target, const char *text_options)

{

	char *global_name, *topdir, *domainname, *remaining;

	int result;

	remaining = NULL;

	result = EX_FAIL;

	global_name = strdup(source);

	if (global_name == NULL) {

		fprintf(stderr, _("%s: Unable to parse globally useful name\n"),

				progname);

		goto out;

	}

	topdir = strtok(global_name, "/");

	if (topdir == NULL) {

		fprintf(stderr, _("%s: Invalid globally useful name: %s\n"),

			progname, source);

		goto out;

	}

	if (verbose)

		printf(_("%s: Top-level directory:  %s\n"),

			progname, topdir);

	domainname = strtok(NULL, "/");

	if (domainname == NULL) {

		fprintf(stderr, _("%s: Missing domain name in globally "

				"useful name: %s\n"), progname, source);

		goto out;

	}

	if (verbose)

		printf(_("%s: Domain name:          %s\n"),

			progname, domainname);

	remaining = strtok(NULL, "/");

	if (remaining == NULL) {

		remaining = strdup("/");

		if (remaining == NULL) {

			fprintf(stderr, _("%s: No memory\n"), progname);

			goto out;

		}

	} else {

		char *tmp;

		tmp = malloc(strlen(remaining) + 1);

		if (tmp == NULL) {

			fprintf(stderr, _("%s: No memory\n"), progname);

			remaining = NULL;

			goto out;

		}

		strcpy(tmp, "/");

		strcat(tmp, remaining);

		remaining = tmp;

	}

	if (verbose)

		printf(_("%s: Export path:          %s\n"),

			progname, remaining);

	if (strcmp(topdir, FEDFS_NFS4_TLDIR) == 0)

		result = nfs4_mount(domainname, remaining, target, text_options);

#if 0

	/* example: SMB support plugs in here */

	else if (strcmp(topdir, FEDFS_SMB_TLDIR) == 0)

		result = smb_mount(domainname, remaining, target, text_options);

#endif

	else

		fprintf(stderr, _("%s: Unrecognized file system protocol\n"), progname);

out:

	free(global_name);

	free(remaining);

	return result;

}

/**

 * Program entry point

 *

 * @param argc count of command line arguments

 * @param argv array of NUL-terminated C strings containing command line arguments

 * @return program exit status

 */

int main(int argc, char *argv[])

{

	char *source, *target, *text_options;

	int c, mnt_err;

	(void)setlocale(LC_ALL, "");

	progname = basename(argv[0]);

	if (argv[1] && argv[1][0] == '-') {

		if(argv[1][1] == 'V')

			printf("%s (VERSION_STRING)\n", progname);

		else

			mount_usage();

		exit(EX_SUCCESS);

	}

	if (argc < 3) {

		mount_usage();

		exit(EX_USAGE);

	}

	source = argv[1];

	target = argv[2];

	mnt_err = EX_USAGE;

	text_options = NULL;

	readonly = false;

	sloppy = false;

	fake = false;

	argv[2] = argv[0]; /* so that getopt error messages are correct */

	while ((c = getopt_long(argc - 2, argv + 2, fedfs_opts,

				fedfs_longopts, NULL)) != -1) {

		switch (c) {

		case 'f':

			fake = true;

			break;

		case 'n':

			++nomtab;

			break;

		case 'o':

			/* Ugh. */

			if (text_options != NULL)

				text_options = xstrconcat3(text_options, ",", optarg);

			else

				text_options = strdup(optarg);

			if (text_options == NULL) {

				fprintf(stderr, _("%s: No memory\n"), progname);

				goto out;

			}

			break;

		case 'r':

			readonly = true;

			break;

		case 's':

			sloppy = true;

			break;

		case 'v':

			++verbose;

			break;

		case 'V':

			printf("%s: (VERSION_STRING)\n", progname);

			mnt_err = EX_SUCCESS;

			goto out;

		case 'w':

			readonly = false;

			break;

		case 'h':

		default:

			mount_usage();

			goto out;

		}

	}

	/* Extra non-option words at the end are bogus...  */

	if (optind != argc - 2) {

		mount_usage();

		goto out;

	}

	if (getuid() != 0 && geteuid() != 0) {

		fprintf(stderr, _("%s: Not installed setuid - "

			    "\"user\" FedFS mounts are not supported\n"), progname);

		mnt_err = EX_FAIL;

		goto out;

	}

	mnt_err = try_mount(source, target, text_options);

out:

	free(text_options);

	exit(mnt_err);

}