Encodings update (IN PROGRESS)
authorEric Biggers <ebiggers3@gmail.com>
Sat, 23 Mar 2013 04:42:11 +0000 (23:42 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Sat, 23 Mar 2013 04:42:11 +0000 (23:42 -0500)
src/add_image.c
src/ntfs-capture.c
src/security.c
src/security.h
src/util.c
src/util.h
src/wimlib_internal.h
src/win32.c
src/win32.h
src/xml.c

index c7464d9..f435c3f 100644 (file)
@@ -36,6 +36,7 @@
 #include "dentry.h"
 #include "lookup_table.h"
 #include "xml.h"
+#include "security.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ -123,15 +124,14 @@ err:
  *             These lookup table entries that are added point to the path of
  *             the file on disk.
  *
- * @sd:                Ignored.  (Security data only captured in NTFS mode.)
+ * @sd_set:    Ignored.  (Security data only captured in NTFS mode.)
  *
  * @capture_config:
  *             Configuration for files to be excluded from capture.
  *
  * @add_flags:  Bitwise or of WIMLIB_ADD_IMAGE_FLAG_*
  *
- * @extra_arg: Ignored in UNIX builds; used to pass sd_set pointer in Windows
- *             builds.
+ * @extra_arg: Ignored
  *
  * @return:    0 on success, nonzero on failure.  It is a failure if any of
  *             the files cannot be `stat'ed, or if any of the needed
@@ -144,7 +144,7 @@ static int
 unix_build_dentry_tree(struct wim_dentry **root_ret,
                       const char *root_disk_path,
                       struct wim_lookup_table *lookup_table,
-                      struct wim_security_data *sd,
+                      struct sd_set *sd,
                       const struct capture_config *config,
                       int add_image_flags,
                       wimlib_progress_func_t progress_func,
@@ -923,7 +923,7 @@ wimlib_add_image_multisource(WIMStruct *w,
        int (*capture_tree)(struct wim_dentry **,
                            const tchar *,
                            struct wim_lookup_table *,
-                           struct wim_security_data *,
+                           struct sd_set *,
                            const struct capture_config *,
                            int,
                            wimlib_progress_func_t,
@@ -935,6 +935,7 @@ wimlib_add_image_multisource(WIMStruct *w,
        struct capture_config config;
        struct wim_image_metadata *imd;
        int ret;
+       struct sd_set sd_set;
 
        if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) {
 #ifdef WITH_NTFS_3G
@@ -1008,6 +1009,9 @@ wimlib_add_image_multisource(WIMStruct *w,
        sd->total_length = 8;
        sd->refcnt = 1;
 
+       sd_set.sd = sd;
+       sd_set.rb_root.rb_node = NULL;
+
        DEBUG("Using %zu capture sources", num_sources);
        canonicalize_targets(sources, num_sources);
        sort_sources(sources, num_sources);
@@ -1041,8 +1045,10 @@ wimlib_add_image_multisource(WIMStruct *w,
                flags = add_image_flags | WIMLIB_ADD_IMAGE_FLAG_SOURCE;
                if (!*sources[i].wim_target_path)
                        flags |= WIMLIB_ADD_IMAGE_FLAG_ROOT;
-               ret = (*capture_tree)(&branch, sources[i].fs_source_path,
-                                     w->lookup_table, sd,
+               ret = (*capture_tree)(&branch,
+                                     sources[i].fs_source_path,
+                                     w->lookup_table,
+                                     &sd_set,
                                      &config,
                                      flags,
                                      progress_func, extra_arg);
@@ -1101,7 +1107,7 @@ wimlib_add_image_multisource(WIMStruct *w,
        if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
                wimlib_set_boot_idx(w, w->hdr.image_count);
        ret = 0;
-       goto out_destroy_capture_config;
+       goto out_destroy_sd_set;
 out_destroy_imd:
        destroy_image_metadata(&w->image_metadata[w->hdr.image_count - 1],
                               w->lookup_table);
@@ -1113,6 +1119,8 @@ out_free_dentry_tree:
        free_dentry_tree(root_dentry, w->lookup_table);
 out_free_security_data:
        free_security_data(sd);
+out_destroy_sd_set:
+       destroy_sd_set(&sd_set);
 out_destroy_capture_config:
        destroy_capture_config(&config);
 out:
index 3f036d0..31c8e56 100644 (file)
@@ -121,7 +121,7 @@ out_error:
 static int
 capture_ntfs_streams(struct wim_dentry *dentry,
                     ntfs_inode *ni,
-                    mbchar *path,
+                    char *path,
                     size_t path_len,
                     struct wim_lookup_table *lookup_table,
                     ntfs_volume **ntfs_vol_p,
@@ -391,7 +391,7 @@ destroy_dos_name_map(struct dos_name_map *map)
 struct readdir_ctx {
        struct wim_dentry *parent;
        ntfs_inode *dir_ni;
-       mbchar *path;
+       char *path;
        size_t path_len;
        struct wim_lookup_table *lookup_table;
        struct sd_set *sd_set;
@@ -406,7 +406,7 @@ static int
 build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
                                 ntfs_inode *dir_ni,
                                 ntfs_inode *ni,
-                                mbchar *path,
+                                char *path,
                                 size_t path_len,
                                 int name_type,
                                 struct wim_lookup_table *lookup_table,
@@ -424,7 +424,7 @@ wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
 {
        struct readdir_ctx *ctx;
        size_t mbs_name_nbytes;
-       mbchar *mbs_name;
+       char *mbs_name;
        struct wim_dentry *child;
        int ret;
        size_t path_len;
@@ -494,7 +494,7 @@ static int
 build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
                                 ntfs_inode *dir_ni,
                                 ntfs_inode *ni,
-                                mbchar *path,
+                                char *path,
                                 size_t path_len,
                                 int name_type,
                                 struct wim_lookup_table *lookup_table,
@@ -638,9 +638,9 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 
 int
 build_dentry_tree_ntfs(struct wim_dentry **root_p,
-                      const mbchar *device,
+                      const char *device,
                       struct wim_lookup_table *lookup_table,
-                      struct wim_security_data *sd,
+                      struct sd_set *sd_set,
                       const struct capture_config *config,
                       int add_image_flags,
                       wimlib_progress_func_t progress_func,
@@ -649,10 +649,6 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
        ntfs_volume *vol;
        ntfs_inode *root_ni;
        int ret;
-       struct sd_set sd_set = {
-               .sd = sd,
-               .rb_root = {NULL},
-       };
        ntfs_volume **ntfs_vol_p = extra_arg;
 
        DEBUG("Mounting NTFS volume `%s' read-only", device);
@@ -687,7 +683,7 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
 
        /* Currently we assume that all the paths fit into this length and there
         * is no check for overflow. */
-       mbchar *path = MALLOC(32768);
+       char *path = MALLOC(32768);
        if (!path) {
                ERROR("Could not allocate memory for NTFS pathname");
                ret = WIMLIB_ERR_NOMEM;
@@ -698,14 +694,13 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
        path[1] = '\0';
        ret = build_dentry_tree_ntfs_recursive(root_p, NULL, root_ni, path, 1,
                                               FILE_NAME_POSIX, lookup_table,
-                                              &sd_set,
+                                              sd_set,
                                               config, ntfs_vol_p,
                                               add_image_flags,
                                               progress_func);
 out_cleanup:
        FREE(path);
        ntfs_inode_close(root_ni);
-       destroy_sd_set(&sd_set);
 out:
        ntfs_index_ctx_put(vol->secure_xsii);
        ntfs_index_ctx_put(vol->secure_xsdh);
index 9b1ea21..88e6c84 100644 (file)
@@ -572,9 +572,6 @@ free_security_data(struct wim_security_data *sd)
        }
 }
 
-/* The security tree stuff is only needed when NTFS capture is supported, either
- * through NTFS-3G or through a native Windows build. */
-#if defined(WITH_NTFS_3G) || defined(__WIN32__)
 struct sd_node {
        int security_id;
        u8 hash[SHA1_HASH_SIZE];
@@ -704,4 +701,3 @@ out_free_node:
 out:
        return -1;
 }
-#endif /* WITH_NTFS_3G || __WIN32__ */
index 4d701d0..e0b83ac 100644 (file)
@@ -12,7 +12,6 @@
 #ifndef _WIMLIB_SECURITY_H
 #define _WIMLIB_SECURITY_H
 
-#if defined(WITH_NTFS_3G) || defined(__WIN32__)
 /* Red-black tree that maps SHA1 message digests of security descriptors to
  * security IDs, which are themselves indices into the table of security
  * descriptors in the 'struct wim_security_data'. */
@@ -24,6 +23,5 @@ void destroy_sd_set(struct sd_set *sd_set);
 int lookup_sd(struct sd_set *set, const u8 hash[SHA1_HASH_SIZE]);
 int sd_set_add_sd(struct sd_set *sd_set, const char descriptor[],
                  size_t size);
-#endif
 
 #endif /* _WIMLIB_SECURITY_H */
index bd37720..1e26a6f 100644 (file)
@@ -501,15 +501,10 @@ to_parent_name(tchar *buf, size_t len)
        buf[i + 1] = T('\0');
 }
 
-/* Like the basename() function, but does not modify @path; it just returns a
- * pointer to it. */
 const tchar *
-path_basename(const tchar *path)
+path_basename_with_len(const tchar *path, size_t len)
 {
-       const tchar *p = path;
-       while (*p)
-               p++;
-       p--;
+       const tchar *p = &path[len] - 1;
 
        /* Trailing slashes. */
        while (1) {
@@ -526,6 +521,14 @@ path_basename(const tchar *path)
        return p + 1;
 }
 
+/* Like the basename() function, but does not modify @path; it just returns a
+ * pointer to it. */
+const tchar *
+path_basename(const tchar *path)
+{
+       return path_basename_with_len(path, tstrlen(path));
+}
+
 /*
  * Returns a pointer to the part of @path following the first colon in the last
  * path component, or NULL if the last path component does not contain a colon.
index 14d620c..07e12fe 100644 (file)
@@ -326,6 +326,9 @@ randomize_char_array_with_alnum(tchar p[], size_t n);
 extern const tchar *
 path_next_part(const tchar *path, size_t *first_part_len_ret);
 
+const tchar *
+path_basename_with_len(const tchar *path, size_t len);
+
 const tchar *
 path_basename(const tchar *path);
 
index 1df3bf7..8b696b5 100644 (file)
@@ -55,6 +55,7 @@
 struct stat;
 struct wim_dentry;
 struct wim_inode;
+struct sd_set;
 
 #define WIM_MAGIC_LEN  8
 #define WIM_GID_LEN    16
@@ -464,7 +465,7 @@ extern int
 build_dentry_tree_ntfs(struct wim_dentry **root_p,
                       const tchar *device,
                       struct wim_lookup_table *lookup_table,
-                      struct wim_security_data *sd,
+                      struct sd_set *sd_set,
                       const struct capture_config *config,
                       int add_image_flags,
                       wimlib_progress_func_t progress_func,
index 78b7167..2b26e1c 100644 (file)
@@ -67,8 +67,6 @@ void
 win32_global_init()
 {
        DWORD err;
-       bool warned;
-
 
        if (hKernel32 == NULL) {
                DEBUG("Loading Kernel32.dll");
@@ -108,26 +106,28 @@ win32_global_cleanup()
        }
 }
 
-static const char *access_denied_msg =
-"         If you are not running this program as the administrator, you may\n"
-"         need to do so, so that all data and metadata can be backed up.\n"
-"         Otherwise, there may be no way to access the desired data or\n"
-"         metadata without taking ownership of the file or directory.\n";
+static const wchar_t *access_denied_msg =
+L"         If you are not running this program as the administrator, you may\n"
+ "         need to do so, so that all data and metadata can be backed up.\n"
+ "         Otherwise, there may be no way to access the desired data or\n"
+ "         metadata without taking ownership of the file or directory.\n"
+ ;
 
 #ifdef ENABLE_ERROR_MESSAGES
 void
 win32_error(u32 err_code)
 {
-       char *buffer;
+       wchar_t *buffer;
        DWORD nchars;
-       nchars = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+       nchars = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
+                                   FORMAT_MESSAGE_ALLOCATE_BUFFER,
                                NULL, err_code, 0,
-                               (char*)&buffer, 0, NULL);
+                               (wchar_t*)&buffer, 0, NULL);
        if (nchars == 0) {
                ERROR("Error printing error message! "
                      "Computer will self-destruct in 3 seconds.");
        } else {
-               ERROR("Win32 error: %s", buffer);
+               ERROR("Win32 error: %ls", buffer);
                LocalFree(buffer);
        }
 }
@@ -159,7 +159,7 @@ win32_open_file_data_only(const wchar_t *path)
 }
 
 int
-win32_read_file(const utf16lechar *win32_filename,
+win32_read_file(const wchar_t *filename,
                void *handle, u64 offset, size_t size, void *buf)
 {
        HANDLE h = handle;
@@ -173,7 +173,7 @@ win32_read_file(const utf16lechar *win32_filename,
                if (ReadFile(h, buf, size, &bytesRead, NULL) && bytesRead == size)
                        return 0;
        err = GetLastError();
-       ERROR("Error reading \"%ls\"", win32_filename);
+       ERROR("Error reading \"%ls\"", filename);
        win32_error(err);
        return WIMLIB_ERR_READ;
 }
@@ -191,14 +191,12 @@ FILETIME_to_u64(const FILETIME *ft)
 }
 
 static int
-win32_get_short_name(struct wim_dentry *dentry,
-                    const wchar_t *path_utf16)
+win32_get_short_name(struct wim_dentry *dentry, const wchar_t *path)
 {
        WIN32_FIND_DATAW dat;
-       if (FindFirstFileW(path_utf16, &dat) &&
-           dat.cAlternateFileName[0] != L'\0')
-       {
-               size_t short_name_nbytes = wcslen(dat.cAlternateFileName) * 2;
+       if (FindFirstFileW(path, &dat) && dat.cAlternateFileName[0] != L'\0') {
+               size_t short_name_nbytes = wcslen(dat.cAlternateFileName) *
+                                          sizeof(wchar_t);
                size_t n = short_name_nbytes + sizeof(wchar_t);
                dentry->short_name = MALLOC(n);
                if (!dentry->short_name)
@@ -212,7 +210,7 @@ win32_get_short_name(struct wim_dentry *dentry,
 static int
 win32_get_security_descriptor(struct wim_dentry *dentry,
                              struct sd_set *sd_set,
-                             const wchar_t *path_utf16)
+                             const wchar_t *path)
 {
        SECURITY_INFORMATION requestedInformation;
        DWORD lenNeeded = 0;
@@ -224,13 +222,13 @@ win32_get_security_descriptor(struct wim_dentry *dentry,
                               OWNER_SECURITY_INFORMATION |
                               GROUP_SECURITY_INFORMATION;
        /* Request length of security descriptor */
-       status = GetFileSecurityW(path_utf16, requestedInformation,
+       status = GetFileSecurityW(path, requestedInformation,
                                  NULL, 0, &lenNeeded);
        err = GetLastError();
        if (!status && err == ERROR_INSUFFICIENT_BUFFER) {
                DWORD len = lenNeeded;
                char buf[len];
-               if (GetFileSecurityW(path_utf16, requestedInformation,
+               if (GetFileSecurityW(path, requestedInformation,
                                     (PSECURITY_DESCRIPTOR)buf, len, &lenNeeded))
                {
                        int security_id = sd_set_add_sd(sd_set, buf, len);
@@ -247,29 +245,36 @@ win32_get_security_descriptor(struct wim_dentry *dentry,
 
        if (err == ERROR_ACCESS_DENIED) {
                WARNING("Failed to read security descriptor of \"%ls\": "
-                       "Access denied!\n%s", path_utf16, access_denied_msg);
+                       "Access denied!\n%ls", path, access_denied_msg);
                return 0;
        } else {
-               ERROR("Win32 API: Failed to read security descriptor of \"%ls\"",
-                     path_utf16);
+               ERROR("Failed to read security descriptor of \"%ls\"", path);
                win32_error(err);
                return WIMLIB_ERR_READ;
        }
 }
 
+static int
+win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
+                                 const wchar_t *path,
+                                 const size_t path_num_chars,
+                                 struct wim_lookup_table *lookup_table,
+                                 struct sd_set *sd_set,
+                                 const struct capture_config *config,
+                                 int add_image_flags,
+                                 wimlib_progress_func_t progress_func);
+
 /* Reads the directory entries of directory using a Win32 API and recursively
  * calls win32_build_dentry_tree() on them. */
 static int
 win32_recurse_directory(struct wim_dentry *root,
-                       const mbchar *root_disk_path,
+                       const wchar_t *dir_path,
+                       const size_t dir_path_num_chars,
                        struct wim_lookup_table *lookup_table,
-                       struct wim_security_data *sd,
+                       struct sd_set *sd_set,
                        const struct capture_config *config,
                        int add_image_flags,
-                       wimlib_progress_func_t progress_func,
-                       struct sd_set *sd_set,
-                       const wchar_t *path_utf16,
-                       size_t path_utf16_nchars)
+                       wimlib_progress_func_t progress_func)
 {
        WIN32_FIND_DATAW dat;
        HANDLE hFind;
@@ -281,12 +286,8 @@ win32_recurse_directory(struct wim_dentry *root,
                 * Unlike UNIX opendir(), FindFirstFileW has file globbing built
                 * into it.  But this isn't what we actually want, so just add a
                 * dummy glob to get all entries. */
-               wchar_t pattern_buf[path_utf16_nchars + 3];
-               memcpy(pattern_buf, path_utf16,
-                      path_utf16_nchars * sizeof(wchar_t));
-               pattern_buf[path_utf16_nchars] = L'/';
-               pattern_buf[path_utf16_nchars + 1] = L'*';
-               pattern_buf[path_utf16_nchars + 2] = L'\0';
+               wchar_t pattern_buf[dir_path_num_chars + 3];
+               swprintf(pattern_buf, L"%ls/*", dir_path);
                hFind = FindFirstFileW(pattern_buf, &dat);
        }
        if (hFind == INVALID_HANDLE_VALUE) {
@@ -294,8 +295,7 @@ win32_recurse_directory(struct wim_dentry *root,
                if (err == ERROR_FILE_NOT_FOUND) {
                        return 0;
                } else {
-                       ERROR("Win32 API: Failed to read directory \"%s\"",
-                             root_disk_path);
+                       ERROR("Failed to read directory \"%ls\"", dir_path);
                        win32_error(err);
                        return WIMLIB_ERR_READ;
                }
@@ -303,28 +303,24 @@ win32_recurse_directory(struct wim_dentry *root,
        ret = 0;
        do {
                /* Skip . and .. entries */
-               if (!(dat.cFileName[0] == cpu_to_le16(L'.') &&
-                     (dat.cFileName[1] == cpu_to_le16(L'\0') ||
-                      (dat.cFileName[1] == cpu_to_le16(L'.') &&
-                       dat.cFileName[2] == cpu_to_le16(L'\0')))))
+               if (wcscmp(dat.cFileName, L".") && wcscmp(dat.cFileName, L".."))
                {
-                       struct wim_dentry *child;
+                       size_t filename_num_chars = wcslen(dat.cFileName);
+                       size_t new_path_num_chars = dir_path_num_chars + 1 +
+                                                   filename_num_chars;
+                       wchar_t new_path[new_path_num_chars + 1];
 
-                       mbchar *mbs_name;
-                       size_t mbs_name_nbytes;
-                       ret = utf16le_to_mbs(dat.cFileName,
-                                            wcslen(dat.cFileName) * sizeof(wchar_t),
-                                            &mbs_name,
-                                            &mbs_name_nbytes);
-                       if (ret)
-                               goto out_find_close;
+                       swprintf(new_path, L"%ls/%ls", dir_path, dat.cFileName);
 
-                       mbchar name[strlen(root_disk_path) + 1 + mbs_name_nbytes + 1];
-                       sprintf(name, "%s/%s", root_disk_path, mbs_name);
-                       FREE(mbs_name);
-                       ret = win32_build_dentry_tree(&child, name, lookup_table,
-                                                     sd, config, add_image_flags,
-                                                     progress_func, sd_set);
+                       struct wim_dentry *child;
+                       ret = win32_build_dentry_tree_recursive(&child,
+                                                               new_path,
+                                                               new_path_num_chars,
+                                                               lookup_table,
+                                                               sd_set,
+                                                               config,
+                                                               add_image_flags,
+                                                               progress_func);
                        if (ret)
                                goto out_find_close;
                        if (child)
@@ -333,7 +329,7 @@ win32_recurse_directory(struct wim_dentry *root,
        } while (FindNextFileW(hFind, &dat));
        err = GetLastError();
        if (err != ERROR_NO_MORE_FILES) {
-               ERROR("Win32 API: Failed to read directory \"%s\"", root_disk_path);
+               ERROR("Failed to read directory \"%s\"", dir_path);
                win32_error(err);
                if (ret == 0)
                        ret = WIMLIB_ERR_READ;
@@ -361,7 +357,7 @@ static int
 win32_capture_reparse_point(HANDLE hFile,
                            struct wim_inode *inode,
                            struct wim_lookup_table *lookup_table,
-                           const mbchar *path)
+                           const wchar_t *path)
 {
        /* "Reparse point data, including the tag and optional GUID,
         * cannot exceed 16 kilobytes." - MSDN  */
@@ -379,16 +375,16 @@ win32_capture_reparse_point(HANDLE hFile,
                             NULL))
        {
                DWORD err = GetLastError();
-               ERROR("Win32 API: Failed to get reparse data of \"%s\"", path);
+               ERROR("Failed to get reparse data of \"%ls\"", path);
                win32_error(err);
                return WIMLIB_ERR_READ;
        }
        if (bytesReturned < 8) {
-               ERROR("Reparse data on \"%s\" is invalid", path);
+               ERROR("Reparse data on \"%ls\" is invalid", path);
                return WIMLIB_ERR_READ;
        }
        inode->i_reparse_tag = le32_to_cpu(*(u32*)reparse_point_buf);
-       return inode_add_ads_with_data(inode, "",
+       return inode_add_ads_with_data(inode, L"",
                                       reparse_point_buf + 8,
                                       bytesReturned - 8, lookup_table);
 }
@@ -439,9 +435,9 @@ out_close_handle:
  * wim_lookup_table_entry' in memory for it, or uses an existing 'struct
  * wim_lookup_table_entry' for an identical stream.
  *
- * @path_utf16:         Path to the file (UTF-16LE).
+ * @path:               Path to the file (UTF-16LE).
  *
- * @path_utf16_nchars:  Number of 2-byte characters in @path_utf16.
+ * @path_num_chars:     Number of 2-byte characters in @path.
  *
  * @inode:              WIM inode to save the stream into.
  *
@@ -453,8 +449,8 @@ out_close_handle:
  * Returns 0 on success; nonzero on failure.
  */
 static int
-win32_capture_stream(const wchar_t *path_utf16,
-                    size_t path_utf16_nchars,
+win32_capture_stream(const wchar_t *path,
+                    size_t path_num_chars,
                     struct wim_inode *inode,
                     struct wim_lookup_table *lookup_table,
                     WIN32_FIND_STREAM_DATA *dat)
@@ -496,7 +492,7 @@ win32_capture_stream(const wchar_t *path_utf16,
        if (is_named_stream) {
                /* Allocate an ADS entry for the named stream. */
                ads_entry = inode_add_ads_utf16le(inode, stream_name,
-                                                 stream_name_nchars * 2);
+                                                 stream_name_nchars * sizeof(wchar_t));
                if (!ads_entry) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto out;
@@ -512,15 +508,15 @@ win32_capture_stream(const wchar_t *path_utf16,
         * begin with an explicit "./" so that, for example, a file t:ads, where
         * :ads is the part we added, is not interpreted as a file on the t:
         * drive. */
-       spath_nchars = path_utf16_nchars;
+       spath_nchars = path_num_chars;
        relpath_prefix = L"";
        colonchar = L"";
        if (is_named_stream) {
                spath_nchars += 1 + stream_name_nchars;
                colonchar = L":";
-               if (path_utf16_nchars == 1 &&
-                   path_utf16[0] != cpu_to_le16('/') &&
-                   path_utf16[0] != cpu_to_le16('\\'))
+               if (path_num_chars == 1 &&
+                   path[0] != L'/' &&
+                   path[0] != L'\\')
                {
                        spath_nchars += 2;
                        relpath_prefix = L"./";
@@ -530,14 +526,13 @@ win32_capture_stream(const wchar_t *path_utf16,
        spath_buf_nbytes = (spath_nchars + 1) * sizeof(wchar_t);
        spath = MALLOC(spath_buf_nbytes);
 
-       swprintf(spath, spath_buf_nbytes, L"%ls%ls%ls%ls",
-                relpath_prefix, path_utf16, colonchar, stream_name);
+       swprintf(spath, L"%ls%ls%ls%ls",
+                relpath_prefix, path, colonchar, stream_name);
 
        ret = win32_sha1sum(spath, hash);
        if (ret) {
                err = GetLastError();
-               ERROR("Win32 API: Failed to read \"%ls\" to calculate SHA1sum",
-                     spath);
+               ERROR("Failed to read \"%ls\" to calculate SHA1sum", spath);
                win32_error(err);
                goto out_free_spath;
        }
@@ -554,8 +549,8 @@ win32_capture_stream(const wchar_t *path_utf16,
                        ret = WIMLIB_ERR_NOMEM;
                        goto out_free_spath;
                }
-               lte->win32_file_on_disk = spath;
-               lte->file_on_disk_fp = INVALID_HANDLE_VALUE;
+               lte->file_on_disk = spath;
+               lte->win32_file_on_disk_fp = INVALID_HANDLE_VALUE;
                spath = NULL;
                lte->resource_location = RESOURCE_WIN32;
                lte->resource_entry.original_size = (uint64_t)dat->StreamSize.QuadPart;
@@ -572,7 +567,7 @@ out_free_spath:
 out:
        return ret;
 out_invalid_stream_name:
-       ERROR("Invalid stream name: \"%ls:%ls\"", path_utf16, dat->cStreamName);
+       ERROR("Invalid stream name: \"%ls:%ls\"", path, dat->cStreamName);
        ret = WIMLIB_ERR_READ;
        goto out;
 }
@@ -580,9 +575,9 @@ out_invalid_stream_name:
 /* Scans a Win32 file for unnamed and named data streams (not reparse point
  * streams).
  *
- * @path_utf16:         Path to the file (UTF-16LE).
+ * @path:               Path to the file (UTF-16LE).
  *
- * @path_utf16_nchars:  Number of 2-byte characters in @path_utf16.
+ * @path_num_chars:     Number of 2-byte characters in @path.
  *
  * @inode:              WIM inode to save the stream into.
  *
@@ -594,8 +589,8 @@ out_invalid_stream_name:
  * Returns 0 on success; nonzero on failure.
  */
 static int
-win32_capture_streams(const wchar_t *path_utf16,
-                     size_t path_utf16_nchars,
+win32_capture_streams(const wchar_t *path,
+                     size_t path_num_chars,
                      struct wim_inode *inode,
                      struct wim_lookup_table *lookup_table,
                      u64 file_size)
@@ -608,7 +603,7 @@ win32_capture_streams(const wchar_t *path_utf16,
        if (win32func_FindFirstStreamW == NULL)
                goto unnamed_only;
 
-       hFind = win32func_FindFirstStreamW(path_utf16, FindStreamInfoStandard, &dat, 0);
+       hFind = win32func_FindFirstStreamW(path, FindStreamInfoStandard, &dat, 0);
        if (hFind == INVALID_HANDLE_VALUE) {
                err = GetLastError();
 
@@ -624,21 +619,21 @@ win32_capture_streams(const wchar_t *path_utf16,
                        return 0;
                } else {
                        if (err == ERROR_ACCESS_DENIED) {
-                               WARNING("Failed to look up data streams of \"%ls\": "
-                                       "Access denied!\n%s", path_utf16,
-                                       access_denied_msg);
+                               WARNING("Failed to look up data streams "
+                                       "of \"%ls\": Access denied!\n%ls",
+                                       path, access_denied_msg);
                                return 0;
                        } else {
-                               ERROR("Win32 API: Failed to look up data streams of \"%ls\"",
-                                     path_utf16);
+                               ERROR("Failed to look up data streams "
+                                     "of \"%ls\"", path);
                                win32_error(err);
                                return WIMLIB_ERR_READ;
                        }
                }
        }
        do {
-               ret = win32_capture_stream(path_utf16,
-                                          path_utf16_nchars,
+               ret = win32_capture_stream(path,
+                                          path_num_chars,
                                           inode, lookup_table,
                                           &dat);
                if (ret)
@@ -646,7 +641,7 @@ win32_capture_streams(const wchar_t *path_utf16,
        } while (win32func_FindNextStreamW(hFind, &dat));
        err = GetLastError();
        if (err != ERROR_HANDLE_EOF) {
-               ERROR("Win32 API: Error reading data streams from \"%ls\"", path_utf16);
+               ERROR("Win32 API: Error reading data streams from \"%ls\"", path);
                win32_error(err);
                ret = WIMLIB_ERR_READ;
        }
@@ -661,37 +656,31 @@ unnamed_only:
        } else {
                wcscpy(dat.cStreamName, L"::$DATA");
                dat.StreamSize.QuadPart = file_size;
-               ret = win32_capture_stream(path_utf16,
-                                          path_utf16_nchars,
+               ret = win32_capture_stream(path,
+                                          path_num_chars,
                                           inode, lookup_table,
                                           &dat);
        }
        return ret;
 }
 
-/* Win32 version of capturing a directory tree */
-int
-win32_build_dentry_tree(struct wim_dentry **root_ret,
-                       const mbchar *root_disk_path,
-                       struct wim_lookup_table *lookup_table,
-                       struct wim_security_data *sd,
-                       const struct capture_config *config,
-                       int add_image_flags,
-                       wimlib_progress_func_t progress_func,
-                       void *extra_arg)
+static int
+win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
+                                 const wchar_t *path,
+                                 const size_t path_num_chars,
+                                 struct wim_lookup_table *lookup_table,
+                                 struct sd_set *sd_set,
+                                 const struct capture_config *config,
+                                 int add_image_flags,
+                                 wimlib_progress_func_t progress_func)
 {
        struct wim_dentry *root = NULL;
-       int ret = 0;
        struct wim_inode *inode;
-
-       wchar_t *path_utf16;
-       size_t path_utf16_nbytes;
-       size_t path_utf16_nchars;
-       struct sd_set *sd_set;
        DWORD err;
        u64 file_size;
+       int ret = 0;
 
-       if (exclude_path(root_disk_path, config, true)) {
+       if (exclude_path(path, config, true)) {
                if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) {
                        ERROR("Cannot exclude the root directory from capture");
                        ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
@@ -701,7 +690,7 @@ win32_build_dentry_tree(struct wim_dentry **root_ret,
                    && progress_func)
                {
                        union wimlib_progress_info info;
-                       info.scan.cur_path = root_disk_path;
+                       info.scan.cur_path = path;
                        info.scan.excluded = true;
                        progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
                }
@@ -712,47 +701,34 @@ win32_build_dentry_tree(struct wim_dentry **root_ret,
            && progress_func)
        {
                union wimlib_progress_info info;
-               info.scan.cur_path = root_disk_path;
+               info.scan.cur_path = path;
                info.scan.excluded = false;
                progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
        }
 
-       if (extra_arg == NULL) {
-               sd_set = alloca(sizeof(struct sd_set));
-               sd_set->rb_root.rb_node = NULL,
-               sd_set->sd = sd;
-       } else {
-               sd_set = extra_arg;
-       }
-
-       ret = mbs_to_utf16le(root_disk_path, strlen(root_disk_path),
-                            &path_utf16, &path_utf16_nbytes);
-       if (ret)
-               goto out_destroy_sd_set;
-       path_utf16_nchars = path_utf16_nbytes / sizeof(wchar_t);
-
-       HANDLE hFile = win32_open_existing_file(path_utf16,
+       HANDLE hFile = win32_open_existing_file(path,
                                                FILE_READ_DATA | FILE_READ_ATTRIBUTES);
        if (hFile == INVALID_HANDLE_VALUE) {
                err = GetLastError();
-               ERROR("Win32 API: Failed to open \"%s\"", root_disk_path);
+               ERROR("Win32 API: Failed to open \"%ls\"", path);
                win32_error(err);
                ret = WIMLIB_ERR_OPEN;
-               goto out_free_path_utf16;
+               goto out;
        }
 
        BY_HANDLE_FILE_INFORMATION file_info;
        if (!GetFileInformationByHandle(hFile, &file_info)) {
                err = GetLastError();
-               ERROR("Win32 API: Failed to get file information for \"%s\"",
-                     root_disk_path);
+               ERROR("Win32 API: Failed to get file information for \"%ls\"",
+                     path);
                win32_error(err);
                ret = WIMLIB_ERR_STAT;
                goto out_close_handle;
        }
 
        /* Create a WIM dentry */
-       ret = new_dentry_with_timeless_inode(path_basename(root_disk_path), &root);
+       ret = new_dentry_with_timeless_inode(path_basename_with_len(path, path_num_chars),
+                                            &root);
        if (ret)
                goto out_close_handle;
 
@@ -770,12 +746,12 @@ win32_build_dentry_tree(struct wim_dentry **root_ret,
        add_image_flags &= ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
 
        /* Get DOS name and security descriptor (if any). */
-       ret = win32_get_short_name(root, path_utf16);
+       ret = win32_get_short_name(root, path);
        if (ret)
                goto out_close_handle;
 
        if (!(add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
-               ret = win32_get_security_descriptor(root, sd_set, path_utf16);
+               ret = win32_get_security_descriptor(root, sd_set, path);
                if (ret)
                        goto out_close_handle;
        }
@@ -788,45 +764,38 @@ win32_build_dentry_tree(struct wim_dentry **root_ret,
 
                /* But first... directories may have alternate data streams that
                 * need to be captured. */
-               ret = win32_capture_streams(path_utf16,
-                                           path_utf16_nchars,
+               ret = win32_capture_streams(path,
+                                           path_num_chars,
                                            inode,
                                            lookup_table,
                                            file_size);
                if (ret)
                        goto out_close_handle;
                ret = win32_recurse_directory(root,
-                                             root_disk_path,
+                                             path,
+                                             path_num_chars,
                                              lookup_table,
-                                             sd,
+                                             sd_set,
                                              config,
                                              add_image_flags,
-                                             progress_func,
-                                             sd_set,
-                                             path_utf16,
-                                             path_utf16_nchars);
+                                             progress_func);
        } else if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
                /* Reparse point: save the reparse tag and data */
                ret = win32_capture_reparse_point(hFile,
                                                  inode,
                                                  lookup_table,
-                                                 root_disk_path);
+                                                 path);
        } else {
                /* Not a directory, not a reparse point; capture the default
                 * file contents and any alternate data streams. */
-               ret = win32_capture_streams(path_utf16,
-                                           path_utf16_nchars,
+               ret = win32_capture_streams(path,
+                                           path_num_chars,
                                            inode,
                                            lookup_table,
                                            file_size);
        }
 out_close_handle:
        CloseHandle(hFile);
-out_free_path_utf16:
-       FREE(path_utf16);
-out_destroy_sd_set:
-       if (extra_arg == NULL)
-               destroy_sd_set(sd_set);
 out:
        if (ret == 0)
                *root_ret = root;
@@ -835,6 +804,45 @@ out:
        return ret;
 }
 
+/* Win32 version of capturing a directory tree */
+int
+win32_build_dentry_tree(struct wim_dentry **root_ret,
+                       const wchar_t *root_disk_path,
+                       struct wim_lookup_table *lookup_table,
+                       struct sd_set *sd_set,
+                       const struct capture_config *config,
+                       int add_image_flags,
+                       wimlib_progress_func_t progress_func,
+                       void *extra_arg)
+{
+       size_t path_nchars;
+       wchar_t *path;
+       int ret;
+       
+       path_nchars = wcslen(root_disk_path);
+       if (path_nchars > 32767)
+               return WIMLIB_ERR_INVALID_PARAM;
+
+       /* There is no check for overflow later when this buffer is being used!
+        * But the max path length on NTFS is 32767 characters, and paths need
+        * to be written specially to even go past 260 characters, so we should
+        * be okay with 32770 characters. */
+       path = MALLOC(32770 * sizeof(wchar_t));
+       if (!path)
+               return WIMLIB_ERR_NOMEM;
+
+       ret = win32_build_dentry_tree_recursive(root_ret,
+                                               path,
+                                               path_nchars,
+                                               lookup_table,
+                                               sd_set,
+                                               config,
+                                               add_image_flags,
+                                               progress_func);
+       FREE(path);
+       return ret;
+}
+
 /* Replacement for POSIX fnmatch() (partial functionality only) */
 int
 fnmatch(const wchar_t *pattern, const wchar_t *string, int flags)
@@ -990,7 +998,7 @@ win32_extract_stream(const struct wim_inode *inode,
                        prefix = L"";
                }
                stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t));
-               swprintf(stream_path, stream_path_nchars + 1, L"%ls%ls:%ls",
+               swprintf(stream_path, L"%ls%ls:%ls",
                         prefix, path, stream_name_utf16);
        } else {
                /* Unnamed stream; its path is just the path to the file itself.
@@ -1126,18 +1134,22 @@ out:
 /* Extract a file, directory, reparse point, or hard link to an
  * already-extracted file using the Win32 API */
 int win32_do_apply_dentry(const wchar_t *output_path,
-                         size_t output_path_num_wchars,
+                         size_t output_path_num_chars,
                          struct wim_dentry *dentry,
                          struct apply_args *args)
 {
-       ret = 0;
+       int ret;
+       struct wim_inode *inode = dentry->d_inode;
+       DWORD err;
+
        if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) {
                /* Linked file, with another name already extracted.  Create a
                 * hard link. */
                DEBUG("Creating hard link \"%ls => %ls\"",
                      output_path, inode->i_extracted_file);
-               if (!CreateHardLinkW(utf16le_path, inode->i_extracted_file, NULL))
-               {
+               if (CreateHardLinkW(output_path, inode->i_extracted_file, NULL)) {
+                       ret = 0;
+               } else {
                        err = GetLastError();
                        ERROR("Can't create hard link \"%ls => %ls\"",
                              output_path, inode->i_extracted_file);
@@ -1156,14 +1168,11 @@ int win32_do_apply_dentry(const wchar_t *output_path,
                ret = win32_extract_streams(inode, output_path,
                                            &args->progress.extract.completed_bytes,
                                            security_data);
-               if (ret)
-                       return ret;
-
-               if (inode->i_nlink > 1) {
+               if (ret == 0 && inode->i_nlink > 1) {
                        /* Save extracted path for a later call to
                         * CreateHardLinkW() if this inode has multiple links.
                         * */
-                       inode->i_extracted_file = WSTRDUP(utf16le_path);
+                       inode->i_extracted_file = WSTRDUP(output_path);
                        if (!inode->i_extracted_file)
                                ret = WIMLIB_ERR_NOMEM;
                }
@@ -1173,32 +1182,22 @@ int win32_do_apply_dentry(const wchar_t *output_path,
 
 /* Set timestamps on an extracted file using the Win32 API */
 int
-win32_do_apply_dentry_timestamps(const mbchar *output_path,
-                                size_t output_path_nbytes,
+win32_do_apply_dentry_timestamps(const wchar_t *path,
+                                size_t path_num_chars,
                                 const struct wim_dentry *dentry,
                                 const struct apply_args *args)
 {
-       /* Win32 */
-       wchar_t *utf16le_path;
-       size_t utf16le_path_nbytes;
        DWORD err;
        HANDLE h;
        int ret;
        const struct wim_inode *inode = dentry->d_inode;
 
-       ret = mbs_to_utf16le(output_path, output_path_nbytes,
-                           &utf16le_path, &utf16le_path_nbytes);
-       if (ret)
-               return ret;
-
-       DEBUG("Opening \"%s\" to set timestamps", output_path);
-       h = win32_open_existing_file(utf16le_path, FILE_WRITE_ATTRIBUTES);
-
-       if (h == INVALID_HANDLE_VALUE)
+       DEBUG("Opening \"%ls\" to set timestamps", path);
+       h = win32_open_existing_file(path, FILE_WRITE_ATTRIBUTES);
+       if (h == INVALID_HANDLE_VALUE) {
                err = GetLastError();
-       FREE(utf16le_path);
-       if (h == INVALID_HANDLE_VALUE)
                goto fail;
+       }
 
        FILETIME creationTime = {.dwLowDateTime = inode->i_creation_time & 0xffffffff,
                                 .dwHighDateTime = inode->i_creation_time >> 32};
@@ -1207,21 +1206,21 @@ win32_do_apply_dentry_timestamps(const mbchar *output_path,
        FILETIME lastWriteTime = {.dwLowDateTime = inode->i_last_write_time & 0xffffffff,
                                  .dwHighDateTime = inode->i_last_write_time >> 32};
 
-       DEBUG("Calling SetFileTime() on \"%s\"", output_path);
+       DEBUG("Calling SetFileTime() on \"%ls\"", path);
        if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) {
                err = GetLastError();
                CloseHandle(h);
                goto fail;
        }
-       DEBUG("Closing \"%s\"", output_path);
+       DEBUG("Closing \"%ls\"", path);
        if (!CloseHandle(h)) {
                err = GetLastError();
                goto fail;
        }
        goto out;
 fail:
-       /* Only warn if setting timestamps failed. */
-       WARNING("Can't set timestamps on \"%s\"", output_path);
+       /* Only warn if setting timestamps failed; still return 0. */
+       WARNING("Can't set timestamps on \"%ls\"", path);
        win32_error(err);
 out:
        return 0;
@@ -1311,10 +1310,34 @@ win32_rename_replacement(const wchar_t *oldpath, const wchar_t *newpath)
        }
 }
 
-/* truncate for wide-character paths */
+/* truncate() replacement */
 int
-win32_truncate_replacement(const char *path, off_t size)
+win32_truncate_replacement(const wchar_t *path, off_t size)
 {
-       /* TODO */
-       wimlib_assert(0);
+       DWORD err = NO_ERROR;
+       LARGE_INTEGER liOffset;
+
+       HANDLE h = win32_open_existing_file(path, GENERIC_WRITE);
+       if (h == INVALID_HANDLE_VALUE)
+               goto fail;
+
+       liOffset.QuadPart = size;
+       if (!SetFilePointerEx(h, liOffset, NULL, FILE_BEGIN))
+               goto fail_close_handle;
+
+       if (!SetEndOfFile(h))
+               goto fail_close_handle;
+       CloseHandle(h);
+       return 0;
+
+fail_close_handle:
+       err = GetLastError();
+       CloseHandle(h);
+fail:
+       if (err == NO_ERROR)
+               err = GetLastError();
+       ERROR("Can't truncate %ls to %"PRIu64" bytes", path, size);
+       win32_error(err);
+       errno = -1;
+       return -1;
 }
index 5810caf..672f08a 100644 (file)
@@ -9,7 +9,7 @@ extern int
 win32_build_dentry_tree(struct wim_dentry **root_ret,
                        const tchar *root_disk_path,
                        struct wim_lookup_table *lookup_table,
-                       struct wim_security_data *sd,
+                       struct sd_set *sd,
                        const struct capture_config *config,
                        int add_image_flags,
                        wimlib_progress_func_t progress_func,
index 73ce120..c4382d4 100644 (file)
--- a/src/xml.c
+++ b/src/xml.c
@@ -48,19 +48,19 @@ struct windows_version {
 };
 
 struct windows_info {
-       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;
+       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 {
@@ -77,12 +77,40 @@ struct image_info {
        tchar *description;
        tchar *display_name;
        tchar *display_description;
-       union {
-               tchar *flags;
-               struct wim_lookup_table *lookup_table;
-       };
+       tchar *flags;
+       struct wim_lookup_table *lookup_table; /* Temporary field only */
 };
 
+struct xml_string_spec {
+       const utf8char *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
+
 
 /* Returns a statically allocated string that is a string representation of the
  * architecture number. */
@@ -152,20 +180,21 @@ node_get_hex_u64(const xmlNode *u64_node)
 }
 
 static int
-node_get_string(const xmlNode *string_node, utf8char **str)
+node_get_string(const xmlNode *string_node, tchar **tstr_ret)
 {
        xmlNode *child;
-       utf8char *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;
 }
 
@@ -273,13 +302,13 @@ xml_read_windows_version(const xmlNode *version_node,
  * */
 static int
 xml_read_languages(const xmlNode *languages_node,
-                  utf8char ***languages_ret,
+                  tchar ***languages_ret,
                   size_t *num_languages_ret,
-                  utf8char **default_language_ret)
+                  tchar **default_language_ret)
 {
        xmlNode *child;
        size_t num_languages = 0;
-       utf8char **languages;
+       tchar **languages;
        int ret;
 
        for_node_child(languages_node, child)
@@ -407,12 +436,12 @@ xml_read_image_info(xmlNode *image_node, struct image_info *image_info)
                        return ret;
        }
        if (!image_info->name) {
-               utf8char *empty_name;
+               tchar *empty_name;
                WARNING("Image with index %d has no name", image_info->index);
-               empty_name = MALLOC(1);
+               empty_name = TMALLOC(1);
                if (!empty_name)
                        return WIMLIB_ERR_NOMEM;
-               *empty_name = '\0';
+               *empty_name = T('\0');
                image_info->name = empty_name;
        }
        return ret;
@@ -540,62 +569,35 @@ print_windows_info(const struct windows_info *windows_info)
        }
        tputchar(T('\n'));
        if (windows_info->default_language) {
-               tprintf("Default Language:       %U\n",
+               tprintf(T("Default Language:       %"TS"\n"),
                        windows_info->default_language);
        }
-       if (windows_info->system_root)
-               wimlib_printf("System Root:            %U\n",
+       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);
        }
 }
 
-const 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),
-       ELEM("DEFAULT", default_language),
-       ELEM("SYSTEMROOT", system_root),
-};
-
 static int
 xml_write_string(xmlTextWriter *writer, const char *name,
                 const tchar *tstr)
 {
        if (tstr) {
-               const utf8char *utf8_str;
+               utf8char *utf8_str;
                int rc = tstr_to_utf8_simple(tstr, &utf8_str);
                if (rc)
                        return rc;
@@ -608,8 +610,10 @@ xml_write_string(xmlTextWriter *writer, const char *name,
 }
 
 static int
-xml_write_strings_from_specs(xmlTextWriter *writer, const void *struct_with_strings,
-                            const struct xml_string_spec *specs, size_t num_specs)
+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,
@@ -621,7 +625,24 @@ xml_write_strings_from_specs(xmlTextWriter *writer, const void *struct_with_stri
        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>
@@ -679,47 +700,12 @@ 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");
@@ -727,14 +713,15 @@ 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> */
@@ -748,12 +735,10 @@ xml_write_windows_info(xmlTextWriter *writer,
                        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;
 
        return xmlTextWriterEndElement(writer); /* </WINDOWS> */
 }
@@ -867,19 +852,10 @@ add_image_info_struct(struct wim_info *wim_info)
 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 (old->languages) {
                new->languages = CALLOC(old->num_languages, sizeof(new->languages[0]));
@@ -889,15 +865,15 @@ clone_windows_info(const struct windows_info *old, struct windows_info *new)
                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;
@@ -910,6 +886,8 @@ clone_windows_info(const struct windows_info *old, struct windows_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;
@@ -917,29 +895,18 @@ 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;
 }
@@ -989,13 +956,13 @@ 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;
        }
@@ -1039,9 +1006,8 @@ xml_get_max_image_name_len(const WIMStruct *w)
 {
        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);
+                       size_t len = tstrlen(w->wim_info->images[i].name);
                        if (len > max_len)
                                max_len = len;
                }
@@ -1142,7 +1108,6 @@ void
 xml_update_image_info(WIMStruct *w, int image)
 {
        struct image_info *image_info;
-       utf8char *flags_save;
 
        DEBUG("Updating the image info for image %d", image);
 
@@ -1153,18 +1118,16 @@ xml_update_image_info(WIMStruct *w, int image)
        image_info->total_bytes     = 0;
        image_info->hard_link_bytes = 0;
 
-       flags_save = image_info->flags;
        image_info->lookup_table = w->lookup_table;
        for_dentry_in_tree(w->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 utf8char *name)
+xml_add_image(WIMStruct *w, const tchar *name)
 {
        struct wim_info *wim_info;
        struct image_info *image_info;
@@ -1185,7 +1148,7 @@ xml_add_image(WIMStruct *w, const utf8char *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;
@@ -1209,47 +1172,49 @@ void
 print_image_info(const struct wim_info *wim_info, int image)
 {
        const struct image_info *image_info;
-       const utf8char *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);
-       wimlib_printf("Name:                   %U\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 = "";
-       wimlib_printf("Description:            %U\n", desc);
+               desc = T("");
+       tprintf(T("Description:            %"TS"\n"), desc);
 
-       if (image_info->display_name)
-               wimlib_printf("Display Name:           %U\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)
-               wimlib_printf("Display Description:    %U\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);
+       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');
 }
 
 void
@@ -1512,12 +1477,12 @@ wimlib_get_image_description(const WIMStruct *w, int image)
 
 /* 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 utf8char *name)
+wimlib_image_name_in_use(const WIMStruct *w, 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)
+               if (tstrcmp(w->wim_info->images[i - 1].name, name) == 0)
                        return true;
        return false;
 }
@@ -1541,12 +1506,12 @@ wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
 
 /* Sets the name of an image in the WIM. */
 WIMLIBAPI int
-wimlib_set_image_name(WIMStruct *w, int image, const utf8char *name)
+wimlib_set_image_name(WIMStruct *w, int image, const tchar *name)
 {
-       utf8char *p;
+       tchar *p;
        int i;
 
-       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");
@@ -1561,14 +1526,14 @@ wimlib_set_image_name(WIMStruct *w, int image, const utf8char *name)
        for (i = 1; i <= w->hdr.image_count; i++) {
                if (i == image)
                        continue;
-               if (strcmp(w->wim_info->images[i - 1].name, name) == 0) {
-                       ERROR("The name `%U' is already in use in the WIM!",
+               if (tstrcmp(w->wim_info->images[i - 1].name, name) == 0) {
+                       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;
 
@@ -1577,47 +1542,44 @@ wimlib_set_image_name(WIMStruct *w, int image, const utf8char *name)
        return 0;
 }
 
-/* Sets the description of an image in the WIM. */
-WIMLIBAPI int
-wimlib_set_image_descripton(WIMStruct *w, int image,
-                           const utf8char *description)
+static int
+do_set_image_info_str(WIMStruct *w, int image, const tchar *tstr,
+                     size_t offset)
 {
-       utf8char *p;
+       tchar *tstr_copy;
+       tchar **dest_tstr_p;
 
        if (image < 1 || image > w->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*)&w->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 */
+/* Sets the description of an image in the WIM. */
 WIMLIBAPI int
-wimlib_set_image_flags(WIMStruct *w, int image, const utf8char *flags)
+wimlib_set_image_descripton(WIMStruct *w, int image,
+                           const tchar *description)
 {
-       utf8char *p;
+       return do_set_image_info_str(w, 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;
+/* Set the <FLAGS> element of a WIM image */
+WIMLIBAPI int
+wimlib_set_image_flags(WIMStruct *w, int image, const tchar *flags)
+{
+       return do_set_image_info_str(w, image, flags,
+                                    offsetof(struct image_info, flags));
 }