/*-
 * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
 * Copyright (c) 2019 The DragonFly Project
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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/types.h>
#include <sys/stat.h>
#include <vfs/fuse/fuse_mount.h>

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <mntopts.h>
#include <err.h>

#define MOPT_FUSE_LINUX_OPTS \
	{ "default_permissions", 0, FUSE_MOUNT_DEFAULT_PERMISSIONS, 1 }, \
	{ "allow_other", 0, FUSE_MOUNT_ALLOW_OTHER, 1 }, \
	{ "max_read=", 0, FUSE_MOUNT_MAX_READ, 1 }, \
	{ "subtype=", 0, FUSE_MOUNT_SUBTYPE, 1 }

/* XXX */
#define MOPT_FUSE_LINUX_IGNORE_OPTS \
	{ "fsname=", 0, 0, 1 }, \
	{ "fd=", 0, 0, 1 }, \
	{ "rootmode=", 0, 0, 1 }, \
	{ "user_id=", 0, 0, 1 }, \
	{ "group_id=", 0, 0, 1 }, \
	\
	{ "auto_unmount", 0, 0, 1 }, \
	{ "blkdev", 0, 0, 1 }, \
	{ "blksize=", 0, 0, 1 }, \
	{ "context=", 0, 0, 1 }, \
	{ "fscontext=", 0, 0, 1 }, \
	{ "defcontext=", 0, 0, 1 }, \
	{ "rootcontext=", 0, 0, 1 }, \
	{ "user=", 0, 0, 1 }, \
	{ "-r", 0, 0, 1 }, \
	{ "ro", 0, 0, 1 }, \
	{ "rw", 0, 0, 1 }, \
	{ "suid", 0, 0, 1 }, \
	{ "nosuid", 0, 0, 1 }, \
	{ "dev", 0, 0, 1 }, \
	{ "nodev", 0, 0, 1 }, \
	{ "exec", 0, 0, 1 }, \
	{ "noexec", 0, 0, 1 }, \
	{ "async", 0, 0, 1 }, \
	{ "sync", 0, 0, 1 }, \
	{ "dirsync", 0, 0, 1 }, \
	{ "atime", 0, 0, 1 }, \
	{ "noatime", 0, 0, 1 }

static struct mntopt mopts[] = {
	MOPT_FUSE_LINUX_OPTS,
	MOPT_FUSE_LINUX_IGNORE_OPTS,
	MOPT_STDOPTS,
	MOPT_NULL
};

static void
usage(void)
{
	fprintf(stderr, "usage: mount_fusefs [-o options] fd mountpoint\n");
	exit(1);
}

static char*
get_optval(const char *ptr)
{
	char *ret = strdup(ptr);
	const char *end = strstr(ptr, ",");

	if (!end)
		return ret;

	ret[(int)(end - ptr)] = '\0';
	return ret;
}

/*
 * e.g.
 * argv[0] = "mount_fusefs"
 * argv[1] = "-o"
 * argv[2] = "max_read=...,subtype=hello"
 * argv[3] = "3"
 * argv[4] = "/mnt/fuse"
 * argv[5] = "(null)"
 */
int
main(int argc, char **argv)
{
	struct fuse_mount_info args;
	struct vfsconf vfc;
	struct stat st;
	const char *fdstr, *mntpt;
	char *ep, mntpath[MAXPATHLEN], fusedev[64];
	int error, c, fd, mntflags;

	mntflags = 0;
	memset(&args, 0, sizeof(args));

	while ((c = getopt_long(argc, argv, "ho:", NULL, NULL)) != -1) {
		switch(c) {
		case 'o':
			getmntopts(optarg, mopts, &mntflags, &args.flags);
			if (args.flags & FUSE_MOUNT_MAX_READ) {
				char *p = strstr(optarg, "max_read=");
				if (p) {
					p = get_optval(p + 9);
					args.max_read = strtol(p, NULL, 0);
					free(p);
				}
			}
			if (args.flags & FUSE_MOUNT_SUBTYPE) {
				char *p = strstr(optarg, "subtype=");
				if (p) {
					p = get_optval(p + 8);
					args.subtype = strdup(p);
					free(p);
				}
			}
			break;
		case 'h':
		default:
			usage(); /* exit */
		}
	}
	argc -= optind;
	argv += optind;

	if (argc < 2)
		usage();

	fdstr = argv[0];
	mntpt = argv[1];
	checkpath(mntpt, mntpath);

	fd = strtol(fdstr, &ep, 10);
	if (fd <= 0 || *ep != '\0')
		err(1, "Invalid FUSE fd %s", fdstr);

	if (fstat(fd, &st) == -1)
		err(1, "Failed to stat FUSE fd %d", fd);
	strcpy(fusedev, "/dev/");
	devname_r(st.st_rdev, S_IFCHR, fusedev + strlen(fusedev),
		sizeof(fusedev) - strlen(fusedev));
	if (stat(fusedev, &st) == -1)
		err(1, "Failed to stat FUSE device %s", fusedev);
	if (strncmp(fusedev, "/dev/fuse", 9))
		err(1, "Invalid FUSE device %s", fusedev);
	args.fd = fd;
	args.from = strdup(fusedev);

	error = getvfsbyname("fuse", &vfc);
	if (error && vfsisloadable("fuse")) {
		if(vfsload("fuse"))
			err(1, "vfsload(%s)", "fuse");
		endvfsent();
		error = getvfsbyname("fuse", &vfc);
	}
	if (error)
		errx(1, "%s filesystem not available", "fuse");

	if (mount(vfc.vfc_name, mntpath, mntflags, &args) == -1)
		err(1, "mount");

	return 0;
}