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 <sys/time.h>
43: #include <netinet/in.h>
44: #include <arpa/inet.h>
45: #ifndef NO_BPF
46: #include <net/bpf.h>
47: #endif
48:
49: #include <stdio.h>
50: #include <stdlib.h>
51: #include <stdarg.h>
52: #include <stddef.h>
53: #include <string.h>
54: #include <unistd.h>
55: #include <errno.h>
56: #ifndef NO_BPF
57: #include <pcap.h>
58: #endif
59: #include <err.h>
60:
61: #include <pdel/structs/structs.h>
62: #include <pdel/structs/xml.h>
63: #include <pdel/structs/types.h>
64: #include <pdel/structs/xmlrpc.h>
65: #include <pdel/structs/type/ip6.h>
66: #include <pdel/sys/alog.h>
67: #include <pdel/util/typed_mem.h>
68:
69: #define ELEM_TAG "structs_test"
70: #define XMLRPC_TAG "value"
71: #define ATTR_MEM_TYPE "attr_mem_type"
72:
73: /* Our structures, etc */
74: struct array_elem {
75: u_int16_t elem_value;
76: char *elem_string;
77: u_char elem_ether[6];
78: u_int32_t elem_color;
79: struct in_addr elem_ip;
80: float elem_float;
81: double elem_double;
82: u_char elem_bytes[13];
83: char elem_bstring[13];
84: struct structs_dnsname elem_dnsname;
85: };
86:
87: union ip_address {
88: struct in_addr ip4;
89: struct in6_addr ip6;
90: };
91:
92: /* fields for union ip_address */
93: static const struct structs_ufield ip_address_fields[] = {
94: STRUCTS_UNION_FIELD(ip4, &structs_type_ip4),
95: STRUCTS_UNION_FIELD(ip6, &structs_type_ip6),
96: STRUCTS_UNION_FIELD_END
97: };
98:
99: /* structs type for union ip_address */
100: static const struct structs_type ip_address_type
101: = STRUCTS_UNION_TYPE(ip_address, &ip_address_fields);
102:
103: /* c type for union ip_address */
104: DEFINE_STRUCTS_UNION(ip_address_struct, ip_address);
105:
106: struct prefix_ip {
107: struct ip_address_struct ip_addr;
108: u_int masklen;
109: };
110:
111: static struct structs_field prefix_ip_fields[] = {
112: STRUCTS_STRUCT_FIELD(prefix_ip, ip_addr, &ip_address_type),
113: STRUCTS_STRUCT_FIELD(prefix_ip, masklen, &structs_type_uint),
114: STRUCTS_STRUCT_FIELD_END
115: };
116:
117: static const struct structs_type prefix_ip_type
118: = STRUCTS_STRUCT_TYPE(prefix_ip, prefix_ip_fields);
119:
120: union my_union {
121: char *u_string;
122: int64_t u_int64;
123: u_char u_bool;
124: };
125:
126: DEFINE_STRUCTS_UNION(ustruct, my_union);
127:
128: #define INNER_STRARY_LEN 4
129:
130: struct inner_struct {
131: char *inner_string;
132: struct structs_data inner_data;
133: struct structs_data inner_data2;
134: struct structs_array inner_array;
135: struct array_elem inner_struct;
136: struct structs_array inner_struct_ptr_array;
137: u_char *inner_ether;
138: struct alog_config inner_alog;
139: #ifndef NO_BPF
140: struct structs_bpf *inner_bpf;
141: #endif
142: time_t inner_time_gmt;
143: time_t inner_time_local;
144: time_t inner_time_iso8601;
145: time_t inner_time_rel;
146: struct ustruct inner_union;
147: struct ustruct inner_union2;
148: struct ip_address_struct ip6_mapped_from_ip4;
149: struct ip_address_struct ip6;
150: struct ip_address_struct ip4;
151: struct prefix_ip pfx_ip6;
152: struct prefix_ip pfx_ip4;
153: struct structs_regex inner_regex;
154: char *inner_strary[INNER_STRARY_LEN];
155: };
156:
157: /* Type for field 'elem_color' */
158: static const struct structs_id color_list[] = {
159: { "Red", 1 }, { "Green", 2 }, { "Blue", 3 }, { NULL, 0 }
160: };
161: static const struct structs_type color_type
162: = STRUCTS_ID_TYPE(color_list, sizeof(u_int32_t));
163:
164: /* Type for field 'elem_bytes' */
165: static const struct structs_type elem_bytes_type
166: = STRUCTS_FIXEDDATA_TYPE(sizeof(((struct array_elem *)0)->elem_bytes));
167:
168: /* Type for field 'elem_bstring' */
169: static const struct structs_type elem_bstring_type
170: = STRUCTS_FIXEDSTRING_TYPE(
171: sizeof(((struct array_elem *)0)->elem_bstring));
172:
173: /* Type for struct array_elem */
174: static const struct structs_field array_elem_fields[] = {
175: STRUCTS_STRUCT_FIELD(array_elem, elem_value, &structs_type_uint16),
176: STRUCTS_STRUCT_FIELD(array_elem, elem_string, &structs_type_string),
177: STRUCTS_STRUCT_FIELD(array_elem, elem_ether, &structs_type_ether),
178: STRUCTS_STRUCT_FIELD(array_elem, elem_bstring, &elem_bstring_type),
179: STRUCTS_STRUCT_FIELD(array_elem, elem_dnsname, &structs_type_dnsname),
180: STRUCTS_STRUCT_FIELD(array_elem, elem_color, &color_type),
181: STRUCTS_STRUCT_FIELD(array_elem, elem_ip, &structs_type_ip4),
182: STRUCTS_STRUCT_FIELD(array_elem, elem_float, &structs_type_float),
183: STRUCTS_STRUCT_FIELD(array_elem, elem_double, &structs_type_double),
184: STRUCTS_STRUCT_FIELD(array_elem, elem_bytes, &elem_bytes_type),
185: STRUCTS_STRUCT_FIELD_END
186: };
187: static const struct structs_type array_elem_type
188: = STRUCTS_STRUCT_TYPE(array_elem, &array_elem_fields);
189: static const struct structs_type array_elem_ptr_type
190: = STRUCTS_POINTER_TYPE(&array_elem_type, "array_elem_ptr");
191: /* Type for array of pointers to array_elems type */
192: static const struct structs_type array_elem_ptr_array_type
193: = STRUCTS_ARRAY_TYPE(&array_elem_ptr_type,
194: "inner_struct_ptr", "inner_struct_ptr");
195:
196: /* Type for array of array_elems type */
197: static const struct structs_type inner_array_type
198: = STRUCTS_ARRAY_TYPE(&array_elem_type, "array_elem", "array_elem");
199:
200: /* Type for pointer to Ethernet address */
201: static const struct structs_type ether_ptr_type
202: = STRUCTS_POINTER_TYPE(&structs_type_ether_nocolon, "ether_ptr");
203:
204: /* Type for union my_union */
205: static const struct structs_ufield my_union_fields[] = {
206: STRUCTS_UNION_FIELD(u_string, &structs_type_string),
207: STRUCTS_UNION_FIELD(u_int64, &structs_type_int64),
208: STRUCTS_UNION_FIELD(u_bool, &structs_type_boolean_char),
209: STRUCTS_UNION_FIELD_END
210: };
211: static const struct structs_type my_union_type
212: = STRUCTS_UNION_TYPE(my_union, &my_union_fields);
213:
214: /* Type for field "inner_strary" in struct inner_struct */
215: static const struct structs_type structs_type_strary
216: = STRUCTS_FIXEDARRAY_TYPE(&structs_type_string,
217: sizeof(char *), INNER_STRARY_LEN, "strary_elem");
218:
219: #ifndef NO_BPF
220: /* Type for field "inner_bpf" in struct inner_struct */
221: static structs_bpf_compile_t bpf_compiler;
222:
223: static const struct structs_type inner_bpf_type
224: = BPF_STRUCTS_TYPE(DLT_EN10MB, bpf_compiler);
225: #endif
226:
227: /* Type for struct inner_struct */
228: static const struct structs_field inner_struct_fields[] = {
229: STRUCTS_STRUCT_FIELD(inner_struct, inner_string, &structs_type_string),
230: STRUCTS_STRUCT_FIELD(inner_struct, inner_data, &structs_type_data),
231: STRUCTS_STRUCT_FIELD(inner_struct, inner_data2, &structs_type_hexdata),
232: STRUCTS_STRUCT_FIELD(inner_struct, inner_array, &inner_array_type),
233: STRUCTS_STRUCT_FIELD(inner_struct, inner_struct, &array_elem_type),
234: STRUCTS_STRUCT_FIELD(inner_struct, inner_struct_ptr_array,
235: &array_elem_ptr_array_type),
236: STRUCTS_STRUCT_FIELD(inner_struct, inner_ether, ðer_ptr_type),
237: STRUCTS_STRUCT_FIELD(inner_struct, inner_alog, &alog_config_type),
238: #ifndef NO_BPF
239: STRUCTS_STRUCT_FIELD(inner_struct, inner_bpf, &inner_bpf_type),
240: #endif
241: STRUCTS_STRUCT_FIELD(inner_struct, inner_time_gmt,
242: &structs_type_time_gmt),
243: STRUCTS_STRUCT_FIELD(inner_struct, inner_time_local,
244: &structs_type_time_local),
245: STRUCTS_STRUCT_FIELD(inner_struct, inner_time_iso8601,
246: &structs_type_time_iso8601),
247: STRUCTS_STRUCT_FIELD(inner_struct, inner_time_rel,
248: &structs_type_time_rel),
249: STRUCTS_STRUCT_FIELD(inner_struct, inner_union, &my_union_type),
250: STRUCTS_STRUCT_FIELD(inner_struct, inner_union2, &my_union_type),
251: STRUCTS_STRUCT_FIELD(inner_struct, ip6_mapped_from_ip4, &ip_address_type),
252: STRUCTS_STRUCT_FIELD(inner_struct, ip6, &ip_address_type),
253: STRUCTS_STRUCT_FIELD(inner_struct, ip4, &ip_address_type),
254: STRUCTS_STRUCT_FIELD(inner_struct, pfx_ip6, &prefix_ip_type),
255: STRUCTS_STRUCT_FIELD(inner_struct, pfx_ip4, &prefix_ip_type),
256: STRUCTS_STRUCT_FIELD(inner_struct, inner_regex, &structs_type_regex),
257: STRUCTS_STRUCT_FIELD(inner_struct, inner_strary, &structs_type_strary),
258: STRUCTS_STRUCT_FIELD_END
259: };
260: static const struct structs_type inner_struct_type
261: = STRUCTS_STRUCT_TYPE(inner_struct, &inner_struct_fields);
262:
263: static int structs_encode(const char *fname);
264: static int structs_decode(const char *fname);
265:
266: static struct in_addr random_ip = { 0x04030201 };
267:
268: static int flags;
269:
270: int
271: main(int argc, char *argv[])
272: {
273: const struct structs_type *type = &inner_struct_type;
274: struct inner_struct s, scopy;
275: const char *name = "inner_array.1.elem_string";
276: const char *value = "new value";
277: const char *fname = NULL;
278: char ebuf[128] = { '\0' };
279: int xml2xmlrpc = 0;
280: int normalize = 0;
281: int nostats = 0;
282: int coding = 0;
283: void *xmlrpc;
284: char *attrs;
285: char *t;
286: int ch;
287:
288: /* Parse command line arguments */
289: while ((ch = getopt(argc, argv, "cdef:nxlTt")) != -1) {
290: switch (ch) {
291: case 'c':
292: flags |= STRUCTS_XML_COMB_TAGS;
293: break;
294: case 'd':
295: coding = -1;
296: break;
297: case 'e':
298: coding = 1;
299: break;
300: case 'f':
301: fname = optarg;
302: break;
303: case 'l':
304: flags |= STRUCTS_XML_LOOSE;
305: break;
306: case 'n':
307: normalize = 1;
308: break;
309: case 'x':
310: nostats = 1;
311: break;
312: case 't':
313: xml2xmlrpc = 1;
314: break;
315: case 'T':
316: xml2xmlrpc = -1;
317: break;
318: default:
319: usage: errx(1, "usage:\n"
320: "\tstructs_test [-xlc] < test.xml\n"
321: "\tstructs_test -n [-xlc] < test.xml > test.xml\n"
322: "\tstructs_test -t [-xlc] < test.xml > test.xmlrpc\n"
323: "\tstructs_test -T [-x] < test.xmlrpc > test.xml\n"
324: "\tstructs_test -e [-f field] [-xlc] < test.xml > test.bin\n"
325: "\tstructs_test -d [-f field] [-xlc] < test.bin > test.xml");
326: }
327: }
328: argc -= optind;
329: argv += optind;
330: switch (argc) {
331: case 0:
332: break;
333: default:
334: goto usage;
335: }
336:
337: if (typed_mem_enable() == -1)
338: err(1, "typed_mem_enable");
339:
340: if (coding && normalize)
341: goto usage;
342:
343: /* Binary encoding/decoding? */
344: if (coding == 1) {
345: structs_encode(fname);
346: goto done;
347: }
348: if (coding == -1) {
349: structs_decode(fname);
350: goto done;
351: }
352:
353: /* Convert between XML and XML-RPC? */
354: if (xml2xmlrpc == 1) {
355: const struct structs_type *const xtype
356: = &structs_type_xmlrpc_value;
357: struct xmlrpc_value_union xvalue;
358:
359: if (structs_xml_input(type, ELEM_TAG, NULL,
360: NULL, stdin, &s, STRUCTS_XML_UNINIT | flags,
361: STRUCTS_LOGGER_STDERR) == -1)
362: err(1, "structs_xml_input");
363: if (structs_init(xtype, NULL, &xvalue) == -1)
364: err(1, "structs_init");
365: if (structs_struct2xmlrpc(type, &s, NULL,
366: xtype, &xvalue, NULL) == -1)
367: err(1, "structs_struct2xmlrpc");
368: structs_free(type, NULL, &s);
369: if (structs_xml_output(xtype, XMLRPC_TAG, NULL,
370: &xvalue, stdout, NULL, 0) == -1)
371: err(1, "structs_xml_output");
372: structs_free(xtype, NULL, &xvalue);
373: goto done;
374: } else if (xml2xmlrpc == -1) {
375: const struct structs_type *const xtype
376: = &structs_type_xmlrpc_value;
377: struct xmlrpc_value_union xvalue;
378:
379: if (structs_xml_input(xtype, XMLRPC_TAG, NULL,
380: NULL, stdin, &xvalue, STRUCTS_XML_UNINIT,
381: STRUCTS_LOGGER_STDERR) == -1)
382: err(1, "structs_xml_input");
383: if (structs_init(type, NULL, &s) == -1)
384: err(1, "structs_init");
385: if (structs_xmlrpc2struct(xtype, &xvalue, NULL,
386: type, &s, NULL, ebuf, sizeof(ebuf)) == -1)
387: errx(1, "structs_struct2xmlrpc: %s", ebuf);
388: structs_free(xtype, NULL, &xvalue);
389: if (structs_xml_output(type, ELEM_TAG, NULL,
390: &s, stdout, NULL, 0) == -1)
391: err(1, "structs_xml_output");
392: structs_free(type, NULL, &s);
393: goto done;
394: }
395:
396: /* Normalize XML? */
397: if (normalize) {
398: if (structs_xml_input(type, ELEM_TAG, NULL,
399: NULL, stdin, &s, STRUCTS_XML_UNINIT | flags,
400: STRUCTS_LOGGER_STDERR) == -1)
401: err(1, "structs_xml_input");
402: if (structs_xml_output(type, ELEM_TAG, NULL,
403: &s, stdout, NULL, 0) == -1)
404: err(1, "structs_xml_output");
405: structs_free(type, NULL, &s);
406: goto done;
407: }
408:
409: printf(">>>>>>>> TEST: Initializing struct...\n");
410: if (structs_init(type, NULL, &s) == -1) {
411: warn("structs_init");
412: goto done;
413: }
414:
415: printf(">>>>>>>> TEST: Dumping initialized struct...\n");
416: if (structs_xml_output(type,
417: ELEM_TAG, NULL, &s, stdout, NULL, 0) == -1) {
418: warn("structs_xml_output");
419: structs_free(type, NULL, &s);
420: goto done;
421: }
422:
423: printf(">>>>>>>> TEST: Free'ing struct...\n");
424: structs_free(type, NULL, &s);
425:
426: printf(">>>>>>>> TEST: Initializing struct...\n");
427: if (structs_init(type, NULL, &s) == -1) {
428: warn("structs_init");
429: goto done;
430: }
431:
432: printf(">>>>>>>> TEST: Setting %s to \"%s\"...\n",
433: "inner_union.u_int64", "0");
434: if (structs_set_string(type, "inner_union.u_int64",
435: "0", &s, ebuf, sizeof(ebuf)) == -1) {
436: warnx("structs_set_string: %s", ebuf);
437: structs_free(type, NULL, &s);
438: goto done;
439: }
440:
441: printf(">>>>>>>> TEST: Dumping struct, should show the union...\n");
442: if (structs_xml_output(type,
443: ELEM_TAG, NULL, &s, stdout, NULL, 0) == -1) {
444: warn("structs_xml_output");
445: structs_free(type, NULL, &s);
446: goto done;
447: }
448:
449: {
450: const char *elems[] = { "inner_union", NULL };
451:
452: printf(">>>>>>>> TEST: Dumping only \"%s\", but full...\n", elems[0]);
453: if (structs_xml_output(type,
454: ELEM_TAG, NULL, &s, stdout, elems, STRUCTS_XML_FULL) == -1) {
455: warn("structs_xml_output");
456: FREE(ATTR_MEM_TYPE, attrs);
457: structs_free(type, NULL, &s);
458: goto done;
459: }
460: }
461:
462: printf(">>>>>>>> TEST: Copying struct...\n");
463: if (structs_get(type, NULL, &s, &scopy) == -1) {
464: warn("structs_get");
465: structs_free(type, NULL, &s);
466: goto done;
467: }
468:
469: printf(">>>>>>>> TEST: Free'ing both structs...\n");
470: structs_free(type, NULL, &s);
471: structs_free(type, NULL, &scopy);
472:
473: printf(">>>>>>>> TEST: Reading input...\n");
474: if (structs_xml_input(type, ELEM_TAG, &attrs,
475: ATTR_MEM_TYPE, stdin, &s, STRUCTS_XML_UNINIT | flags,
476: STRUCTS_LOGGER_STDERR) == -1) {
477: warn("structs_xml_input");
478: goto done;
479: }
480:
481: printf(">>>>>>>> TEST: Displaying attributes...\n");
482: for (t = attrs; *t != '\0'; ) {
483: printf("%30s =", t);
484: t += strlen(t) + 1;
485: printf(" %s\n", t);
486: t += strlen(t) + 1;
487: }
488:
489: printf(">>>>>>>> TEST: Dumping output...\n");
490: if (structs_xml_output(type,
491: ELEM_TAG, attrs, &s, stdout, NULL, 0) == -1) {
492: warn("structs_xml_output");
493: FREE(ATTR_MEM_TYPE, attrs);
494: structs_free(type, NULL, &s);
495: goto done;
496: }
497:
498: {
499: const char *elems[] = { "inner_struct", NULL };
500:
501: printf(">>>>>>>> TEST: Dumping only \"%s\" ...\n", elems[0]);
502: if (structs_xml_output(type,
503: ELEM_TAG, attrs, &s, stdout, elems, 0) == -1) {
504: warn("structs_xml_output");
505: FREE(ATTR_MEM_TYPE, attrs);
506: structs_free(type, NULL, &s);
507: goto done;
508: }
509: }
510:
511: {
512: const char *elems[] = {
513: "inner_struct_ptr_array.2.elem_bytes", NULL };
514:
515: printf(">>>>>>>> TEST: Dumping only \"%s\", but full...\n", elems[0]);
516: if (structs_xml_output(type,
517: ELEM_TAG, NULL, &s, stdout, elems, STRUCTS_XML_FULL) == -1) {
518: warn("structs_xml_output");
519: FREE(ATTR_MEM_TYPE, attrs);
520: structs_free(type, NULL, &s);
521: goto done;
522: }
523: }
524:
525: printf(">>>>>>>> TEST: Copying struct...\n");
526: if (structs_get(type, NULL, &s, &scopy) == -1) {
527: warn("structs_get");
528: FREE(ATTR_MEM_TYPE, attrs);
529: structs_free(type, NULL, &s);
530: goto done;
531: }
532:
533: printf(">>>>>>>> TEST: Dumping copy...\n");
534: if (structs_xml_output(type,
535: ELEM_TAG, attrs, &scopy, stdout, NULL, 0) == -1) {
536: warn("structs_xml_output");
537: FREE(ATTR_MEM_TYPE, attrs);
538: structs_free(type, NULL, &scopy);
539: structs_free(type, NULL, &s);
540: goto done;
541: }
542: FREE(ATTR_MEM_TYPE, attrs);
543:
544: printf(">>>>>>>> TEST: Comparing original and copy...\n");
545: printf("equal = %s\n",
546: structs_equal(type, NULL, &s, &scopy) ? "TRUE" : "FALSE");
547:
548: printf(">>>>>>>> TEST: Setting copy's %s to \"%s\"...\n", name, value);
549: if (structs_set_string(type, name, value,
550: &scopy, ebuf, sizeof(ebuf)) == -1) {
551: warnx("structs_set_string: %s", ebuf);
552: structs_free(type, NULL, &scopy);
553: structs_free(type, NULL, &s);
554: goto done;
555: }
556:
557: printf(">>>>>>>> TEST: Setting copy's %s to \"%s\"...\n",
558: "inner_union.u_int64", "1234567890");
559: if (structs_set_string(type, "inner_union.u_int64",
560: "1234567890", &scopy, ebuf, sizeof(ebuf)) == -1) {
561: warnx("structs_set_string: %s", ebuf);
562: structs_free(type, NULL, &scopy);
563: structs_free(type, NULL, &s);
564: goto done;
565: }
566:
567: printf(">>>>>>>> TEST: Setting copy's %s to \"%s\"...\n",
568: "inner_struct.elem_ip", inet_ntoa(random_ip));
569: if (structs_set(type, &random_ip,
570: "inner_struct.elem_ip", &scopy) == -1) {
571: warn("structs_set");
572: structs_free(type, NULL, &scopy);
573: structs_free(type, NULL, &s);
574: goto done;
575: }
576:
577: printf(">>>>>>>> TEST: Comparing original and copy...\n");
578: printf("equal = %s\n",
579: structs_equal(type, NULL, &s, &scopy) ? "TRUE" : "FALSE");
580:
581: printf(">>>>>>>> TEST: Dumping copy...\n");
582: if (structs_xml_output(type,
583: ELEM_TAG, NULL, &scopy, stdout, NULL, 0) == -1) {
584: warn("structs_xml_output");
585: structs_free(type, NULL, &scopy);
586: structs_free(type, NULL, &s);
587: goto done;
588: }
589:
590: printf(">>>>>>>> TEST: Dumping copy in an XML-RPC request...\n");
591: {
592: const struct structs_type *types[1] = { type };
593: const void *datas[1] = { &scopy };
594:
595: if ((xmlrpc = structs_xmlrpc_build_request(TYPED_MEM_TEMP,
596: "someMethodName", 1, types, datas)) == NULL) {
597: warn("structs_xmlrpc_build_request");
598: structs_free(type, NULL, &scopy);
599: structs_free(type, NULL, &s);
600: goto done;
601: }
602: if (structs_xml_output(&structs_type_xmlrpc_request,
603: "methodCall", NULL, xmlrpc, stdout, NULL, 0) == -1) {
604: warn("structs_xml_output");
605: structs_free(&structs_type_xmlrpc_request, NULL, xmlrpc);
606: FREE(TYPED_MEM_TEMP, xmlrpc);
607: structs_free(type, NULL, &scopy);
608: structs_free(type, NULL, &s);
609: goto done;
610: }
611: structs_free(&structs_type_xmlrpc_request, NULL, xmlrpc);
612: FREE(TYPED_MEM_TEMP, xmlrpc);
613: }
614:
615: printf(">>>>>>>> TEST: dumping copy's element list...\n");
616: {
617: char **list;
618: int len;
619: int i;
620:
621: if ((len = structs_traverse(type, &scopy, &list, TYPED_MEM_TEMP)) == -1)
622: err(1, "structs_traverse");
623: for (i = 0; i < len; i++) {
624: char *val;
625:
626: if ((val = structs_get_string(type,
627: list[i], &scopy, TYPED_MEM_TEMP)) == NULL)
628: err(1, "structs_get_string");
629: printf("\t%s=%s\n", list[i], val);
630: FREE(TYPED_MEM_TEMP, val);
631: }
632: while (len > 0)
633: FREE(TYPED_MEM_TEMP, list[--len]);
634: FREE(TYPED_MEM_TEMP, list);
635: }
636:
637: printf(">>>>>>>> TEST: Free'ing original and copy...\n");
638: structs_free(type, NULL, &s);
639: structs_free(type, NULL, &scopy);
640:
641: done:
642: if (!nostats) {
643: FILE *const fp = coding ? stderr : stdout;
644:
645: fprintf(fp, ">>>>>>>> TEST: Displaying unfree'd memory...\n");
646: typed_mem_dump(fp);
647: }
648:
649: /* Done */
650: return (0);
651: }
652:
653: static int
654: structs_encode(const char *fname)
655: {
656: const struct structs_type *type = &inner_struct_type;
657: struct structs_data code;
658: struct inner_struct s;
659:
660: if (structs_xml_input(type, ELEM_TAG, NULL, NULL, stdin,
661: &s, STRUCTS_XML_UNINIT | flags, STRUCTS_LOGGER_STDERR) == -1) {
662: warn("structs_xml_input");
663: return (-1);
664: }
665: if (structs_get_binary(type, fname, &s, TYPED_MEM_TEMP, &code) == -1) {
666: warn("structs_get_binary");
667: structs_free(type, NULL, &s);
668: return (-1);
669: }
670: if (fwrite(code.data, 1, code.length, stdout) != code.length) {
671: warn("fwrite");
672: FREE(TYPED_MEM_TEMP, code.data);
673: structs_free(type, NULL, &s);
674: return (-1);
675: }
676: FREE(TYPED_MEM_TEMP, code.data);
677: structs_free(type, NULL, &s);
678: return (0);
679: }
680:
681: static int
682: structs_decode(const char *fname)
683: {
684: const struct structs_type *type = &inner_struct_type;
685: struct structs_data code;
686: struct inner_struct s;
687: u_char buf[0x10000];
688: char ebuf[128];
689: int blen;
690: int clen;
691:
692: if (structs_init(type, NULL, &s) == -1) {
693: warn("initializing inner_struct");
694: return (-1);
695: }
696: if ((blen = fread(buf, 1, sizeof(buf), stdin)) == 0) {
697: warn("reading input");
698: structs_free(type, NULL, &s);
699: return (-1);
700: }
701: code.data = buf;
702: code.length = blen;
703: if ((clen = structs_set_binary(type,
704: fname, &code, &s, ebuf, sizeof(ebuf))) == -1) {
705: warnx("structs_set_binary: %s", ebuf);
706: structs_free(type, NULL, &s);
707: return (-1);
708: }
709: if (clen < blen) {
710: fprintf(stderr, "WARNING: ignoring %d extra bytes\n",
711: blen - clen);
712: }
713: if (structs_xml_output(type,
714: ELEM_TAG, NULL, &s, stdout, NULL, 0) == -1) {
715: warn("structs_xml_output");
716: structs_free(type, NULL, &s);
717: return (-1);
718: }
719: structs_free(type, NULL, &s);
720: return (0);
721: }
722:
723: #ifndef NO_BPF
724: static int
725: bpf_compiler(const char *string, struct bpf_program *bpf,
726: int linktype, char *ebuf, size_t emax)
727: {
728: pcap_t *pcap;
729:
730: memset(bpf, 0, sizeof(*bpf));
731: if ((pcap = pcap_open_dead(linktype, 2048)) == NULL)
732: return (-1);
733: if (pcap_compile(pcap, bpf, (char *)string, 1, ~0) != 0) {
734: strlcpy(ebuf, pcap_geterr(pcap), emax);
735: pcap_close(pcap);
736: errno = EINVAL;
737: return (-1);
738: }
739: pcap_close(pcap);
740: return (0);
741: }
742: #endif
743:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.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 / test