git.meshlink.io Git - catta/blob - avahi-core/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_arbitrary(AvahiStringList *l, const guint8*text, guint size) {
  32     AvahiStringList *n;
  33
  34     g_assert(text);
  35
  36     n = g_malloc(sizeof(AvahiStringList) + size);
  37     n->next = l;
  38     memcpy(n->text, text, n->size = size);
  39
  40     return n;
  41 }
  42
  43 AvahiStringList *avahi_string_list_add(AvahiStringList *l, const gchar *text) {
  44     g_assert(text);
  45
  46     return avahi_string_list_add_arbitrary(l, (const guint8*) text, strlen(text));
  47 }
  48
  49 AvahiStringList *avahi_string_list_parse(gconstpointer data, guint size) {
  50     AvahiStringList *r = NULL;
  51     const guint8 *c;
  52     g_assert(data);
  53
  54     c = data;
  55     for (;;) {
  56         guint k;
  57
  58         if (size < 1)
  59             break;
  60
  61         k = *(c++);
  62         r = avahi_string_list_add_arbitrary(r, c, k);
  63         c += k;
  64
  65         size -= 1 + k;
  66     }
  67
  68     return r;
  69 }
  70
  71 void avahi_string_list_free(AvahiStringList *l) {
  72     AvahiStringList *n;
  73
  74     while (l) {
  75         n = l->next;
  76         g_free(l);
  77         l = n;
  78     }
  79 }
  80
  81 static AvahiStringList* string_list_reverse(AvahiStringList *l) {
  82     AvahiStringList *r = NULL, *n;
  83
  84     while (l) {
  85         n = l->next;
  86         l->next = r;
  87         r = l;
  88         l = n;
  89     }
  90
  91     return r;
  92 }
  93
  94 gchar* avahi_string_list_to_string(AvahiStringList *l) {
  95     AvahiStringList *n;
  96     guint s = 0;
  97     gchar *t, *e;
  98
  99     l = string_list_reverse(l);
 100
 101     for (n = l; n; n = n->next) {
 102         if (n != l)
 103             s ++;
 104
 105         s += n->size+3;
 106     }
 107
 108     t = e = g_new(gchar, s);
 109
 110     for (n = l; n; n = n->next) {
 111         if (n != l)
 112             *(e++) = ' ';
 113
 114         *(e++) = '"';
 115         strncpy(e, (gchar*) n->text, n->size);
 116         e[n->size] = 0;
 117         e = strchr(e, 0);
 118         *(e++) = '"';
 119     }
 120
 121     l = string_list_reverse(l);
 122
 123     *e = 0;
 124
 125     return t;
 126 }
 127
 128 guint avahi_string_list_serialize(AvahiStringList *l, gpointer data, guint size) {
 129     guint used = 0;
 130
 131     if (data) {
 132         guint8 *c;
 133         AvahiStringList *n;
 134
 135         g_assert(data);
 136
 137         l = string_list_reverse(l);
 138         c = data;
 139
 140         for (n = l; n; n = n->next) {
 141             guint k;
 142             if (size < 1)
 143                 break;
 144
 145             k = n->size;
 146             if (k > 255)
 147                 k = 255;
 148
 149             if (k > size-1)
 150                 k = size-1;
 151
 152             *(c++) = k;
 153             memcpy(c, n->text, k);
 154             c += k;
 155
 156             used += 1+ k;
 157         }
 158
 159         l = string_list_reverse(l);
 160     } else {
 161         AvahiStringList *n;
 162
 163         for (n = l; n; n = n->next) {
 164             guint k;
 165
 166             k = n->size;
 167             if (k > 255)
 168                 k = 255;
 169
 170             used += 1+k;
 171         }
 172     }
 173
 174     return used;
 175 }
 176
 177 gboolean avahi_string_list_equal(AvahiStringList *a, AvahiStringList *b) {
 178
 179     for (;;) {
 180         if (!a && !b)
 181             return TRUE;
 182
 183         if (!a || !b)
 184             return FALSE;
 185
 186         if (a->size != b->size)
 187             return FALSE;
 188
 189         if (a->size != 0 && memcmp(a->text, b->text, a->size) != 0)
 190             return FALSE;
 191
 192         a = a->next;
 193         b = b->next;
 194     }
 195 }
 196
 197 AvahiStringList *avahi_string_list_add_many(AvahiStringList *r, ...) {
 198     va_list va;
 199
 200     va_start(va, r);
 201     r = avahi_string_list_add_many_va(r, va);
 202     va_end(va);
 203
 204     return r;
 205 }
 206
 207 AvahiStringList *avahi_string_list_add_many_va(AvahiStringList *r, va_list va) {
 208     const gchar *txt;
 209
 210     while ((txt = va_arg(va, const gchar*)))
 211         r = avahi_string_list_add(r, txt);
 212
 213     return r;
 214 }
 215
 216
 217 AvahiStringList *avahi_string_list_new(const gchar *txt, ...) {
 218     va_list va;
 219     AvahiStringList *r = NULL;
 220
 221     if (txt) {
 222         r = avahi_string_list_add(r, txt);
 223
 224         va_start(va, txt);
 225         r = avahi_string_list_add_many_va(r, va);
 226         va_end(va);
 227     }
 228
 229     return r;
 230 }
 231
 232 AvahiStringList *avahi_string_list_new_va(va_list va) {
 233     return avahi_string_list_add_many_va(NULL, va);
 234 }
 235
 236 AvahiStringList *avahi_string_list_copy(AvahiStringList *l) {
 237     AvahiStringList *r = NULL;
 238
 239     for (; l; l = l->next)
 240         r = avahi_string_list_add_arbitrary(r, l->text, l->size);
 241
 242     return string_list_reverse(r);
 243 }