path: root/src/pulse/proplist.c

/***
  This file is part of PulseAudio.

  Copyright 2007 Lennart Poettering

  PulseAudio is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  PulseAudio is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>
#include <ctype.h>

#include <pulse/xmalloc.h>
#include <pulse/utf8.h>

#include <pulsecore/hashmap.h>
#include <pulsecore/strbuf.h>
#include <pulsecore/core-util.h>

#include "proplist.h"

struct property {
    char *key;
    void *value;
    size_t nbytes;
};

#define MAKE_HASHMAP(p) ((pa_hashmap*) (p))
#define MAKE_HASHMAP_CONST(p) ((const pa_hashmap*) (p))
#define MAKE_PROPLIST(p) ((pa_proplist*) (p))

int pa_proplist_key_valid(const char *key) {

    if (!pa_ascii_valid(key))
        return 0;

    if (strlen(key) <= 0)
        return 0;

    return 1;
}

static void property_free(struct property *prop) {
    pa_assert(prop);

    pa_xfree(prop->key);
    pa_xfree(prop->value);
    pa_xfree(prop);
}

pa_proplist* pa_proplist_new(void) {
    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_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;
    bool add = false;

    pa_assert(p);
    pa_assert(key);
    pa_assert(value);

    if (!pa_proplist_key_valid(key) || !pa_utf8_valid(value))
        return -1;

    if (!(prop = pa_hashmap_get(MAKE_HASHMAP_CONST(p), key))) {
        prop = pa_xnew(struct property, 1);
        prop->key = pa_xstrdup(key);
        add = true;
    } else
        pa_xfree(prop->value);

    prop->value = pa_xstrdup(value);
    prop->nbytes = strlen(value)+1;

    if (add)
        pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);

    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_CONST(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_CONST(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;
    char *v;

    pa_assert(p);
    pa_assert(key);
    pa_assert(format);

    if (!pa_proplist_key_valid(key) || !pa_utf8_valid(format))
        return -1;

    va_start(ap, format);
    v = pa_vsprintf_malloc(format, ap);
    va_end(ap);

    if (!pa_utf8_valid(v))
        goto fail;

    if (!(prop = pa_hashmap_get(MAKE_HASHMAP_CONST(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;
    bool add = false;

    pa_assert(p);
    pa_assert(key);
    pa_assert(data || nbytes == 0);

    if (!pa_proplist_key_valid(key))
        return -1;

    if (!(prop = pa_hashmap_get(MAKE_HASHMAP_CONST(p), key))) {
        prop = pa_xnew(struct property, 1);
        prop->key = pa_xstrdup(key);
        add = true;
    } else
        pa_xfree(prop->value);

    prop->value = pa_xmalloc(nbytes+1);
    if (nbytes > 0)
        memcpy(prop->value, data, nbytes);
    ((char*) prop->value)[nbytes] = 0;
    prop->nbytes = nbytes;

    if (add)
        pa_hashmap_put(MAKE_HASHMAP(p), prop->key, prop);

    return 0;
}

const char *pa_proplist_gets(const pa_proplist *p, const char *key) {
    struct property *prop;

    pa_assert(p);
    pa_assert(key);

    if (!pa_proplist_key_valid(key))
        return NULL;

    if (!(prop = pa_hashmap_get(MAKE_HASHMAP_CONST(p), key)))
        return NULL;

    if (prop->nbytes <= 0)
        return NULL;

    if (((char*) prop->value)[prop->nbytes-1] != 0)
        return NULL;

    if (strlen((char*) prop->value) != prop->nbytes-1)
        return NULL;

    if (!pa_utf8_valid((char*) prop->value))
        return NULL;

    return (char*) prop->value;
}

int pa_proplist_get(const pa_proplist *p, const char *key, const void **data, size_t *nbytes) {
    struct property *prop;

    pa_assert(p);
    pa_assert(key);
    pa_assert(data);
    pa_assert(nbytes);

    if (!pa_proplist_key_valid(key))
        return -1;

    if (!(prop = pa_hashmap_get(MAKE_HASHMAP_CONST(p), key)))
        return -1;

    *data = prop->value;
    *nbytes = prop->nbytes;

    return 0;
}

void pa_proplist_update(pa_proplist *p, pa_update_mode_t mode, const pa_proplist *other) {
    struct property *prop;
    void *state = NULL;

    pa_assert(p);
    pa_assert(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE);
    pa_assert(other);

    if (mode == PA_UPDATE_SET)
        pa_proplist_clear(p);

    while ((prop = pa_hashmap_iterate(MAKE_HASHMAP_CONST(other), &state, NULL))) {

        if (mode == PA_UPDATE_MERGE && pa_proplist_contains(p, prop->key))
            continue;

        pa_assert_se(pa_proplist_set(p, prop->key, prop->value, prop->nbytes) == 0);
    }
}

int pa_proplist_unset(pa_proplist *p, const char *key) {
    pa_assert(p);
    pa_assert(key);

    if (!pa_proplist_key_valid(key))
        return -1;

    if (pa_hashmap_remove_and_free(MAKE_HASHMAP(p), key) < 0)
        return -2;

    return 0;
}

int pa_proplist_unset_many(pa_proplist *p, const char * const keys[]) {
    const char * const * k;
    int n = 0;

    pa_assert(p);
    pa_assert(keys);

    for (k = keys; *k; k++)
        if (!pa_proplist_key_valid(*k))
            return -1;

    for (k = keys; *k; k++)
        if (pa_proplist_unset(p, *k) >= 0)
            n++;

    return n;
}

const char *pa_proplist_iterate(const pa_proplist *p, void **state) {
    struct property *prop;

    if (!(prop = pa_hashmap_iterate(MAKE_HASHMAP_CONST(p), state, NULL)))
        return NULL;

    return prop->key;
}

char *pa_proplist_to_string_sep(const pa_proplist *p, const char *sep) {
    const char *key;
    void *state = NULL;
    pa_strbuf *buf;

    pa_assert(p);
    pa_assert(sep);

    buf = pa_strbuf_new();

    while ((key = pa_proplist_iterate(p, &state))) {
        const char *v;

        if (!pa_strbuf_isempty(buf))
            pa_strbuf_puts(buf, sep);

        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;

            pa_assert_se(pa_proplist_get(p, key, &value, &nbytes) == 0);
            c = pa_xmalloc(nbytes*2+1);
            pa_hexstr((const uint8_t*) value, nbytes, c, nbytes*2+1);

            pa_strbuf_printf(buf, "%s = hex:%s", key, c);
            pa_xfree(c);
        }
    }

    return pa_strbuf_to_string_free(buf);
}

char *pa_proplist_to_string(const pa_proplist *p) {
    char *s, *t;

    s = pa_proplist_to_string_sep(p, "\n");
    t = pa_sprintf_malloc("%s\n", s);
    pa_xfree(s);

    return t;
}

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((unsigned char)*p)) {
                    key = p;
                    state = KEY;
                    key_len = 1;
                }
                break;

            case KEY:
                if (*p == 0)
                    goto fail;
                else if (*p == '=')
                    state = VALUE_START;
                else if (isspace((unsigned char)*p))
                    state = AFTER_KEY;
                else
                    key_len++;
                break;

            case AFTER_KEY:
                if (*p == 0)
                    goto fail;
                else if (*p == '=')
                    state = VALUE_START;
                else if (!isspace((unsigned char)*p))
                    goto fail;
                break;

            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((unsigned char)*p)) {
                    state = VALUE_SIMPLE;
                    value = p;
                    value_len = 1;
                }
                break;

            case VALUE_SIMPLE:
                if (*p == 0 || isspace((unsigned char)*p)) {
                    if (proplist_setn(pl, key, key_len, value, value_len) < 0)
                        goto fail;

                    if (*p == 0)
                        goto success;

                    state = WHITESPACE;
                } else
                    value_len++;
                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;

            case VALUE_DOUBLE_QUOTES_ESCAPE:
                if (*p == 0)
                    goto fail;
                else {
                    state = VALUE_DOUBLE_QUOTES;
                    value_len++;
                }
                break;

            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;

            case VALUE_TICKS_ESCAPED:
                if (*p == 0)
                    goto fail;
                else {
                    state = VALUE_TICKS;
                    value_len++;
                }
                break;

            case VALUE_HEX:
                if ((*p >= '0' && *p <= '9') ||
                    (*p >= 'A' && *p <= 'F') ||
                    (*p >= 'a' && *p <= 'f')) {
                    value_len++;
                } else if (*p == 0 || isspace((unsigned char)*p)) {

                    if (proplist_sethex(pl, key, key_len, value, value_len) < 0)
                        goto fail;

                    if (*p == 0)
                        goto success;

                    state = WHITESPACE;
                } else
                    goto fail;
                break;
        }
    }

success:
    return MAKE_PROPLIST(pl);

fail:
    pa_proplist_free(pl);
    return NULL;
}

int pa_proplist_contains(const pa_proplist *p, const char *key) {
    pa_assert(p);
    pa_assert(key);

    if (!pa_proplist_key_valid(key))
        return -1;

    if (!(pa_hashmap_get(MAKE_HASHMAP_CONST(p), key)))
        return 0;

    return 1;
}

void pa_proplist_clear(pa_proplist *p) {
    pa_assert(p);

    pa_hashmap_remove_all(MAKE_HASHMAP(p));
}

pa_proplist* pa_proplist_copy(const pa_proplist *p) {
    pa_proplist *copy;

    pa_assert_se(copy = pa_proplist_new());

    if (p)
        pa_proplist_update(copy, PA_UPDATE_REPLACE, p);

    return copy;
}

unsigned pa_proplist_size(const pa_proplist *p) {
    pa_assert(p);

    return pa_hashmap_size(MAKE_HASHMAP_CONST(p));
}

int pa_proplist_isempty(const pa_proplist *p) {
    pa_assert(p);

    return pa_hashmap_isempty(MAKE_HASHMAP_CONST(p));
}

int pa_proplist_equal(const pa_proplist *a, const 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_CONST(a), &state, &key))) {
        if (!(b_prop = pa_hashmap_get(MAKE_HASHMAP_CONST(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;
}