]> code.delx.au - pulseaudio/blobdiff - src/pulse/proplist.c
Use pa_hashmap_remove_and_free() where appropriate
[pulseaudio] / src / pulse / proplist.c
index 282fe5ccb50b85abce14b0d87aa7084ec01dc162..a5ab7d264fa0cb6eab877550b42867e863607718 100644 (file)
 #endif
 
 #include <string.h>
+#include <ctype.h>
 
 #include <pulse/xmalloc.h>
 #include <pulse/utf8.h>
-#include <pulse/i18n.h>
 
 #include <pulsecore/hashmap.h>
 #include <pulsecore/strbuf.h>
@@ -44,15 +44,15 @@ struct property {
 #define MAKE_HASHMAP(p) ((pa_hashmap*) (p))
 #define MAKE_PROPLIST(p) ((pa_proplist*) (p))
 
-static pa_bool_t property_name_valid(const char *key) {
+int pa_proplist_key_valid(const char *key) {
 
-    if (!pa_utf8_valid(key))
-        return FALSE;
+    if (!pa_ascii_valid(key))
+        return 0;
 
     if (strlen(key) <= 0)
-        return FALSE;
+        return 0;
 
-    return TRUE;
+    return 1;
 }
 
 static void property_free(struct property *prop) {
@@ -64,33 +64,31 @@ static void property_free(struct property *prop) {
 }
 
 pa_proplist* pa_proplist_new(void) {
-    pa_init_i18n();
-
-    return MAKE_PROPLIST(pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func));
+    return MAKE_PROPLIST(pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) property_free));
 }
 
 void pa_proplist_free(pa_proplist* p) {
     pa_assert(p);
 
-    pa_proplist_clear(p);
-    pa_hashmap_free(MAKE_HASHMAP(p), NULL, NULL);
+    pa_hashmap_free(MAKE_HASHMAP(p));
 }
 
 /** Will accept only valid UTF-8 */
 int pa_proplist_sets(pa_proplist *p, const char *key, const char *value) {
     struct property *prop;
-    pa_bool_t add = FALSE;
+    bool add = false;
 
     pa_assert(p);
     pa_assert(key);
+    pa_assert(value);
 
-    if (!property_name_valid(key) || !pa_utf8_valid(value))
+    if (!pa_proplist_key_valid(key) || !pa_utf8_valid(value))
         return -1;
 
     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
         prop = pa_xnew(struct property, 1);
         prop->key = pa_xstrdup(key);
-        add = TRUE;
+        add = true;
     } else
         pa_xfree(prop->value);
 
@@ -103,46 +101,170 @@ int pa_proplist_sets(pa_proplist *p, const char *key, const char *value) {
     return 0;
 }
 
+/** Will accept only valid UTF-8 */
+static int proplist_setn(pa_proplist *p, const char *key, size_t key_length, const char *value, size_t value_length) {
+    struct property *prop;
+    bool add = false;
+    char *k, *v;
+
+    pa_assert(p);
+    pa_assert(key);
+    pa_assert(value);
+
+    k = pa_xstrndup(key, key_length);
+    v = pa_xstrndup(value, value_length);
+
+    if (!pa_proplist_key_valid(k) || !pa_utf8_valid(v)) {
+        pa_xfree(k);
+        pa_xfree(v);
+        return -1;
+    }
+
+    if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), k))) {
+        prop = pa_xnew(struct property, 1);
+        prop->key = k;
+        add = true;
+    } else {
+        pa_xfree(prop->value);
+        pa_xfree(k);
+    }
+
+    prop->value = v;
+    prop->nbytes = strlen(v)+1;
+
+    if (add)
+        pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
+
+    return 0;
+}
+
+/** Will accept only valid UTF-8 */
+int pa_proplist_setp(pa_proplist *p, const char *pair) {
+    const char *t;
+
+    pa_assert(p);
+    pa_assert(pair);
+
+    if (!(t = strchr(pair, '=')))
+        return -1;
+
+    return proplist_setn(p,
+                         pair, t - pair,
+                         t + 1, strchr(pair, 0) - t - 1);
+}
+
+static int proplist_sethex(pa_proplist *p, const char *key, size_t key_length, const char *value, size_t value_length) {
+    struct property *prop;
+    bool add = false;
+    char *k, *v;
+    uint8_t *d;
+    size_t dn;
+
+    pa_assert(p);
+    pa_assert(key);
+    pa_assert(value);
+
+    k = pa_xstrndup(key, key_length);
+
+    if (!pa_proplist_key_valid(k)) {
+        pa_xfree(k);
+        return -1;
+    }
+
+    v = pa_xstrndup(value, value_length);
+    d = pa_xmalloc(value_length*2+1);
+
+    if ((dn = pa_parsehex(v, d, value_length*2)) == (size_t) -1) {
+        pa_xfree(k);
+        pa_xfree(v);
+        pa_xfree(d);
+        return -1;
+    }
+
+    pa_xfree(v);
+
+    if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), k))) {
+        prop = pa_xnew(struct property, 1);
+        prop->key = k;
+        add = true;
+    } else {
+        pa_xfree(prop->value);
+        pa_xfree(k);
+    }
+
+    d[dn] = 0;
+    prop->value = d;
+    prop->nbytes = dn;
+
+    if (add)
+        pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
+
+    return 0;
+}
+
 /** Will accept only valid UTF-8 */
 int pa_proplist_setf(pa_proplist *p, const char *key, const char *format, ...) {
+    struct property *prop;
+    bool add = false;
     va_list ap;
-    int r;
-    char *t;
+    char *v;
 
     pa_assert(p);
     pa_assert(key);
+    pa_assert(format);
 
-    if (!property_name_valid(key) || !pa_utf8_valid(format))
+    if (!pa_proplist_key_valid(key) || !pa_utf8_valid(format))
         return -1;
 
     va_start(ap, format);
-    t = pa_vsprintf_malloc(format, ap);
+    v = pa_vsprintf_malloc(format, ap);
     va_end(ap);
 
-    r = pa_proplist_sets(p, key, t);
+    if (!pa_utf8_valid(v))
+        goto fail;
 
-    pa_xfree(t);
-    return r;
+    if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
+        prop = pa_xnew(struct property, 1);
+        prop->key = pa_xstrdup(key);
+        add = true;
+    } else
+        pa_xfree(prop->value);
+
+    prop->value = v;
+    prop->nbytes = strlen(v)+1;
+
+    if (add)
+        pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);
+
+    return 0;
+
+fail:
+    pa_xfree(v);
+    return -1;
 }
 
 int pa_proplist_set(pa_proplist *p, const char *key, const void *data, size_t nbytes) {
     struct property *prop;
-    pa_bool_t add = FALSE;
+    bool add = false;
 
     pa_assert(p);
     pa_assert(key);
+    pa_assert(data || nbytes == 0);
 
-    if (!property_name_valid(key))
+    if (!pa_proplist_key_valid(key))
         return -1;
 
     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
         prop = pa_xnew(struct property, 1);
         prop->key = pa_xstrdup(key);
-        add = TRUE;
+        add = true;
     } else
         pa_xfree(prop->value);
 
-    prop->value = pa_xmemdup(data, nbytes);
+    prop->value = pa_xmalloc(nbytes+1);
+    if (nbytes > 0)
+        memcpy(prop->value, data, nbytes);
+    ((char*) prop->value)[nbytes] = 0;
     prop->nbytes = nbytes;
 
     if (add)
@@ -157,7 +279,7 @@ const char *pa_proplist_gets(pa_proplist *p, const char *key) {
     pa_assert(p);
     pa_assert(key);
 
-    if (!property_name_valid(key))
+    if (!pa_proplist_key_valid(key))
         return NULL;
 
     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
@@ -183,8 +305,10 @@ int pa_proplist_get(pa_proplist *p, const char *key, const void **data, size_t *
 
     pa_assert(p);
     pa_assert(key);
+    pa_assert(data);
+    pa_assert(nbytes);
 
-    if (!property_name_valid(key))
+    if (!pa_proplist_key_valid(key))
         return -1;
 
     if (!(prop = pa_hashmap_get(MAKE_HASHMAP(p), key)))
@@ -196,7 +320,7 @@ int pa_proplist_get(pa_proplist *p, const char *key, const void **data, size_t *
     return 0;
 }
 
-void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, pa_proplist *other) {
+void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, const pa_proplist *other) {
     struct property *prop;
     void *state = NULL;
 
@@ -207,6 +331,8 @@ void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, pa_proplist *othe
     if (mode == PA_UPDATE_SET)
         pa_proplist_clear(p);
 
+    /* MAKE_HASHMAP turns the const pointer into a non-const pointer, but
+     * that's ok, because we don't modify the hashmap contents. */
     while ((prop = pa_hashmap_iterate(MAKE_HASHMAP(other), &state, NULL))) {
 
         if (mode == PA_UPDATE_MERGE && pa_proplist_contains(p, prop->key))
@@ -217,18 +343,15 @@ void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, pa_proplist *othe
 }
 
 int pa_proplist_unset(pa_proplist *p, const char *key) {
-    struct property *prop;
-
     pa_assert(p);
     pa_assert(key);
 
-    if (!property_name_valid(key))
+    if (!pa_proplist_key_valid(key))
         return -1;
 
-    if (!(prop = pa_hashmap_remove(MAKE_HASHMAP(p), key)))
+    if (pa_hashmap_remove_and_free(MAKE_HASHMAP(p), key) < 0)
         return -2;
 
-    property_free(prop);
     return 0;
 }
 
@@ -240,7 +363,7 @@ int pa_proplist_unset_many(pa_proplist *p, const char * const keys[]) {
     pa_assert(keys);
 
     for (k = keys; *k; k++)
-        if (!property_name_valid(*k))
+        if (!pa_proplist_key_valid(*k))
             return -1;
 
     for (k = keys; *k; k++)
@@ -275,9 +398,32 @@ char *pa_proplist_to_string_sep(pa_proplist *p, const char *sep) {
         if (!pa_strbuf_isempty(buf))
             pa_strbuf_puts(buf, sep);
 
-        if ((v = pa_proplist_gets(p, key)))
-            pa_strbuf_printf(buf, "%s = \"%s\"", key, v);
-        else {
+        if ((v = pa_proplist_gets(p, key))) {
+            const char *t;
+
+            pa_strbuf_printf(buf, "%s = \"", key);
+
+            for (t = v;;) {
+                size_t h;
+
+                h = strcspn(t, "\"");
+
+                if (h > 0)
+                    pa_strbuf_putsn(buf, t, h);
+
+                t += h;
+
+                if (*t == 0)
+                    break;
+
+                pa_assert(*t == '"');
+                pa_strbuf_puts(buf, "\\\"");
+
+                t++;
+            }
+
+            pa_strbuf_puts(buf, "\"");
+        } else {
             const void *value;
             size_t nbytes;
             char *c;
@@ -304,95 +450,196 @@ char *pa_proplist_to_string(pa_proplist *p) {
     return t;
 }
 
-/* Remove all whitepsapce from the beginning and the end of *s. *s may
- * be modified. (from conf-parser.c) */
-#define WHITESPACE " \t\n"
-#define in_string(c,s) (strchr(s,c) != NULL)
-
-static char *strip(char *s) {
-    char *b = s+strspn(s, WHITESPACE);
-    char *e, *l = NULL;
-
-    for (e = b; *e; e++)
-        if (!in_string(*e, WHITESPACE))
-            l = e;
+pa_proplist *pa_proplist_from_string(const char *s) {
+    enum {
+        WHITESPACE,
+        KEY,
+        AFTER_KEY,
+        VALUE_START,
+        VALUE_SIMPLE,
+        VALUE_DOUBLE_QUOTES,
+        VALUE_DOUBLE_QUOTES_ESCAPE,
+        VALUE_TICKS,
+        VALUE_TICKS_ESCAPED,
+        VALUE_HEX
+    } state;
+
+    pa_proplist *pl;
+    const char *p, *key = NULL, *value = NULL;
+    size_t key_len = 0, value_len = 0;
+
+    pa_assert(s);
+
+    pl = pa_proplist_new();
+
+    state = WHITESPACE;
+
+    for (p = s;; p++) {
+        switch (state) {
+
+            case WHITESPACE:
+                if (*p == 0)
+                    goto success;
+                else if (*p == '=')
+                    goto fail;
+                else if (!isspace(*p)) {
+                    key = p;
+                    state = KEY;
+                    key_len = 1;
+                }
+                break;
 
-    if (l)
-        *(l+1) = 0;
+            case KEY:
+                if (*p == 0)
+                    goto fail;
+                else if (*p == '=')
+                    state = VALUE_START;
+                else if (isspace(*p))
+                    state = AFTER_KEY;
+                else
+                    key_len++;
+                break;
 
-    return b;
-}
+            case AFTER_KEY:
+                if (*p == 0)
+                    goto fail;
+                else if (*p == '=')
+                    state = VALUE_START;
+                else if (!isspace(*p))
+                    goto fail;
+                break;
 
-pa_proplist *pa_proplist_from_string(const char *str) {
-    pa_proplist *p;
-    char *s, *v, *k, *e;
+            case VALUE_START:
+                if (*p == 0)
+                    goto fail;
+                else if (strncmp(p, "hex:", 4) == 0) {
+                    state = VALUE_HEX;
+                    value = p+4;
+                    value_len = 0;
+                    p += 3;
+                } else if (*p == '\'') {
+                    state = VALUE_TICKS;
+                    value = p+1;
+                    value_len = 0;
+                } else if (*p == '"') {
+                    state = VALUE_DOUBLE_QUOTES;
+                    value = p+1;
+                    value_len = 0;
+                } else if (!isspace(*p)) {
+                    state = VALUE_SIMPLE;
+                    value = p;
+                    value_len = 1;
+                }
+                break;
 
-    pa_assert(str);
-    pa_assert_se(p = pa_proplist_new());
-    pa_assert_se(s = strdup(str));
+            case VALUE_SIMPLE:
+                if (*p == 0 || isspace(*p)) {
+                    if (proplist_setn(pl, key, key_len, value, value_len) < 0)
+                        goto fail;
 
-    for (k = s; *k; k = e) {
-        k = k+strspn(k, WHITESPACE);
+                    if (*p == 0)
+                        goto success;
 
-        if (!*k)
-            break;
+                    state = WHITESPACE;
+                } else
+                    value_len++;
+                break;
 
-        if (!(v = strchr(k, '='))) {
-            pa_log("Missing '='.");
-            break;
-        }
+            case VALUE_DOUBLE_QUOTES:
+                if (*p == 0)
+                    goto fail;
+                else if (*p == '"') {
+                    char *v;
+
+                    v = pa_unescape(pa_xstrndup(value, value_len));
+
+                    if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
+                        pa_xfree(v);
+                        goto fail;
+                    }
+
+                    pa_xfree(v);
+                    state = WHITESPACE;
+                } else if (*p == '\\') {
+                    state = VALUE_DOUBLE_QUOTES_ESCAPE;
+                    value_len++;
+                } else
+                    value_len++;
+                break;
 
-        *v++ = '\0';
-        k = strip(k);
+            case VALUE_DOUBLE_QUOTES_ESCAPE:
+                if (*p == 0)
+                    goto fail;
+                else {
+                    state = VALUE_DOUBLE_QUOTES;
+                    value_len++;
+                }
+                break;
 
-        v = v+strspn(v, WHITESPACE);
-        if (*v == '"') {
-            v++;
-            if (!(e = strchr(v, '"'))) { /* FIXME: handle escape */
-                pa_log("Missing '\"' at end of string value.");
+            case VALUE_TICKS:
+                if (*p == 0)
+                    goto fail;
+                else if (*p == '\'') {
+                    char *v;
+
+                    v = pa_unescape(pa_xstrndup(value, value_len));
+
+                    if (proplist_setn(pl, key, key_len, v, strlen(v)) < 0) {
+                        pa_xfree(v);
+                        goto fail;
+                    }
+
+                    pa_xfree(v);
+                    state = WHITESPACE;
+                } else if (*p == '\\') {
+                    state = VALUE_TICKS_ESCAPED;
+                    value_len++;
+                } else
+                    value_len++;
                 break;
-            }
-            *e++ = '\0';
-            pa_proplist_sets(p, k, v);
-        } else {
-            uint8_t *blob;
 
-            if (*v++ != 'h' || *v++ != 'e' || *v++ != 'x' || *v++ != ':') {
-                pa_log("Value must be a string or \"hex:\"");
+            case VALUE_TICKS_ESCAPED:
+                if (*p == 0)
+                    goto fail;
+                else {
+                    state = VALUE_TICKS;
+                    value_len++;
+                }
                 break;
-            }
 
-            e = v;
-            while (in_string(*e, "0123456789abcdefABCDEF"))
-                ++e;
+            case VALUE_HEX:
+                if ((*p >= '0' && *p <= '9') ||
+                    (*p >= 'A' && *p <= 'F') ||
+                    (*p >= 'a' && *p <= 'f')) {
+                    value_len++;
+                } else if (*p == 0 || isspace(*p)) {
 
-            if ((e - v) % 2) {
-                pa_log("Invalid \"hex:\" value data");
-                break;
-            }
+                    if (proplist_sethex(pl, key, key_len, value, value_len) < 0)
+                        goto fail;
 
-            blob = pa_xmalloc((size_t)(e-v)/2);
-            if (pa_parsehex(v, blob, (e-v)/2) != (size_t)((e-v)/2)) {
-                pa_log("Invalid \"hex:\" value data");
-                pa_xfree(blob);
-                break;
-            }
+                    if (*p == 0)
+                        goto success;
 
-            pa_proplist_set(p, k, blob, (e-v)/2);
-            pa_xfree(blob);
+                    state = WHITESPACE;
+                } else
+                    goto fail;
+                break;
         }
     }
 
-    pa_xfree(s);
+success:
+    return MAKE_PROPLIST(pl);
 
-    return p;
+fail:
+    pa_proplist_free(pl);
+    return NULL;
 }
 
 int pa_proplist_contains(pa_proplist *p, const char *key) {
     pa_assert(p);
     pa_assert(key);
 
-    if (!property_name_valid(key))
+    if (!pa_proplist_key_valid(key))
         return -1;
 
     if (!(pa_hashmap_get(MAKE_HASHMAP(p), key)))
@@ -402,22 +649,20 @@ int pa_proplist_contains(pa_proplist *p, const char *key) {
 }
 
 void pa_proplist_clear(pa_proplist *p) {
-    struct property *prop;
     pa_assert(p);
 
-    while ((prop = pa_hashmap_steal_first(MAKE_HASHMAP(p))))
-        property_free(prop);
+    pa_hashmap_remove_all(MAKE_HASHMAP(p));
 }
 
-pa_proplist* pa_proplist_copy(pa_proplist *template) {
-    pa_proplist *p;
+pa_proplist* pa_proplist_copy(const pa_proplist *p) {
+    pa_proplist *copy;
 
-    pa_assert_se(p = pa_proplist_new());
+    pa_assert_se(copy = pa_proplist_new());
 
-    if (template)
-        pa_proplist_update(p, PA_UPDATE_REPLACE, template);
+    if (p)
+        pa_proplist_update(copy, PA_UPDATE_REPLACE, p);
 
-    return p;
+    return copy;
 }
 
 unsigned pa_proplist_size(pa_proplist *p) {
@@ -431,3 +676,32 @@ int pa_proplist_isempty(pa_proplist *p) {
 
     return pa_hashmap_isempty(MAKE_HASHMAP(p));
 }
+
+int pa_proplist_equal(pa_proplist *a, pa_proplist *b) {
+    const void *key = NULL;
+    struct property *a_prop = NULL;
+    struct property *b_prop = NULL;
+    void *state = NULL;
+
+    pa_assert(a);
+    pa_assert(b);
+
+    if (a == b)
+        return 1;
+
+    if (pa_proplist_size(a) != pa_proplist_size(b))
+        return 0;
+
+    while ((a_prop = pa_hashmap_iterate(MAKE_HASHMAP(a), &state, &key))) {
+        if (!(b_prop = pa_hashmap_get(MAKE_HASHMAP(b), key)))
+            return 0;
+
+        if (a_prop->nbytes != b_prop->nbytes)
+            return 0;
+
+        if (memcmp(a_prop->value, b_prop->value, a_prop->nbytes) != 0)
+            return 0;
+    }
+
+    return 1;
+}