tools/virtiofsd/fuse_opt.c

   1 /*
   2  * FUSE: Filesystem in Userspace
   3  * Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
   4  *
   5  * Implementation of option parsing routines (dealing with `struct
   6  * fuse_args`).
   7  *
   8  * This program can be distributed under the terms of the GNU LGPLv2.
   9  * See the file COPYING.LIB
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "fuse_opt.h"
  14 #include "fuse_i.h"
  15 #include "fuse_misc.h"
  16
  17
  18 struct fuse_opt_context {
  19     void *data;
  20     const struct fuse_opt *opt;
  21     fuse_opt_proc_t proc;
  22     int argctr;
  23     int argc;
  24     char **argv;
  25     struct fuse_args outargs;
  26     char *opts;
  27     int nonopt;
  28 };
  29
  30 void fuse_opt_free_args(struct fuse_args *args)
  31 {
  32     if (args) {
  33         if (args->argv && args->allocated) {
  34             int i;
  35             for (i = 0; i < args->argc; i++) {
  36                 free(args->argv[i]);
  37             }
  38             free(args->argv);
  39         }
  40         args->argc = 0;
  41         args->argv = NULL;
  42         args->allocated = 0;
  43     }
  44 }
  45
  46 static int alloc_failed(void)
  47 {
  48     fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
  49     return -1;
  50 }
  51
  52 int fuse_opt_add_arg(struct fuse_args *args, const char *arg)
  53 {
  54     char **newargv;
  55     char *newarg;
  56
  57     assert(!args->argv || args->allocated);
  58
  59     newarg = strdup(arg);
  60     if (!newarg) {
  61         return alloc_failed();
  62     }
  63
  64     newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
  65     if (!newargv) {
  66         free(newarg);
  67         return alloc_failed();
  68     }
  69
  70     args->argv = newargv;
  71     args->allocated = 1;
  72     args->argv[args->argc++] = newarg;
  73     args->argv[args->argc] = NULL;
  74     return 0;
  75 }
  76
  77 static int fuse_opt_insert_arg_common(struct fuse_args *args, int pos,
  78                                       const char *arg)
  79 {
  80     assert(pos <= args->argc);
  81     if (fuse_opt_add_arg(args, arg) == -1) {
  82         return -1;
  83     }
  84
  85     if (pos != args->argc - 1) {
  86         char *newarg = args->argv[args->argc - 1];
  87         memmove(&args->argv[pos + 1], &args->argv[pos],
  88                 sizeof(char *) * (args->argc - pos - 1));
  89         args->argv[pos] = newarg;
  90     }
  91     return 0;
  92 }
  93
  94 int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)
  95 {
  96     return fuse_opt_insert_arg_common(args, pos, arg);
  97 }
  98
  99 static int next_arg(struct fuse_opt_context *ctx, const char *opt)
 100 {
 101     if (ctx->argctr + 1 >= ctx->argc) {
 102         fuse_log(FUSE_LOG_ERR, "fuse: missing argument after `%s'\n", opt);
 103         return -1;
 104     }
 105     ctx->argctr++;
 106     return 0;
 107 }
 108
 109 static int add_arg(struct fuse_opt_context *ctx, const char *arg)
 110 {
 111     return fuse_opt_add_arg(&ctx->outargs, arg);
 112 }
 113
 114 static int add_opt_common(char **opts, const char *opt, int esc)
 115 {
 116     unsigned oldlen = *opts ? strlen(*opts) : 0;
 117     char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
 118
 119     if (!d) {
 120         return alloc_failed();
 121     }
 122
 123     *opts = d;
 124     if (oldlen) {
 125         d += oldlen;
 126         *d++ = ',';
 127     }
 128
 129     for (; *opt; opt++) {
 130         if (esc && (*opt == ',' || *opt == '\\')) {
 131             *d++ = '\\';
 132         }
 133         *d++ = *opt;
 134     }
 135     *d = '\0';
 136
 137     return 0;
 138 }
 139
 140 int fuse_opt_add_opt(char **opts, const char *opt)
 141 {
 142     return add_opt_common(opts, opt, 0);
 143 }
 144
 145 int fuse_opt_add_opt_escaped(char **opts, const char *opt)
 146 {
 147     return add_opt_common(opts, opt, 1);
 148 }
 149
 150 static int add_opt(struct fuse_opt_context *ctx, const char *opt)
 151 {
 152     return add_opt_common(&ctx->opts, opt, 1);
 153 }
 154
 155 static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
 156                      int iso)
 157 {
 158     if (key == FUSE_OPT_KEY_DISCARD) {
 159         return 0;
 160     }
 161
 162     if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
 163         int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
 164         if (res == -1 || !res) {
 165             return res;
 166         }
 167     }
 168     if (iso) {
 169         return add_opt(ctx, arg);
 170     } else {
 171         return add_arg(ctx, arg);
 172     }
 173 }
 174
 175 static int match_template(const char *t, const char *arg, unsigned *sepp)
 176 {
 177     int arglen = strlen(arg);
 178     const char *sep = strchr(t, '=');
 179     sep = sep ? sep : strchr(t, ' ');
 180     if (sep && (!sep[1] || sep[1] == '%')) {
 181         int tlen = sep - t;
 182         if (sep[0] == '=') {
 183             tlen++;
 184         }
 185         if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {
 186             *sepp = sep - t;
 187             return 1;
 188         }
 189     }
 190     if (strcmp(t, arg) == 0) {
 191         *sepp = 0;
 192         return 1;
 193     }
 194     return 0;
 195 }
 196
 197 static const struct fuse_opt *find_opt(const struct fuse_opt *opt,
 198                                        const char *arg, unsigned *sepp)
 199 {
 200     for (; opt && opt->templ; opt++) {
 201         if (match_template(opt->templ, arg, sepp)) {
 202             return opt;
 203         }
 204     }
 205     return NULL;
 206 }
 207
 208 int fuse_opt_match(const struct fuse_opt *opts, const char *opt)
 209 {
 210     unsigned dummy;
 211     return find_opt(opts, opt, &dummy) ? 1 : 0;
 212 }
 213
 214 static int process_opt_param(void *var, const char *format, const char *param,
 215                              const char *arg)
 216 {
 217     assert(format[0] == '%');
 218     if (format[1] == 's') {
 219         char **s = var;
 220         char *copy = strdup(param);
 221         if (!copy) {
 222             return alloc_failed();
 223         }
 224
 225         free(*s);
 226         *s = copy;
 227     } else {
 228         if (sscanf(param, format, var) != 1) {
 229             fuse_log(FUSE_LOG_ERR, "fuse: invalid parameter in option `%s'\n",
 230                      arg);
 231             return -1;
 232         }
 233     }
 234     return 0;
 235 }
 236
 237 static int process_opt(struct fuse_opt_context *ctx, const struct fuse_opt *opt,
 238                        unsigned sep, const char *arg, int iso)
 239 {
 240     if (opt->offset == -1U) {
 241         if (call_proc(ctx, arg, opt->value, iso) == -1) {
 242             return -1;
 243         }
 244     } else {
 245         void *var = (char *)ctx->data + opt->offset;
 246         if (sep && opt->templ[sep + 1]) {
 247             const char *param = arg + sep;
 248             if (opt->templ[sep] == '=') {
 249                 param++;
 250             }
 251             if (process_opt_param(var, opt->templ + sep + 1, param, arg) ==
 252                 -1) {
 253                 return -1;
 254             }
 255         } else {
 256             *(int *)var = opt->value;
 257         }
 258     }
 259     return 0;
 260 }
 261
 262 static int process_opt_sep_arg(struct fuse_opt_context *ctx,
 263                                const struct fuse_opt *opt, unsigned sep,
 264                                const char *arg, int iso)
 265 {
 266     int res;
 267     char *newarg;
 268     char *param;
 269
 270     if (next_arg(ctx, arg) == -1) {
 271         return -1;
 272     }
 273
 274     param = ctx->argv[ctx->argctr];
 275     newarg = malloc(sep + strlen(param) + 1);
 276     if (!newarg) {
 277         return alloc_failed();
 278     }
 279
 280     memcpy(newarg, arg, sep);
 281     strcpy(newarg + sep, param);
 282     res = process_opt(ctx, opt, sep, newarg, iso);
 283     free(newarg);
 284
 285     return res;
 286 }
 287
 288 static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)
 289 {
 290     unsigned sep;
 291     const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
 292     if (opt) {
 293         for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
 294             int res;
 295             if (sep && opt->templ[sep] == ' ' && !arg[sep]) {
 296                 res = process_opt_sep_arg(ctx, opt, sep, arg, iso);
 297             } else {
 298                 res = process_opt(ctx, opt, sep, arg, iso);
 299             }
 300             if (res == -1) {
 301                 return -1;
 302             }
 303         }
 304         return 0;
 305     } else {
 306         return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
 307     }
 308 }
 309
 310 static int process_real_option_group(struct fuse_opt_context *ctx, char *opts)
 311 {
 312     char *s = opts;
 313     char *d = s;
 314     int end = 0;
 315
 316     while (!end) {
 317         if (*s == '\0') {
 318             end = 1;
 319         }
 320         if (*s == ',' || end) {
 321             int res;
 322
 323             *d = '\0';
 324             res = process_gopt(ctx, opts, 1);
 325             if (res == -1) {
 326                 return -1;
 327             }
 328             d = opts;
 329         } else {
 330             if (s[0] == '\\' && s[1] != '\0') {
 331                 s++;
 332                 if (s[0] >= '0' && s[0] <= '3' && s[1] >= '0' && s[1] <= '7' &&
 333                     s[2] >= '0' && s[2] <= '7') {
 334                     *d++ = (s[0] - '0') * 0100 + (s[1] - '0') * 0010 +
 335                            (s[2] - '0');
 336                     s += 2;
 337                 } else {
 338                     *d++ = *s;
 339                 }
 340             } else {
 341                 *d++ = *s;
 342             }
 343         }
 344         s++;
 345     }
 346
 347     return 0;
 348 }
 349
 350 static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
 351 {
 352     int res;
 353     char *copy = strdup(opts);
 354
 355     if (!copy) {
 356         fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
 357         return -1;
 358     }
 359     res = process_real_option_group(ctx, copy);
 360     free(copy);
 361     return res;
 362 }
 363
 364 static int process_one(struct fuse_opt_context *ctx, const char *arg)
 365 {
 366     if (ctx->nonopt || arg[0] != '-') {
 367         return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
 368     } else if (arg[1] == 'o') {
 369         if (arg[2]) {
 370             return process_option_group(ctx, arg + 2);
 371         } else {
 372             if (next_arg(ctx, arg) == -1) {
 373                 return -1;
 374             }
 375
 376             return process_option_group(ctx, ctx->argv[ctx->argctr]);
 377         }
 378     } else if (arg[1] == '-' && !arg[2]) {
 379         if (add_arg(ctx, arg) == -1) {
 380             return -1;
 381         }
 382         ctx->nonopt = ctx->outargs.argc;
 383         return 0;
 384     } else {
 385         return process_gopt(ctx, arg, 0);
 386     }
 387 }
 388
 389 static int opt_parse(struct fuse_opt_context *ctx)
 390 {
 391     if (ctx->argc) {
 392         if (add_arg(ctx, ctx->argv[0]) == -1) {
 393             return -1;
 394         }
 395     }
 396
 397     for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++) {
 398         if (process_one(ctx, ctx->argv[ctx->argctr]) == -1) {
 399             return -1;
 400         }
 401     }
 402
 403     if (ctx->opts) {
 404         if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
 405             fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1) {
 406             return -1;
 407         }
 408     }
 409
 410     /* If option separator ("--") is the last argument, remove it */
 411     if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
 412         strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
 413         free(ctx->outargs.argv[ctx->outargs.argc - 1]);
 414         ctx->outargs.argv[--ctx->outargs.argc] = NULL;
 415     }
 416
 417     return 0;
 418 }
 419
 420 int fuse_opt_parse(struct fuse_args *args, void *data,
 421                    const struct fuse_opt opts[], fuse_opt_proc_t proc)
 422 {
 423     int res;
 424     struct fuse_opt_context ctx = {
 425         .data = data,
 426         .opt = opts,
 427         .proc = proc,
 428     };
 429
 430     if (!args || !args->argv || !args->argc) {
 431         return 0;
 432     }
 433
 434     ctx.argc = args->argc;
 435     ctx.argv = args->argv;
 436
 437     res = opt_parse(&ctx);
 438     if (res != -1) {
 439         struct fuse_args tmp = *args;
 440         *args = ctx.outargs;
 441         ctx.outargs = tmp;
 442     }
 443     free(ctx.opts);
 444     fuse_opt_free_args(&ctx.outargs);
 445     return res;
 446 }