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