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 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_rate(pa_modargs *ma, uint32_t *rate) {
 368     uint32_t rate_local;
 369
 370     pa_assert(rate);
 371
 372     rate_local = *rate;
 373     if ((pa_modargs_get_value_u32(ma, "rate", &rate_local)) < 0 ||
 374         !pa_sample_rate_valid(rate_local))
 375         return -1;
 376
 377     *rate = rate_local;
 378
 379     return 0;
 380 }
 381
 382 int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
 383     const char *format;
 384     uint32_t channels;
 385     pa_sample_spec ss;
 386
 387     pa_assert(rss);
 388
 389     ss = *rss;
 390     if ((pa_modargs_get_sample_rate(ma, &ss.rate)) < 0)
 391         return -1;
 392
 393     channels = ss.channels;
 394     if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
 395         !pa_channels_valid(channels))
 396         return -1;
 397     ss.channels = (uint8_t) channels;
 398
 399     if ((format = pa_modargs_get_value(ma, "format", NULL)))
 400         if ((ss.format = pa_parse_sample_format(format)) < 0)
 401             return -1;
 402
 403     if (!pa_sample_spec_valid(&ss))
 404         return -1;
 405
 406     *rss = ss;
 407
 408     return 0;
 409 }
 410
 411 int pa_modargs_get_alternate_sample_rate(pa_modargs *ma, uint32_t *alternate_rate) {
 412     uint32_t rate_local;
 413
 414     pa_assert(alternate_rate);
 415
 416     rate_local = *alternate_rate;
 417     if ((pa_modargs_get_value_u32(ma, "alternate_rate", &rate_local)) < 0 ||
 418         !pa_sample_rate_valid(*alternate_rate))
 419         return -1;
 420
 421     if (!((rate_local % 4000 == 0) || (rate_local % 11025 == 0)))
 422         return -1;
 423
 424     *alternate_rate = rate_local;
 425
 426     return 0;
 427 }
 428
 429 int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
 430     pa_channel_map map;
 431     const char *cm;
 432
 433     pa_assert(rmap);
 434
 435     map = *rmap;
 436
 437     if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
 438         if (!pa_channel_map_parse(&map, cm))
 439             return -1;
 440
 441     if (!pa_channel_map_valid(&map))
 442         return -1;
 443
 444     *rmap = map;
 445     return 0;
 446 }
 447
 448 int pa_modargs_get_resample_method(pa_modargs *ma, pa_resample_method_t *rmethod) {
 449     const char *m;
 450
 451     pa_assert(ma);
 452     pa_assert(rmethod);
 453
 454     if ((m = pa_modargs_get_value(ma, "resample_method", NULL))) {
 455         pa_resample_method_t method = pa_parse_resample_method(m);
 456
 457         if (method == PA_RESAMPLER_INVALID)
 458             return -1;
 459
 460         *rmethod = method;
 461     }
 462
 463     return 0;
 464 }
 465
 466 int pa_modargs_get_sample_spec_and_channel_map(
 467         pa_modargs *ma,
 468         pa_sample_spec *rss,
 469         pa_channel_map *rmap,
 470         pa_channel_map_def_t def) {
 471
 472     pa_sample_spec ss;
 473     pa_channel_map map;
 474
 475     pa_assert(rss);
 476     pa_assert(rmap);
 477
 478     ss = *rss;
 479
 480     if (pa_modargs_get_sample_spec(ma, &ss) < 0)
 481         return -1;
 482
 483     map = *rmap;
 484
 485     if (ss.channels != map.channels)
 486         pa_channel_map_init_extend(&map, ss.channels, def);
 487
 488     if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
 489         return -1;
 490
 491     if (map.channels != ss.channels) {
 492         if (!pa_modargs_get_value(ma, "channels", NULL))
 493             ss.channels = map.channels;
 494         else
 495             return -1;
 496     }
 497
 498     *rmap = map;
 499     *rss = ss;
 500
 501     return 0;
 502 }
 503
 504 int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
 505     const char *v;
 506     pa_proplist *n;
 507
 508     pa_assert(ma);
 509     pa_assert(name);
 510     pa_assert(p);
 511
 512     if (!(v = modargs_get_value_raw(ma, name, NULL)))
 513         return 0;
 514
 515     if (!(n = pa_proplist_from_string(v)))
 516         return -1;
 517
 518     pa_proplist_update(p, m, n);
 519     pa_proplist_free(n);
 520
 521     return 0;
 522 }
 523
 524 const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
 525     struct entry *e;
 526
 527     pa_assert(ma);
 528
 529     if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
 530         return NULL;
 531
 532     return e->key;
 533 }