xref: /freebsd/contrib/wpa/src/utils/xml_libxml2.c (revision 5ca8e32633c4ffbbcd6762e5888b6a4ba0708c6c) 
1 /*
2  * XML wrapper for libxml2
3  * Copyright (c) 2012-2013, Qualcomm Atheros, Inc.
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "includes.h"
10 #define LIBXML_VALID_ENABLED
11 #include <libxml/tree.h>
12 #include <libxml/xmlschemastypes.h>
13 
14 #include "common.h"
15 #include "base64.h"
16 #include "xml-utils.h"
17 
18 
19 struct xml_node_ctx {
20 	void *ctx;
21 };
22 
23 
24 struct str_buf {
25 	char *buf;
26 	size_t len;
27 };
28 
29 #define MAX_STR 1000
30 
31 static void add_str(void *ctx_ptr, const char *fmt, ...)
32 {
33 	struct str_buf *str = ctx_ptr;
34 	va_list ap;
35 	char *n;
36 	int len;
37 
38 	n = os_realloc(str->buf, str->len + MAX_STR + 2);
39 	if (n == NULL)
40 		return;
41 	str->buf = n;
42 
43 	va_start(ap, fmt);
44 	len = vsnprintf(str->buf + str->len, MAX_STR, fmt, ap);
45 	va_end(ap);
46 	if (len >= MAX_STR)
47 		len = MAX_STR - 1;
48 	str->len += len;
49 	str->buf[str->len] = '\0';
50 }
51 
52 
53 int xml_validate(struct xml_node_ctx *ctx, xml_node_t *node,
54 		 const char *xml_schema_fname, char **ret_err)
55 {
56 	xmlDocPtr doc;
57 	xmlNodePtr n;
58 	xmlSchemaParserCtxtPtr pctx;
59 	xmlSchemaValidCtxtPtr vctx;
60 	xmlSchemaPtr schema;
61 	int ret;
62 	struct str_buf errors;
63 
64 	if (ret_err)
65 		*ret_err = NULL;
66 
67 	doc = xmlNewDoc((xmlChar *) "1.0");
68 	if (doc == NULL)
69 		return -1;
70 	n = xmlDocCopyNode((xmlNodePtr) node, doc, 1);
71 	if (n == NULL) {
72 		xmlFreeDoc(doc);
73 		return -1;
74 	}
75 	xmlDocSetRootElement(doc, n);
76 
77 	os_memset(&errors, 0, sizeof(errors));
78 
79 	pctx = xmlSchemaNewParserCtxt(xml_schema_fname);
80 	xmlSchemaSetParserErrors(pctx, (xmlSchemaValidityErrorFunc) add_str,
81 				 (xmlSchemaValidityWarningFunc) add_str,
82 				 &errors);
83 	schema = xmlSchemaParse(pctx);
84 	xmlSchemaFreeParserCtxt(pctx);
85 
86 	vctx = xmlSchemaNewValidCtxt(schema);
87 	xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc) add_str,
88 				(xmlSchemaValidityWarningFunc) add_str,
89 				&errors);
90 
91 	ret = xmlSchemaValidateDoc(vctx, doc);
92 	xmlSchemaFreeValidCtxt(vctx);
93 	xmlFreeDoc(doc);
94 	xmlSchemaFree(schema);
95 
96 	if (ret == 0) {
97 		os_free(errors.buf);
98 		return 0;
99 	} else if (ret > 0) {
100 		if (ret_err)
101 			*ret_err = errors.buf;
102 		else
103 			os_free(errors.buf);
104 		return -1;
105 	} else {
106 		if (ret_err)
107 			*ret_err = errors.buf;
108 		else
109 			os_free(errors.buf);
110 		return -1;
111 	}
112 }
113 
114 
115 int xml_validate_dtd(struct xml_node_ctx *ctx, xml_node_t *node,
116 		     const char *dtd_fname, char **ret_err)
117 {
118 	xmlDocPtr doc;
119 	xmlNodePtr n;
120 	xmlValidCtxt vctx;
121 	xmlDtdPtr dtd;
122 	int ret;
123 	struct str_buf errors;
124 
125 	if (ret_err)
126 		*ret_err = NULL;
127 
128 	doc = xmlNewDoc((xmlChar *) "1.0");
129 	if (doc == NULL)
130 		return -1;
131 	n = xmlDocCopyNode((xmlNodePtr) node, doc, 1);
132 	if (n == NULL) {
133 		xmlFreeDoc(doc);
134 		return -1;
135 	}
136 	xmlDocSetRootElement(doc, n);
137 
138 	os_memset(&errors, 0, sizeof(errors));
139 
140 	dtd = xmlParseDTD(NULL, (const xmlChar *) dtd_fname);
141 	if (dtd == NULL) {
142 		xmlFreeDoc(doc);
143 		return -1;
144 	}
145 
146 	os_memset(&vctx, 0, sizeof(vctx));
147 	vctx.userData = &errors;
148 	vctx.error = add_str;
149 	vctx.warning = add_str;
150 	ret = xmlValidateDtd(&vctx, doc, dtd);
151 	xmlFreeDoc(doc);
152 	xmlFreeDtd(dtd);
153 
154 	if (ret == 1) {
155 		os_free(errors.buf);
156 		return 0;
157 	} else {
158 		if (ret_err)
159 			*ret_err = errors.buf;
160 		else
161 			os_free(errors.buf);
162 		return -1;
163 	}
164 }
165 
166 
167 void xml_node_free(struct xml_node_ctx *ctx, xml_node_t *node)
168 {
169 	xmlFreeNode((xmlNodePtr) node);
170 }
171 
172 
173 xml_node_t * xml_node_get_parent(struct xml_node_ctx *ctx, xml_node_t *node)
174 {
175 	return (xml_node_t *) ((xmlNodePtr) node)->parent;
176 }
177 
178 
179 xml_node_t * xml_node_from_buf(struct xml_node_ctx *ctx, const char *buf)
180 {
181 	xmlDocPtr doc;
182 	xmlNodePtr node;
183 
184 	doc = xmlParseMemory(buf, strlen(buf));
185 	if (doc == NULL)
186 		return NULL;
187 	node = xmlDocGetRootElement(doc);
188 	node = xmlCopyNode(node, 1);
189 	xmlFreeDoc(doc);
190 
191 	return (xml_node_t *) node;
192 }
193 
194 
195 const char * xml_node_get_localname(struct xml_node_ctx *ctx,
196 				    xml_node_t *node)
197 {
198 	return (const char *) ((xmlNodePtr) node)->name;
199 }
200 
201 
202 char * xml_node_to_str(struct xml_node_ctx *ctx, xml_node_t *node)
203 {
204 	xmlChar *buf;
205 	int bufsiz;
206 	char *ret, *pos;
207 	xmlNodePtr n = (xmlNodePtr) node;
208 	xmlDocPtr doc;
209 
210 	doc = xmlNewDoc((xmlChar *) "1.0");
211 	n = xmlDocCopyNode(n, doc, 1);
212 	xmlDocSetRootElement(doc, n);
213 	xmlDocDumpFormatMemory(doc, &buf, &bufsiz, 0);
214 	xmlFreeDoc(doc);
215 	if (!buf)
216 		return NULL;
217 	pos = (char *) buf;
218 	if (strncmp(pos, "<?xml", 5) == 0) {
219 		pos = strchr(pos, '>');
220 		if (pos)
221 			pos++;
222 		while (pos && (*pos == '\r' || *pos == '\n'))
223 			pos++;
224 	}
225 	if (pos)
226 		ret = os_strdup(pos);
227 	else
228 		ret = NULL;
229 	xmlFree(buf);
230 
231 	if (ret) {
232 		pos = ret;
233 		if (pos[0]) {
234 			while (pos[1])
235 				pos++;
236 		}
237 		while (pos >= ret && *pos == '\n')
238 			*pos-- = '\0';
239 	}
240 
241 	return ret;
242 }
243 
244 
245 void xml_node_detach(struct xml_node_ctx *ctx, xml_node_t *node)
246 {
247 	xmlUnlinkNode((xmlNodePtr) node);
248 }
249 
250 
251 void xml_node_add_child(struct xml_node_ctx *ctx, xml_node_t *parent,
252 			xml_node_t *child)
253 {
254 	xmlAddChild((xmlNodePtr) parent, (xmlNodePtr) child);
255 }
256 
257 
258 xml_node_t * xml_node_create_root(struct xml_node_ctx *ctx, const char *ns_uri,
259 				  const char *ns_prefix,
260 				  xml_namespace_t **ret_ns, const char *name)
261 {
262 	xmlNodePtr node;
263 	xmlNsPtr ns = NULL;
264 
265 	node = xmlNewNode(NULL, (const xmlChar *) name);
266 	if (node == NULL)
267 		return NULL;
268 	if (ns_uri) {
269 		ns = xmlNewNs(node, (const xmlChar *) ns_uri,
270 			      (const xmlChar *) ns_prefix);
271 		xmlSetNs(node, ns);
272 	}
273 
274 	if (ret_ns)
275 		*ret_ns = (xml_namespace_t *) ns;
276 
277 	return (xml_node_t *) node;
278 }
279 
280 
281 xml_node_t * xml_node_create(struct xml_node_ctx *ctx, xml_node_t *parent,
282 			     xml_namespace_t *ns, const char *name)
283 {
284 	xmlNodePtr node;
285 	node = xmlNewChild((xmlNodePtr) parent, (xmlNsPtr) ns,
286 			   (const xmlChar *) name, NULL);
287 	return (xml_node_t *) node;
288 }
289 
290 
291 xml_node_t * xml_node_create_text(struct xml_node_ctx *ctx,
292 				  xml_node_t *parent, xml_namespace_t *ns,
293 				  const char *name, const char *value)
294 {
295 	xmlNodePtr node;
296 	node = xmlNewTextChild((xmlNodePtr) parent, (xmlNsPtr) ns,
297 			       (const xmlChar *) name, (const xmlChar *) value);
298 	return (xml_node_t *) node;
299 }
300 
301 
302 xml_node_t * xml_node_create_text_ns(struct xml_node_ctx *ctx,
303 				     xml_node_t *parent, const char *ns_uri,
304 				     const char *name, const char *value)
305 {
306 	xmlNodePtr node;
307 	xmlNsPtr ns;
308 
309 	node = xmlNewTextChild((xmlNodePtr) parent, NULL,
310 			       (const xmlChar *) name, (const xmlChar *) value);
311 	ns = xmlNewNs(node, (const xmlChar *) ns_uri, NULL);
312 	xmlSetNs(node, ns);
313 	return (xml_node_t *) node;
314 }
315 
316 
317 void xml_node_set_text(struct xml_node_ctx *ctx, xml_node_t *node,
318 		       const char *value)
319 {
320 	/* TODO: escape XML special chars in value */
321 	xmlNodeSetContent((xmlNodePtr) node, (xmlChar *) value);
322 }
323 
324 
325 int xml_node_add_attr(struct xml_node_ctx *ctx, xml_node_t *node,
326 		      xml_namespace_t *ns, const char *name, const char *value)
327 {
328 	xmlAttrPtr attr;
329 
330 	if (ns) {
331 		attr = xmlNewNsProp((xmlNodePtr) node, (xmlNsPtr) ns,
332 				    (const xmlChar *) name,
333 				    (const xmlChar *) value);
334 	} else {
335 		attr = xmlNewProp((xmlNodePtr) node, (const xmlChar *) name,
336 				  (const xmlChar *) value);
337 	}
338 
339 	return attr ? 0 : -1;
340 }
341 
342 
343 char * xml_node_get_attr_value(struct xml_node_ctx *ctx, xml_node_t *node,
344 			       char *name)
345 {
346 	return (char *) xmlGetNoNsProp((xmlNodePtr) node,
347 				       (const xmlChar *) name);
348 }
349 
350 
351 char * xml_node_get_attr_value_ns(struct xml_node_ctx *ctx, xml_node_t *node,
352 				  const char *ns_uri, char *name)
353 {
354 	return (char *) xmlGetNsProp((xmlNodePtr) node, (const xmlChar *) name,
355 				     (const xmlChar *) ns_uri);
356 }
357 
358 
359 void xml_node_get_attr_value_free(struct xml_node_ctx *ctx, char *val)
360 {
361 	if (val)
362 		xmlFree((xmlChar *) val);
363 }
364 
365 
366 xml_node_t * xml_node_first_child(struct xml_node_ctx *ctx,
367 				  xml_node_t *parent)
368 {
369 	return (xml_node_t *) ((xmlNodePtr) parent)->children;
370 }
371 
372 
373 xml_node_t * xml_node_next_sibling(struct xml_node_ctx *ctx,
374 				   xml_node_t *node)
375 {
376 	return (xml_node_t *) ((xmlNodePtr) node)->next;
377 }
378 
379 
380 int xml_node_is_element(struct xml_node_ctx *ctx, xml_node_t *node)
381 {
382 	return ((xmlNodePtr) node)->type == XML_ELEMENT_NODE;
383 }
384 
385 
386 char * xml_node_get_text(struct xml_node_ctx *ctx, xml_node_t *node)
387 {
388 	if (xmlChildElementCount((xmlNodePtr) node) > 0)
389 		return NULL;
390 	return (char *) xmlNodeGetContent((xmlNodePtr) node);
391 }
392 
393 
394 void xml_node_get_text_free(struct xml_node_ctx *ctx, char *val)
395 {
396 	if (val)
397 		xmlFree((xmlChar *) val);
398 }
399 
400 
401 char * xml_node_get_base64_text(struct xml_node_ctx *ctx, xml_node_t *node,
402 				int *ret_len)
403 {
404 	char *txt;
405 	unsigned char *ret;
406 	size_t len;
407 
408 	txt = xml_node_get_text(ctx, node);
409 	if (txt == NULL)
410 		return NULL;
411 
412 	ret = base64_decode(txt, strlen(txt), &len);
413 	if (ret_len)
414 		*ret_len = len;
415 	xml_node_get_text_free(ctx, txt);
416 	if (ret == NULL)
417 		return NULL;
418 	txt = os_malloc(len + 1);
419 	if (txt == NULL) {
420 		os_free(ret);
421 		return NULL;
422 	}
423 	os_memcpy(txt, ret, len);
424 	txt[len] = '\0';
425 	return txt;
426 }
427 
428 
429 xml_node_t * xml_node_copy(struct xml_node_ctx *ctx, xml_node_t *node)
430 {
431 	if (node == NULL)
432 		return NULL;
433 	return (xml_node_t *) xmlCopyNode((xmlNodePtr) node, 1);
434 }
435 
436 
437 struct xml_node_ctx * xml_node_init_ctx(void *upper_ctx,
438 					const void *env)
439 {
440 	struct xml_node_ctx *xctx;
441 
442 	xctx = os_zalloc(sizeof(*xctx));
443 	if (xctx == NULL)
444 		return NULL;
445 	xctx->ctx = upper_ctx;
446 
447 	LIBXML_TEST_VERSION
448 
449 	return xctx;
450 }
451 
452 
453 void xml_node_deinit_ctx(struct xml_node_ctx *ctx)
454 {
455 	xmlSchemaCleanupTypes();
456 	xmlCleanupParser();
457 	xmlMemoryDump();
458 	os_free(ctx);
459 }
460