Mercurial > pidgin3 / file comparison

comparison: plugins/jabber/xmlnode.c

plugins/jabber/xmlnode.c

changeset 1347
6fa6aa0d4d6e
equal deleted inserted replaced
1346:3bd401519c9e 1347:6fa6aa0d4d6e
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15 *
16 * Jabber
17 * Copyright (C) 1998-1999 The Jabber Team http://jabber.org/
18 */
19
20 #include "libxode.h"
21
22 /* Internal routines */
23 xmlnode _xmlnode_new(pool p, const char* name, unsigned int type)
24 {
25 xmlnode result = NULL;
26 if (type > NTYPE_LAST)
27 return NULL;
28
29 if (type != NTYPE_CDATA && name == NULL)
30 return NULL;
31
32 if (p == NULL)
33 {
34 p = pool_heap(1*1024);
35 }
36
37 /* Allocate & zero memory */
38 result = (xmlnode)pmalloc(p, sizeof(_xmlnode));
39 memset(result, '\0', sizeof(_xmlnode));
40
41 /* Initialize fields */
42 if (type != NTYPE_CDATA)
43 result->name = pstrdup(p,name);
44 result->type = type;
45 result->p = p;
46 return result;
47 }
48
49 static xmlnode _xmlnode_append_sibling(xmlnode lastsibling, const char* name, unsigned int type)
50 {
51 xmlnode result;
52
53 result = _xmlnode_new(xmlnode_pool(lastsibling), name, type);
54 if (result != NULL)
55 {
56 /* Setup sibling pointers */
57 result->prev = lastsibling;
58 lastsibling->next = result;
59 }
60 return result;
61 }
62
63 static xmlnode _xmlnode_insert(xmlnode parent, const char* name, unsigned int type)
64 {
65 xmlnode result;
66
67 if(parent == NULL || name == NULL) return NULL;
68
69 /* If parent->firstchild is NULL, simply create a new node for the first child */
70 if (parent->firstchild == NULL)
71 {
72 result = _xmlnode_new(parent->p, name, type);
73 parent->firstchild = result;
74 }
75 /* Otherwise, append this to the lastchild */
76 else
77 {
78 result= _xmlnode_append_sibling(parent->lastchild, name, type);
79 }
80 result->parent = parent;
81 parent->lastchild = result;
82 return result;
83
84 }
85
86 static xmlnode _xmlnode_search(xmlnode firstsibling, const char* name, unsigned int type)
87 {
88 xmlnode current;
89
90 /* Walk the sibling list, looking for a NTYPE_TAG xmlnode with
91 the specified name */
92 current = firstsibling;
93 while (current != NULL)
94 {
95 if ((current->type == type) && (j_strcmp(current->name, name) == 0))
96 return current;
97 else
98 current = current->next;
99 }
100 return NULL;
101 }
102
103 static char* _xmlnode_merge(pool p, char* dest, unsigned int destsize, const char* src, unsigned int srcsize)
104 {
105 char* result;
106 result = (char*)pmalloc(p, destsize + srcsize + 1);
107 memcpy(result, dest, destsize);
108 memcpy(result+destsize, src, srcsize);
109 result[destsize + srcsize] = '\0';
110
111 /* WARNING: major ugly hack: since we're throwing the old data away, let's jump in the pool and subtract it from the size, this is for xmlstream's big-node checking */
112 p->size -= destsize;
113
114 return result;
115 }
116
117 static void _xmlnode_hide_sibling(xmlnode child)
118 {
119 if(child == NULL)
120 return;
121
122 if(child->prev != NULL)
123 child->prev->next = child->next;
124 if(child->next != NULL)
125 child->next->prev = child->prev;
126 }
127
128 void _xmlnode_tag2str(spool s, xmlnode node, int flag)
129 {
130 xmlnode tmp;
131
132 if(flag==0 || flag==1)
133 {
134 spooler(s,"<",xmlnode_get_name(node),s);
135 tmp = xmlnode_get_firstattrib(node);
136 while(tmp) {
137 spooler(s," ",xmlnode_get_name(tmp),"='",strescape(xmlnode_pool(node),xmlnode_get_data(tmp)),"'",s);
138 tmp = xmlnode_get_nextsibling(tmp);
139 }
140 if(flag==0)
141 spool_add(s,"/>");
142 else
143 spool_add(s,">");
144 }
145 else
146 {
147 spooler(s,"</",xmlnode_get_name(node),">",s);
148 }
149 }
150
151 spool _xmlnode2spool(xmlnode node)
152 {
153 spool s;
154 int level=0,dir=0;
155 xmlnode tmp;
156
157 if(!node || xmlnode_get_type(node)!=NTYPE_TAG)
158 return NULL;
159
160 s = spool_new(xmlnode_pool(node));
161 if(!s) return(NULL);
162
163 while(1)
164 {
165 if(dir==0)
166 {
167 if(xmlnode_get_type(node) == NTYPE_TAG)
168 {
169 if(xmlnode_has_children(node))
170 {
171 _xmlnode_tag2str(s,node,1);
172 node = xmlnode_get_firstchild(node);
173 level++;
174 continue;
175 }
176 else
177 {
178 _xmlnode_tag2str(s,node,0);
179 }
180 }
181 else
182 {
183 spool_add(s,strescape(xmlnode_pool(node),xmlnode_get_data(node)));
184 }
185 }
186
187 tmp = xmlnode_get_nextsibling(node);
188 if(!tmp)
189 {
190 node = xmlnode_get_parent(node);
191 level--;
192 if(level>=0) _xmlnode_tag2str(s,node,2);
193 if(level<1) break;
194 dir = 1;
195 }
196 else
197 {
198 node = tmp;
199 dir = 0;
200 }
201 }
202
203 return s;
204 }
205
206
207 /* External routines */
208
209
210 /*
211 * xmlnode_new_tag -- create a tag node
212 * Automatically creates a memory pool for the node.
213 *
214 * parameters
215 * name -- name of the tag
216 *
217 * returns
218 * a pointer to the tag node
219 * or NULL if it was unsuccessfull
220 */
221 xmlnode xmlnode_new_tag(const char* name)
222 {
223 return _xmlnode_new(NULL, name, NTYPE_TAG);
224 }
225
226
227 /*
228 * xmlnode_new_tag_pool -- create a tag node within given pool
229 *
230 * parameters
231 * p -- previously created memory pool
232 * name -- name of the tag
233 *
234 * returns
235 * a pointer to the tag node
236 * or NULL if it was unsuccessfull
237 */
238 xmlnode xmlnode_new_tag_pool(pool p, const char* name)
239 {
240 return _xmlnode_new(p, name, NTYPE_TAG);
241 }
242
243
244 /*
245 * xmlnode_insert_tag -- append a child tag to a tag
246 *
247 * parameters
248 * parent -- pointer to the parent tag
249 * name -- name of the child tag
250 *
251 * returns
252 * a pointer to the child tag node
253 * or NULL if it was unsuccessfull
254 */
255 xmlnode xmlnode_insert_tag(xmlnode parent, const char* name)
256 {
257 return _xmlnode_insert(parent, name, NTYPE_TAG);
258 }
259
260
261 /*
262 * xmlnode_insert_cdata -- append character data to a tag
263 * If last child of the parent is CDATA, merges CDATA nodes. Otherwise
264 * creates a CDATA node, and appends it to the parent's child list.
265 *
266 * parameters
267 * parent -- parent tag
268 * CDATA -- character data
269 * size -- size of CDATA
270 * or -1 for null-terminated CDATA strings
271 *
272 * returns
273 * a pointer to the child CDATA node
274 * or NULL if it was unsuccessfull
275 */
276 xmlnode xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size)
277 {
278 xmlnode result;
279
280 if(CDATA == NULL || parent == NULL)
281 return NULL;
282
283 if(size == -1)
284 size = strlen(CDATA);
285
286 if ((parent->lastchild != NULL) && (parent->lastchild->type == NTYPE_CDATA))
287 {
288 result = parent->lastchild;
289 result->data = _xmlnode_merge(result->p, result->data, result->data_sz, CDATA, size);
290 result->data_sz = result->data_sz + size;
291 }
292 else
293 {
294 result = _xmlnode_insert(parent, "", NTYPE_CDATA);
295 if (result != NULL)
296 {
297 result->data = (char*)pmalloc(result->p, size + 1);
298 memcpy(result->data, CDATA, size);
299 result->data[size] = '\0';
300 result->data_sz = size;
301 }
302 }
303
304 return result;
305 }
306
307
308 /*
309 * xmlnode_get_tag -- find given tag in an xmlnode tree
310 *
311 * parameters
312 * parent -- pointer to the parent tag
313 * name -- "name" for the child tag of that name
314 * "name/name" for a sub child (recurses)
315 * "?attrib" to match the first tag with that attrib defined
316 * "?attrib=value" to match the first tag with that attrib and value
317 * or any combination: "name/name/?attrib", etc
318 *
319 * results
320 * a pointer to the tag matching search criteria
321 * or NULL if search was unsuccessfull
322 */
323 xmlnode xmlnode_get_tag(xmlnode parent, const char* name)
324 {
325 char *str, *slash, *qmark, *equals;
326 xmlnode step, ret;
327
328 if(parent == NULL || parent->firstchild == NULL || name == NULL || name == '\0') return NULL;
329
330 if(strstr(name, "/") == NULL && strstr(name,"?") == NULL)
331 return _xmlnode_search(parent->firstchild, name, NTYPE_TAG);
332
333 /* jer's note: why can't I modify the name directly, why do I have to strdup it? damn c grrr! */
334 str = strdup(name);
335 slash = strstr(str, "/");
336 qmark = strstr(str, "?");
337 equals = strstr(str, "=");
338
339 if(qmark != NULL && (slash == NULL || qmark < slash))
340 { /* of type ?attrib */
341
342 *qmark = '\0';
343 qmark++;
344 if(equals != NULL)
345 {
346 *equals = '\0';
347 equals++;
348 }
349
350 for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))
351 {
352 if(xmlnode_get_type(step) != NTYPE_TAG)
353 continue;
354
355 if(*str != '\0')
356 if(j_strcmp(xmlnode_get_name(step),str) != 0)
357 continue;
358
359 if(xmlnode_get_attrib(step,qmark) == NULL)
360 continue;
361
362 if(equals != NULL && j_strcmp(xmlnode_get_attrib(step,qmark),equals) != 0)
363 continue;
364
365 break;
366 }
367
368 free(str);
369 return step;
370 }
371
372
373 *slash = '\0';
374 ++slash;
375
376 for(step = parent->firstchild; step != NULL; step = xmlnode_get_nextsibling(step))
377 {
378 if(xmlnode_get_type(step) != NTYPE_TAG) continue;
379
380 if(j_strcmp(xmlnode_get_name(step),str) != 0)
381 continue;
382
383 ret = xmlnode_get_tag(step, slash);
384 if(ret != NULL)
385 {
386 free(str);
387 return ret;
388 }
389 }
390
391 free(str);
392 return NULL;
393 }
394
395
396 /* return the cdata from any tag */
397 char *xmlnode_get_tag_data(xmlnode parent, const char *name)
398 {
399 xmlnode tag;
400
401 tag = xmlnode_get_tag(parent, name);
402 if(tag == NULL) return NULL;
403
404 return xmlnode_get_data(tag);
405 }
406
407
408 void xmlnode_put_attrib(xmlnode owner, const char* name, const char* value)
409 {
410 xmlnode attrib;
411
412 if(owner == NULL || name == NULL || value == NULL) return;
413
414 /* If there are no existing attributs, allocate a new one to start
415 the list */
416 if (owner->firstattrib == NULL)
417 {
418 attrib = _xmlnode_new(owner->p, name, NTYPE_ATTRIB);
419 owner->firstattrib = attrib;
420 owner->lastattrib = attrib;
421 }
422 else
423 {
424 attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
425 if(attrib == NULL)
426 {
427 attrib = _xmlnode_append_sibling(owner->lastattrib, name, NTYPE_ATTRIB);
428 owner->lastattrib = attrib;
429 }
430 }
431 /* Update the value of the attribute */
432 attrib->data_sz = strlen(value);
433 attrib->data = pstrdup(owner->p, value);
434
435 }
436
437 char* xmlnode_get_attrib(xmlnode owner, const char* name)
438 {
439 xmlnode attrib;
440
441 if (owner != NULL && owner->firstattrib != NULL)
442 {
443 attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
444 if (attrib != NULL)
445 return (char*)attrib->data;
446 }
447 return NULL;
448 }
449
450 void xmlnode_put_vattrib(xmlnode owner, const char* name, void *value)
451 {
452 xmlnode attrib;
453
454 if (owner != NULL)
455 {
456 attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
457 if (attrib == NULL)
458 {
459 xmlnode_put_attrib(owner, name, "");
460 attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
461 }
462 if (attrib != NULL)
463 attrib->firstchild = (xmlnode)value;
464 }
465 }
466
467 void* xmlnode_get_vattrib(xmlnode owner, const char* name)
468 {
469 xmlnode attrib;
470
471 if (owner != NULL && owner->firstattrib != NULL)
472 {
473 attrib = _xmlnode_search(owner->firstattrib, name, NTYPE_ATTRIB);
474 if (attrib != NULL)
475 return (void*)attrib->firstchild;
476 }
477 return NULL;
478 }
479
480 xmlnode xmlnode_get_firstattrib(xmlnode parent)
481 {
482 if (parent != NULL)
483 return parent->firstattrib;
484 return NULL;
485 }
486
487 xmlnode xmlnode_get_firstchild(xmlnode parent)
488 {
489 if (parent != NULL)
490 return parent->firstchild;
491 return NULL;
492 }
493
494 xmlnode xmlnode_get_lastchild(xmlnode parent)
495 {
496 if (parent != NULL)
497 return parent->lastchild;
498 return NULL;
499 }
500
501 xmlnode xmlnode_get_nextsibling(xmlnode sibling)
502 {
503 if (sibling != NULL)
504 return sibling->next;
505 return NULL;
506 }
507
508 xmlnode xmlnode_get_prevsibling(xmlnode sibling)
509 {
510 if (sibling != NULL)
511 return sibling->prev;
512 return NULL;
513 }
514
515 xmlnode xmlnode_get_parent(xmlnode node)
516 {
517 if (node != NULL)
518 return node->parent;
519 return NULL;
520 }
521
522 char* xmlnode_get_name(xmlnode node)
523 {
524 if (node != NULL)
525 return node->name;
526 return NULL;
527 }
528
529 char* xmlnode_get_data(xmlnode node)
530 {
531 xmlnode cur;
532
533 if(node == NULL) return NULL;
534
535 if(xmlnode_get_type(node) == NTYPE_TAG) /* loop till we find a CDATA */
536 {
537 for(cur = xmlnode_get_firstchild(node); cur != NULL; cur = xmlnode_get_nextsibling(cur))
538 if(xmlnode_get_type(cur) == NTYPE_CDATA)
539 return cur->data;
540 }else{
541 return node->data;
542 }
543 return NULL;
544 }
545
546 int xmlnode_get_datasz(xmlnode node)
547 {
548 if (node != NULL)
549 return node->data_sz;
550 return (int)NULL;
551 }
552
553 int xmlnode_get_type(xmlnode node)
554 {
555 if (node != NULL)
556 return node->type;
557 return (int)NULL;
558 }
559
560 int xmlnode_has_children(xmlnode node)
561 {
562 if ((node != NULL) && (node->firstchild != NULL))
563 return 1;
564 return 0;
565 }
566
567 int xmlnode_has_attribs(xmlnode node)
568 {
569 if ((node != NULL) && (node->firstattrib != NULL))
570 return 1;
571 return 0;
572 }
573
574 pool xmlnode_pool(xmlnode node)
575 {
576 if (node != NULL)
577 return node->p;
578 return (pool)NULL;
579 }
580
581 void xmlnode_hide(xmlnode child)
582 {
583 xmlnode parent;
584
585 if(child == NULL || child->parent == NULL)
586 return;
587
588 parent = child->parent;
589
590 /* first fix up at the child level */
591 _xmlnode_hide_sibling(child);
592
593 /* next fix up at the parent level */
594 if(parent->firstchild == child)
595 parent->firstchild = child->next;
596 if(parent->lastchild == child)
597 parent->lastchild = child->prev;
598 }
599
600 void xmlnode_hide_attrib(xmlnode parent, const char *name)
601 {
602 xmlnode attrib;
603
604 if(parent == NULL || parent->firstattrib == NULL || name == NULL)
605 return;
606
607 attrib = _xmlnode_search(parent->firstattrib, name, NTYPE_ATTRIB);
608 if(attrib == NULL)
609 return;
610
611 /* first fix up at the child level */
612 _xmlnode_hide_sibling(attrib);
613
614 /* next fix up at the parent level */
615 if(parent->firstattrib == attrib)
616 parent->firstattrib = attrib->next;
617 if(parent->lastattrib == attrib)
618 parent->lastattrib = attrib->prev;
619 }
620
621
622
623 /*
624 * xmlnode2str -- convert given xmlnode tree into a string
625 *
626 * parameters
627 * node -- pointer to the xmlnode structure
628 *
629 * results
630 * a pointer to the created string
631 * or NULL if it was unsuccessfull
632 */
633 char *xmlnode2str(xmlnode node)
634 {
635 return spool_print(_xmlnode2spool(node));
636 }
637
638 /*
639 * xmlnode2tstr -- convert given xmlnode tree into a newline terminated string
640 *
641 * parameters
642 * node -- pointer to the xmlnode structure
643 *
644 * results
645 * a pointer to the created string
646 * or NULL if it was unsuccessfull
647 */
648 char* xmlnode2tstr(xmlnode node)
649 {
650 spool s = _xmlnode2spool(node);
651 if (s != NULL)
652 spool_add(s, "\n");
653 return spool_print(s);
654 }
655
656
657 /* loop through both a and b comparing everything, attribs, cdata, children, etc */
658 int xmlnode_cmp(xmlnode a, xmlnode b)
659 {
660 int ret = 0;
661
662 while(1)
663 {
664 if(a == NULL && b == NULL)
665 return 0;
666
667 if(a == NULL || b == NULL)
668 return -1;
669
670 if(xmlnode_get_type(a) != xmlnode_get_type(b))
671 return -1;
672
673 switch(xmlnode_get_type(a))
674 {
675 case NTYPE_ATTRIB:
676 ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
677 if(ret != 0)
678 return -1;
679 ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
680 if(ret != 0)
681 return -1;
682 break;
683 case NTYPE_TAG:
684 ret = j_strcmp(xmlnode_get_name(a), xmlnode_get_name(b));
685 if(ret != 0)
686 return -1;
687 ret = xmlnode_cmp(xmlnode_get_firstattrib(a), xmlnode_get_firstattrib(b));
688 if(ret != 0)
689 return -1;
690 ret = xmlnode_cmp(xmlnode_get_firstchild(a), xmlnode_get_firstchild(b));
691 if(ret != 0)
692 return -1;
693 break;
694 case NTYPE_CDATA:
695 ret = j_strcmp(xmlnode_get_data(a), xmlnode_get_data(b));
696 if(ret != 0)
697 return -1;
698 }
699 a = xmlnode_get_nextsibling(a);
700 b = xmlnode_get_nextsibling(b);
701 }
702 }
703
704
705 xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node)
706 {
707 xmlnode child;
708
709 child = xmlnode_insert_tag(parent, xmlnode_get_name(node));
710 if (xmlnode_has_attribs(node))
711 xmlnode_insert_node(child, xmlnode_get_firstattrib(node));
712 if (xmlnode_has_children(node))
713 xmlnode_insert_node(child, xmlnode_get_firstchild(node));
714
715 return child;
716 }
717
718 /* places copy of node and node's siblings in parent */
719 void xmlnode_insert_node(xmlnode parent, xmlnode node)
720 {
721 if(node == NULL || parent == NULL)
722 return;
723
724 while(node != NULL)
725 {
726 switch(xmlnode_get_type(node))
727 {
728 case NTYPE_ATTRIB:
729 xmlnode_put_attrib(parent, xmlnode_get_name(node), xmlnode_get_data(node));
730 break;
731 case NTYPE_TAG:
732 xmlnode_insert_tag_node(parent, node);
733 break;
734 case NTYPE_CDATA:
735 xmlnode_insert_cdata(parent, xmlnode_get_data(node), xmlnode_get_datasz(node));
736 }
737 node = xmlnode_get_nextsibling(node);
738 }
739 }
740
741
742 /* produce full duplicate of x with a new pool, x must be a tag! */
743 xmlnode xmlnode_dup(xmlnode x)
744 {
745 xmlnode x2;
746
747 if(x == NULL)
748 return NULL;
749
750 x2 = xmlnode_new_tag(xmlnode_get_name(x));
751
752 if (xmlnode_has_attribs(x))
753 xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));
754 if (xmlnode_has_children(x))
755 xmlnode_insert_node(x2, xmlnode_get_firstchild(x));
756
757 return x2;
758 }
759
760 xmlnode xmlnode_dup_pool(pool p, xmlnode x)
761 {
762 xmlnode x2;
763
764 if(x == NULL)
765 return NULL;
766
767 x2 = xmlnode_new_tag_pool(p, xmlnode_get_name(x));
768
769 if (xmlnode_has_attribs(x))
770 xmlnode_insert_node(x2, xmlnode_get_firstattrib(x));
771 if (xmlnode_has_children(x))
772 xmlnode_insert_node(x2, xmlnode_get_firstchild(x));
773
774 return x2;
775 }
776
777 xmlnode xmlnode_wrap(xmlnode x,const char *wrapper)
778 {
779 xmlnode wrap;
780 if(x==NULL||wrapper==NULL) return NULL;
781 wrap=xmlnode_new_tag_pool(xmlnode_pool(x),wrapper);
782 if(wrap==NULL) return NULL;
783 wrap->firstchild=x;
784 wrap->lastchild=x;
785 x->parent=wrap;
786 return wrap;
787 }
788
789 void xmlnode_free(xmlnode node)
790 {
791 if(node == NULL)
792 return;
793
794 pool_free(node->p);
795 }

Mercurial Repository: pidgin3

mercurial