code.delx.au - pulseaudio/blob - src/modules/rtp/headerlist.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2008 Colin Guthrie
   5   Copyright 2007 Lennart Poettering
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as
   9   published by the Free Software Foundation; either version 2.1 of the
  10   License, or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public
  18   License along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <string.h>
  28
  29 #include <pulse/xmalloc.h>
  30
  31 #include <pulsecore/hashmap.h>
  32 #include <pulsecore/strbuf.h>
  33 #include <pulsecore/core-util.h>
  34
  35 #include "headerlist.h"
  36
  37 struct header {
  38     char *key;
  39     void *value;
  40     size_t nbytes;
  41 };
  42
  43 #define MAKE_HASHMAP(p) ((pa_hashmap*) (p))
  44 #define MAKE_HEADERLIST(p) ((pa_headerlist*) (p))
  45
  46 static void header_free(struct header *hdr) {
  47     pa_assert(hdr);
  48
  49     pa_xfree(hdr->key);
  50     pa_xfree(hdr->value);
  51     pa_xfree(hdr);
  52 }
  53
  54 pa_headerlist* pa_headerlist_new(void) {
  55     return MAKE_HEADERLIST(pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) header_free));
  56 }
  57
  58 void pa_headerlist_free(pa_headerlist* p) {
  59     pa_hashmap_free(MAKE_HASHMAP(p));
  60 }
  61
  62 int pa_headerlist_puts(pa_headerlist *p, const char *key, const char *value) {
  63     struct header *hdr;
  64     bool add = false;
  65
  66     pa_assert(p);
  67     pa_assert(key);
  68
  69     if (!(hdr = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
  70         hdr = pa_xnew(struct header, 1);
  71         hdr->key = pa_xstrdup(key);
  72         add = true;
  73     } else
  74         pa_xfree(hdr->value);
  75
  76     hdr->value = pa_xstrdup(value);
  77     hdr->nbytes = strlen(value)+1;
  78
  79     if (add)
  80         pa_hashmap_put(MAKE_HASHMAP(p), hdr->key, hdr);
  81
  82     return 0;
  83 }
  84
  85 int pa_headerlist_putsappend(pa_headerlist *p, const char *key, const char *value) {
  86     struct header *hdr;
  87     bool add = false;
  88
  89     pa_assert(p);
  90     pa_assert(key);
  91
  92     if (!(hdr = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
  93         hdr = pa_xnew(struct header, 1);
  94         hdr->key = pa_xstrdup(key);
  95         hdr->value = pa_xstrdup(value);
  96         add = true;
  97     } else {
  98         void *newval = pa_sprintf_malloc("%s%s", (char*)hdr->value, value);
  99         pa_xfree(hdr->value);
 100         hdr->value = newval;
 101     }
 102     hdr->nbytes = strlen(hdr->value)+1;
 103
 104     if (add)
 105         pa_hashmap_put(MAKE_HASHMAP(p), hdr->key, hdr);
 106
 107     return 0;
 108 }
 109
 110 const char *pa_headerlist_gets(pa_headerlist *p, const char *key) {
 111     struct header *hdr;
 112
 113     pa_assert(p);
 114     pa_assert(key);
 115
 116     if (!(hdr = pa_hashmap_get(MAKE_HASHMAP(p), key)))
 117         return NULL;
 118
 119     if (hdr->nbytes <= 0)
 120         return NULL;
 121
 122     if (((char*) hdr->value)[hdr->nbytes-1] != 0)
 123         return NULL;
 124
 125     if (strlen((char*) hdr->value) != hdr->nbytes-1)
 126         return NULL;
 127
 128     return (char*) hdr->value;
 129 }
 130
 131 int pa_headerlist_remove(pa_headerlist *p, const char *key) {
 132     pa_assert(p);
 133     pa_assert(key);
 134
 135     return pa_hashmap_remove_and_free(MAKE_HASHMAP(p), key);
 136 }
 137
 138 const char *pa_headerlist_iterate(pa_headerlist *p, void **state) {
 139     struct header *hdr;
 140
 141     if (!(hdr = pa_hashmap_iterate(MAKE_HASHMAP(p), state, NULL)))
 142         return NULL;
 143
 144     return hdr->key;
 145 }
 146
 147 char *pa_headerlist_to_string(pa_headerlist *p) {
 148     const char *key;
 149     void *state = NULL;
 150     pa_strbuf *buf;
 151
 152     pa_assert(p);
 153
 154     buf = pa_strbuf_new();
 155
 156     while ((key = pa_headerlist_iterate(p, &state))) {
 157
 158         const char *v;
 159
 160         if ((v = pa_headerlist_gets(p, key)))
 161             pa_strbuf_printf(buf, "%s: %s\r\n", key, v);
 162     }
 163
 164     return pa_strbuf_tostring_free(buf);
 165 }
 166
 167 int pa_headerlist_contains(pa_headerlist *p, const char *key) {
 168     pa_assert(p);
 169     pa_assert(key);
 170
 171     if (!(pa_hashmap_get(MAKE_HASHMAP(p), key)))
 172         return 0;
 173
 174     return 1;
 175 }