7131
|
1 /**
|
|
2 * @file xmlnode.c XML DOM functions
|
|
3 *
|
|
4 * gaim
|
|
5 *
|
8046
|
6 * Gaim is the legal property of its developers, whose names are too numerous
|
|
7 * to list here. Please refer to the COPYRIGHT file distributed with this
|
|
8 * source distribution.
|
7131
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; either version 2 of the License, or
|
|
13 * (at your option) any later version.
|
|
14 *
|
|
15 * This program is distributed in the hope that it will be useful,
|
|
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
18 * GNU General Public License for more details.
|
|
19 *
|
|
20 * You should have received a copy of the GNU General Public License
|
|
21 * along with this program; if not, write to the Free Software
|
|
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
23 */
|
|
24
|
|
25 /* A lot of this code at least resembles the code in libxode, but since
|
|
26 * libxode uses memory pools that we simply have no need for, I decided to
|
|
27 * write my own stuff. Also, re-writing this lets me be as lightweight
|
|
28 * as I want to be. Thank you libxode for giving me a good starting point */
|
|
29
|
|
30 #include "internal.h"
|
|
31
|
|
32 #include <string.h>
|
|
33 #include <glib.h>
|
|
34
|
|
35 #include "xmlnode.h"
|
|
36
|
|
37 static xmlnode*
|
8135
|
38 new_node(const char *name, XMLNodeType type)
|
7131
|
39 {
|
|
40 xmlnode *node = g_new0(xmlnode, 1);
|
10423
|
41
|
7131
|
42 if(name)
|
|
43 node->name = g_strdup(name);
|
|
44 node->type = type;
|
|
45
|
|
46 return node;
|
|
47 }
|
|
48
|
|
49 xmlnode*
|
|
50 xmlnode_new(const char *name)
|
|
51 {
|
|
52 g_return_val_if_fail(name != NULL, NULL);
|
|
53
|
8135
|
54 return new_node(name, XMLNODE_TYPE_TAG);
|
7131
|
55 }
|
|
56
|
10423
|
57 xmlnode*
|
|
58 xmlnode_new_with_data(const char *name, const char *data, size_t size)
|
|
59 {
|
|
60 xmlnode *node;
|
|
61
|
|
62 g_return_val_if_fail(name != NULL, NULL);
|
|
63 g_return_val_if_fail(data != NULL, NULL);
|
|
64 g_return_val_if_fail(size != 0, NULL);
|
|
65
|
|
66 node = new_node(name, XMLNODE_TYPE_TAG);
|
|
67 xmlnode_insert_data(node, data, size);
|
|
68
|
|
69 return node;
|
|
70 }
|
|
71
|
|
72 xmlnode *
|
|
73 xmlnode_new_child(xmlnode *parent, const char *name)
|
7131
|
74 {
|
|
75 xmlnode *node;
|
|
76
|
|
77 g_return_val_if_fail(parent != NULL, NULL);
|
|
78 g_return_val_if_fail(name != NULL, NULL);
|
|
79
|
8135
|
80 node = new_node(name, XMLNODE_TYPE_TAG);
|
7131
|
81
|
|
82 xmlnode_insert_child(parent, node);
|
|
83
|
|
84 return node;
|
|
85 }
|
|
86
|
10423
|
87 xmlnode *
|
|
88 xmlnode_new_child_with_data(xmlnode *parent, const char *name,
|
|
89 const char *data, size_t size)
|
|
90 {
|
|
91 xmlnode *node;
|
|
92
|
|
93 g_return_val_if_fail(parent != NULL, NULL);
|
|
94 g_return_val_if_fail(name != NULL, NULL);
|
|
95 g_return_val_if_fail(data != NULL, NULL);
|
|
96 g_return_val_if_fail(size != 0, NULL);
|
|
97
|
|
98 node = new_node(name, XMLNODE_TYPE_TAG);
|
|
99 xmlnode_insert_data(node, data, size);
|
|
100
|
|
101 xmlnode_insert_child(parent, node);
|
|
102
|
|
103 return node;
|
|
104 }
|
|
105
|
7131
|
106 void
|
|
107 xmlnode_insert_child(xmlnode *parent, xmlnode *child)
|
|
108 {
|
|
109 g_return_if_fail(parent != NULL);
|
|
110 g_return_if_fail(child != NULL);
|
|
111
|
|
112 child->parent = parent;
|
|
113
|
|
114 if(parent->child) {
|
|
115 xmlnode *x;
|
|
116 for(x = parent->child; x->next; x = x->next);
|
|
117 x->next = child;
|
|
118 } else {
|
|
119 parent->child = child;
|
|
120 }
|
|
121 }
|
|
122
|
|
123 void
|
10415
|
124 xmlnode_insert_data(xmlnode *node, const char *data, size_t size)
|
7131
|
125 {
|
10415
|
126 xmlnode *child;
|
7131
|
127 size_t real_size;
|
|
128
|
10415
|
129 g_return_if_fail(node != NULL);
|
7131
|
130 g_return_if_fail(data != NULL);
|
|
131 g_return_if_fail(size != 0);
|
|
132
|
|
133 real_size = size == -1 ? strlen(data) : size;
|
|
134
|
10415
|
135 child = new_node(NULL, XMLNODE_TYPE_DATA);
|
7131
|
136
|
10415
|
137 child->data = g_memdup(data, real_size);
|
|
138 child->data_sz = real_size;
|
7131
|
139
|
10415
|
140 xmlnode_insert_child(node, child);
|
7131
|
141 }
|
|
142
|
|
143 void
|
|
144 xmlnode_remove_attrib(xmlnode *node, const char *attr)
|
|
145 {
|
|
146 xmlnode *attr_node, *sibling = NULL;
|
|
147
|
|
148 g_return_if_fail(node != NULL);
|
|
149 g_return_if_fail(attr != NULL);
|
|
150
|
|
151 for(attr_node = node->child; attr_node; attr_node = attr_node->next)
|
|
152 {
|
8135
|
153 if(attr_node->type == XMLNODE_TYPE_ATTRIB &&
|
7131
|
154 !strcmp(attr_node->name, attr)) {
|
|
155 if(node->child == attr_node) {
|
|
156 node->child = attr_node->next;
|
|
157 } else {
|
|
158 sibling->next = attr_node->next;
|
|
159 }
|
|
160 xmlnode_free(attr_node);
|
|
161 return;
|
|
162 }
|
|
163 sibling = attr_node;
|
|
164 }
|
|
165 }
|
|
166
|
|
167 void
|
|
168 xmlnode_set_attrib(xmlnode *node, const char *attr, const char *value)
|
|
169 {
|
|
170 xmlnode *attrib_node;
|
|
171
|
|
172 g_return_if_fail(node != NULL);
|
|
173 g_return_if_fail(attr != NULL);
|
|
174 g_return_if_fail(value != NULL);
|
|
175
|
|
176 xmlnode_remove_attrib(node, attr);
|
|
177
|
8135
|
178 attrib_node = new_node(attr, XMLNODE_TYPE_ATTRIB);
|
7131
|
179
|
|
180 attrib_node->data = g_strdup(value);
|
|
181
|
|
182 xmlnode_insert_child(node, attrib_node);
|
|
183 }
|
|
184
|
|
185 const char*
|
|
186 xmlnode_get_attrib(xmlnode *node, const char *attr)
|
|
187 {
|
|
188 xmlnode *x;
|
|
189
|
|
190 g_return_val_if_fail(node != NULL, NULL);
|
|
191
|
|
192 for(x = node->child; x; x = x->next) {
|
8135
|
193 if(x->type == XMLNODE_TYPE_ATTRIB && !strcmp(attr, x->name)) {
|
7131
|
194 return x->data;
|
|
195 }
|
|
196 }
|
|
197
|
|
198 return NULL;
|
|
199 }
|
|
200
|
10423
|
201 void
|
|
202 xmlnode_free(xmlnode *node)
|
7131
|
203 {
|
|
204 xmlnode *x, *y;
|
|
205
|
|
206 g_return_if_fail(node != NULL);
|
|
207
|
|
208 x = node->child;
|
|
209 while(x) {
|
|
210 y = x->next;
|
|
211 xmlnode_free(x);
|
|
212 x = y;
|
|
213 }
|
|
214
|
|
215 if(node->name)
|
|
216 g_free(node->name);
|
|
217 if(node->data)
|
|
218 g_free(node->data);
|
|
219 g_free(node);
|
|
220 }
|
|
221
|
|
222 xmlnode*
|
8262
|
223 xmlnode_get_child_with_namespace(xmlnode *parent, const char *name, const char *ns)
|
7131
|
224 {
|
|
225 xmlnode *x, *ret = NULL;
|
|
226 char **names;
|
|
227 char *parent_name, *child_name;
|
|
228
|
|
229 g_return_val_if_fail(parent != NULL, NULL);
|
|
230
|
|
231 names = g_strsplit(name, "/", 2);
|
|
232 parent_name = names[0];
|
|
233 child_name = names[1];
|
|
234
|
|
235 for(x = parent->child; x; x = x->next) {
|
8262
|
236 const char *xmlns = NULL;
|
|
237 if(ns)
|
|
238 xmlns = xmlnode_get_attrib(x, "xmlns");
|
|
239
|
|
240 if(x->type == XMLNODE_TYPE_TAG && name && !strcmp(parent_name, x->name)
|
|
241 && (!ns || (xmlns && !strcmp(ns, xmlns)))) {
|
7131
|
242 ret = x;
|
|
243 break;
|
|
244 }
|
|
245 }
|
|
246
|
|
247 if(child_name && ret)
|
8262
|
248 ret = xmlnode_get_child(ret, child_name);
|
7131
|
249
|
|
250 g_strfreev(names);
|
|
251 return ret;
|
|
252 }
|
|
253
|
8262
|
254 xmlnode*
|
|
255 xmlnode_get_child(xmlnode *parent, const char *name)
|
|
256 {
|
|
257 return xmlnode_get_child_with_namespace(parent, name, NULL);
|
|
258 }
|
|
259
|
7131
|
260 char *
|
|
261 xmlnode_get_data(xmlnode *node)
|
|
262 {
|
|
263 GString *str = NULL;
|
|
264 xmlnode *c;
|
|
265
|
|
266 g_return_val_if_fail(node != NULL, NULL);
|
|
267
|
|
268
|
|
269 for(c = node->child; c; c = c->next) {
|
8135
|
270 if(c->type == XMLNODE_TYPE_DATA) {
|
7131
|
271 if(!str)
|
|
272 str = g_string_new("");
|
|
273 str = g_string_append_len(str, c->data, c->data_sz);
|
|
274 }
|
|
275 }
|
|
276
|
10331
|
277 if (str == NULL)
|
|
278 return NULL;
|
7131
|
279
|
10331
|
280 return g_string_free(str, FALSE);
|
7131
|
281 }
|
|
282
|
10423
|
283 static gchar *
|
|
284 xmlnode_to_str_helper(xmlnode *node, int *len, gboolean formatting, int depth)
|
7131
|
285 {
|
|
286 GString *text = g_string_new("");
|
|
287 xmlnode *c;
|
9837
|
288 char *node_name, *esc, *esc2, *tab = NULL;
|
9838
|
289 gboolean need_end = FALSE, pretty = formatting;
|
9837
|
290 #ifdef _WIN32
|
|
291 static const char *newline = "\r\n";
|
|
292 #else
|
|
293 static const char *newline = "\n";
|
|
294 #endif
|
|
295
|
|
296 if(pretty && depth) {
|
|
297 tab = g_strnfill(depth, '\t');
|
|
298 text = g_string_append(text, tab);
|
|
299 }
|
7131
|
300
|
|
301 node_name = g_markup_escape_text(node->name, -1);
|
|
302 g_string_append_printf(text, "<%s", node_name);
|
|
303
|
|
304 for(c = node->child; c; c = c->next)
|
|
305 {
|
8135
|
306 if(c->type == XMLNODE_TYPE_ATTRIB) {
|
7131
|
307 esc = g_markup_escape_text(c->name, -1);
|
|
308 esc2 = g_markup_escape_text(c->data, -1);
|
|
309 g_string_append_printf(text, " %s='%s'", esc, esc2);
|
|
310 g_free(esc);
|
|
311 g_free(esc2);
|
8135
|
312 } else if(c->type == XMLNODE_TYPE_TAG || c->type == XMLNODE_TYPE_DATA) {
|
9837
|
313 if(c->type == XMLNODE_TYPE_DATA)
|
9838
|
314 pretty = FALSE;
|
7131
|
315 need_end = TRUE;
|
|
316 }
|
|
317 }
|
|
318
|
|
319 if(need_end) {
|
9838
|
320 g_string_append_printf(text, ">%s", pretty ? newline : "");
|
7131
|
321
|
|
322 for(c = node->child; c; c = c->next)
|
|
323 {
|
8135
|
324 if(c->type == XMLNODE_TYPE_TAG) {
|
7642
|
325 int esc_len;
|
9838
|
326 esc = xmlnode_to_str_helper(c, &esc_len, pretty, depth+1);
|
7642
|
327 text = g_string_append_len(text, esc, esc_len);
|
7131
|
328 g_free(esc);
|
8135
|
329 } else if(c->type == XMLNODE_TYPE_DATA) {
|
7131
|
330 esc = g_markup_escape_text(c->data, c->data_sz);
|
7642
|
331 text = g_string_append(text, esc);
|
7131
|
332 g_free(esc);
|
|
333 }
|
|
334 }
|
|
335
|
9838
|
336 if(tab && pretty)
|
9837
|
337 text = g_string_append(text, tab);
|
10415
|
338 g_string_append_printf(text, "</%s>%s", node_name, formatting ? newline : "");
|
7131
|
339 } else {
|
10415
|
340 g_string_append_printf(text, "/>%s", formatting ? newline : "");
|
7131
|
341 }
|
|
342
|
|
343 g_free(node_name);
|
|
344
|
9837
|
345 if(tab)
|
|
346 g_free(tab);
|
|
347
|
7642
|
348 if(len)
|
|
349 *len = text->len;
|
10331
|
350
|
|
351 return g_string_free(text, FALSE);
|
7131
|
352 }
|
|
353
|
10423
|
354 gchar *
|
|
355 xmlnode_to_str(xmlnode *node, int *len)
|
|
356 {
|
9837
|
357 return xmlnode_to_str_helper(node, len, FALSE, 0);
|
|
358 }
|
|
359
|
10423
|
360 gchar *
|
|
361 xmlnode_to_formatted_str(xmlnode *node, int *len)
|
|
362 {
|
10415
|
363 gchar *xml, *xml_with_declaration;
|
|
364
|
|
365 xml = xmlnode_to_str_helper(node, len, TRUE, 0);
|
|
366 xml_with_declaration =
|
|
367 g_strdup_printf("<?xml version='1.0' encoding='UTF-8' ?>\n\n%s", xml);
|
|
368 g_free(xml);
|
|
369
|
|
370 return xml_with_declaration;
|
9837
|
371 }
|
|
372
|
7131
|
373 struct _xmlnode_parser_data {
|
|
374 xmlnode *current;
|
|
375 };
|
|
376
|
|
377 static void
|
|
378 xmlnode_parser_element_start(GMarkupParseContext *context,
|
|
379 const char *element_name, const char **attrib_names,
|
|
380 const char **attrib_values, gpointer user_data, GError **error)
|
|
381 {
|
|
382 struct _xmlnode_parser_data *xpd = user_data;
|
|
383 xmlnode *node;
|
|
384 int i;
|
|
385
|
|
386 if(!element_name) {
|
|
387 return;
|
|
388 } else {
|
|
389 if(xpd->current)
|
|
390 node = xmlnode_new_child(xpd->current, element_name);
|
|
391 else
|
|
392 node = xmlnode_new(element_name);
|
|
393
|
|
394 for(i=0; attrib_names[i]; i++)
|
|
395 xmlnode_set_attrib(node, attrib_names[i], attrib_values[i]);
|
|
396
|
|
397 xpd->current = node;
|
|
398 }
|
|
399 }
|
|
400
|
|
401 static void
|
|
402 xmlnode_parser_element_end(GMarkupParseContext *context,
|
|
403 const char *element_name, gpointer user_data, GError **error)
|
|
404 {
|
|
405 struct _xmlnode_parser_data *xpd = user_data;
|
|
406
|
|
407 if(!element_name || !xpd->current)
|
|
408 return;
|
|
409
|
|
410 if(xpd->current->parent) {
|
|
411 if(!strcmp(xpd->current->name, element_name))
|
|
412 xpd->current = xpd->current->parent;
|
|
413 }
|
|
414 }
|
|
415
|
|
416 static void
|
|
417 xmlnode_parser_element_text(GMarkupParseContext *context, const char *text,
|
|
418 gsize text_len, gpointer user_data, GError **error)
|
|
419 {
|
|
420 struct _xmlnode_parser_data *xpd = user_data;
|
|
421
|
|
422 if(!xpd->current)
|
|
423 return;
|
|
424
|
|
425 if(!text || !text_len)
|
|
426 return;
|
|
427
|
|
428 xmlnode_insert_data(xpd->current, text, text_len);
|
|
429 }
|
|
430
|
|
431 static GMarkupParser xmlnode_parser = {
|
|
432 xmlnode_parser_element_start,
|
|
433 xmlnode_parser_element_end,
|
|
434 xmlnode_parser_element_text,
|
|
435 NULL,
|
|
436 NULL
|
|
437 };
|
|
438
|
|
439
|
10423
|
440 xmlnode *
|
|
441 xmlnode_from_str(const char *str, size_t size)
|
7131
|
442 {
|
|
443 struct _xmlnode_parser_data *xpd = g_new0(struct _xmlnode_parser_data, 1);
|
|
444 xmlnode *ret;
|
|
445 GMarkupParseContext *context;
|
|
446 size_t real_size = size == -1 ? strlen(str) : size;
|
|
447
|
|
448 context = g_markup_parse_context_new(&xmlnode_parser, 0, xpd, NULL);
|
|
449
|
|
450 if(!g_markup_parse_context_parse(context, str, real_size, NULL)) {
|
|
451 while(xpd->current && xpd->current->parent)
|
|
452 xpd->current = xpd->current->parent;
|
|
453 if(xpd->current)
|
|
454 xmlnode_free(xpd->current);
|
|
455 xpd->current = NULL;
|
|
456 }
|
|
457 g_markup_parse_context_free(context);
|
|
458
|
|
459 ret = xpd->current;
|
|
460 g_free(xpd);
|
|
461 return ret;
|
|
462 }
|
8135
|
463
|
10423
|
464 xmlnode *
|
|
465 xmlnode_copy(xmlnode *src)
|
8135
|
466 {
|
|
467 xmlnode *ret;
|
|
468 xmlnode *child;
|
|
469 xmlnode *sibling = NULL;
|
|
470
|
|
471 if(!src)
|
|
472 return NULL;
|
|
473
|
|
474 ret = new_node(src->name, src->type);
|
|
475 if(src->data) {
|
8167
|
476 if(src->data_sz) {
|
|
477 ret->data = g_memdup(src->data, src->data_sz);
|
|
478 ret->data_sz = src->data_sz;
|
|
479 } else {
|
|
480 ret->data = g_strdup(src->data);
|
|
481 }
|
8135
|
482 }
|
|
483
|
|
484 for(child = src->child; child; child = child->next) {
|
|
485 if(sibling) {
|
|
486 sibling->next = xmlnode_copy(child);
|
|
487 sibling = sibling->next;
|
|
488 } else {
|
|
489 ret->child = xmlnode_copy(child);
|
|
490 sibling = ret->child;
|
|
491 }
|
|
492 sibling->parent = ret;
|
|
493 }
|
|
494
|
|
495 return ret;
|
|
496 }
|
|
497
|
10423
|
498 xmlnode *
|
|
499 xmlnode_get_next_twin(xmlnode *node)
|
|
500 {
|
8135
|
501 xmlnode *sibling;
|
8262
|
502 const char *ns = xmlnode_get_attrib(node, "xmlns");
|
8135
|
503
|
|
504 g_return_val_if_fail(node != NULL, NULL);
|
|
505 g_return_val_if_fail(node->type == XMLNODE_TYPE_TAG, NULL);
|
|
506
|
|
507 for(sibling = node->next; sibling; sibling = sibling->next) {
|
8283
|
508 const char *xmlns = NULL;
|
8262
|
509 if(ns)
|
|
510 xmlns = xmlnode_get_attrib(sibling, "xmlns");
|
|
511
|
|
512 if(sibling->type == XMLNODE_TYPE_TAG && !strcmp(node->name, sibling->name) &&
|
|
513 (!ns || (xmlns && !strcmp(ns, xmlns))))
|
8135
|
514 return sibling;
|
|
515 }
|
|
516
|
|
517 return NULL;
|
|
518 }
|