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 (pa_streq(*v, key))
  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_value_double(pa_modargs *ma, const char *key, double *value) {
 340     const char *v;
 341
 342     pa_assert(value);
 343
 344     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 345         return 0;
 346
 347     if (pa_atod(v, value) < 0)
 348         return -1;
 349
 350     return 0;
 351 }
 352
 353 int pa_modargs_get_value_volume(pa_modargs *ma, const char *key, pa_volume_t *value) {
 354     const char *v;
 355
 356     pa_assert(value);
 357
 358     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 359         return 0;
 360
 361     if (pa_parse_volume(v, value) < 0)
 362         return -1;
 363
 364     return 0;
 365 }
 366
 367 int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
 368     const char *format;
 369     uint32_t channels;
 370     pa_sample_spec ss;
 371
 372     pa_assert(rss);
 373
 374     ss = *rss;
 375     if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0 ||
 376         ss.rate <= 0 ||
 377         ss.rate > PA_RATE_MAX)
 378         return -1;
 379
 380     channels = ss.channels;
 381     if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
 382         channels <= 0 ||
 383         channels >= PA_CHANNELS_MAX)
 384         return -1;
 385     ss.channels = (uint8_t) channels;
 386
 387     if ((format = pa_modargs_get_value(ma, "format", NULL)))
 388         if ((ss.format = pa_parse_sample_format(format)) < 0)
 389             return -1;
 390
 391     if (!pa_sample_spec_valid(&ss))
 392         return -1;
 393
 394     *rss = ss;
 395
 396     return 0;
 397 }
 398
 399 int pa_modargs_get_alternate_sample_rate(pa_modargs *ma, uint32_t *alternate_rate) {
 400     pa_assert(ma);
 401     pa_assert(alternate_rate);
 402
 403     if ((pa_modargs_get_value_u32(ma, "alternate_rate", alternate_rate)) < 0 ||
 404         *alternate_rate <= 0 ||
 405         *alternate_rate > PA_RATE_MAX ||
 406         !((*alternate_rate % 4000 == 0) || (*alternate_rate % 11025 == 0)))
 407         return -1;
 408
 409     return 0;
 410 }
 411
 412 int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
 413     pa_channel_map map;
 414     const char *cm;
 415
 416     pa_assert(rmap);
 417
 418     map = *rmap;
 419
 420     if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
 421         if (!pa_channel_map_parse(&map, cm))
 422             return -1;
 423
 424     if (!pa_channel_map_valid(&map))
 425         return -1;
 426
 427     *rmap = map;
 428     return 0;
 429 }
 430
 431 int pa_modargs_get_sample_spec_and_channel_map(
 432         pa_modargs *ma,
 433         pa_sample_spec *rss,
 434         pa_channel_map *rmap,
 435         pa_channel_map_def_t def) {
 436
 437     pa_sample_spec ss;
 438     pa_channel_map map;
 439
 440     pa_assert(rss);
 441     pa_assert(rmap);
 442
 443     ss = *rss;
 444
 445     if (pa_modargs_get_sample_spec(ma, &ss) < 0)
 446         return -1;
 447
 448     map = *rmap;
 449
 450     if (ss.channels != map.channels)
 451         pa_channel_map_init_extend(&map, ss.channels, def);
 452
 453     if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
 454         return -1;
 455
 456     if (map.channels != ss.channels)
 457         return -1;
 458
 459     *rmap = map;
 460     *rss = ss;
 461
 462     return 0;
 463 }
 464
 465 int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
 466     const char *v;
 467     pa_proplist *n;
 468
 469     pa_assert(ma);
 470     pa_assert(name);
 471     pa_assert(p);
 472
 473     if (!(v = modargs_get_value_raw(ma, name, NULL)))
 474         return 0;
 475
 476     if (!(n = pa_proplist_from_string(v)))
 477         return -1;
 478
 479     pa_proplist_update(p, m, n);
 480     pa_proplist_free(n);
 481
 482     return 0;
 483 }
 484
 485 const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
 486     struct entry *e;
 487
 488     pa_assert(ma);
 489
 490     if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
 491         return NULL;
 492
 493     return e->key;
 494 }