chiark - git - mdw - disorder/blob - lib/kvp.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004, 2005, 2007, 2008 Richard Kettlewell
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file lib/kvp.c
  19  * @brief Linked list of key-value pairs
  20  *
  21  * Also supports URL encoding/decoding (of raw strings and kvp lists).
  22  *
  23  * For large sets of keys, see @ref lib/hash.c.
  24  */
  25
  26 #include "common.h"
  27
  28 #include "mem.h"
  29 #include "kvp.h"
  30 #include "log.h"
  31 #include "vector.h"
  32 #include "hex.h"
  33 #include "sink.h"
  34
  35 /** @brief Decode a URL-encoded string to a ink
  36  * @param sink Where to store result
  37  * @param ptr Start of string
  38  * @param n Length of string
  39  * @return 0 on success, non-0 if string could not be decoded or sink write failed
  40  */
  41 int urldecode(struct sink *sink, const char *ptr, size_t n) {
  42   int c, d1, d2;
  43
  44   while(n-- > 0) {
  45     switch(c = *ptr++) {
  46     case '%':
  47       if((d1 = unhexdigit(ptr[0])) == -1
  48          || (d2 = unhexdigit(ptr[1])) == -1)
  49         return -1;
  50       c  = d1 * 16 + d2;
  51       ptr += 2;
  52       n -= 2;
  53       break;
  54     case '+':
  55       c = ' ';
  56       break;
  57     default:
  58       break;
  59     }
  60     if(sink_writec(sink,c) < 0)
  61       return -1;
  62   }
  63   return 0;
  64 }
  65
  66 static char *decode(const char *ptr, size_t n) {
  67   struct dynstr d;
  68   struct sink *s;
  69
  70   dynstr_init(&d);
  71   s = sink_dynstr(&d);
  72   if(urldecode(s, ptr, n))
  73     return 0;
  74   dynstr_terminate(&d);
  75   return d.vec;
  76 }
  77
  78 /** @brief Decode a URL-decoded key-value pair list
  79  * @param ptr Start of input string
  80  * @param n Length of input string
  81  * @return @ref kvp of values from input
  82  *
  83  * The KVP is in the same order as the original input.
  84  *
  85  * If the original input contains duplicates names, so will the KVP.
  86  */
  87 struct kvp *kvp_urldecode(const char *ptr, size_t n) {
  88   struct kvp *kvp, **kk = &kvp, *k;
  89   const char *q, *r, *top = ptr + n, *next;
  90
  91   while(ptr < top) {
  92     *kk = k = xmalloc(sizeof *k);
  93     if(!(q = memchr(ptr, '=', top - ptr)))
  94       break;
  95     if(!(k->name = decode(ptr, q - ptr))) break;
  96     if((r = memchr(ptr, '&', top - ptr)))
  97       next = r + 1;
  98     else
  99       next = r = top;
 100     if(r < q)
 101       break;
 102     if(!(k->value = decode(q + 1, r - (q + 1)))) break;
 103     kk = &k->next;
 104     ptr = next;
 105   }
 106   *kk = 0;
 107   return kvp;
 108 }
 109
 110 /** @brief URL-encode a string to a sink
 111  * @param sink Where to send output
 112  * @param s String to encode
 113  * @param n Length of string to encode
 114  * @return 0 on success or non-0 if sink write failed
 115  */
 116 int urlencode(struct sink *sink, const char *s, size_t n) {
 117   unsigned char c;
 118
 119   while(n > 0) {
 120     c = *s++;
 121     n--;
 122     switch(c) {
 123     default:
 124       if((c >= '0' && c <= '9')
 125          || (c >= 'a' && c <= 'z')
 126          || (c >= 'A' && c <= 'Z')) {
 127         /* RFC2396 2.3 unreserved characters */
 128       case '-':
 129       case '_':
 130       case '.':
 131       case '!':
 132       case '~':
 133       case '*':
 134       case '\'':
 135       case '(':
 136       case ')':
 137         /* additional unreserved characters */
 138       case '/':
 139         if(sink_writec(sink, c) < 0)
 140           return -1;
 141       } else
 142         if(sink_printf(sink, "%%%02x", (unsigned int)c) < 0)
 143           return -1;
 144     }
 145   }
 146   return 0;
 147 }
 148
 149 /** @brief URL-encode @p s
 150  * @param s String to encode
 151  * @return Encoded string
 152  */
 153 char *urlencodestring(const char *s) {
 154   struct dynstr d;
 155
 156   dynstr_init(&d);
 157   urlencode(sink_dynstr(&d), s, strlen(s));
 158   dynstr_terminate(&d);
 159   return d.vec;
 160 }
 161
 162 /** @brief URL-decode @p s
 163  * @param s String to decode
 164  * @param ns Length of string
 165  * @return Decoded string or NULL
 166  */
 167 char *urldecodestring(const char *s, size_t ns) {
 168   struct dynstr d;
 169
 170   dynstr_init(&d);
 171   if(urldecode(sink_dynstr(&d), s, ns))
 172     return NULL;
 173   dynstr_terminate(&d);
 174   return d.vec;
 175 }
 176
 177 /** @brief URL-encode a KVP
 178  * @param kvp Linked list to encode
 179  * @param np Where to store length (or NULL)
 180  * @return Newly created string
 181  */
 182 char *kvp_urlencode(const struct kvp *kvp, size_t *np) {
 183   struct dynstr d;
 184   struct sink *sink;
 185
 186   dynstr_init(&d);
 187   sink = sink_dynstr(&d);
 188   while(kvp) {
 189     urlencode(sink, kvp->name, strlen(kvp->name));
 190     dynstr_append(&d, '=');
 191     urlencode(sink, kvp->value, strlen(kvp->value));
 192     if((kvp = kvp->next))
 193       dynstr_append(&d, '&');
 194
 195   }
 196   dynstr_terminate(&d);
 197   if(np)
 198     *np = d.nvec;
 199   return d.vec;
 200 }
 201
 202 /** @brief Set or remove a value in a @ref kvp
 203  * @param kvpp Address of KVP head to modify
 204  * @param name Key to search for
 205  * @param value New value or NULL to delete
 206  * @return 1 if any change was made otherwise 0
 207  *
 208  * If @p value is not NULL then the first matching key is replaced; if
 209  * there was no matching key a new one is added at the end.
 210  *
 211  * If @p value is NULL then the first matching key is removed.
 212  *
 213  * If anything actually changes the return value is 1.  If no actual
 214  * change is made then 0 is returned instead.
 215  */
 216 int kvp_set(struct kvp **kvpp, const char *name, const char *value) {
 217   struct kvp *k, **kk;
 218
 219   for(kk = kvpp; (k = *kk) && strcmp(name, k->name); kk = &k->next)
 220     ;
 221   if(k) {
 222     if(value) {
 223       if(strcmp(k->value, value)) {
 224         k->value = xstrdup(value);
 225         return 1;
 226       } else
 227         return 0;
 228     } else {
 229       *kk = k->next;
 230       return 1;
 231     }
 232   } else {
 233     if(value) {
 234       *kk = k = xmalloc(sizeof *k);
 235       k->name = xstrdup(name);
 236       k->value = xstrdup(value);
 237       return 1;
 238     } else
 239       return 0;
 240   }
 241 }
 242
 243 /** @brief Look up a value in a @ref kvp
 244  * @param kvp Head of KVP linked list
 245  * @param name Key to search for
 246  * @return Value or NULL
 247  *
 248  * The returned value is owned by the KVP so must not be modified or
 249  * freed.
 250  */
 251 const char *kvp_get(const struct kvp *kvp, const char *name) {
 252   for(;kvp && strcmp(kvp->name, name); kvp = kvp->next)
 253     ;
 254   return kvp ? kvp->value : 0;
 255 }
 256
 257 /** @brief Construct a KVP from arguments
 258  * @param name First name
 259  * @return Newly created KVP
 260  *
 261  * Arguments must come in name/value pairs and must be followed by a (char *)0.
 262  *
 263  * The order of the new KVP is not formally defined though the test
 264  * programs rely on it nonetheless so update them if you change it.
 265  */
 266 struct kvp *kvp_make(const char *name, ...) {
 267   const char *value;
 268   struct kvp *kvp = 0, *k;
 269   va_list ap;
 270
 271   va_start(ap, name);
 272   while(name) {
 273     value = va_arg(ap, const char *);
 274     k = xmalloc(sizeof *k);
 275     k->name = name;
 276     k->value = value ? xstrdup(value) : "";
 277     k->next = kvp;
 278     kvp = k;
 279     name = va_arg(ap, const char *);
 280   }
 281   va_end(ap);
 282   return kvp;
 283 }
 284
 285 /*
 286 Local Variables:
 287 c-basic-offset:2
 288 comment-column:40
 289 End:
 290 */