wimlib.net Git - wimlib/blob - src/xml.c

   1 /*
   2  * xml.c
   3  *
   4  * Deals with the XML information in WIM files.  Uses the C library libxml2.
   5  */
   6
   7 /*
   8  * Copyright (C) 2012, 2013, 2015 Eric Biggers
   9  *
  10  * This file is free software; you can redistribute it and/or modify it under
  11  * the terms of the GNU Lesser General Public License as published by the Free
  12  * Software Foundation; either version 3 of the License, or (at your option) any
  13  * later version.
  14  *
  15  * This file is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this file; if not, see http://www.gnu.org/licenses/.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include "config.h"
  26 #endif
  27
  28 #include <libxml/parser.h>
  29 #include <libxml/tree.h>
  30 #include <libxml/xmlsave.h>
  31 #include <string.h>
  32
  33 #include "wimlib/blob_table.h"
  34 #include "wimlib/dentry.h"
  35 #include "wimlib/encoding.h"
  36 #include "wimlib/error.h"
  37 #include "wimlib/file_io.h"
  38 #include "wimlib/metadata.h"
  39 #include "wimlib/resource.h"
  40 #include "wimlib/timestamp.h"
  41 #include "wimlib/xml.h"
  42 #include "wimlib/write.h"
  43
  44 /*
  45  * A wrapper around a WIM file's XML document.  The XML document contains
  46  * metadata about each image in the WIM file as well as metadata about the WIM
  47  * file itself.
  48  */
  49 struct wim_xml_info {
  50
  51         /* The parsed XML document as a libxml2 document tree  */
  52         xmlDocPtr doc;
  53
  54         /* The root element of the document.  This is a cached value, equal to
  55          * xmlDocGetRootElement(doc).  */
  56         xmlNode *root;
  57
  58         /* A malloc()ed array containing a pointer to the IMAGE element for each
  59          * WIM image.  The image with 1-based index 'i' is at index 'i - 1' in
  60          * this array.  Note: these pointers are cached values, since they could
  61          * also be found by searching the document.  */
  62         xmlNode **images;
  63
  64         /* The number of WIM images (the length of 'images')  */
  65         int image_count;
  66
  67         /* Temporary memory for UTF-8 => 'tchar' string translations.  When an
  68          * API function needs to return a 'tchar' string, it uses one of these
  69          * array slots to hold the string and returns a pointer to it.  */
  70         tchar *strings[128];
  71         size_t next_string_idx;
  72         size_t num_strings;
  73 };
  74
  75 /*----------------------------------------------------------------------------*
  76  *                            Internal functions                              *
  77  *----------------------------------------------------------------------------*/
  78
  79 /* Iterate through the children of an xmlNode.  */
  80 #define node_for_each_child(parent, child)      \
  81         for (child = (parent)->children; child != NULL; child = child->next)
  82
  83 /* Is the specified node an element of the specified name?  */
  84 static bool
  85 node_is_element(const xmlNode *node, const xmlChar *name)
  86 {
  87         return node->type == XML_ELEMENT_NODE && xmlStrEqual(node->name, name);
  88 }
  89
  90 /* Retrieve a pointer to the UTF-8 text contents of the specified node, or NULL
  91  * if the node has no text contents.  This assumes the simple case where the
  92  * node has a single TEXT child node.  */
  93 static const xmlChar *
  94 node_get_text(const xmlNode *node)
  95 {
  96         const xmlNode *child;
  97
  98         if (!node)
  99                 return NULL;
 100         node_for_each_child(node, child)
 101                 if (child->type == XML_TEXT_NODE && child->content)
 102                         return child->content;
 103         return NULL;
 104 }
 105
 106 /* Retrieve an unsigned integer from the contents of the specified node,
 107  * decoding it using the specified base.  If the node has no contents or does
 108  * not contain a valid number, returns 0.  */
 109 static u64
 110 node_get_number(const xmlNode *node, int base)
 111 {
 112         const xmlChar *str = node_get_text(node);
 113         char *end;
 114         unsigned long long v;
 115
 116         if (!str)
 117                 return 0;
 118         v = strtoull(str, &end, base);
 119         if ((xmlChar *)end == str || *end || v >= UINT64_MAX)
 120                 return 0;
 121         return v;
 122 }
 123
 124 /* Retrieve the timestamp from a time node.  This node should have child
 125  * elements HIGHPART and LOWPART; these elements will be used to construct a
 126  * Windows-style timestamp.  */
 127 static u64
 128 node_get_timestamp(const xmlNode *node)
 129 {
 130         u64 timestamp = 0;
 131         xmlNode *child;
 132
 133         if (!node)
 134                 return 0;
 135         node_for_each_child(node, child) {
 136                 if (node_is_element(child, "HIGHPART"))
 137                         timestamp |= node_get_number(child, 16) << 32;
 138                 else if (node_is_element(child, "LOWPART"))
 139                         timestamp |= node_get_number(child, 16);
 140         }
 141         return timestamp;
 142 }
 143
 144 static int
 145 tstr_get_utf8(const tchar *tstr, const xmlChar **utf8_ret)
 146 {
 147         if (wimlib_mbs_is_utf8) {
 148                 *utf8_ret = (xmlChar *)tstr;
 149                 return 0;
 150         }
 151         return tstr_to_utf8_simple(tstr, (char **)utf8_ret);
 152 }
 153
 154 static void
 155 tstr_put_utf8(const xmlChar *utf8)
 156 {
 157         if (!wimlib_mbs_is_utf8)
 158                 FREE((void *)utf8);
 159 }
 160
 161 /* Retrieve the text contents of an XML element as a 'tchar' string.  If not
 162  * found or if the text could not be translated, returns NULL.  */
 163 static const tchar *
 164 node_get_ttext(struct wim_xml_info *info, xmlNode *node)
 165 {
 166         const xmlChar *text;
 167         tchar **ttext_p;
 168
 169         text = node_get_text(node);
 170
 171         if (!text || wimlib_mbs_is_utf8)
 172                 return (const tchar *)text;
 173
 174         ttext_p = &info->strings[info->next_string_idx];
 175         if (info->num_strings >= ARRAY_LEN(info->strings)) {
 176                 FREE(*ttext_p);
 177                 *ttext_p = NULL;
 178         }
 179         if (utf8_to_tstr_simple(text, ttext_p))
 180                 return NULL;
 181         if (info->num_strings < ARRAY_LEN(info->strings))
 182                 info->num_strings++;
 183         info->next_string_idx++;
 184         info->next_string_idx %= ARRAY_LEN(info->strings);
 185         return *ttext_p;
 186 }
 187
 188 /* Unlink the specified node from its parent, then free it (recursively).  */
 189 static void
 190 unlink_and_free_tree(xmlNode *node)
 191 {
 192         xmlUnlinkNode(node);
 193         xmlFreeNode(node);
 194 }
 195
 196 /* Unlink and free (recursively) all children of the specified node.  */
 197 static void
 198 unlink_and_free_children(xmlNode *node)
 199 {
 200         xmlNode *child;
 201
 202         while ((child = node->last) != NULL)
 203                 unlink_and_free_tree(child);
 204 }
 205
 206 /* Add the new child element 'replacement' to 'parent', replacing any same-named
 207  * element that may already exist.  */
 208 static void
 209 node_replace_child_element(xmlNode *parent, xmlNode *replacement)
 210 {
 211         xmlNode *child;
 212
 213         node_for_each_child(parent, child) {
 214                 if (node_is_element(child, replacement->name)) {
 215                         xmlReplaceNode(child, replacement);
 216                         xmlFreeNode(child);
 217                         return;
 218                 }
 219         }
 220
 221         xmlAddChild(parent, replacement);
 222 }
 223
 224 /* Set the text contents of the specified element to the specified string,
 225  * replacing the existing contents (if any).  The string is "raw" and is
 226  * permitted to contain characters that have special meaning in XML.  */
 227 static int
 228 node_set_text(xmlNode *node, const xmlChar *text)
 229 {
 230         xmlNode *text_node = xmlNewText(text);
 231         if (!text_node)
 232                 return WIMLIB_ERR_NOMEM;
 233         unlink_and_free_children(node);
 234         xmlAddChild(node, text_node);
 235         return 0;
 236 }
 237
 238 /* Like 'node_set_text()', but takes in a 'tchar' string.  */
 239 static int
 240 node_set_ttext(xmlNode *node, const tchar *ttext)
 241 {
 242         const xmlChar *text;
 243         int ret;
 244
 245         ret = tstr_get_utf8(ttext, &text);
 246         if (ret)
 247                 return ret;
 248         ret = node_set_text(node, text);
 249         tstr_put_utf8(text);
 250         return ret;
 251 }
 252
 253 /* Create a new element containing text and optionally link it into a tree.  */
 254 static xmlNode *
 255 new_element_with_text(xmlNode *parent, const xmlChar *name, const xmlChar *text)
 256 {
 257         xmlNode *node;
 258
 259         node = xmlNewNode(NULL, name);
 260         if (!node)
 261                 return NULL;
 262
 263         if (node_set_text(node, text)) {
 264                 xmlFreeNode(node);
 265                 return NULL;
 266         }
 267
 268         if (parent)
 269                 xmlAddChild(parent, node);
 270         return node;
 271 }
 272
 273 /* Create a new element containing text and optionally link it into a tree.  */
 274 static int
 275 new_element_with_ttext(xmlNode *parent, const xmlChar *name, const tchar *ttext,
 276                        xmlNode **node_ret)
 277 {
 278         const xmlChar *text;
 279         int ret;
 280         xmlNode *node;
 281
 282         ret = tstr_get_utf8(ttext, &text);
 283         if (ret)
 284                 return ret;
 285         node = new_element_with_text(parent, name, text);
 286         tstr_put_utf8(text);
 287         if (!node)
 288                 return WIMLIB_ERR_NOMEM;
 289         if (node_ret)
 290                 *node_ret = node;
 291         return 0;
 292 }
 293
 294 /* Create a new timestamp element and optionally link it into a tree.  */
 295 static xmlNode *
 296 new_element_with_timestamp(xmlNode *parent, const xmlChar *name, u64 timestamp)
 297 {
 298         xmlNode *node;
 299         char buf[32];
 300
 301         node = xmlNewNode(NULL, name);
 302         if (!node)
 303                 goto err;
 304
 305         sprintf(buf, "0x%08"PRIX32, (u32)(timestamp >> 32));
 306         if (!new_element_with_text(node, "HIGHPART", buf))
 307                 goto err;
 308
 309         sprintf(buf, "0x%08"PRIX32, (u32)timestamp);
 310         if (!new_element_with_text(node, "LOWPART", buf))
 311                 goto err;
 312
 313         if (parent)
 314                 xmlAddChild(parent, node);
 315         return node;
 316
 317 err:
 318         xmlFreeNode(node);
 319         return NULL;
 320 }
 321
 322 /* Create a new number element and optionally link it into a tree.  */
 323 static xmlNode *
 324 new_element_with_u64(xmlNode *parent, const xmlChar *name, u64 value)
 325 {
 326         char buf[32];
 327
 328         sprintf(buf, "%"PRIu64, value);
 329         return new_element_with_text(parent, name, buf);
 330 }
 331
 332 /* Allocate a 'struct wim_xml_info'.  The caller is responsible for initializing
 333  * the document and the images array.  */
 334 static struct wim_xml_info *
 335 alloc_wim_xml_info(void)
 336 {
 337         struct wim_xml_info *info = MALLOC(sizeof(*info));
 338         if (info) {
 339                 info->next_string_idx = 0;
 340                 info->num_strings = 0;
 341         }
 342         return info;
 343 }
 344
 345 static int
 346 do_xml_path_walk(xmlNode *node, const xmlChar *path, bool create,
 347                  xmlNode **result_ret)
 348 {
 349         size_t n = strlen(path) + 1;
 350         xmlChar buf[n];
 351         xmlChar *p;
 352         xmlChar c;
 353
 354         *result_ret = NULL;
 355
 356         if (!node)
 357                 return 0;
 358
 359         /* Copy the path to a temporary buffer.  */
 360         memcpy(buf, path, n);
 361         p = buf;
 362
 363         if (*p == '/')
 364                 goto bad_syntax;
 365         if (strchr(p, '[')) /* reserved for future use */
 366                 goto bad_syntax;
 367         c = *p;
 368
 369         while (c != '\0') {
 370                 const xmlChar *name;
 371                 xmlNode *child;
 372
 373                 /* We have another path component.  */
 374
 375                 /* Parse the element name.  */
 376                 name = p;
 377                 while (*p != '/' && *p != '\0')
 378                         p++;
 379                 if (p == name) /* empty name?  */
 380                         goto bad_syntax;
 381                 c = *p;
 382                 *p = '\0';
 383
 384                 /* Look for a matching child.  */
 385                 node_for_each_child(node, child)
 386                         if (node_is_element(child, name))
 387                                 goto next_step;
 388
 389                 /* No child matched the path.  If create=false, the lookup
 390                  * failed.  If create=true, create the needed element.  */
 391                 if (!create)
 392                         return 0;
 393                 child = xmlNewChild(node, NULL, name, NULL);
 394                 if (!child)
 395                         return WIMLIB_ERR_NOMEM;
 396         next_step:
 397                 /* Continue to the next path component, if there is one.  */
 398                 node = child;
 399                 p++;
 400         }
 401
 402         *result_ret = node;
 403         return 0;
 404
 405 bad_syntax:
 406         ERROR("The XML path \"%s\" has invalid syntax.", path);
 407         return WIMLIB_ERR_INVALID_PARAM;
 408 }
 409
 410 /* Retrieve the XML element, if any, at the specified 'path'.  This supports a
 411  * simple filesystem-like syntax.  If the element was found, returns a pointer
 412  * to it; otherwise returns NULL.  */
 413 static xmlNode *
 414 xml_get_node_by_path(xmlNode *root, const xmlChar *path)
 415 {
 416         xmlNode *node;
 417         do_xml_path_walk(root, path, false, &node);
 418         return node;
 419 }
 420
 421 /* Similar to xml_get_node_by_path(), but creates the element and any requisite
 422  * ancestor elements as needed.   If successful, 0 is returned and *node_ret is
 423  * set to a pointer to the resulting element.  If unsuccessful, an error code is
 424  * returned and *node_ret is set to NULL.  */
 425 static int
 426 xml_ensure_node_by_path(xmlNode *root, const xmlChar *path, xmlNode **node_ret)
 427 {
 428         return do_xml_path_walk(root, path, true, node_ret);
 429 }
 430
 431 static u64
 432 xml_get_number_by_path(xmlNode *root, const xmlChar *path)
 433 {
 434         return node_get_number(xml_get_node_by_path(root, path), 10);
 435 }
 436
 437 static u64
 438 xml_get_timestamp_by_path(xmlNode *root, const xmlChar *path)
 439 {
 440         return node_get_timestamp(xml_get_node_by_path(root, path));
 441 }
 442
 443 static const xmlChar *
 444 xml_get_text_by_path(xmlNode *root, const xmlChar *path)
 445 {
 446         return node_get_text(xml_get_node_by_path(root, path));
 447 }
 448
 449 static const tchar *
 450 xml_get_ttext_by_path(struct wim_xml_info *info, xmlNode *root,
 451                       const xmlChar *path)
 452 {
 453         return node_get_ttext(info, xml_get_node_by_path(root, path));
 454 }
 455
 456 /* Creates/replaces (if ttext is not NULL and not empty) or removes (if ttext is
 457  * NULL or empty) an element containing text.  */
 458 static int
 459 xml_set_ttext_by_path(xmlNode *root, const xmlChar *path, const tchar *ttext)
 460 {
 461         int ret;
 462         xmlNode *node;
 463
 464         if (ttext && *ttext) {
 465                 /* Create or replace  */
 466                 ret = xml_ensure_node_by_path(root, path, &node);
 467                 if (ret)
 468                         return ret;
 469                 return node_set_ttext(node, ttext);
 470         } else {
 471                 /* Remove  */
 472                 node = xml_get_node_by_path(root, path);
 473                 if (node)
 474                         unlink_and_free_tree(node);
 475                 return 0;
 476         }
 477 }
 478
 479 /* Sets a string property for the specified WIM image.  */
 480 static int
 481 set_image_property(WIMStruct *wim, int image, const xmlChar *name,
 482                    const tchar *value)
 483 {
 484         struct wim_xml_info *info = wim->xml_info;
 485
 486         if (image < 1 || image > info->image_count)
 487                 return WIMLIB_ERR_INVALID_IMAGE;
 488
 489         return xml_set_ttext_by_path(info->images[image - 1], name, value);
 490 }
 491
 492 /* Gets a string property for the specified WIM image as a 'tchar' string.
 493  * Returns a pointer to the property value if found; NULL if the image doesn't
 494  * exist; or 'default_value' if the property doesn't exist in the image or if
 495  * the property value could not be translated to a 'tchar' string.  */
 496 static const tchar *
 497 get_image_property(const WIMStruct *wim, int image, const xmlChar *name,
 498                    const tchar *default_value)
 499 {
 500         struct wim_xml_info *info = wim->xml_info;
 501         const tchar *value;
 502
 503         if (image < 1 || image > info->image_count)
 504                 return NULL;
 505
 506         value = xml_get_ttext_by_path(info, info->images[image - 1], name);
 507         return value ? value : default_value;
 508 }
 509
 510 /* Unlink and return the node which represents the INDEX attribute of the
 511  * specified IMAGE element.  */
 512 static xmlAttr *
 513 unlink_index_attribute(xmlNode *image_node)
 514 {
 515         xmlAttr *attr = xmlHasProp(image_node, "INDEX");
 516         xmlUnlinkNode((xmlNode *)attr);
 517         return attr;
 518 }
 519
 520 /* Compute the total uncompressed size of the streams of the specified inode. */
 521 static u64
 522 inode_sum_stream_sizes(const struct wim_inode *inode,
 523                        const struct blob_table *blob_table)
 524 {
 525         u64 total_size = 0;
 526
 527         for (unsigned i = 0; i < inode->i_num_streams; i++) {
 528                 const struct blob_descriptor *blob;
 529
 530                 blob = stream_blob(&inode->i_streams[i], blob_table);
 531                 if (blob)
 532                         total_size += blob->size;
 533         }
 534         return total_size;
 535 }
 536
 537 static int
 538 append_image_node(struct wim_xml_info *info, xmlNode *image_node)
 539 {
 540         char buf[32];
 541         xmlNode **images;
 542
 543         /* Limit exceeded?  */
 544         if (unlikely(info->image_count >= MAX_IMAGES))
 545                 return WIMLIB_ERR_IMAGE_COUNT;
 546
 547         /* Add the INDEX attribute.  */
 548         sprintf(buf, "%d", info->image_count + 1);
 549         if (!xmlNewProp(image_node, "INDEX", buf))
 550                 return WIMLIB_ERR_NOMEM;
 551
 552         /* Append the IMAGE element to the 'images' array.  */
 553         images = REALLOC(info->images,
 554                          (info->image_count + 1) * sizeof(info->images[0]));
 555         if (unlikely(!images))
 556                 return WIMLIB_ERR_NOMEM;
 557         info->images = images;
 558         images[info->image_count++] = image_node;
 559
 560         /* Add the IMAGE element to the document.  */
 561         xmlAddChild(info->root, image_node);
 562         return 0;
 563 }
 564
 565 /*----------------------------------------------------------------------------*
 566  *                     Functions for internal library use                     *
 567  *----------------------------------------------------------------------------*/
 568
 569 /* Allocate an empty 'struct wim_xml_info', containing no images.  */
 570 struct wim_xml_info *
 571 xml_new_info_struct(void)
 572 {
 573         struct wim_xml_info *info;
 574
 575         info = alloc_wim_xml_info();
 576         if (!info)
 577                 goto err;
 578
 579         info->doc = xmlNewDoc("1.0");
 580         if (!info->doc)
 581                 goto err_free_info;
 582
 583         info->root = xmlNewNode(NULL, "WIM");
 584         if (!info->root)
 585                 goto err_free_doc;
 586         xmlDocSetRootElement(info->doc, info->root);
 587
 588         info->images = NULL;
 589         info->image_count = 0;
 590         return info;
 591
 592 err_free_doc:
 593         xmlFreeDoc(info->doc);
 594 err_free_info:
 595         FREE(info);
 596 err:
 597         return NULL;
 598 }
 599
 600 /* Free a 'struct wim_xml_info'.  */
 601 void
 602 xml_free_info_struct(struct wim_xml_info *info)
 603 {
 604         if (info) {
 605                 xmlFreeDoc(info->doc);
 606                 FREE(info->images);
 607                 for (size_t i = 0; i < info->num_strings; i++)
 608                         FREE(info->strings[i]);
 609                 FREE(info);
 610         }
 611 }
 612
 613 /* Retrieve the number of images for which there exist IMAGE elements in the XML
 614  * document.  */
 615 int
 616 xml_get_image_count(const struct wim_xml_info *info)
 617 {
 618         return info->image_count;
 619 }
 620
 621 /* Retrieve the TOTALBYTES value for the WIM file, or 0 if this value is
 622  * unavailable.  */
 623 u64
 624 xml_get_total_bytes(const struct wim_xml_info *info)
 625 {
 626         return xml_get_number_by_path(info->root, "TOTALBYTES");
 627 }
 628
 629 /* Retrieve the TOTALBYTES value for the specified image, or 0 if this value is
 630  * unavailable.  */
 631 u64
 632 xml_get_image_total_bytes(const struct wim_xml_info *info, int image)
 633 {
 634         return xml_get_number_by_path(info->images[image - 1], "TOTALBYTES");
 635 }
 636
 637 /* Retrieve the HARDLINKBYTES value for the specified image, or 0 if this value
 638  * is unavailable.  */
 639 u64
 640 xml_get_image_hard_link_bytes(const struct wim_xml_info *info, int image)
 641 {
 642         return xml_get_number_by_path(info->images[image - 1], "HARDLINKBYTES");
 643 }
 644
 645 /* Retrieve the WIMBOOT value for the specified image, or false if this value is
 646  * unavailable.  */
 647 bool
 648 xml_get_wimboot(const struct wim_xml_info *info, int image)
 649 {
 650         return xml_get_number_by_path(info->images[image - 1], "WIMBOOT");
 651 }
 652
 653 /* Retrieve the Windows build number for the specified image, or 0 if this
 654  * information is not available.  */
 655 u64
 656 xml_get_windows_build_number(const struct wim_xml_info *info, int image)
 657 {
 658         return xml_get_number_by_path(info->images[image - 1],
 659                                       "WINDOWS/VERSION/BUILD");
 660 }
 661
 662 /* Set the WIMBOOT value for the specified image.  */
 663 int
 664 xml_set_wimboot(struct wim_xml_info *info, int image)
 665 {
 666         return xml_set_ttext_by_path(info->images[image - 1], "WIMBOOT", T("1"));
 667 }
 668
 669 /*
 670  * Update the DIRCOUNT, FILECOUNT, TOTALBYTES, HARDLINKBYTES, and
 671  * LASTMODIFICATIONTIME elements for the specified WIM image.
 672  *
 673  * Note: since these stats are likely to be used for display purposes only, we
 674  * no longer attempt to duplicate WIMGAPI's weird bugs when calculating them.
 675  */
 676 int
 677 xml_update_image_info(WIMStruct *wim, int image)
 678 {
 679         const struct wim_image_metadata *imd = wim->image_metadata[image - 1];
 680         xmlNode *image_node = wim->xml_info->images[image - 1];
 681         const struct wim_inode *inode;
 682         u64 dir_count = 0;
 683         u64 file_count = 0;
 684         u64 total_bytes = 0;
 685         u64 hard_link_bytes = 0;
 686         u64 size;
 687         xmlNode *dircount_node;
 688         xmlNode *filecount_node;
 689         xmlNode *totalbytes_node;
 690         xmlNode *hardlinkbytes_node;
 691         xmlNode *lastmodificationtime_node;
 692
 693         image_for_each_inode(inode, imd) {
 694                 if (inode_is_directory(inode))
 695                         dir_count += inode->i_nlink;
 696                 else
 697                         file_count += inode->i_nlink;
 698                 size = inode_sum_stream_sizes(inode, wim->blob_table);
 699                 total_bytes += size * inode->i_nlink;
 700                 hard_link_bytes += size * (inode->i_nlink - 1);
 701         }
 702
 703         dircount_node = new_element_with_u64(NULL, "DIRCOUNT", dir_count);
 704         filecount_node = new_element_with_u64(NULL, "FILECOUNT", file_count);
 705         totalbytes_node = new_element_with_u64(NULL, "TOTALBYTES", total_bytes);
 706         hardlinkbytes_node = new_element_with_u64(NULL, "HARDLINKBYTES",
 707                                                   hard_link_bytes);
 708         lastmodificationtime_node =
 709                 new_element_with_timestamp(NULL, "LASTMODIFICATIONTIME",
 710                                            now_as_wim_timestamp());
 711
 712         if (unlikely(!dircount_node || !filecount_node || !totalbytes_node ||
 713                      !hardlinkbytes_node || !lastmodificationtime_node)) {
 714                 xmlFreeNode(dircount_node);
 715                 xmlFreeNode(filecount_node);
 716                 xmlFreeNode(totalbytes_node);
 717                 xmlFreeNode(hardlinkbytes_node);
 718                 xmlFreeNode(lastmodificationtime_node);
 719                 WARNING("Failed to update image information!");
 720                 return WIMLIB_ERR_NOMEM;
 721         }
 722
 723         node_replace_child_element(image_node, dircount_node);
 724         node_replace_child_element(image_node, filecount_node);
 725         node_replace_child_element(image_node, totalbytes_node);
 726         node_replace_child_element(image_node, hardlinkbytes_node);
 727         node_replace_child_element(image_node, lastmodificationtime_node);
 728         return 0;
 729 }
 730
 731 /* Add an image to the XML information. */
 732 int
 733 xml_add_image(struct wim_xml_info *info, const tchar *name)
 734 {
 735         const u64 now = now_as_wim_timestamp();
 736         xmlNode *image_node;
 737         int ret;
 738
 739         ret = WIMLIB_ERR_NOMEM;
 740         image_node = xmlNewNode(NULL, "IMAGE");
 741         if (!image_node)
 742                 goto err;
 743
 744         if (name && *name) {
 745                 ret = new_element_with_ttext(image_node, "NAME", name, NULL);
 746                 if (ret)
 747                         goto err;
 748         }
 749         ret = WIMLIB_ERR_NOMEM;
 750         if (!new_element_with_u64(image_node, "DIRCOUNT", 0))
 751                 goto err;
 752         if (!new_element_with_u64(image_node, "FILECOUNT", 0))
 753                 goto err;
 754         if (!new_element_with_u64(image_node, "TOTALBYTES", 0))
 755                 goto err;
 756         if (!new_element_with_u64(image_node, "HARDLINKBYTES", 0))
 757                 goto err;
 758         if (!new_element_with_timestamp(image_node, "CREATIONTIME", now))
 759                 goto err;
 760         if (!new_element_with_timestamp(image_node, "LASTMODIFICATIONTIME", now))
 761                 goto err;
 762         ret = append_image_node(info, image_node);
 763         if (ret)
 764                 goto err;
 765         return 0;
 766
 767 err:
 768         xmlFreeNode(image_node);
 769         return ret;
 770 }
 771
 772 /*
 773  * Make a copy of the XML information for the image with index @src_image in the
 774  * @src_info XML document and append it to the @dest_info XML document.
 775  *
 776  * In the process, change the image's name and description to the values
 777  * specified by @dest_image_name and @dest_image_description.  Either or both
 778  * may be NULL, which indicates that the corresponding element will not be
 779  * included in the destination image.
 780  */
 781 int
 782 xml_export_image(const struct wim_xml_info *src_info, int src_image,
 783                  struct wim_xml_info *dest_info, const tchar *dest_image_name,
 784                  const tchar *dest_image_description, bool wimboot)
 785 {
 786         xmlNode *dest_node;
 787         int ret;
 788
 789         ret = WIMLIB_ERR_NOMEM;
 790         dest_node = xmlDocCopyNode(src_info->images[src_image - 1],
 791                                    dest_info->doc, 1);
 792         if (!dest_node)
 793                 goto err;
 794
 795         ret = xml_set_ttext_by_path(dest_node, "NAME", dest_image_name);
 796         if (ret)
 797                 goto err;
 798
 799         ret = xml_set_ttext_by_path(dest_node, "DESCRIPTION",
 800                                     dest_image_description);
 801         if (ret)
 802                 goto err;
 803
 804         if (wimboot) {
 805                 ret = xml_set_ttext_by_path(dest_node, "WIMBOOT", T("1"));
 806                 if (ret)
 807                         goto err;
 808         }
 809
 810         xmlFreeProp(unlink_index_attribute(dest_node));
 811
 812         ret = append_image_node(dest_info, dest_node);
 813         if (ret)
 814                 goto err;
 815         return 0;
 816
 817 err:
 818         xmlFreeNode(dest_node);
 819         return ret;
 820 }
 821
 822 /* Remove the specified image from the XML document.  */
 823 void
 824 xml_delete_image(struct wim_xml_info *info, int image)
 825 {
 826         xmlNode *next_image;
 827         xmlAttr *index_attr, *next_index_attr;
 828
 829         /* Free the IMAGE element for the deleted image.  Then, shift all
 830          * higher-indexed IMAGE elements down by 1, in the process re-assigning
 831          * their INDEX attributes.  */
 832
 833         next_image = info->images[image - 1];
 834         next_index_attr = unlink_index_attribute(next_image);
 835         unlink_and_free_tree(next_image);
 836
 837         while (image < info->image_count) {
 838                 index_attr = next_index_attr;
 839                 next_image = info->images[image];
 840                 next_index_attr = unlink_index_attribute(next_image);
 841                 xmlAddChild(next_image, (xmlNode *)index_attr);
 842                 info->images[image - 1] = next_image;
 843                 image++;
 844         }
 845
 846         xmlFreeProp(next_index_attr);
 847         info->image_count--;
 848 }
 849
 850 /* Architecture constants are from w64 mingw winnt.h  */
 851 #define PROCESSOR_ARCHITECTURE_INTEL            0
 852 #define PROCESSOR_ARCHITECTURE_MIPS             1
 853 #define PROCESSOR_ARCHITECTURE_ALPHA            2
 854 #define PROCESSOR_ARCHITECTURE_PPC              3
 855 #define PROCESSOR_ARCHITECTURE_SHX              4
 856 #define PROCESSOR_ARCHITECTURE_ARM              5
 857 #define PROCESSOR_ARCHITECTURE_IA64             6
 858 #define PROCESSOR_ARCHITECTURE_ALPHA64          7
 859 #define PROCESSOR_ARCHITECTURE_MSIL             8
 860 #define PROCESSOR_ARCHITECTURE_AMD64            9
 861 #define PROCESSOR_ARCHITECTURE_IA32_ON_WIN64    10
 862
 863 static const tchar *
 864 describe_arch(u64 arch)
 865 {
 866         static const tchar * const descriptions[] = {
 867                 [PROCESSOR_ARCHITECTURE_INTEL] = T("x86"),
 868                 [PROCESSOR_ARCHITECTURE_MIPS]  = T("MIPS"),
 869                 [PROCESSOR_ARCHITECTURE_ARM]   = T("ARM"),
 870                 [PROCESSOR_ARCHITECTURE_IA64]  = T("ia64"),
 871                 [PROCESSOR_ARCHITECTURE_AMD64] = T("x86_64"),
 872         };
 873
 874         if (arch < ARRAY_LEN(descriptions) && descriptions[arch] != NULL)
 875                 return descriptions[arch];
 876
 877         return T("unknown");
 878 }
 879
 880 /* Print information from the WINDOWS element, if present.  */
 881 static void
 882 print_windows_info(struct wim_xml_info *info, xmlNode *image_node)
 883 {
 884         xmlNode *windows_node;
 885         xmlNode *langs_node;
 886         xmlNode *version_node;
 887         const tchar *text;
 888
 889         windows_node = xml_get_node_by_path(image_node, "WINDOWS");
 890         if (!windows_node)
 891                 return;
 892
 893         tprintf(T("Architecture:           %"TS"\n"),
 894                 describe_arch(xml_get_number_by_path(windows_node, "ARCH")));
 895
 896         text = xml_get_ttext_by_path(info, windows_node, "PRODUCTNAME");
 897         if (text)
 898                 tprintf(T("Product Name:           %"TS"\n"), text);
 899
 900         text = xml_get_ttext_by_path(info, windows_node, "EDITIONID");
 901         if (text)
 902                 tprintf(T("Edition ID:             %"TS"\n"), text);
 903
 904         text = xml_get_ttext_by_path(info, windows_node, "INSTALLATIONTYPE");
 905         if (text)
 906                 tprintf(T("Installation Type:      %"TS"\n"), text);
 907
 908         text = xml_get_ttext_by_path(info, windows_node, "HAL");
 909         if (text)
 910                 tprintf(T("HAL:                    %"TS"\n"), text);
 911
 912         text = xml_get_ttext_by_path(info, windows_node, "PRODUCTTYPE");
 913         if (text)
 914                 tprintf(T("Product Type:           %"TS"\n"), text);
 915
 916         text = xml_get_ttext_by_path(info, windows_node, "PRODUCTSUITE");
 917         if (text)
 918                 tprintf(T("Product Suite:          %"TS"\n"), text);
 919
 920         langs_node = xml_get_node_by_path(windows_node, "LANGUAGES");
 921         if (langs_node) {
 922                 xmlNode *lang_node;
 923
 924                 tprintf(T("Languages:              "));
 925                 node_for_each_child(langs_node, lang_node) {
 926                         if (!node_is_element(lang_node, "LANGUAGE"))
 927                                 continue;
 928                         text = node_get_ttext(info, lang_node);
 929                         if (!text)
 930                                 continue;
 931                         tprintf(T("%"TS" "), text);
 932                 }
 933                 tputchar(T('\n'));
 934
 935                 text = xml_get_ttext_by_path(info, langs_node, "DEFAULT");
 936                 if (text)
 937                         tprintf(T("Default Language:       %"TS"\n"), text);
 938         }
 939
 940         text = xml_get_ttext_by_path(info, windows_node, "SYSTEMROOT");
 941         if (text)
 942                 tprintf(T("System Root:            %"TS"\n"), text);
 943
 944         version_node = xml_get_node_by_path(windows_node, "VERSION");
 945         if (version_node) {
 946                 tprintf(T("Major Version:          %"PRIu64"\n"),
 947                         xml_get_number_by_path(version_node, "MAJOR"));
 948                 tprintf(T("Minor Version:          %"PRIu64"\n"),
 949                         xml_get_number_by_path(version_node, "MINOR"));
 950                 tprintf(T("Build:                  %"PRIu64"\n"),
 951                         xml_get_number_by_path(version_node, "BUILD"));
 952                 tprintf(T("Service Pack Build:     %"PRIu64"\n"),
 953                         xml_get_number_by_path(version_node, "SPBUILD"));
 954                 tprintf(T("Service Pack Level:     %"PRIu64"\n"),
 955                         xml_get_number_by_path(version_node, "SPLEVEL"));
 956         }
 957 }
 958
 959 /* Prints information about the specified image.  */
 960 void
 961 xml_print_image_info(struct wim_xml_info *info, int image)
 962 {
 963         xmlNode * const image_node = info->images[image - 1];
 964         const tchar *text;
 965         tchar timebuf[64];
 966
 967         tprintf(T("Index:                  %d\n"), image);
 968
 969         /* Always print the Name and Description, even if the corresponding XML
 970          * elements are not present.  */
 971         text = xml_get_ttext_by_path(info, image_node, "NAME");
 972         tprintf(T("Name:                   %"TS"\n"), text ? text : T(""));
 973         text = xml_get_ttext_by_path(info, image_node, "DESCRIPTION");
 974         tprintf(T("Description:            %"TS"\n"), text ? text : T(""));
 975
 976         text = xml_get_ttext_by_path(info, image_node, "DISPLAYNAME");
 977         if (text)
 978                 tprintf(T("Display Name:           %"TS"\n"), text);
 979
 980         text = xml_get_ttext_by_path(info, image_node, "DISPLAYDESCRIPTION");
 981         if (text)
 982                 tprintf(T("Display Description:    %"TS"\n"), text);
 983
 984         tprintf(T("Directory Count:        %"PRIu64"\n"),
 985                 xml_get_number_by_path(image_node, "DIRCOUNT"));
 986
 987         tprintf(T("File Count:             %"PRIu64"\n"),
 988                 xml_get_number_by_path(image_node, "FILECOUNT"));
 989
 990         tprintf(T("Total Bytes:            %"PRIu64"\n"),
 991                 xml_get_number_by_path(image_node, "TOTALBYTES"));
 992
 993         tprintf(T("Hard Link Bytes:        %"PRIu64"\n"),
 994                 xml_get_number_by_path(image_node, "HARDLINKBYTES"));
 995
 996         wim_timestamp_to_str(xml_get_timestamp_by_path(image_node,
 997                                                        "CREATIONTIME"),
 998                              timebuf, ARRAY_LEN(timebuf));
 999         tprintf(T("Creation Time:          %"TS"\n"), timebuf);
1000
1001         wim_timestamp_to_str(xml_get_timestamp_by_path(image_node,
1002                                                        "LASTMODIFICATIONTIME"),
1003                              timebuf, ARRAY_LEN(timebuf));
1004         tprintf(T("Last Modification Time: %"TS"\n"), timebuf);
1005
1006         print_windows_info(info, image_node);
1007
1008         text = xml_get_ttext_by_path(info, image_node, "FLAGS");
1009         if (text)
1010                 tprintf(T("Flags:                  %"TS"\n"), text);
1011
1012         tprintf(T("WIMBoot compatible:     %"TS"\n"),
1013                 xml_get_number_by_path(image_node, "WIMBOOT") ?
1014                         T("yes") : T("no"));
1015
1016         tputchar('\n');
1017 }
1018
1019 /*----------------------------------------------------------------------------*
1020  *                      Reading and writing the XML data                      *
1021  *----------------------------------------------------------------------------*/
1022
1023 static int
1024 image_node_get_index(const xmlNode *node)
1025 {
1026         u64 v = node_get_number((const xmlNode *)xmlHasProp(node, "INDEX"), 10);
1027         return min(v, INT_MAX);
1028 }
1029
1030 /* Prepare the 'images' array from the XML document tree.  */
1031 static int
1032 setup_images(struct wim_xml_info *info, xmlNode *root)
1033 {
1034         xmlNode *child;
1035         int index;
1036         int max_index = 0;
1037         int ret;
1038
1039         info->images = NULL;
1040         info->image_count = 0;
1041
1042         node_for_each_child(root, child) {
1043                 if (!node_is_element(child, "IMAGE"))
1044                         continue;
1045                 index = image_node_get_index(child);
1046                 if (unlikely(index < 1 || info->image_count >= MAX_IMAGES))
1047                         goto err_indices;
1048                 max_index = max(max_index, index);
1049                 info->image_count++;
1050         }
1051         if (unlikely(max_index != info->image_count))
1052                 goto err_indices;
1053         ret = WIMLIB_ERR_NOMEM;
1054         info->images = CALLOC(info->image_count, sizeof(info->images[0]));
1055         if (unlikely(!info->images))
1056                 goto err;
1057         node_for_each_child(root, child) {
1058                 if (!node_is_element(child, "IMAGE"))
1059                         continue;
1060                 index = image_node_get_index(child);
1061                 if (unlikely(info->images[index - 1]))
1062                         goto err_indices;
1063                 info->images[index - 1] = child;
1064         }
1065         return 0;
1066
1067 err_indices:
1068         ERROR("The WIM file's XML document does not contain exactly one IMAGE "
1069               "element per image!");
1070         ret = WIMLIB_ERR_XML;
1071 err:
1072         FREE(info->images);
1073         return ret;
1074 }
1075
1076 /* Reads the XML data from a WIM file.  */
1077 int
1078 read_wim_xml_data(WIMStruct *wim)
1079 {
1080         struct wim_xml_info *info;
1081         void *buf;
1082         size_t bufsize;
1083         xmlDoc *doc;
1084         xmlNode *root;
1085         int ret;
1086
1087         /* Allocate the 'struct wim_xml_info'.  */
1088         ret = WIMLIB_ERR_NOMEM;
1089         info = alloc_wim_xml_info();
1090         if (!info)
1091                 goto err;
1092
1093         /* Read the raw UTF-16LE bytes.  */
1094         ret = wimlib_get_xml_data(wim, &buf, &bufsize);
1095         if (ret)
1096                 goto err_free_info;
1097
1098         /* Parse the document with libxml2, creating the document tree.  */
1099         doc = xmlReadMemory(buf, bufsize, NULL, "UTF-16LE", XML_PARSE_NONET);
1100         FREE(buf);
1101         buf = NULL;
1102         if (!doc) {
1103                 ERROR("Unable to parse the WIM file's XML document!");
1104                 ret = WIMLIB_ERR_XML;
1105                 goto err_free_info;
1106         }
1107
1108         /* Verify the root element.  */
1109         root = xmlDocGetRootElement(doc);
1110         if (!node_is_element(root, "WIM")) {
1111                 ERROR("The WIM file's XML document has an unexpected format!");
1112                 ret = WIMLIB_ERR_XML;
1113                 goto err_free_doc;
1114         }
1115
1116         /* Verify the WIM file is not encrypted.  */
1117         if (xml_get_node_by_path(root, "ESD/ENCRYPTED")) {
1118                 ret = WIMLIB_ERR_WIM_IS_ENCRYPTED;
1119                 goto err_free_doc;
1120         }
1121
1122         /* Validate the image elements and set up the images[] array.  */
1123         ret = setup_images(info, root);
1124         if (ret)
1125                 goto err_free_doc;
1126
1127         /* Save the document and return.  */
1128         info->doc = doc;
1129         info->root = root;
1130         wim->xml_info = info;
1131         return 0;
1132
1133 err_free_doc:
1134         xmlFreeDoc(doc);
1135 err_free_info:
1136         FREE(info);
1137 err:
1138         return ret;
1139 }
1140
1141 /* Swap the INDEX attributes of two IMAGE elements.  */
1142 static void
1143 swap_index_attributes(xmlNode *image_node_1, xmlNode *image_node_2)
1144 {
1145         xmlAttr *attr_1, *attr_2;
1146
1147         if (image_node_1 != image_node_2) {
1148                 attr_1 = unlink_index_attribute(image_node_1);
1149                 attr_2 = unlink_index_attribute(image_node_2);
1150                 xmlAddChild(image_node_1, (xmlNode *)attr_2);
1151                 xmlAddChild(image_node_2, (xmlNode *)attr_1);
1152         }
1153 }
1154
1155 static int
1156 prepare_document_for_write(struct wim_xml_info *info, int image, u64 total_bytes,
1157                            xmlNode **orig_totalbytes_node_ret)
1158 {
1159         xmlNode *totalbytes_node = NULL;
1160
1161         /* Allocate the new TOTALBYTES element if needed.  */
1162         if (total_bytes != WIM_TOTALBYTES_USE_EXISTING &&
1163             total_bytes != WIM_TOTALBYTES_OMIT) {
1164                 totalbytes_node = new_element_with_u64(NULL, "TOTALBYTES",
1165                                                        total_bytes);
1166                 if (!totalbytes_node)
1167                         return WIMLIB_ERR_NOMEM;
1168         }
1169
1170         /* Adjust the IMAGE elements if needed.  */
1171         if (image != WIMLIB_ALL_IMAGES) {
1172                 /* We're writing a single image only.  Temporarily unlink all
1173                  * other IMAGE elements from the document.  */
1174                 for (int i = 0; i < info->image_count; i++)
1175                         if (i + 1 != image)
1176                                 xmlUnlinkNode(info->images[i]);
1177
1178                 /* Temporarily set the INDEX attribute of the needed IMAGE
1179                  * element to 1.  */
1180                 swap_index_attributes(info->images[0], info->images[image - 1]);
1181         }
1182
1183         /* Adjust (add, change, or remove) the TOTALBYTES element if needed.  */
1184         *orig_totalbytes_node_ret = NULL;
1185         if (total_bytes != WIM_TOTALBYTES_USE_EXISTING) {
1186                 /* Unlink the previous TOTALBYTES element, if any.  */
1187                 *orig_totalbytes_node_ret = xml_get_node_by_path(info->root,
1188                                                                  "TOTALBYTES");
1189                 if (*orig_totalbytes_node_ret)
1190                         xmlUnlinkNode(*orig_totalbytes_node_ret);
1191
1192                 /* Link in the new TOTALBYTES element, if any.  */
1193                 if (totalbytes_node)
1194                         xmlAddChild(info->root, totalbytes_node);
1195         }
1196         return 0;
1197 }
1198
1199 static void
1200 restore_document_after_write(struct wim_xml_info *info, int image,
1201                              xmlNode *orig_totalbytes_node)
1202 {
1203         /* Restore the IMAGE elements if needed.  */
1204         if (image != WIMLIB_ALL_IMAGES) {
1205                 /* We wrote a single image only.  Re-link all other IMAGE
1206                  * elements to the document.  */
1207                 for (int i = 0; i < info->image_count; i++)
1208                         if (i + 1 != image)
1209                                 xmlAddChild(info->root, info->images[i]);
1210
1211                 /* Restore the original INDEX attributes.  */
1212                 swap_index_attributes(info->images[0], info->images[image - 1]);
1213         }
1214
1215         /* Restore the original TOTALBYTES element if needed.  */
1216         if (orig_totalbytes_node)
1217                 node_replace_child_element(info->root, orig_totalbytes_node);
1218 }
1219
1220 /*
1221  * Writes the XML data to a WIM file.
1222  *
1223  * 'image' specifies the image(s) to include in the XML data.  Normally it is
1224  * WIMLIB_ALL_IMAGES, but it can also be a 1-based image index.
1225  *
1226  * 'total_bytes' is the number to use in the top-level TOTALBYTES element, or
1227  * WIM_TOTALBYTES_USE_EXISTING to use the existing value from the XML document
1228  * (if any), or WIM_TOTALBYTES_OMIT to omit the TOTALBYTES element entirely.
1229  */
1230 int
1231 write_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
1232                    struct wim_reshdr *out_reshdr, int write_resource_flags)
1233 {
1234         struct wim_xml_info *info = wim->xml_info;
1235         long ret;
1236         long ret2;
1237         xmlBuffer *buffer;
1238         xmlNode *orig_totalbytes_node;
1239         xmlSaveCtxt *save_ctx;
1240
1241         /* Make any needed temporary changes to the document.  */
1242         ret = prepare_document_for_write(info, image, total_bytes,
1243                                          &orig_totalbytes_node);
1244         if (ret)
1245                 goto out;
1246
1247         /* Create an in-memory buffer to hold the encoded document.  */
1248         ret = WIMLIB_ERR_NOMEM;
1249         buffer = xmlBufferCreate();
1250         if (!buffer)
1251                 goto out_restore_document;
1252
1253         /* Encode the document in UTF-16LE, with a byte order mark, and with no
1254          * XML declaration.  Some other WIM software requires all of these
1255          * characteristics.  */
1256         ret = WIMLIB_ERR_NOMEM;
1257         if (xmlBufferCat(buffer, "\xff\xfe"))
1258                 goto out_free_buffer;
1259         save_ctx = xmlSaveToBuffer(buffer, "UTF-16LE", XML_SAVE_NO_DECL);
1260         if (!save_ctx)
1261                 goto out_free_buffer;
1262         ret = xmlSaveDoc(save_ctx, info->doc);
1263         ret2 = xmlSaveClose(save_ctx);
1264         if (ret < 0 || ret2 < 0) {
1265                 ERROR("Unable to serialize the WIM file's XML document!");
1266                 ret = WIMLIB_ERR_NOMEM;
1267                 goto out_free_buffer;
1268         }
1269
1270         /* Write the XML data uncompressed.  Although wimlib can handle
1271          * compressed XML data, some other WIM software cannot.  */
1272         ret = write_wim_resource_from_buffer(xmlBufferContent(buffer),
1273                                              xmlBufferLength(buffer),
1274                                              true,
1275                                              &wim->out_fd,
1276                                              WIMLIB_COMPRESSION_TYPE_NONE,
1277                                              0,
1278                                              out_reshdr,
1279                                              NULL,
1280                                              write_resource_flags);
1281 out_free_buffer:
1282         xmlBufferFree(buffer);
1283 out_restore_document:
1284         /* Revert any temporary changes we made to the document.  */
1285         restore_document_after_write(info, image, orig_totalbytes_node);
1286 out:
1287         return ret;
1288 }
1289
1290 /*----------------------------------------------------------------------------*
1291  *                           Global setup functions                           *
1292  *----------------------------------------------------------------------------*/
1293
1294 void
1295 xml_global_init(void)
1296 {
1297         xmlInitParser();
1298 }
1299
1300 void
1301 xml_global_cleanup(void)
1302 {
1303         xmlCleanupParser();
1304 }
1305
1306 void
1307 xml_set_memory_allocator(void *(*malloc_func)(size_t),
1308                          void (*free_func)(void *),
1309                          void *(*realloc_func)(void *, size_t))
1310 {
1311         xmlMemSetup(free_func, malloc_func, realloc_func, wimlib_strdup);
1312 }
1313
1314 /*----------------------------------------------------------------------------*
1315  *                           Library API functions                            *
1316  *----------------------------------------------------------------------------*/
1317
1318 WIMLIBAPI int
1319 wimlib_get_xml_data(WIMStruct *wim, void **buf_ret, size_t *bufsize_ret)
1320 {
1321         const struct wim_reshdr *xml_reshdr;
1322
1323         if (wim->filename == NULL && filedes_is_seekable(&wim->in_fd))
1324                 return WIMLIB_ERR_NO_FILENAME;
1325
1326         if (buf_ret == NULL || bufsize_ret == NULL)
1327                 return WIMLIB_ERR_INVALID_PARAM;
1328
1329         xml_reshdr = &wim->hdr.xml_data_reshdr;
1330
1331         *bufsize_ret = xml_reshdr->uncompressed_size;
1332         return wim_reshdr_to_data(xml_reshdr, wim, buf_ret);
1333 }
1334
1335 WIMLIBAPI int
1336 wimlib_extract_xml_data(WIMStruct *wim, FILE *fp)
1337 {
1338         int ret;
1339         void *buf;
1340         size_t bufsize;
1341
1342         ret = wimlib_get_xml_data(wim, &buf, &bufsize);
1343         if (ret)
1344                 return ret;
1345
1346         if (fwrite(buf, 1, bufsize, fp) != bufsize) {
1347                 ERROR_WITH_ERRNO("Failed to extract XML data");
1348                 ret = WIMLIB_ERR_WRITE;
1349         }
1350         FREE(buf);
1351         return ret;
1352 }
1353
1354 static bool
1355 image_name_in_use(const WIMStruct *wim, const tchar *name, int excluded_image)
1356 {
1357         const struct wim_xml_info *info = wim->xml_info;
1358         const xmlChar *name_utf8;
1359         bool found = false;
1360
1361         /* Any number of images can have "no name".  */
1362         if (!name || !*name)
1363                 return false;
1364
1365         /* Check for images that have the specified name.  */
1366         if (tstr_get_utf8(name, &name_utf8))
1367                 return false;
1368         for (int i = 0; i < info->image_count && !found; i++) {
1369                 if (i + 1 == excluded_image)
1370                         continue;
1371                 found = xmlStrEqual(name_utf8, xml_get_text_by_path(
1372                                                     info->images[i], "NAME"));
1373         }
1374         tstr_put_utf8(name_utf8);
1375         return found;
1376 }
1377
1378 WIMLIBAPI bool
1379 wimlib_image_name_in_use(const WIMStruct *wim, const tchar *name)
1380 {
1381         return image_name_in_use(wim, name, WIMLIB_NO_IMAGE);
1382 }
1383
1384 WIMLIBAPI const tchar *
1385 wimlib_get_image_name(const WIMStruct *wim, int image)
1386 {
1387         return get_image_property(wim, image, "NAME", T(""));
1388 }
1389
1390 WIMLIBAPI const tchar *
1391 wimlib_get_image_description(const WIMStruct *wim, int image)
1392 {
1393         return get_image_property(wim, image, "DESCRIPTION", NULL);
1394 }
1395
1396 WIMLIBAPI const tchar *
1397 wimlib_get_image_property(const WIMStruct *wim, int image,
1398                           const tchar *property_name)
1399 {
1400         const xmlChar *name;
1401         const tchar *value;
1402
1403         if (!property_name || !*property_name)
1404                 return NULL;
1405         if (tstr_get_utf8(property_name, &name))
1406                 return NULL;
1407         value = get_image_property(wim, image, name, NULL);
1408         tstr_put_utf8(name);
1409         return value;
1410 }
1411
1412 WIMLIBAPI int
1413 wimlib_set_image_name(WIMStruct *wim, int image, const tchar *name)
1414 {
1415         if (image_name_in_use(wim, name, image))
1416                 return WIMLIB_ERR_IMAGE_NAME_COLLISION;
1417
1418         return set_image_property(wim, image, "NAME", name);
1419 }
1420
1421 WIMLIBAPI int
1422 wimlib_set_image_descripton(WIMStruct *wim, int image, const tchar *description)
1423 {
1424         return set_image_property(wim, image, "DESCRIPTION", description);
1425 }
1426
1427 WIMLIBAPI int
1428 wimlib_set_image_flags(WIMStruct *wim, int image, const tchar *flags)
1429 {
1430         return set_image_property(wim, image, "FLAGS", flags);
1431 }
1432
1433 WIMLIBAPI int
1434 wimlib_set_image_property(WIMStruct *wim, int image, const tchar *property_name,
1435                           const tchar *property_value)
1436 {
1437         const xmlChar *name;
1438         int ret;
1439
1440         if (!property_name || !*property_name)
1441                 return WIMLIB_ERR_INVALID_PARAM;
1442
1443         ret = tstr_get_utf8(property_name, &name);
1444         if (ret)
1445                 return ret;
1446         ret = set_image_property(wim, image, name, property_value);
1447         tstr_put_utf8(name);
1448         return ret;
1449 }