add System Compression support
[wimlib] / src / win32_apply.c
index 9d627db..0367719 100644 (file)
 #include "wimlib/error.h"
 #include "wimlib/metadata.h"
 #include "wimlib/paths.h"
+#include "wimlib/pattern.h"
 #include "wimlib/reparse.h"
 #include "wimlib/textfile.h"
 #include "wimlib/xml.h"
-#include "wimlib/wildcard.h"
 #include "wimlib/wimboot.h"
+#include "wimlib/wof.h"
 
 struct win32_apply_ctx {
 
@@ -59,17 +60,18 @@ struct win32_apply_ctx {
                        u8 blob_table_hash[SHA1_HASH_SIZE];
                } *wims;
                size_t num_wims;
-               struct string_set *prepopulate_pats;
-               void *mem_prepopulate_pats;
                bool wof_running;
-               bool tried_to_load_prepopulate_list;
-
                bool have_wrong_version_wims;
                bool have_uncompressed_wims;
                bool have_unsupported_compressed_resources;
                bool have_huge_resources;
        } wimboot;
 
+       /* External backing information  */
+       struct string_set *prepopulate_pats;
+       void *mem_prepopulate_pats;
+       bool tried_to_load_prepopulate_list;
+
        /* Open handle to the target directory  */
        HANDLE h_target;
 
@@ -122,12 +124,12 @@ struct win32_apply_ctx {
         * beginning of the array)  */
        unsigned num_open_handles;
 
-       /* List of dentries, joined by @tmp_list, that need to have reparse data
-        * extracted as soon as the whole blob has been read into @data_buffer.
-        * */
+       /* List of dentries, joined by @d_tmp_list, that need to have reparse
+        * data extracted as soon as the whole blob has been read into
+        * @data_buffer.  */
        struct list_head reparse_dentries;
 
-       /* List of dentries, joined by @tmp_list, that need to have raw
+       /* List of dentries, joined by @d_tmp_list, that need to have raw
         * encrypted data extracted as soon as the whole blob has been read into
         * @data_buffer.  */
        struct list_head encrypted_dentries;
@@ -146,6 +148,9 @@ struct win32_apply_ctx {
        /* Number of files for which we couldn't remove the short name.  */
        unsigned long num_remove_short_name_failures;
 
+       /* Number of files on which we couldn't set System Compression.  */
+       unsigned long num_system_compression_failures;
+
        /* Have we tried to enable short name support on the target volume yet?
         */
        bool tried_to_enable_short_names;
@@ -282,8 +287,22 @@ win32_get_supported_features(const wchar_t *target,
        return 0;
 }
 
-/* Load the patterns from [PrepopulateList] of WimBootCompress.ini in the WIM
- * image being extracted.  */
+#define COMPACT_FLAGS  (WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K |         \
+                        WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K |         \
+                        WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K |        \
+                        WIMLIB_EXTRACT_FLAG_COMPACT_LZX)
+
+
+
+/*
+ * If not done already, load the patterns from the [PrepopulateList] section of
+ * WimBootCompress.ini in the WIM image being extracted.
+ *
+ * Note: WimBootCompress.ini applies to both types of "external backing":
+ *
+ *     - WIM backing ("WIMBoot" - Windows 8.1 and later)
+ *     - File backing ("System Compression" - Windows 10 and later)
+ */
 static int
 load_prepopulate_pats(struct win32_apply_ctx *ctx)
 {
@@ -296,7 +315,10 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx)
        void *mem;
        struct text_file_section sec;
 
-       ctx->wimboot.tried_to_load_prepopulate_list = true;
+       if (ctx->tried_to_load_prepopulate_list)
+               return 0;
+
+       ctx->tried_to_load_prepopulate_list = true;
 
        dentry = get_dentry(ctx->common.wim, path, WIMLIB_CASE_INSENSITIVE);
        if (!dentry ||
@@ -336,33 +358,19 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx)
                FREE(s);
                return ret;
        }
-       ctx->wimboot.prepopulate_pats = s;
-       ctx->wimboot.mem_prepopulate_pats = mem;
+       ctx->prepopulate_pats = s;
+       ctx->mem_prepopulate_pats = mem;
        return 0;
 }
 
-/* Returns %true if the specified absolute path to a file in the WIM image
- * matches a pattern in [PrepopulateList] of WimBootCompress.ini.  Otherwise
- * returns %false.  */
-static bool
-in_prepopulate_list(const wchar_t *path, size_t path_nchars,
-                   const struct win32_apply_ctx *ctx)
-{
-       const struct string_set *pats = ctx->wimboot.prepopulate_pats;
-
-       if (!pats || !pats->num_strings)
-               return false;
-
-       return match_pattern_list(path, path_nchars, pats);
-}
-
 /* Returns %true if the specified absolute path to a file in the WIM image can
  * be subject to external backing when extracted.  Otherwise returns %false.  */
 static bool
-can_externally_back_path(const wchar_t *path, size_t path_nchars,
-                        const struct win32_apply_ctx *ctx)
+can_externally_back_path(const wchar_t *path, const struct win32_apply_ctx *ctx)
 {
-       if (in_prepopulate_list(path, path_nchars, ctx))
+       /* Does the path match a pattern given in the [PrepopulateList] section
+        * of WimBootCompress.ini?  */
+       if (ctx->prepopulate_pats && match_pattern_list(path, ctx->prepopulate_pats))
                return false;
 
        /* Since we attempt to modify the SYSTEM registry after it's extracted
@@ -374,13 +382,14 @@ can_externally_back_path(const wchar_t *path, size_t path_nchars,
         * However, a WIM that wasn't specifically captured in "WIMBoot mode"
         * may contain SYSTEM.* files.  So to make things "just work", hard-code
         * the pattern.  */
-       if (match_path(path, path_nchars, L"\\Windows\\System32\\config\\SYSTEM*",
-                      OS_PREFERRED_PATH_SEPARATOR, false))
+       if (match_path(path, L"\\Windows\\System32\\config\\SYSTEM*", false))
                return false;
 
        return true;
 }
 
+/* Can the specified WIM resource be used as the source of an external backing
+ * for the wof.sys WIM provider?  */
 static bool
 is_resource_valid_for_external_backing(const struct wim_resource_descriptor *rdesc,
                                       struct win32_apply_ctx *ctx)
@@ -450,19 +459,38 @@ is_resource_valid_for_external_backing(const struct wim_resource_descriptor *rde
        return true;
 }
 
-#define WIM_BACKING_NOT_ENABLED                -1
-#define WIM_BACKING_NOT_POSSIBLE       -2
-#define WIM_BACKING_EXCLUDED           -3
+#define EXTERNAL_BACKING_NOT_ENABLED           -1
+#define EXTERNAL_BACKING_NOT_POSSIBLE          -2
+#define EXTERNAL_BACKING_EXCLUDED              -3
 
+/*
+ * Determines whether the specified file will be externally backed.  Returns a
+ * negative status code if no, 0 if yes, or a positive wimlib error code on
+ * error.  If the file is excluded from external backing based on its path, then
+ * *excluded_dentry_ret is set to the dentry for the path that matched the
+ * exclusion rule.
+ *
+ * Note that this logic applies to both types of "external backing":
+ *
+ *     - WIM backing ("WIMBoot" - Windows 8.1 and later)
+ *     - File backing ("System Compression" - Windows 10 and later)
+ *
+ * However, in the case of WIM backing we also need to validate that the WIM
+ * resource that would be the source of the backing is supported by the wof.sys
+ * WIM provider.
+ */
 static int
 will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx,
-                          const struct wim_dentry **excluded_dentry_ret)
+                          const struct wim_dentry **excluded_dentry_ret,
+                          bool wimboot_mode)
 {
-       struct list_head *next;
        struct wim_dentry *dentry;
        struct blob_descriptor *blob;
        int ret;
 
+       if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
+               return WIMLIB_ERR_NOMEM;
+
        if (inode->i_can_externally_back)
                return 0;
 
@@ -474,58 +502,54 @@ will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx,
        if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
                                   FILE_ATTRIBUTE_REPARSE_POINT |
                                   FILE_ATTRIBUTE_ENCRYPTED))
-               return WIM_BACKING_NOT_POSSIBLE;
+               return EXTERNAL_BACKING_NOT_POSSIBLE;
 
        blob = inode_get_blob_for_unnamed_data_stream_resolved(inode);
 
-       if (!blob || blob->blob_location != BLOB_IN_WIM ||
-           !is_resource_valid_for_external_backing(blob->rdesc, ctx))
-               return WIM_BACKING_NOT_POSSIBLE;
+       if (!blob)
+               return EXTERNAL_BACKING_NOT_POSSIBLE;
+
+       if (wimboot_mode &&
+           (blob->blob_location != BLOB_IN_WIM ||
+            !is_resource_valid_for_external_backing(blob->rdesc, ctx)))
+               return EXTERNAL_BACKING_NOT_POSSIBLE;
 
        /*
         * We need to check the patterns in [PrepopulateList] against every name
         * of the inode, in case any of them match.
         */
-       next = inode->i_extraction_aliases.next;
-       do {
-               dentry = list_entry(next, struct wim_dentry,
-                                   d_extraction_alias_node);
+
+       inode_for_each_extraction_alias(dentry, inode) {
 
                ret = calculate_dentry_full_path(dentry);
                if (ret)
                        return ret;
 
-               if (!can_externally_back_path(dentry->_full_path,
-                                             wcslen(dentry->_full_path), ctx))
-               {
+               if (!can_externally_back_path(dentry->d_full_path, ctx)) {
                        if (excluded_dentry_ret)
                                *excluded_dentry_ret = dentry;
-                       return WIM_BACKING_EXCLUDED;
+                       return EXTERNAL_BACKING_EXCLUDED;
                }
-               next = next->next;
-       } while (next != &inode->i_extraction_aliases);
+       }
 
        inode->i_can_externally_back = 1;
        return 0;
 }
 
 /*
- * Determines if the unnamed data stream of a file will be created as an
- * external backing, as opposed to a standard extraction.
+ * Determines if the unnamed data stream of a file will be created as a WIM
+ * external backing (a "WIMBoot pointer file"), as opposed to a standard
+ * extraction.
  */
 static int
-win32_will_externally_back(struct wim_dentry *dentry, struct apply_ctx *_ctx)
+win32_will_back_from_wim(struct wim_dentry *dentry, struct apply_ctx *_ctx)
 {
        struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx;
 
        if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
-               return WIM_BACKING_NOT_ENABLED;
+               return EXTERNAL_BACKING_NOT_ENABLED;
 
-       if (!ctx->wimboot.tried_to_load_prepopulate_list)
-               if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
-                       return WIMLIB_ERR_NOMEM;
-
-       return will_externally_back_inode(dentry->d_inode, ctx, NULL);
+       return will_externally_back_inode(dentry->d_inode, ctx, NULL, true);
 }
 
 /* Find the WOF registration information for the specified WIM file.  */
@@ -541,27 +565,27 @@ find_wimboot_wim(WIMStruct *wim_to_find, struct win32_apply_ctx *ctx)
 }
 
 static int
-set_external_backing(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx)
+set_backed_from_wim(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx)
 {
        int ret;
        const struct wim_dentry *excluded_dentry;
        const struct blob_descriptor *blob;
        const struct wimboot_wim *wimboot_wim;
 
-       ret = will_externally_back_inode(inode, ctx, &excluded_dentry);
+       ret = will_externally_back_inode(inode, ctx, &excluded_dentry, true);
        if (ret > 0) /* Error.  */
                return ret;
 
-       if (ret < 0 && ret != WIM_BACKING_EXCLUDED)
+       if (ret < 0 && ret != EXTERNAL_BACKING_EXCLUDED)
                return 0; /* Not externally backing, other than due to exclusion.  */
 
-       if (unlikely(ret == WIM_BACKING_EXCLUDED)) {
+       if (unlikely(ret == EXTERNAL_BACKING_EXCLUDED)) {
                /* Not externally backing due to exclusion.  */
                union wimlib_progress_info info;
 
                build_extraction_path(excluded_dentry, ctx);
 
-               info.wimboot_exclude.path_in_wim = excluded_dentry->_full_path;
+               info.wimboot_exclude.path_in_wim = excluded_dentry->d_full_path;
                info.wimboot_exclude.extraction_path = current_path(ctx);
 
                return call_progress(ctx->common.progfunc,
@@ -635,8 +659,7 @@ register_wim_with_wof(WIMStruct *wim, struct win32_apply_ctx *ctx)
        return 0;
 }
 
-/* Prepare for doing a "WIMBoot" extraction by loading patterns from
- * [PrepopulateList] of WimBootCompress.ini and registering each source WIM file
+/* Prepare for doing a "WIMBoot" extraction by registering each source WIM file
  * with WOF on the target volume.  */
 static int
 start_wimboot_extraction(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
@@ -644,10 +667,6 @@ start_wimboot_extraction(struct list_head *dentry_list, struct win32_apply_ctx *
        int ret;
        struct wim_dentry *dentry;
 
-       if (!ctx->wimboot.tried_to_load_prepopulate_list)
-               if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
-                       return WIMLIB_ERR_NOMEM;
-
        if (!wim_info_get_wimboot(ctx->common.wim->wim_info,
                                  ctx->common.wim->current_image))
                WARNING("The WIM image is not marked as WIMBoot compatible.  This usually\n"
@@ -657,7 +676,7 @@ start_wimboot_extraction(struct list_head *dentry_list, struct win32_apply_ctx *
        list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
                struct blob_descriptor *blob;
 
-               ret = win32_will_externally_back(dentry, &ctx->common);
+               ret = win32_will_back_from_wim(dentry, &ctx->common);
                if (ret > 0) /* Error */
                        return ret;
                if (ret < 0) /* Won't externally back */
@@ -1028,17 +1047,12 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
 static struct wim_dentry *
 first_extraction_alias(const struct wim_inode *inode)
 {
-       struct list_head *next = inode->i_extraction_aliases.next;
        struct wim_dentry *dentry;
 
-       do {
-               dentry = list_entry(next, struct wim_dentry,
-                                   d_extraction_alias_node);
+       inode_for_each_extraction_alias(dentry, inode)
                if (dentry_has_short_name(dentry))
-                       break;
-               next = next->next;
-       } while (next != &inode->i_extraction_aliases);
-       return dentry;
+                       return dentry;
+       return inode_first_extraction_dentry(inode);
 }
 
 /*
@@ -1158,7 +1172,7 @@ remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_appl
        name = &ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)];
        while (name != ctx->pathbuf.Buffer && *(name - 1) != L'\\')
                name--;
-       end = mempcpy(name, dentry->short_name, dentry->short_name_nbytes);
+       end = mempcpy(name, dentry->d_short_name, dentry->d_short_name_nbytes);
        ctx->pathbuf.Length = ((u8 *)end - (u8 *)ctx->pathbuf.Buffer);
 
        /* Open the conflicting file (by short name).  */
@@ -1235,7 +1249,7 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry,
         */
 
        size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
-                        max(dentry->short_name_nbytes, sizeof(wchar_t)) +
+                        max(dentry->d_short_name_nbytes, sizeof(wchar_t)) +
                         sizeof(wchar_t);
        u8 buf[bufsize] _aligned_attribute(8);
        FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
@@ -1244,8 +1258,8 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry,
 
        memset(buf, 0, bufsize);
 
-       info->FileNameLength = dentry->short_name_nbytes;
-       memcpy(info->FileName, dentry->short_name, dentry->short_name_nbytes);
+       info->FileNameLength = dentry->d_short_name_nbytes;
+       memcpy(info->FileName, dentry->d_short_name, dentry->d_short_name_nbytes);
 
 retry:
        status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize,
@@ -1254,7 +1268,7 @@ retry:
                return 0;
 
        if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) {
-               if (dentry->short_name_nbytes == 0)
+               if (dentry->d_short_name_nbytes == 0)
                        return 0;
                if (!ctx->tried_to_enable_short_names) {
                        wchar_t volume[7];
@@ -1288,7 +1302,7 @@ retry:
         *   from files.
         */
        if (unlikely(status == STATUS_OBJECT_NAME_COLLISION) &&
-           dentry->short_name_nbytes && !tried_to_remove_existing)
+           dentry->d_short_name_nbytes && !tried_to_remove_existing)
        {
                tried_to_remove_existing = true;
                status = remove_conflicting_short_name(dentry, ctx);
@@ -1299,7 +1313,7 @@ retry:
        /* By default, failure to set short names is not an error (since short
         * names aren't too important anymore...).  */
        if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES)) {
-               if (dentry->short_name_nbytes)
+               if (dentry->d_short_name_nbytes)
                        ctx->num_set_short_name_failures++;
                else
                        ctx->num_remove_short_name_failures++;
@@ -1473,44 +1487,104 @@ retry:
        return WIMLIB_ERR_OPEN;
 }
 
+/* Set the reparse point @rpbuf of length @rpbuflen on the extracted file
+ * corresponding to the WIM dentry @dentry.  */
+static int
+do_set_reparse_point(const struct wim_dentry *dentry,
+                    const struct reparse_buffer_disk *rpbuf, u16 rpbuflen,
+                    struct win32_apply_ctx *ctx)
+{
+       NTSTATUS status;
+       HANDLE h;
+
+       status = create_file(&h, GENERIC_WRITE, NULL,
+                            0, FILE_OPEN, 0, dentry, ctx);
+       if (!NT_SUCCESS(status))
+               goto fail;
+
+       status = (*func_NtFsControlFile)(h, NULL, NULL, NULL,
+                                        &ctx->iosb, FSCTL_SET_REPARSE_POINT,
+                                        (void *)rpbuf, rpbuflen,
+                                        NULL, 0);
+       (*func_NtClose)(h);
+
+       if (NT_SUCCESS(status))
+               return 0;
+
+       /* On Windows, by default only the Administrator can create symbolic
+        * links for some reason.  By default we just issue a warning if this
+        * appears to be the problem.  Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS
+        * to get a hard error.  */
+       if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS)
+           && (status == STATUS_PRIVILEGE_NOT_HELD ||
+               status == STATUS_ACCESS_DENIED)
+           && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
+               dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
+       {
+               WARNING("Can't create symbolic link \"%ls\"!              \n"
+                       "          (Need Administrator rights, or at least "
+                       "the\n"
+                       "          SeCreateSymbolicLink privilege.)",
+                       current_path(ctx));
+               return 0;
+       }
+
+fail:
+       winnt_error(status, L"Can't set reparse data on \"%ls\"",
+                   current_path(ctx));
+       return WIMLIB_ERR_SET_REPARSE_DATA;
+}
+
 /*
- * Create empty named data streams for the specified file, if there are any.
+ * Create empty named data streams and potentially a reparse point for the
+ * specified file, if any.
  *
  * Since these won't have blob descriptors, they won't show up in the call to
  * extract_blob_list().  Hence the need for the special case.
  */
 static int
-create_empty_named_data_streams(const struct wim_dentry *dentry,
-                               struct win32_apply_ctx *ctx)
+create_empty_streams(const struct wim_dentry *dentry,
+                    struct win32_apply_ctx *ctx)
 {
        const struct wim_inode *inode = dentry->d_inode;
-       bool path_modified = false;
-       int ret = 0;
-
-       if (!ctx->common.supported_features.named_data_streams)
-               return 0;
+       int ret;
 
        for (unsigned i = 0; i < inode->i_num_streams; i++) {
                const struct wim_inode_stream *strm = &inode->i_streams[i];
-               HANDLE h;
 
-               if (!stream_is_named_data_stream(strm) ||
-                   stream_blob_resolved(strm) != NULL)
+               if (stream_blob_resolved(strm) != NULL)
                        continue;
 
-               build_extraction_path_with_ads(dentry, ctx,
-                                              strm->stream_name,
-                                              utf16le_len_chars(strm->stream_name));
-               path_modified = true;
-               ret = supersede_file_or_stream(ctx, &h);
-               if (ret)
-                       break;
-               (*func_NtClose)(h);
+               if (strm->stream_type == STREAM_TYPE_REPARSE_POINT &&
+                   ctx->common.supported_features.reparse_points)
+               {
+                       u8 buf[REPARSE_DATA_OFFSET] _aligned_attribute(8);
+                       struct reparse_buffer_disk *rpbuf =
+                               (struct reparse_buffer_disk *)buf;
+                       complete_reparse_point(rpbuf, inode, 0);
+                       ret = do_set_reparse_point(dentry, rpbuf,
+                                                  REPARSE_DATA_OFFSET, ctx);
+                       if (ret)
+                               return ret;
+               } else if (stream_is_named_data_stream(strm) &&
+                          ctx->common.supported_features.named_data_streams)
+               {
+                       HANDLE h;
+
+                       build_extraction_path_with_ads(dentry, ctx,
+                                                      strm->stream_name,
+                                                      utf16le_len_chars(strm->stream_name));
+                       ret = supersede_file_or_stream(ctx, &h);
+
+                       build_extraction_path(dentry, ctx);
+
+                       if (ret)
+                               return ret;
+                       (*func_NtClose)(h);
+               }
        }
-       /* Restore the path to the dentry itself  */
-       if (path_modified)
-               build_extraction_path(dentry, ctx);
-       return ret;
+
+       return 0;
 }
 
 /*
@@ -1596,7 +1670,7 @@ create_directories(struct list_head *dentry_list,
                ret = create_directory(dentry, ctx);
 
                if (!ret)
-                       ret = create_empty_named_data_streams(dentry, ctx);
+                       ret = create_empty_streams(dentry, ctx);
 
                ret = check_apply_error(dentry, ctx, ret);
                if (ret)
@@ -1633,7 +1707,7 @@ create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry,
        if (ret)
                goto out_close;
 
-       ret = create_empty_named_data_streams(dentry, ctx);
+       ret = create_empty_streams(dentry, ctx);
        if (ret)
                goto out_close;
 
@@ -1706,23 +1780,17 @@ static int
 create_links(HANDLE h, const struct wim_dentry *first_dentry,
             struct win32_apply_ctx *ctx)
 {
-       const struct wim_inode *inode;
-       const struct list_head *next;
+       const struct wim_inode *inode = first_dentry->d_inode;
        const struct wim_dentry *dentry;
        int ret;
 
-       inode = first_dentry->d_inode;
-       next = inode->i_extraction_aliases.next;
-       do {
-               dentry = list_entry(next, struct wim_dentry,
-                                   d_extraction_alias_node);
+       inode_for_each_extraction_alias(dentry, inode) {
                if (dentry != first_dentry) {
                        ret = create_link(h, dentry, ctx);
                        if (ret)
                                return ret;
                }
-               next = next->next;
-       } while (next != &inode->i_extraction_aliases);
+       }
        return 0;
 }
 
@@ -1751,7 +1819,7 @@ create_nondirectory(struct wim_inode *inode, struct win32_apply_ctx *ctx)
 
        /* "WIMBoot" extraction: set external backing by the WIM file if needed.  */
        if (!ret && unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
-               ret = set_external_backing(h, inode, ctx);
+               ret = set_backed_from_wim(h, inode, ctx);
 
        (*func_NtClose)(h);
        return ret;
@@ -1830,7 +1898,7 @@ begin_extract_blob_instance(const struct blob_descriptor *blob,
                 * data be available.  So, stage the data in a buffer.  */
                if (!prepare_data_buffer(ctx, blob->size))
                        return WIMLIB_ERR_NOMEM;
-               list_add_tail(&dentry->tmp_list, &ctx->reparse_dentries);
+               list_add_tail(&dentry->d_tmp_list, &ctx->reparse_dentries);
                return 0;
        }
 
@@ -1848,7 +1916,7 @@ begin_extract_blob_instance(const struct blob_descriptor *blob,
                 * such files...  */
                if (!prepare_data_buffer(ctx, blob->size))
                        return WIMLIB_ERR_NOMEM;
-               list_add_tail(&dentry->tmp_list, &ctx->encrypted_dentries);
+               list_add_tail(&dentry->d_tmp_list, &ctx->encrypted_dentries);
                return 0;
        }
 
@@ -1896,54 +1964,6 @@ begin_extract_blob_instance(const struct blob_descriptor *blob,
        return 0;
 }
 
-/* Set the reparse data @rpbuf of length @rpbuflen on the extracted file
- * corresponding to the WIM dentry @dentry.  */
-static int
-do_set_reparse_data(const struct wim_dentry *dentry,
-                   const void *rpbuf, u16 rpbuflen,
-                   struct win32_apply_ctx *ctx)
-{
-       NTSTATUS status;
-       HANDLE h;
-
-       status = create_file(&h, GENERIC_WRITE, NULL,
-                            0, FILE_OPEN, 0, dentry, ctx);
-       if (!NT_SUCCESS(status))
-               goto fail;
-
-       status = (*func_NtFsControlFile)(h, NULL, NULL, NULL,
-                                        &ctx->iosb, FSCTL_SET_REPARSE_POINT,
-                                        (void *)rpbuf, rpbuflen,
-                                        NULL, 0);
-       (*func_NtClose)(h);
-
-       if (NT_SUCCESS(status))
-               return 0;
-
-       /* On Windows, by default only the Administrator can create symbolic
-        * links for some reason.  By default we just issue a warning if this
-        * appears to be the problem.  Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS
-        * to get a hard error.  */
-       if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS)
-           && (status == STATUS_PRIVILEGE_NOT_HELD ||
-               status == STATUS_ACCESS_DENIED)
-           && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
-               dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
-       {
-               WARNING("Can't create symbolic link \"%ls\"!              \n"
-                       "          (Need Administrator rights, or at least "
-                       "the\n"
-                       "          SeCreateSymbolicLink privilege.)",
-                       current_path(ctx));
-               return 0;
-       }
-
-fail:
-       winnt_error(status, L"Can't set reparse data on \"%ls\"",
-                   current_path(ctx));
-       return WIMLIB_ERR_SET_REPARSE_DATA;
-}
-
 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
  * pointer to the suffix of the path that begins with the device directly, such
  * as e:\Windows\System32.  */
@@ -1955,33 +1975,27 @@ skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars)
                L"\\DosDevices\\",
                L"\\Device\\",
        };
-       size_t first_dir_len = 0;
        const wchar_t * const end = path + path_nchars;
 
        for (size_t i = 0; i < ARRAY_LEN(dirs); i++) {
                size_t len = wcslen(dirs[i]);
-               if (len <= (end - path) && !wcsnicmp(path, dirs[i], len)) {
-                       first_dir_len = len;
-                       break;
+               if (len <= (end - path) && !wmemcmp(path, dirs[i], len)) {
+                       path += len;
+                       while (path != end && *path == L'\\')
+                               path++;
+                       return path;
                }
        }
-       if (first_dir_len == 0)
-               return path;
-       path += first_dir_len;
-       while (path != end && *path == L'\\')
-               path++;
        return path;
 }
 
-/* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
- * pointer to the suffix of the path that is device-relative, such as
- * Windows\System32.
+/*
+ * Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
+ * pointer to the suffix of the path that is device-relative but possibly with
+ * leading slashes, such as \Windows\System32.
  *
  * The path has an explicit length and is not necessarily null terminated.
- *
- * If the path just something like \??\e: then the returned pointer will point
- * just past the colon.  In this case the length of the result will be 0
- * characters.  */
+ */
 static const wchar_t *
 get_device_relative_path(const wchar_t *path, size_t path_nchars)
 {
@@ -1992,24 +2006,22 @@ get_device_relative_path(const wchar_t *path, size_t path_nchars)
        if (path == orig_path)
                return orig_path;
 
-       path = wmemchr(path, L'\\', (end - path));
-       if (!path)
-               return end;
-       do {
+       while (path != end && *path != L'\\')
                path++;
-       } while (path != end && *path == L'\\');
+
        return path;
 }
 
 /*
- * Given a reparse point buffer for a symbolic link or junction, adjust its
- * contents so that the target of the link is consistent with the new location
- * of the files.
+ * Given a reparse point buffer for an inode for which the absolute link target
+ * was relativized when it was archived, de-relative the link target to be
+ * consistent with the actual extraction location.
  */
 static void
-try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
+try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p,
+         struct win32_apply_ctx *ctx)
 {
-       struct reparse_data rpdata;
+       struct link_reparse_point link;
        size_t orig_subst_name_nchars;
        const wchar_t *relpath;
        size_t relpath_nchars;
@@ -2018,43 +2030,33 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
        const wchar_t *fixed_print_name;
        size_t fixed_print_name_nchars;
 
-       if (parse_reparse_data(rpbuf, *rpbuflen_p, &rpdata)) {
-               /* Do nothing if the reparse data is invalid.  */
+       /* Do nothing if the reparse data is invalid.  */
+       if (parse_link_reparse_point(rpbuf, *rpbuflen_p, &link))
                return;
-       }
 
-       if (rpdata.rptag == WIM_IO_REPARSE_TAG_SYMLINK &&
-           (rpdata.rpflags & SYMBOLIC_LINK_RELATIVE))
-       {
-               /* Do nothing if it's a relative symbolic link.  */
+       /* Do nothing if the reparse point is a relative symbolic link.  */
+       if (link_is_relative_symlink(&link))
                return;
-       }
 
        /* Build the new substitute name from the NT namespace path to the
         * target directory, then a path separator, then the "device relative"
         * part of the old substitute name.  */
 
-       orig_subst_name_nchars = rpdata.substitute_name_nbytes / sizeof(wchar_t);
+       orig_subst_name_nchars = link.substitute_name_nbytes / sizeof(wchar_t);
 
-       relpath = get_device_relative_path(rpdata.substitute_name,
+       relpath = get_device_relative_path(link.substitute_name,
                                           orig_subst_name_nchars);
        relpath_nchars = orig_subst_name_nchars -
-                        (relpath - rpdata.substitute_name);
+                        (relpath - link.substitute_name);
 
        target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
 
-       fixed_subst_name_nchars = target_ntpath_nchars;
-       if (relpath_nchars)
-               fixed_subst_name_nchars += 1 + relpath_nchars;
+       fixed_subst_name_nchars = target_ntpath_nchars + relpath_nchars;
+
        wchar_t fixed_subst_name[fixed_subst_name_nchars];
 
-       wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer,
-               target_ntpath_nchars);
-       if (relpath_nchars) {
-               fixed_subst_name[target_ntpath_nchars] = L'\\';
-               wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
-                       relpath, relpath_nchars);
-       }
+       wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, target_ntpath_nchars);
+       wmemcpy(&fixed_subst_name[target_ntpath_nchars], relpath, relpath_nchars);
        /* Doesn't need to be null-terminated.  */
 
        /* Print name should be Win32, but not all NT names can even be
@@ -2066,33 +2068,29 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
        fixed_print_name_nchars = fixed_subst_name_nchars - (fixed_print_name -
                                                             fixed_subst_name);
 
-       rpdata.substitute_name = fixed_subst_name;
-       rpdata.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t);
-       rpdata.print_name = (wchar_t *)fixed_print_name;
-       rpdata.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t);
-       make_reparse_buffer(&rpdata, rpbuf, rpbuflen_p);
+       link.substitute_name = fixed_subst_name;
+       link.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t);
+       link.print_name = (wchar_t *)fixed_print_name;
+       link.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t);
+       make_link_reparse_point(&link, rpbuf, rpbuflen_p);
 }
 
-/* Sets reparse data on the specified file.  This handles "fixing" the targets
- * of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX was
- * specified.  */
+/* Sets the reparse point on the specified file.  This handles "fixing" the
+ * targets of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX
+ * was specified.  */
 static int
-set_reparse_data(const struct wim_dentry *dentry,
-                const void *_rpbuf, u16 rpbuflen, struct win32_apply_ctx *ctx)
+set_reparse_point(const struct wim_dentry *dentry,
+                 const struct reparse_buffer_disk *rpbuf, u16 rpbuflen,
+                 struct win32_apply_ctx *ctx)
 {
-       const struct wim_inode *inode = dentry->d_inode;
-       const void *rpbuf = _rpbuf;
-
        if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX)
-           && !inode->i_not_rpfixed
-           && (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
-               inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
+           && !(dentry->d_inode->i_rp_flags & WIM_RP_FLAG_NOT_FIXED))
        {
-               memcpy(&ctx->rpfixbuf, _rpbuf, rpbuflen);
-               try_rpfix((u8 *)&ctx->rpfixbuf, &rpbuflen, ctx);
+               memcpy(&ctx->rpfixbuf, rpbuf, rpbuflen);
+               try_rpfix(&ctx->rpfixbuf, &rpbuflen, ctx);
                rpbuf = &ctx->rpfixbuf;
        }
-       return do_set_reparse_data(dentry, rpbuf, rpbuflen, ctx);
+       return do_set_reparse_point(dentry, rpbuf, rpbuflen, ctx);
 
 }
 
@@ -2200,18 +2198,12 @@ begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
                } else {
                        /* Hard links not supported.  Extract the blob
                         * separately to each alias of the inode.  */
-                       struct list_head *next;
-
-                       next = inode->i_extraction_aliases.next;
-                       do {
-                               dentry = list_entry(next, struct wim_dentry,
-                                                   d_extraction_alias_node);
+                       inode_for_each_extraction_alias(dentry, inode) {
                                ret = begin_extract_blob_instance(blob, dentry, strm, ctx);
                                ret = check_apply_error(dentry, ctx, ret);
                                if (ret)
                                        goto fail;
-                               next = next->next;
-                       } while (next != &inode->i_extraction_aliases);
+                       }
                }
        }
 
@@ -2257,6 +2249,123 @@ extract_chunk(const void *chunk, size_t size, void *_ctx)
        return 0;
 }
 
+static int
+get_system_compression_format(int extract_flags)
+{
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K)
+               return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K;
+
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K)
+               return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS8K;
+
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K)
+               return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS16K;
+
+       return FILE_PROVIDER_COMPRESSION_FORMAT_LZX;
+}
+
+static DWORD
+set_system_compression(HANDLE h, int format)
+{
+       DWORD bytes_returned;
+       DWORD err;
+       struct {
+               struct wof_external_info wof_info;
+               struct file_provider_external_info file_info;
+       } in = {
+               .wof_info = {
+                       .version = WOF_CURRENT_VERSION,
+                       .provider = WOF_PROVIDER_FILE,
+               },
+               .file_info = {
+                       .version = FILE_PROVIDER_CURRENT_VERSION,
+                       .compression_format = format,
+               },
+       };
+
+       if (DeviceIoControl(h, FSCTL_SET_EXTERNAL_BACKING, &in, sizeof(in),
+                           NULL, 0, &bytes_returned, NULL))
+               return 0;
+
+       err = GetLastError();
+
+       if (err == 344) /* "Compressing this object would not save space."  */
+               return 0;
+
+       return err;
+}
+
+/*
+ * This function is called when doing a "compact-mode" extraction and we just
+ * finished extracting a blob to one or more locations.  For each location that
+ * was the unnamed data stream of a file, this function compresses the
+ * corresponding file using System Compression, if allowed.
+ *
+ * Note: we're doing the compression immediately after extracting the data
+ * rather than during a separate compression pass.  This way should be faster
+ * since the operating system should still have the file's data cached.
+ *
+ * Note: we're having the operating system do the compression, which is not
+ * ideal because wimlib could create the compressed data faster and more
+ * efficiently (the compressed data format is identical to a WIM resource).  But
+ * we seemingly don't have a choice because WOF prevents applications from
+ * creating its reparse points.
+ */
+static void
+handle_system_compression(struct blob_descriptor *blob, struct win32_apply_ctx *ctx)
+{
+       const struct blob_extraction_target *targets = blob_extraction_targets(blob);
+
+       const int format = get_system_compression_format(ctx->common.extract_flags);
+
+       for (u32 i = 0; i < blob->out_refcnt; i++) {
+               struct wim_inode *inode = targets[i].inode;
+               struct wim_inode_stream *strm = targets[i].stream;
+               HANDLE h;
+               NTSTATUS status;
+               DWORD err;
+
+               if (!stream_is_unnamed_data_stream(strm))
+                       continue;
+
+               if (will_externally_back_inode(inode, ctx, NULL, false) != 0)
+                       continue;
+
+               status = create_file(&h, GENERIC_READ | GENERIC_WRITE, NULL,
+                                    0, FILE_OPEN, 0,
+                                    inode_first_extraction_dentry(inode), ctx);
+
+               if (NT_SUCCESS(status)) {
+                       err = set_system_compression(h, format);
+                       (*func_NtClose)(h);
+               } else {
+                       err = (*func_RtlNtStatusToDosError)(status);
+               }
+
+               if (err == ERROR_INVALID_FUNCTION) {
+                       WARNING(
+         "The request to compress the extracted files using System Compression\n"
+"          will not be honored because the operating system or target volume\n"
+"          does not support it.  System Compression is only supported on\n"
+"          Windows 10 and later, and only on NTFS volumes.");
+                       ctx->common.extract_flags &= ~COMPACT_FLAGS;
+                       return;
+               }
+
+               if (err) {
+                       ctx->num_system_compression_failures++;
+                       if (ctx->num_system_compression_failures < 10) {
+                               win32_warning(err, L"\"%ls\": Failed to compress "
+                                             "extracted file using System Compression",
+                                             current_path(ctx));
+                       } else if (ctx->num_system_compression_failures == 10) {
+                               WARNING("Suppressing further warnings about "
+                                       "System Compression failures.");
+                       }
+               }
+       }
+}
+
 /* Called when a blob has been fully read for extraction on Windows  */
 static int
 end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
@@ -2270,13 +2379,16 @@ end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
        if (status)
                return status;
 
+       if (unlikely(ctx->common.extract_flags & COMPACT_FLAGS))
+               handle_system_compression(blob, ctx);
+
        if (likely(!ctx->data_buffer_ptr))
                return 0;
 
        if (!list_empty(&ctx->reparse_dentries)) {
                if (blob->size > REPARSE_DATA_MAX_SIZE) {
                        dentry = list_first_entry(&ctx->reparse_dentries,
-                                                 struct wim_dentry, tmp_list);
+                                                 struct wim_dentry, d_tmp_list);
                        build_extraction_path(dentry, ctx);
                        ERROR("Reparse data of \"%ls\" has size "
                              "%"PRIu64" bytes (exceeds %u bytes)",
@@ -2285,17 +2397,18 @@ end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
                        ret = WIMLIB_ERR_INVALID_REPARSE_DATA;
                        return check_apply_error(dentry, ctx, ret);
                }
-               /* In the WIM format, reparse point streams are just the reparse
-                * data and omit the header.  But we can reconstruct the header.
-                */
+               /* Reparse data  */
                memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, blob->size);
-               ctx->rpbuf.rpdatalen = blob->size;
-               ctx->rpbuf.rpreserved = 0;
-               list_for_each_entry(dentry, &ctx->reparse_dentries, tmp_list) {
-                       ctx->rpbuf.rptag = dentry->d_inode->i_reparse_tag;
-                       ret = set_reparse_data(dentry, &ctx->rpbuf,
-                                              blob->size + REPARSE_DATA_OFFSET,
-                                              ctx);
+
+               list_for_each_entry(dentry, &ctx->reparse_dentries, d_tmp_list) {
+
+                       /* Reparse point header  */
+                       complete_reparse_point(&ctx->rpbuf, dentry->d_inode,
+                                              blob->size);
+
+                       ret = set_reparse_point(dentry, &ctx->rpbuf,
+                                               REPARSE_DATA_OFFSET + blob->size,
+                                               ctx);
                        ret = check_apply_error(dentry, ctx, ret);
                        if (ret)
                                return ret;
@@ -2304,7 +2417,7 @@ end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
 
        if (!list_empty(&ctx->encrypted_dentries)) {
                ctx->encrypted_size = blob->size;
-               list_for_each_entry(dentry, &ctx->encrypted_dentries, tmp_list) {
+               list_for_each_entry(dentry, &ctx->encrypted_dentries, d_tmp_list) {
                        ret = extract_encrypted_file(dentry, ctx);
                        ret = check_apply_error(dentry, ctx, ret);
                        if (ret)
@@ -2472,7 +2585,7 @@ do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode,
        NTSTATUS status;
 
        /* Set security descriptor if present and not in NO_ACLS mode  */
-       if (inode->i_security_id >= 0 &&
+       if (inode_has_security_descriptor(inode) &&
            !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS))
        {
                const struct wim_security_data *sd;
@@ -2722,11 +2835,11 @@ out:
        FREE(ctx->pathbuf.Buffer);
        FREE(ctx->print_buffer);
        FREE(ctx->wimboot.wims);
-       if (ctx->wimboot.prepopulate_pats) {
-               FREE(ctx->wimboot.prepopulate_pats->strings);
-               FREE(ctx->wimboot.prepopulate_pats);
+       if (ctx->prepopulate_pats) {
+               FREE(ctx->prepopulate_pats->strings);
+               FREE(ctx->prepopulate_pats);
        }
-       FREE(ctx->wimboot.mem_prepopulate_pats);
+       FREE(ctx->mem_prepopulate_pats);
        FREE(ctx->data_buffer);
        return ret;
 }
@@ -2735,7 +2848,7 @@ const struct apply_operations win32_apply_ops = {
        .name                   = "Windows",
        .get_supported_features = win32_get_supported_features,
        .extract                = win32_extract,
-       .will_externally_back   = win32_will_externally_back,
+       .will_back_from_wim     = win32_will_back_from_wim,
        .context_size           = sizeof(struct win32_apply_ctx),
 };