Branch data Line data Source code
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, write to the Free Software
18 : : Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 : : USA.
20 : : ***/
21 : :
22 : : #ifdef HAVE_CONFIG_H
23 : : #include <config.h>
24 : : #endif
25 : :
26 : : #include <ctype.h>
27 : : #include <stdlib.h>
28 : : #include <string.h>
29 : :
30 : : #include <pulse/xmalloc.h>
31 : :
32 : : #include <pulsecore/hashmap.h>
33 : : #include <pulsecore/idxset.h>
34 : : #include <pulsecore/core-util.h>
35 : : #include <pulsecore/macro.h>
36 : :
37 : : #include "modargs.h"
38 : :
39 : : struct pa_modargs {
40 : : pa_hashmap *raw;
41 : : pa_hashmap *unescaped;
42 : : };
43 : :
44 : : struct entry {
45 : : char *key, *value;
46 : : };
47 : :
48 : 1 : static int add_key_value(pa_modargs *ma, char *key, char *value, const char* const valid_keys[]) {
49 : : struct entry *e;
50 : : char *raw;
51 : :
52 [ - + ]: 1 : pa_assert(ma);
53 [ - + ]: 1 : pa_assert(ma->raw);
54 [ - + ]: 1 : pa_assert(ma->unescaped);
55 [ - + ]: 1 : pa_assert(key);
56 [ - + ]: 1 : pa_assert(value);
57 : :
58 [ - + ]: 1 : if (pa_hashmap_get(ma->unescaped, key)) {
59 : 0 : pa_xfree(key);
60 : 0 : pa_xfree(value);
61 : 0 : return -1;
62 : : }
63 : :
64 [ + - ]: 1 : if (valid_keys) {
65 : : const char*const* v;
66 [ + - ]: 1 : for (v = valid_keys; *v; v++)
67 [ - + ]: 1 : if (pa_streq(*v, key))
68 : : break;
69 : :
70 [ - + ]: 1 : if (!*v) {
71 : 0 : pa_xfree(key);
72 : 0 : pa_xfree(value);
73 : 0 : return -1;
74 : : }
75 : : }
76 : :
77 : 1 : raw = pa_xstrdup(value);
78 : :
79 : 1 : e = pa_xnew(struct entry, 1);
80 : 1 : e->key = key;
81 : 1 : e->value = pa_unescape(value);
82 : 1 : pa_hashmap_put(ma->unescaped, key, e);
83 : :
84 [ - + ]: 1 : if (pa_streq(raw, value))
85 : 0 : pa_xfree(raw);
86 : : else {
87 : 1 : e = pa_xnew(struct entry, 1);
88 : 1 : e->key = pa_xstrdup(key);
89 : 1 : e->value = raw;
90 : 1 : pa_hashmap_put(ma->raw, key, e);
91 : : }
92 : :
93 : : return 0;
94 : : }
95 : :
96 : 1 : pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
97 : : enum {
98 : : WHITESPACE,
99 : : KEY,
100 : : VALUE_START,
101 : : VALUE_SIMPLE,
102 : : VALUE_SIMPLE_ESCAPED,
103 : : VALUE_DOUBLE_QUOTES,
104 : : VALUE_DOUBLE_QUOTES_ESCAPED,
105 : : VALUE_TICKS,
106 : : VALUE_TICKS_ESCAPED
107 : : } state;
108 : :
109 : 1 : const char *p, *key = NULL, *value = NULL;
110 : 1 : size_t key_len = 0, value_len = 0;
111 : 1 : pa_modargs *ma = pa_xnew(pa_modargs, 1);
112 : :
113 : 1 : ma->raw = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
114 : 1 : ma->unescaped = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
115 : :
116 [ + - ]: 1 : if (!args)
117 : : return ma;
118 : :
119 : : state = WHITESPACE;
120 : :
121 [ + + ]: 52 : for (p = args; *p; p++) {
122 [ + + + - : 51 : switch (state) {
- - - + +
- ]
123 : :
124 : : case WHITESPACE:
125 [ + - ]: 1 : if (*p == '=')
126 : : goto fail;
127 [ + - ]: 1 : else if (!isspace(*p)) {
128 : 1 : key = p;
129 : 1 : state = KEY;
130 : 1 : key_len = 1;
131 : : }
132 : : break;
133 : :
134 : : case KEY:
135 [ + + ]: 3 : if (*p == '=')
136 : : state = VALUE_START;
137 [ + - ]: 2 : else if (isspace(*p))
138 : : goto fail;
139 : : else
140 : 2 : key_len++;
141 : : break;
142 : :
143 : : case VALUE_START:
144 [ + - ]: 1 : if (*p == '\'') {
145 : 1 : state = VALUE_TICKS;
146 : 1 : value = p+1;
147 : 1 : value_len = 0;
148 [ # # ]: 0 : } else if (*p == '"') {
149 : 0 : state = VALUE_DOUBLE_QUOTES;
150 : 0 : value = p+1;
151 : 0 : value_len = 0;
152 [ # # ]: 0 : } else if (isspace(*p)) {
153 [ # # ]: 0 : if (add_key_value(ma,
154 : : pa_xstrndup(key, key_len),
155 : : pa_xstrdup(""),
156 : : valid_keys) < 0)
157 : : goto fail;
158 : : state = WHITESPACE;
159 [ # # ]: 0 : } else if (*p == '\\') {
160 : : state = VALUE_SIMPLE_ESCAPED;
161 : : value = p;
162 : : value_len = 1;
163 : : } else {
164 : 0 : state = VALUE_SIMPLE;
165 : 0 : value = p;
166 : 0 : value_len = 1;
167 : : }
168 : : break;
169 : :
170 : : case VALUE_SIMPLE:
171 [ # # ]: 0 : if (isspace(*p)) {
172 [ # # ]: 0 : if (add_key_value(ma,
173 : : pa_xstrndup(key, key_len),
174 : : pa_xstrndup(value, value_len),
175 : : valid_keys) < 0)
176 : : goto fail;
177 : : state = WHITESPACE;
178 [ # # ]: 0 : } else if (*p == '\\') {
179 : 0 : state = VALUE_SIMPLE_ESCAPED;
180 : 0 : value_len++;
181 : : } else
182 : 0 : value_len++;
183 : : break;
184 : :
185 : : case VALUE_SIMPLE_ESCAPED:
186 : 0 : state = VALUE_SIMPLE;
187 : 0 : value_len++;
188 : 0 : break;
189 : :
190 : : case VALUE_DOUBLE_QUOTES:
191 [ # # ]: 0 : if (*p == '"') {
192 [ # # ]: 0 : if (add_key_value(ma,
193 : : pa_xstrndup(key, key_len),
194 : : pa_xstrndup(value, value_len),
195 : : valid_keys) < 0)
196 : : goto fail;
197 : : state = WHITESPACE;
198 [ # # ]: 0 : } else if (*p == '\\') {
199 : 0 : state = VALUE_DOUBLE_QUOTES_ESCAPED;
200 : 0 : value_len++;
201 : : } else
202 : 0 : value_len++;
203 : : break;
204 : :
205 : : case VALUE_DOUBLE_QUOTES_ESCAPED:
206 : 0 : state = VALUE_DOUBLE_QUOTES;
207 : 0 : value_len++;
208 : 0 : break;
209 : :
210 : : case VALUE_TICKS:
211 [ + + ]: 44 : if (*p == '\'') {
212 [ + - ]: 1 : if (add_key_value(ma,
213 : : pa_xstrndup(key, key_len),
214 : : pa_xstrndup(value, value_len),
215 : : valid_keys) < 0)
216 : : goto fail;
217 : : state = WHITESPACE;
218 [ + + ]: 43 : } else if (*p == '\\') {
219 : 2 : state = VALUE_TICKS_ESCAPED;
220 : 2 : value_len++;
221 : : } else
222 : 41 : value_len++;
223 : : break;
224 : :
225 : : case VALUE_TICKS_ESCAPED:
226 : 2 : state = VALUE_TICKS;
227 : 2 : value_len++;
228 : 2 : break;
229 : : }
230 : : }
231 : :
232 [ - + ]: 1 : if (state == VALUE_START) {
233 [ # # ]: 0 : if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
234 : : goto fail;
235 [ - + ]: 1 : } else if (state == VALUE_SIMPLE) {
236 [ # # ]: 0 : if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
237 : : goto fail;
238 [ - + ]: 1 : } else if (state != WHITESPACE)
239 : : goto fail;
240 : :
241 : : return ma;
242 : :
243 : : fail:
244 : :
245 : 0 : pa_modargs_free(ma);
246 : :
247 : 1 : return NULL;
248 : : }
249 : :
250 : 2 : static void free_func(void *p, void*userdata) {
251 : 2 : struct entry *e = p;
252 [ - + ]: 2 : pa_assert(e);
253 : :
254 : 2 : pa_xfree(e->key);
255 : 2 : pa_xfree(e->value);
256 : 2 : pa_xfree(e);
257 : 2 : }
258 : :
259 : 1 : void pa_modargs_free(pa_modargs*ma) {
260 [ - + ]: 1 : pa_assert(ma);
261 : :
262 : 1 : pa_hashmap_free(ma->raw, free_func, NULL);
263 : 1 : pa_hashmap_free(ma->unescaped, free_func, NULL);
264 : 1 : pa_xfree(ma);
265 : 1 : }
266 : :
267 : 0 : const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def) {
268 : : struct entry*e;
269 : :
270 [ # # ]: 0 : pa_assert(ma);
271 [ # # ]: 0 : pa_assert(key);
272 : :
273 [ # # ]: 0 : if (!(e = pa_hashmap_get(ma->unescaped, key)))
274 : : return def;
275 : :
276 : 0 : return e->value;
277 : : }
278 : :
279 : 1 : static const char *modargs_get_value_raw(pa_modargs *ma, const char *key, const char *def) {
280 : : struct entry*e;
281 : :
282 [ - + ]: 1 : pa_assert(ma);
283 [ - + ]: 1 : pa_assert(key);
284 : :
285 [ - + ]: 1 : if (!(e = pa_hashmap_get(ma->raw, key)))
286 [ # # ]: 0 : if (!(e = pa_hashmap_get(ma->unescaped, key)))
287 : : return def;
288 : :
289 : 1 : return e->value;
290 : : }
291 : :
292 : 0 : int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
293 : : const char *v;
294 : :
295 [ # # ]: 0 : pa_assert(value);
296 : :
297 [ # # ]: 0 : if (!(v = pa_modargs_get_value(ma, key, NULL)))
298 : : return 0;
299 : :
300 [ # # ]: 0 : if (pa_atou(v, value) < 0)
301 : : return -1;
302 : :
303 : 0 : return 0;
304 : : }
305 : :
306 : 0 : int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
307 : : const char *v;
308 : :
309 [ # # ]: 0 : pa_assert(value);
310 : :
311 [ # # ]: 0 : if (!(v = pa_modargs_get_value(ma, key, NULL)))
312 : : return 0;
313 : :
314 [ # # ]: 0 : if (pa_atoi(v, value) < 0)
315 : : return -1;
316 : :
317 : 0 : return 0;
318 : : }
319 : :
320 : 0 : int pa_modargs_get_value_boolean(pa_modargs *ma, const char *key, pa_bool_t *value) {
321 : : const char *v;
322 : : int r;
323 : :
324 [ # # ]: 0 : pa_assert(value);
325 : :
326 [ # # ]: 0 : if (!(v = pa_modargs_get_value(ma, key, NULL)))
327 : : return 0;
328 : :
329 [ # # ]: 0 : if (!*v)
330 : : return -1;
331 : :
332 [ # # ]: 0 : if ((r = pa_parse_boolean(v)) < 0)
333 : : return -1;
334 : :
335 : 0 : *value = r;
336 : 0 : return 0;
337 : : }
338 : :
339 : 0 : int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
340 : : const char *format;
341 : : uint32_t channels;
342 : : pa_sample_spec ss;
343 : :
344 [ # # ]: 0 : pa_assert(rss);
345 : :
346 : 0 : ss = *rss;
347 [ # # ][ # # ]: 0 : if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0 ||
348 [ # # ]: 0 : ss.rate <= 0 ||
349 : 0 : ss.rate > PA_RATE_MAX)
350 : : return -1;
351 : :
352 : 0 : channels = ss.channels;
353 [ # # ][ # # ]: 0 : if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
354 [ # # ]: 0 : channels <= 0 ||
355 : 0 : channels >= PA_CHANNELS_MAX)
356 : : return -1;
357 : 0 : ss.channels = (uint8_t) channels;
358 : :
359 [ # # ]: 0 : if ((format = pa_modargs_get_value(ma, "format", NULL)))
360 [ # # ]: 0 : if ((ss.format = pa_parse_sample_format(format)) < 0)
361 : : return -1;
362 : :
363 [ # # ]: 0 : if (!pa_sample_spec_valid(&ss))
364 : : return -1;
365 : :
366 : 0 : *rss = ss;
367 : :
368 : 0 : return 0;
369 : : }
370 : :
371 : 0 : int pa_modargs_get_alternate_sample_rate(pa_modargs *ma, uint32_t *alternate_rate) {
372 [ # # ]: 0 : pa_assert(ma);
373 [ # # ]: 0 : pa_assert(alternate_rate);
374 : :
375 [ # # ][ # # ]: 0 : if ((pa_modargs_get_value_u32(ma, "alternate_rate", alternate_rate)) < 0 ||
376 [ # # ]: 0 : *alternate_rate <= 0 ||
377 [ # # ]: 0 : *alternate_rate > PA_RATE_MAX ||
378 [ # # ]: 0 : !((*alternate_rate % 4000 == 0) || (*alternate_rate % 11025 == 0)))
379 : : return -1;
380 : :
381 : 0 : return 0;
382 : : }
383 : :
384 : 0 : int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
385 : : pa_channel_map map;
386 : : const char *cm;
387 : :
388 [ # # ]: 0 : pa_assert(rmap);
389 : :
390 : 0 : map = *rmap;
391 : :
392 [ # # ][ # # ]: 0 : if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
393 [ # # ]: 0 : if (!pa_channel_map_parse(&map, cm))
394 : : return -1;
395 : :
396 [ # # ]: 0 : if (!pa_channel_map_valid(&map))
397 : : return -1;
398 : :
399 : 0 : *rmap = map;
400 : 0 : return 0;
401 : : }
402 : :
403 : 0 : int pa_modargs_get_sample_spec_and_channel_map(
404 : : pa_modargs *ma,
405 : : pa_sample_spec *rss,
406 : : pa_channel_map *rmap,
407 : : pa_channel_map_def_t def) {
408 : :
409 : : pa_sample_spec ss;
410 : : pa_channel_map map;
411 : :
412 [ # # ]: 0 : pa_assert(rss);
413 [ # # ]: 0 : pa_assert(rmap);
414 : :
415 : 0 : ss = *rss;
416 : :
417 [ # # ]: 0 : if (pa_modargs_get_sample_spec(ma, &ss) < 0)
418 : : return -1;
419 : :
420 : 0 : map = *rmap;
421 : :
422 [ # # ]: 0 : if (ss.channels != map.channels)
423 : 0 : pa_channel_map_init_extend(&map, ss.channels, def);
424 : :
425 [ # # ]: 0 : if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
426 : : return -1;
427 : :
428 [ # # ]: 0 : if (map.channels != ss.channels)
429 : : return -1;
430 : :
431 : 0 : *rmap = map;
432 : 0 : *rss = ss;
433 : :
434 : 0 : return 0;
435 : : }
436 : :
437 : 1 : int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
438 : : const char *v;
439 : : pa_proplist *n;
440 : :
441 [ - + ]: 1 : pa_assert(ma);
442 [ - + ]: 1 : pa_assert(name);
443 [ - + ]: 1 : pa_assert(p);
444 : :
445 [ + - ]: 1 : if (!(v = modargs_get_value_raw(ma, name, NULL)))
446 : : return 0;
447 : :
448 [ + - ]: 1 : if (!(n = pa_proplist_from_string(v)))
449 : : return -1;
450 : :
451 : 1 : pa_proplist_update(p, m, n);
452 : 1 : pa_proplist_free(n);
453 : :
454 : 1 : return 0;
455 : : }
456 : :
457 : 0 : const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
458 : : struct entry *e;
459 : :
460 [ # # ]: 0 : pa_assert(ma);
461 : :
462 [ # # ]: 0 : if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
463 : : return NULL;
464 : :
465 : 0 : return e->key;
466 : : }
|
