Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu.git] / 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 = g_try_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 g_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 }