git.meshlink.io Git - catta/blob - avahi-common/strlst.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   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   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; 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 <stdarg.h>
  28
  29 #include "strlst.h"
  30
  31 AvahiStringList*avahi_string_list_add_anonymous(AvahiStringList *l, guint size) {
  32     AvahiStringList *n;
  33
  34     n = g_malloc(sizeof(AvahiStringList) + size);
  35     n->next = l;
  36     n->size = size;
  37
  38     return n;
  39 }
  40
  41 AvahiStringList *avahi_string_list_add_arbitrary(AvahiStringList *l, const guint8*text, guint size) {
  42     AvahiStringList *n;
  43
  44     g_assert(text);
  45
  46     n = avahi_string_list_add_anonymous(l, size);
  47
  48     if (size > 0)
  49         memcpy(n->text, text, size);
  50
  51     return n;
  52 }
  53
  54 AvahiStringList *avahi_string_list_add(AvahiStringList *l, const gchar *text) {
  55     g_assert(text);
  56
  57     return avahi_string_list_add_arbitrary(l, (const guint8*) text, strlen(text));
  58 }
  59
  60 AvahiStringList *avahi_string_list_parse(gconstpointer data, guint size) {
  61     AvahiStringList *r = NULL;
  62     const guint8 *c;
  63     g_assert(data);
  64
  65     c = data;
  66     for (;;) {
  67         guint k;
  68
  69         if (size < 1)
  70             break;
  71
  72         k = *(c++);
  73         r = avahi_string_list_add_arbitrary(r, c, k);
  74         c += k;
  75
  76         size -= 1 + k;
  77     }
  78
  79     return r;
  80 }
  81
  82 void avahi_string_list_free(AvahiStringList *l) {
  83     AvahiStringList *n;
  84
  85     while (l) {
  86         n = l->next;
  87         g_free(l);
  88         l = n;
  89     }
  90 }
  91
  92 AvahiStringList* avahi_string_list_reverse(AvahiStringList *l) {
  93     AvahiStringList *r = NULL, *n;
  94
  95     while (l) {
  96         n = l->next;
  97         l->next = r;
  98         r = l;
  99         l = n;
 100     }
 101
 102     return r;
 103 }
 104
 105 gchar* avahi_string_list_to_string(AvahiStringList *l) {
 106     AvahiStringList *n;
 107     guint s = 0;
 108     gchar *t, *e;
 109
 110     l = avahi_string_list_reverse(l);
 111
 112     for (n = l; n; n = n->next) {
 113         if (n != l)
 114             s ++;
 115
 116         s += n->size+2;
 117     }
 118
 119     t = e = g_new(gchar, s+1);
 120
 121     for (n = l; n; n = n->next) {
 122         if (n != l)
 123             *(e++) = ' ';
 124
 125         *(e++) = '"';
 126         strncpy(e, (gchar*) n->text, n->size);
 127         e[n->size] = 0;
 128         e = strchr(e, 0);
 129         *(e++) = '"';
 130
 131         g_assert(e);
 132     }
 133
 134     l = avahi_string_list_reverse(l);
 135
 136     *e = 0;
 137
 138     return t;
 139 }
 140
 141 guint avahi_string_list_serialize(AvahiStringList *l, gpointer data, guint size) {
 142     guint used = 0;
 143
 144     if (data) {
 145         guint8 *c;
 146         AvahiStringList *n;
 147
 148         g_assert(data);
 149
 150         l = avahi_string_list_reverse(l);
 151         c = data;
 152
 153         for (n = l; n; n = n->next) {
 154             guint k;
 155             if (size < 1)
 156                 break;
 157
 158             k = n->size;
 159             if (k > 255)
 160                 k = 255;
 161
 162             if (k > size-1)
 163                 k = size-1;
 164
 165             *(c++) = k;
 166             memcpy(c, n->text, k);
 167             c += k;
 168
 169             used += 1+ k;
 170         }
 171
 172         l = avahi_string_list_reverse(l);
 173     } else {
 174         AvahiStringList *n;
 175
 176         for (n = l; n; n = n->next) {
 177             guint k;
 178
 179             k = n->size;
 180             if (k > 255)
 181                 k = 255;
 182
 183             used += 1+k;
 184         }
 185     }
 186
 187     return used;
 188 }
 189
 190 gboolean avahi_string_list_equal(const AvahiStringList *a, const AvahiStringList *b) {
 191
 192     for (;;) {
 193         if (!a && !b)
 194             return TRUE;
 195
 196         if (!a || !b)
 197             return FALSE;
 198
 199         if (a->size != b->size)
 200             return FALSE;
 201
 202         if (a->size != 0 && memcmp(a->text, b->text, a->size) != 0)
 203             return FALSE;
 204
 205         a = a->next;
 206         b = b->next;
 207     }
 208 }
 209
 210 AvahiStringList *avahi_string_list_add_many(AvahiStringList *r, ...) {
 211     va_list va;
 212
 213     va_start(va, r);
 214     r = avahi_string_list_add_many_va(r, va);
 215     va_end(va);
 216
 217     return r;
 218 }
 219
 220 AvahiStringList *avahi_string_list_add_many_va(AvahiStringList *r, va_list va) {
 221     const gchar *txt;
 222
 223     while ((txt = va_arg(va, const gchar*)))
 224         r = avahi_string_list_add(r, txt);
 225
 226     return r;
 227 }
 228
 229
 230 AvahiStringList *avahi_string_list_new(const gchar *txt, ...) {
 231     va_list va;
 232     AvahiStringList *r = NULL;
 233
 234     if (txt) {
 235         r = avahi_string_list_add(r, txt);
 236
 237         va_start(va, txt);
 238         r = avahi_string_list_add_many_va(r, va);
 239         va_end(va);
 240     }
 241
 242     return r;
 243 }
 244
 245 AvahiStringList *avahi_string_list_new_va(va_list va) {
 246     return avahi_string_list_add_many_va(NULL, va);
 247 }
 248
 249 AvahiStringList *avahi_string_list_copy(const AvahiStringList *l) {
 250     AvahiStringList *r = NULL;
 251
 252     for (; l; l = l->next)
 253         r = avahi_string_list_add_arbitrary(r, l->text, l->size);
 254
 255     return avahi_string_list_reverse(r);
 256 }
 257
 258 AvahiStringList *avahi_string_list_new_from_array(const gchar *array[], gint length) {
 259     AvahiStringList *r = NULL;
 260     gint i;
 261
 262     g_assert(array);
 263
 264     for (i = 0; length >= 0 ? i < length : !!array[i]; i++)
 265         r = avahi_string_list_add(r, array[i]);
 266
 267     return r;
 268 }
 269
 270 guint avahi_string_list_length(const AvahiStringList *l) {
 271     guint n = 0;
 272
 273     for (; l; l = l->next)
 274         n++;
 275
 276     return n;
 277 }