git.meshlink.io Git - catta/blob - libavahi-core/strlst.c

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