![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_xml.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / structs|
Return to structs_xml.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / structs |
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <net/ethernet.h>
43: #include <netinet/in.h>
44:
45: #include <stdlib.h>
46: #include <stdio.h>
47: #include <stdarg.h>
48: #include <assert.h>
49: #include <ctype.h>
50: #include <syslog.h>
51: #include <string.h>
52: #include <errno.h>
53: #include <pthread.h>
54:
55: #include <expat.h>
56:
57: #include "structs/structs.h"
58: #include "structs/xml.h"
59: #include "structs/type/array.h"
60: #include "structs/type/struct.h"
61: #include "structs/type/union.h"
62: #include "util/typed_mem.h"
63: #include "sys/alog.h"
64:
65: /* Standard XML header */
66: #define XML_HEADER "<?xml version=\"1.0\" standalone=\"yes\"?>\n"
67:
68: /* Max parse depth */
69: #define MAX_XML_STACK 128
70:
71: #define INPUT_MEM_TYPE "structs_xml_input"
72: #define INFO_MEM_TYPE "structs_xml_input.info"
73: #define CHARDATA_MEM_TYPE "structs_xml_input.chardata"
74: #define OUTPUT_MEM_TYPE "structs_xml_output"
75:
76: /* Parse private context */
77: struct xmlinput_stackframe {
78: const struct structs_type *type; /* type we're parsing */
79: void *data; /* data pointer */
80: char *s; /* character data */
81: u_int s_len; /* strlen(s) */
82: u_int index; /* fixed array index */
83: u_char combined; /* was a combined tag */
84: };
85:
86: struct xml_input_info {
87: XML_Parser p;
88: int error;
89: int depth;
90: int flags;
91: u_int skip;
92: const char *elem_tag;
93: char **attrp;
94: const char *attr_mtype;
95: int attr_len;
96: struct xmlinput_stackframe stack[MAX_XML_STACK];
97: structs_xmllog_t *logger;
98: };
99:
100: /*
101: * Internal functions
102: */
103: static void *structs_xml_malloc(size_t size);
104: static void *structs_xml_realloc(void *ptr, size_t size);
105: static void structs_xml_free(void *ptr);
106:
107: static void structs_xml_output_cleanup(void *arg);
108: static void structs_xml_output_prefix(FILE *fp, int depth);
109: static void structs_xml_encode(FILE *fp, const char *s);
110:
111: static structs_xmllog_t structs_xml_null_logger;
112: static structs_xmllog_t structs_xml_stderr_logger;
113: static structs_xmllog_t structs_xml_alog_logger;
114:
115: /*
116: * Internal variables
117: */
118: static const XML_Memory_Handling_Suite memsuite = {
119: structs_xml_malloc,
120: structs_xml_realloc,
121: structs_xml_free
122: };
123:
124: static const char separator_string[] = { STRUCTS_SEPARATOR, '\0' };
125: static const char double_separator_string[] = {
126: STRUCTS_SEPARATOR, STRUCTS_SEPARATOR, '\0'
127: };
128:
129: /*********************************************************************
130: XML INPUT ROUTINES
131: *********************************************************************/
132:
133: /*
134: * Internal functions
135: */
136: static void structs_xml_input_cleanup(void *arg);
137: static void structs_xml_input_start(void *userData,
138: const XML_Char *name, const XML_Char **atts);
139: static void structs_xml_input_end(void *userData, const XML_Char *name);
140: static void structs_xml_input_chardata(void *userData,
141: const XML_Char *s, int len);
142: static void structs_xml_input_nest(struct xml_input_info *info,
143: const char *name, const struct structs_type **typep,
144: void **datap);
145: static void structs_xml_input_prep(struct xml_input_info *info,
146: const struct structs_type *type, void *data,
147: int combined);
148: static void structs_xml_unnest(struct xml_input_info *info,
149: const XML_Char *name);
150: static void structs_xml_pop(struct xml_input_info *info);
151:
152: /* Context for one XML parse run */
153: struct structs_xml_input_ctx {
154: struct xml_input_info *info;
155: XML_Parser p;
156: int data_init;
157: int rtn;
158: const struct structs_type *type;
159: void *data;
160: char **attrp;
161: const char *attr_mtype;
162: };
163:
164: /*
165: * Input a type from XML.
166: *
167: * Note: it is safe for the calling thread to be canceled.
168: */
169: int
170: structs_xml_input(const struct structs_type *type,
171: const char *elem_tag, char **attrp, const char *attr_mtype,
172: FILE *fp, void *data, int flags, structs_xmllog_t *logger)
173: {
174: struct structs_xml_input_ctx *ctx;
175: int esave;
176: int r;
177:
178: /* Special cases for logger */
179: if (logger == STRUCTS_LOGGER_NONE)
180: logger = structs_xml_null_logger;
181: else if (logger == STRUCTS_LOGGER_STDERR)
182: logger = structs_xml_stderr_logger;
183: else if (logger == STRUCTS_LOGGER_ALOG)
184: logger = structs_xml_alog_logger;
185:
186: /* Create context */
187: if ((ctx = MALLOC(INPUT_MEM_TYPE, sizeof(*ctx))) == NULL)
188: return (-1);
189: memset(ctx, 0, sizeof(*ctx));
190: ctx->attrp = attrp;
191: ctx->attr_mtype = attr_mtype;
192: ctx->type = type;
193: ctx->data = data;
194: ctx->rtn = -1;
195: pthread_cleanup_push(structs_xml_input_cleanup, ctx);
196:
197: /* Initialize attributes */
198: if (ctx->attrp != NULL
199: && (*ctx->attrp = STRDUP(ctx->attr_mtype, "")) == NULL)
200: goto done;
201:
202: /* Initialize data object if desired */
203: if (ctx->type != NULL && (flags & STRUCTS_XML_UNINIT) != 0) {
204: if ((*type->init)(ctx->type, ctx->data) == -1) {
205: esave = errno;
206: (*logger)(LOG_ERR, "error initializing data: %s",
207: strerror(errno));
208: errno = esave;
209: goto done;
210: }
211: ctx->data_init = 1;
212: }
213:
214: /* Allocate info structure */
215: if ((ctx->info = MALLOC(INFO_MEM_TYPE, sizeof(*ctx->info))) == NULL) {
216: esave = errno;
217: (*logger)(LOG_ERR, "%s: %s", "malloc", strerror(errno));
218: errno = esave;
219: goto done;
220: }
221: memset(ctx->info, 0, sizeof(*ctx->info));
222: ctx->info->logger = logger;
223: ctx->info->attrp = attrp;
224: ctx->info->attr_len = 0;
225: ctx->info->attr_mtype = attr_mtype;
226: ctx->info->elem_tag = elem_tag;
227: ctx->info->stack[0].type = type;
228: ctx->info->stack[0].data = data;
229: ctx->info->flags = flags;
230:
231: /* Create a new parser */
232: if ((ctx->p = XML_ParserCreate_MM(NULL, &memsuite, NULL)) == NULL) {
233: esave = errno;
234: (*logger)(LOG_ERR,
235: "error creating XML parser: %s", strerror(errno));
236: errno = esave;
237: goto done;
238: }
239: ctx->info->p = ctx->p;
240: XML_SetUserData(ctx->p, ctx->info);
241: XML_SetElementHandler(ctx->p,
242: structs_xml_input_start, structs_xml_input_end);
243: XML_SetCharacterDataHandler(ctx->p, structs_xml_input_chardata);
244:
245: /* Parse it */
246: while (1) {
247: const int bufsize = 1024;
248: size_t len;
249: void *buf;
250:
251: /* Get buffer */
252: if ((buf = XML_GetBuffer(ctx->p, bufsize)) == NULL) {
253: esave = errno;
254: (*logger)(LOG_ERR,
255: "error from XML_GetBuffer: %s", strerror(errno));
256: errno = esave;
257: break;
258: }
259:
260: /* Read more bytes. Note: we could get canceled here. */
261: len = fread(buf, 1, bufsize, fp);
262:
263: /* Check for error */
264: if (ferror(fp)) {
265: esave = errno;
266: (*logger)(LOG_ERR, "read error: %s", strerror(errno));
267: errno = esave;
268: break;
269: }
270:
271: /* Process them */
272: if (len > 0 && !XML_ParseBuffer(ctx->p, len, feof(fp))) {
273: (*logger)(LOG_ERR, "line %d:%d: %s",
274: XML_GetCurrentLineNumber(ctx->p),
275: XML_GetCurrentColumnNumber(ctx->p),
276: XML_ErrorString(XML_GetErrorCode(ctx->p)));
277: errno = EINVAL;
278: break;
279: }
280:
281: /* Done? */
282: if (feof(fp)) {
283: if (ctx->info->error != 0)
284: errno = ctx->info->error;
285: else
286: ctx->rtn = 0;
287: break;
288: }
289: }
290:
291: done:
292: /* Clean up and exit */
293: r = ctx->rtn;
294: pthread_cleanup_pop(1);
295: return (r);
296: }
297:
298: /*
299: * Cleanup for structs_xml_input()
300: */
301: static void
302: structs_xml_input_cleanup(void *arg)
303: {
304: struct structs_xml_input_ctx *const ctx = arg;
305: const int esave = errno;
306:
307: /* Free private parse info */
308: if (ctx->info != NULL) {
309: while (ctx->info->depth >= 0)
310: structs_xml_pop(ctx->info);
311: FREE(INFO_MEM_TYPE, ctx->info);
312: }
313:
314: /* Free parser */
315: if (ctx->p != NULL)
316: XML_ParserFree(ctx->p);
317:
318: /* If error, free returned attributes and initialized data */
319: if (ctx->rtn != 0) {
320: if (ctx->attrp != NULL && *ctx->attrp != NULL) {
321: FREE(ctx->attr_mtype, *ctx->attrp);
322: *ctx->attrp = NULL;
323: }
324: if (ctx->data_init)
325: (*ctx->type->uninit)(ctx->type, ctx->data);
326: }
327:
328: /* Free context */
329: FREE(INPUT_MEM_TYPE, ctx);
330: errno = esave;
331: }
332:
333: /*
334: * Start tag handler
335: */
336: static void
337: structs_xml_input_start(void *userData,
338: const XML_Char *name, const XML_Char **attrs)
339: {
340: struct xml_input_info *const info = userData;
341: struct xmlinput_stackframe *const frame = &info->stack[info->depth];
342: const struct structs_type *type = frame->type;
343: void *data = frame->data;
344: char *namebuf;
345: char *ctx;
346: int first;
347: char *s;
348: int sev;
349:
350: /* Skip if any errors */
351: if (info->error)
352: return;
353: if (info->skip) {
354: info->skip++;
355: return;
356: }
357:
358: /* Handle the top level tag specially */
359: if (info->depth == 0) {
360: int i;
361:
362: /* The top level tag must match what we expect */
363: if (strcmp(name, info->elem_tag) != 0) {
364: (*info->logger)(LOG_ERR,
365: "line %d:%d: expecting element \"%s\" here",
366: XML_GetCurrentLineNumber(info->p),
367: XML_GetCurrentColumnNumber(info->p),
368: info->elem_tag);
369: info->error = EINVAL;
370: return;
371: }
372:
373: /* Extract attributes */
374: for (i = 0; info->attrp != NULL && attrs[i] != NULL; i += 2) {
375: const char *const name = attrs[i];
376: const char *const value = attrs[i + 1];
377: void *mem;
378:
379: if ((mem = REALLOC(info->attr_mtype,
380: *info->attrp, info->attr_len + strlen(name) + 1
381: + strlen(value) + 1 + 1)) == NULL) {
382: info->error = errno;
383: (*info->logger)(LOG_ERR, "line %d:%d: %s: %s",
384: XML_GetCurrentLineNumber(info->p),
385: XML_GetCurrentColumnNumber(info->p),
386: "malloc", strerror(errno));
387: return;
388: }
389: *info->attrp = mem;
390: strcpy(*info->attrp + info->attr_len, name);
391: strcpy(*info->attrp + info->attr_len
392: + strlen(name) + 1, value);
393: (*info->attrp)[info->attr_len + strlen(name) + 1
394: + strlen(value) + 1] = '\0';
395: info->attr_len += strlen(name) + 1 + strlen(value) + 1;
396: }
397:
398: /* Are we only scanning? */
399: if ((info->flags & STRUCTS_XML_SCAN) != 0) {
400: info->skip++;
401: return;
402: }
403:
404: /* Prep the top level data structure */
405: structs_xml_input_prep(info, type, data, 0);
406: return;
407: }
408:
409: /* We don't allow attributes with non top level elements */
410: if (attrs[0] != NULL) {
411: sev = (info->flags & STRUCTS_XML_LOOSE) == 0 ?
412: LOG_ERR : LOG_WARNING;
413: (*info->logger)(sev, "line %d:%d: element \"%s\""
414: " contains attributes (not allowed)",
415: XML_GetCurrentLineNumber(info->p),
416: XML_GetCurrentColumnNumber(info->p), name);
417: if (sev == LOG_ERR) {
418: info->error = EINVAL;
419: return;
420: }
421: }
422:
423: /*
424: * Check the case of a structure or union field name
425: * containing the separator character. Such fields take
426: * precedence over combined XML tags.
427: */
428: if (strchr(name, STRUCTS_SEPARATOR) != NULL) {
429: switch (type->tclass) {
430: case STRUCTS_TYPE_STRUCTURE:
431: {
432: const struct structs_field *field;
433:
434: for (field = frame->type->args[0].v;
435: field->name != NULL; field++) {
436: if (strcmp(field->name, name) == 0)
437: goto not_combined;
438: }
439: }
440: case STRUCTS_TYPE_UNION:
441: {
442: const struct structs_ufield *field;
443:
444: for (field = frame->type->args[0].v;
445: field->name != NULL; field++) {
446: if (strcmp(field->name, name) == 0)
447: goto not_combined;
448: }
449: }
450: default:
451: break;
452: }
453: }
454:
455: /* Check whether we need to consider this as a combined tag */
456: if ((info->flags & STRUCTS_XML_COMB_TAGS) == 0
457: || strchr(name, STRUCTS_SEPARATOR) == NULL)
458: goto not_combined;
459:
460: /* Check that the combined XML tag is well-formed */
461: if (name[0] == STRUCTS_SEPARATOR
462: || (name[0] != '\0' && name[strlen(name) - 1] == STRUCTS_SEPARATOR)
463: || strstr(name, double_separator_string) != NULL) {
464: (*info->logger)(LOG_ERR, "line %d:%d: invalid combined"
465: " element tag \"%s\"", XML_GetCurrentLineNumber(info->p),
466: XML_GetCurrentColumnNumber(info->p), name);
467: info->error = EINVAL;
468: return;
469: }
470:
471: /* Copy XML tag so we can parse it */
472: if ((namebuf = STRDUP(TYPED_MEM_TEMP, name)) == NULL) {
473: info->error = errno;
474: return;
475: }
476:
477: /* Parse combined XML tag into individual tag names */
478: for (first = 1, s = strtok_r(namebuf, separator_string, &ctx);
479: s != NULL; first = 0, s = strtok_r(NULL, separator_string, &ctx)) {
480: struct xmlinput_stackframe *const frame
481: = &info->stack[info->depth];
482:
483: type = frame->type;
484: data = frame->data;
485: structs_xml_input_nest(info, s, &type, &data);
486: if (info->error != 0) {
487: FREE(TYPED_MEM_TEMP, namebuf);
488: return;
489: }
490: structs_xml_input_prep(info, type, data, !first);
491: if (info->error != 0) {
492: FREE(TYPED_MEM_TEMP, namebuf);
493: return;
494: }
495: }
496: FREE(TYPED_MEM_TEMP, namebuf);
497: return;
498:
499: not_combined:
500: /* Handle a non-combined tag */
501: structs_xml_input_nest(info, name, &type, &data);
502: if (info->error != 0)
503: return;
504: structs_xml_input_prep(info, type, data, 0);
505: if (info->error != 0)
506: return;
507: }
508:
509: /*
510: * Nest one level deeper into the data structure we're inputting
511: * using the sub-field "name".
512: */
513: static void
514: structs_xml_input_nest(struct xml_input_info *info, const char *name,
515: const struct structs_type **typep, void **datap)
516: {
517: struct xmlinput_stackframe *const frame = &info->stack[info->depth];
518: const struct structs_type *type;
519: void *data;
520: int sev;
521:
522: /* Check type type */
523: switch (frame->type->tclass) {
524: case STRUCTS_TYPE_STRUCTURE:
525: case STRUCTS_TYPE_UNION:
526: {
527: /* Find field; for unions, adjust the field type if necessary */
528: type = frame->type;
529: data = frame->data;
530: if ((type = structs_find(type, name, &data, 1)) == NULL) {
531: if (errno == ENOENT) {
532: sev = (info->flags & STRUCTS_XML_LOOSE) == 0 ?
533: LOG_ERR : LOG_WARNING;
534: (*info->logger)(sev,
535: "line %d:%d: element \"%s\" is not"
536: " expected here",
537: XML_GetCurrentLineNumber(info->p),
538: XML_GetCurrentColumnNumber(info->p), name);
539: if (sev == LOG_ERR) {
540: info->error = EINVAL;
541: return;
542: }
543: info->skip++;
544: return;
545: }
546: (*info->logger)(LOG_ERR, "line %d:%d: error"
547: " initializing union field \"%s\": %s",
548: XML_GetCurrentLineNumber(info->p),
549: XML_GetCurrentColumnNumber(info->p),
550: name, strerror(errno));
551: info->error = errno;
552: return;
553: }
554: break;
555: }
556:
557: case STRUCTS_TYPE_ARRAY:
558: {
559: const struct structs_type *const etype = frame->type->args[0].v;
560: const char *mtype = frame->type->args[1].s;
561: const char *elem_name = frame->type->args[2].s;
562: struct structs_array *const ary = frame->data;
563: void *mem;
564:
565: /* Check tag name */
566: if (strcmp(name, elem_name) != 0) {
567: (*info->logger)(LOG_ERR, "line %d:%d: expected element"
568: " \"%s\" instead of \"%s\"",
569: XML_GetCurrentLineNumber(info->p),
570: XML_GetCurrentColumnNumber(info->p),
571: elem_name, name);
572: info->error = EINVAL;
573: return;
574: }
575:
576: /* Expand the array by one */
577: if ((mem = REALLOC(mtype,
578: ary->elems, (ary->length + 1) * etype->size)) == NULL) {
579: info->error = errno;
580: (*info->logger)(LOG_ERR, "line %d:%d: %s: %s",
581: XML_GetCurrentLineNumber(info->p),
582: XML_GetCurrentColumnNumber(info->p),
583: "realloc", strerror(errno));
584: return;
585: }
586: ary->elems = mem;
587:
588: /* Initialize the new element */
589: memset((char *)ary->elems + (ary->length * etype->size),
590: 0, etype->size);
591: if ((*etype->init)(etype,
592: (char *)ary->elems + (ary->length * etype->size)) == -1) {
593: info->error = errno;
594: (*info->logger)(LOG_ERR, "line %d:%d: %s: %s",
595: XML_GetCurrentLineNumber(info->p),
596: XML_GetCurrentColumnNumber(info->p),
597: "error initializing new array element",
598: strerror(errno));
599: return;
600: }
601:
602: /* Parse the element next */
603: type = etype;
604: data = (char *)ary->elems + (ary->length * etype->size);
605: ary->length++;
606: break;
607: }
608:
609: case STRUCTS_TYPE_FIXEDARRAY:
610: {
611: const struct structs_type *const etype = frame->type->args[0].v;
612: const char *elem_name = frame->type->args[1].s;
613: const u_int length = frame->type->args[2].i;
614:
615: /* Check tag name */
616: if (strcmp(name, elem_name) != 0) {
617: (*info->logger)(LOG_ERR, "line %d:%d: expected element"
618: " \"%s\" instead of \"%s\"",
619: XML_GetCurrentLineNumber(info->p),
620: XML_GetCurrentColumnNumber(info->p),
621: elem_name, name);
622: info->error = EINVAL;
623: return;
624: }
625:
626: /* Check index vs. array length */
627: if (frame->index >= length) {
628: sev = (info->flags & STRUCTS_XML_LOOSE) == 0 ?
629: LOG_ERR : LOG_WARNING;
630: (*info->logger)(sev, "line %d:%d: too many"
631: " elements in fixed array (length %u)",
632: XML_GetCurrentLineNumber(info->p),
633: XML_GetCurrentColumnNumber(info->p), length);
634: if (sev == LOG_ERR) {
635: info->error = EINVAL;
636: return;
637: }
638: info->skip++;
639: return;
640: }
641:
642: /* Parse the element next */
643: type = etype;
644: data = (char *)frame->data + (frame->index * etype->size);
645: frame->index++;
646: break;
647: }
648:
649: case STRUCTS_TYPE_PRIMITIVE:
650: sev = (info->flags & STRUCTS_XML_LOOSE) == 0 ?
651: LOG_ERR : LOG_WARNING;
652: (*info->logger)(sev,
653: "line %d:%d: element \"%s\" is not expected here",
654: XML_GetCurrentLineNumber(info->p),
655: XML_GetCurrentColumnNumber(info->p), name);
656: if (sev == LOG_ERR) {
657: info->error = EINVAL;
658: return;
659: }
660: info->skip++;
661: return;
662:
663: default:
664: assert(0);
665: return;
666: }
667:
668: /* Done */
669: *typep = type;
670: *datap = data;
671: }
672:
673: /*
674: * Prepare the next level of nesting for parsing.
675: */
676: static void
677: structs_xml_input_prep(struct xml_input_info *info,
678: const struct structs_type *type, void *data, int combined)
679: {
680: /* Dereference through pointer(s) */
681: while (type->tclass == STRUCTS_TYPE_POINTER) {
682: type = type->args[0].v;
683: data = *((void **)data);
684: }
685:
686: /* If next item is an array, re-initialize it */
687: switch (type->tclass) {
688: case STRUCTS_TYPE_ARRAY:
689: (*type->uninit)(type, data);
690: memset(data, 0, type->size);
691: break;
692: case STRUCTS_TYPE_FIXEDARRAY:
693: {
694: void *mem;
695:
696: /* Get temporary region for newly initialized array */
697: if ((mem = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL) {
698: info->error = errno;
699: (*info->logger)(LOG_ERR, "line %d:%d: %s: %s",
700: XML_GetCurrentLineNumber(info->p),
701: XML_GetCurrentColumnNumber(info->p),
702: "error initializing new array", strerror(errno));
703: return;
704: }
705:
706: /* Initialize new array */
707: if ((*type->init)(type, mem) == -1) {
708: info->error = errno;
709: (*info->logger)(LOG_ERR, "line %d:%d: %s: %s",
710: XML_GetCurrentLineNumber(info->p),
711: XML_GetCurrentColumnNumber(info->p),
712: "error initializing new array", strerror(errno));
713: FREE(TYPED_MEM_TEMP, mem);
714: return;
715: }
716:
717: /* Replace existing array with fresh one */
718: (*type->uninit)(type, data);
719: memcpy(data, mem, type->size);
720: FREE(TYPED_MEM_TEMP, mem);
721:
722: /* Remember that we're on the first element */
723: info->stack[info->depth + 1].index = 0;
724: break;
725: }
726: default:
727: break;
728: }
729:
730: /* Check stack overflow */
731: if (info->depth == MAX_XML_STACK - 1) {
732: (*info->logger)(LOG_ERR,
733: "line %d:%d: maximum parse stack depth (%d) exceeded",
734: XML_GetCurrentLineNumber(info->p),
735: XML_GetCurrentColumnNumber(info->p), MAX_XML_STACK);
736: info->error = EMLINK;
737: return;
738: }
739:
740: /* Continue in a new stack frame */
741: info->depth++;
742: info->stack[info->depth].type = type;
743: info->stack[info->depth].data = data;
744: info->stack[info->depth].combined = combined;
745: }
746:
747: /*
748: * Character data handler
749: */
750: static void
751: structs_xml_input_chardata(void *userData, const XML_Char *s, int len)
752: {
753: struct xml_input_info *const info = userData;
754: struct xmlinput_stackframe *const frame = &info->stack[info->depth];
755: void *mem;
756:
757: /* Skip if any errors */
758: if (info->error || info->skip)
759: return;
760:
761: /* Expand buffer and append character data */
762: if ((mem = REALLOC(CHARDATA_MEM_TYPE,
763: frame->s, frame->s_len + len + 1)) == NULL) {
764: info->error = errno;
765: (*info->logger)(LOG_ERR, "%s: %s",
766: "realloc", strerror(errno));
767: return;
768: }
769: frame->s = mem;
770: memcpy(frame->s + frame->s_len, (char *)s, len);
771: frame->s[frame->s_len + len] = '\0';
772: frame->s_len += len;
773: }
774:
775: /*
776: * End tag handler
777: */
778: static void
779: structs_xml_input_end(void *userData, const XML_Char *name)
780: {
781: struct xml_input_info *const info = userData;
782: struct xmlinput_stackframe *frame;
783: int was_combined;
784:
785: /* Un-nest once for each structs tag */
786: do {
787: frame = &info->stack[info->depth];
788: was_combined = frame->combined;
789: structs_xml_unnest(info, name);
790: } while (was_combined);
791: }
792:
793: /*
794: * Unnest one level
795: */
796: static void
797: structs_xml_unnest(struct xml_input_info *info, const XML_Char *name)
798: {
799: struct xmlinput_stackframe *const frame = &info->stack[info->depth];
800: const struct structs_type *type;
801: const char *s;
802: char ebuf[64];
803: void *data;
804:
805: /* Skip if any errors */
806: if (info->error)
807: return;
808: if (info->skip) {
809: info->skip--;
810: return;
811: }
812:
813: /* Get current type and data */
814: data = frame->data;
815: type = frame->type;
816:
817: /*
818: * Convert from ASCII if possible, otherwise check only whitespace.
819: * For unions, we allow the field name tag to be omitted if you
820: * want to use the default field, which must have primitive type.
821: */
822: switch (type->tclass) {
823: case STRUCTS_TYPE_UNION:
824: {
825: const struct structs_ufield *const field = type->args[0].v;
826:
827: /* Check to see if there's any non-whitespace text */
828: if (frame->s == NULL)
829: goto done;
830: for (s = frame->s; *s != '\0' && isspace(*s); s++);
831: if (*s == '\0')
832: goto done;
833:
834: /* Default field must have primitive type */
835: if (field->type->tclass != STRUCTS_TYPE_PRIMITIVE)
836: break;
837:
838: /* Switch the union to the default field */
839: if (structs_union_set(type, NULL, data, field->name) == -1) {
840: info->error = errno;
841: (*info->logger)(LOG_ERR,
842: "%s: %s", "structs_union_set", strerror(errno));
843: return;
844: }
845:
846: /* Point at the field instead of the union */
847: type = field->type;
848: data = ((const struct structs_union *)data)->un;
849:
850: /* FALLTHROUGH */
851: }
852: case STRUCTS_TYPE_PRIMITIVE:
853: if (structs_set_string(type, NULL,
854: frame->s, data, ebuf, sizeof(ebuf)) == -1) {
855: info->error = errno;
856: (*info->logger)(LOG_ERR,
857: "line %d:%d: error in \"%s\" element data"
858: " \"%s\": %s",
859: XML_GetCurrentLineNumber(info->p),
860: XML_GetCurrentColumnNumber(info->p),
861: name, frame->s == NULL ? "" : frame->s, ebuf);
862: return;
863: }
864: goto done;
865: default:
866: break;
867: }
868:
869: /* There shouldn't be any non-whitespace text here */
870: if (frame->s != NULL) {
871: for (s = frame->s; *s != '\0' && isspace(*s); s++);
872: if (*s != '\0') {
873: (*info->logger)(LOG_ERR, "line %d:%d:"
874: " extra garbage within \"%s\" element",
875: XML_GetCurrentLineNumber(info->p),
876: XML_GetCurrentColumnNumber(info->p),
877: name);
878: info->error = EINVAL;
879: return;
880: }
881: }
882:
883: done:
884: /* Pop stack frame */
885: structs_xml_pop(info);
886: }
887:
888: /*
889: * Pop the XML parse stack
890: */
891: static void
892: structs_xml_pop(struct xml_input_info *info)
893: {
894: struct xmlinput_stackframe *const frame = &info->stack[info->depth];
895:
896: assert(info->depth >= 0);
897: if (frame->s != NULL)
898: FREE(CHARDATA_MEM_TYPE, frame->s);
899: memset(frame, 0, sizeof(*frame));
900: info->depth--;
901: }
902:
903: /*********************************************************************
904: XML OUTPUT ROUTINES
905: *********************************************************************/
906:
907: #define STRUCTS_XML_SHOWONE 0x0100 /* show elem for next level only */
908: #define STRUCTS_XML_SHOWALL 0x0200 /* show elem and all sub elems */
909:
910: /*
911: * Internal functions
912: */
913: static int structs_xml_output_sub(const struct structs_type *type,
914: const void *data, const char *tag, const char *attrs,
915: FILE *fp, const char **elems, const char *posn,
916: int flags, int depth);
917: static void structs_xml_output_openelem(FILE *fp,
918: int depth, const char *tag, const char *attrs);
919:
920: /*
921: * Output a structure in XML
922: *
923: * Note: it is safe for the calling thread to be canceled.
924: */
925: int
926: structs_xml_output(const struct structs_type *type, const char *elem_tag,
927: const char *attrs, const void *data, FILE *fp, const char **elems,
928: int flags)
929: {
930: static const char *all[] = { "", NULL };
931:
932: /* Output standard XML header */
933: fputs(XML_HEADER, fp);
934:
935: /* NULL elems list means "show everything" */
936: if (elems == NULL)
937: elems = all;
938:
939: /* Output structure, and always show the opening and closing tags */
940: return (structs_xml_output_sub(type, data, elem_tag, attrs, fp,
941: elems, "", flags | STRUCTS_XML_SHOWONE, 0));
942: }
943:
944: /*
945: * Output a sub-structure in XML
946: */
947: static int
948: structs_xml_output_sub(const struct structs_type *type, const void *data,
949: const char *tag, const char *attrs, FILE *fp, const char **elems,
950: const char *posn, int flags, int depth)
951: {
952: int r = 0;
953: int i;
954:
955: /* Dereference through pointer(s) */
956: while (type->tclass == STRUCTS_TYPE_POINTER) {
957: type = type->args[0].v;
958: data = *((void **)data);
959: }
960:
961: /* Determine whether to show this element */
962: if ((flags & STRUCTS_XML_SHOWALL) == 0) {
963: const size_t plen = strlen(posn);
964:
965: for (i = 0; elems[i] != NULL; i++) {
966: if (strncmp(elems[i], posn, plen) == 0
967: && (elems[i][plen] == '\0'
968: || elems[i][plen] == STRUCTS_SEPARATOR)) {
969: if (elems[i][plen] == '\0')
970: flags |= STRUCTS_XML_SHOWALL;
971: break;
972: }
973: }
974: if (elems[i] == NULL && depth > 0
975: && (flags & STRUCTS_XML_SHOWONE) == 0)
976: return (0); /* not matched, skip element */
977: }
978:
979: /* If doing abbreviated version, compare with default value */
980: if (depth > 0
981: && (flags & (STRUCTS_XML_FULL|STRUCTS_XML_SHOWONE)) == 0) {
982: void *init_value;
983: int equal;
984:
985: if ((init_value = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL)
986: return (-1);
987: if ((*type->init)(type, init_value) == -1) {
988: FREE(TYPED_MEM_TEMP, init_value);
989: return (-1);
990: }
991: equal = (*type->equal)(type, data, init_value);
992: (*type->uninit)(type, init_value);
993: FREE(TYPED_MEM_TEMP, init_value);
994: if (equal)
995: return (0);
996: }
997:
998: /* The STRUCTS_XML_SHOWONE flag only applies to the next level down */
999: flags &= ~STRUCTS_XML_SHOWONE;
1000:
1001: /* Output element */
1002: switch (type->tclass) {
1003: case STRUCTS_TYPE_UNION:
1004: {
1005: const struct structs_union *const un = data;
1006: const struct structs_ufield *const fields = type->args[0].v;
1007: const struct structs_ufield *field;
1008: char *sposn;
1009:
1010: /* Find field */
1011: for (field = fields; field->name != NULL
1012: && strcmp(un->field_name, field->name) != 0; field++);
1013: if (field->name == NULL)
1014: assert(0);
1015:
1016: /* Generate new position tag */
1017: ASPRINTF(OUTPUT_MEM_TYPE, &sposn, "%s%s%s", posn,
1018: *posn != '\0' ? separator_string : "", field->name);
1019: if (sposn == NULL)
1020: return (-1);
1021: pthread_cleanup_push(structs_xml_output_cleanup, sposn);
1022:
1023: /* Opening tag */
1024: structs_xml_output_openelem(fp, depth, tag, attrs);
1025: fprintf(fp, "\n");
1026:
1027: /*
1028: * If the union field is not the default choice for this union,
1029: * then it must always be shown so the recipient knows that.
1030: */
1031: if (strcmp(un->field_name, fields[0].name) != 0)
1032: flags |= STRUCTS_XML_SHOWONE;
1033:
1034: /* Output chosen union field */
1035: r = structs_xml_output_sub(field->type, un->un, field->name,
1036: NULL, fp, elems, sposn, flags, depth + 1);
1037:
1038: /* Free position tag */
1039: pthread_cleanup_pop(1);
1040:
1041: /* Bail out if there was an error */
1042: if (r == -1)
1043: break;
1044:
1045: /* Closing tag */
1046: structs_xml_output_prefix(fp, depth);
1047: fprintf(fp, "</%s>\n", tag);
1048: break;
1049: }
1050:
1051: case STRUCTS_TYPE_STRUCTURE:
1052: {
1053: const struct structs_field *field;
1054:
1055: /* Opening tag */
1056: structs_xml_output_openelem(fp, depth, tag, attrs);
1057: fprintf(fp, "\n");
1058:
1059: /* Do each structure field */
1060: for (field = type->args[0].v; field->name != NULL; field++) {
1061: char *sposn;
1062:
1063: /* Generate new position tag */
1064: ASPRINTF(OUTPUT_MEM_TYPE, &sposn, "%s%s%s", posn,
1065: *posn != '\0' ? separator_string : "", field->name);
1066: if (sposn == NULL)
1067: return (-1);
1068: pthread_cleanup_push(structs_xml_output_cleanup, sposn);
1069:
1070: /* Do structure field */
1071: r = structs_xml_output_sub(field->type,
1072: (char *)data + field->offset, field->name, NULL,
1073: fp, elems, sposn, flags, depth + 1);
1074:
1075: /* Free position tag */
1076: pthread_cleanup_pop(1);
1077:
1078: /* Bail out if there was an error */
1079: if (r == -1)
1080: break;
1081: }
1082:
1083: /* Closing tag */
1084: structs_xml_output_prefix(fp, depth);
1085: fprintf(fp, "</%s>\n", tag);
1086: break;
1087: }
1088:
1089: case STRUCTS_TYPE_ARRAY:
1090: {
1091: const struct structs_type *const etype = type->args[0].v;
1092: const char *elem_name = type->args[2].s;
1093: const struct structs_array *const ary = data;
1094: int i;
1095:
1096: /* Opening tag */
1097: structs_xml_output_openelem(fp, depth, tag, attrs);
1098: fprintf(fp, "\n");
1099:
1100: /* All array elements must be shown to keep proper ordering */
1101: flags |= STRUCTS_XML_SHOWONE;
1102:
1103: /* Do elements in order */
1104: for (i = 0; i < ary->length; i++) {
1105: char *sposn;
1106:
1107: /* Generate new position tag */
1108: ASPRINTF(OUTPUT_MEM_TYPE, &sposn, "%s%s%u",
1109: posn, *posn != '\0' ? separator_string : "", i);
1110: if (sposn == NULL)
1111: return (-1);
1112: pthread_cleanup_push(structs_xml_output_cleanup, sposn);
1113:
1114: /* Output array element */
1115: r = structs_xml_output_sub(etype, (char *)ary->elems
1116: + (i * etype->size), elem_name, NULL, fp, elems,
1117: sposn, flags, depth + 1);
1118:
1119: /* Free position tag */
1120: pthread_cleanup_pop(1);
1121:
1122: /* Bail out if there was an error */
1123: if (r == -1)
1124: break;
1125: }
1126:
1127: /* Closing tag */
1128: structs_xml_output_prefix(fp, depth);
1129: fprintf(fp, "</%s>\n", tag);
1130: break;
1131: }
1132:
1133: case STRUCTS_TYPE_FIXEDARRAY:
1134: {
1135: const struct structs_type *const etype = type->args[0].v;
1136: const char *elem_name = type->args[1].s;
1137: const u_int length = type->args[2].i;
1138: u_int i;
1139:
1140: /* Opening tag */
1141: structs_xml_output_openelem(fp, depth, tag, attrs);
1142: fprintf(fp, "\n");
1143:
1144: /* All array elements must be shown to keep proper ordering */
1145: flags |= STRUCTS_XML_SHOWONE;
1146:
1147: /* Do elements in order */
1148: for (i = 0; i < length; i++) {
1149: char *sposn;
1150:
1151: /* Generate new position tag */
1152: ASPRINTF(OUTPUT_MEM_TYPE, &sposn, "%s%s%u",
1153: posn, *posn != '\0' ? separator_string : "", i);
1154: if (sposn == NULL)
1155: return (-1);
1156: pthread_cleanup_push(structs_xml_output_cleanup, sposn);
1157:
1158: /* Output array element */
1159: r = structs_xml_output_sub(etype, (char *)data
1160: + (i * etype->size), elem_name, NULL, fp, elems,
1161: sposn, flags, depth + 1);
1162:
1163: /* Free position tag */
1164: pthread_cleanup_pop(1);
1165:
1166: /* Bail out if there was an error */
1167: if (r == -1)
1168: break;
1169: }
1170:
1171: /* Closing tag */
1172: structs_xml_output_prefix(fp, depth);
1173: fprintf(fp, "</%s>\n", tag);
1174: break;
1175: }
1176:
1177: case STRUCTS_TYPE_PRIMITIVE:
1178: {
1179: char *ascii;
1180:
1181: /* Get ascii string */
1182: if ((ascii = (*type->ascify)(type,
1183: OUTPUT_MEM_TYPE, data)) == NULL)
1184: return (-1);
1185:
1186: /* Push cleanup hook to handle cancellation */
1187: pthread_cleanup_push(structs_xml_output_cleanup, ascii);
1188:
1189: /* Output element */
1190: structs_xml_output_openelem(fp, depth, tag, attrs);
1191: structs_xml_encode(fp, ascii);
1192: fprintf(fp, "</%s>\n", tag);
1193:
1194: /* Free ascii string */
1195: pthread_cleanup_pop(1);
1196: break;
1197: }
1198:
1199: default:
1200: assert(0);
1201: }
1202: return (r);
1203: }
1204:
1205: /*
1206: * Cleanup for structs_xml_output_sub()
1207: */
1208: static void
1209: structs_xml_output_cleanup(void *arg)
1210: {
1211: FREE(OUTPUT_MEM_TYPE, arg);
1212: }
1213:
1214: /*
1215: * Output opening element tag with optional attributes
1216: */
1217: static void
1218: structs_xml_output_openelem(FILE *fp,
1219: int depth, const char *tag, const char *attrs)
1220: {
1221: structs_xml_output_prefix(fp, depth);
1222: fprintf(fp, "<%s", tag);
1223: if (attrs != NULL) {
1224: while (*attrs != '\0') {
1225: fprintf(fp, " ");
1226: structs_xml_encode(fp, attrs);
1227: attrs += strlen(attrs) + 1;
1228: fprintf(fp, "=\"");
1229: structs_xml_encode(fp, attrs);
1230: attrs += strlen(attrs) + 1;
1231: fprintf(fp, "\"");
1232: }
1233: }
1234: fprintf(fp, ">");
1235: }
1236:
1237: /*********************************************************************
1238: UTILITY STUFF
1239: *********************************************************************/
1240:
1241: /*
1242: * Output whitespace prefix
1243: */
1244: static void
1245: structs_xml_output_prefix(FILE *fp, int depth)
1246: {
1247: while (depth >= 2) {
1248: putc('\t', fp);
1249: depth -= 2;
1250: }
1251: if (depth > 0) {
1252: fputs(" ", fp);
1253: }
1254: }
1255:
1256: /*
1257: * Output text XML-encoded
1258: */
1259: static void
1260: structs_xml_encode(FILE *fp, const char *s)
1261: {
1262: for ( ; *s != '\0'; s++) {
1263: switch (*s) {
1264: case '<':
1265: fprintf(fp, "<");
1266: break;
1267: case '>':
1268: fprintf(fp, ">");
1269: break;
1270: case '"':
1271: fprintf(fp, """);
1272: break;
1273: case '&':
1274: fprintf(fp, "&");
1275: break;
1276: break;
1277: default:
1278: if (!isprint(*s)) {
1279: fprintf(fp, "&#%d;", (u_char)*s);
1280: break;
1281: }
1282: /* fall through */
1283: case '\n':
1284: case '\t':
1285: putc(*s, fp);
1286: break;
1287: }
1288: }
1289: }
1290:
1291: /*********************************************************************
1292: BUILT-IN LOGGERS
1293: *********************************************************************/
1294:
1295: static void
1296: structs_xml_null_logger(int sev, const char *fmt, ...)
1297: {
1298: }
1299:
1300: static void
1301: structs_xml_stderr_logger(int sev, const char *fmt, ...)
1302: {
1303: static const char *const sevs[] = {
1304: "emerg", "alert", "crit", "err",
1305: "warning", "notice", "info", "debug"
1306: };
1307: static const int num_sevs = sizeof(sevs) / sizeof(*sevs);
1308: va_list args;
1309:
1310: va_start(args, fmt);
1311: if (sev < 0)
1312: sev = 0;
1313: if (sev >= num_sevs)
1314: sev = num_sevs - 1;
1315: fprintf(stderr, "%s: ", sevs[sev]);
1316: vfprintf(stderr, fmt, args);
1317: fprintf(stderr, "\n");
1318: va_end(args);
1319: }
1320:
1321: static void
1322: structs_xml_alog_logger(int sev, const char *fmt, ...)
1323: {
1324: va_list args;
1325:
1326: va_start(args, fmt);
1327: valog(sev, fmt, args);
1328: va_end(args);
1329: }
1330:
1331: /*********************************************************************
1332: MEMORY WRAPPERS
1333: *********************************************************************/
1334:
1335: #define EXPAT_MEM_TYPE "structs_xml_input.expat"
1336:
1337: static void *
1338: structs_xml_malloc(size_t size)
1339: {
1340: return (MALLOC(EXPAT_MEM_TYPE, size));
1341: }
1342:
1343: static void *
1344: structs_xml_realloc(void *ptr, size_t size)
1345: {
1346: return (REALLOC(EXPAT_MEM_TYPE, ptr, size));
1347: }
1348:
1349: static void
1350: structs_xml_free(void *ptr)
1351: {
1352: FREE(EXPAT_MEM_TYPE, ptr);
1353: }
1354: