Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/xml_element.c, revision 1.1.1.1
1.1 misho 1: /*
2: This file is part of libXMLRPC - a C library for xml-encoded function calls.
3:
4: Author: Dan Libby (dan@libby.com)
5: Epinions.com may be contacted at feedback@epinions-inc.com
6: */
7:
8: /*
9: Copyright 2000 Epinions, Inc.
10:
11: Subject to the following 3 conditions, Epinions, Inc. permits you, free
12: of charge, to (a) use, copy, distribute, modify, perform and display this
13: software and associated documentation files (the "Software"), and (b)
14: permit others to whom the Software is furnished to do so as well.
15:
16: 1) The above copyright notice and this permission notice shall be included
17: without modification in all copies or substantial portions of the
18: Software.
19:
20: 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF
21: ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY
22: IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR
23: PURPOSE OR NONINFRINGEMENT.
24:
25: 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT,
26: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
27: OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING
28: NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH
29: DAMAGES.
30:
31: */
32:
33:
34: static const char rcsid[] = "#(@) $Id: xml_element.c 271367 2008-12-17 00:30:27Z iliaa $";
35:
36:
37:
38: /****h* ABOUT/xml_element
39: * NAME
40: * xml_element
41: * AUTHOR
42: * Dan Libby, aka danda (dan@libby.com)
43: * CREATION DATE
44: * 06/2000
45: * HISTORY
46: * $Log$
47: * Revision 1.9.4.1.2.1 2008/12/09 17:22:12 iliaa
48: *
49: * MFH: Fixed bug #46746 (xmlrpc_decode_request outputs non-suppressable error
50: * when given bad data).
51: *
52: * Revision 1.9.4.1 2006/07/30 11:34:02 tony2001
53: * MFH: fix compile warnings (#38257)
54: *
55: * Revision 1.9 2005/04/22 11:06:53 jorton
56: * Fixed bug #32797 (invalid C code in xmlrpc extension).
57: *
58: * Revision 1.8 2005/03/28 00:07:24 edink
59: * Reshufle includes to make it compile on windows
60: *
61: * Revision 1.7 2005/03/26 03:13:58 sniper
62: * - Made it possible to build ext/xmlrpc with libxml2
63: *
64: * Revision 1.6 2004/06/01 20:16:06 iliaa
65: * Fixed bug #28597 (xmlrpc_encode_request() incorrectly encodes chars in
66: * 200-210 range).
67: * Patch by: fernando dot nemec at folha dot com dot br
68: *
69: * Revision 1.5 2003/12/16 21:00:21 sniper
70: * Fix some compile warnings (patch by Joe Orton)
71: *
72: * Revision 1.4 2002/11/26 23:01:16 fmk
73: * removing unused variables
74: *
75: * Revision 1.3 2002/07/05 04:43:53 danda
76: * merged in updates from SF project. bring php repository up to date with xmlrpc-epi version 0.51
77: *
78: * Revision 1.9 2002/07/03 20:54:30 danda
79: * root element should not have a parent. patch from anon SF user
80: *
81: * Revision 1.8 2002/05/23 17:46:51 danda
82: * patch from mukund - fix non utf-8 encoding conversions
83: *
84: * Revision 1.7 2002/02/13 20:58:50 danda
85: * patch to make source more windows friendly, contributed by Jeff Lawson
86: *
87: * Revision 1.6 2002/01/08 01:06:55 danda
88: * enable <?xml version="1.0"?> format for parsers that are very picky.
89: *
90: * Revision 1.5 2001/09/29 21:58:05 danda
91: * adding cvs log to history section
92: *
93: * 10/15/2000 -- danda -- adding robodoc documentation
94: * TODO
95: * Nicer external API. Get rid of macros. Make opaque types, etc.
96: * PORTABILITY
97: * Coded on RedHat Linux 6.2. Builds on Solaris x86. Should build on just
98: * about anything with minor mods.
99: * NOTES
100: * This code incorporates ideas from expat-ensor from http://xml.ensor.org.
101: *
102: * It was coded primarily to act as a go-between for expat and xmlrpc. To this
103: * end, it stores xml elements, their sub-elements, and their attributes in an
104: * in-memory tree. When expat is done parsing, the tree can be walked, thus
105: * retrieving the values. The code can also be used to build a tree via API then
106: * write out the tree to a buffer, thus "serializing" the xml.
107: *
108: * It turns out this is useful for other purposes, such as parsing config files.
109: * YMMV.
110: *
111: * Some Features:
112: * - output option for xml escaping data. Choices include no escaping, entity escaping,
113: * or CDATA sections.
114: * - output option for character encoding. Defaults to (none) utf-8.
115: * - output option for verbosity/readability. ultra-compact, newlines, pretty/level indented.
116: *
117: * BUGS
118: * there must be some.
119: ******/
120:
121: #include "ext/xml/expat_compat.h"
122: #ifdef _WIN32
123: #include "xmlrpc_win32.h"
124: #endif
125: #include <stdlib.h>
126: #include <string.h>
127: #include <ctype.h>
128:
129: #include "xml_element.h"
130: #include "queue.h"
131: #include "encodings.h"
132:
133: #define my_free(thing) if(thing) {free(thing); thing = NULL;}
134:
135: #define XML_DECL_START "<?xml"
136: #define XML_DECL_START_LEN sizeof(XML_DECL_START) - 1
137: #define XML_DECL_VERSION "version=\"1.0\""
138: #define XML_DECL_VERSION_LEN sizeof(XML_DECL_VERSION) - 1
139: #define XML_DECL_ENCODING_ATTR "encoding"
140: #define XML_DECL_ENCODING_ATTR_LEN sizeof(XML_DECL_ENCODING_ATTR) - 1
141: #define XML_DECL_ENCODING_DEFAULT "utf-8"
142: #define XML_DECL_ENCODING_DEFAULT_LEN sizeof(XML_DECL_ENCODING_DEFAULT) - 1
143: #define XML_DECL_END "?>"
144: #define XML_DECL_END_LEN sizeof(XML_DECL_END) - 1
145: #define START_TOKEN_BEGIN "<"
146: #define START_TOKEN_BEGIN_LEN sizeof(START_TOKEN_BEGIN) - 1
147: #define START_TOKEN_END ">"
148: #define START_TOKEN_END_LEN sizeof(START_TOKEN_END) - 1
149: #define EMPTY_START_TOKEN_END "/>"
150: #define EMPTY_START_TOKEN_END_LEN sizeof(EMPTY_START_TOKEN_END) - 1
151: #define END_TOKEN_BEGIN "</"
152: #define END_TOKEN_BEGIN_LEN sizeof(END_TOKEN_BEGIN) - 1
153: #define END_TOKEN_END ">"
154: #define END_TOKEN_END_LEN sizeof(END_TOKEN_END) - 1
155: #define ATTR_DELIMITER "\""
156: #define ATTR_DELIMITER_LEN sizeof(ATTR_DELIMITER) - 1
157: #define CDATA_BEGIN "<![CDATA["
158: #define CDATA_BEGIN_LEN sizeof(CDATA_BEGIN) - 1
159: #define CDATA_END "]]>"
160: #define CDATA_END_LEN sizeof(CDATA_END) - 1
161: #define EQUALS "="
162: #define EQUALS_LEN sizeof(EQUALS) - 1
163: #define WHITESPACE " "
164: #define WHITESPACE_LEN sizeof(WHITESPACE) - 1
165: #define NEWLINE "\n"
166: #define NEWLINE_LEN sizeof(NEWLINE) - 1
167: #define MAX_VAL_BUF 144
168: #define SCALAR_STR "SCALAR"
169: #define SCALAR_STR_LEN sizeof(SCALAR_STR) - 1
170: #define VECTOR_STR "VECTOR"
171: #define VECTOR_STR_LEN sizeof(VECTOR_STR) - 1
172: #define RESPONSE_STR "RESPONSE"
173: #define RESPONSE_STR_LEN sizeof(RESPONSE_STR) - 1
174:
175:
176: /*-----------------------------
177: - Begin xml_element Functions -
178: -----------------------------*/
179:
180: /****f* xml_element/xml_elem_free_non_recurse
181: * NAME
182: * xml_elem_free_non_recurse
183: * SYNOPSIS
184: * void xml_elem_free_non_recurse(xml_element* root)
185: * FUNCTION
186: * free a single xml element. child elements will not be freed.
187: * INPUTS
188: * root - the element to free
189: * RESULT
190: * void
191: * NOTES
192: * SEE ALSO
193: * xml_elem_free ()
194: * xml_elem_new ()
195: * SOURCE
196: */
197: void xml_elem_free_non_recurse(xml_element* root) {
198: if(root) {
199: xml_element_attr* attrs = Q_Head(&root->attrs);
200: while(attrs) {
201: my_free(attrs->key);
202: my_free(attrs->val);
203: my_free(attrs);
204: attrs = Q_Next(&root->attrs);
205: }
206:
207: Q_Destroy(&root->children);
208: Q_Destroy(&root->attrs);
209: if(root->name) {
210: free((char *)root->name);
211: root->name = NULL;
212: }
213: simplestring_free(&root->text);
214: my_free(root);
215: }
216: }
217: /******/
218:
219: /****f* xml_element/xml_elem_free
220: * NAME
221: * xml_elem_free
222: * SYNOPSIS
223: * void xml_elem_free(xml_element* root)
224: * FUNCTION
225: * free an xml element and all of its child elements
226: * INPUTS
227: * root - the root of an xml tree you would like to free
228: * RESULT
229: * void
230: * NOTES
231: * SEE ALSO
232: * xml_elem_free_non_recurse ()
233: * xml_elem_new ()
234: * SOURCE
235: */
236: void xml_elem_free(xml_element* root) {
237: if(root) {
238: xml_element* kids = Q_Head(&root->children);
239: while(kids) {
240: xml_elem_free(kids);
241: kids = Q_Next(&root->children);
242: }
243: xml_elem_free_non_recurse(root);
244: }
245: }
246: /******/
247:
248: /****f* xml_element/xml_elem_new
249: * NAME
250: * xml_elem_new
251: * SYNOPSIS
252: * xml_element* xml_elem_new()
253: * FUNCTION
254: * allocates and initializes a new xml_element
255: * INPUTS
256: * none
257: * RESULT
258: * xml_element* or NULL. NULL indicates an out-of-memory condition.
259: * NOTES
260: * SEE ALSO
261: * xml_elem_free ()
262: * xml_elem_free_non_recurse ()
263: * SOURCE
264: */
265: xml_element* xml_elem_new() {
266: xml_element* elem = calloc(1, sizeof(xml_element));
267: if(elem) {
268: Q_Init(&elem->children);
269: Q_Init(&elem->attrs);
270: simplestring_init(&elem->text);
271:
272: /* init empty string in case we don't find any char data */
273: simplestring_addn(&elem->text, "", 0);
274: }
275: return elem;
276: }
277: /******/
278:
279: static int xml_elem_writefunc(int (*fptr)(void *data, const char *text, int size), const char *text, void *data, int len)
280: {
281: return fptr && text ? fptr(data, text, len ? len : strlen(text)) : 0;
282: }
283:
284:
285:
286: static int create_xml_escape(char *pString, unsigned char c)
287: {
288: int counter = 0;
289:
290: pString[counter++] = '&';
291: pString[counter++] = '#';
292: if(c >= 100) {
293: pString[counter++] = c / 100 + '0';
294: c = c % 100;
295: }
296: pString[counter++] = c / 10 + '0';
297: c = c % 10;
298:
299: pString[counter++] = c + '0';
300: pString[counter++] = ';';
301: return counter;
302: }
303:
304: #define non_ascii(c) (c > 127)
305: #define non_print(c) (!isprint(c))
306: #define markup(c) (c == '&' || c == '\"' || c == '>' || c == '<')
307: #define entity_length(c) ( (c >= 100) ? 3 : ((c >= 10) ? 2 : 1) ) + 3; /* "&#" + c + ";" */
308:
309: /*
310: * xml_elem_entity_escape
311: *
312: * Purpose:
313: * escape reserved xml chars and non utf-8 chars as xml entities
314: * Comments:
315: * The return value may be a new string, or null if no
316: * conversion was performed. In the latter case, *newlen will
317: * be 0.
318: * Flags (to escape)
319: * xml_elem_no_escaping = 0x000,
320: * xml_elem_entity_escaping = 0x002, // escape xml special chars as entities
321: * xml_elem_non_ascii_escaping = 0x008, // escape chars above 127
322: * xml_elem_cdata_escaping = 0x010, // wrap in cdata
323: */
324: static char* xml_elem_entity_escape(const char* buf, int old_len, int *newlen, XML_ELEM_ESCAPING flags) {
325: char *pRetval = 0;
326: int iNewBufLen=0;
327:
328: #define should_escape(c, flag) ( ((flag & xml_elem_markup_escaping) && markup(c)) || \
329: ((flag & xml_elem_non_ascii_escaping) && non_ascii(c)) || \
330: ((flag & xml_elem_non_print_escaping) && non_print(c)) )
331:
332: if(buf && *buf) {
333: const unsigned char *bufcopy;
334: char *NewBuffer;
335: int ToBeXmlEscaped=0;
336: int iLength;
337: bufcopy = buf;
338: iLength= old_len ? old_len : strlen(buf);
339: while(*bufcopy) {
340: if( should_escape(*bufcopy, flags) ) {
341: /* the length will increase by length of xml escape - the character length */
342: iLength += entity_length(*bufcopy);
343: ToBeXmlEscaped=1;
344: }
345: bufcopy++;
346: }
347:
348: if(ToBeXmlEscaped) {
349:
350: NewBuffer= malloc(iLength+1);
351: if(NewBuffer) {
352: bufcopy=buf;
353: while(*bufcopy) {
354: if(should_escape(*bufcopy, flags)) {
355: iNewBufLen += create_xml_escape(NewBuffer+iNewBufLen,*bufcopy);
356: }
357: else {
358: NewBuffer[iNewBufLen++]=*bufcopy;
359: }
360: bufcopy++;
361: }
362: NewBuffer[iNewBufLen] = 0;
363: pRetval = NewBuffer;
364: }
365: }
366: }
367:
368: if(newlen) {
369: *newlen = iNewBufLen;
370: }
371:
372: return pRetval;
373: }
374:
375:
376: static void xml_element_serialize(xml_element *el, int (*fptr)(void *data, const char *text, int size), void *data, XML_ELEM_OUTPUT_OPTIONS options, int depth)
377: {
378: int i;
379: static STRUCT_XML_ELEM_OUTPUT_OPTIONS default_opts = {xml_elem_pretty, xml_elem_markup_escaping | xml_elem_non_print_escaping, XML_DECL_ENCODING_DEFAULT};
380: static char whitespace[] = " "
381: " "
382: " ";
383: depth++;
384:
385: if(!el) {
386: /* fprintf(stderr, "Nothing to write\n"); */
387: return;
388: }
389: if(!options) {
390: options = &default_opts;
391: }
392:
393: /* print xml declaration if at root level */
394: if(depth == 1) {
395: xml_elem_writefunc(fptr, XML_DECL_START, data, XML_DECL_START_LEN);
396: xml_elem_writefunc(fptr, WHITESPACE, data, WHITESPACE_LEN);
397: xml_elem_writefunc(fptr, XML_DECL_VERSION, data, XML_DECL_VERSION_LEN);
398: if(options->encoding && *options->encoding) {
399: xml_elem_writefunc(fptr, WHITESPACE, data, WHITESPACE_LEN);
400: xml_elem_writefunc(fptr, XML_DECL_ENCODING_ATTR, data, XML_DECL_ENCODING_ATTR_LEN);
401: xml_elem_writefunc(fptr, EQUALS, data, EQUALS_LEN);
402: xml_elem_writefunc(fptr, ATTR_DELIMITER, data, ATTR_DELIMITER_LEN);
403: xml_elem_writefunc(fptr, options->encoding, data, 0);
404: xml_elem_writefunc(fptr, ATTR_DELIMITER, data, ATTR_DELIMITER_LEN);
405: }
406: xml_elem_writefunc(fptr, XML_DECL_END, data, XML_DECL_END_LEN);
407: if(options->verbosity != xml_elem_no_white_space) {
408: xml_elem_writefunc(fptr, NEWLINE, data, NEWLINE_LEN);
409: }
410: }
411:
412: if(options->verbosity == xml_elem_pretty && depth > 2) {
413: xml_elem_writefunc(fptr, whitespace, data, depth - 2);
414: }
415: /* begin element */
416: xml_elem_writefunc(fptr,START_TOKEN_BEGIN, data, START_TOKEN_BEGIN_LEN);
417: if(el->name) {
418: xml_elem_writefunc(fptr, el->name, data, 0);
419:
420: /* write attrs, if any */
421: if(Q_Size(&el->attrs)) {
422: xml_element_attr* iter = Q_Head(&el->attrs);
423: while( iter ) {
424: xml_elem_writefunc(fptr, WHITESPACE, data, WHITESPACE_LEN);
425: xml_elem_writefunc(fptr, iter->key, data, 0);
426: xml_elem_writefunc(fptr, EQUALS, data, EQUALS_LEN);
427: xml_elem_writefunc(fptr, ATTR_DELIMITER, data, ATTR_DELIMITER_LEN);
428: xml_elem_writefunc(fptr, iter->val, data, 0);
429: xml_elem_writefunc(fptr, ATTR_DELIMITER, data, ATTR_DELIMITER_LEN);
430:
431: iter = Q_Next(&el->attrs);
432: }
433: }
434: }
435: else {
436: xml_elem_writefunc(fptr, "None", data, 0);
437: }
438: /* if no text and no children, use abbreviated form, eg: <foo/> */
439: if(!el->text.len && !Q_Size(&el->children)) {
440: xml_elem_writefunc(fptr, EMPTY_START_TOKEN_END, data, EMPTY_START_TOKEN_END_LEN);
441: }
442: /* otherwise, print element contents */
443: else {
444: xml_elem_writefunc(fptr, START_TOKEN_END, data, START_TOKEN_END_LEN);
445:
446: /* print text, if any */
447: if(el->text.len) {
448: char* escaped_str = el->text.str;
449: int buflen = el->text.len;
450:
451: if(options->escaping && options->escaping != xml_elem_cdata_escaping) {
452: escaped_str = xml_elem_entity_escape(el->text.str, buflen, &buflen, options->escaping );
453: if(!escaped_str) {
454: escaped_str = el->text.str;
455: }
456: }
457:
458: if(options->escaping & xml_elem_cdata_escaping) {
459: xml_elem_writefunc(fptr, CDATA_BEGIN, data, CDATA_BEGIN_LEN);
460: }
461:
462: xml_elem_writefunc(fptr, escaped_str, data, buflen);
463:
464: if(escaped_str != el->text.str) {
465: my_free(escaped_str);
466: }
467:
468: if(options->escaping & xml_elem_cdata_escaping) {
469: xml_elem_writefunc(fptr, CDATA_END, data, CDATA_END_LEN);
470: }
471: }
472: /* no text, so print child elems */
473: else {
474: xml_element *kids = Q_Head(&el->children);
475: i = 0;
476: while( kids ) {
477: if(i++ == 0) {
478: if(options->verbosity != xml_elem_no_white_space) {
479: xml_elem_writefunc(fptr, NEWLINE, data, NEWLINE_LEN);
480: }
481: }
482: xml_element_serialize(kids, fptr, data, options, depth);
483: kids = Q_Next(&el->children);
484: }
485: if(i) {
486: if(options->verbosity == xml_elem_pretty && depth > 2) {
487: xml_elem_writefunc(fptr, whitespace, data, depth - 2);
488: }
489: }
490: }
491:
492: xml_elem_writefunc(fptr, END_TOKEN_BEGIN, data, END_TOKEN_BEGIN_LEN);
493: xml_elem_writefunc(fptr,el->name ? el->name : "None", data, 0);
494: xml_elem_writefunc(fptr, END_TOKEN_END, data, END_TOKEN_END_LEN);
495: }
496: if(options->verbosity != xml_elem_no_white_space) {
497: xml_elem_writefunc(fptr, NEWLINE, data, NEWLINE_LEN);
498: }
499: }
500:
501: /* print buf to file */
502: static int file_out_fptr(void *f, const char *text, int size)
503: {
504: fputs(text, (FILE *)f);
505: return 0;
506: }
507:
508: /* print buf to simplestring */
509: static int simplestring_out_fptr(void *f, const char *text, int size)
510: {
511: simplestring* buf = (simplestring*)f;
512: if(buf) {
513: simplestring_addn(buf, text, size);
514: }
515: return 0;
516: }
517:
518: /****f* xml_element/xml_elem_serialize_to_string
519: * NAME
520: * xml_elem_serialize_to_string
521: * SYNOPSIS
522: * void xml_element_serialize_to_string(xml_element *el, XML_ELEM_OUTPUT_OPTIONS options, int *buf_len)
523: * FUNCTION
524: * writes element tree as XML into a newly allocated buffer
525: * INPUTS
526: * el - root element of tree
527: * options - options determining how output is written. see XML_ELEM_OUTPUT_OPTIONS
528: * buf_len - length of returned buffer, if not null.
529: * RESULT
530: * char* or NULL. Must be free'd by caller.
531: * NOTES
532: * SEE ALSO
533: * xml_elem_serialize_to_stream ()
534: * xml_elem_parse_buf ()
535: * SOURCE
536: */
537: char* xml_elem_serialize_to_string(xml_element *el, XML_ELEM_OUTPUT_OPTIONS options, int *buf_len)
538: {
539: simplestring buf;
540: simplestring_init(&buf);
541:
542: xml_element_serialize(el, simplestring_out_fptr, (void *)&buf, options, 0);
543:
544: if(buf_len) {
545: *buf_len = buf.len;
546: }
547:
548: return buf.str;
549: }
550: /******/
551:
552: /****f* xml_element/xml_elem_serialize_to_stream
553: * NAME
554: * xml_elem_serialize_to_stream
555: * SYNOPSIS
556: * void xml_elem_serialize_to_stream(xml_element *el, FILE *output, XML_ELEM_OUTPUT_OPTIONS options)
557: * FUNCTION
558: * writes element tree as XML into a stream (typically an opened file)
559: * INPUTS
560: * el - root element of tree
561: * output - stream handle
562: * options - options determining how output is written. see XML_ELEM_OUTPUT_OPTIONS
563: * RESULT
564: * void
565: * NOTES
566: * SEE ALSO
567: * xml_elem_serialize_to_string ()
568: * xml_elem_parse_buf ()
569: * SOURCE
570: */
571: void xml_elem_serialize_to_stream(xml_element *el, FILE *output, XML_ELEM_OUTPUT_OPTIONS options)
572: {
573: xml_element_serialize(el, file_out_fptr, (void *)output, options, 0);
574: }
575: /******/
576:
577: /*--------------------------*
578: * End xml_element Functions *
579: *--------------------------*/
580:
581:
582: /*----------------------
583: * Begin Expat Handlers *
584: *---------------------*/
585:
586: typedef struct _xml_elem_data {
587: xml_element* root;
588: xml_element* current;
589: XML_ELEM_INPUT_OPTIONS input_options;
590: int needs_enc_conversion;
591: } xml_elem_data;
592:
593:
594: /* expat start of element handler */
595: static void _xmlrpc_startElement(void *userData, const char *name, const char **attrs)
596: {
597: xml_element *c;
598: xml_elem_data* mydata = (xml_elem_data*)userData;
599: const char** p = attrs;
600:
601: if(mydata) {
602: c = mydata->current;
603:
604: mydata->current = xml_elem_new();
605: mydata->current->name = (char*)strdup(name);
606: mydata->current->parent = c;
607:
608: /* init attrs */
609: while(p && *p) {
610: xml_element_attr* attr = malloc(sizeof(xml_element_attr));
611: if(attr) {
612: attr->key = strdup(*p);
613: attr->val = strdup(*(p+1));
614: Q_PushTail(&mydata->current->attrs, attr);
615:
616: p += 2;
617: }
618: }
619: }
620: }
621:
622: /* expat end of element handler */
623: static void _xmlrpc_endElement(void *userData, const char *name)
624: {
625: xml_elem_data* mydata = (xml_elem_data*)userData;
626:
627: if(mydata && mydata->current && mydata->current->parent) {
628: Q_PushTail(&mydata->current->parent->children, mydata->current);
629:
630: mydata->current = mydata->current->parent;
631: }
632: }
633:
634: /* expat char data handler */
635: static void _xmlrpc_charHandler(void *userData,
636: const char *s,
637: int len)
638: {
639: xml_elem_data* mydata = (xml_elem_data*)userData;
640: if(mydata && mydata->current) {
641:
642: /* Check if we need to decode utf-8 parser output to another encoding */
643: if(mydata->needs_enc_conversion && mydata->input_options->encoding) {
644: int new_len = 0;
645: char* add_text = utf8_decode(s, len, &new_len, mydata->input_options->encoding);
646: if(add_text) {
647: len = new_len;
648: simplestring_addn(&mydata->current->text, add_text, len);
649: free(add_text);
650: return;
651: }
652: }
653: simplestring_addn(&mydata->current->text, s, len);
654: }
655: }
656: /******/
657:
658: /*-------------------*
659: * End Expat Handlers *
660: *-------------------*/
661:
662: /*-------------------*
663: * xml_elem_parse_buf *
664: *-------------------*/
665:
666: /****f* xml_element/xml_elem_parse_buf
667: * NAME
668: * xml_elem_parse_buf
669: * SYNOPSIS
670: * xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error)
671: * FUNCTION
672: * parse a buffer containing XML into an xml_element in-memory tree
673: * INPUTS
674: * in_buf - buffer containing XML document
675: * len - length of buffer
676: * options - input options. optional
677: * error - error result data. optional. check if result is null.
678: * RESULT
679: * void
680: * NOTES
681: * The returned data must be free'd by caller
682: * SEE ALSO
683: * xml_elem_serialize_to_string ()
684: * xml_elem_free ()
685: * SOURCE
686: */
687: xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error)
688: {
689: xml_element* xReturn = NULL;
690: char buf[100] = "";
691: static STRUCT_XML_ELEM_INPUT_OPTIONS default_opts = {encoding_utf_8};
692:
693: if(!options) {
694: options = &default_opts;
695: }
696:
697: if(in_buf) {
698: XML_Parser parser;
699: xml_elem_data mydata = {0};
700:
701: parser = XML_ParserCreate(NULL);
702:
703: mydata.root = xml_elem_new();
704: mydata.current = mydata.root;
705: mydata.input_options = options;
706: mydata.needs_enc_conversion = options->encoding && strcmp(options->encoding, encoding_utf_8);
707:
708: XML_SetElementHandler(parser, (XML_StartElementHandler)_xmlrpc_startElement, (XML_EndElementHandler)_xmlrpc_endElement);
709: XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)_xmlrpc_charHandler);
710:
711: /* pass the xml_elem_data struct along */
712: XML_SetUserData(parser, (void*)&mydata);
713:
714: if(!len) {
715: len = strlen(in_buf);
716: }
717:
718: /* parse the XML */
719: if(XML_Parse(parser, in_buf, len, 1) == 0) {
720: enum XML_Error err_code = XML_GetErrorCode(parser);
721: int line_num = XML_GetCurrentLineNumber(parser);
722: int col_num = XML_GetCurrentColumnNumber(parser);
723: long byte_idx = XML_GetCurrentByteIndex(parser);
724: /* int byte_total = XML_GetCurrentByteCount(parser); */
725: const char * error_str = XML_ErrorString(err_code);
726: if(byte_idx >= 0) {
727: snprintf(buf,
728: sizeof(buf),
729: "\n\tdata beginning %ld before byte index: %s\n",
730: byte_idx > 10 ? 10 : byte_idx,
731: in_buf + (byte_idx > 10 ? byte_idx - 10 : byte_idx));
732: }
733: /*
734: fprintf(stderr, "expat reports error code %i\n"
735: "\tdescription: %s\n"
736: "\tline: %i\n"
737: "\tcolumn: %i\n"
738: "\tbyte index: %ld\n"
739: "\ttotal bytes: %i\n%s ",
740: err_code, error_str, line_num,
741: col_num, byte_idx, byte_total, buf);
742: */
743:
744: /* error condition */
745: if(error) {
746: error->parser_code = (long)err_code;
747: error->line = line_num;
748: error->column = col_num;
749: error->byte_index = byte_idx;
750: error->parser_error = error_str;
751: }
752: }
753: else {
754: xReturn = (xml_element*)Q_Head(&mydata.root->children);
755: xReturn->parent = NULL;
756: }
757:
758: XML_ParserFree(parser);
759:
760:
761: xml_elem_free_non_recurse(mydata.root);
762: }
763:
764: return xReturn;
765: }
766:
767: /******/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xml_element.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / xmlrpc / libxmlrpc