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 
add_str(void * ctx_ptr,const char * fmt,...)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 
xml_validate(struct xml_node_ctx * ctx,xml_node_t * node,const char * xml_schema_fname,char ** ret_err)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 
xml_validate_dtd(struct xml_node_ctx * ctx,xml_node_t * node,const char * dtd_fname,char ** ret_err)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 
xml_node_free(struct xml_node_ctx * ctx,xml_node_t * node)167 void xml_node_free(struct xml_node_ctx *ctx, xml_node_t *node)
168 {
169           xmlFreeNode((xmlNodePtr) node);
170 }
171 
172 
xml_node_get_parent(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_from_buf(struct xml_node_ctx * ctx,const char * buf)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 
xml_node_get_localname(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_to_str(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_detach(struct xml_node_ctx * ctx,xml_node_t * node)245 void xml_node_detach(struct xml_node_ctx *ctx, xml_node_t *node)
246 {
247           xmlUnlinkNode((xmlNodePtr) node);
248 }
249 
250 
xml_node_add_child(struct xml_node_ctx * ctx,xml_node_t * parent,xml_node_t * child)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 
xml_node_create_root(struct xml_node_ctx * ctx,const char * ns_uri,const char * ns_prefix,xml_namespace_t ** ret_ns,const char * name)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 
xml_node_create(struct xml_node_ctx * ctx,xml_node_t * parent,xml_namespace_t * ns,const char * name)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 
xml_node_create_text(struct xml_node_ctx * ctx,xml_node_t * parent,xml_namespace_t * ns,const char * name,const char * value)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 
xml_node_create_text_ns(struct xml_node_ctx * ctx,xml_node_t * parent,const char * ns_uri,const char * name,const char * value)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 
xml_node_set_text(struct xml_node_ctx * ctx,xml_node_t * node,const char * value)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 
xml_node_add_attr(struct xml_node_ctx * ctx,xml_node_t * node,xml_namespace_t * ns,const char * name,const char * value)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 
xml_node_get_attr_value(struct xml_node_ctx * ctx,xml_node_t * node,char * name)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 
xml_node_get_attr_value_ns(struct xml_node_ctx * ctx,xml_node_t * node,const char * ns_uri,char * name)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 
xml_node_get_attr_value_free(struct xml_node_ctx * ctx,char * val)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 
xml_node_first_child(struct xml_node_ctx * ctx,xml_node_t * parent)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 
xml_node_next_sibling(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_is_element(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_get_text(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_get_text_free(struct xml_node_ctx * ctx,char * val)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 
xml_node_get_base64_text(struct xml_node_ctx * ctx,xml_node_t * node,int * ret_len)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 
xml_node_copy(struct xml_node_ctx * ctx,xml_node_t * node)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 
xml_node_init_ctx(void * upper_ctx,const void * env)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 
xml_node_deinit_ctx(struct xml_node_ctx * ctx)453 void xml_node_deinit_ctx(struct xml_node_ctx *ctx)
454 {
455           xmlSchemaCleanupTypes();
456           xmlCleanupParser();
457           xmlMemoryDump();
458           os_free(ctx);
459 }
460