/*
 * nfsmount/main.c
 */

#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <arpa/inet.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>

#include <linux/nfs_mount.h>

#include "nfsmount.h"
#include "sunrpc.h"
#include "dummypmap.h"

static char *progname;

static struct nfs_mount_data mount_data = {
	.version = NFS_MOUNT_VERSION,
	.flags = NFS_MOUNT_NONLM | NFS_MOUNT_VER3 | NFS_MOUNT_TCP,
	.rsize = 0,		/* Server's choice */
	.wsize = 0,		/* Server's choice */
	.timeo = 7,
	.retrans = 3,
	.acregmin = 3,
	.acregmax = 60,
	.acdirmin = 30,
	.acdirmax = 60,
	.namlen = NAME_MAX,
};

__u32 nfs_port;

static struct int_opts {
	char *name;
	int  *val;
} int_opts[] = {
	{ "port",	&nfs_port },
	{ "rsize",	&mount_data.rsize },
	{ "wsize",	&mount_data.wsize },
	{ "timeo",	&mount_data.timeo },
	{ "retrans",	&mount_data.retrans },
	{ "acregmin",	&mount_data.acregmin },
	{ "acregmax",	&mount_data.acregmax },
	{ "acdirmin",	&mount_data.acdirmin },
	{ "acdirmax",	&mount_data.acdirmax },
	{ NULL,		NULL }
};

static struct bool_opts {
	char *name;
	int  and_mask;
	int  or_mask;
} bool_opts[] = {
	{ "soft",	~NFS_MOUNT_SOFT,	NFS_MOUNT_SOFT },
	{ "hard",	~NFS_MOUNT_SOFT,	0 },
	{ "intr",	~NFS_MOUNT_INTR,	NFS_MOUNT_INTR },
	{ "nointr",	~NFS_MOUNT_INTR,	0 },
	{ "posix",	~NFS_MOUNT_POSIX,	NFS_MOUNT_POSIX },
	{ "noposix",	~NFS_MOUNT_POSIX,	0 },
	{ "cto",	~NFS_MOUNT_NOCTO,	0 },
	{ "nocto",	~NFS_MOUNT_NOCTO,	NFS_MOUNT_NOCTO },
	{ "ac",		~NFS_MOUNT_NOAC,	0 },
	{ "noac",	~NFS_MOUNT_NOAC,	NFS_MOUNT_NOAC },
	{ "lock",	~NFS_MOUNT_NONLM,	0 },
	{ "nolock",	~NFS_MOUNT_NONLM,	NFS_MOUNT_NONLM },
	{ "v2",		~NFS_MOUNT_VER3,	0 },
	{ "v3",		~NFS_MOUNT_VER3,	NFS_MOUNT_VER3 },
	{ "udp",	~NFS_MOUNT_TCP,		0 },
	{ "tcp",	~NFS_MOUNT_TCP,		NFS_MOUNT_TCP },
	{ "broken_suid",~NFS_MOUNT_BROKEN_SUID,	NFS_MOUNT_BROKEN_SUID },
	{ "ro",		~NFS_MOUNT_KLIBC_RONLY, NFS_MOUNT_KLIBC_RONLY },
	{ "rw",		~NFS_MOUNT_KLIBC_RONLY,	0 },
	{ NULL,		0,			0 }
};

static int parse_int(const char *val, const char *ctx)
{
	char *end;
	int ret;

	ret = (int) strtoul(val, &end, 0);
	if (*val == '\0' || *end != '\0') {
		fprintf(stderr, "%s: invalid value for %s\n", val, ctx);
		exit(1);
	}
	return ret;
}

static void parse_opts(char *opts)
{
	char *cp, *val;

	while ((cp = strsep(&opts, ",")) != NULL) {
		if (*cp == '\0')
			continue;
		if ((val = strchr(cp, '=')) != NULL) {
			struct int_opts *opts = int_opts;
			*val++ = '\0';
			while (opts->name && strcmp(opts->name, cp) != 0)
				opts++;
			if (opts->name)
				*(opts->val) = parse_int(val, opts->name);
			else {
				fprintf(stderr, "%s: bad option '%s'\n",
					progname, cp);
				exit(1);
			}
		} else {
			struct bool_opts *opts = bool_opts;
			while (opts->name && strcmp(opts->name, cp) != 0)
				opts++;
			if (opts->name) {
				mount_data.flags &= opts->and_mask;
				mount_data.flags |= opts->or_mask;
			} else {
				fprintf(stderr, "%s: bad option '%s'\n",
					progname, cp);
				exit(1);
			}
		}
	}
}

static __u32 parse_addr(const char *ip)
{
	struct in_addr in;
	if (inet_aton(ip, &in) == 0) {
		fprintf(stderr, "%s: can't parse IP address '%s'\n",
			progname, ip);
		exit(1);
	}
	return in.s_addr;
}

static void check_path(const char *path)
{
	struct stat st;

	if (stat(path, &st) == -1) {
		perror("stat");
		exit(1);
	}
	else if (!S_ISDIR(st.st_mode)) {
		fprintf(stderr, "%s: '%s' not a directory\n",
			progname, path);
		exit(1);
	}
}

int main(int argc, char *argv[])
	__attribute__ ((weak, alias ("nfsmount_main")));

int nfsmount_main(int argc, char *argv[])
{
	struct timeval now;
	__u32 server = 0;
	char *rem_name;
	char *rem_path;
	char *hostname;
	char *path;
	int c;
	int spoof_portmap = 0;
	FILE *portmap_file = NULL;

	progname = argv[0];

	gettimeofday(&now, NULL);
	srand48(now.tv_usec ^ (now.tv_sec << 24));

	while ((c = getopt(argc, argv, "o:p:")) != EOF) {
		switch (c) {
		case 'o':
			parse_opts(optarg);
			break;
		case 'p':
			spoof_portmap = 1;
			portmap_file  = fopen(optarg, "w");
			break;
		case '?':
			fprintf(stderr, "%s: invalid option -%c\n",
				progname, optopt);
			exit(1);
		}
	}

	if (optind == argc) {
		fprintf(stderr, "%s: need a path\n", progname);
		exit(1);
	}

	hostname = rem_path = argv[optind];

	if ((rem_name = strdup(rem_path)) == NULL) {
		perror("strdup");
		exit(1);
	}

	if ((rem_path = strchr(rem_path, ':')) == NULL) {
		fprintf(stderr, "%s: need a server\n", progname);
		exit(1);
	}

	*rem_path++ = '\0';

	if (*rem_path != '/') {
		fprintf(stderr, "%s: need a path\n", progname);
		exit(1);
	}

	server = parse_addr(hostname);

	if (optind <= argc - 2) {
		path = argv[optind + 1];
	} else {
		path = "/nfs_root";
	}

	check_path(path);

	if ( spoof_portmap ) {
		int sock = bind_portmap();

		if ( sock == -1 ) {
			if ( errno == EINVAL || errno == EADDRINUSE )
				spoof_portmap = 0; /* Assume not needed */
			else {
				fprintf(stderr,
					"%s: portmap spoofing failed\n",
					progname);
				exit(1);
			}
		} else {
			spoof_portmap = fork();
			if ( spoof_portmap == -1 ) {
				fprintf(stderr, "%s: cannot fork\n", progname);
				exit(1);
			} else if ( spoof_portmap == 0 ) {
				/* Child process */
				dummy_portmap(sock, portmap_file);
				_exit(255); /* Error */
			} else {
				/* Parent process */
				close(sock);
			}
		}
	}

	if (nfs_mount(rem_name, hostname, server, rem_path, path,
		      &mount_data) != 0)
		return 1;

	/* If we set up the spoofer, tear it down now */
	if ( spoof_portmap ) {
		kill(SIGTERM, spoof_portmap);
		while ( waitpid(spoof_portmap, NULL, 0) == -1 &&
			errno == EINTR );
	}

	free(rem_name);

	return 0;
}