gwenhywfar  4.6.0beta
xml.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Sat Jun 28 2003
3  copyright : (C) 2003-2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * *
8  * This library is free software; you can redistribute it and/or *
9  * modify it under the terms of the GNU Lesser General Public *
10  * License as published by the Free Software Foundation; either *
11  * version 2.1 of the License, or (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16  * Lesser General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU Lesser General Public *
19  * License along with this library; if not, write to the Free Software *
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21  * MA 02111-1307 USA *
22  * *
23  ***************************************************************************/
24 
25 #ifdef HAVE_CONFIG_H
26 # include <config.h>
27 #endif
28 
29 #define DISABLE_DEBUGLOG
30 
31 #include "xml_p.h"
32 #include "xmlctx_l.h"
33 #include "i18n_l.h"
34 
35 #include <gwenhywfar/debug.h>
36 #include <gwenhywfar/misc.h>
37 #include <gwenhywfar/text.h>
38 #include <gwenhywfar/path.h>
39 #include <gwenhywfar/fastbuffer.h>
40 #include <gwenhywfar/syncio_file.h>
41 #include <gwenhywfar/syncio_memory.h>
42 
43 #include <stdlib.h>
44 #include <assert.h>
45 #include <string.h>
46 #include <ctype.h>
47 #include <sys/types.h>
48 #ifdef HAVE_SYS_STAT_H
49 # include <sys/stat.h>
50 #endif
51 #ifdef HAVE_FCNTL_H
52 # include <fcntl.h>
53 #endif
54 #include <errno.h>
55 #ifdef HAVE_UNISTD_H
56 # include <unistd.h>
57 #endif
58 
59 
60 #define GWEN_XML_BUFFERSIZE 512
61 
62 
63 
64 GWEN_LIST_FUNCTIONS(GWEN_XMLNODE, GWEN_XMLNode)
66 
67 GWEN_LIST_FUNCTIONS(GWEN_XMLNODE_NAMESPACE, GWEN_XMLNode_NameSpace)
68 
69 
70 
71 
72 GWEN_XMLPROPERTY *GWEN_XMLProperty_new(const char *name, const char *value){
74 
76  if (name)
77  p->name=GWEN_Memory_strdup(name);
78  if (value)
79  p->value=GWEN_Memory_strdup(value);
80  return p;
81 }
82 
83 
84 
86  if (p) {
87  GWEN_Memory_dealloc(p->name);
88  GWEN_Memory_dealloc(p->value);
89  GWEN_Memory_dealloc(p->nameSpace);
91  }
92 }
93 
94 
95 
97  GWEN_XMLPROPERTY *pp;
98 
99  pp=GWEN_XMLProperty_new(p->name, p->value);
100  if (p->nameSpace)
101  pp->nameSpace=strdup(p->nameSpace);
102 
103  return pp;
104 }
105 
106 
107 
110 }
111 
112 
113 
116 }
117 
118 
121 }
122 
123 
125  while(p) {
126  GWEN_XMLPROPERTY *next;
127 
128  next=p->next;
130  p=next;
131  } /* while */
132 }
133 
134 
135 
136 
138  GWEN_XMLNODE *n;
139 
142  n->type=t;
143  n->children=GWEN_XMLNode_List_new();
144  n->headers=GWEN_XMLNode_List_new();
145  if (data)
146  n->data=GWEN_Memory_strdup(data);
147  n->nameSpaces=GWEN_XMLNode_NameSpace_List_new();
148  return n;
149 }
150 
151 
153  if (n) {
155  GWEN_XMLProperty_freeAll(n->properties);
156  GWEN_Memory_dealloc(n->nameSpace);
157  GWEN_Memory_dealloc(n->data);
158  GWEN_XMLNode_List_free(n->headers);
159  GWEN_XMLNode_List_free(n->children);
160  GWEN_XMLNode_NameSpace_List_free(n->nameSpaces);
161  GWEN_FREE_OBJECT(n);
162  }
163 }
164 
165 
167  while(n) {
168  GWEN_XMLNODE *next;
169 
170  next=GWEN_XMLNode_List_Next(n);
172  n=next;
173  } /* while */
174 }
175 
176 
178  GWEN_XMLNODE *nn, *cn, *ncn;
179  const GWEN_XMLPROPERTY *p;
180  const GWEN_XMLNODE_NAMESPACE *nns;
181 
182  /* duplicate node itself */
183  nn=GWEN_XMLNode_new(n->type, n->data);
184  if (n->nameSpace)
185  nn->nameSpace=strdup(n->nameSpace);
186 
187  /* duplicate properties */
188  p=n->properties;
189  while(p) {
190  GWEN_XMLPROPERTY *np;
191 
192  np=GWEN_XMLProperty_dup(p);
193  GWEN_XMLProperty_add(np, &(nn->properties));
194  p=p->next;
195  } /* while */
196 
197  /* duplicate children */
198  cn=GWEN_XMLNode_List_First(n->children);
199  while(cn) {
200  ncn=GWEN_XMLNode_dup(cn);
201  GWEN_XMLNode_AddChild(nn, ncn);
202  cn=GWEN_XMLNode_Next(cn);
203  } /* while */
204 
205  /* duplicate headers */
206  cn=GWEN_XMLNode_List_First(n->headers);
207  while(cn) {
208  ncn=GWEN_XMLNode_dup(cn);
209  GWEN_XMLNode_AddHeader(nn, ncn);
210  cn=GWEN_XMLNode_Next(cn);
211  } /* while */
212 
213  /* duplicate namespaces */
214  nns=GWEN_XMLNode_NameSpace_List_First(n->nameSpaces);
215  while(nns) {
217 
218  nnns=GWEN_XMLNode_NameSpace_dup(nns);
219  GWEN_XMLNode_NameSpace_List_Add(nnns, nn->nameSpaces);
220  nns=GWEN_XMLNode_NameSpace_List_Next(nns);
221  }
222 
223  return nn;
224 }
225 
226 
227 
228 const char *GWEN_XMLNode_GetProperty(const GWEN_XMLNODE *n, const char *name,
229  const char *defaultValue){
230  GWEN_XMLPROPERTY *p;
231 
232  assert(n);
233  assert(name);
234  p=n->properties;
235  while(p) {
236  assert(p->name);
237  if (strcasecmp(p->name, name)==0)
238  break;
239  p=p->next;
240  } /* while */
241 
242  if (p) {
243  if (p->value)
244  return p->value;
245  }
246  return defaultValue;
247 }
248 
249 
250 
251 int GWEN_XMLNode_GetIntProperty(const GWEN_XMLNODE *n, const char *name,
252  int defaultValue){
253  GWEN_XMLPROPERTY *p;
254 
255  assert(n);
256  assert(name);
257  p=n->properties;
258  while(p) {
259  assert(p->name);
260  if (strcasecmp(p->name, name)==0)
261  break;
262  p=p->next;
263  } /* while */
264 
265  if (p) {
266  if (p->value) {
267  int i;
268 
269  if (1==sscanf(p->value, "%i", &i))
270  return i;
271  }
272  }
273  return defaultValue;
274 }
275 
276 
278  const char *name, const char *value,
279  int doInsert){
280  GWEN_XMLPROPERTY *p;
281 
282  p=n->properties;
283  while(p) {
284  assert(p->name);
285  if (strcasecmp(p->name, name)==0)
286  break;
287  p=p->next;
288  } /* while */
289 
290  if (p) {
291  GWEN_Memory_dealloc(p->value);
292  if (value)
293  p->value=GWEN_Memory_strdup(value);
294  else
295  p->value=0;
296  }
297  else {
298  p=GWEN_XMLProperty_new(name, value);
299  if (doInsert)
300  GWEN_XMLProperty_insert(p, &(n->properties));
301  else
302  GWEN_XMLProperty_add(p, &(n->properties));
303  }
304 }
305 
306 
307 
309  const char *name, const char *value){
310  GWEN_XMLNode__SetProperty(n, name, value, 0);
311 }
312 
313 
314 
316  const char *name, int value){
317  char numbuf[256];
318 
319  snprintf(numbuf, sizeof(numbuf)-1, "%i", value);
320  numbuf[sizeof(numbuf)-1]=0;
321  GWEN_XMLNode__SetProperty(n, name, numbuf, 0);
322 }
323 
324 
325 
327  assert(n);
328  n->usage++;
329 }
330 
331 
332 
334  assert(n);
335  if (n->usage==0) {
336  DBG_WARN(GWEN_LOGDOMAIN, "Node usage already is zero");
337  }
338  else
339  n->usage--;
340 }
341 
342 
343 
345  assert(n);
346  return n->usage;
347 }
348 
349 
350 
351 const char *GWEN_XMLNode_GetData(const GWEN_XMLNODE *n){
352  assert(n);
353  return n->data;
354 }
355 
356 
357 void GWEN_XMLNode_SetData(GWEN_XMLNODE *n, const char *data){
358  assert(n);
359  GWEN_Memory_dealloc(n->data);
360  if (data)
361  n->data=GWEN_Memory_strdup(data);
362  else
363  n->data=0;
364 }
365 
366 
367 
369  assert(n);
370  return n->nameSpace;
371 }
372 
373 
374 
375 void GWEN_XMLNode_SetNamespace(GWEN_XMLNODE *n, const char *s) {
376  assert(n);
377  GWEN_Memory_dealloc(n->nameSpace);
378  if (s)
379  n->nameSpace=GWEN_Memory_strdup(s);
380  else
381  n->nameSpace=NULL;
382 }
383 
384 
385 
387  assert(n);
388  return GWEN_XMLNode_List_First(n->children);
389 }
390 
391 
393  assert(n);
394  return n->parent;
395 }
396 
397 
399  assert(n);
400  GWEN_XMLNode_List_Add(child, n->children);
401  child->parent=n;
402 }
403 
404 
405 
407  int copythem){
408  GWEN_XMLNODE *ch;
409 
410  assert(n);
411  assert(nn);
412 
413  ch=GWEN_XMLNode_GetChild(nn);
414  while(ch) {
415  GWEN_XMLNODE *nc;
416 
417  nc=GWEN_XMLNode_Next(ch);
418  if (!copythem) {
419  GWEN_XMLNode_UnlinkChild(nn, ch);
420  GWEN_XMLNode_AddChild(n, ch);
421  }
422  else {
424  }
425  ch=nc;
426  } /* while */
427 }
428 
429 
430 
432  assert(n);
433  return n->type;
434 }
435 
436 
438  assert(n);
439  return GWEN_XMLNode_List_Next(n);
440 }
441 
442 
443 void GWEN_XMLNode_Dump(const GWEN_XMLNODE *n, int ind) {
444  GWEN_XMLPROPERTY *p;
445  GWEN_XMLNODE *c;
446  int i;
447  int simpleTag;
448 
449  assert(n);
450 
451  for(i=0; i<ind; i++)
452  fprintf(stderr, " ");
453 
454  simpleTag=0;
455  if (n->type==GWEN_XMLNodeTypeTag) {
456  if (n->data)
457  fprintf(stderr, "<%s", n->data);
458  else
459  fprintf(stderr, "<UNKNOWN");
460  p=n->properties;
461  while (p) {
462  if (p->value)
463  fprintf(stderr, " %s=\"%s\"", p->name, p->value);
464  else
465  fprintf(stderr, " %s", p->name);
466  p=p->next;
467  }
468 
469  if (n->data) {
470  if (n->data[0]=='?') {
471  simpleTag=1;
472  fprintf(stderr, "?");
473  }
474  else if (n->data[0]=='!') {
475  simpleTag=1;
476  }
477  }
478 
479  fprintf(stderr, ">\n");
480  if (!simpleTag) {
482  while(c) {
483  GWEN_XMLNode_Dump(c, ind+2);
484  c=GWEN_XMLNode_Next(c);
485  }
486  for(i=0; i<ind; i++)
487  fprintf(stderr, " ");
488  if (n->data)
489  fprintf(stderr, "</%s>\n", n->data);
490  else
491  fprintf(stderr, "</UNKNOWN>\n");
492  }
493  }
494  else if (n->type==GWEN_XMLNodeTypeData) {
495  if (n->data) {
496  fprintf(stderr, "%s\n", n->data);
497  }
498  }
499  else if (n->type==GWEN_XMLNodeTypeComment) {
500  fprintf(stderr, "<!--");
501  if (n->data) {
502  fprintf(stderr, "%s", n->data);
503  }
504  fprintf(stderr, "-->\n");
505  }
506  else {
507  DBG_ERROR(GWEN_LOGDOMAIN, "Unknown tag type (%d)", n->type);
508  }
509 }
510 
511 
512 
514  GWEN_XMLNODE_TYPE t, const char *data) {
515  GWEN_XMLNODE *n;
516 
517  assert(node);
518  assert(data);
519 
520  n=GWEN_XMLNode_GetChild(node);
521  while(n) {
522  if (n->type==t)
523  if (n->data)
524  if (strcasecmp(n->data, data)==0)
525  break;
526  n=GWEN_XMLNode_Next(n);
527  } /* while */
528 
529  if (!n) {
530  DBG_DEBUG(GWEN_LOGDOMAIN, "Node %d:\"%s\" not found", t, data);
531  return 0;
532  }
533 
534  return n;
535 }
536 
537 
538 
540  assert(n);
541  assert(child);
542  GWEN_XMLNode_List_Del(child);
543  child->parent=0;
544 }
545 
546 
547 
549  assert(n);
550  GWEN_XMLNode_List_Clear(n->children);
551 }
552 
553 
554 
556  const GWEN_XMLNODE *sn,
557  int overwrite){
558  const GWEN_XMLPROPERTY *sp;
559  GWEN_XMLPROPERTY *tp;
560 
561  assert(tn);
562  assert(sn);
563 
564  sp=sn->properties;
565  while(sp) {
566  GWEN_XMLPROPERTY *np;
567 
568  assert(sp->name);
569  tp=tn->properties;
570  /* lookup property in target */
571  while(tp) {
572 
573  assert(tp->name);
574  if (strcasecmp(tp->name, sp->name)==0) {
575  /* property already exists */
576  if (overwrite) {
577  /* overwrite old property */
578  GWEN_Memory_dealloc(tp->value);
579  tp->value=0;
580  if (sp->value)
581  tp->value=GWEN_Memory_strdup(sp->value);
582  }
583  break;
584  }
585  tp=tp->next;
586  } /* while */
587 
588  if (!tp) {
589  /* property not found, simply copy and add it */
590  np=GWEN_XMLProperty_dup(sp);
591  GWEN_XMLProperty_add(np, &(tn->properties));
592  }
593 
594  sp=sp->next;
595  } /* while */
596 }
597 
598 
599 
602  GWEN_XMLNODE *nn;
603 
604  assert(n);
605  nn=GWEN_XMLNode_GetChild(n);
606  while(nn) {
607  if (nn->type==t)
608  return nn;
609  nn=GWEN_XMLNode_Next(nn);
610  } /* while */
611  return 0;
612 }
613 
614 
615 
618  assert(n);
619  while(n) {
620  if (n->type==t)
621  return (GWEN_XMLNODE *)n;
622  n=GWEN_XMLNode_Next(n);
623  } /* while */
624  return 0;
625 }
626 
627 
628 
631 }
632 
633 
634 
636  GWEN_XMLNODE *next;
637 
638  next=GWEN_XMLNode_Next(n);
639  if (!next)
640  return 0;
642 }
643 
644 
645 
648 }
649 
650 
651 
653  GWEN_XMLNODE *next;
654 
655  next=GWEN_XMLNode_Next(n);
656  if (!next)
657  return 0;
659 }
660 
661 
662 
664  const char *tname,
665  const char *pname,
666  const char *pvalue){
667  while(n) {
668  if (-1!=GWEN_Text_ComparePattern(n->data, tname, 0)) {
669  if (pname) {
670  const char *p;
671 
672  p=GWEN_XMLNode_GetProperty(n, pname, 0);
673  if (p) {
674  if (!pvalue)
675  return (GWEN_XMLNODE*)n;
676  if (-1!=GWEN_Text_ComparePattern(pvalue, p, 0))
677  return (GWEN_XMLNODE*)n;
678  }
679  else {
680  /* return this node if pvalue is 0 an the property does not exist */
681  if (!pvalue)
682  return (GWEN_XMLNODE*)n;
683  }
684  } /* if pname */
685  else
686  return (GWEN_XMLNODE*)n;
687  }
689  } /* while */
690  return 0;
691 }
692 
693 
694 
696  const char *tname,
697  const char *pname,
698  const char *pvalue){
699  GWEN_XMLNODE *nn;
700 
702  if (!nn)
703  return 0;
704  return GWEN_XMLNode_FindTag(nn,
705  tname,
706  pname,
707  pvalue);
708 }
709 
710 
711 
713  const char *tname,
714  const char *pname,
715  const char *pvalue){
716  GWEN_XMLNODE *nn;
717 
719  if (!nn)
720  return 0;
721  return GWEN_XMLNode_FindTag(nn,
722  tname,
723  pname,
724  pvalue);
725 }
726 
727 
728 
730  const char *name,
731  const char *defValue) {
732  GWEN_XMLNODE *nn;
733 
734  nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
735  while(nn) {
736  GWEN_XMLNODE *dn;
737 
739  if (dn) {
740  if (dn->data)
741  return dn->data;
742  }
743  nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
744  }
745 
746  return defValue;
747 }
748 
749 
750 
752  const char *name,
753  const char *defValue) {
754  GWEN_XMLNODE *nn=0;
755  GWEN_STRINGLIST *langl;
756 
758  if (langl) {
760 
761  se=GWEN_StringList_FirstEntry(langl);
762  while(se) {
763  const char *l;
764 
766  DBG_DEBUG(GWEN_LOGDOMAIN, "Trying locale \"%s\"", l);
767  assert(l);
768  nn=GWEN_XMLNode_FindFirstTag(n, name, "lang", l);
769  while(nn) {
770  GWEN_XMLNODE *dn;
771 
773  if (dn) {
774  if (dn->data && *(dn->data))
775  return dn->data;
776  }
777  nn=GWEN_XMLNode_FindNextTag(nn, name, "lang", l);
778  } /* while nn */
780  } /* while */
781  } /* if language list available */
782 
783  /* otherwise try without locale */
784  nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
785  while(nn) {
786  GWEN_XMLNODE *dn;
787 
789  if (dn) {
790  if (dn->data)
791  return dn->data;
792  }
793  nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
794  }
795 
796  return defValue;
797 }
798 
799 
800 
802  const char *name,
803  const char *value){
804  GWEN_XMLNODE *nn;
805 
807  if (value) {
808  GWEN_XMLNODE *nnn;
809 
811  GWEN_XMLNode_AddChild(nn, nnn);
812  }
813  GWEN_XMLNode_AddChild(n, nn);
814 }
815 
816 
817 
819  const char *name,
820  int defValue) {
821  const char *p;
822  int res;
823 
824  p=GWEN_XMLNode_GetCharValue(n, name, 0);
825  if (!p)
826  return defValue;
827  if (1!=sscanf(p, "%i", &res))
828  return defValue;
829  return res;
830 }
831 
832 
833 
835  const char *name,
836  int value){
837  char numbuf[32];
838 
839  snprintf(numbuf, sizeof(numbuf)-1, "%d", value);
840  numbuf[sizeof(numbuf)-1]=0;
841  GWEN_XMLNode_SetCharValue(n, name, numbuf);
842 }
843 
844 
845 
847  assert(n);
848  return n->properties;
849 }
850 
851 
852 
854  const GWEN_XMLPROPERTY *pr){
855  assert(n);
856  assert(pr);
857  return pr->next;
858 }
859 
860 
861 
863  assert(pr);
864  return pr->name;
865 }
866 
867 
868 
870  assert(pr);
871  return pr->value;
872 }
873 
874 
875 
877  const GWEN_XMLNODE *child) {
878  GWEN_XMLNODE *n;
879 
880  if (!child || !parent || child==parent)
881  return 0;
882  n=child->parent;
883  while(n) {
884  if (n==parent)
885  return 1;
886  n=n->parent;
887  }
888  return 0;
889 }
890 
891 
892 
894  const GWEN_XMLNODE *n2,
895  GWEN_BUFFER *nbuf) {
896  GWEN_BUFFER *lbuf;
897  const GWEN_XMLNODE *ln1;
898  const GWEN_XMLNODE *ln2;
899 
900  if (!n1 && !n2) {
901  DBG_ERROR(GWEN_LOGDOMAIN, "Both nodes are NULL");
902  return -1;
903  }
904 
905  if (!n1) {
906  n1=n2;
907  while(n1->parent)
908  n1=n1->parent;
909  }
910 
911  if (!n2) {
912  n2=n1;
913  while(n2->parent)
914  n2=n2->parent;
915  }
916 
917  if (n2==n1) {
918  GWEN_Buffer_AppendString(nbuf, "here()");
919  return 0;
920  }
921 
922  lbuf=GWEN_Buffer_new(0, 256, 0, 1);
923  GWEN_Buffer_ReserveBytes(lbuf, 128);
924 
925  ln1=n1->parent;
926  if (ln1) {
927  GWEN_Buffer_AppendString(lbuf, "../");
928  while(ln1) {
929  if (ln1==n2) {
930  /* found n2 */
931  GWEN_Buffer_AppendBuffer(nbuf, lbuf);
932  GWEN_Buffer_free(lbuf);
933  return 0;
934  }
935  if (GWEN_XMLNode_IsChildOf(ln1, n2))
936  break;
937  ln1=ln1->parent;
938  GWEN_Buffer_AppendString(lbuf, "../");
939  }
940 
941  if (!ln1) {
942  DBG_ERROR(GWEN_LOGDOMAIN, "Nodes do not share root node");
943  GWEN_Buffer_free(lbuf);
944  return -1;
945  }
946 
947  /* append path to n1 */
948  GWEN_Buffer_AppendBuffer(nbuf, lbuf);
949  }
950  DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
951 
952  /* get path to n2 */
953  GWEN_Buffer_Reset(lbuf);
954 
955  ln2=n2;
956  while(ln2) {
957  GWEN_XMLNODE *tn;
958  int idx;
959  char idxbuf[32];
960 
961  if (ln2->parent==ln1)
962  break;
963 
964  /* count occurences of this tag in this level */
965  idx=1;
966  tn=ln2->parent;
967  if (tn) {
968  tn=GWEN_XMLNode_FindFirstTag(tn, ln2->data, 0, 0);
969 
970  while(tn) {
971  if (tn==ln2)
972  break;
973  idx++;
974  tn=GWEN_XMLNode_FindNextTag(tn, ln2->data, 0, 0);
975  }
976  }
977 
978  snprintf(idxbuf, sizeof(idxbuf), "[%d]", idx);
979  idxbuf[sizeof(idxbuf)-1]=0;
980  GWEN_Buffer_InsertString(lbuf, idxbuf);
982  GWEN_Buffer_InsertByte(lbuf, '/');
983  ln2=ln2->parent;
984  }
985  DBG_ERROR(GWEN_LOGDOMAIN, "Path so far: %s", GWEN_Buffer_GetStart(lbuf));
986  assert(ln2);
987 
988  /* append path to n2 */
989  GWEN_Buffer_AppendBuffer(nbuf, lbuf);
990  GWEN_Buffer_free(lbuf);
991  return 0;
992 }
993 
994 
995 
996 void* GWEN_XMLNode_HandlePath(const char *entry,
997  void *data,
998  int idx,
999  uint32_t flags) {
1000  GWEN_XMLNODE *n;
1001  GWEN_XMLNODE *nn;
1002  int i;
1003 
1004  n=(GWEN_XMLNODE*)data;
1005 
1006  if (flags & GWEN_PATH_FLAGS_VARIABLE) {
1008  "GWEN_PATH_FLAGS_VARIABLE not allowed for XPATH");
1009  return 0;
1010  }
1011 
1012  if (flags & GWEN_PATH_FLAGS_ROOT) {
1013  while(n->parent)
1014  n=n->parent;
1015  if (*entry=='/')
1016  entry++;
1017  }
1018 
1019  if (strcasecmp(entry, "..")==0) {
1020  return n->parent;
1021  }
1022  else if (strcasecmp(entry, ".")==0 ||
1023  strcasecmp(entry, "here()")==0) {
1024  return n;
1025  }
1026 
1027  /* check whether we are allowed to simply create the node */
1028  if (
1029  ((flags & GWEN_PATH_FLAGS_LAST) &&
1030  (((flags & GWEN_PATH_FLAGS_VARIABLE) &&
1031  (flags & GWEN_PATH_FLAGS_CREATE_VAR)) ||
1032  (!(flags & GWEN_PATH_FLAGS_VARIABLE) &&
1033  (flags & GWEN_PATH_FLAGS_CREATE_GROUP)))
1034  ) ||
1035  (
1036  !(flags & GWEN_PATH_FLAGS_LAST) &&
1037  (flags & GWEN_PATH_FLAGS_PATHCREATE))
1038  ) {
1039  /* simply create the new variable/group */
1040  if (flags & GWEN_PATH_FLAGS_VARIABLE) {
1041  /* not allowed for now */
1042  return 0;
1043  }
1044  else {
1045  if (idx!=0) {
1047  "Can not create tag with index!=1 (%s)", entry);
1048  return 0;
1049  }
1051  "Unconditionally creating tag \"%s\"", entry);
1053  GWEN_XMLNode_AddChild(n, nn);
1054  return nn;
1055  }
1056  }
1057 
1058  /* find the node */
1059  i=idx;
1060  nn=GWEN_XMLNode_FindFirstTag(n, entry, 0, 0);
1061  while(nn && i--) {
1062  nn=GWEN_XMLNode_FindNextTag(nn, entry, 0, 0);
1063  }
1064 
1065  if (!nn) {
1066  /* node not found, check, if we are allowed to create it */
1067  if (
1068  (!(flags & GWEN_PATH_FLAGS_LAST) &&
1069  (flags & GWEN_PATH_FLAGS_PATHMUSTEXIST)) ||
1071  ) {
1073  "Tag \"%s\" does not exist", entry);
1074  return 0;
1075  }
1076  /* create the new variable/group */
1077  if (idx!=0) {
1079  "Can not create tag with index!=1 (%s)", entry);
1080  return 0;
1081  }
1083  "Tag \"%s\" not found, creating", entry);
1085  GWEN_XMLNode_AddChild(n, nn);
1086  } /* if node not found */
1087  else {
1088  /* node does exist, check whether this is ok */
1089  if (
1090  ((flags & GWEN_PATH_FLAGS_LAST) &&
1091  (flags & GWEN_PATH_FLAGS_NAMEMUSTNOTEXIST)) ||
1092  (!(flags & GWEN_PATH_FLAGS_LAST) &&
1094  ) {
1095  DBG_VERBOUS(GWEN_LOGDOMAIN, "Entry \"%s\" already exists", entry);
1096  return 0;
1097  }
1098  }
1099 
1100  return nn;
1101 }
1102 
1103 
1104 
1106  const char *path,
1107  uint32_t flags){
1108  return (GWEN_XMLNODE*)GWEN_Path_HandleWithIdx(path,
1109  (void*)n,
1110  flags,
1112 }
1113 
1114 
1115 
1117  assert(n);
1118  return GWEN_XMLNode_List_First(n->headers);
1119 }
1120 
1121 
1122 
1124  assert(n);
1125  assert(nh);
1126  GWEN_XMLNode_List_Add(nh, n->headers);
1127 }
1128 
1129 
1130 
1132  assert(n);
1133  assert(nh);
1134  GWEN_XMLNode_List_Del(nh);
1135 }
1136 
1137 
1138 
1140  assert(n);
1141  GWEN_XMLNode_List_Clear(n->headers);
1142 }
1143 
1144 
1145 
1146 GWEN_XMLNODE_NAMESPACE_LIST *GWEN_XMLNode_GetNameSpaces(const GWEN_XMLNODE *n) {
1147  assert(n);
1148  return n->nameSpaces;
1149 }
1150 
1151 
1152 
1154  const char *s) {
1156 
1157  assert(n);
1158  ns=GWEN_XMLNode_NameSpace_List_First(n->nameSpaces);
1159  while(ns) {
1160  const char *d;
1161 
1163  if (d && strcasecmp(d, s)==0)
1164  return ns;
1165  ns=GWEN_XMLNode_NameSpace_List_Next(ns);
1166  }
1167 
1168  return NULL;
1169 }
1170 
1171 
1172 
1174  const char *s) {
1176 
1177  assert(n);
1178  ns=GWEN_XMLNode_NameSpace_List_First(n->nameSpaces);
1179  while(ns) {
1180  const char *d;
1181 
1183  if (d && strcasecmp(d, s)==0)
1184  return ns;
1185  ns=GWEN_XMLNode_NameSpace_List_Next(ns);
1186  }
1187 
1188  return NULL;
1189 }
1190 
1191 
1192 
1194  assert(n);
1195  assert(ns);
1196  GWEN_XMLNode_NameSpace_List_Add(GWEN_XMLNode_NameSpace_dup(ns), n->nameSpaces);
1197 }
1198 
1199 
1200 
1201 
1202 
1203 
1204 
1205 
1206 
1207 
1208 
1210  const char *prefix,
1211  const char *name){
1212  GWEN_BUFFER *nbuf;
1213  int rv;
1214 
1215  nbuf=GWEN_Buffer_new(0, 32, 0, 1);
1216  if (prefix)
1217  GWEN_Buffer_AppendString(nbuf, prefix);
1218  GWEN_Buffer_AppendByte(nbuf, ':');
1219  GWEN_Buffer_AppendString(nbuf, name);
1222  GWEN_Buffer_free(nbuf);
1223  return rv;
1224 }
1225 
1226 
1227 
1229  const char *s){
1231 
1232  it=GWEN_StringList2_First(sl);
1233  if (it) {
1234  const char *t;
1235 
1237  assert(t);
1238  while(t) {
1239  const char *p;
1240 
1241  p=strchr(t, ':');
1242  assert(p);
1243  if ((s==0 && p==t) || (s && strncasecmp(t, s, p-t)==0))
1244  return t;
1246  } /* while */
1248  }
1249  return 0;
1250 }
1251 
1252 
1253 
1255  const char *s){
1257 
1258  it=GWEN_StringList2_First(sl);
1259  if (it) {
1260  const char *t;
1261 
1263  assert(t);
1264  while(t) {
1265  const char *p;
1266 
1267  p=strchr(t, ':');
1268  assert(p);
1269  p++;
1270  if (strcasecmp(p, s)==0) {
1272  return t;
1273  }
1275  } /* while */
1277  }
1278  return 0;
1279 }
1280 
1281 
1282 
1284  const char *prefix,
1285  const char *name){
1286  GWEN_BUFFER *nbuf;
1288 
1289  nbuf=GWEN_Buffer_new(0, 32, 0, 1);
1290  if (prefix)
1291  GWEN_Buffer_AppendString(nbuf, prefix);
1292  GWEN_Buffer_AppendByte(nbuf, ':');
1293  GWEN_Buffer_AppendString(nbuf, name);
1294 
1295  it=GWEN_StringList2_First(sl);
1296  if (it) {
1297  const char *t;
1298 
1300  assert(t);
1301  while(t) {
1302  const char *p;
1303 
1304  p=strchr(t, ':');
1305  assert(p);
1306  p++;
1307  if (strcasecmp(p, GWEN_Buffer_GetStart(nbuf))==0) {
1309  GWEN_Buffer_free(nbuf);
1310  return t;
1311  }
1313  } /* while */
1315  }
1316 
1317  GWEN_Buffer_free(nbuf);
1318  return 0;
1319 }
1320 
1321 
1322 
1324  GWEN_STRINGLIST2 *sl,
1325  const char *currentNameSpace) {
1326  GWEN_XMLPROPERTY *pr;
1327  GWEN_XMLNODE *nn;
1328  char *localNameSpace;
1329 
1330  localNameSpace=0;
1331 
1332  /* remove all unnecessary namespace declarations from this node */
1333  pr=n->properties;
1334  while(pr) {
1335  GWEN_XMLPROPERTY *prNext;
1336 
1337  prNext=pr->next;
1338  if (strcasecmp(pr->name, "xmlns")==0) {
1339  /* default namespace changed ? */
1340  if (localNameSpace) {
1341  if (strcasecmp(pr->value, localNameSpace)==0) {
1342  /* already mentioned name space, remove duplicate property */
1343  GWEN_XMLProperty_del(pr, &n->properties);
1345  }
1346  else {
1347  /* current namespace changed */
1348  GWEN_Memory_dealloc(localNameSpace);
1349  localNameSpace=GWEN_Memory_strdup(pr->value);
1350  }
1351  }
1352  else if (currentNameSpace) {
1353  if (strcasecmp(pr->value, currentNameSpace)==0) {
1354  /* already active name space, remove property */
1355  GWEN_XMLProperty_del(pr, &n->properties);
1357  }
1358  else {
1359  /* current namespace changed */
1360  GWEN_Memory_dealloc(localNameSpace);
1361  localNameSpace=GWEN_Memory_strdup(pr->value);
1362  }
1363  }
1364  else {
1365  /* set current namespace */
1366  GWEN_Memory_dealloc(localNameSpace);
1367  localNameSpace=GWEN_Memory_strdup(pr->value);
1368  }
1369  }
1370  else if (strncasecmp(pr->name, "xmlns:", 6)==0) {
1371  const char *prefix;
1372  const char *x;
1373 
1374  prefix=strchr(pr->name, ':');
1375  prefix++;
1376 
1377  /* check for redefinition */
1378  x=GWEN_XML_FindNameSpaceByName(sl, prefix);
1379  if (x) {
1380  const char *p;
1381 
1382  /* prefix already in use, check whether it is the same namespace */
1383  p=strchr(x, ':');
1384  assert(p);
1385  p++;
1386  if (strcasecmp(p, pr->value)!=0) {
1387  GWEN_BUFFER *xpath;
1388 
1389  /* same prefix, different namespace */
1390  xpath=GWEN_Buffer_new(0, 256, 0, 1);
1391  GWEN_XMLNode_GetXPath(0, n, xpath);
1393  "Redefinition of namespace prefix \"%s\" in \"%s\"",
1394  prefix, GWEN_Buffer_GetStart(xpath));
1395  GWEN_Buffer_free(xpath);
1396  return -1;
1397  } /* if different namespace for same prefix */
1398  else {
1399  /* already in list, remove property here */
1400  GWEN_XMLProperty_del(pr, &n->properties);
1402  }
1403  }
1404  else {
1405  GWEN_XML_AddNameSpace(sl, prefix, pr->value);
1406  }
1407  }
1408  pr=prNext;
1409  } /* while */
1410 
1411  /* do the same on all sub nodes */
1413  while(nn) {
1414  int rv;
1415 
1417  localNameSpace?localNameSpace:
1418  currentNameSpace);
1419  if (rv) {
1420  GWEN_Memory_dealloc(localNameSpace);
1421  return rv;
1422  }
1423  nn=GWEN_XMLNode_GetNextTag(nn);
1424  }
1425 
1426  GWEN_Memory_dealloc(localNameSpace);
1427  return 0;
1428 }
1429 
1430 
1431 
1433  const char *prefix,
1434  const char *nspace) {
1435  GWEN_XMLPROPERTY *pr;
1436  const char *p;
1437  int inUse;
1438 
1439  inUse=0;
1440  /* check current tag for prefix */
1441  if (prefix) {
1442  p=strchr(n->data, ':');
1443  if (p) {
1444  if (strncasecmp(n->data, prefix, p-n->data)==0) {
1445  DBG_DEBUG(GWEN_LOGDOMAIN, "Prefix \"%s\" used in tag \"%s\"",
1446  prefix, n->data);
1447  inUse=1;
1448  }
1449  }
1450 
1451  if (!inUse) {
1452  /* check all attributes for prefixes */
1453  pr=n->properties;
1454  while(pr) {
1455  p=strchr(pr->name, ':');
1456  if (p) {
1457  if (strncasecmp(pr->name, prefix, p-pr->name)==0) {
1459  "Prefix \"%s\" used in attribute \"%s\" of tag \"%s\"",
1460  prefix, pr->name, n->data);
1461  inUse=1;
1462  break;
1463  }
1464  else {
1466  "Prefix \"%s\" not used in attribute \"%s\" of tag \"%s\"",
1467  prefix, pr->name, n->data);
1468  }
1469  }
1470  pr=pr->next;
1471  } /* while */
1472  }
1473  } /* if prefix */
1474  else {
1475  /* no prefix, check whether the current element hasn't any */
1476  p=strchr(n->data, ':');
1477  if (!p) {
1478  /* current tag has no prefix, check whether we have a namespace
1479  * declaration here */
1480  if (GWEN_XMLNode_GetProperty(n, "xmlns", 0)==0) {
1481  /* no, so the current namespace from above is used */
1483  "No prefix, current namespace is used");
1484  inUse=1;
1485  }
1486  }
1487  } /* if no prefix */
1488 
1489  if (inUse) {
1490  GWEN_BUFFER *nbuf;
1491 
1492  nbuf=GWEN_Buffer_new(0, 32, 0, 1);
1493  GWEN_Buffer_AppendString(nbuf, "xmlns");
1494  if (prefix) {
1495  GWEN_Buffer_AppendByte(nbuf, ':');
1496  GWEN_Buffer_AppendString(nbuf, prefix);
1497  }
1498  GWEN_XMLNode__SetProperty(n, GWEN_Buffer_GetStart(nbuf), nspace, 1);
1499  GWEN_Buffer_free(nbuf);
1500  return 1;
1501  }
1502 
1503  return 0;
1504 }
1505 
1506 
1507 
1509  const char *prefix,
1510  const char *nspace) {
1511  GWEN_XMLNODE *nn;
1512  int rv;
1513 
1514  rv=GWEN_XMLNode__CheckAndSetNameSpace(n, prefix, nspace);
1515  if (rv)
1516  return rv;
1517 
1519  while(nn) {
1520  rv=GWEN_XMLNode__CheckAndSetNameSpace(nn, prefix, nspace);
1521  if (rv==-1)
1522  return rv;
1523  else if (rv==0) {
1524  /* check children */
1525  rv=GWEN_XMLNode__SetNameSpaces(nn, prefix, nspace);
1526  if (rv)
1527  return rv;
1528  }
1529 
1530  nn=GWEN_XMLNode_GetNextTag(nn);
1531  }
1532 
1533  return 0;
1534 }
1535 
1536 
1537 
1539  GWEN_XMLPROPERTY *pr;
1540  GWEN_XMLNODE *nn;
1541  int rv;
1542 
1543  /* move all namespace declarations from this node to the nodes
1544  * of first use */
1545  pr=n->properties;
1546  while(pr) {
1547  GWEN_XMLPROPERTY *prNext;
1548 
1549  prNext=pr->next;
1550  if (strcasecmp(pr->name, "xmlns")==0 ||
1551  strncasecmp(pr->name, "xmlns:", 6)==0) {
1552  const char *prefix;
1553 
1554  prefix=strchr(pr->name, ':');
1555  if (prefix)
1556  prefix++;
1557 
1558  GWEN_XMLProperty_del(pr, &n->properties);
1559  rv=GWEN_XMLNode__SetNameSpaces(n, prefix, pr->value);
1560  DBG_DEBUG(GWEN_LOGDOMAIN, "Removing property \"%s\"",
1561  pr->name);
1563  if (rv==-1)
1564  return rv;
1565  }
1566  pr=prNext;
1567  } /* while */
1568 
1569  /* do the same on all sub nodes */
1571  while(nn) {
1573  if (rv) {
1574  return rv;
1575  }
1576  nn=GWEN_XMLNode_GetNextTag(nn);
1577  }
1578 
1579  return 0;
1580 }
1581 
1582 
1583 
1584 
1586  const char *ns;
1587  int rv;
1588  GWEN_STRINGLIST2 *sl;
1589 
1590  ns=GWEN_XMLNode_GetProperty(n, "xmlns", 0);
1591  sl=GWEN_StringList2_new();
1592  rv=GWEN_XMLNode__CheckNameSpaceDecls1(n, sl, ns);
1594  if (rv) {
1595  DBG_INFO(GWEN_LOGDOMAIN, "here");
1596  return rv;
1597  }
1598 
1599  //rv=GWEN_XMLNode__CheckNameSpaceDecls2(n, ns);
1601  if (rv==-1)
1602  return rv;
1603  return 0;
1604 }
1605 
1606 
1607 
1609  if (n && n->type==GWEN_XMLNodeTypeTag && n->data) {
1610  GWEN_XMLNODE *nn;
1611  GWEN_XMLPROPERTY *pp;
1612 
1613  if (n->nameSpace==0) {
1614  char *p;
1615 
1616  p=strchr(n->data, ':');
1617  if (p) {
1618  int len=p-n->data;
1619  char *s;
1620 
1621  n->nameSpace=(char*)GWEN_Memory_malloc(len);
1622  assert(n->nameSpace);
1623  memmove(n->nameSpace, n->data, len);
1624  n->nameSpace[len-1]=0;
1625  s=GWEN_Memory_strdup(p+1);
1626  free(n->data);
1627  n->data=s;
1628  }
1629  }
1630 
1631  pp=n->properties;
1632  while(pp) {
1633  if (pp->nameSpace==0) {
1634  char *p;
1635 
1636  p=strchr(pp->name, ':');
1637  if (p) {
1638  int len=p-pp->name;
1639  char *s;
1640 
1641  pp->nameSpace=(char*)GWEN_Memory_malloc(len);
1642  assert(pp->nameSpace);
1643  memmove(pp->nameSpace, pp->name, len);
1644  pp->nameSpace[len-1]=0;
1645  s=GWEN_Memory_strdup(p+1);
1646  free(pp->name);
1647  pp->name=s;
1648  }
1649  }
1650 
1651  pp=pp->next;
1652  }
1653 
1654  nn=GWEN_XMLNode_List_First(n->children);
1655  while(nn) {
1656  int rv;
1657 
1659  if (rv<0) {
1660  DBG_DEBUG(GWEN_LOGDOMAIN, "here (%d)", rv);
1661  return rv;
1662  }
1663  nn=GWEN_XMLNode_List_Next(nn);
1664  }
1665  }
1666 
1667  return 0;
1668 }
1669 
1670 
1671 
1672 
1673 
1674 
1675 
1676 
1677 
1679  GWEN_XMLNODE_PATH *p;
1680 
1682  return p;
1683 }
1684 
1685 
1686 
1688  GWEN_XMLNODE_PATH *p;
1689  unsigned int i;
1690 
1692  p->pos=np->pos;
1693  for (i=0; i<np->pos; i++) {
1694  p->nodes[i]=np->nodes[i];
1695  }
1696  return p;
1697 }
1698 
1699 
1700 
1702  GWEN_FREE_OBJECT(np);
1703 }
1704 
1705 
1706 
1708  GWEN_XMLNODE *n){
1709  unsigned int i;
1710 
1711  if (np->pos>=GWEN_XML_MAX_DEPTH) {
1712  DBG_ERROR(GWEN_LOGDOMAIN, "Path too deep");
1713  return 1;
1714  }
1715 
1716  /* check for double entries */
1717  for (i=0; i<np->pos; i++) {
1718  assert(np->nodes[i]!=n);
1719  }
1720  np->nodes[np->pos++]=n;
1721  DBG_DEBUG(GWEN_LOGDOMAIN, "Dived to %d", np->pos);
1722  return 0;
1723 }
1724 
1725 
1726 
1728  if (np->pos==0) {
1729  DBG_DEBUG(GWEN_LOGDOMAIN, "Root reached");
1730  return 0;
1731  }
1732  DBG_DEBUG(GWEN_LOGDOMAIN, "Surfaced to %d", np->pos-1);
1733  return np->nodes[--np->pos];
1734 }
1735 
1736 
1737 
1739  unsigned int i;
1740 
1741  if (np->pos==0) {
1742  DBG_NOTICE(GWEN_LOGDOMAIN, "Empty path");
1743  }
1744  for (i=0; i<np->pos; i++) {
1745  DBG_NOTICE(GWEN_LOGDOMAIN, "Path entry %d:", i);
1746  GWEN_XMLNode_Dump(np->nodes[i], 1);
1747  }
1748 }
1749 
1750 
1751 
1752 
1753 
1754 
1755 
1756 
1757 
1758 
1759 
1761  const char *url) {
1763 
1766 
1767  if (name)
1768  ns->name=GWEN_Memory_strdup(name);
1769  if (url)
1770  ns->url=GWEN_Memory_strdup(url);
1771 
1772  return ns;
1773 }
1774 
1775 
1776 
1778  if (ns) {
1780  free(ns->url);
1781  free(ns->name);
1782  GWEN_FREE_OBJECT(ns);
1783  }
1784 }
1785 
1786 
1787 
1790 
1791  assert(ns);
1792  nns=GWEN_XMLNode_NameSpace_new(ns->name, ns->url);
1793  return nns;
1794 }
1795 
1796 
1797 
1799  assert(ns);
1800  return ns->name;
1801 }
1802 
1803 
1804 
1806  assert(ns);
1807  return ns->url;
1808 }
1809 
1810 
1811 
1812 
1813 
1814 
1815 #include "xmlrw.c"
1816 #include "xmlglobalize.c"
1817 
1818 
1819