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 static void free_func(void *p) {
  97     struct entry *e = p;
  98     pa_assert(e);
  99
 100     pa_xfree(e->key);
 101     pa_xfree(e->value);
 102     pa_xfree(e);
 103 }
 104
 105 pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
 106     enum {
 107         WHITESPACE,
 108         KEY,
 109         VALUE_START,
 110         VALUE_SIMPLE,
 111         VALUE_SIMPLE_ESCAPED,
 112         VALUE_DOUBLE_QUOTES,
 113         VALUE_DOUBLE_QUOTES_ESCAPED,
 114         VALUE_TICKS,
 115         VALUE_TICKS_ESCAPED
 116     } state;
 117
 118     const char *p, *key = NULL, *value = NULL;
 119     size_t key_len = 0, value_len = 0;
 120     pa_modargs *ma = pa_xnew(pa_modargs, 1);
 121
 122     ma->raw = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, free_func);
 123     ma->unescaped = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, free_func);
 124
 125     if (!args)
 126         return ma;
 127
 128     state = WHITESPACE;
 129
 130     for (p = args; *p; p++) {
 131         switch (state) {
 132
 133             case WHITESPACE:
 134                 if (*p == '=')
 135                     goto fail;
 136                 else if (!isspace(*p)) {
 137                     key = p;
 138                     state = KEY;
 139                     key_len = 1;
 140                 }
 141                 break;
 142
 143             case KEY:
 144                 if (*p == '=')
 145                     state = VALUE_START;
 146                 else if (isspace(*p))
 147                     goto fail;
 148                 else
 149                     key_len++;
 150                 break;
 151
 152             case VALUE_START:
 153                 if (*p == '\'') {
 154                     state = VALUE_TICKS;
 155                     value = p+1;
 156                     value_len = 0;
 157                 } else if (*p == '"') {
 158                     state = VALUE_DOUBLE_QUOTES;
 159                     value = p+1;
 160                     value_len = 0;
 161                 } else if (isspace(*p)) {
 162                     if (add_key_value(ma,
 163                                       pa_xstrndup(key, key_len),
 164                                       pa_xstrdup(""),
 165                                       valid_keys) < 0)
 166                         goto fail;
 167                     state = WHITESPACE;
 168                 } else if (*p == '\\') {
 169                     state = VALUE_SIMPLE_ESCAPED;
 170                     value = p;
 171                     value_len = 1;
 172                 } else {
 173                     state = VALUE_SIMPLE;
 174                     value = p;
 175                     value_len = 1;
 176                 }
 177                 break;
 178
 179             case VALUE_SIMPLE:
 180                 if (isspace(*p)) {
 181                     if (add_key_value(ma,
 182                                       pa_xstrndup(key, key_len),
 183                                       pa_xstrndup(value, value_len),
 184                                       valid_keys) < 0)
 185                         goto fail;
 186                     state = WHITESPACE;
 187                 } else if (*p == '\\') {
 188                     state = VALUE_SIMPLE_ESCAPED;
 189                     value_len++;
 190                 } else
 191                     value_len++;
 192                 break;
 193
 194             case VALUE_SIMPLE_ESCAPED:
 195                 state = VALUE_SIMPLE;
 196                 value_len++;
 197                 break;
 198
 199             case VALUE_DOUBLE_QUOTES:
 200                 if (*p == '"') {
 201                     if (add_key_value(ma,
 202                                       pa_xstrndup(key, key_len),
 203                                       pa_xstrndup(value, value_len),
 204                                       valid_keys) < 0)
 205                         goto fail;
 206                     state = WHITESPACE;
 207                 } else if (*p == '\\') {
 208                     state = VALUE_DOUBLE_QUOTES_ESCAPED;
 209                     value_len++;
 210                 } else
 211                     value_len++;
 212                 break;
 213
 214             case VALUE_DOUBLE_QUOTES_ESCAPED:
 215                 state = VALUE_DOUBLE_QUOTES;
 216                 value_len++;
 217                 break;
 218
 219             case VALUE_TICKS:
 220                 if (*p == '\'') {
 221                     if (add_key_value(ma,
 222                                       pa_xstrndup(key, key_len),
 223                                       pa_xstrndup(value, value_len),
 224                                       valid_keys) < 0)
 225                         goto fail;
 226                     state = WHITESPACE;
 227                 } else if (*p == '\\') {
 228                     state = VALUE_TICKS_ESCAPED;
 229                     value_len++;
 230                 } else
 231                     value_len++;
 232                 break;
 233
 234             case VALUE_TICKS_ESCAPED:
 235                 state = VALUE_TICKS;
 236                 value_len++;
 237                 break;
 238         }
 239     }
 240
 241     if (state == VALUE_START) {
 242         if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
 243             goto fail;
 244     } else if (state == VALUE_SIMPLE) {
 245         if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
 246             goto fail;
 247     } else if (state != WHITESPACE)
 248         goto fail;
 249
 250     return ma;
 251
 252 fail:
 253
 254     pa_modargs_free(ma);
 255
 256     return NULL;
 257 }
 258
 259 void pa_modargs_free(pa_modargs*ma) {
 260     pa_assert(ma);
 261
 262     pa_hashmap_free(ma->raw);
 263     pa_hashmap_free(ma->unescaped);
 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, bool *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         if (!pa_modargs_get_value(ma, "channels", NULL))
 458             ss.channels = map.channels;
 459         else
 460             return -1;
 461     }
 462
 463     *rmap = map;
 464     *rss = ss;
 465
 466     return 0;
 467 }
 468
 469 int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
 470     const char *v;
 471     pa_proplist *n;
 472
 473     pa_assert(ma);
 474     pa_assert(name);
 475     pa_assert(p);
 476
 477     if (!(v = modargs_get_value_raw(ma, name, NULL)))
 478         return 0;
 479
 480     if (!(n = pa_proplist_from_string(v)))
 481         return -1;
 482
 483     pa_proplist_update(p, m, n);
 484     pa_proplist_free(n);
 485
 486     return 0;
 487 }
 488
 489 const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
 490     struct entry *e;
 491
 492     pa_assert(ma);
 493
 494     if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
 495         return NULL;
 496
 497     return e->key;
 498 }