Add wimlib_get_xml_data() API
[wimlib] / src / xml.c
index fd5cddf..deeedb5 100644 (file)
--- a/src/xml.c
+++ b/src/xml.c
@@ -5,7 +5,7 @@
  */
 
 /*
- * Copyright (C) 2012 Eric Biggers
+ * Copyright (C) 2012, 2013 Eric Biggers
  *
  * This file is part of wimlib, a library for working with WIM files.
  *
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
-#include "dentry.h"
-#include "lookup_table.h"
-#include "timestamp.h"
-#include "wimlib_internal.h"
-#include "xml.h"
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
 
-#include <string.h>
+#include "wimlib/dentry.h"
+#include "wimlib/encoding.h"
+#include "wimlib/error.h"
+#include "wimlib/file_io.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/metadata.h"
+#include "wimlib/resource.h"
+#include "wimlib/timestamp.h"
+#include "wimlib/xml.h"
+
+#include <libxml/encoding.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/xmlwriter.h>
-#include <libxml/encoding.h>
 #include <limits.h>
+#include <string.h>
+#include <unistd.h>
 
 /* Structures used to form an in-memory representation of the XML data (other
  * than the raw parse tree from libxml). */
@@ -48,19 +57,19 @@ struct windows_version {
 };
 
 struct windows_info {
-       u64    arch;
-       char  *product_name;
-       char  *edition_id;
-       char  *installation_type;
-       char  *hal;
-       char  *product_type;
-       char  *product_suite;
-       char **languages;
-       char  *default_language;
-       size_t num_languages;
-       char  *system_root;
-       bool   windows_version_exists;
-       struct windows_version windows_version;
+       u64      arch;
+       tchar   *product_name;
+       tchar   *edition_id;
+       tchar   *installation_type;
+       tchar   *hal;
+       tchar   *product_type;
+       tchar   *product_suite;
+       tchar  **languages;
+       tchar   *default_language;
+       size_t   num_languages;
+       tchar   *system_root;
+       bool     windows_version_exists;
+       struct   windows_version windows_version;
 };
 
 struct image_info {
@@ -73,33 +82,120 @@ struct image_info {
        u64 creation_time;
        u64 last_modification_time;
        struct windows_info windows_info;
-       char *name;
-       char *description;
-       char *display_name;
-       char *display_description;
-       union {
-               char *flags;
-               struct lookup_table *lookup_table;
-       };
+       tchar *name;
+       tchar *description;
+       tchar *display_name;
+       tchar *display_description;
+       tchar *flags;
+       struct wim_lookup_table *lookup_table; /* temporary field */
 };
 
+/* A struct wim_info structure corresponds to the entire XML data for a WIM file. */
+struct wim_info {
+       u64 total_bytes;
+       int num_images;
+       /* Array of `struct image_info's, one for each image in the WIM that is
+        * mentioned in the XML data. */
+       struct image_info *images;
+};
+
+struct xml_string_spec {
+       const char *name;
+       size_t offset;
+};
+
+#define ELEM(STRING_NAME, MEMBER_NAME) \
+       {STRING_NAME, offsetof(struct image_info, MEMBER_NAME)}
+static const struct xml_string_spec
+image_info_xml_string_specs[] = {
+       ELEM("NAME", name),
+       ELEM("DESCRIPTION", description),
+       ELEM("DISPLAYNAME", display_name),
+       ELEM("DISPLAYDESCRIPTION", display_description),
+       ELEM("FLAGS", flags),
+};
+#undef ELEM
+
+#define ELEM(STRING_NAME, MEMBER_NAME) \
+       {STRING_NAME, offsetof(struct windows_info, MEMBER_NAME)}
+static const struct xml_string_spec
+windows_info_xml_string_specs[] = {
+       ELEM("PRODUCTNAME", product_name),
+       ELEM("EDITIONID", edition_id),
+       ELEM("INSTALLATIONTYPE", installation_type),
+       ELEM("HAL", hal),
+       ELEM("PRODUCTTYPE", product_type),
+       ELEM("PRODUCTSUITE", product_suite),
+};
+#undef ELEM
+
+u64
+wim_info_get_total_bytes(const struct wim_info *info)
+{
+       if (info)
+               return info->total_bytes;
+       else
+               return 0;
+}
+
+u64
+wim_info_get_image_hard_link_bytes(const struct wim_info *info, int image)
+{
+       if (info)
+               return info->images[image - 1].hard_link_bytes;
+       else
+               return 0;
+}
+
+u64
+wim_info_get_image_total_bytes(const struct wim_info *info, int image)
+{
+       if (info)
+               return info->images[image - 1].total_bytes;
+       else
+               return 0;
+}
+
+unsigned
+wim_info_get_num_images(const struct wim_info *info)
+{
+       if (info)
+               return info->num_images;
+       else
+               return 0;
+}
+
+/* Architecture constants are from w64 mingw winnt.h  */
+#define PROCESSOR_ARCHITECTURE_INTEL 0
+#define PROCESSOR_ARCHITECTURE_MIPS 1
+#define PROCESSOR_ARCHITECTURE_ALPHA 2
+#define PROCESSOR_ARCHITECTURE_PPC 3
+#define PROCESSOR_ARCHITECTURE_SHX 4
+#define PROCESSOR_ARCHITECTURE_ARM 5
+#define PROCESSOR_ARCHITECTURE_IA64 6
+#define PROCESSOR_ARCHITECTURE_ALPHA64 7
+#define PROCESSOR_ARCHITECTURE_MSIL 8
+#define PROCESSOR_ARCHITECTURE_AMD64 9
+#define PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 10
 
 /* Returns a statically allocated string that is a string representation of the
  * architecture number. */
-static const char *get_arch(int arch)
+static const tchar *
+get_arch(int arch)
 {
-       static char buf[20];
        switch (arch) {
-       case 0:
-               return "x86";
-       case 6:
-               return "ia64";
-       case 9:
-               return "x86_64";
-       /* XXX Are there other arch values? */
+       case PROCESSOR_ARCHITECTURE_INTEL:
+               return T("x86");
+       case PROCESSOR_ARCHITECTURE_MIPS:
+               return T("MIPS");
+       case PROCESSOR_ARCHITECTURE_ARM:
+               return T("ARM");
+       case PROCESSOR_ARCHITECTURE_IA64:
+               return T("ia64");
+       case PROCESSOR_ARCHITECTURE_AMD64:
+               return T("x86_64");
        default:
-               snprintf(buf, sizeof(buf), "%d (unknown)", arch);
-               return buf;
+               return T("unknown");
        }
 }
 
@@ -109,64 +205,74 @@ static const char *get_arch(int arch)
        for (child = parent->children; child != NULL; child = child->next)
 
 /* Utility functions for xmlNodes */
-static inline bool node_is_element(xmlNode *node)
+static inline bool
+node_is_element(xmlNode *node)
 {
        return node->type == XML_ELEMENT_NODE;
 }
 
-static inline bool node_is_text(xmlNode *node)
+static inline bool
+node_is_text(xmlNode *node)
 {
        return node->type == XML_TEXT_NODE;
 }
 
-static inline bool node_name_is(xmlNode *node, const char *name)
+static inline bool
+node_name_is(xmlNode *node, const char *name)
 {
        /* For now, both upper case and lower case element names are accepted. */
        return strcasecmp((const char *)node->name, name) == 0;
 }
 
-/* Finds the text node that is a child of an element node and returns its
- * content converted to a 64-bit unsigned integer.  Returns 0 if no text node is
- * found. */
-static u64 node_get_u64(const xmlNode *u64_node)
+static u64
+node_get_number(const xmlNode *u64_node, int base)
 {
        xmlNode *child;
        for_node_child(u64_node, child)
                if (node_is_text(child))
-                       return strtoull((const char *)child->content, NULL, 10);
+                       return strtoull(child->content, NULL, base);
        return 0;
 }
 
+/* Finds the text node that is a child of an element node and returns its
+ * content converted to a 64-bit unsigned integer.  Returns 0 if no text node is
+ * found. */
+static u64
+node_get_u64(const xmlNode *u64_node)
+{
+       return node_get_number(u64_node, 10);
+}
+
 /* Like node_get_u64(), but expects a number in base 16. */
-static u64 node_get_hex_u64(const xmlNode *u64_node)
+static u64
+node_get_hex_u64(const xmlNode *u64_node)
 {
-       xmlNode *child;
-       for_node_child(u64_node, child)
-               if (node_is_text(child))
-                       return strtoull(child->content, NULL, 16);
-       return 0;
+       return node_get_number(u64_node, 16);
 }
 
-static int node_get_string(const xmlNode *string_node, char **str)
+static int
+node_get_string(const xmlNode *string_node, tchar **tstr_ret)
 {
        xmlNode *child;
-       char *p = NULL;
+       tchar *tstr = NULL;
+       int ret;
 
        for_node_child(string_node, child) {
                if (node_is_text(child) && child->content) {
-                       p = STRDUP(child->content);
-                       if (!p)
-                               return WIMLIB_ERR_NOMEM;
+                       ret = utf8_to_tstr_simple(child->content, &tstr);
+                       if (ret)
+                               return ret;
                        break;
                }
        }
-       *str = p;
+       *tstr_ret = tstr;
        return 0;
 }
 
 /* Returns the timestamp from a time node.  It has child elements <HIGHPART> and
  * <LOWPART> that are then used to construct a 64-bit timestamp. */
-static u64 node_get_timestamp(const xmlNode *time_node)
+static u64
+node_get_timestamp(const xmlNode *time_node)
 {
        u32 high_part = 0;
        u32 low_part = 0;
@@ -183,10 +289,11 @@ static u64 node_get_timestamp(const xmlNode *time_node)
 }
 
 /* Used to sort an array of struct image_infos by their image indices. */
-static int sort_by_index(const void *p1, const void *p2)
+static int
+sort_by_index(const void *p1, const void *p2)
 {
-       int index_1 = ((struct image_info*)p1)->index;
-       int index_2 = ((struct image_info*)p1)->index;
+       int index_1 = ((const struct image_info*)p1)->index;
+       int index_2 = ((const struct image_info*)p2)->index;
        if (index_1 < index_2)
                return -1;
        else if (index_1 > index_2)
@@ -197,7 +304,8 @@ static int sort_by_index(const void *p1, const void *p2)
 
 
 /* Frees memory allocated inside a struct windows_info structure. */
-static void destroy_windows_info(struct windows_info *windows_info)
+static void
+destroy_windows_info(struct windows_info *windows_info)
 {
        FREE(windows_info->product_name);
        FREE(windows_info->edition_id);
@@ -213,7 +321,8 @@ static void destroy_windows_info(struct windows_info *windows_info)
 }
 
 /* Frees memory allocated inside a struct image_info structure. */
-static void destroy_image_info(struct image_info *image_info)
+static void
+destroy_image_info(struct image_info *image_info)
 {
        FREE(image_info->name);
        FREE(image_info->description);
@@ -224,7 +333,8 @@ static void destroy_image_info(struct image_info *image_info)
        memset(image_info, 0, sizeof(struct image_info));
 }
 
-void free_wim_info(struct wim_info *info)
+void
+free_wim_info(struct wim_info *info)
 {
        if (info) {
                if (info->images) {
@@ -238,8 +348,9 @@ void free_wim_info(struct wim_info *info)
 
 /* Reads the information from a <VERSION> element inside the <WINDOWS> element.
  * */
-static void xml_read_windows_version(const xmlNode *version_node,
-                                    struct windows_version* windows_version)
+static void
+xml_read_windows_version(const xmlNode *version_node,
+                        struct windows_version* windows_version)
 {
        xmlNode *child;
        for_node_child(version_node, child) {
@@ -260,14 +371,15 @@ static void xml_read_windows_version(const xmlNode *version_node,
 
 /* Reads the information from a <LANGUAGE> element inside a <WINDOWS> element.
  * */
-static int xml_read_languages(const xmlNode *languages_node,
-                             char ***languages_ret,
-                             size_t *num_languages_ret,
-                             char **default_language_ret)
+static int
+xml_read_languages(const xmlNode *languages_node,
+                  tchar ***languages_ret,
+                  size_t *num_languages_ret,
+                  tchar **default_language_ret)
 {
        xmlNode *child;
        size_t num_languages = 0;
-       char **languages;
+       tchar **languages;
        int ret;
 
        for_node_child(languages_node, child)
@@ -296,8 +408,9 @@ static int xml_read_languages(const xmlNode *languages_node,
 }
 
 /* Reads the information from a <WINDOWS> element inside an <IMAGE> element. */
-static int xml_read_windows_info(const xmlNode *windows_node,
-                                struct windows_info *windows_info)
+static int
+xml_read_windows_info(const xmlNode *windows_node,
+                     struct windows_info *windows_info)
 {
        xmlNode *child;
        int ret = 0;
@@ -343,8 +456,8 @@ static int xml_read_windows_info(const xmlNode *windows_node,
 }
 
 /* Reads the information from an <IMAGE> element. */
-static int xml_read_image_info(xmlNode *image_node,
-                              struct image_info *image_info)
+static int
+xml_read_image_info(xmlNode *image_node, struct image_info *image_info)
 {
        xmlNode *child;
        xmlChar *index_prop;
@@ -394,12 +507,12 @@ static int xml_read_image_info(xmlNode *image_node,
                        return ret;
        }
        if (!image_info->name) {
-               char *empty_name;
-               WARNING("Image with index %d has no name", image_info->index);
-               empty_name = MALLOC(1);
+               tchar *empty_name;
+               /*WARNING("Image with index %d has no name", image_info->index);*/
+               empty_name = MALLOC(sizeof(tchar));
                if (!empty_name)
                        return WIMLIB_ERR_NOMEM;
-               *empty_name = '\0';
+               *empty_name = T('\0');
                image_info->name = empty_name;
        }
        return ret;
@@ -407,8 +520,8 @@ static int xml_read_image_info(xmlNode *image_node,
 
 /* Reads the information from a <WIM> element, which should be the root element
  * of the XML tree. */
-static int xml_read_wim_info(const xmlNode *wim_node,
-                            struct wim_info **wim_info_ret)
+static int
+xml_read_wim_info(const xmlNode *wim_node, struct wim_info **wim_info_ret)
 {
        struct wim_info *wim_info;
        xmlNode *child;
@@ -477,70 +590,137 @@ err:
        return ret;
 }
 
-/* Prints the information contained in a `struct windows_info'. */
-static void print_windows_info(const struct windows_info *windows_info)
+/* Prints the information contained in a `struct windows_info'.
+ *
+ * Warning: any strings printed here are in UTF-8 encoding.  If the locale
+ * character encoding is not UTF-8, the printed strings may be garbled. */
+static void
+print_windows_info(const struct windows_info *windows_info)
 {
        const struct windows_version *windows_version;
 
-       printf("Architecture:           %s\n", get_arch(windows_info->arch));
+       tprintf(T("Architecture:           %"TS"\n"),
+               get_arch(windows_info->arch));
 
-       if (windows_info->product_name)
-               printf("Product Name:           %s\n",
-                      windows_info->product_name);
+       if (windows_info->product_name) {
+               tprintf(T("Product Name:           %"TS"\n"),
+                       windows_info->product_name);
+       }
 
-       if (windows_info->edition_id)
-               printf("Edition ID:             %s\n",
-                      windows_info->edition_id);
+       if (windows_info->edition_id) {
+               tprintf(T("Edition ID:             %"TS"\n"),
+                       windows_info->edition_id);
+       }
 
-       if (windows_info->installation_type)
-               printf("Installation Type:      %s\n",
-                      windows_info->installation_type);
+       if (windows_info->installation_type) {
+               tprintf(T("Installation Type:      %"TS"\n"),
+                       windows_info->installation_type);
+       }
 
-       if (windows_info->hal)
-               printf("HAL:                    %s\n",
-                      windows_info->hal);
+       if (windows_info->hal) {
+               tprintf(T("HAL:                    %"TS"\n"),
+                             windows_info->hal);
+       }
 
-       if (windows_info->product_type)
-               printf("Product Type:           %s\n",
-                      windows_info->product_type);
+       if (windows_info->product_type) {
+               tprintf(T("Product Type:           %"TS"\n"),
+                       windows_info->product_type);
+       }
 
-       if (windows_info->product_suite)
-               printf("Product Suite:          %s\n",
-                      windows_info->product_suite);
+       if (windows_info->product_suite) {
+               tprintf(T("Product Suite:          %"TS"\n"),
+                       windows_info->product_suite);
+       }
 
-       printf("Languages:              ");
+       tprintf(T("Languages:              "));
        for (size_t i = 0; i < windows_info->num_languages; i++) {
-               fputs(windows_info->languages[i], stdout);
-               putchar(' ');
+
+               tfputs(windows_info->languages[i], stdout);
+               tputchar(T(' '));
        }
-       putchar('\n');
-       if (windows_info->default_language)
-               printf("Default Language:       %s\n",
-                      windows_info->default_language);
-       if (windows_info->system_root)
-               printf("System Root:            %s\n",
-                      windows_info->system_root);
+       tputchar(T('\n'));
+       if (windows_info->default_language) {
+               tprintf(T("Default Language:       %"TS"\n"),
+                       windows_info->default_language);
+       }
+       if (windows_info->system_root) {
+               tprintf(T("System Root:            %"TS"\n"),
+                             windows_info->system_root);
+       }
+
        if (windows_info->windows_version_exists) {
                windows_version = &windows_info->windows_version;
-               printf("Major Version:          %"PRIu64"\n",
-                      windows_version->major);
-               printf("Minor Version:          %"PRIu64"\n",
-                      windows_version->minor);
-               printf("Build:                  %"PRIu64"\n",
-                      windows_version->build);
-               printf("Service Pack Build:     %"PRIu64"\n",
-                      windows_version->sp_build);
-               printf("Service Pack Level:     %"PRIu64"\n",
-                      windows_version->sp_level);
+               tprintf(T("Major Version:          %"PRIu64"\n"),
+                       windows_version->major);
+               tprintf(T("Minor Version:          %"PRIu64"\n"),
+                       windows_version->minor);
+               tprintf(T("Build:                  %"PRIu64"\n"),
+                       windows_version->build);
+               tprintf(T("Service Pack Build:     %"PRIu64"\n"),
+                       windows_version->sp_build);
+               tprintf(T("Service Pack Level:     %"PRIu64"\n"),
+                       windows_version->sp_level);
+       }
+}
+
+static int
+xml_write_string(xmlTextWriter *writer, const char *name,
+                const tchar *tstr)
+{
+       if (tstr) {
+               char *utf8_str;
+               int rc = tstr_to_utf8_simple(tstr, &utf8_str);
+               if (rc)
+                       return rc;
+               rc = xmlTextWriterWriteElement(writer, name, utf8_str);
+               FREE(utf8_str);
+               if (rc < 0)
+                       return rc;
        }
+       return 0;
 }
 
+static int
+xml_write_strings_from_specs(xmlTextWriter *writer,
+                            const void *struct_with_strings,
+                            const struct xml_string_spec specs[],
+                            size_t num_specs)
+{
+       for (size_t i = 0; i < num_specs; i++) {
+               int rc = xml_write_string(writer, specs[i].name,
+                                     *(const tchar * const *)
+                                       (struct_with_strings + specs[i].offset));
+               if (rc)
+                       return rc;
+       }
+       return 0;
+}
+
+static int
+dup_strings_from_specs(const void *old_struct_with_strings,
+                      void *new_struct_with_strings,
+                      const struct xml_string_spec specs[],
+                      size_t num_specs)
+{
+       for (size_t i = 0; i < num_specs; i++) {
+               const tchar *old_str = *(const tchar * const *)
+                                       ((const void*)old_struct_with_strings + specs[i].offset);
+               tchar **new_str_p = (tchar **)((void*)new_struct_with_strings + specs[i].offset);
+               if (old_str) {
+                       *new_str_p = TSTRDUP(old_str);
+                       if (!*new_str_p)
+                               return WIMLIB_ERR_NOMEM;
+               }
+       }
+       return 0;
+}
 
 /* Writes the information contained in a `struct windows_version' to the XML
  * document being written.  This is the <VERSION> element inside the <WINDOWS>
  * element. */
-static int xml_write_windows_version(xmlTextWriter *writer,
-                                    const struct windows_version *version)
+static int
+xml_write_windows_version(xmlTextWriter *writer,
+                         const struct windows_version *version)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, "VERSION");
@@ -572,13 +752,18 @@ static int xml_write_windows_version(xmlTextWriter *writer,
        if (rc < 0)
                return rc;
 
-       return xmlTextWriterEndElement(writer); /* </VERSION> */
+       rc = xmlTextWriterEndElement(writer); /* </VERSION> */
+       if (rc < 0)
+               return rc;
+
+       return 0;
 }
 
 /* Writes the information contained in a `struct windows_info' to the XML
  * document being written. This is the <WINDOWS> element. */
-static int xml_write_windows_info(xmlTextWriter *writer,
-                                 const struct windows_info *windows_info)
+static int
+xml_write_windows_info(xmlTextWriter *writer,
+                      const struct windows_info *windows_info)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, "WINDOWS");
@@ -590,47 +775,12 @@ static int xml_write_windows_info(xmlTextWriter *writer,
        if (rc < 0)
                return rc;
 
-       if (windows_info->product_name) {
-               rc = xmlTextWriterWriteElement(writer, "PRODUCTNAME",
-                                              windows_info->product_name);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (windows_info->edition_id) {
-               rc = xmlTextWriterWriteElement(writer, "EDITIONID",
-                                              windows_info->edition_id);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (windows_info->installation_type) {
-               rc = xmlTextWriterWriteElement(writer, "INSTALLATIONTYPE",
-                                              windows_info->installation_type);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (windows_info->hal) {
-               rc = xmlTextWriterWriteElement(writer, "HAL",
-                                              windows_info->hal);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (windows_info->product_type) {
-               rc = xmlTextWriterWriteElement(writer, "PRODUCTTYPE",
-                                              windows_info->product_type);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (windows_info->product_suite) {
-               rc = xmlTextWriterWriteElement(writer, "PRODUCTSUITE",
-                                              windows_info->product_suite);
-               if (rc < 0)
-                       return rc;
-       }
+       rc = xml_write_strings_from_specs(writer,
+                                         windows_info,
+                                         windows_info_xml_string_specs,
+                                         ARRAY_LEN(windows_info_xml_string_specs));
+       if (rc)
+               return rc;
 
        if (windows_info->num_languages) {
                rc = xmlTextWriterStartElement(writer, "LANGUAGES");
@@ -638,14 +788,15 @@ static int xml_write_windows_info(xmlTextWriter *writer,
                        return rc;
 
                for (size_t i = 0; i < windows_info->num_languages; i++) {
-                       rc = xmlTextWriterWriteElement(writer, "LANGUAGE",
-                                                      windows_info->languages[i]);
-                       if (rc < 0)
+                       rc = xml_write_string(writer, "LANGUAGE",
+                                             windows_info->languages[i]);
+                       if (rc)
                                return rc;
                }
-               rc = xmlTextWriterWriteElement(writer, "DEFAULT",
-                                              windows_info->default_language);
-               if (rc < 0)
+
+               rc = xml_write_string(writer, "DEFAULT",
+                                     windows_info->default_language);
+               if (rc)
                        return rc;
 
                rc = xmlTextWriterEndElement(writer); /* </LANGUAGES> */
@@ -655,23 +806,24 @@ static int xml_write_windows_info(xmlTextWriter *writer,
 
        if (windows_info->windows_version_exists) {
                rc = xml_write_windows_version(writer, &windows_info->windows_version);
-               if (rc < 0)
+               if (rc)
                        return rc;
        }
 
-       if (windows_info->system_root) {
-               rc = xmlTextWriterWriteElement(writer, "SYSTEMROOT",
-                                              windows_info->system_root);
-               if (rc < 0)
-                       return rc;
-       }
+       rc = xml_write_string(writer, "SYSTEMROOT", windows_info->system_root);
+       if (rc)
+               return rc;
+
+       rc = xmlTextWriterEndElement(writer); /* </WINDOWS> */
+       if (rc < 0)
+               return rc;
 
-       return xmlTextWriterEndElement(writer); /* </WINDOWS> */
+       return 0;
 }
 
 /* Writes a time element to the XML document being constructed in memory. */
-static int xml_write_time(xmlTextWriter *writer, const char *element_name,
-                         u64 time)
+static int
+xml_write_time(xmlTextWriter *writer, const char *element_name, u64 time)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, element_name);
@@ -695,8 +847,8 @@ static int xml_write_time(xmlTextWriter *writer, const char *element_name,
 }
 
 /* Writes an <IMAGE> element to the XML document. */
-static int xml_write_image_info(xmlTextWriter *writer,
-                               const struct image_info *image_info)
+static int
+xml_write_image_info(xmlTextWriter *writer, const struct image_info *image_info)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, "IMAGE");
@@ -739,51 +891,29 @@ static int xml_write_image_info(xmlTextWriter *writer,
 
        if (image_info->windows_info_exists) {
                rc = xml_write_windows_info(writer, &image_info->windows_info);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (image_info->name) {
-               rc = xmlTextWriterWriteElement(writer, "NAME",
-                                              image_info->name);
-               if (rc < 0)
+               if (rc)
                        return rc;
        }
 
-       if (image_info->description) {
-               rc = xmlTextWriterWriteElement(writer, "DESCRIPTION",
-                                              image_info->description);
-               if (rc < 0)
-                       return rc;
-       }
-       if (image_info->display_name) {
-               rc = xmlTextWriterWriteElement(writer, "DISPLAYNAME",
-                                              image_info->display_name);
-               if (rc < 0)
-                       return rc;
-       }
-       if (image_info->display_description) {
-               rc = xmlTextWriterWriteElement(writer, "DISPLAYDESCRIPTION",
-                                              image_info->display_description);
-               if (rc < 0)
-                       return rc;
-       }
+       rc = xml_write_strings_from_specs(writer, image_info,
+                                         image_info_xml_string_specs,
+                                         ARRAY_LEN(image_info_xml_string_specs));
+       if (rc)
+               return rc;
 
-       if (image_info->flags) {
-               rc = xmlTextWriterWriteElement(writer, "FLAGS",
-                                              image_info->flags);
-               if (rc < 0)
-                       return rc;
-       }
+       rc = xmlTextWriterEndElement(writer); /* </IMAGE> */
+       if (rc < 0)
+               return rc;
 
-       return xmlTextWriterEndElement(writer); /* </IMAGE> */
+       return 0;
 }
 
 
 
 /* Makes space for another image in the XML information and return a pointer to
  * it.*/
-static struct image_info *add_image_info_struct(struct wim_info *wim_info)
+static struct image_info *
+add_image_info_struct(struct wim_info *wim_info)
 {
        struct image_info *images;
 
@@ -798,40 +928,33 @@ static struct image_info *add_image_info_struct(struct wim_info *wim_info)
        return &images[wim_info->num_images - 1];
 }
 
-static int clone_windows_info(const struct windows_info *old,
-                             struct windows_info *new)
+static int
+clone_windows_info(const struct windows_info *old, struct windows_info *new)
 {
-       if (old->product_name && !(new->product_name = STRDUP(old->product_name)))
-               return WIMLIB_ERR_NOMEM;
-       if (old->edition_id && !(new->edition_id = STRDUP(old->edition_id)))
-               return WIMLIB_ERR_NOMEM;
-       if (old->installation_type && !(new->installation_type =
-                                       STRDUP(old->installation_type)))
-               return WIMLIB_ERR_NOMEM;
-       if (old->hal && !(new->hal = STRDUP(old->hal)))
-               return WIMLIB_ERR_NOMEM;
-       if (old->product_type && !(new->product_type = STRDUP(old->product_type)))
-               return WIMLIB_ERR_NOMEM;
-       if (old->product_suite && !(new->product_suite = STRDUP(old->product_suite)))
-               return WIMLIB_ERR_NOMEM;
+       int ret;
+
+       ret = dup_strings_from_specs(old, new, windows_info_xml_string_specs,
+                                    ARRAY_LEN(windows_info_xml_string_specs));
+       if (ret)
+               return ret;
 
        if (old->languages) {
-               new->languages = CALLOC(old->num_languages, sizeof(char*));
+               new->languages = CALLOC(old->num_languages, sizeof(new->languages[0]));
                if (!new->languages)
                        return WIMLIB_ERR_NOMEM;
                new->num_languages = old->num_languages;
                for (size_t i = 0; i < new->num_languages; i++) {
                        if (!old->languages[i])
                                continue;
-                       new->languages[i] = STRDUP(old->languages[i]);
+                       new->languages[i] = TSTRDUP(old->languages[i]);
                        if (!new->languages[i])
                                return WIMLIB_ERR_NOMEM;
                }
        }
        if (old->default_language &&
-                       !(new->default_language = STRDUP(old->default_language)))
+                       !(new->default_language = TSTRDUP(old->default_language)))
                return WIMLIB_ERR_NOMEM;
-       if (old->system_root && !(new->system_root = STRDUP(old->system_root)))
+       if (old->system_root && !(new->system_root = TSTRDUP(old->system_root)))
                return WIMLIB_ERR_NOMEM;
        if (old->windows_version_exists) {
                new->windows_version_exists = true;
@@ -841,8 +964,11 @@ static int clone_windows_info(const struct windows_info *old,
        return 0;
 }
 
-static int clone_image_info(const struct image_info *old, struct image_info *new)
+static int
+clone_image_info(const struct image_info *old, struct image_info *new)
 {
+       int ret;
+
        new->dir_count              = old->dir_count;
        new->file_count             = old->file_count;
        new->total_bytes            = old->total_bytes;
@@ -850,29 +976,18 @@ static int clone_image_info(const struct image_info *old, struct image_info *new
        new->creation_time          = old->creation_time;
        new->last_modification_time = old->last_modification_time;
 
-       if (!(new->name = STRDUP(old->name)))
-               return WIMLIB_ERR_NOMEM;
-
-       if (old->description)
-               if (!(new->description = STRDUP(old->description)))
-                       return WIMLIB_ERR_NOMEM;
-
-       if (old->display_name)
-               if (!(new->display_name = STRDUP(old->display_name)))
-                       return WIMLIB_ERR_NOMEM;
-
-       if (old->display_description)
-               if (!(new->display_description = STRDUP(old->display_description)))
-                       return WIMLIB_ERR_NOMEM;
-
-       if (old->flags)
-               if (!(new->flags = STRDUP(old->flags)))
-                       return WIMLIB_ERR_NOMEM;
+       ret = dup_strings_from_specs(old, new,
+                                    image_info_xml_string_specs,
+                                    ARRAY_LEN(image_info_xml_string_specs));
+       if (ret)
+               return ret;
 
        if (old->windows_info_exists) {
                new->windows_info_exists = true;
-               return clone_windows_info(&old->windows_info,
-                                         &new->windows_info);
+               ret = clone_windows_info(&old->windows_info,
+                                        &new->windows_info);
+               if (ret)
+                       return ret;
        }
        return 0;
 }
@@ -886,11 +1001,12 @@ static int clone_image_info(const struct image_info *old, struct image_info *new
  * On failure, WIMLIB_ERR_NOMEM is returned and no changes are made.  Otherwise,
  * 0 is returned and the WIM information at *new_wim_info_p is modified.
  */
-int xml_export_image(const struct wim_info *old_wim_info,
-                    int image,
-                    struct wim_info **new_wim_info_p,
-                    const char *dest_image_name,
-                    const char *dest_image_description)
+int
+xml_export_image(const struct wim_info *old_wim_info,
+                int image,
+                struct wim_info **new_wim_info_p,
+                const tchar *dest_image_name,
+                const tchar *dest_image_description)
 {
        struct wim_info *new_wim_info;
        struct image_info *image_info;
@@ -921,13 +1037,13 @@ int xml_export_image(const struct wim_info *old_wim_info,
 
        if (dest_image_name) {
                FREE(image_info->name);
-               image_info->name = STRDUP(dest_image_name);
+               image_info->name = TSTRDUP(dest_image_name);
                if (!image_info->name)
                        goto err_destroy_image_info;
        }
        if (dest_image_description) {
                FREE(image_info->description);
-               image_info->description = STRDUP(dest_image_description);
+               image_info->description = TSTRDUP(dest_image_description);
                if (!image_info->description)
                        goto err_destroy_image_info;
        }
@@ -942,19 +1058,20 @@ err:
 }
 
 /* Removes an image from the XML information. */
-void xml_delete_image(struct wim_info **wim_info_p, int image)
+void
+xml_delete_image(struct wim_info **wim_info_p, int image)
 {
        struct wim_info *wim_info;
 
-       DEBUG("Deleting image %d from the XML data.", image);
-
        wim_info = *wim_info_p;
+       wimlib_assert(image >= 1 && image <= wim_info->num_images);
+       DEBUG("Deleting image %d from the XML data.", image);
 
        destroy_image_info(&wim_info->images[image - 1]);
 
-       memcpy(&wim_info->images[image - 1],
-              &wim_info->images[image],
-              (wim_info->num_images - image) * sizeof(struct image_info));
+       memmove(&wim_info->images[image - 1],
+               &wim_info->images[image],
+               (wim_info->num_images - image) * sizeof(struct image_info));
 
        if (--wim_info->num_images == 0) {
                free_wim_info(wim_info);
@@ -965,35 +1082,31 @@ void xml_delete_image(struct wim_info **wim_info_p, int image)
        }
 }
 
-size_t xml_get_max_image_name_len(const WIMStruct *w)
+size_t
+xml_get_max_image_name_len(const WIMStruct *wim)
 {
        size_t max_len = 0;
-       if (w->wim_info) {
-               size_t len;
-               for (int i = 0; i < w->wim_info->num_images; i++) {
-                       len = strlen(w->wim_info->images[i].name);
-                       if (len > max_len)
-                               max_len = len;
-               }
-       }
+       for (u32 i = 0; i < wim->hdr.image_count; i++)
+               max_len = max(max_len, tstrlen(wim->wim_info->images[i].name));
        return max_len;
 }
 
 #ifdef ENABLE_CUSTOM_MEMORY_ALLOCATOR
-void xml_set_memory_allocator(void *(*malloc_func)(size_t),
-                                  void (*free_func)(void *),
-                                  void *(*realloc_func)(void *, size_t))
+void
+xml_set_memory_allocator(void *(*malloc_func)(size_t),
+                        void (*free_func)(void *),
+                        void *(*realloc_func)(void *, size_t))
 {
        xmlMemSetup(free_func, malloc_func, realloc_func, STRDUP);
 }
 #endif
 
-static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
+static int
+calculate_dentry_statistics(struct wim_dentry *dentry, void *arg)
 {
        struct image_info *info = arg;
-       struct lookup_table *lookup_table = info->lookup_table;
-       const struct inode *inode = dentry->d_inode;
-       struct lookup_table_entry *lte;
+       const struct wim_inode *inode = dentry->d_inode;
+       struct wim_lookup_table_entry *lte;
 
        /* Update directory count and file count.
         *
@@ -1045,12 +1158,12 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
                        info->hard_link_bytes += wim_resource_size(lte);
        }
 
-       if (inode->link_count >= 2 && dentry_is_first_in_inode(dentry)) {
-               for (unsigned i = 0; i < inode->num_ads; i++) {
-                       if (inode->ads_entries[i].stream_name_len) {
-                               lte = inode_stream_lte(inode, i + 1, lookup_table);
+       if (inode->i_nlink >= 2 && dentry_is_first_in_inode(dentry)) {
+               for (unsigned i = 0; i < inode->i_num_ads; i++) {
+                       if (inode->i_ads_entries[i].stream_name_nbytes) {
+                               lte = inode_stream_lte(inode, i + 1, info->lookup_table);
                                if (lte) {
-                                       info->hard_link_bytes += inode->link_count *
+                                       info->hard_link_bytes += inode->i_nlink *
                                                                 wim_resource_size(lte);
                                }
                        }
@@ -1066,31 +1179,30 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
  * Please note there is no official documentation for exactly how this is done.
  * But, see calculate_dentry_statistics().
  */
-void xml_update_image_info(WIMStruct *w, int image)
+void
+xml_update_image_info(WIMStruct *wim, int image)
 {
        struct image_info *image_info;
-       char *flags_save;
 
        DEBUG("Updating the image info for image %d", image);
 
-       image_info = &w->wim_info->images[image - 1];
+       image_info = &wim->wim_info->images[image - 1];
 
        image_info->file_count      = 0;
        image_info->dir_count       = 0;
        image_info->total_bytes     = 0;
        image_info->hard_link_bytes = 0;
+       image_info->lookup_table = wim->lookup_table;
 
-       flags_save = image_info->flags;
-       image_info->lookup_table = w->lookup_table;
-       for_dentry_in_tree(w->image_metadata[image - 1].root_dentry,
+       for_dentry_in_tree(wim->image_metadata[image - 1]->root_dentry,
                           calculate_dentry_statistics,
                           image_info);
-       image_info->flags = flags_save;
        image_info->last_modification_time = get_wim_timestamp();
 }
 
 /* Adds an image to the XML information. */
-int xml_add_image(WIMStruct *w, const char *name)
+int
+xml_add_image(WIMStruct *wim, const tchar *name)
 {
        struct wim_info *wim_info;
        struct image_info *image_info;
@@ -1099,8 +1211,8 @@ int xml_add_image(WIMStruct *w, const char *name)
 
        /* If this is the first image, allocate the struct wim_info.  Otherwise
         * use the existing struct wim_info. */
-       if (w->wim_info) {
-               wim_info = w->wim_info;
+       if (wim->wim_info) {
+               wim_info = wim->wim_info;
        } else {
                wim_info = CALLOC(1, sizeof(struct wim_info));
                if (!wim_info)
@@ -1111,416 +1223,462 @@ int xml_add_image(WIMStruct *w, const char *name)
        if (!image_info)
                goto out_free_wim_info;
 
-       if (!(image_info->name = STRDUP(name)))
+       if (!(image_info->name = TSTRDUP(name)))
                goto out_destroy_image_info;
 
-       w->wim_info = wim_info;
+       wim->wim_info = wim_info;
        image_info->index = wim_info->num_images;
        image_info->creation_time = get_wim_timestamp();
-       xml_update_image_info(w, image_info->index);
+       xml_update_image_info(wim, image_info->index);
        return 0;
 
 out_destroy_image_info:
        destroy_image_info(image_info);
        wim_info->num_images--;
 out_free_wim_info:
-       if (wim_info != w->wim_info)
+       if (wim_info != wim->wim_info)
                FREE(wim_info);
        return WIMLIB_ERR_NOMEM;
 }
 
 /* Prints information about the specified image from struct wim_info structure.
  * */
-void print_image_info(const struct wim_info *wim_info, int image)
+void
+print_image_info(const struct wim_info *wim_info, int image)
 {
        const struct image_info *image_info;
-       const char *desc;
-       char buf[50];
+       const tchar *desc;
+       tchar buf[50];
 
        wimlib_assert(image >= 1 && image <= wim_info->num_images);
 
        image_info = &wim_info->images[image - 1];
 
-       printf("Index:                  %d\n", image_info->index);
-       printf("Name:                   %s\n", image_info->name);
+       tprintf(T("Index:                  %d\n"), image_info->index);
+       tprintf(T("Name:                   %"TS"\n"), image_info->name);
 
        /* Always print the Description: part even if there is no
         * description. */
        if (image_info->description)
                desc = image_info->description;
        else
-               desc = "";
-       printf("Description:            %s\n", desc);
+               desc = T("");
+       tprintf(T("Description:            %"TS"\n"), desc);
 
-       if (image_info->display_name)
-               printf("Display Name:           %s\n",
-                      image_info->display_name);
+       if (image_info->display_name) {
+               tprintf(T("Display Name:           %"TS"\n"),
+                       image_info->display_name);
+       }
 
-       if (image_info->display_description)
-               printf("Display Description:    %s\n",
-                      image_info->display_description);
+       if (image_info->display_description) {
+               tprintf(T("Display Description:    %"TS"\n"),
+                       image_info->display_description);
+       }
 
-       printf("Directory Count:        %"PRIu64"\n", image_info->dir_count);
-       printf("File Count:             %"PRIu64"\n", image_info->file_count);
-       printf("Total Bytes:            %"PRIu64"\n", image_info->total_bytes);
-       printf("Hard Link Bytes:        %"PRIu64"\n", image_info->hard_link_bytes);
+       tprintf(T("Directory Count:        %"PRIu64"\n"), image_info->dir_count);
+       tprintf(T("File Count:             %"PRIu64"\n"), image_info->file_count);
+       tprintf(T("Total Bytes:            %"PRIu64"\n"), image_info->total_bytes);
+       tprintf(T("Hard Link Bytes:        %"PRIu64"\n"), image_info->hard_link_bytes);
 
        wim_timestamp_to_str(image_info->creation_time, buf, sizeof(buf));
-       printf("Creation Time:          %s\n", buf);
+       tprintf(T("Creation Time:          %"TS"\n"), buf);
 
-       wim_timestamp_to_str(image_info->creation_time, buf, sizeof(buf));
-       printf("Last Modification Time: %s\n", buf);
+       wim_timestamp_to_str(image_info->last_modification_time, buf, sizeof(buf));
+       tprintf(T("Last Modification Time: %"TS"\n"), buf);
        if (image_info->windows_info_exists)
                print_windows_info(&image_info->windows_info);
        if (image_info->flags)
-               printf("Flags:                  %s\n", image_info->flags);
-       putchar('\n');
+               tprintf(T("Flags:                  %"TS"\n"), image_info->flags);
+       tputchar('\n');
 }
 
-/*
- * Reads the XML data from a WIM file.
- */
-int read_xml_data(FILE *fp, const struct resource_entry *res_entry,
-                 u8 **xml_data_ret, struct wim_info **info_ret)
+void
+libxml_global_init(void)
+{
+       xmlInitParser();
+       xmlInitCharEncodingHandlers();
+}
+
+void
+libxml_global_cleanup(void)
+{
+       xmlCleanupParser();
+       xmlCleanupCharEncodingHandlers();
+}
+
+/* Reads the XML data from a WIM file.  */
+int
+read_wim_xml_data(WIMStruct *wim)
 {
+       void *buf;
        u8 *xml_data;
        xmlDoc *doc;
        xmlNode *root;
        int ret;
+       const struct resource_entry *res_entry;
 
-       DEBUG("XML data is %"PRIu64" bytes at offset %"PRIu64"",
-             (u64)res_entry->size, res_entry->offset);
-
-       if (resource_is_compressed(res_entry)) {
-               ERROR("XML data is supposed to be uncompressed");
-               ret = WIMLIB_ERR_XML;
-               goto out_cleanup_parser;
-       }
-
-       if (res_entry->size < 2) {
-               ERROR("XML data must be at least 2 bytes long");
-               ret = WIMLIB_ERR_XML;
-               goto out_cleanup_parser;
-       }
-
-       xml_data = MALLOC(res_entry->size + 2);
-       if (!xml_data) {
-               ret = WIMLIB_ERR_NOMEM;
-               goto out_cleanup_parser;
-       }
-
-       ret = read_uncompressed_resource(fp, res_entry->offset,
-                                        res_entry->size, xml_data);
-       if (ret != 0)
-               goto out_free_xml_data;
-
-       /* Null-terminate just in case */
-       xml_data[res_entry->size] = 0;
-       xml_data[res_entry->size + 1] = 0;
+       res_entry = &wim->hdr.xml_res_entry;
 
-       DEBUG("Parsing XML using libxml2 to create XML tree");
+       DEBUG("Reading XML data: %"PRIu64" bytes at offset %"PRIu64"",
+             (u64)res_entry->size, res_entry->offset);
 
-       doc = xmlReadMemory(xml_data, res_entry->size,
-                           "noname.xml", "UTF-16", 0);
+       ret = res_entry_to_data(res_entry, wim, &buf);
+       if (ret)
+               goto out;
+       xml_data = buf;
 
+       doc = xmlReadMemory((const char *)xml_data, res_entry->original_size,
+                           NULL, "UTF-16LE", 0);
        if (!doc) {
                ERROR("Failed to parse XML data");
                ret = WIMLIB_ERR_XML;
                goto out_free_xml_data;
        }
 
-       DEBUG("Constructing WIM information structure from XML tree.");
-
        root = xmlDocGetRootElement(doc);
-       if (!root) {
-               ERROR("WIM XML data is an empty XML document");
+       if (!root || !node_is_element(root) || !node_name_is(root, "WIM")) {
+               ERROR("WIM XML data is invalid");
                ret = WIMLIB_ERR_XML;
                goto out_free_doc;
        }
 
-       if (!node_is_element(root) || !node_name_is(root, "WIM")) {
-               ERROR("Expected <WIM> for the root XML element (found <%s>)",
-                     root->name);
-               ret = WIMLIB_ERR_XML;
-               goto out_free_doc;
-       }
-
-       ret = xml_read_wim_info(root, info_ret);
-       if (ret != 0)
-               goto out_free_doc;
-
-       DEBUG("Freeing XML tree.");
-
-       *xml_data_ret = xml_data;
-       xml_data = NULL;
+       ret = xml_read_wim_info(root, &wim->wim_info);
 out_free_doc:
        xmlFreeDoc(doc);
 out_free_xml_data:
        FREE(xml_data);
-out_cleanup_parser:
-       xmlCleanupParser();
+out:
        return ret;
 }
 
-#define CHECK_RET  ({  if (ret < 0)  { \
-                               ERROR("Error writing XML data"); \
-                               ret = WIMLIB_ERR_WRITE; \
-                               goto out_free_text_writer; \
-                       } })
-
-/*
- * Writes XML data to a WIM file.
+/* Prepares an in-memory buffer containing the UTF-16LE XML data for a WIM file.
  *
- * If @total_bytes is non-zero, it specifies what to write to the TOTALBYTES
- * element in the XML data.  If zero, TOTALBYTES is given the default value of
- * the offset of the XML data.
+ * total_bytes is the number to write in <TOTALBYTES>, or
+ * WIM_TOTALBYTES_USE_EXISTING to use the existing value in memory, or
+ * WIM_TOTALBYTES_OMIT to omit <TOTALBYTES> entirely.
  */
-int write_xml_data(const struct wim_info *wim_info, int image, FILE *out,
-                  u64 total_bytes, struct resource_entry *out_res_entry)
+static int
+prepare_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
+                    u8 **xml_data_ret, size_t *xml_len_ret)
 {
        xmlCharEncodingHandler *encoding_handler;
-       xmlOutputBuffer *out_buffer;
+       xmlBuffer *buf;
+       xmlOutputBuffer *outbuf;
        xmlTextWriter *writer;
        int ret;
-       off_t start_offset;
-       off_t end_offset;
-
-       wimlib_assert(image == WIMLIB_ALL_IMAGES ||
-                       (wim_info != NULL && image >= 1 &&
-                        image <= wim_info->num_images));
-
-       start_offset = ftello(out);
-       if (start_offset == -1)
-               return WIMLIB_ERR_WRITE;
-
-       DEBUG("Writing XML data for image %d at offset %"PRIu64,
-             image, start_offset);
-
-       /* 2 bytes endianness marker for UTF-16LE.  This is _required_ for WIM
-        * XML data. */
-       if ((putc(0xff, out)) == EOF || (putc(0xfe, out) == EOF)) {
-               ERROR_WITH_ERRNO("Error writing XML data");
-               return WIMLIB_ERR_WRITE;
-       }
-
-       /* The contents of the <TOTALBYTES> element in the XML data, under the
-        * <WIM> element (not the <IMAGE> element), is for non-split WIMs the
-        * size of the WIM file excluding the XML data and integrity table.
-        * This should be equal to the current position in the output stream,
-        * since the XML data and integrity table are the last elements of the
-        * WIM.
-        *
-        * For split WIMs, <TOTALBYTES> takes into account the entire WIM, not
-        * just the current part.  In that case, @total_bytes should be passed
-        * in to this function. */
-       if (total_bytes == 0)
-               total_bytes = start_offset;
+       int first, last;
+       const xmlChar *content;
+       int len;
+       u8 *xml_data;
+       size_t xml_len;
 
-       xmlInitCharEncodingHandlers();
+       /* Open an xmlTextWriter that writes to an in-memory buffer using
+        * UTF-16LE encoding.  */
 
-       /* The encoding of the XML data must be UTF-16LE. */
        encoding_handler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF16LE);
        if (!encoding_handler) {
                ERROR("Failed to get XML character encoding handler for UTF-16LE");
-               ret = WIMLIB_ERR_CHAR_CONVERSION;
-               goto out_cleanup_char_encoding_handlers;
+               ret = WIMLIB_ERR_LIBXML_UTF16_HANDLER_NOT_AVAILABLE;
+               goto out;
        }
 
-       out_buffer = xmlOutputBufferCreateFile(out, encoding_handler);
-       if (!out_buffer) {
+       buf = xmlBufferCreate();
+       if (!buf) {
+               ERROR("Failed to create xmlBuffer");
+               ret = WIMLIB_ERR_NOMEM;
+               goto out;
+       }
+
+       outbuf = xmlOutputBufferCreateBuffer(buf, encoding_handler);
+       if (!outbuf) {
                ERROR("Failed to allocate xmlOutputBuffer");
                ret = WIMLIB_ERR_NOMEM;
-               goto out_cleanup_char_encoding_handlers;
+               goto out_buffer_free;
        }
 
-       writer = xmlNewTextWriter(out_buffer);
+       writer = xmlNewTextWriter(outbuf);
        if (!writer) {
                ERROR("Failed to allocate xmlTextWriter");
                ret = WIMLIB_ERR_NOMEM;
                goto out_output_buffer_close;
        }
 
-       DEBUG("Writing <WIM> element");
+       /* Write the XML document.  */
 
        ret = xmlTextWriterStartElement(writer, "WIM");
-       CHECK_RET;
-
-       ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
-                                             total_bytes);
-       CHECK_RET;
-
-       if (wim_info != NULL) {
-               int first, last;
-               if (image == WIMLIB_ALL_IMAGES) {
-                       first = 1;
-                       last = wim_info->num_images;
-               } else {
-                       first = image;
-                       last = image;
+       if (ret < 0)
+               goto out_write_error;
+
+       /* The contents of the <TOTALBYTES> element in the XML data, under the
+        * <WIM> element (not the <IMAGE> element), is for non-split WIMs the
+        * size of the WIM file excluding the XML data and integrity table.
+        * For split WIMs, <TOTALBYTES> takes into account the entire WIM, not
+        * just the current part.  */
+       if (total_bytes != WIM_TOTALBYTES_OMIT) {
+               if (total_bytes == WIM_TOTALBYTES_USE_EXISTING) {
+                       if (wim->wim_info)
+                               total_bytes = wim->wim_info->total_bytes;
+                       else
+                               total_bytes = 0;
                }
-               DEBUG("Writing %d <IMAGE> elements", last - first + 1);
-               for (int i = first; i <= last; i++) {
-                       ret = xml_write_image_info(writer, &wim_info->images[i - 1]);
-                       CHECK_RET;
+               ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES",
+                                                     "%"PRIu64, total_bytes);
+               if (ret < 0)
+                       goto out_write_error;
+       }
+
+       if (image == WIMLIB_ALL_IMAGES) {
+               first = 1;
+               last = wim->hdr.image_count;
+       } else {
+               first = image;
+               last = image;
+       }
+
+       for (int i = first; i <= last; i++) {
+               ret = xml_write_image_info(writer, &wim->wim_info->images[i - 1]);
+               if (ret) {
+                       if (ret < 0)
+                               goto out_write_error;
+                       goto out_free_text_writer;
                }
        }
 
        ret = xmlTextWriterEndElement(writer);
-       CHECK_RET;
+       if (ret < 0)
+               goto out_write_error;
 
        ret = xmlTextWriterEndDocument(writer);
-       CHECK_RET;
+       if (ret < 0)
+               goto out_write_error;
 
-       DEBUG("Ended XML document");
+       ret = xmlTextWriterFlush(writer);
+       if (ret < 0)
+               goto out_write_error;
 
-       /* Call xmlFreeTextWriter() before ftello() because the former will
-        * flush the file stream. */
-       xmlFreeTextWriter(writer);
-       writer = NULL;
+       /* Retrieve the buffer into which the document was written.  */
 
-       end_offset = ftello(out);
-       if (end_offset == -1) {
-               ret = WIMLIB_ERR_WRITE;
-       } else {
-               ret = 0;
-               out_res_entry->offset        = start_offset;
-               out_res_entry->size          = end_offset - start_offset;
-               out_res_entry->original_size = end_offset - start_offset;
-               out_res_entry->flags         = WIM_RESHDR_FLAG_METADATA;
+       content = xmlBufferContent(buf);
+       len = xmlBufferLength(buf);
+
+       /* Copy the data into a new buffer, and prefix it with the UTF-16LE BOM
+        * (byte order mark), which is required by MS's software to understand
+        * the data.  */
+
+       xml_len = len + 2;
+       xml_data = MALLOC(xml_len);
+       if (!xml_data) {
+               ret = WIMLIB_ERR_NOMEM;
+               goto out_free_text_writer;
        }
+       xml_data[0] = 0xff;
+       xml_data[1] = 0xfe;
+       memcpy(&xml_data[2], content, len);
+
+       /* Clean up libxml objects and return success.  */
+       *xml_data_ret = xml_data;
+       *xml_len_ret = xml_len;
+       ret = 0;
 out_free_text_writer:
-       /* xmlFreeTextWriter will free the attached xmlOutputBuffer. */
+       /* xmlFreeTextWriter will free the attached xmlOutputBuffer.  */
        xmlFreeTextWriter(writer);
-       out_buffer = NULL;
+       goto out_buffer_free;
 out_output_buffer_close:
-       if (out_buffer != NULL)
-               xmlOutputBufferClose(out_buffer);
-out_cleanup_char_encoding_handlers:
-       xmlCleanupCharEncodingHandlers();
+       xmlOutputBufferClose(outbuf);
+out_buffer_free:
+       xmlBufferFree(buf);
 out:
-       if (ret == 0)
-               DEBUG("Successfully wrote XML data");
+       DEBUG("ret=%d", ret);
+       return ret;
+
+out_write_error:
+       ERROR("Error writing XML data");
+       ret = WIMLIB_ERR_WRITE;
+       goto out_free_text_writer;
+}
+
+/* Writes the XML data to a WIM file.  */
+int
+write_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
+                  struct resource_entry *out_res_entry,
+                  int write_resource_flags)
+{
+       int ret;
+       u8 *xml_data;
+       size_t xml_len;
+
+       DEBUG("Writing WIM XML data (image=%d, offset=%"PRIu64")",
+             image, total_bytes, wim->out_fd.offset);
+
+       ret = prepare_wim_xml_data(wim, image, total_bytes,
+                                  &xml_data, &xml_len);
+       if (ret)
+               return ret;
+
+       /* Write the XML data uncompressed.  Although wimlib can handle
+        * compressed XML data, MS software cannot.  */
+       ret = write_wim_resource_from_buffer(xml_data,
+                                            xml_len,
+                                            WIM_RESHDR_FLAG_METADATA,
+                                            &wim->out_fd,
+                                            WIMLIB_COMPRESSION_TYPE_NONE,
+                                            out_res_entry,
+                                            NULL,
+                                            write_resource_flags,
+                                            &wim->lzx_context);
+       FREE(xml_data);
+       DEBUG("ret=%d");
        return ret;
 }
 
-/* Returns the name of the specified image. */
-WIMLIBAPI const char *wimlib_get_image_name(const WIMStruct *w, int image)
+/* API function documented in wimlib.h  */
+WIMLIBAPI const tchar *
+wimlib_get_image_name(const WIMStruct *wim, int image)
 {
-       if (image < 1 || image > w->hdr.image_count)
+       if (image < 1 || image > wim->hdr.image_count)
                return NULL;
-       return w->wim_info->images[image - 1].name;
+       return wim->wim_info->images[image - 1].name;
 }
 
-/* Returns the description of the specified image. */
-WIMLIBAPI const char *wimlib_get_image_description(const WIMStruct *w,
-                                                  int image)
+/* API function documented in wimlib.h  */
+WIMLIBAPI const tchar *
+wimlib_get_image_description(const WIMStruct *wim, int image)
 {
-       if (image < 1 || image > w->hdr.image_count)
+       if (image < 1 || image > wim->hdr.image_count)
                return NULL;
-       return w->wim_info->images[image - 1].description;
+       return wim->wim_info->images[image - 1].description;
 }
 
-/* Determines if an image name is already used by some image in the WIM. */
-WIMLIBAPI bool wimlib_image_name_in_use(const WIMStruct *w, const char *name)
+/* API function documented in wimlib.h  */
+WIMLIBAPI bool
+wimlib_image_name_in_use(const WIMStruct *wim, const tchar *name)
 {
        if (!name || !*name)
                return false;
-       for (int i = 1; i <= w->hdr.image_count; i++)
-               if (strcmp(w->wim_info->images[i - 1].name, name) == 0)
+       for (int i = 1; i <= wim->hdr.image_count; i++)
+               if (!tstrcmp(wim->wim_info->images[i - 1].name, name))
                        return true;
        return false;
 }
 
-/* Extracts the raw XML data to a file stream. */
-WIMLIBAPI int wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
+
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_get_xml_data(WIMStruct *wim, void **buf_ret, size_t *bufsize_ret)
 {
-       if (!w->xml_data)
+       if (wim->filename == NULL)
                return WIMLIB_ERR_INVALID_PARAM;
-       if (fwrite(w->xml_data, 1, w->hdr.xml_res_entry.size, fp) !=
-                       w->hdr.xml_res_entry.size) {
+
+       if (buf_ret == NULL || bufsize_ret == NULL)
+               return WIMLIB_ERR_INVALID_PARAM;
+
+       *bufsize_ret = wim->hdr.xml_res_entry.original_size;
+       return res_entry_to_data(&wim->hdr.xml_res_entry, wim, buf_ret);
+}
+
+WIMLIBAPI int
+wimlib_extract_xml_data(WIMStruct *wim, FILE *fp)
+{
+       int ret;
+       void *buf;
+       size_t bufsize;
+
+       ret = wimlib_get_xml_data(wim, &buf, &bufsize);
+       if (ret)
+               return ret;
+
+       if (fwrite(buf, 1, bufsize, fp) != bufsize) {
                ERROR_WITH_ERRNO("Failed to extract XML data");
-               return WIMLIB_ERR_WRITE;
+               ret = WIMLIB_ERR_WRITE;
        }
-       return 0;
+       FREE(buf);
+       return ret;
 }
 
-/* Sets the name of an image in the WIM. */
-WIMLIBAPI int wimlib_set_image_name(WIMStruct *w, int image, const char *name)
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_set_image_name(WIMStruct *wim, int image, const tchar *name)
 {
-       char *p;
+       tchar *p;
        int i;
+       int ret;
 
-       DEBUG("Setting the name of image %d to %s", image, name);
+       DEBUG("Setting the name of image %d to %"TS, image, name);
 
-       if (!name || !*name) {
-               ERROR("Must specify a non-empty string for the image name");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
+       ret = can_modify_wim(wim);
+       if (ret)
+               return ret;
+
+       if (name == NULL)
+               name = T("");
 
-       if (image < 1 || image > w->hdr.image_count) {
+       if (image < 1 || image > wim->hdr.image_count) {
                ERROR("%d is not a valid image", image);
                return WIMLIB_ERR_INVALID_IMAGE;
        }
 
-       for (i = 1; i <= w->hdr.image_count; i++) {
+       for (i = 1; i <= wim->hdr.image_count; i++) {
                if (i == image)
                        continue;
-               if (strcmp(w->wim_info->images[i - 1].name, name) == 0) {
-                       ERROR("The name `%s' is already used for image %d",
-                             name, i);
+               if (!tstrcmp(wim->wim_info->images[i - 1].name, name)) {
+                       ERROR("The name \"%"TS"\" is already in use in the WIM!",
+                             name);
                        return WIMLIB_ERR_IMAGE_NAME_COLLISION;
                }
        }
 
-       p = STRDUP(name);
+       p = TSTRDUP(name);
        if (!p)
                return WIMLIB_ERR_NOMEM;
 
-       FREE(w->wim_info->images[image - 1].name);
-       w->wim_info->images[image - 1].name = p;
+       FREE(wim->wim_info->images[image - 1].name);
+       wim->wim_info->images[image - 1].name = p;
        return 0;
 }
 
-/* Sets the description of an image in the WIM. */
-WIMLIBAPI int wimlib_set_image_descripton(WIMStruct *w, int image,
-                                         const char *description)
+static int
+do_set_image_info_str(WIMStruct *wim, int image, const tchar *tstr,
+                     size_t offset)
 {
-       char *p;
+       tchar *tstr_copy;
+       tchar **dest_tstr_p;
+       int ret;
 
-       if (image < 1 || image > w->hdr.image_count) {
+       ret = can_modify_wim(wim);
+       if (ret)
+               return ret;
+
+       if (image < 1 || image > wim->hdr.image_count) {
                ERROR("%d is not a valid image", image);
                return WIMLIB_ERR_INVALID_IMAGE;
        }
-       if (description) {
-               p = STRDUP(description);
-               if (!p)
+       if (tstr) {
+               tstr_copy = TSTRDUP(tstr);
+               if (!tstr_copy)
                        return WIMLIB_ERR_NOMEM;
        } else {
-               p = NULL;
+               tstr_copy = NULL;
        }
-       FREE(w->wim_info->images[image - 1].description);
-       w->wim_info->images[image - 1].description = p;
+       dest_tstr_p = (tchar**)((void*)&wim->wim_info->images[image - 1] + offset);
+
+       FREE(*dest_tstr_p);
+       *dest_tstr_p = tstr_copy;
        return 0;
 }
 
-/* Set the <FLAGS> element of a WIM image */
-WIMLIBAPI int wimlib_set_image_flags(WIMStruct *w, int image,
-                                    const char *flags)
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_set_image_descripton(WIMStruct *wim, int image,
+                           const tchar *description)
 {
-       char *p;
+       return do_set_image_info_str(wim, image, description,
+                                    offsetof(struct image_info, description));
+}
 
-       if (image < 1 || image > w->hdr.image_count) {
-               ERROR("%d is not a valid image", image);
-               return WIMLIB_ERR_INVALID_IMAGE;
-       }
-       if (flags) {
-               p = STRDUP(flags);
-               if (!p)
-                       return WIMLIB_ERR_NOMEM;
-       } else {
-               p = NULL;
-       }
-       FREE(w->wim_info->images[image - 1].flags);
-       w->wim_info->images[image - 1].flags = p;
-       return 0;
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_set_image_flags(WIMStruct *wim, int image, const tchar *flags)
+{
+       return do_set_image_info_str(wim, image, flags,
+                                    offsetof(struct image_info, flags));
 }