xml-reader.c

   1 /*
   2  * QEMU Marshalling Framework
   3  * XML unmarshaller
   4  *
   5  * Copyright IBM, Corp. 2010
   6  *
   7  * Authors:
   8  *  Anthony Liguori <aliguori@us.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2.  See
  11  * the COPYING file in the top-level directory.
  12  */
  13
  14 #include <string.h>
  15 #include <inttypes.h>
  16 #include <malloc.h>
  17
  18 #include <libxml/parser.h>
  19 #include <libxml/tree.h>
  20
  21 #include "xml-reader.h"
  22
  23 #define container_of(obj, type, member) \
  24     ((type *)(((char *)obj) - offsetof(type, member)))
  25
  26 #define MAX_FEATURES 100
  27
  28 typedef struct XMLReader
  29 {
  30     Marshaller m;
  31     xmlDoc *doc;
  32
  33     /* we use these three values to transverse the XML tree.  last_node points
  34      * to the last node we visited.  We really use this as a backlink to the
  35      * parent in the event node == NULL.
  36      *
  37      * There's a special case though where the children of a node is NULL.  We
  38      * don't have a node that we can point to who's parent is us so we use
  39      * no_kids as a hack.  We can probably simplify by just storing the parent.
  40      */
  41     xmlNode *last_node;
  42     xmlNode *node;
  43     int no_kids;
  44
  45     int feature;
  46     bool features[MAX_FEATURES];
  47 } XMLReader;
  48
  49 #define CSTR(a) ((const char*)(a))
  50
  51 static XMLReader *to_xm(Marshaller *m)
  52 {
  53     return container_of(m, XMLReader, m);
  54 }
  55
  56 static bool strequals(const char *lhs, const char *rhs)
  57 {
  58     return !!(strcmp(lhs, rhs) == 0);
  59 }
  60
  61 static xmlNode *next_node(xmlNode *n)
  62 {
  63     do {
  64         n = n->next;
  65     } while (n && n->type != XML_ELEMENT_NODE);
  66     return n;
  67 }
  68
  69 static xmlNode *first_node(xmlNode *n)
  70 {
  71     while (n && n->type != XML_ELEMENT_NODE) {
  72         n = n->next;
  73     }
  74     return n;
  75 }
  76
  77 static bool check_disabled(Marshaller *m)
  78 {
  79     XMLReader *xm = to_xm(m);
  80     return !xm->features[xm->feature - 1];
  81 }
  82
  83 static void xml_m_uint(Marshaller *m, uint64_t *v, const char *t, const char *n, Error **errp)
  84 {
  85     XMLReader *xm = to_xm(m);
  86     xmlChar *content;
  87     int ret;
  88
  89     if (xm->node == NULL) {
  90         error_set(errp, "xml-reader", 0,
  91                   "Unexpected end of section looking for `%s' node `%s' on line %d",
  92                   t, n, xm->last_node->line);
  93         return;
  94     }
  95     if (!strequals(CSTR(xm->node->name), t)) {
  96         error_set(errp, "xml-reader", 0,
  97                   "Expecting node type `%s', got `%s' while parsing `%s' on line %d",
  98                   t, CSTR(xm->node->name), n, xm->node->line);
  99         return;
 100     }
 101     content = xmlNodeGetContent(xm->node);
 102     if (content) {
 103         ret = sscanf(CSTR(content), "%" PRIu64, v);
 104         xmlFree(content);
 105     }
 106     if (!content || ret != 1) {
 107         error_set(errp, "xml-reader", 0,
 108                   "Failed to parse type `%s' node `%s' on line %d",
 109                   t, n, xm->node->line);
 110         return;
 111     }
 112
 113     xm->last_node = xm->node;
 114     xm->node = next_node(xm->node);
 115 }
 116
 117 static void xml_m_int(Marshaller *m, int64_t *v, const char *t, const char *n, Error **errp)
 118 {
 119     XMLReader *xm = to_xm(m);
 120     xmlChar *content;
 121     int ret;
 122
 123     if (xm->node == NULL) {
 124         error_set(errp, "xml-reader", 0,
 125                   "Unexpected end of section looking for `%s' node `%s' on line %d",
 126                   t, n, xm->last_node->line);
 127         return;
 128     }
 129     if (!strequals(CSTR(xm->node->name), t)) {
 130         error_set(errp, "xml-reader", 0,
 131                   "Expecting node type `%s', got `%s' while parsing `%s' on line %d",
 132                   t, CSTR(xm->node->name), n, xm->node->line);
 133         return;
 134     }
 135     content = xmlNodeGetContent(xm->node);
 136     if (content) {
 137         ret = sscanf(CSTR(content), "%" PRId64, v);
 138         xmlFree(content);
 139     }
 140     if (!content || ret != 1) {
 141         error_set(errp, "xml-reader", 0,
 142                   "Failed to parse type `%s' node `%s' on line %d",
 143                   t, n, xm->node->line);
 144         return;
 145     }
 146
 147     xm->last_node = xm->node;
 148     xm->node = next_node(xm->node);
 149 }
 150
 151 static void xml_m_uint8(Marshaller *m, uint8_t *v, const char *n, Error **errp)
 152 {
 153     uint64_t value;
 154
 155     if (check_disabled(m)) {
 156         return;
 157     }
 158
 159     xml_m_uint(m, &value, "uint8", n, errp);
 160     if (!error_is_set(errp)) {
 161         *v = value;
 162     }
 163 }
 164
 165 static void xml_m_uint16(Marshaller *m, uint16_t *v, const char *n, Error **errp)
 166 {
 167     uint64_t value;
 168
 169     if (check_disabled(m)) {
 170         return;
 171     }
 172
 173     xml_m_uint(m, &value, "uint16", n, errp);
 174     if (!error_is_set(errp)) {
 175         *v = value;
 176     }
 177 }
 178
 179 static void xml_m_uint32(Marshaller *m, uint32_t *v, const char *n, Error **errp)
 180 {
 181     uint64_t value;
 182
 183     if (check_disabled(m)) {
 184         return;
 185     }
 186
 187     xml_m_uint(m, &value, "uint32", n, errp);
 188     if (!error_is_set(errp)) {
 189         *v = value;
 190     }
 191 }
 192
 193 static void xml_m_uint64(Marshaller *m, uint64_t *v, const char *n, Error **errp)
 194 {
 195     if (check_disabled(m)) {
 196         return;
 197     }
 198
 199     xml_m_uint(m, v, "uint64", n, errp);
 200 }
 201
 202 static void xml_m_int8(Marshaller *m, int8_t *v, const char *n, Error **errp)
 203 {
 204     int64_t value;
 205
 206     if (check_disabled(m)) {
 207         return;
 208     }
 209
 210     xml_m_int(m, &value, "int8", n, errp);
 211     if (!error_is_set(errp)) {
 212         *v = value;
 213     }
 214 }
 215
 216 static void xml_m_int16(Marshaller *m, int16_t *v, const char *n, Error **errp)
 217 {
 218     int64_t value;
 219
 220     if (check_disabled(m)) {
 221         return;
 222     }
 223
 224     xml_m_int(m, &value, "int16", n, errp);
 225     if (!error_is_set(errp)) {
 226         *v = value;
 227     }
 228 }
 229
 230 static void xml_m_int32(Marshaller *m, int32_t *v, const char *n, Error **errp)
 231 {
 232     int64_t value;
 233
 234     if (check_disabled(m)) {
 235         return;
 236     }
 237
 238     xml_m_int(m, &value, "int32", n, errp);
 239     if (!error_is_set(errp)) {
 240         *v = value;
 241     }
 242 }
 243
 244 static void xml_m_int64(Marshaller *m, int64_t *v, const char *n, Error **errp)
 245 {
 246     if (check_disabled(m)) {
 247         return;
 248     }
 249
 250     xml_m_int(m, v, "int64", n, errp);
 251 }
 252
 253 static void xml_m_double(Marshaller *m, double *v, const char *n, Error **errp)
 254 {
 255     XMLReader *xm = to_xm(m);
 256     xmlChar *content;
 257     int ret;
 258
 259     if (check_disabled(m)) {
 260         return;
 261     }
 262
 263     if (xm->node == NULL) {
 264         error_set(errp, "xml-reader", 0,
 265                   "Unexpected end of section looking for `%s' node `%s' on line %d",
 266                   "double", n, xm->last_node->line);
 267         return;
 268     }
 269     if (!strequals(CSTR(xm->node->name), "double")) {
 270         error_set(errp, "xml-reader", 0,
 271                   "Expecting node type `%s', got `%s' while parsing `%s' on line %d",
 272                   "double", CSTR(xm->node->name), n, xm->node->line);
 273         return;
 274     }
 275     content = xmlNodeGetContent(xm->node);
 276     if (content) {
 277         ret = sscanf(CSTR(content), "%lf", v);
 278         xmlFree(content);
 279     }
 280     if (!content || ret != 1) {
 281         error_set(errp, "xml-reader", 0,
 282                   "Failed to parse type `%s' node `%s' on line %d",
 283                   "double", n, xm->node->line);
 284         return;
 285     }
 286
 287     xm->last_node = xm->node;
 288     xm->node = next_node(xm->node);
 289 }
 290
 291 static void xml_m_bool(Marshaller *m, bool *v, const char *n, Error **errp)
 292 {
 293     XMLReader *xm = to_xm(m);
 294     xmlChar *content;
 295
 296     if (check_disabled(m)) {
 297         return;
 298     }
 299
 300     if (xm->node == NULL) {
 301         error_set(errp, "xml-reader", 0,
 302                   "Unexpected end of section looking for `%s' node `%s' on line %d",
 303                   "double", n, xm->last_node->line);
 304         return;
 305     }
 306     if (!strequals(CSTR(xm->node->name), "bool")) {
 307         error_set(errp, "xml-reader", 0,
 308                   "Expecting node type `%s', got `%s' while parsing `%s' on line %d",
 309                   "bool", CSTR(xm->node->name), n, xm->node->line);
 310         return;
 311     }
 312     content = xmlNodeGetContent(xm->node);
 313     if (content) {
 314         if (strequals(CSTR(content), "true")) {
 315             *v = true;
 316         } else if (strequals(CSTR(content), "false")) {
 317             *v = false;
 318         } else {
 319             error_set(errp, "xml-reader", 0,
 320                       "Invalid value for node type `%s', got `%s', expecting `true' or 'false' on line %d",
 321                       "bool", content, xm->node->line);
 322             xmlFree(content);
 323             return;
 324         }
 325         xmlFree(content);
 326     }
 327     if (!content) {
 328         error_set(errp, "xml-reader", 0,
 329                   "Failed to parse type `%s' node `%s' on line %d",
 330                   "bool", n, xm->node->line);
 331         return;
 332     }
 333
 334     xm->last_node = xm->node;
 335     xm->node = next_node(xm->node);
 336 }
 337
 338 static void confirm_prop(xmlNode *node, const char *t, const char *n, const char *p, Error **errp)
 339 {
 340     xmlChar *v;
 341
 342     if (t) {
 343         v = xmlGetProp(node, (xmlChar *)p);
 344         if (!v) {
 345             error_set(errp, "xml-reader", 0,
 346                       "Missing attribute `%s' in `%s' node `%s' on line %d",
 347                       p, CSTR(node->name), n, node->line);
 348             return;
 349         }
 350         if (!strequals(CSTR(v), t)) {
 351             error_set(errp, "xml-reader", 0,
 352                       "Expecting attribute `%s' value of `%s' for `%s' node `%s', got `%s' on line %d",
 353                       p, t, CSTR(node->name), n, CSTR(v), node->line);
 354             xmlFree(v);
 355             return;
 356         }
 357         xmlFree(v);
 358     }
 359 }
 360
 361 static void xml_start_struct(Marshaller *m, const char *t, const char *n, Error **errp)
 362 {
 363     XMLReader *xm = to_xm(m);
 364
 365     if (check_disabled(m)) {
 366         return;
 367     }
 368
 369     if (!strequals(CSTR(xm->node->name), "struct")) {
 370         error_set(errp, "xml-reader", 0, "Expecting node `%s', got `%s' on line %d",
 371                   CSTR(xm->node->name), n, xm->node->line);
 372         return;
 373     }
 374
 375     confirm_prop(xm->node, t, n, "type", errp);
 376     if (error_is_set(errp)) {
 377         return;
 378     }
 379
 380     confirm_prop(xm->node, n, n, "name", errp);
 381     if (error_is_set(errp)) {
 382         return;
 383     }
 384
 385     xm->last_node = xm->node;
 386     xm->node = first_node(xm->node->children);
 387     xm->no_kids = !!(xm->node == NULL);
 388 }
 389
 390 static void xml_end_struct(Marshaller *m, Error **errp)
 391 {
 392     XMLReader *xm = to_xm(m);
 393
 394     if (check_disabled(m)) {
 395         return;
 396     }
 397
 398     if (xm->node != NULL) {
 399         error_set(errp, "xml-reader", 0, "Extra nodes at end of `%s' on line %d",
 400                   "struct", xm->node->line);
 401         return;
 402     }
 403
 404     if (xm->no_kids) {
 405         xm->no_kids = 0;
 406     } else {
 407         xm->last_node = xm->last_node->parent;
 408     }
 409     xm->node = next_node(xm->last_node);
 410 }
 411
 412 static void xml_start_array(Marshaller *m, const char *n, Error **errp)
 413 {
 414     XMLReader *xm = to_xm(m);
 415
 416     if (check_disabled(m)) {
 417         return;
 418     }
 419
 420     if (!strequals(CSTR(xm->node->name), "array")) {
 421         error_set(errp, "xml-reader", 0, "Expecting node `%s', got `%s' on line %d",
 422                   CSTR(xm->node->name), n, xm->node->line);
 423         return;
 424     }
 425
 426     confirm_prop(xm->node, n, n, "name", errp);
 427     if (error_is_set(errp)) {
 428         return;
 429     }
 430
 431     xm->last_node = xm->node;
 432     xm->node = first_node(xm->node->children);
 433     xm->no_kids = !!(xm->node == NULL);
 434 }
 435
 436 static void xml_end_array(Marshaller *m, Error **errp)
 437 {
 438     XMLReader *xm = to_xm(m);
 439
 440     if (check_disabled(m)) {
 441         return;
 442     }
 443
 444     if (xm->node != NULL) {
 445         error_set(errp, "xml-reader", 0, "Extra nodes at end of `%s' on line %d",
 446                   "array", xm->node->line);
 447         return;
 448     }
 449
 450     if (xm->no_kids) {
 451         xm->no_kids = 0;
 452     } else {
 453         xm->last_node = xm->last_node->parent;
 454     }
 455     xm->node = next_node(xm->last_node);
 456 }
 457
 458 static void xml_start_feature(Marshaller *m, bool *v, const char *n, Error **errp)
 459 {
 460     XMLReader *xm = to_xm(m);
 461     bool previous_feature;
 462
 463     previous_feature = xm->features[xm->feature - 1];
 464     xm->features[xm->feature++] = previous_feature && *v;
 465
 466     if (check_disabled(m)) {
 467         return;
 468     }
 469
 470     if (!strequals(CSTR(xm->node->name), "feature")) {
 471         error_set(errp, "xml-reader", 0, "Expecting node `%s', got `%s' on line %d",
 472                   "feature", CSTR(xm->node->name), xm->node->line);
 473         return;
 474     }
 475
 476     confirm_prop(xm->node, n, n, "name", errp);
 477     if (error_is_set(errp)) {
 478         return;
 479     }
 480
 481     xm->last_node = xm->node;
 482     xm->node = first_node(xm->node->children);
 483 }
 484
 485 static void xml_end_feature(Marshaller *m, Error **errp)
 486 {
 487     XMLReader *xm = to_xm(m);
 488
 489     if (!check_disabled(m)) {
 490         if (xm->node != NULL) {
 491             error_set(errp, "xml-reader", 0, "Extra nodes at end of `%s' on line %d",
 492                       "feature", xm->node->line);
 493             return;
 494         }
 495
 496         xm->last_node = xm->last_node->parent;
 497         xm->node = next_node(xm->last_node);
 498     }
 499     xm->feature--;
 500 }
 501
 502 static MarshallerOps xml_reader_ops = {
 503     .m_uint8 = xml_m_uint8,
 504     .m_uint16 = xml_m_uint16,
 505     .m_uint32 = xml_m_uint32,
 506     .m_uint64 = xml_m_uint64,
 507     .m_int8 = xml_m_int8,
 508     .m_int16 = xml_m_int16,
 509     .m_int32 = xml_m_int32,
 510     .m_int64 = xml_m_int64,
 511     .m_double = xml_m_double,
 512     .m_bool = xml_m_bool,
 513     .start_struct = xml_start_struct,
 514     .end_struct = xml_end_struct,
 515     .start_array = xml_start_array,
 516     .end_array = xml_end_array,
 517     .start_feature = xml_start_feature,
 518     .end_feature = xml_end_feature,
 519 };
 520
 521 Marshaller *xml_reader_open(FILE *filep)
 522 {
 523     XMLReader *xm;
 524     xmlNode *root;
 525
 526     xm = malloc(sizeof(*xm));
 527     memset(xm, 0, sizeof(*xm));
 528
 529     xm->m.ops = &xml_reader_ops;
 530     xm->features[xm->feature++] = true;
 531
 532     xm->doc = xmlReadFd(fileno(filep), "anonymous.xml", NULL, 0);
 533     if (xm->doc == NULL) {
 534         return NULL;
 535     }
 536
 537     root = xmlDocGetRootElement(xm->doc);
 538
 539     xm->node = first_node(root->children);
 540     xm->last_node = xm->node;
 541
 542     return &xm->m;
 543 }
 544
 545 void xml_reader_close(Marshaller *m)
 546 {
 547     XMLReader *xm = to_xm(m);
 548
 549     xmlFreeDoc(xm->doc);
 550     xmlCleanupParser();
 551     free(xm);
 552 }