/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 | } |