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