code.delx.au - pulseaudio/blob - src/pulsecore/modargs.c

   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 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     pa_assert(ma);
  53     pa_assert(ma->raw);
  54     pa_assert(ma->unescaped);
  55     pa_assert(key);
  56     pa_assert(value);
  57
  58     if (pa_hashmap_get(ma->unescaped, key)) {
  59         pa_xfree(key);
  60         pa_xfree(value);
  61         return -1;
  62     }
  63
  64     if (valid_keys) {
  65         const char*const* v;
  66         for (v = valid_keys; *v; v++)
  67             if (strcmp(*v, key) == 0)
  68                 break;
  69
  70         if (!*v) {
  71             pa_xfree(key);
  72             pa_xfree(value);
  73             return -1;
  74         }
  75     }
  76
  77     raw = pa_xstrdup(value);
  78
  79     e = pa_xnew(struct entry, 1);
  80     e->key = key;
  81     e->value = pa_unescape(value);
  82     pa_hashmap_put(ma->unescaped, key, e);
  83
  84     if (pa_streq(raw, value))
  85         pa_xfree(raw);
  86     else {
  87         e = pa_xnew(struct entry, 1);
  88         e->key = pa_xstrdup(key);
  89         e->value = raw;
  90         pa_hashmap_put(ma->raw, key, e);
  91     }
  92
  93     return 0;
  94 }
  95
  96 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     const char *p, *key = NULL, *value = NULL;
 110     size_t key_len = 0, value_len = 0;
 111     pa_modargs *ma = pa_xnew(pa_modargs, 1);
 112
 113     ma->raw = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 114     ma->unescaped = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 115
 116     if (!args)
 117         return ma;
 118
 119     state = WHITESPACE;
 120
 121     for (p = args; *p; p++) {
 122         switch (state) {
 123
 124             case WHITESPACE:
 125                 if (*p == '=')
 126                     goto fail;
 127                 else if (!isspace(*p)) {
 128                     key = p;
 129                     state = KEY;
 130                     key_len = 1;
 131                 }
 132                 break;
 133
 134             case KEY:
 135                 if (*p == '=')
 136                     state = VALUE_START;
 137                 else if (isspace(*p))
 138                     goto fail;
 139                 else
 140                     key_len++;
 141                 break;
 142
 143             case VALUE_START:
 144                 if (*p == '\'') {
 145                     state = VALUE_TICKS;
 146                     value = p+1;
 147                     value_len = 0;
 148                 } else if (*p == '"') {
 149                     state = VALUE_DOUBLE_QUOTES;
 150                     value = p+1;
 151                     value_len = 0;
 152                 } else if (isspace(*p)) {
 153                     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                 } else if (*p == '\\') {
 160                     state = VALUE_SIMPLE_ESCAPED;
 161                     value = p;
 162                     value_len = 1;
 163                 } else {
 164                     state = VALUE_SIMPLE;
 165                     value = p;
 166                     value_len = 1;
 167                 }
 168                 break;
 169
 170             case VALUE_SIMPLE:
 171                 if (isspace(*p)) {
 172                     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                 } else if (*p == '\\') {
 179                     state = VALUE_SIMPLE_ESCAPED;
 180                     value_len++;
 181                 } else
 182                     value_len++;
 183                 break;
 184
 185             case VALUE_SIMPLE_ESCAPED:
 186                 state = VALUE_SIMPLE;
 187                 value_len++;
 188                 break;
 189
 190             case VALUE_DOUBLE_QUOTES:
 191                 if (*p == '"') {
 192                     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                 } else if (*p == '\\') {
 199                     state = VALUE_DOUBLE_QUOTES_ESCAPED;
 200                     value_len++;
 201                 } else
 202                     value_len++;
 203                 break;
 204
 205             case VALUE_DOUBLE_QUOTES_ESCAPED:
 206                 state = VALUE_DOUBLE_QUOTES;
 207                 value_len++;
 208                 break;
 209
 210             case VALUE_TICKS:
 211                 if (*p == '\'') {
 212                     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                 } else if (*p == '\\') {
 219                     state = VALUE_TICKS_ESCAPED;
 220                     value_len++;
 221                 } else
 222                     value_len++;
 223                 break;
 224
 225             case VALUE_TICKS_ESCAPED:
 226                 state = VALUE_TICKS;
 227                 value_len++;
 228                 break;
 229         }
 230     }
 231
 232     if (state == VALUE_START) {
 233         if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
 234             goto fail;
 235     } else if (state == VALUE_SIMPLE) {
 236         if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
 237             goto fail;
 238     } else if (state != WHITESPACE)
 239         goto fail;
 240
 241     return ma;
 242
 243 fail:
 244
 245     pa_modargs_free(ma);
 246
 247     return NULL;
 248 }
 249
 250 static void free_func(void *p, void*userdata) {
 251     struct entry *e = p;
 252     pa_assert(e);
 253
 254     pa_xfree(e->key);
 255     pa_xfree(e->value);
 256     pa_xfree(e);
 257 }
 258
 259 void pa_modargs_free(pa_modargs*ma) {
 260     pa_assert(ma);
 261
 262     pa_hashmap_free(ma->raw, free_func, NULL);
 263     pa_hashmap_free(ma->unescaped, free_func, NULL);
 264     pa_xfree(ma);
 265 }
 266
 267 const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def) {
 268     struct entry*e;
 269
 270     pa_assert(ma);
 271     pa_assert(key);
 272
 273     if (!(e = pa_hashmap_get(ma->unescaped, key)))
 274         return def;
 275
 276     return e->value;
 277 }
 278
 279 static const char *modargs_get_value_raw(pa_modargs *ma, const char *key, const char *def) {
 280     struct entry*e;
 281
 282     pa_assert(ma);
 283     pa_assert(key);
 284
 285     if (!(e = pa_hashmap_get(ma->raw, key)))
 286         if (!(e = pa_hashmap_get(ma->unescaped, key)))
 287             return def;
 288
 289     return e->value;
 290 }
 291
 292 int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
 293     const char *v;
 294
 295     pa_assert(value);
 296
 297     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 298         return 0;
 299
 300     if (pa_atou(v, value) < 0)
 301         return -1;
 302
 303     return 0;
 304 }
 305
 306 int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
 307     const char *v;
 308
 309     pa_assert(value);
 310
 311     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 312         return 0;
 313
 314     if (pa_atoi(v, value) < 0)
 315         return -1;
 316
 317     return 0;
 318 }
 319
 320 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     pa_assert(value);
 325
 326     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 327         return 0;
 328
 329     if (!*v)
 330         return -1;
 331
 332     if ((r = pa_parse_boolean(v)) < 0)
 333         return -1;
 334
 335     *value = r;
 336     return 0;
 337 }
 338
 339 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     pa_assert(rss);
 345
 346     ss = *rss;
 347     if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0 ||
 348         ss.rate <= 0 ||
 349         ss.rate > PA_RATE_MAX)
 350         return -1;
 351
 352     channels = ss.channels;
 353     if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
 354         channels <= 0 ||
 355         channels >= PA_CHANNELS_MAX)
 356         return -1;
 357     ss.channels = (uint8_t) channels;
 358
 359     if ((format = pa_modargs_get_value(ma, "format", NULL)))
 360         if ((ss.format = pa_parse_sample_format(format)) < 0)
 361             return -1;
 362
 363     if (!pa_sample_spec_valid(&ss))
 364         return -1;
 365
 366     *rss = ss;
 367
 368     return 0;
 369 }
 370
 371 int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
 372     pa_channel_map map;
 373     const char *cm;
 374
 375     pa_assert(rmap);
 376
 377     map = *rmap;
 378
 379     if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
 380         if (!pa_channel_map_parse(&map, cm))
 381             return -1;
 382
 383     if (!pa_channel_map_valid(&map))
 384         return -1;
 385
 386     *rmap = map;
 387     return 0;
 388 }
 389
 390 int pa_modargs_get_sample_spec_and_channel_map(
 391         pa_modargs *ma,
 392         pa_sample_spec *rss,
 393         pa_channel_map *rmap,
 394         pa_channel_map_def_t def) {
 395
 396     pa_sample_spec ss;
 397     pa_channel_map map;
 398
 399     pa_assert(rss);
 400     pa_assert(rmap);
 401
 402     ss = *rss;
 403
 404     if (pa_modargs_get_sample_spec(ma, &ss) < 0)
 405         return -1;
 406
 407     map = *rmap;
 408
 409     if (ss.channels != map.channels)
 410         pa_channel_map_init_extend(&map, ss.channels, def);
 411
 412     if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
 413         return -1;
 414
 415     if (map.channels != ss.channels)
 416         return -1;
 417
 418     *rmap = map;
 419     *rss = ss;
 420
 421     return 0;
 422 }
 423
 424 int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
 425     const char *v;
 426     pa_proplist *n;
 427
 428     pa_assert(ma);
 429     pa_assert(name);
 430     pa_assert(p);
 431
 432     if (!(v = modargs_get_value_raw(ma, name, NULL)))
 433         return 0;
 434
 435     if (!(n = pa_proplist_from_string(v)))
 436         return -1;
 437
 438     pa_proplist_update(p, m, n);
 439     pa_proplist_free(n);
 440
 441     return 0;
 442 }
 443
 444 const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
 445     struct entry *e;
 446
 447     pa_assert(ma);
 448
 449     if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
 450         return NULL;
 451
 452     return e->key;
 453 }