/*
  FUSE: Filesystem in Userspace
  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>

  Helper functions to create (simple) standalone programs. With the
  aid of these functions it should be possible to create full FUSE
  file system by implementing nothing but the request handlers.

  This program can be distributed under the terms of the GNU LGPLv2.
  See the file LGPL2.txt.
*/

#include "fuse_config.h"
#include "fuse_i.h"
#include "fuse_misc.h"
#include "fuse_opt.h"
#include "fuse_lowlevel.h"
#include "fuse_daemonize.h"
#include "fuse_daemonize_i.h"
#include "fuse_service.h"
#include "mount_util.h"

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <sys/param.h>

#ifdef HAVE_SERVICEMOUNT
# include <linux/types.h>
# include "fuse_service_priv.h"
#endif

#define FUSE_HELPER_OPT(t, p) \
	{ t, offsetof(struct fuse_cmdline_opts, p), 1 }

static const struct fuse_opt fuse_helper_opts[] = {
	FUSE_HELPER_OPT("-h",		show_help),
	FUSE_HELPER_OPT("--help",	show_help),
	FUSE_HELPER_OPT("-V",		show_version),
	FUSE_HELPER_OPT("--version",	show_version),
	FUSE_HELPER_OPT("-d",		debug),
	FUSE_HELPER_OPT("debug",	debug),
	FUSE_HELPER_OPT("-d",		foreground),
	FUSE_HELPER_OPT("debug",	foreground),
	FUSE_OPT_KEY("-d",		FUSE_OPT_KEY_KEEP),
	FUSE_OPT_KEY("debug",		FUSE_OPT_KEY_KEEP),
	FUSE_HELPER_OPT("-f",		foreground),
	FUSE_HELPER_OPT("-s",		singlethread),
	FUSE_HELPER_OPT("fsname=",	nodefault_subtype),
	FUSE_OPT_KEY("fsname=",		FUSE_OPT_KEY_KEEP),
#ifndef __FreeBSD__
	FUSE_HELPER_OPT("subtype=",	nodefault_subtype),
	FUSE_OPT_KEY("subtype=",	FUSE_OPT_KEY_KEEP),
#endif
	FUSE_HELPER_OPT("clone_fd",	clone_fd),
	FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
	FUSE_HELPER_OPT("max_threads=%u", max_threads),
	FUSE_OPT_END
};

struct fuse_conn_info_opts {
	int atomic_o_trunc;
	int no_remote_posix_lock;
	int no_remote_flock;
	int splice_write;
	int splice_move;
	int splice_read;
	int no_splice_write;
	int no_splice_move;
	int no_splice_read;
	int auto_inval_data;
	int no_auto_inval_data;
	int no_readdirplus;
	int no_readdirplus_auto;
	int async_dio;
	int no_async_dio;
	int writeback_cache;
	int no_writeback_cache;
	int async_read;
	int sync_read;
	unsigned max_write;
	unsigned max_readahead;
	unsigned max_background;
	unsigned congestion_threshold;
	unsigned time_gran;
	int set_max_write;
	int set_max_readahead;
	int set_max_background;
	int set_congestion_threshold;
	int set_time_gran;
};

#define CONN_OPTION(t, p, v)					\
	{ t, offsetof(struct fuse_conn_info_opts, p), v }
static const struct fuse_opt conn_info_opt_spec[] = {
	CONN_OPTION("max_write=%u", max_write, 0),
	CONN_OPTION("max_write=", set_max_write, 1),
	CONN_OPTION("max_readahead=%u", max_readahead, 0),
	CONN_OPTION("max_readahead=", set_max_readahead, 1),
	CONN_OPTION("max_background=%u", max_background, 0),
	CONN_OPTION("max_background=", set_max_background, 1),
	CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),
	CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),
	CONN_OPTION("sync_read", sync_read, 1),
	CONN_OPTION("async_read", async_read, 1),
	CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),
	CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),
	CONN_OPTION("no_remote_lock", no_remote_flock, 1),
	CONN_OPTION("no_remote_flock", no_remote_flock, 1),
	CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),
	CONN_OPTION("splice_write", splice_write, 1),
	CONN_OPTION("no_splice_write", no_splice_write, 1),
	CONN_OPTION("splice_move", splice_move, 1),
	CONN_OPTION("no_splice_move", no_splice_move, 1),
	CONN_OPTION("splice_read", splice_read, 1),
	CONN_OPTION("no_splice_read", no_splice_read, 1),
	CONN_OPTION("auto_inval_data", auto_inval_data, 1),
	CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),
	CONN_OPTION("readdirplus=no", no_readdirplus, 1),
	CONN_OPTION("readdirplus=yes", no_readdirplus, 0),
	CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),
	CONN_OPTION("readdirplus=auto", no_readdirplus, 0),
	CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),
	CONN_OPTION("async_dio", async_dio, 1),
	CONN_OPTION("no_async_dio", no_async_dio, 1),
	CONN_OPTION("writeback_cache", writeback_cache, 1),
	CONN_OPTION("no_writeback_cache", no_writeback_cache, 1),
	CONN_OPTION("time_gran=%u", time_gran, 0),
	CONN_OPTION("time_gran=", set_time_gran, 1),
	FUSE_OPT_END
};


void fuse_cmdline_help(void)
{
	printf("    -h   --help            print help\n"
	       "    -V   --version         print version\n"
	       "    -d   -o debug          enable debug output (implies -f)\n"
	       "    -f                     foreground operation\n"
	       "    -s                     disable multi-threaded operation\n"
	       "    -o clone_fd            use separate fuse device fd for each thread\n"
	       "                           (may improve performance)\n"
	       "    -o max_idle_threads    the maximum number of idle worker threads\n"
	       "                           allowed (default: -1)\n"
	       "    -o max_threads         the maximum number of worker threads\n"
	       "                           allowed (default: 10)\n");
}

static int fuse_helper_opt_proc(void *data, const char *arg, int key,
				struct fuse_args *outargs)
{
	(void) outargs;
	struct fuse_cmdline_opts *opts = data;

	switch (key) {
	case FUSE_OPT_KEY_NONOPT:
		if (!opts->mountpoint) {
			if (fuse_mnt_parse_fuse_fd(arg) != -1) {
				return fuse_opt_add_opt(&opts->mountpoint, arg);
			}

			char mountpoint[PATH_MAX] = "";
			if (realpath(arg, mountpoint) == NULL) {
				fuse_log(FUSE_LOG_ERR,
					"fuse: bad mount point `%s': %s\n",
					arg, strerror(errno));
				return -1;
			}
			return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
		} else {
			fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
			return -1;
		}

	default:
		/* Pass through unknown options */
		return 1;
	}
}

/* Under FreeBSD, there is no subtype option so this
   function actually sets the fsname */
static int add_default_subtype(const char *progname, struct fuse_args *args)
{
	char subtype_opt[PATH_MAX];

	const char *basename = strrchr(progname, '/');
	if (basename == NULL)
		basename = progname;
	else if (basename[1] != '\0')
		basename++;

#ifdef __FreeBSD__
	snprintf(subtype_opt, sizeof(subtype_opt), "-ofsname=%s", basename);
#else
	snprintf(subtype_opt, sizeof(subtype_opt), "-osubtype=%s", basename);
#endif
	return fuse_opt_add_arg(args, subtype_opt);
}

int fuse_parse_cmdline_312(struct fuse_args *args,
			   struct fuse_cmdline_opts *opts);
FUSE_SYMVER("fuse_parse_cmdline_312", "fuse_parse_cmdline@@FUSE_3.12")
int fuse_parse_cmdline_312(struct fuse_args *args,
			   struct fuse_cmdline_opts *opts)
{
	memset(opts, 0, sizeof(struct fuse_cmdline_opts));

	opts->max_idle_threads = UINT_MAX; /* new default in fuse version 3.12 */
	opts->max_threads = 10;

	if (fuse_opt_parse(args, opts, fuse_helper_opts,
			   fuse_helper_opt_proc) == -1)
		return -1;

	/* *Linux*: if neither -o subtype nor -o fsname are specified,
	   set subtype to program's basename.
	   *FreeBSD*: if fsname is not specified, set to program's
	   basename. */
	if (!opts->nodefault_subtype)
		if (add_default_subtype(args->argv[0], args) == -1)
			return -1;

	return 0;
}

#ifdef HAVE_SERVICEMOUNT
static int fuse_helper_opt_proc_service(void *data, const char *arg, int key,
					struct fuse_args *outargs)
{
	(void) outargs;
	struct fuse_cmdline_opts *opts = data;

	switch (key) {
	case FUSE_OPT_KEY_NONOPT:
		if (!opts->mountpoint)
			return fuse_opt_add_opt(&opts->mountpoint, arg);

		fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
		return -1;
	default:
		/* Pass through unknown options */
		return 1;
	}
}

int fuse_parse_cmdline_service(struct fuse_args *args,
			       struct fuse_cmdline_opts *opts)
{
	memset(opts, 0, sizeof(struct fuse_cmdline_opts));

	opts->max_idle_threads = UINT_MAX; /* new default in fuse version 3.12 */
	opts->max_threads = 10;

	if (fuse_opt_parse(args, opts, fuse_helper_opts,
			   fuse_helper_opt_proc_service) == -1)
		return -1;

	/*
	 * *Linux*: if neither -o subtype nor -o fsname are specified,
	 * set subtype to program's basename.
	 * *FreeBSD*: if fsname is not specified, set to program's
	 * basename.
	 */
	if (!opts->nodefault_subtype)
		if (add_default_subtype(args->argv[0], args) == -1)
			return -1;

	return 0;
}
#endif

/**
 * struct fuse_cmdline_opts got extended in libfuse-3.12
 */
int fuse_parse_cmdline_30(struct fuse_args *args,
		       struct fuse_cmdline_opts *opts);
FUSE_SYMVER("fuse_parse_cmdline_30", "fuse_parse_cmdline@FUSE_3.0")
int fuse_parse_cmdline_30(struct fuse_args *args,
			  struct fuse_cmdline_opts *out_opts)
{
	struct fuse_cmdline_opts opts;

	int rc = fuse_parse_cmdline_312(args, &opts);
	if (rc == 0) {
		/* copy up to the size of the old pre 3.12 struct */
		memcpy(out_opts, &opts,
		       offsetof(struct fuse_cmdline_opts, max_idle_threads) +
		       sizeof(opts.max_idle_threads));
	}

	return rc;
}

struct fuse *_fuse_new_31(struct fuse_args *args,
		       const struct fuse_operations *op, size_t op_size,
		       struct libfuse_version *version,
		       void *user_data);

int fuse_service_main_real_versioned(struct fuse_service *service,
				     struct fuse_args *args,
				     const struct fuse_operations *op,
				     size_t op_size,
				     struct libfuse_version *version,
				     void *user_data)
{
	struct fuse *fuse;
	struct fuse_cmdline_opts opts;
	struct fuse_loop_config *loop_config = NULL;
	int res;

	if (fuse_service_parse_cmdline_opts(args, &opts) != 0) {
		res = 1;
		goto out0;
	}

	if (opts.show_version) {
		printf("FUSE library version %s\n", PACKAGE_VERSION);
		fuse_lowlevel_version();
		res = 0;
		goto out1;
	}

	if (opts.show_help) {
		if (args->argv[0][0] != '\0')
			printf("usage: %s [options] <mountpoint>\n\n",
			       args->argv[0]);
		printf("FUSE options:\n");
		fuse_cmdline_help();
		fuse_lib_help(args);
		res = 0;
		goto out1;
	}

	if (!opts.show_help &&
	    !opts.mountpoint) {
		fuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");
		res = 2;
		goto out1;
	}

	fuse = _fuse_new_31(args, op, op_size, version, user_data);
	if (fuse == NULL) {
		res = 3;
		goto out1;
	}
	struct fuse_session *se = fuse_get_session(fuse);

	if (!opts.singlethread) {
		loop_config = fuse_loop_cfg_create();
		if (loop_config == NULL) {
			res = 7;
			goto out2;
		}
	}

	if (fuse_set_signal_handlers(se) != 0) {
		res = 6;
		goto out3;
	}

	if (fuse_service_session_mount(service, se, 0, &opts) != 0) {
		res = 4;
		goto out4;
	}

	if (opts.singlethread) {
		fuse_service_send_goodbye(service, 0);
		fuse_service_release(service);

		res = fuse_loop(fuse);
	} else {
		fuse_loop_cfg_set_clone_fd(loop_config, opts.clone_fd);
		fuse_loop_cfg_set_idle_threads(loop_config, opts.max_idle_threads);
		fuse_loop_cfg_set_max_threads(loop_config, opts.max_threads);

		fuse_service_send_goodbye(service, 0);
		fuse_service_release(service);

		res = fuse_loop_mt(fuse, loop_config);
	}
	if (res)
		res = 8;

out4:
	fuse_remove_signal_handlers(se);
out3:
	fuse_loop_cfg_destroy(loop_config);
out2:
	fuse_destroy(fuse);
out1:
	free(opts.mountpoint);
out0:
	fuse_service_send_goodbye(service, res);
	fuse_service_release(service);
	return res;
}

int fuse_main_real_versioned(int argc, char *argv[],
			     const struct fuse_operations *op, size_t op_size,
			     struct libfuse_version *version, void *user_data)
{
	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
	struct fuse *fuse;
	struct fuse_cmdline_opts opts;
	int res;
	struct fuse_loop_config *loop_config = NULL;
	bool self_daemonize = false;

	if (fuse_parse_cmdline(&args, &opts) != 0)
		return 1;

	if (opts.show_version) {
		printf("FUSE library version %s\n", PACKAGE_VERSION);
		fuse_lowlevel_version();
		res = 0;
		goto out1;
	}

	if (opts.show_help) {
		if(args.argv[0][0] != '\0')
			printf("usage: %s [options] <mountpoint>\n\n",
			       args.argv[0]);
		printf("FUSE options:\n");
		fuse_cmdline_help();
		fuse_lib_help(&args);
		res = 0;
		goto out1;
	}

	if (!opts.show_help &&
	    !opts.mountpoint) {
		fuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");
		res = 2;
		goto out1;
	}

	/* The application might have already started daemonization itself */
	if (!fuse_daemonize_early_is_used()) {
		int daemonize_early_flags = 0;

		if (opts.foreground)
			daemonize_early_flags |= FUSE_DAEMONIZE_NO_BACKGROUND;

		res = fuse_daemonize_early_start(daemonize_early_flags);
		if (res != 0) {
			fuse_log(FUSE_LOG_ERR, "fuse: daemonize_early_start failed\n");
			goto out1;
		}
		self_daemonize = true;
	}

	fuse = _fuse_new_31(&args, op, op_size, version, user_data);
	if (fuse == NULL) {
		res = 3;
		goto out1;
	}

	struct fuse_session *se = fuse_get_session(fuse);
	if (fuse_mount(fuse,opts.mountpoint) != 0) {
		res = 4;
		goto out2;
	}

	if (fuse_set_signal_handlers(se) != 0) {
		res = 6;
		goto out3;
	}

	if (self_daemonize)
		fuse_daemonize_early_success();

	if (opts.singlethread)
		res = fuse_loop(fuse);
	else {
		loop_config = fuse_loop_cfg_create();
		if (loop_config == NULL) {
			res = 7;
			goto out3;
		}

		fuse_loop_cfg_set_clone_fd(loop_config, opts.clone_fd);

		fuse_loop_cfg_set_max_threads(loop_config, opts.max_threads);
		fuse_loop_cfg_set_idle_threads(loop_config, opts.max_idle_threads);
		res = fuse_loop_mt(fuse, loop_config);
	}
	if (res)
		res = 8;

	fuse_remove_signal_handlers(se);
out3:
	fuse_unmount(fuse);
out2:
	fuse_destroy(fuse);
out1:
	fuse_loop_cfg_destroy(loop_config);
	free(opts.mountpoint);
	fuse_opt_free_args(&args);
	return res;
}

/* Not symboled, as not part of the official API */
int fuse_main_real_30(int argc, char *argv[], const struct fuse_operations *op,
		      size_t op_size, void *user_data);
int fuse_main_real_30(int argc, char *argv[], const struct fuse_operations *op,
		      size_t op_size, void *user_data)
{
	struct libfuse_version version = { 0 };
	return fuse_main_real_versioned(argc, argv, op, op_size, &version,
					user_data);
}

void fuse_apply_conn_info_opts(const struct fuse_conn_info_opts *opts,
			       struct fuse_conn_info *conn)
{
	if(opts->set_max_write)
		conn->max_write = opts->max_write;
	if(opts->set_max_background)
		conn->max_background = opts->max_background;
	if(opts->set_congestion_threshold)
		conn->congestion_threshold = opts->congestion_threshold;
	if(opts->set_time_gran)
		conn->time_gran = opts->time_gran;
	if(opts->set_max_readahead)
		conn->max_readahead = opts->max_readahead;

#define LL_ENABLE(cond, cap)                     \
	do {                                     \
		if (cond)                        \
			fuse_set_feature_flag(conn, cap); \
	} while (0)

#define LL_DISABLE(cond, cap)                     \
	do {                                      \
		if (cond)                         \
			fuse_unset_feature_flag(conn, cap); \
	} while (0)

	LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);
	LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);

	LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);
	LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);

	LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);
	LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);

	LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
	LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);

	LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);
	LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);

	LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);
	LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);

	LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
	LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);

	LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);
	LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);

	LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);
	LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);
}

struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
{
	struct fuse_conn_info_opts *opts;

	opts = calloc(1, sizeof(struct fuse_conn_info_opts));
	if(opts == NULL) {
		fuse_log(FUSE_LOG_ERR, "calloc failed\n");
		return NULL;
	}
	if(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
		free(opts);
		return NULL;
	}
	return opts;
}

int fuse_open_channel(const char *mountpoint, const char* options)
{
	struct mount_opts *opts = NULL;
	int fd = -1;
	const char *argv[] = { "", "-o", options };
	int argc = sizeof(argv) / sizeof(argv[0]);
	struct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);

	opts = parse_mount_opts(&args);
	if (opts == NULL)
		return -1;

	fd = fuse_kern_mount(mountpoint, opts);
	destroy_mount_opts(opts);

	return fd;
}
