Add wimlib_get_xml_data() API
[wimlib] / src / xml.c
index c377283..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 "wimlib_internal.h"
-#include "dentry.h"
-#include "xml.h"
-#include "timestamp.h"
-#include "lookup_table.h"
-#include <string.h>
-#include <time.h>
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#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 <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). */
@@ -46,58 +57,145 @@ 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;
-       u64    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 {
-       u64   index;
-       u64   dir_count;
-       u64   file_count;
-       u64   total_bytes;
-       u64   hard_link_bytes;
-       u64   creation_time;
-       u64   last_modification_time;
-       bool  windows_info_exists;
+       int index;
+       bool windows_info_exists;
+       u64 dir_count;
+       u64 file_count;
+       u64 total_bytes;
+       u64 hard_link_bytes;
+       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");
        }
 }
 
@@ -107,71 +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_is_attribute(xmlNode *node)
-{
-       return node->type == XML_ATTRIBUTE_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) {
-                               ERROR("Out of memory");
-                               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;
@@ -188,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)
 {
-       u64 index_1 = ((struct image_info*)p1)->index;
-       u64 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)
@@ -202,22 +304,25 @@ 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)
 {
-       uint i;
-
        FREE(windows_info->product_name);
        FREE(windows_info->edition_id);
        FREE(windows_info->installation_type);
+       FREE(windows_info->hal);
        FREE(windows_info->product_type);
-       for (i = 0; i < windows_info->num_languages; i++)
+       FREE(windows_info->product_suite);
+       for (size_t i = 0; i < windows_info->num_languages; i++)
                FREE(windows_info->languages[i]);
        FREE(windows_info->languages);
+       FREE(windows_info->default_language);
        FREE(windows_info->system_root);
 }
 
 /* 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);
@@ -228,12 +333,12 @@ 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)
 {
-       uint i;
        if (info) {
                if (info->images) {
-                       for (i = 0; i < info->num_images; i++)
+                       for (int i = 0; i < info->num_images; i++)
                                destroy_image_info(&info->images[i]);
                        FREE(info->images);
                }
@@ -243,19 +348,20 @@ 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) {
                if (!node_is_element(child))
                        continue;
                if (node_name_is(child, "MAJOR"))
-                       windows_version->major    = node_get_u64(child);
+                       windows_version->major = node_get_u64(child);
                else if (node_name_is(child, "MINOR"))
-                       windows_version->minor    = node_get_u64(child);
+                       windows_version->minor = node_get_u64(child);
                else if (node_name_is(child, "BUILD"))
-                       windows_version->build    = node_get_u64(child);
+                       windows_version->build = node_get_u64(child);
                else if (node_name_is(child, "SPBUILD"))
                        windows_version->sp_build = node_get_u64(child);
                else if (node_name_is(child, "SPLEVEL"))
@@ -265,49 +371,46 @@ 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, 
-                             u64 *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;
-       uint i;
-       uint num_languages;
-       char **languages;
+       size_t num_languages = 0;
+       tchar **languages;
        int ret;
 
-       num_languages = 0;
        for_node_child(languages_node, child)
                if (node_is_element(child) && node_name_is(child, "LANGUAGE"))
                        num_languages++;
 
-       languages = CALLOC(num_languages, sizeof(char*));
-       if (!languages) {
-               ERROR("Out of memory");
+       languages = CALLOC(num_languages, sizeof(languages[0]));
+       if (!languages)
                return WIMLIB_ERR_NOMEM;
-       }
 
        *languages_ret = languages;
        *num_languages_ret = num_languages;
 
-       i = 0;
        ret = 0;
        for_node_child(languages_node, child) {
                if (!node_is_element(child))
                        continue;
                if (node_name_is(child, "LANGUAGE"))
-                       ret = node_get_string(child, &languages[i++]);
+                       ret = node_get_string(child, languages++);
                else if (node_name_is(child, "DEFAULT"))
                        ret = node_get_string(child, default_language_ret);
                if (ret != 0)
-                       return ret;
+                       break;
        }
        return ret;
 }
 
 /* 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;
@@ -318,27 +421,27 @@ static int xml_read_windows_info(const xmlNode *windows_node,
                if (node_name_is(child, "ARCH")) {
                        windows_info->arch = node_get_u64(child);
                } else if (node_name_is(child, "PRODUCTNAME")) {
-                       ret = node_get_string(child, 
+                       ret = node_get_string(child,
                                              &windows_info->product_name);
                } else if (node_name_is(child, "EDITIONID")) {
-                       ret = node_get_string(child, 
+                       ret = node_get_string(child,
                                              &windows_info->edition_id);
                } else if (node_name_is(child, "INSTALLATIONTYPE")) {
-                       ret = node_get_string(child, 
+                       ret = node_get_string(child,
                                              &windows_info->installation_type);
                } else if (node_name_is(child, "PRODUCTTYPE")) {
-                       ret = node_get_string(child, 
+                       ret = node_get_string(child,
                                              &windows_info->product_type);
                } else if (node_name_is(child, "PRODUCTSUITE")) {
-                       ret = node_get_string(child, 
+                       ret = node_get_string(child,
                                              &windows_info->product_suite);
                } else if (node_name_is(child, "LANGUAGES")) {
-                       ret = xml_read_languages(child, 
+                       ret = xml_read_languages(child,
                                                 &windows_info->languages,
                                                 &windows_info->num_languages,
                                                 &windows_info->default_language);
                } else if (node_name_is(child, "VERSION")) {
-                       xml_read_windows_version(child, 
+                       xml_read_windows_version(child,
                                                &windows_info->windows_version);
                        windows_info->windows_version_exists = true;
                } else if (node_name_is(child, "SYSTEMROOT")) {
@@ -346,7 +449,6 @@ static int xml_read_windows_info(const xmlNode *windows_node,
                } else if (node_name_is(child, "HAL")) {
                        ret = node_get_string(child, &windows_info->hal);
                }
-
                if (ret != 0)
                        return ret;
        }
@@ -354,20 +456,19 @@ 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;
        int ret;
-       
+
        index_prop = xmlGetProp(image_node, "INDEX");
        if (index_prop) {
-               char *tmp;
-               image_info->index = strtoul(index_prop, &tmp, 10);
+               image_info->index = atoi(index_prop);
                FREE(index_prop);
        } else {
-               image_info->index = 0;
+               image_info->index = 1;
        }
 
        ret = 0;
@@ -406,70 +507,82 @@ static int xml_read_image_info(xmlNode *image_node,
                        return ret;
        }
        if (!image_info->name) {
-               WARNING("Image with index %"PRIu64" has no name",
-                       image_info->index);
-               image_info->name = MALLOC(1);
-               if (!image_info->name) {
-                       ERROR("Out of memory");
+               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;
-               }
-               image_info->name[0] = '\0';
+               *empty_name = T('\0');
+               image_info->name = empty_name;
        }
        return ret;
 }
 
 /* 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;
        int ret;
-       uint num_images;
-       struct image_info *cur_image_info;
+       int num_images;
+       int i;
 
        wim_info = CALLOC(1, sizeof(struct wim_info));
-       if (!wim_info) {
-               ERROR("Out of memory");
+       if (!wim_info)
                return WIMLIB_ERR_NOMEM;
-       }
 
        /* Count how many images there are. */
        num_images = 0;
-       for_node_child(wim_node, child)
-               if (node_is_element(child) && node_name_is(child, "IMAGE"))
+       for_node_child(wim_node, child) {
+               if (node_is_element(child) && node_name_is(child, "IMAGE")) {
+                       if (num_images == INT_MAX) {
+                               return WIMLIB_ERR_IMAGE_COUNT;
+                       }
                        num_images++;
+               }
+       }
 
-       if (num_images == 0)
-               goto done;
+       if (num_images > 0) {
+               /* Allocate the array of struct image_infos and fill them in. */
+               wim_info->images = CALLOC(num_images, sizeof(wim_info->images[0]));
+               if (!wim_info->images) {
+                       ret = WIMLIB_ERR_NOMEM;
+                       goto err;
+               }
+               wim_info->num_images = num_images;
+               i = 0;
+               for_node_child(wim_node, child) {
+                       if (!node_is_element(child))
+                               continue;
+                       if (node_name_is(child, "IMAGE")) {
+                               DEBUG("Found <IMAGE> tag");
+                               ret = xml_read_image_info(child,
+                                                         &wim_info->images[i]);
+                               if (ret != 0)
+                                       goto err;
+                               i++;
+                       } else if (node_name_is(child, "TOTALBYTES")) {
+                               wim_info->total_bytes = node_get_u64(child);
+                       }
+               }
 
-       /* Allocate the array of struct image_infos and fill them in. */
-       wim_info->images = CALLOC(num_images, sizeof(wim_info->images[0]));
-       if (!wim_info->images) {
-               ret = WIMLIB_ERR_NOMEM;
-               ERROR("Out of memory!");
-               goto err;
-       }
-       wim_info->num_images = num_images;
-       cur_image_info = wim_info->images;
-       for_node_child(wim_node, child) {
-               if (!node_is_element(child))
-                       continue;
-               if (node_name_is(child, "IMAGE")) {
-                       DEBUG("Found <IMAGE> tag");
-                       ret = xml_read_image_info(child, cur_image_info++);
-                       if (ret != 0)
-                               goto err;
-               } else if (node_name_is(child, "TOTALBYTES")) {
-                       wim_info->total_bytes = node_get_u64(child);
+               /* Sort the array of image info by image index. */
+               qsort(wim_info->images, num_images,
+                     sizeof(struct image_info), sort_by_index);
+
+               /* Make sure the image indices make sense */
+               for (i = 0; i < num_images; i++) {
+                       if (wim_info->images[i].index != i + 1) {
+                               ERROR("WIM images are not indexed [1...%d] "
+                                     "in XML data as expected",
+                                     num_images);
+                               return WIMLIB_ERR_IMAGE_COUNT;
+                       }
                }
-       }
 
-       /* Sort the array of struct image_infos by image index. */
-       qsort(wim_info->images, wim_info->num_images, 
-             sizeof(struct image_info), sort_by_index);
-done:
+       }
        *wim_info_ret = wim_info;
        return 0;
 err:
@@ -477,163 +590,213 @@ err:
        return ret;
 }
 
-/* Prints the information contained in a struct windows_info structure. */
-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)
 {
-       uint i;
        const struct windows_version *windows_version;
 
-       printf("Architecture:           %s\n", get_arch(windows_info->arch));
-       printf("Product Name:           %s\n", windows_info->product_name);
-       printf("Edition ID:             %s\n", windows_info->edition_id);
-       printf("Installation Type:      %s\n", windows_info->installation_type);
-       if (windows_info->hal)
-               printf("HAL:                    %s\n", windows_info->hal);
-       printf("Product Type:           %s\n", windows_info->product_type);
-       if (windows_info->product_suite)
-               printf("Product Suite:          %s\n", windows_info->product_suite);
-       printf("Languages:              ");
-       for (i = 0; i < windows_info->num_languages; i++) {
-               fputs(windows_info->languages[i], stdout);
-               putchar(' ');
+       tprintf(T("Architecture:           %"TS"\n"),
+               get_arch(windows_info->arch));
+
+       if (windows_info->product_name) {
+               tprintf(T("Product Name:           %"TS"\n"),
+                       windows_info->product_name);
        }
-       putchar('\n');
-       printf("Default Language:       %s\n", windows_info->default_language);
-       printf("System Root:            %s\n", windows_info->system_root);
+
+       if (windows_info->edition_id) {
+               tprintf(T("Edition ID:             %"TS"\n"),
+                       windows_info->edition_id);
+       }
+
+       if (windows_info->installation_type) {
+               tprintf(T("Installation Type:      %"TS"\n"),
+                       windows_info->installation_type);
+       }
+
+       if (windows_info->hal) {
+               tprintf(T("HAL:                    %"TS"\n"),
+                             windows_info->hal);
+       }
+
+       if (windows_info->product_type) {
+               tprintf(T("Product Type:           %"TS"\n"),
+                       windows_info->product_type);
+       }
+
+       if (windows_info->product_suite) {
+               tprintf(T("Product Suite:          %"TS"\n"),
+                       windows_info->product_suite);
+       }
+
+       tprintf(T("Languages:              "));
+       for (size_t i = 0; i < windows_info->num_languages; i++) {
+
+               tfputs(windows_info->languages[i], stdout);
+               tputchar(T(' '));
+       }
+       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;
+}
 
-/* Writes the information contained in a struct windows_version structure to the XML
- * document being constructed in memory.  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_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)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, "VERSION");
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "MAJOR", "%"PRIu64, 
-                                                               version->major);
+       rc = xmlTextWriterWriteFormatElement(writer, "MAJOR", "%"PRIu64,
+                                            version->major);
+       if (rc < 0)
+               return rc;
+
+       rc = xmlTextWriterWriteFormatElement(writer, "MINOR", "%"PRIu64,
+                                            version->minor);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "MINOR", "%"PRIu64, 
-                                                               version->minor);
+       rc = xmlTextWriterWriteFormatElement(writer, "BUILD", "%"PRIu64,
+                                            version->build);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "BUILD", "%"PRIu64, 
-                                                               version->build);
+       rc = xmlTextWriterWriteFormatElement(writer, "SPBUILD", "%"PRIu64,
+                                            version->sp_build);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "SPBUILD", "%"PRIu64, 
-                                                               version->sp_build);
+       rc = xmlTextWriterWriteFormatElement(writer, "SPLEVEL", "%"PRIu64,
+                                            version->sp_level);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "SPLEVEL", "%"PRIu64, 
-                                                               version->sp_level);
+       rc = xmlTextWriterEndElement(writer); /* </VERSION> */
        if (rc < 0)
                return rc;
 
-       return xmlTextWriterEndElement(writer); /* </VERSION> */
+       return 0;
 }
 
-/* Writes the information contained in a struct windows_info structure to the XML
- * document being constructed in memory. This is the <WINDOWS> element. */
-static int xml_write_windows_info(xmlTextWriter *writer, 
-                                       const struct windows_info *windows_info)
+/* 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)
 {
        int rc;
        rc = xmlTextWriterStartElement(writer, "WINDOWS");
        if (rc < 0)
                return rc;
 
-
-       rc = xmlTextWriterWriteFormatElement(writer, "ARCH", "%"PRIu64, 
-                                                       windows_info->arch);
+       rc = xmlTextWriterWriteFormatElement(writer, "ARCH", "%"PRIu64,
+                                            windows_info->arch);
        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->system_root) {
-               rc = xmlTextWriterWriteElement(writer, "SYSTEMROOT", 
-                                               windows_info->system_root);
-                       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");
                if (rc < 0)
                        return rc;
 
-               for (int i = 0; i < windows_info->num_languages; i++) {
-                       rc = xmlTextWriterWriteElement(writer, "LANGUAGE", 
-                                                       windows_info->languages[i]);
-                       if (rc < 0)
+               for (size_t i = 0; i < windows_info->num_languages; i++) {
+                       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> */
@@ -643,29 +806,37 @@ 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;
        }
 
-       return xmlTextWriterEndElement(writer); /* </WINDOWS> */
+       rc = xml_write_string(writer, "SYSTEMROOT", windows_info->system_root);
+       if (rc)
+               return rc;
+
+       rc = xmlTextWriterEndElement(writer); /* </WINDOWS> */
+       if (rc < 0)
+               return rc;
+
+       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);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "HIGHPART", 
-                                       "0x%"PRIX32, (u32)(time >> 32));
+       rc = xmlTextWriterWriteFormatElement(writer, "HIGHPART",
+                                            "0x%08"PRIX32, (u32)(time >> 32));
        if (rc < 0)
                return rc;
 
        rc = xmlTextWriterWriteFormatElement(writer, "LOWPART",
-                                               "0x%"PRIX32, (u32)time);
+                                            "0x%08"PRIX32, (u32)time);
        if (rc < 0)
                return rc;
 
@@ -675,98 +846,74 @@ static int xml_write_time(xmlTextWriter *writer, const char *element_name,
        return 0;
 }
 
-
 /* 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");
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatAttribute(writer, "INDEX", "%"PRIu64, 
-                                               image_info->index);
+       rc = xmlTextWriterWriteFormatAttribute(writer, "INDEX", "%d",
+                                              image_info->index);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "DIRCOUNT", "%"PRIu64, 
-                                               image_info->dir_count);
+       rc = xmlTextWriterWriteFormatElement(writer, "DIRCOUNT", "%"PRIu64,
+                                            image_info->dir_count);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "FILECOUNT", "%"PRIu64, 
-                                               image_info->file_count);
+       rc = xmlTextWriterWriteFormatElement(writer, "FILECOUNT", "%"PRIu64,
+                                            image_info->file_count);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64, 
-                                               image_info->total_bytes);
+       rc = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
+                                            image_info->total_bytes);
        if (rc < 0)
                return rc;
 
-       rc = xmlTextWriterWriteFormatElement(writer, "HARDLINKBYTES", "%"PRIu64, 
-                                               image_info->hard_link_bytes);
+       rc = xmlTextWriterWriteFormatElement(writer, "HARDLINKBYTES", "%"PRIu64,
+                                            image_info->hard_link_bytes);
        if (rc < 0)
                return rc;
 
-       rc = xml_write_time(writer, "CREATIONTIME", 
-                                               image_info->creation_time);
+       rc = xml_write_time(writer, "CREATIONTIME", image_info->creation_time);
        if (rc < 0)
                return rc;
 
-       rc = xml_write_time(writer, "LASTMODIFICATIONTIME", 
-                                               image_info->last_modification_time);
+       rc = xml_write_time(writer, "LASTMODIFICATIONTIME",
+                           image_info->last_modification_time);
        if (rc < 0)
                return rc;
 
        if (image_info->windows_info_exists) {
                rc = xml_write_windows_info(writer, &image_info->windows_info);
-               if (rc < 0)
+               if (rc)
                        return rc;
-       } else {
-               DEBUG("<WINDOWS> tag does not exist.");
        }
 
-       if (image_info->name) {
-               rc = xmlTextWriterWriteElement(writer, "NAME", image_info->name);
-               if (rc < 0)
-                       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;
 
@@ -781,42 +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)
 {
-       uint i;
+       int ret;
 
-       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;
+       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 (i = 0; i < new->num_languages; i++) {
+               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)))
+       if (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;
@@ -826,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;
@@ -835,43 +976,37 @@ 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;
 }
 
-/* Copies the XML information for an image between WIM files. 
+/* Copies the XML information for an image between WIM files.
  *
  * @dest_image_name and @dest_image_description are ignored if they are NULL;
  * otherwise, they are used to override the image name and/or image description
- * from the XML data in the source WIM file. */
-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)
+ * from the XML data in the source WIM file.
+ *
+ * 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 tchar *dest_image_name,
+                const tchar *dest_image_description)
 {
        struct wim_info *new_wim_info;
        struct image_info *image_info;
@@ -879,6 +1014,7 @@ int xml_export_image(const struct wim_info *old_wim_info,
 
        DEBUG("Copying XML data between WIM files for source image %d.", image);
 
+       wimlib_assert(old_wim_info != NULL);
        wimlib_assert(image >= 1 && image <= old_wim_info->num_images);
 
        if (*new_wim_info_p) {
@@ -895,87 +1031,87 @@ int xml_export_image(const struct wim_info *old_wim_info,
 
        ret = clone_image_info(&old_wim_info->images[image - 1], image_info);
        if (ret != 0)
-               goto err;
+               goto err_destroy_image_info;
 
        image_info->index = new_wim_info->num_images;
 
        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;
+                       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;
+                       goto err_destroy_image_info;
        }
        *new_wim_info_p = new_wim_info;
        return 0;
+err_destroy_image_info:
+       destroy_image_info(image_info);
 err:
-       ERROR("Out of memory");
-       free_wim_info(new_wim_info);
+       if (new_wim_info != *new_wim_info_p)
+               free_wim_info(new_wim_info);
        return WIMLIB_ERR_NOMEM;
 }
 
 /* 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;
-       int i;
 
-       DEBUG("Deleting image %d from the XML data.", image);
-       
        wim_info = *wim_info_p;
-
-       wimlib_assert(wim_info);
        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]);
 
-       for (i = image - 1; i < wim_info->num_images - 1; i++) {
-               memcpy(&wim_info->images[i], &wim_info->images[i + 1],
-                                       sizeof(struct image_info));
-               wim_info->images[i].index--;
-       }
+       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);
                *wim_info_p = NULL;
+       } else {
+               for (int i = image - 1; i < wim_info->num_images; i++)
+                       wim_info->images[i].index--;
        }
 }
 
-size_t xml_get_max_image_name_len(const WIMStruct *w)
+size_t
+xml_get_max_image_name_len(const WIMStruct *wim)
 {
-       size_t len = 0;
-       uint i;
-       uint num_images = w->wim_info->num_images;
-       for (i = 0; i < num_images; i++)
-               len = max(len, strlen(w->wim_info->images[i].name));
-       return len;
+       size_t max_len = 0;
+       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;
+       struct image_info *info = arg;
+       const struct wim_inode *inode = dentry->d_inode;
+       struct wim_lookup_table_entry *lte;
 
        /* Update directory count and file count.
         *
         * Each dentry counts as either a file or a directory, but not both.
-        * The root directory is an exception: it is not counted.
+        * The root directory is an exception: it is not counted at all.
         *
         * Symbolic links and junction points (and presumably other reparse
         * points) count as regular files.  This is despite the fact that
@@ -989,7 +1125,7 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
        else
                info->file_count++;
 
-       /* 
+       /*
         * Update total bytes and hard link bytes.
         *
         * Unfortunately there are some inconsistencies/bugs in the way this is
@@ -1022,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);
                                }
                        }
@@ -1036,495 +1172,513 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
        return 0;
 }
 
-void xml_update_image_info(WIMStruct *w, int image)
+/*
+ * Calculate what to put in the <FILECOUNT>, <DIRCOUNT>, <TOTALBYTES>, and
+ * <HARDLINKBYTES> elements of each <IMAGE>.
+ *
+ * Please note there is no official documentation for exactly how this is done.
+ * But, see calculate_dentry_statistics().
+ */
+void
+xml_update_image_info(WIMStruct *wim, int image)
 {
        struct image_info *image_info;
-       struct dentry *root; 
-       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->lookup_table = NULL;
-       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;
 
-       wimlib_assert(name);
-
-       DEBUG("Adding image: name = %s", name);
+       wimlib_assert(name != NULL);
 
        /* 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 {
-               DEBUG("Allocing struct wim_info with 1 image");
                wim_info = CALLOC(1, sizeof(struct wim_info));
-               if (!wim_info) {
-                       ERROR("Could not allocate WIM information struct--- "
-                             "out of memory");
+               if (!wim_info)
                        return WIMLIB_ERR_NOMEM;
-               }
        }
 
        image_info = add_image_info_struct(wim_info);
        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 (w->wim_info)
-               wim_info->num_images--;
-       else
+       if (wim_info != wim->wim_info)
                FREE(wim_info);
-       ERROR("Out of memory");
        return WIMLIB_ERR_NOMEM;
 }
 
-/* Prints information about the specified image from struct wim_info structure. 
- * @image may be WIM_ALL_IMAGES. */
-void print_image_info(const struct wim_info *wim_info, int image)
+/* Prints information about the specified image from struct wim_info structure.
+ * */
+void
+print_image_info(const struct wim_info *wim_info, int image)
 {
-       uint i;
        const struct image_info *image_info;
-       const char *desc;
+       const tchar *desc;
+       tchar buf[50];
 
+       wimlib_assert(image >= 1 && image <= wim_info->num_images);
 
-       if (image == WIM_ALL_IMAGES) {
-               for (i = 1; i <= wim_info->num_images; i++)
-                       print_image_info(wim_info, i);
-       } else {
-               time_t time;
-               char *p;
-
-               image_info = &wim_info->images[image - 1];
-
-               printf("Index:                  %"PRIu64"\n", 
-                       image_info->index);
-               printf("Name:                   %s\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);
-
-               if (image_info->display_name)
-                       printf("Display Name:           %s\n", 
-                               image_info->display_name);
-
-               if (image_info->display_description)
-                       printf("Display Description:    %s\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);
-
-               time = wim_timestamp_to_unix(image_info->creation_time);
-               p = asctime(gmtime(&time));
-               *(strrchr(p, '\n')) = '\0';
-
-               printf("Creation Time:          %s UTC\n", p);
-
-               time = wim_timestamp_to_unix(image_info->last_modification_time);
-               p = asctime(gmtime(&time));
-               *(strrchr(p, '\n')) = '\0';
-
-               printf("Last Modification Time: %s UTC\n", p);
-               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');
+       image_info = &wim_info->images[image - 1];
+
+       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 = T("");
+       tprintf(T("Description:            %"TS"\n"), desc);
+
+       if (image_info->display_name) {
+               tprintf(T("Display Name:           %"TS"\n"),
+                       image_info->display_name);
        }
+
+       if (image_info->display_description) {
+               tprintf(T("Display Description:    %"TS"\n"),
+                       image_info->display_description);
+       }
+
+       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));
+       tprintf(T("Creation Time:          %"TS"\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)
+               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, 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->size, res->offset);
-
-       if (resource_is_compressed(res)) {
-               ERROR("XML data is supposed to be uncompressed");
-               ret = WIMLIB_ERR_XML;
-               goto out_cleanup_parser;
-       }
-       if (res->size < 2) {
-               ERROR("XML data must be at least 2 bytes");
-               ret = WIMLIB_ERR_XML;
-               goto out_cleanup_parser;
-       }
-
-       xml_data = MALLOC(res->size + 2);
-       if (!xml_data) {
-               ret = WIMLIB_ERR_NOMEM;
-               goto out_cleanup_parser;
-       }
-       ret = read_uncompressed_resource(fp, res->offset, res->size, xml_data);
-       if (ret != 0)
-               goto out_free_xml_data;
-
-       xml_data[res->size] = 0;
-       xml_data[res->size + 1] = 0;
+       res_entry = &wim->hdr.xml_res_entry;
 
-       DEBUG("Parsing XML using libxml2 to create XML tree.");
-
-       doc = xmlReadMemory(xml_data, res->size, "noname.xml", "UTF-16", 0);
+       DEBUG("Reading XML data: %"PRIu64" bytes at offset %"PRIu64"",
+             (u64)res_entry->size, res_entry->offset);
 
+       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("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.");
-
-       xmlFreeDoc(doc);
-       xmlCleanupParser();
-       *xml_data_ret = xml_data;
-       return 0;
+       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 err2; \
-                       } })
-
-/* 
- * 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)
+static int
+prepare_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
+                    u8 **xml_data_ret, size_t *xml_len_ret)
 {
-       xmlBuffer     *buf;
+       xmlCharEncodingHandler *encoding_handler;
+       xmlBuffer *buf;
+       xmlOutputBuffer *outbuf;
        xmlTextWriter *writer;
-       char          *utf16_str;
        int ret;
-       int num_images;
-       int i;
+       int first, last;
        const xmlChar *content;
-       size_t len;
-       size_t utf16_len;
-       size_t bytes_written;
+       int len;
+       u8 *xml_data;
+       size_t xml_len;
 
-       wimlib_assert(image == WIM_ALL_IMAGES || 
-                       (wim_info != NULL && image >= 1 && 
-                        image <= wim_info->num_images));
+       /* Open an xmlTextWriter that writes to an in-memory buffer using
+        * UTF-16LE encoding.  */
 
-       /* The contents of the <TOTALBYTES> element in the XML data, under the
-        * <WIM> element not the <IMAGE> element, is (for non-spit WIMs) the
-        * size of the WIM file excluding the XML data and integrity table,
-        * which is the current offset, since the XML data goes at the end of
-        * the WIM file before the integrity table. */
-       if (total_bytes == 0) {
-               total_bytes = ftello(out);
-               if (total_bytes == (u64)-1)
-                       return WIMLIB_ERR_WRITE;
+       encoding_handler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF16LE);
+       if (!encoding_handler) {
+               ERROR("Failed to get XML character encoding handler for UTF-16LE");
+               ret = WIMLIB_ERR_LIBXML_UTF16_HANDLER_NOT_AVAILABLE;
+               goto out;
        }
 
-       DEBUG("Creating XML buffer and text writer.");
        buf = xmlBufferCreate();
        if (!buf) {
-               ERROR("Failed to allocate XML buffer");
+               ERROR("Failed to create xmlBuffer");
                ret = WIMLIB_ERR_NOMEM;
-               goto err0;
+               goto out;
        }
-       writer = xmlNewTextWriterMemory(buf, 0);
+
+       outbuf = xmlOutputBufferCreateBuffer(buf, encoding_handler);
+       if (!outbuf) {
+               ERROR("Failed to allocate xmlOutputBuffer");
+               ret = WIMLIB_ERR_NOMEM;
+               goto out_buffer_free;
+       }
+
+       writer = xmlNewTextWriter(outbuf);
        if (!writer) {
-               ERROR("Failed to allocate XML writer");
+               ERROR("Failed to allocate xmlTextWriter");
                ret = WIMLIB_ERR_NOMEM;
-               goto err1;
+               goto out_output_buffer_close;
        }
 
-       /* XXX */
-       /* M$'s WIM files do not have XML declarations, so do not write one.
-        * I'm not sure how we can force the document to be written in UTF-16
-        * without calling xmlTextWriterStartDocument(), though, so currently it
-        * is composed in a buffer UTF-8, then converted to UTF-16. */
-#if 0
-       ret = xmlTextWriterStartDocument(writer, NULL, "UTF-16", NULL);
-       CHECK_RET;
-#endif
+       /* Write the XML document.  */
 
-       DEBUG("Writing <WIM> element");
        ret = xmlTextWriterStartElement(writer, "WIM");
-       CHECK_RET;
+       if (ret < 0)
+               goto out_write_error;
 
-       ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
-                                             total_bytes);
-       CHECK_RET;
+       /* 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;
+               }
+               ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES",
+                                                     "%"PRIu64, total_bytes);
+               if (ret < 0)
+                       goto out_write_error;
+       }
 
-       if (wim_info)
-               num_images = wim_info->num_images;
-       else
-               num_images = 0;
-       DEBUG("Writing %u <IMAGE> elements", num_images);
+       if (image == WIMLIB_ALL_IMAGES) {
+               first = 1;
+               last = wim->hdr.image_count;
+       } else {
+               first = image;
+               last = image;
+       }
 
-       for (i = 1; i <= num_images; i++) {
-               if (image != WIM_ALL_IMAGES && i != image)
-                       continue;
-               DEBUG("Writing <IMAGE> element for image %d", i);
-               ret = xml_write_image_info(writer, &wim_info->images[i - 1]);
-               CHECK_RET;
+       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;
+
+       ret = xmlTextWriterFlush(writer);
+       if (ret < 0)
+               goto out_write_error;
 
-       DEBUG("Done composing XML document. Now converting to UTF-16 and "
-             "writing it to the output file.");
+       /* Retrieve the buffer into which the document was written.  */
 
        content = xmlBufferContent(buf);
        len = xmlBufferLength(buf);
 
-       utf16_str = utf8_to_utf16(content, len, &utf16_len);
-       if (!utf16_str) {
-               ret = WIMLIB_ERR_NOMEM;
-               goto err2;
-       }
+       /* 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.  */
 
-       if ((putc(0xff, out)) == EOF || (putc(0xfe, out) == EOF) || 
-               ((bytes_written = fwrite(utf16_str, 1, utf16_len, out))
-                               != utf16_len)) {
-               ERROR_WITH_ERRNO("Error writing XML data");
-               ret = WIMLIB_ERR_WRITE;
-               goto err3;
+       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);
 
-       DEBUG("Cleaning up.");
-
+       /* Clean up libxml objects and return success.  */
+       *xml_data_ret = xml_data;
+       *xml_len_ret = xml_len;
        ret = 0;
-err3:
-       FREE(utf16_str);
-err2:
+out_free_text_writer:
+       /* xmlFreeTextWriter will free the attached xmlOutputBuffer.  */
        xmlFreeTextWriter(writer);
-err1:
+       goto out_buffer_free;
+out_output_buffer_close:
+       xmlOutputBufferClose(outbuf);
+out_buffer_free:
        xmlBufferFree(buf);
-err0:
+out:
+       DEBUG("ret=%d", ret);
        return ret;
+
+out_write_error:
+       ERROR("Error writing XML data");
+       ret = WIMLIB_ERR_WRITE;
+       goto out_free_text_writer;
 }
 
-/* Returns the name of the specified image. */
-WIMLIBAPI const char *wimlib_get_image_name(const WIMStruct *w, int image)
+/* 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)
 {
-       DEBUG("Getting the name of image %d", image);
-       if (image < 1 || image > w->hdr.image_count)
-               return NULL;
-
-       return w->wim_info->images[image - 1].name;
+       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 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_name(const WIMStruct *wim, int image)
 {
-       DEBUG("Getting the description of image %d", 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].name;
 }
 
-/* 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 const tchar *
+wimlib_get_image_description(const WIMStruct *wim, int image)
 {
-       int i;
+       if (image < 1 || image > wim->hdr.image_count)
+               return NULL;
+       return wim->wim_info->images[image - 1].description;
+}
 
-       DEBUG("Checking to see if the image name `%s' is already in use", name);
-       if (!name || !w->wim_info)
+/* 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 (i = 1; i <= w->wim_info->num_images; 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;
 }
 
-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 (wim->filename == NULL)
+               return WIMLIB_ERR_INVALID_PARAM;
+
+       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)
 {
-       DEBUG("Extracting the XML data.");
-       if (fwrite(w->xml_data, 1, w->hdr.xml_res_entry.size, fp) != 
-                       w->hdr.xml_res_entry.size) {
+       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 (!w)
-               return WIMLIB_ERR_INVALID_PARAM;
+       ret = can_modify_wim(wim);
+       if (ret)
+               return ret;
 
-       if (!name || !*name) {
-               ERROR("Must specify a non-empty string for the image name");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-       if (image < 1 || image > w->hdr.image_count) {
+       if (name == NULL)
+               name = T("");
+
+       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);
-       if (!p) {
-               ERROR("Out of memory");
+       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;
-
-       DEBUG("Setting the description of image %d to %s", image, description);
+       tchar *tstr_copy;
+       tchar **dest_tstr_p;
+       int ret;
 
-       if (!w)
-               return WIMLIB_ERR_INVALID_PARAM;
+       ret = can_modify_wim(wim);
+       if (ret)
+               return ret;
 
-       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;
        }
-       if (description) {
-               p = STRDUP(description);
-               if (!p) {
-                       ERROR("Out of memory");
+       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;
 }
 
-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;
-
-       DEBUG("Setting the flags of image %d to %s", image, flags);
+       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) {
-                       ERROR("Out of memory");
-                       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));
 }