xref: /netbsd-src/lib/librefuse/refuse_opt.c (revision c68139a4b6daa43e46772ed422785053da5037b9)

/* 	$NetBSD: refuse_opt.c,v 1.23 2022/01/22 07:58:32 pho Exp $	*/

/*-
 * Copyright (c) 2007 Juan Romero Pardines.
 * 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 ``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 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 <err.h>
#include <fuse_internal.h>
#include <fuse_opt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef FUSE_OPT_DEBUG
#define DPRINTF(x)	do { printf x; } while ( /* CONSTCOND */ 0)
#else
#define DPRINTF(x)
#endif

/*
 * Public API.
 */

/* ARGSUSED */
int
fuse_opt_add_arg(struct fuse_args *args, const char *arg)
{
	struct fuse_args	*ap;

	if (args->allocated == 0) {
		ap = fuse_opt_deep_copy_args(args->argc, args->argv);
		args->argv = ap->argv;
		args->argc = ap->argc;
		args->allocated = ap->allocated;
		(void) free(ap);
	} else if (args->allocated == args->argc) {
		int na = args->allocated + 10;

		if (reallocarr(&args->argv, (size_t)na, sizeof(*args->argv)) != 0)
			return -1;

		args->allocated = na;
	}
	DPRINTF(("%s: arguments passed: [arg:%s]\n", __func__, arg));
	if ((args->argv[args->argc++] = strdup(arg)) == NULL)
		err(1, "fuse_opt_add_arg");
	args->argv[args->argc] = NULL;
        return 0;
}

struct fuse_args *
fuse_opt_deep_copy_args(int argc, char **argv)
{
	struct fuse_args	*ap;
	int			 i;

	if ((ap = malloc(sizeof(*ap))) == NULL)
		err(1, "_fuse_deep_copy_args");
	/* deep copy args structure into channel args */
	ap->allocated = ((argc / 10) + 1) * 10;

	if ((ap->argv = calloc((size_t)ap->allocated,
	    sizeof(*ap->argv))) == NULL)
		err(1, "_fuse_deep_copy_args");

	for (i = 0; i < argc; i++) {
		if ((ap->argv[i] = strdup(argv[i])) == NULL)
			err(1, "_fuse_deep_copy_args");
	}
	ap->argv[ap->argc = i] = NULL;
	return ap;
}

void
fuse_opt_free_args(struct fuse_args *ap)
{
	if (ap) {
		if (ap->allocated) {
			int	i;
			for (i = 0; i < ap->argc; i++) {
				free(ap->argv[i]);
			}
			free(ap->argv);
		}
		ap->argv = NULL;
		ap->allocated = ap->argc = 0;
	}
}

/* ARGSUSED */
int
fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)
{
	int	i;
	int	na;

	DPRINTF(("%s: arguments passed: [pos=%d] [arg=%s]\n",
	    __func__, pos, arg));
	if (args->argv == NULL) {
		na = 10;
	} else {
		na = args->allocated + 10;
	}
	if (reallocarr(&args->argv, (size_t)na, sizeof(*args->argv)) != 0) {
		warn("fuse_opt_insert_arg");
		return -1;
	}
	args->allocated = na;

	for (i = args->argc++; i > pos; --i) {
		args->argv[i] = args->argv[i - 1];
	}
	if ((args->argv[pos] = strdup(arg)) == NULL)
		err(1, "fuse_opt_insert_arg");
	args->argv[args->argc] = NULL;
	return 0;
}

static int add_opt(char **opts, const char *opt, bool escape)
{
	const size_t orig_len = *opts == NULL ? 0 : strlen(*opts);
	char* buf = realloc(*opts, orig_len + 1 + strlen(opt) * 2 + 1);

	if (buf == NULL) {
		return -1;
	}
	*opts = buf;

	if (orig_len > 0) {
		buf += orig_len;
		*buf++ = ',';
	}

	for (; *opt; opt++) {
		if (escape && (*opt == ',' || *opt == '\\')) {
			*buf++ = '\\';
		}
		*buf++ = *opt;
	}
	*buf = '\0';

	return 0;
}

int fuse_opt_add_opt(char **opts, const char *opt)
{
	DPRINTF(("%s: arguments passed: [opts=%s] [opt=%s]\n",
	    __func__, *opts, opt));
	return add_opt(opts, opt, false);
}

int fuse_opt_add_opt_escaped(char **opts, const char *opt)
{
	DPRINTF(("%s: arguments passed: [opts=%s] [opt=%s]\n",
	    __func__, *opts, opt));
	return add_opt(opts, opt, true);
}

static bool match_templ(const char *templ, const char *opt, ssize_t *sep_idx)
{
	const char *sep = strpbrk(templ, "= ");

	if (sep != NULL && (sep[1] == '\0' || sep[1] == '%')) {
		const size_t cmp_len =
			(size_t)(sep[0] == '=' ? sep - templ + 1 : sep - templ);

		if (strlen(opt) >= cmp_len && strncmp(templ, opt, cmp_len) == 0) {
			if (sep_idx != NULL)
				*sep_idx = (ssize_t)(sep - templ);
			return true;
		}
		else {
			return false;
		}
	}
	else {
		if (strcmp(templ, opt) == 0) {
			if (sep_idx != NULL)
				*sep_idx = -1;
			return true;
		}
		else {
			return false;
		}
	}
}

static const struct fuse_opt *
find_opt(const struct fuse_opt *opts, const char *opt, ssize_t *sep_idx)
{
	for (; opts != NULL && opts->templ != NULL; opts++) {
		if (match_templ(opts->templ, opt, sep_idx))
			return opts;
	}
	return NULL;
}

/*
 * Returns 1 if opt was matched with any option from opts,
 * otherwise returns 0.
 */
int
fuse_opt_match(const struct fuse_opt *opts, const char *opt)
{
	return find_opt(opts, opt, NULL) != NULL ? 1 : 0;
}

static int call_proc(fuse_opt_proc_t proc, void* data,
		const char* arg, int key, struct fuse_args *outargs, bool is_opt)
{
	if (key == FUSE_OPT_KEY_DISCARD)
		return 0;

	if (key != FUSE_OPT_KEY_KEEP && proc != NULL) {
		const int rv = proc(data, arg, key, outargs);

		if (rv == -1 || /* error   */
			rv ==  0    /* discard */)
			return rv;
	}

	if (is_opt) {
		/* Do we already have "-o" at the beginning of outargs? */
		if (outargs->argc >= 3 && strcmp(outargs->argv[1], "-o") == 0) {
			/* Append the option to the comma-separated list. */
			if (fuse_opt_add_opt_escaped(&outargs->argv[2], arg) == -1)
				return -1;
		}
		else {
			/* Insert -o arg at the beginning. */
			if (fuse_opt_insert_arg(outargs, 1, "-o") == -1)
				return -1;
			if (fuse_opt_insert_arg(outargs, 2, arg) == -1)
				return -1;
		}
	}
	else {
		if (fuse_opt_add_arg(outargs, arg) == -1)
			return -1;
	}

	return 0;
}

/* Skip the current argv if possible. */
static int next_arg(const struct fuse_args *args, int *i)
{
	if (*i + 1 >= args->argc) {
		(void)fprintf(stderr, "fuse: missing argument"
				" after '%s'\n", args->argv[*i]);
		return -1;
	}
	else {
		*i += 1;
		return 0;
	}
}

/* Parse a single argument with a matched template. */
static int
parse_matched_arg(const char* arg, struct fuse_args *outargs,
		const struct fuse_opt* opt, ssize_t sep_idx, void* data,
		fuse_opt_proc_t proc, bool is_opt)
{
	if (opt->offset == -1) {
		/* The option description does not want any variables to be
		 * updated.*/
		if (call_proc(proc, data, arg, opt->value, outargs, is_opt) == -1)
			return -1;
	}
	else {
		void *var = (char*)data + opt->offset;

		if (sep_idx > 0 && opt->templ[sep_idx + 1] == '%') {
			/* "foo=%y" or "-x %y" */
			const char* param =
				opt->templ[sep_idx] == '=' ? &arg[sep_idx + 1] : &arg[sep_idx];

			if (opt->templ[sep_idx + 2] == 's') {
				char* dup = strdup(param);
				if (dup == NULL)
					return -1;

				*(char **)var = dup;
			}
			else {
				/* The format string is not a literal. We all know
				 * this is a bad idea but it's exactly what fuse_opt
				 * wants to do... */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
				if (sscanf(param, &opt->templ[sep_idx + 1], var) == -1) {
#pragma GCC diagnostic pop
					(void)fprintf(stderr, "fuse: '%s' is not a "
								"valid parameter for option '%.*s'\n",
								param, (int)sep_idx, opt->templ);
					return -1;
				}
			}
		}
		else {
			/* No parameter format is given. */
			*(int *)var = opt->value;
		}
	}
	return 0;
}

/* Parse a single argument with matching templates. */
static int
parse_arg(struct fuse_args* args, int *argi, const char* arg,
		struct fuse_args *outargs, void *data,
		const struct fuse_opt *opts, fuse_opt_proc_t proc, bool is_opt)
{
	ssize_t sep_idx;
	const struct fuse_opt *opt = find_opt(opts, arg, &sep_idx);

	if (opt) {
		/* An argument can match to multiple templates. Process them
		 * all. */
		for (; opt != NULL && opt->templ != NULL;
			opt = find_opt(++opt, arg, &sep_idx)) {

			if (sep_idx > 0 && opt->templ[sep_idx] == ' ' &&
				arg[sep_idx] == '\0') {
				/* The template "-x %y" requests a separate
				 * parameter "%y". Try to find one. */
				char *new_arg;
				int rv;

				if (next_arg(args, argi) == -1)
					return -1;

				/* ...but processor callbacks expect a concatenated
				 * argument "-xfoo". */
				if ((new_arg = malloc((size_t)sep_idx +
									strlen(args->argv[*argi]) + 1)) == NULL)
					return -1;

				strncpy(new_arg, arg, (size_t)sep_idx); /* -x */
				strcpy(new_arg + sep_idx, args->argv[*argi]); /* foo */
				rv = parse_matched_arg(new_arg, outargs, opt, sep_idx,
									data, proc, is_opt);
				free(new_arg);

				if (rv == -1)
					return -1;
			}
			else {
				int rv;
				rv = parse_matched_arg(arg, outargs, opt, sep_idx,
									data, proc, is_opt);
				if (rv == -1)
					return -1;
			}
		}
		return 0;
	}
	else {
		/* No templates matched to it so just invoke the callback. */
		return call_proc(proc, data, arg, FUSE_OPT_KEY_OPT, outargs, is_opt);
	}
}

/* Parse a comma-separated list of options which possibly has escaped
 * characters. */
static int
parse_opts(struct fuse_args *args, int *argi, const char* arg,
		struct fuse_args *outargs, void *data,
		const struct fuse_opt *opts, fuse_opt_proc_t proc)
{
	char *opt;
	size_t i, opt_len = 0;

	/* An unescaped option can never be longer than the original
	 * list. */
	if ((opt = malloc(strlen(arg) + 1)) == NULL)
		return -1;

	for (i = 0; i < strlen(arg); i++) {
		if (arg[i] == ',') {
			opt[opt_len] = '\0';
			if (parse_arg(args, argi, opt, outargs,
						data, opts, proc, true) == -1) {
				free(opt);
				return -1;
			}
			/* Start a new option. */
			opt_len = 0;
		}
		else if (arg[i] == '\\' && arg[i+1] != '\0') {
			/* Unescape it. */
			opt[opt_len++] = arg[i+1];
			i++;
		}
		else {
			opt[opt_len++] = arg[i];
		}
	}

	/* Parse the last option here. */
	opt[opt_len] = '\0';
	if (parse_arg(args, argi, opt, outargs, data, opts, proc, true) == -1) {
		free(opt);
		return -1;
	}

	free(opt);
	return 0;
}

static int
parse_all(struct fuse_args *args, struct fuse_args *outargs, void *data,
		const struct fuse_opt *opts, fuse_opt_proc_t proc)
{
	bool nonopt = false; /* Have we seen the "--" marker? */
	int i;

	/* The first argument, the program name, is implicitly
	 * FUSE_OPT_KEY_KEEP. */
	if (args->argc > 0) {
		if (fuse_opt_add_arg(outargs, args->argv[0]) == -1)
			return -1;
	}

	/* the real loop to process the arguments */
	for (i = 1; i < args->argc; i++) {
		const char *arg = args->argv[i];

		/* argvn != -foo... */
		if (nonopt || arg[0] != '-') {
			if (call_proc(proc, data, arg, FUSE_OPT_KEY_NONOPT,
						outargs, false) == -1)
				return -1;
		}
		/* -o or -ofoo */
		else if (arg[1] == 'o') {
			/* -oblah,foo... */
			if (arg[2] != '\0') {
				/* skip -o */
				if (parse_opts(args, &i, arg + 2, outargs,
							data, opts, proc) == -1)
					return -1;
			}
			/* -o blah,foo... */
			else {
				if (next_arg(args, &i) == -1)
					return -1;
				if (parse_opts(args, &i, args->argv[i], outargs,
							data, opts, proc) == -1)
					return -1;
			}
		}
		/* -- */
		else if (arg[1] == '-' && arg[2] == '\0') {
			if (fuse_opt_add_arg(outargs, arg) == -1)
				return -1;
			nonopt = true;
		}
		/* -foo */
		else {
			if (parse_arg(args, &i, arg, outargs,
						data, opts, proc, false) == -1)
				return -1;
		}
	}

	/* The "--" marker at the last of outargs should be removed */
	if (nonopt && strcmp(outargs->argv[outargs->argc - 1], "--") == 0) {
		free(outargs->argv[outargs->argc - 1]);
		outargs->argv[--outargs->argc] = NULL;
	}

	return 0;
}

int
fuse_opt_parse(struct fuse_args *args, void *data,
		const struct fuse_opt *opts, fuse_opt_proc_t proc)
{
	struct fuse_args outargs = FUSE_ARGS_INIT(0, NULL);
	int rv;

	if (!args || !args->argv || !args->argc)
		return 0;

	rv = parse_all(args, &outargs, data, opts, proc);
	if (rv != -1) {
		/* Succeeded. Swap the outargs and args. */
		struct fuse_args tmp = *args;
		*args = outargs;
		outargs = tmp;
	}

	fuse_opt_free_args(&outargs);
	return rv;
}