src/utils/xml_libxml2.c

   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((unsigned char *) 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 }