Coverage Report

Created: 2025-06-12 06:44

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