code.delx.au - pulseaudio/blob - src/pulse/proplist.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2007 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
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, 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   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License 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 <string.h>
  27 #include <ctype.h>
  28
  29 #include <pulse/xmalloc.h>
  30 #include <pulse/utf8.h>
  31 #include <pulse/i18n.h>
  32
  33 #include <pulsecore/hashmap.h>
  34 #include <pulsecore/strbuf.h>
  35 #include <pulsecore/core-util.h>
  36
  37 #include "proplist.h"
  38
  39 struct property {
  40     char *key;
  41     void *value;
  42     size_t nbytes;
  43 };
  44
  45 #define MAKE_HASHMAP(p) ((pa_hashmap*) (p))
  46 #define MAKE_PROPLIST(p) ((pa_proplist*) (p))
  47
  48 static pa_bool_t property_name_valid(const char *key) {
  49
  50     if (!pa_ascii_valid(key))
  51         return FALSE;
  52
  53     if (strlen(key) <= 0)
  54         return FALSE;
  55
  56     return TRUE;
  57 }
  58
  59 static void property_free(struct property *prop) {
  60     pa_assert(prop);
  61
  62     pa_xfree(prop->key);
  63     pa_xfree(prop->value);
  64     pa_xfree(prop);
  65 }
  66
  67 pa_proplist* pa_proplist_new(void) {
  68     return MAKE_PROPLIST(pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func));
  69 }
  70
  71 void pa_proplist_free(pa_proplist* p) {
  72     pa_assert(p);
  73
  74     pa_proplist_clear(p);
  75     pa_hashmap_free(MAKE_HASHMAP(p), NULL, NULL);
  76 }
  77
  78 /** Will accept only valid UTF-8 */
  79 int pa_proplist_sets(pa_proplist *p, const char *key, const char *value) {
  80     struct property *prop;
  81     pa_bool_t add = FALSE;
  82
  83     pa_assert(p);
  84     pa_assert(key);
  85     pa_assert(value);
  86
  87     if (!property_name_valid(key) || !pa_utf8_valid(value))
  88         return -1;
  89
  90     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
  91         prop = pa_xnew(struct property, 1);
  92         prop->key = pa_xstrdup(key);
  93         add = TRUE;
  94     } else
  95         pa_xfree(prop->value);
  96
  97     prop->value = pa_xstrdup(value);
  98     prop->nbytes = strlen(value)+1;
  99
 100     if (add)
 101         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 102
 103     return 0;
 104 }
 105
 106 /** Will accept only valid UTF-8 */
 107 static int proplist_setn(pa_proplist *p, const char *key, size_t key_length, const char *value, size_t value_length) {
 108     struct property *prop;
 109     pa_bool_t add = FALSE;
 110     char *k, *v;
 111
 112     pa_assert(p);
 113     pa_assert(key);
 114     pa_assert(value);
 115
 116     k = pa_xstrndup(key, key_length);
 117     v = pa_xstrndup(value, value_length);
 118
 119     if (!property_name_valid(k) || !pa_utf8_valid(v)) {
 120         pa_xfree(k);
 121         pa_xfree(v);
 122         return -1;
 123     }
 124
 125     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), k))) {
 126         prop = pa_xnew(struct property, 1);
 127         prop->key = k;
 128         add = TRUE;
 129     } else {
 130         pa_xfree(prop->value);
 131         pa_xfree(k);
 132     }
 133
 134     prop->value = v;
 135     prop->nbytes = strlen(v)+1;
 136
 137     if (add)
 138         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 139
 140     return 0;
 141 }
 142
 143 /** Will accept only valid UTF-8 */
 144 int pa_proplist_setp(pa_proplist *p, const char *pair) {
 145     const char *t;
 146
 147     pa_assert(p);
 148     pa_assert(pair);
 149
 150     if (!(t = strchr(pair, '=')))
 151         return -1;
 152
 153     return proplist_setn(p,
 154                          pair, t - pair,
 155                          t + 1, strchr(pair, 0) - t - 1);
 156 }
 157
 158 static int proplist_sethex(pa_proplist *p, const char *key, size_t key_length, const char *value, size_t value_length) {
 159     struct property *prop;
 160     pa_bool_t add = FALSE;
 161     char *k, *v;
 162     uint8_t *d;
 163     size_t dn;
 164
 165     pa_assert(p);
 166     pa_assert(key);
 167     pa_assert(value);
 168
 169     k = pa_xstrndup(key, key_length);
 170
 171     if (!property_name_valid(k)) {
 172         pa_xfree(k);
 173         return -1;
 174     }
 175
 176     v = pa_xstrndup(value, value_length);
 177     d = pa_xmalloc(value_length*2+1);
 178
 179     if ((dn = pa_parsehex(v, d, value_length*2)) == (size_t) -1) {
 180         pa_xfree(k);
 181         pa_xfree(v);
 182         pa_xfree(d);
 183         return -1;
 184     }
 185
 186     pa_xfree(v);
 187
 188     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), k))) {
 189         prop = pa_xnew(struct property, 1);
 190         prop->key = k;
 191         add = TRUE;
 192     } else {
 193         pa_xfree(prop->value);
 194         pa_xfree(k);
 195     }
 196
 197     d[dn] = 0;
 198     prop->value = d;
 199     prop->nbytes = dn;
 200
 201     if (add)
 202         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 203
 204     return 0;
 205 }
 206
 207 /** Will accept only valid UTF-8 */
 208 int pa_proplist_setf(pa_proplist *p, const char *key, const char *format, ...) {
 209     struct property *prop;
 210     pa_bool_t add = FALSE;
 211     va_list ap;
 212     char *v;
 213
 214     pa_assert(p);
 215     pa_assert(key);
 216     pa_assert(format);
 217
 218     if (!property_name_valid(key) || !pa_utf8_valid(format))
 219         return -1;
 220
 221     va_start(ap, format);
 222     v = pa_vsprintf_malloc(format, ap);
 223     va_end(ap);
 224
 225     if (!pa_utf8_valid(v))
 226         goto fail;
 227
 228     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
 229         prop = pa_xnew(struct property, 1);
 230         prop->key = pa_xstrdup(key);
 231         add = TRUE;
 232     } else
 233         pa_xfree(prop->value);
 234
 235     prop->value = v;
 236     prop->nbytes = strlen(v)+1;
 237
 238     if (add)
 239         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 240
 241     return 0;
 242
 243 fail:
 244     pa_xfree(v);
 245     return -1;
 246 }
 247
 248 int pa_proplist_set(pa_proplist *p, const char *key, const void *data, size_t nbytes) {
 249     struct property *prop;
 250     pa_bool_t add = FALSE;
 251
 252     pa_assert(p);
 253     pa_assert(key);
 254     pa_assert(data || nbytes == 0);
 255
 256     if (!property_name_valid(key))
 257         return -1;
 258
 259     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
 260         prop = pa_xnew(struct property, 1);
 261         prop->key = pa_xstrdup(key);
 262         add = TRUE;
 263     } else
 264         pa_xfree(prop->value);
 265
 266     prop->value = pa_xmalloc(nbytes+1);
 267     if (nbytes > 0)
 268         memcpy(prop->value, data, nbytes);
 269     ((char*) prop->value)[nbytes] = 0;
 270     prop->nbytes = nbytes;
 271
 272     if (add)
 273         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 274
 275     return 0;
 276 }
 277
 278 const char *pa_proplist_gets(pa_proplist *p, const char *key) {
 279     struct property *prop;
 280
 281     pa_assert(p);
 282     pa_assert(key);
 283
 284     if (!property_name_valid(key))
 285         return NULL;
 286
 287     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
 288         return NULL;
 289
 290     if (prop->nbytes <= 0)
 291         return NULL;
 292
 293     if (((char*) prop->value)[prop->nbytes-1] != 0)
 294         return NULL;
 295
 296     if (strlen((char*) prop->value) != prop->nbytes-1)
 297         return NULL;
 298
 299     if (!pa_utf8_valid((char*) prop->value))
 300         return NULL;
 301
 302     return (char*) prop->value;
 303 }
 304
 305 int pa_proplist_get(pa_proplist *p, const char *key, const void **data, size_t *nbytes) {
 306     struct property *prop;
 307
 308     pa_assert(p);
 309     pa_assert(key);
 310     pa_assert(data);
 311     pa_assert(nbytes);
 312
 313     if (!property_name_valid(key))
 314         return -1;
 315
 316     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
 317         return -1;
 318
 319     *data = prop->value;
 320     *nbytes = prop->nbytes;
 321
 322     return 0;
 323 }
 324
 325 void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, pa_proplist *other) {
 326     struct property *prop;
 327     void *state = NULL;
 328
 329     pa_assert(p);
 330     pa_assert(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE);
 331     pa_assert(other);
 332
 333     if (mode == PA_UPDATE_SET)
 334         pa_proplist_clear(p);
 335
 336     while ((prop = pa_hashmap_iterate(MAKE_HASHMAP(other), &state, NULL))) {
 337
 338         if (mode == PA_UPDATE_MERGE && pa_proplist_contains(p, prop->key))
 339             continue;
 340
 341         pa_assert_se(pa_proplist_set(p, prop->key, prop->value, prop->nbytes) == 0);
 342     }
 343 }
 344
 345 int pa_proplist_unset(pa_proplist *p, const char *key) {
 346     struct property *prop;
 347
 348     pa_assert(p);
 349     pa_assert(key);
 350
 351     if (!property_name_valid(key))
 352         return -1;
 353
 354     if (!(prop = pa_hashmap_remove(MAKE_HASHMAP(p), key)))
 355         return -2;
 356
 357     property_free(prop);
 358     return 0;
 359 }
 360
 361 int pa_proplist_unset_many(pa_proplist *p, const char * const keys[]) {
 362     const char * const * k;
 363     int n = 0;
 364
 365     pa_assert(p);
 366     pa_assert(keys);
 367
 368     for (k = keys; *k; k++)
 369         if (!property_name_valid(*k))
 370             return -1;
 371
 372     for (k = keys; *k; k++)
 373         if (pa_proplist_unset(p, *k) >= 0)
 374             n++;
 375
 376     return n;
 377 }
 378
 379 const char *pa_proplist_iterate(pa_proplist *p, void **state) {
 380     struct property *prop;
 381
 382     if (!(prop = pa_hashmap_iterate(MAKE_HASHMAP(p), state, NULL)))
 383         return NULL;
 384
 385     return prop->key;
 386 }
 387
 388 char *pa_proplist_to_string_sep(pa_proplist *p, const char *sep) {
 389     const char *key;
 390     void *state = NULL;
 391     pa_strbuf *buf;
 392
 393     pa_assert(p);
 394     pa_assert(sep);
 395
 396     buf = pa_strbuf_new();
 397
 398     while ((key = pa_proplist_iterate(p, &state))) {
 399         const char *v;
 400
 401         if (!pa_strbuf_isempty(buf))
 402             pa_strbuf_puts(buf, sep);
 403
 404         if ((v = pa_proplist_gets(p, key))) {
 405             const char *t;
 406
 407             pa_strbuf_printf(buf, "%s = \"", key);
 408
 409             for (t = v;;) {
 410                 size_t h;
 411
 412                 h = strcspn(t, "\"");
 413
 414                 if (h > 0)
 415                     pa_strbuf_putsn(buf, t, h);
 416
 417                 t += h;
 418
 419                 if (*t == 0)
 420                     break;
 421
 422                 pa_assert(*t == '"');
 423                 pa_strbuf_puts(buf, "\\\"");
 424
 425                 t++;
 426             }
 427
 428             pa_strbuf_puts(buf, "\"");
 429         } else {
 430             const void *value;
 431             size_t nbytes;
 432             char *c;
 433
 434             pa_assert_se(pa_proplist_get(p, key, &value, &nbytes) == 0);
 435             c = pa_xmalloc(nbytes*2+1);
 436             pa_hexstr((const uint8_t*) value, nbytes, c, nbytes*2+1);
 437
 438             pa_strbuf_printf(buf, "%s = hex:%s", key, c);
 439             pa_xfree(c);
 440         }
 441     }
 442
 443     return pa_strbuf_tostring_free(buf);
 444 }
 445
 446 char *pa_proplist_to_string(pa_proplist *p) {
 447     char *s, *t;
 448
 449     s = pa_proplist_to_string_sep(p, "\n");
 450     t = pa_sprintf_malloc("%s\n", s);
 451     pa_xfree(s);
 452
 453     return t;
 454 }
 455
 456 pa_proplist *pa_proplist_from_string(const char *s) {
 457     enum {
 458         WHITESPACE,
 459         KEY,
 460         AFTER_KEY,
 461         VALUE_START,
 462         VALUE_SIMPLE,
 463         VALUE_DOUBLE_QUOTES,
 464         VALUE_DOUBLE_QUOTES_ESCAPE,
 465         VALUE_TICKS,
 466         VALUE_TICKS_ESCAPED,
 467         VALUE_HEX
 468     } state;
 469
 470     pa_proplist *pl;
 471     const char *p, *key = NULL, *value = NULL;
 472     size_t key_len = 0, value_len = 0;
 473
 474     pa_assert(s);
 475
 476     pl = pa_proplist_new();
 477
 478     state = WHITESPACE;
 479
 480     for (p = s;; p++) {
 481         switch (state) {
 482
 483             case WHITESPACE:
 484                 if (*p == 0)
 485                     goto success;
 486                 else if (*p == '=')
 487                     goto fail;
 488                 else if (!isspace(*p)) {
 489                     key = p;
 490                     state = KEY;
 491                     key_len = 1;
 492                 }
 493                 break;
 494
 495             case KEY:
 496                 if (*p == 0)
 497                     goto fail;
 498                 else if (*p == '=')
 499                     state = VALUE_START;
 500                 else if (isspace(*p))
 501                     state = AFTER_KEY;
 502                 else
 503                     key_len++;
 504                 break;
 505
 506             case AFTER_KEY:
 507                 if (*p == 0)
 508                     goto fail;
 509                 else if (*p == '=')
 510                     state = VALUE_START;
 511                 else if (!isspace(*p))
 512                     goto fail;
 513                 break;
 514
 515             case VALUE_START:
 516                 if (*p == 0)
 517                     goto fail;
 518                 else if (strncmp(p, "hex:", 4) == 0) {
 519                     state = VALUE_HEX;
 520                     value = p+4;
 521                     value_len = 0;
 522                     p += 3;
 523                 } else if (*p == '\'') {
 524                     state = VALUE_TICKS;
 525                     value = p+1;
 526                     value_len = 0;
 527                 } else if (*p == '"') {
 528                     state = VALUE_DOUBLE_QUOTES;
 529                     value = p+1;
 530                     value_len = 0;
 531                 } else if (!isspace(*p)) {
 532                     state = VALUE_SIMPLE;
 533                     value = p;
 534                     value_len = 1;
 535                 }
 536                 break;
 537
 538             case VALUE_SIMPLE:
 539                 if (*p == 0 || isspace(*p)) {
 540                     if (proplist_setn(pl, key, key_len, value, value_len) < 0)
 541                         goto fail;
 542
 543                     if (*p == 0)
 544                         goto success;
 545
 546                     state = WHITESPACE;
 547                 } else
 548                     value_len++;
 549                 break;
 550
 551             case VALUE_DOUBLE_QUOTES:
 552                 if (*p == 0)
 553                     goto fail;
 554                 else if (*p == '"') {
 555                     char *v;
 556
 557                     v = pa_unescape(pa_xstrndup(value, value_len));
 558
 559                     if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
 560                         pa_xfree(v);
 561                         goto fail;
 562                     }
 563
 564                     pa_xfree(v);
 565                     state = WHITESPACE;
 566                 } else if (*p == '\\') {
 567                     state = VALUE_DOUBLE_QUOTES_ESCAPE;
 568                     value_len++;
 569                 } else
 570                     value_len++;
 571                 break;
 572
 573             case VALUE_DOUBLE_QUOTES_ESCAPE:
 574                 if (*p == 0)
 575                     goto fail;
 576                 else {
 577                     state = VALUE_DOUBLE_QUOTES;
 578                     value_len++;
 579                 }
 580                 break;
 581
 582             case VALUE_TICKS:
 583                 if (*p == 0)
 584                     goto fail;
 585                 else if (*p == '\'') {
 586                     char *v;
 587
 588                     v = pa_unescape(pa_xstrndup(value, value_len));
 589
 590                     if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
 591                         pa_xfree(v);
 592                         goto fail;
 593                     }
 594
 595                     pa_xfree(v);
 596                     state = WHITESPACE;
 597                 } else if (*p == '\\') {
 598                     state = VALUE_TICKS_ESCAPED;
 599                     value_len++;
 600                 } else
 601                     value_len++;
 602                 break;
 603
 604             case VALUE_TICKS_ESCAPED:
 605                 if (*p == 0)
 606                     goto fail;
 607                 else {
 608                     state = VALUE_TICKS;
 609                     value_len++;
 610                 }
 611                 break;
 612
 613             case VALUE_HEX:
 614                 if ((*p >= '0' && *p <= '9') ||
 615                     (*p >= 'A' && *p <= 'F') ||
 616                     (*p >= 'a' && *p <= 'f')) {
 617                     value_len++;
 618                 } else if (*p == 0 || isspace(*p)) {
 619
 620                     if (proplist_sethex(pl, key, key_len, value, value_len) < 0)
 621                         goto fail;
 622
 623                     if (*p == 0)
 624                         goto success;
 625
 626                     state = WHITESPACE;
 627                 } else
 628                     goto fail;
 629                 break;
 630         }
 631     }
 632
 633 success:
 634     return MAKE_PROPLIST(pl);
 635
 636 fail:
 637     pa_proplist_free(pl);
 638     return NULL;
 639 }
 640
 641 int pa_proplist_contains(pa_proplist *p, const char *key) {
 642     pa_assert(p);
 643     pa_assert(key);
 644
 645     if (!property_name_valid(key))
 646         return -1;
 647
 648     if (!(pa_hashmap_get(MAKE_HASHMAP(p), key)))
 649         return 0;
 650
 651     return 1;
 652 }
 653
 654 void pa_proplist_clear(pa_proplist *p) {
 655     struct property *prop;
 656     pa_assert(p);
 657
 658     while ((prop = pa_hashmap_steal_first(MAKE_HASHMAP(p))))
 659         property_free(prop);
 660 }
 661
 662 pa_proplist* pa_proplist_copy(pa_proplist *template) {
 663     pa_proplist *p;
 664
 665     pa_assert_se(p = pa_proplist_new());
 666
 667     if (template)
 668         pa_proplist_update(p, PA_UPDATE_REPLACE, template);
 669
 670     return p;
 671 }
 672
 673 unsigned pa_proplist_size(pa_proplist *p) {
 674     pa_assert(p);
 675
 676     return pa_hashmap_size(MAKE_HASHMAP(p));
 677 }
 678
 679 int pa_proplist_isempty(pa_proplist *p) {
 680     pa_assert(p);
 681
 682     return pa_hashmap_isempty(MAKE_HASHMAP(p));
 683 }