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 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/sample-util.h>
  35 #include <pulsecore/namereg.h>
  36 #include <pulsecore/sink.h>
  37 #include <pulsecore/source.h>
  38 #include <pulsecore/core-util.h>
  39 #include <pulsecore/macro.h>
  40
  41 #include "modargs.h"
  42
  43 struct entry {
  44     char *key, *value;
  45 };
  46
  47 static int add_key_value(pa_hashmap *map, char *key, char *value, const char* const valid_keys[]) {
  48     struct entry *e;
  49
  50     pa_assert(map);
  51     pa_assert(key);
  52     pa_assert(value);
  53
  54     if (pa_hashmap_get(map, key)) {
  55         pa_xfree(key);
  56         pa_xfree(value);
  57         return -1;
  58     }
  59
  60     if (valid_keys) {
  61         const char*const* v;
  62         for (v = valid_keys; *v; v++)
  63             if (strcmp(*v, key) == 0)
  64                 break;
  65
  66         if (!*v) {
  67             pa_xfree(key);
  68             pa_xfree(value);
  69             return -1;
  70         }
  71     }
  72
  73     e = pa_xnew(struct entry, 1);
  74     e->key = key;
  75     e->value = value;
  76     pa_hashmap_put(map, key, e);
  77
  78     return 0;
  79 }
  80
  81 pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
  82     enum {
  83         WHITESPACE,
  84         KEY,
  85         VALUE_START,
  86         VALUE_SIMPLE,
  87         VALUE_DOUBLE_QUOTES,
  88         VALUE_TICKS
  89     } state;
  90
  91     const char *p, *key = NULL, *value = NULL;
  92     size_t key_len = 0, value_len = 0;
  93     pa_hashmap *map;
  94
  95     map = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
  96
  97     if (!args)
  98         return (pa_modargs*) map;
  99
 100     state = WHITESPACE;
 101
 102     for (p = args; *p; p++) {
 103         switch (state) {
 104
 105             case WHITESPACE:
 106                 if (*p == '=')
 107                     goto fail;
 108                 else if (!isspace(*p)) {
 109                     key = p;
 110                     state = KEY;
 111                     key_len = 1;
 112                 }
 113                 break;
 114
 115             case KEY:
 116                 if (*p == '=')
 117                     state = VALUE_START;
 118                 else if (isspace(*p))
 119                     goto fail;
 120                 else
 121                     key_len++;
 122                 break;
 123
 124             case  VALUE_START:
 125                 if (*p == '\'') {
 126                     state = VALUE_TICKS;
 127                     value = p+1;
 128                     value_len = 0;
 129                 } else if (*p == '"') {
 130                     state = VALUE_DOUBLE_QUOTES;
 131                     value = p+1;
 132                     value_len = 0;
 133                 } else if (isspace(*p)) {
 134                     if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
 135                         goto fail;
 136                     state = WHITESPACE;
 137                 } else {
 138                     state = VALUE_SIMPLE;
 139                     value = p;
 140                     value_len = 1;
 141                 }
 142                 break;
 143
 144             case VALUE_SIMPLE:
 145                 if (isspace(*p)) {
 146                     if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
 147                         goto fail;
 148                     state = WHITESPACE;
 149                 } else
 150                     value_len++;
 151                 break;
 152
 153             case VALUE_DOUBLE_QUOTES:
 154                 if (*p == '"') {
 155                     if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
 156                         goto fail;
 157                     state = WHITESPACE;
 158                 } else
 159                     value_len++;
 160                 break;
 161
 162             case VALUE_TICKS:
 163                 if (*p == '\'') {
 164                     if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
 165                         goto fail;
 166                     state = WHITESPACE;
 167                 } else
 168                     value_len++;
 169                 break;
 170         }
 171     }
 172
 173     if (state == VALUE_START) {
 174         if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
 175             goto fail;
 176     } else if (state == VALUE_SIMPLE) {
 177         if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
 178             goto fail;
 179     } else if (state != WHITESPACE)
 180         goto fail;
 181
 182     return (pa_modargs*) map;
 183
 184 fail:
 185
 186     pa_modargs_free((pa_modargs*) map);
 187
 188     return NULL;
 189 }
 190
 191 static void free_func(void *p, void*userdata) {
 192     struct entry *e = p;
 193     pa_assert(e);
 194
 195     pa_xfree(e->key);
 196     pa_xfree(e->value);
 197     pa_xfree(e);
 198 }
 199
 200 void pa_modargs_free(pa_modargs*ma) {
 201     pa_hashmap *map = (pa_hashmap*) ma;
 202     pa_hashmap_free(map, free_func, NULL);
 203 }
 204
 205 const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def) {
 206     pa_hashmap *map = (pa_hashmap*) ma;
 207     struct entry*e;
 208
 209     if (!(e = pa_hashmap_get(map, key)))
 210         return def;
 211
 212     return e->value;
 213 }
 214
 215 int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
 216     const char *v;
 217
 218     pa_assert(ma);
 219     pa_assert(key);
 220     pa_assert(value);
 221
 222     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 223         return 0;
 224
 225     if (pa_atou(v, value) < 0)
 226         return -1;
 227
 228     return 0;
 229 }
 230
 231 int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
 232     const char *v;
 233
 234     pa_assert(ma);
 235     pa_assert(key);
 236     pa_assert(value);
 237
 238     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 239         return 0;
 240
 241     if (pa_atoi(v, value) < 0)
 242         return -1;
 243
 244     return 0;
 245 }
 246
 247 int pa_modargs_get_value_boolean(pa_modargs *ma, const char *key, pa_bool_t *value) {
 248     const char *v;
 249     int r;
 250
 251     pa_assert(ma);
 252     pa_assert(key);
 253     pa_assert(value);
 254
 255     if (!(v = pa_modargs_get_value(ma, key, NULL)))
 256         return 0;
 257
 258     if (!*v)
 259         return -1;
 260
 261     if ((r = pa_parse_boolean(v)) < 0)
 262         return -1;
 263
 264     *value = r;
 265     return 0;
 266 }
 267
 268 int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
 269     const char *format;
 270     uint32_t channels;
 271     pa_sample_spec ss;
 272
 273     pa_assert(ma);
 274     pa_assert(rss);
 275
 276     ss = *rss;
 277     if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0)
 278         return -1;
 279
 280     channels = ss.channels;
 281     if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0)
 282         return -1;
 283     ss.channels = (uint8_t) channels;
 284
 285     if ((format = pa_modargs_get_value(ma, "format", NULL)))
 286         if ((ss.format = pa_parse_sample_format(format)) < 0)
 287             return -1;
 288
 289     if (!pa_sample_spec_valid(&ss))
 290         return -1;
 291
 292     *rss = ss;
 293
 294     return 0;
 295 }
 296
 297 int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
 298     pa_channel_map map;
 299     const char *cm;
 300
 301     pa_assert(ma);
 302     pa_assert(rmap);
 303
 304     map = *rmap;
 305
 306     if ((cm = pa_modargs_get_value(ma, name ? name : "channel_map", NULL)))
 307         if (!pa_channel_map_parse(&map, cm))
 308             return -1;
 309
 310     if (!pa_channel_map_valid(&map))
 311         return -1;
 312
 313     *rmap = map;
 314     return 0;
 315 }
 316
 317 int pa_modargs_get_sample_spec_and_channel_map(pa_modargs *ma, pa_sample_spec *rss, pa_channel_map *rmap, pa_channel_map_def_t def) {
 318     pa_sample_spec ss;
 319     pa_channel_map map;
 320
 321     pa_assert(ma);
 322     pa_assert(rss);
 323     pa_assert(rmap);
 324
 325     ss = *rss;
 326
 327     if (pa_modargs_get_sample_spec(ma, &ss) < 0)
 328         return -1;
 329
 330     pa_channel_map_init_extend(&map, ss.channels, def);
 331
 332     if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
 333         return -1;
 334
 335     if (map.channels != ss.channels)
 336         return -1;
 337
 338     *rmap = map;
 339     *rss = ss;
 340
 341     return 0;
 342 }