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 static int proplist_sethex(pa_proplist *p, const char *key, size_t key_length, const char *value, size_t value_length) {
 144     struct property *prop;
 145     pa_bool_t add = FALSE;
 146     char *k, *v;
 147     uint8_t *d;
 148     size_t dn;
 149
 150     pa_assert(p);
 151     pa_assert(key);
 152     pa_assert(value);
 153
 154     k = pa_xstrndup(key, key_length);
 155
 156     if (!property_name_valid(k)) {
 157         pa_xfree(k);
 158         return -1;
 159     }
 160
 161     v = pa_xstrndup(value, value_length);
 162     d = pa_xmalloc(value_length*2+1);
 163
 164     if ((dn = pa_parsehex(v, d, value_length*2)) == (size_t) -1) {
 165         pa_xfree(k);
 166         pa_xfree(v);
 167         pa_xfree(d);
 168         return -1;
 169     }
 170
 171     pa_xfree(v);
 172
 173     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), k))) {
 174         prop = pa_xnew(struct property, 1);
 175         prop->key = k;
 176         add = TRUE;
 177     } else {
 178         pa_xfree(prop->value);
 179         pa_xfree(k);
 180     }
 181
 182     d[dn] = 0;
 183     prop->value = d;
 184     prop->nbytes = dn;
 185
 186     if (add)
 187         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 188
 189     return 0;
 190 }
 191
 192 /** Will accept only valid UTF-8 */
 193 int pa_proplist_setf(pa_proplist *p, const char *key, const char *format, ...) {
 194     struct property *prop;
 195     pa_bool_t add = FALSE;
 196     va_list ap;
 197     char *v;
 198
 199     pa_assert(p);
 200     pa_assert(key);
 201     pa_assert(format);
 202
 203     if (!property_name_valid(key) || !pa_utf8_valid(format))
 204         return -1;
 205
 206     va_start(ap, format);
 207     v = pa_vsprintf_malloc(format, ap);
 208     va_end(ap);
 209
 210     if (!pa_utf8_valid(v))
 211         goto fail;
 212
 213     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
 214         prop = pa_xnew(struct property, 1);
 215         prop->key = pa_xstrdup(key);
 216         add = TRUE;
 217     } else
 218         pa_xfree(prop->value);
 219
 220     prop->value = v;
 221     prop->nbytes = strlen(v)+1;
 222
 223     if (add)
 224         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 225
 226     return 0;
 227
 228 fail:
 229     pa_xfree(v);
 230     return -1;
 231 }
 232
 233 int pa_proplist_set(pa_proplist *p, const char *key, const void *data, size_t nbytes) {
 234     struct property *prop;
 235     pa_bool_t add = FALSE;
 236
 237     pa_assert(p);
 238     pa_assert(key);
 239     pa_assert(data);
 240
 241     if (!property_name_valid(key))
 242         return -1;
 243
 244     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
 245         prop = pa_xnew(struct property, 1);
 246         prop->key = pa_xstrdup(key);
 247         add = TRUE;
 248     } else
 249         pa_xfree(prop->value);
 250
 251     prop->value = pa_xmalloc(nbytes+1);
 252     memcpy(prop->value, data, nbytes);
 253     ((char*) prop->value)[nbytes] = 0;
 254     prop->nbytes = nbytes;
 255
 256     if (add)
 257         pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
 258
 259     return 0;
 260 }
 261
 262 const char *pa_proplist_gets(pa_proplist *p, const char *key) {
 263     struct property *prop;
 264
 265     pa_assert(p);
 266     pa_assert(key);
 267
 268     if (!property_name_valid(key))
 269         return NULL;
 270
 271     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
 272         return NULL;
 273
 274     if (prop->nbytes <= 0)
 275         return NULL;
 276
 277     if (((char*) prop->value)[prop->nbytes-1] != 0)
 278         return NULL;
 279
 280     if (strlen((char*) prop->value) != prop->nbytes-1)
 281         return NULL;
 282
 283     if (!pa_utf8_valid((char*) prop->value))
 284         return NULL;
 285
 286     return (char*) prop->value;
 287 }
 288
 289 int pa_proplist_get(pa_proplist *p, const char *key, const void **data, size_t *nbytes) {
 290     struct property *prop;
 291
 292     pa_assert(p);
 293     pa_assert(key);
 294     pa_assert(data);
 295     pa_assert(nbytes);
 296
 297     if (!property_name_valid(key))
 298         return -1;
 299
 300     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
 301         return -1;
 302
 303     *data = prop->value;
 304     *nbytes = prop->nbytes;
 305
 306     return 0;
 307 }
 308
 309 void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, pa_proplist *other) {
 310     struct property *prop;
 311     void *state = NULL;
 312
 313     pa_assert(p);
 314     pa_assert(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE);
 315     pa_assert(other);
 316
 317     if (mode == PA_UPDATE_SET)
 318         pa_proplist_clear(p);
 319
 320     while ((prop = pa_hashmap_iterate(MAKE_HASHMAP(other), &state, NULL))) {
 321
 322         if (mode == PA_UPDATE_MERGE && pa_proplist_contains(p, prop->key))
 323             continue;
 324
 325         pa_assert_se(pa_proplist_set(p, prop->key, prop->value, prop->nbytes) == 0);
 326     }
 327 }
 328
 329 int pa_proplist_unset(pa_proplist *p, const char *key) {
 330     struct property *prop;
 331
 332     pa_assert(p);
 333     pa_assert(key);
 334
 335     if (!property_name_valid(key))
 336         return -1;
 337
 338     if (!(prop = pa_hashmap_remove(MAKE_HASHMAP(p), key)))
 339         return -2;
 340
 341     property_free(prop);
 342     return 0;
 343 }
 344
 345 int pa_proplist_unset_many(pa_proplist *p, const char * const keys[]) {
 346     const char * const * k;
 347     int n = 0;
 348
 349     pa_assert(p);
 350     pa_assert(keys);
 351
 352     for (k = keys; *k; k++)
 353         if (!property_name_valid(*k))
 354             return -1;
 355
 356     for (k = keys; *k; k++)
 357         if (pa_proplist_unset(p, *k) >= 0)
 358             n++;
 359
 360     return n;
 361 }
 362
 363 const char *pa_proplist_iterate(pa_proplist *p, void **state) {
 364     struct property *prop;
 365
 366     if (!(prop = pa_hashmap_iterate(MAKE_HASHMAP(p), state, NULL)))
 367         return NULL;
 368
 369     return prop->key;
 370 }
 371
 372 char *pa_proplist_to_string_sep(pa_proplist *p, const char *sep) {
 373     const char *key;
 374     void *state = NULL;
 375     pa_strbuf *buf;
 376
 377     pa_assert(p);
 378     pa_assert(sep);
 379
 380     buf = pa_strbuf_new();
 381
 382     while ((key = pa_proplist_iterate(p, &state))) {
 383         const char *v;
 384
 385         if (!pa_strbuf_isempty(buf))
 386             pa_strbuf_puts(buf, sep);
 387
 388         if ((v = pa_proplist_gets(p, key))) {
 389             const char *t;
 390
 391             pa_strbuf_printf(buf, "%s = \"", key);
 392
 393             for (t = v;;) {
 394                 size_t h;
 395
 396                 h = strcspn(t, "\"");
 397
 398                 if (h > 0)
 399                     pa_strbuf_putsn(buf, t, h);
 400
 401                 t += h;
 402
 403                 if (*t == 0)
 404                     break;
 405
 406                 pa_assert(*t == '"');
 407                 pa_strbuf_puts(buf, "\\\"");
 408
 409                 t++;
 410             }
 411
 412             pa_strbuf_puts(buf, "\"");
 413         } else {
 414             const void *value;
 415             size_t nbytes;
 416             char *c;
 417
 418             pa_assert_se(pa_proplist_get(p, key, &value, &nbytes) == 0);
 419             c = pa_xmalloc(nbytes*2+1);
 420             pa_hexstr((const uint8_t*) value, nbytes, c, nbytes*2+1);
 421
 422             pa_strbuf_printf(buf, "%s = hex:%s", key, c);
 423             pa_xfree(c);
 424         }
 425     }
 426
 427     return pa_strbuf_tostring_free(buf);
 428 }
 429
 430 char *pa_proplist_to_string(pa_proplist *p) {
 431     char *s, *t;
 432
 433     s = pa_proplist_to_string_sep(p, "\n");
 434     t = pa_sprintf_malloc("%s\n", s);
 435     pa_xfree(s);
 436
 437     return t;
 438 }
 439
 440 pa_proplist *pa_proplist_from_string(const char *s) {
 441     enum {
 442         WHITESPACE,
 443         KEY,
 444         AFTER_KEY,
 445         VALUE_START,
 446         VALUE_SIMPLE,
 447         VALUE_DOUBLE_QUOTES,
 448         VALUE_DOUBLE_QUOTES_ESCAPE,
 449         VALUE_TICKS,
 450         VALUE_TICKS_ESCAPED,
 451         VALUE_HEX
 452     } state;
 453
 454     pa_proplist *pl;
 455     const char *p, *key = NULL, *value = NULL;
 456     size_t key_len = 0, value_len = 0;
 457
 458     pa_assert(s);
 459
 460     pl = pa_proplist_new();
 461
 462     state = WHITESPACE;
 463
 464     for (p = s;; p++) {
 465         switch (state) {
 466
 467             case WHITESPACE:
 468                 if (*p == 0)
 469                     goto success;
 470                 else if (*p == '=')
 471                     goto fail;
 472                 else if (!isspace(*p)) {
 473                     key = p;
 474                     state = KEY;
 475                     key_len = 1;
 476                 }
 477                 break;
 478
 479             case KEY:
 480                 if (*p == 0)
 481                     goto fail;
 482                 else if (*p == '=')
 483                     state = VALUE_START;
 484                 else if (isspace(*p))
 485                     state = AFTER_KEY;
 486                 else
 487                     key_len++;
 488                 break;
 489
 490             case AFTER_KEY:
 491                 if (*p == 0)
 492                     goto fail;
 493                 else if (*p == '=')
 494                     state = VALUE_START;
 495                 else if (!isspace(*p))
 496                     goto fail;
 497                 break;
 498
 499             case VALUE_START:
 500                 if (*p == 0)
 501                     goto fail;
 502                 else if (strncmp(p, "hex:", 4) == 0) {
 503                     state = VALUE_HEX;
 504                     value = p+4;
 505                     value_len = 0;
 506                     p += 3;
 507                 } else if (*p == '\'') {
 508                     state = VALUE_TICKS;
 509                     value = p+1;
 510                     value_len = 0;
 511                 } else if (*p == '"') {
 512                     state = VALUE_DOUBLE_QUOTES;
 513                     value = p+1;
 514                     value_len = 0;
 515                 } else if (!isspace(*p)) {
 516                     state = VALUE_SIMPLE;
 517                     value = p;
 518                     value_len = 1;
 519                 }
 520                 break;
 521
 522             case VALUE_SIMPLE:
 523                 if (*p == 0 || isspace(*p)) {
 524                     if (proplist_setn(pl, key, key_len, value, value_len) < 0)
 525                         goto fail;
 526
 527                     if (*p == 0)
 528                         goto success;
 529
 530                     state = WHITESPACE;
 531                 } else
 532                     value_len++;
 533                 break;
 534
 535             case VALUE_DOUBLE_QUOTES:
 536                 if (*p == 0)
 537                     goto fail;
 538                 else if (*p == '"') {
 539                     char *v;
 540
 541                     v = pa_unescape(pa_xstrndup(value, value_len));
 542
 543                     if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
 544                         pa_xfree(v);
 545                         goto fail;
 546                     }
 547
 548                     pa_xfree(v);
 549                     state = WHITESPACE;
 550                 } else if (*p == '\\') {
 551                     state = VALUE_DOUBLE_QUOTES_ESCAPE;
 552                     value_len++;
 553                 } else
 554                     value_len++;
 555                 break;
 556
 557             case VALUE_DOUBLE_QUOTES_ESCAPE:
 558                 if (*p == 0)
 559                     goto fail;
 560                 else {
 561                     state = VALUE_DOUBLE_QUOTES;
 562                     value_len++;
 563                 }
 564                 break;
 565
 566             case VALUE_TICKS:
 567                 if (*p == 0)
 568                     goto fail;
 569                 else if (*p == '\'') {
 570                     char *v;
 571
 572                     v = pa_unescape(pa_xstrndup(value, value_len));
 573
 574                     if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
 575                         pa_xfree(v);
 576                         goto fail;
 577                     }
 578
 579                     pa_xfree(v);
 580                     state = WHITESPACE;
 581                 } else if (*p == '\\') {
 582                     state = VALUE_TICKS_ESCAPED;
 583                     value_len++;
 584                 } else
 585                     value_len++;
 586                 break;
 587
 588             case VALUE_TICKS_ESCAPED:
 589                 if (*p == 0)
 590                     goto fail;
 591                 else {
 592                     state = VALUE_TICKS;
 593                     value_len++;
 594                 }
 595                 break;
 596
 597             case VALUE_HEX:
 598                 if ((*p >= '0' && *p <= '9') ||
 599                     (*p >= 'A' && *p <= 'F') ||
 600                     (*p >= 'a' && *p <= 'f')) {
 601                     value_len++;
 602                 } else if (*p == 0 || isspace(*p)) {
 603
 604                     if (proplist_sethex(pl, key, key_len, value, value_len) < 0)
 605                         goto fail;
 606
 607                     if (*p == 0)
 608                         goto success;
 609
 610                     state = WHITESPACE;
 611                 } else
 612                     goto fail;
 613                 break;
 614         }
 615     }
 616
 617 success:
 618     return MAKE_PROPLIST(pl);
 619
 620 fail:
 621     pa_proplist_free(pl);
 622     return NULL;
 623 }
 624
 625 int pa_proplist_contains(pa_proplist *p, const char *key) {
 626     pa_assert(p);
 627     pa_assert(key);
 628
 629     if (!property_name_valid(key))
 630         return -1;
 631
 632     if (!(pa_hashmap_get(MAKE_HASHMAP(p), key)))
 633         return 0;
 634
 635     return 1;
 636 }
 637
 638 void pa_proplist_clear(pa_proplist *p) {
 639     struct property *prop;
 640     pa_assert(p);
 641
 642     while ((prop = pa_hashmap_steal_first(MAKE_HASHMAP(p))))
 643         property_free(prop);
 644 }
 645
 646 pa_proplist* pa_proplist_copy(pa_proplist *template) {
 647     pa_proplist *p;
 648
 649     pa_assert_se(p = pa_proplist_new());
 650
 651     if (template)
 652         pa_proplist_update(p, PA_UPDATE_REPLACE, template);
 653
 654     return p;
 655 }
 656
 657 unsigned pa_proplist_size(pa_proplist *p) {
 658     pa_assert(p);
 659
 660     return pa_hashmap_size(MAKE_HASHMAP(p));
 661 }
 662
 663 int pa_proplist_isempty(pa_proplist *p) {
 664     pa_assert(p);
 665
 666     return pa_hashmap_isempty(MAKE_HASHMAP(p));
 667 }