]> git.meshlink.io Git - catta/blob - avahi-common/strlst.c
d4d67da2d9d3c9250f27034fbe90f454efca5dc4
[catta] / 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_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 AvahiStringList* avahi_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 = avahi_string_list_reverse(l);
100     
101     for (n = l; n; n = n->next) {
102         if (n != l)
103             s ++;
104
105         s += n->size+2;
106     }
107
108     t = e = g_new(gchar, s+1);
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         g_assert(e);
121     }
122
123     l = avahi_string_list_reverse(l);
124     
125     *e = 0;
126
127     return t;
128 }
129
130 guint avahi_string_list_serialize(AvahiStringList *l, gpointer data, guint size) {
131     guint used = 0;
132
133     if (data) {
134         guint8 *c;
135         AvahiStringList *n;
136     
137         g_assert(data);
138         
139         l = avahi_string_list_reverse(l);
140         c = data;
141         
142         for (n = l; n; n = n->next) {
143             guint k;
144             if (size < 1)
145                 break;
146             
147             k = n->size;
148             if (k > 255)
149                 k = 255;
150             
151             if (k > size-1)
152                 k = size-1;
153             
154             *(c++) = k;
155             memcpy(c, n->text, k);
156             c += k;
157             
158             used += 1+ k;
159         }
160         
161         l = avahi_string_list_reverse(l);
162     } else {
163         AvahiStringList *n;
164
165         for (n = l; n; n = n->next) {
166             guint k;
167         
168             k = n->size;
169             if (k > 255)
170                 k = 255;
171             
172             used += 1+k;
173         }
174     }
175
176     return used;
177 }
178
179 gboolean avahi_string_list_equal(const AvahiStringList *a, const AvahiStringList *b) {
180
181     for (;;) {
182         if (!a && !b)
183             return TRUE;
184
185         if (!a || !b)
186             return FALSE;
187
188         if (a->size != b->size)
189             return FALSE;
190
191         if (a->size != 0 && memcmp(a->text, b->text, a->size) != 0)
192             return FALSE;
193
194         a = a->next;
195         b = b->next;
196     }
197 }
198
199 AvahiStringList *avahi_string_list_add_many(AvahiStringList *r, ...) {
200     va_list va;
201
202     va_start(va, r);
203     r = avahi_string_list_add_many_va(r, va);
204     va_end(va);
205     
206     return r;
207 }
208
209 AvahiStringList *avahi_string_list_add_many_va(AvahiStringList *r, va_list va) {
210     const gchar *txt;
211
212     while ((txt = va_arg(va, const gchar*)))
213         r = avahi_string_list_add(r, txt);
214
215     return r;
216 }
217
218
219 AvahiStringList *avahi_string_list_new(const gchar *txt, ...) {
220     va_list va;
221     AvahiStringList *r = NULL;
222
223     if (txt) {
224         r = avahi_string_list_add(r, txt);
225
226         va_start(va, txt);
227         r = avahi_string_list_add_many_va(r, va);
228         va_end(va);
229     }
230
231     return r;
232 }
233
234 AvahiStringList *avahi_string_list_new_va(va_list va) {
235     return avahi_string_list_add_many_va(NULL, va);
236 }
237
238 AvahiStringList *avahi_string_list_copy(const AvahiStringList *l) {
239     AvahiStringList *r = NULL;
240
241     for (; l; l = l->next)
242         r = avahi_string_list_add_arbitrary(r, l->text, l->size);
243
244     return avahi_string_list_reverse(r);
245 }
246
247 AvahiStringList *avahi_string_list_new_from_array(const gchar *array[], gint length) {
248     AvahiStringList *r = NULL;
249     gint i;
250
251     g_assert(array);
252
253     for (i = 0; length >= 0 ? i < length : !!array[i]; i++)
254         r = avahi_string_list_add(r, array[i]);
255
256     return r;
257 }
258
259 guint avahi_string_list_length(const AvahiStringList *l) {
260     guint n = 0;
261
262     for (; l; l = l->next)
263         n++;
264
265     return n;
266 }