1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of the License,
9 or (at your option) any later version.
10
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <ctype.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include <pulse/xmalloc.h>
29
30 #include <pulsecore/hashmap.h>
31 #include <pulsecore/idxset.h>
32 #include <pulsecore/core-util.h>
33 #include <pulsecore/macro.h>
34
35 #include "modargs.h"
36
37 struct pa_modargs {
38 pa_hashmap *raw;
39 pa_hashmap *unescaped;
40 };
41
42 struct entry {
43 char *key, *value;
44 };
45
add_key_value(pa_modargs * ma,char * key,char * value,const char * const valid_keys[],bool ignore_dupes)46 static int add_key_value(pa_modargs *ma, char *key, char *value, const char* const valid_keys[], bool ignore_dupes) {
47 struct entry *e;
48 char *raw;
49
50 pa_assert(ma);
51 pa_assert(ma->raw);
52 pa_assert(ma->unescaped);
53 pa_assert(key);
54 pa_assert(value);
55
56 if (pa_hashmap_get(ma->unescaped, key)) {
57 pa_xfree(key);
58 pa_xfree(value);
59
60 if (ignore_dupes)
61 return 0;
62 else
63 return -1;
64 }
65
66 if (valid_keys) {
67 const char*const* v;
68 for (v = valid_keys; *v; v++)
69 if (pa_streq(*v, key))
70 break;
71
72 if (!*v) {
73 pa_xfree(key);
74 pa_xfree(value);
75 return -1;
76 }
77 }
78
79 raw = pa_xstrdup(value);
80
81 e = pa_xnew(struct entry, 1);
82 e->key = key;
83 e->value = pa_unescape(value);
84 pa_hashmap_put(ma->unescaped, key, e);
85
86 if (pa_streq(raw, value))
87 pa_xfree(raw);
88 else {
89 e = pa_xnew(struct entry, 1);
90 e->key = pa_xstrdup(key);
91 e->value = raw;
92 pa_hashmap_put(ma->raw, key, e);
93 }
94
95 return 0;
96 }
97
free_func(void * p)98 static void free_func(void *p) {
99 struct entry *e = p;
100 pa_assert(e);
101
102 pa_xfree(e->key);
103 pa_xfree(e->value);
104 pa_xfree(e);
105 }
106
parse(pa_modargs * ma,const char * args,const char * const * valid_keys,bool ignore_dupes)107 static int parse(pa_modargs *ma, const char *args, const char* const* valid_keys, bool ignore_dupes) {
108 enum {
109 WHITESPACE,
110 KEY,
111 VALUE_START,
112 VALUE_SIMPLE,
113 VALUE_SIMPLE_ESCAPED,
114 VALUE_DOUBLE_QUOTES,
115 VALUE_DOUBLE_QUOTES_ESCAPED,
116 VALUE_TICKS,
117 VALUE_TICKS_ESCAPED
118 } state;
119
120 const char *p, *key = NULL, *value = NULL;
121 size_t key_len = 0, value_len = 0;
122
123 state = WHITESPACE;
124
125 for (p = args; *p; p++) {
126 switch (state) {
127
128 case WHITESPACE:
129 if (*p == '=')
130 goto fail;
131 else if (!isspace((unsigned char)*p)) {
132 key = p;
133 state = KEY;
134 key_len = 1;
135 }
136 break;
137
138 case KEY:
139 if (*p == '=')
140 state = VALUE_START;
141 else if (isspace((unsigned char)*p))
142 goto fail;
143 else
144 key_len++;
145 break;
146
147 case VALUE_START:
148 if (*p == '\'') {
149 state = VALUE_TICKS;
150 value = p+1;
151 value_len = 0;
152 } else if (*p == '"') {
153 state = VALUE_DOUBLE_QUOTES;
154 value = p+1;
155 value_len = 0;
156 } else if (isspace((unsigned char)*p)) {
157 if (add_key_value(ma,
158 pa_xstrndup(key, key_len),
159 pa_xstrdup(""),
160 valid_keys,
161 ignore_dupes) < 0)
162 goto fail;
163 state = WHITESPACE;
164 } else if (*p == '\\') {
165 state = VALUE_SIMPLE_ESCAPED;
166 value = p;
167 value_len = 1;
168 } else {
169 state = VALUE_SIMPLE;
170 value = p;
171 value_len = 1;
172 }
173 break;
174
175 case VALUE_SIMPLE:
176 if (isspace((unsigned char)*p)) {
177 if (add_key_value(ma,
178 pa_xstrndup(key, key_len),
179 pa_xstrndup(value, value_len),
180 valid_keys,
181 ignore_dupes) < 0)
182 goto fail;
183 state = WHITESPACE;
184 } else if (*p == '\\') {
185 state = VALUE_SIMPLE_ESCAPED;
186 value_len++;
187 } else
188 value_len++;
189 break;
190
191 case VALUE_SIMPLE_ESCAPED:
192 state = VALUE_SIMPLE;
193 value_len++;
194 break;
195
196 case VALUE_DOUBLE_QUOTES:
197 if (*p == '"') {
198 if (add_key_value(ma,
199 pa_xstrndup(key, key_len),
200 pa_xstrndup(value, value_len),
201 valid_keys,
202 ignore_dupes) < 0)
203 goto fail;
204 state = WHITESPACE;
205 } else if (*p == '\\') {
206 state = VALUE_DOUBLE_QUOTES_ESCAPED;
207 value_len++;
208 } else
209 value_len++;
210 break;
211
212 case VALUE_DOUBLE_QUOTES_ESCAPED:
213 state = VALUE_DOUBLE_QUOTES;
214 value_len++;
215 break;
216
217 case VALUE_TICKS:
218 if (*p == '\'') {
219 if (add_key_value(ma,
220 pa_xstrndup(key, key_len),
221 pa_xstrndup(value, value_len),
222 valid_keys,
223 ignore_dupes) < 0)
224 goto fail;
225 state = WHITESPACE;
226 } else if (*p == '\\') {
227 state = VALUE_TICKS_ESCAPED;
228 value_len++;
229 } else
230 value_len++;
231 break;
232
233 case VALUE_TICKS_ESCAPED:
234 state = VALUE_TICKS;
235 value_len++;
236 break;
237 }
238 }
239
240 if (state == VALUE_START) {
241 if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys, ignore_dupes) < 0)
242 goto fail;
243 } else if (state == VALUE_SIMPLE) {
244 if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys, ignore_dupes) < 0)
245 goto fail;
246 } else if (state != WHITESPACE)
247 goto fail;
248
249 return 0;
250
251 fail:
252 return -1;
253 }
254
pa_modargs_new(const char * args,const char * const * valid_keys)255 pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
256 pa_modargs *ma = pa_xnew(pa_modargs, 1);
257
258 ma->raw = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, free_func);
259 ma->unescaped = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, free_func);
260
261 if (args && parse(ma, args, valid_keys, false) < 0)
262 goto fail;
263
264 return ma;
265
266 fail:
267 pa_modargs_free(ma);
268 return NULL;
269 }
270
pa_modargs_append(pa_modargs * ma,const char * args,const char * const * valid_keys)271 int pa_modargs_append(pa_modargs *ma, const char *args, const char* const* valid_keys) {
272 return parse(ma, args, valid_keys, true);
273 }
274
pa_modargs_free(pa_modargs * ma)275 void pa_modargs_free(pa_modargs*ma) {
276 pa_assert(ma);
277
278 pa_hashmap_free(ma->raw);
279 pa_hashmap_free(ma->unescaped);
280 pa_xfree(ma);
281 }
282
pa_modargs_get_value(pa_modargs * ma,const char * key,const char * def)283 const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def) {
284 struct entry*e;
285
286 pa_assert(ma);
287 pa_assert(key);
288
289 if (!(e = pa_hashmap_get(ma->unescaped, key)))
290 return def;
291
292 return e->value;
293 }
294
modargs_get_value_raw(pa_modargs * ma,const char * key,const char * def)295 static const char *modargs_get_value_raw(pa_modargs *ma, const char *key, const char *def) {
296 struct entry*e;
297
298 pa_assert(ma);
299 pa_assert(key);
300
301 if (!(e = pa_hashmap_get(ma->raw, key)))
302 if (!(e = pa_hashmap_get(ma->unescaped, key)))
303 return def;
304
305 return e->value;
306 }
307
pa_modargs_get_value_u32(pa_modargs * ma,const char * key,uint32_t * value)308 int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
309 const char *v;
310
311 pa_assert(value);
312
313 if (!(v = pa_modargs_get_value(ma, key, NULL)))
314 return 0;
315
316 if (pa_atou(v, value) < 0)
317 return -1;
318
319 return 0;
320 }
321
pa_modargs_get_value_s32(pa_modargs * ma,const char * key,int32_t * value)322 int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
323 const char *v;
324
325 pa_assert(value);
326
327 if (!(v = pa_modargs_get_value(ma, key, NULL)))
328 return 0;
329
330 if (pa_atoi(v, value) < 0)
331 return -1;
332
333 return 0;
334 }
335
pa_modargs_get_value_boolean(pa_modargs * ma,const char * key,bool * value)336 int pa_modargs_get_value_boolean(pa_modargs *ma, const char *key, bool *value) {
337 const char *v;
338 int r;
339
340 pa_assert(value);
341
342 if (!(v = pa_modargs_get_value(ma, key, NULL)))
343 return 0;
344
345 if (!*v)
346 return -1;
347
348 if ((r = pa_parse_boolean(v)) < 0)
349 return -1;
350
351 *value = r;
352 return 0;
353 }
354
pa_modargs_get_value_double(pa_modargs * ma,const char * key,double * value)355 int pa_modargs_get_value_double(pa_modargs *ma, const char *key, double *value) {
356 const char *v;
357
358 pa_assert(value);
359
360 if (!(v = pa_modargs_get_value(ma, key, NULL)))
361 return 0;
362
363 if (pa_atod(v, value) < 0)
364 return -1;
365
366 return 0;
367 }
368
pa_modargs_get_value_volume(pa_modargs * ma,const char * key,pa_volume_t * value)369 int pa_modargs_get_value_volume(pa_modargs *ma, const char *key, pa_volume_t *value) {
370 const char *v;
371
372 pa_assert(value);
373
374 if (!(v = pa_modargs_get_value(ma, key, NULL)))
375 return 0;
376
377 if (pa_parse_volume(v, value) < 0)
378 return -1;
379
380 return 0;
381 }
382
pa_modargs_get_sample_rate(pa_modargs * ma,uint32_t * rate)383 int pa_modargs_get_sample_rate(pa_modargs *ma, uint32_t *rate) {
384 uint32_t rate_local;
385
386 pa_assert(rate);
387
388 rate_local = *rate;
389 if ((pa_modargs_get_value_u32(ma, "rate", &rate_local)) < 0 ||
390 !pa_sample_rate_valid(rate_local))
391 return -1;
392
393 *rate = rate_local;
394
395 return 0;
396 }
397
pa_modargs_get_sample_spec(pa_modargs * ma,pa_sample_spec * rss)398 int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
399 const char *format;
400 uint32_t channels;
401 pa_sample_spec ss;
402
403 pa_assert(rss);
404
405 ss = *rss;
406 if ((pa_modargs_get_sample_rate(ma, &ss.rate)) < 0)
407 return -1;
408
409 channels = ss.channels;
410 if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
411 !pa_channels_valid(channels))
412 return -1;
413 ss.channels = (uint8_t) channels;
414
415 if ((format = pa_modargs_get_value(ma, "format", NULL)))
416 if ((ss.format = pa_parse_sample_format(format)) < 0)
417 return -1;
418
419 if (!pa_sample_spec_valid(&ss))
420 return -1;
421
422 *rss = ss;
423
424 return 0;
425 }
426
pa_modargs_get_alternate_sample_rate(pa_modargs * ma,uint32_t * alternate_rate)427 int pa_modargs_get_alternate_sample_rate(pa_modargs *ma, uint32_t *alternate_rate) {
428 uint32_t rate_local;
429
430 pa_assert(alternate_rate);
431
432 rate_local = *alternate_rate;
433 if ((pa_modargs_get_value_u32(ma, "alternate_rate", &rate_local)) < 0 ||
434 !pa_sample_rate_valid(*alternate_rate))
435 return -1;
436
437 *alternate_rate = rate_local;
438
439 return 0;
440 }
441
pa_modargs_get_channel_map(pa_modargs * ma,const char * name,pa_channel_map * rmap)442 int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
443 pa_channel_map map;
444 const char *cm;
445
446 pa_assert(rmap);
447
448 map = *rmap;
449
450 if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
451 if (!pa_channel_map_parse(&map, cm))
452 return -1;
453
454 if (!pa_channel_map_valid(&map))
455 return -1;
456
457 *rmap = map;
458 return 0;
459 }
460
pa_modargs_get_resample_method(pa_modargs * ma,pa_resample_method_t * rmethod)461 int pa_modargs_get_resample_method(pa_modargs *ma, pa_resample_method_t *rmethod) {
462 const char *m;
463
464 pa_assert(ma);
465 pa_assert(rmethod);
466
467 if ((m = pa_modargs_get_value(ma, "resample_method", NULL))) {
468 pa_resample_method_t method = pa_parse_resample_method(m);
469
470 if (method == PA_RESAMPLER_INVALID)
471 return -1;
472
473 *rmethod = method;
474 }
475
476 return 0;
477 }
478
pa_modargs_get_sample_spec_and_channel_map(pa_modargs * ma,pa_sample_spec * rss,pa_channel_map * rmap,pa_channel_map_def_t def)479 int pa_modargs_get_sample_spec_and_channel_map(
480 pa_modargs *ma,
481 pa_sample_spec *rss,
482 pa_channel_map *rmap,
483 pa_channel_map_def_t def) {
484
485 pa_sample_spec ss;
486 pa_channel_map map;
487
488 pa_assert(rss);
489 pa_assert(rmap);
490
491 ss = *rss;
492
493 if (pa_modargs_get_sample_spec(ma, &ss) < 0)
494 return -1;
495
496 map = *rmap;
497
498 if (ss.channels != map.channels)
499 pa_channel_map_init_extend(&map, ss.channels, def);
500
501 if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
502 return -1;
503
504 if (map.channels != ss.channels) {
505 if (!pa_modargs_get_value(ma, "channels", NULL))
506 ss.channels = map.channels;
507 else
508 return -1;
509 }
510
511 *rmap = map;
512 *rss = ss;
513
514 return 0;
515 }
516
pa_modargs_get_proplist(pa_modargs * ma,const char * name,pa_proplist * p,pa_update_mode_t m)517 int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
518 const char *v;
519 pa_proplist *n;
520
521 pa_assert(ma);
522 pa_assert(name);
523 pa_assert(p);
524
525 if (!(v = modargs_get_value_raw(ma, name, NULL)))
526 return 0;
527
528 if (!(n = pa_proplist_from_string(v)))
529 return -1;
530
531 pa_proplist_update(p, m, n);
532 pa_proplist_free(n);
533
534 return 0;
535 }
536
pa_modargs_iterate(pa_modargs * ma,void ** state)537 const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
538 struct entry *e;
539
540 pa_assert(ma);
541
542 if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
543 return NULL;
544
545 return e->key;
546 }
547