win32: handle excluded reparse points correctly

diff --git a/src/add_image.c b/src/add_image.c
index 89721052d3a6156effd77fa1f07d873409312e3c..ff97bc1c603a7ee1ec7a4b5bad82a13eccaf6062 100644 (file)
--- a/src/add_image.c
+++ b/src/add_image.c
@@ -300,9 +300,7 @@ unix_build_dentry_tree_recursive(struct wim_dentry **root_ret,
 
        ret = inode_table_new_dentry(params->inode_table,
                                     path_basename_with_len(path, path_len),
 
        ret = inode_table_new_dentry(params->inode_table,
                                     path_basename_with_len(path, path_len),

-                                    stbuf.st_ino,
-                                    stbuf.st_dev,
-                                    &root);
+                                    stbuf.st_ino, stbuf.st_dev, false, &root);

        if (ret)
                goto out;
 
        if (ret)
                goto out;
 

diff --git a/src/dentry.c b/src/dentry.c
index c17e45a38a9e1b010de4c2fe03cafdbd1c89c830..7cd93ed1ab9e42a21aa0dfcaf6ae31d6e5e441c7 100644 (file)
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -1129,16 +1129,12 @@ inode_set_unnamed_stream(struct wim_inode *inode, const void *data, size_t len,
        void *buf;
 
        sha1_buffer(data, len, hash);
        void *buf;
 
        sha1_buffer(data, len, hash);

-

        existing_lte = __lookup_resource(lookup_table, hash);
        existing_lte = __lookup_resource(lookup_table, hash);

-

        if (existing_lte) {
                wimlib_assert(wim_resource_size(existing_lte) == len);
                lte = existing_lte;
                lte->refcnt++;
        } else {
        if (existing_lte) {
                wimlib_assert(wim_resource_size(existing_lte) == len);
                lte = existing_lte;
                lte->refcnt++;
        } else {

-               void *buf;
-

                lte = new_lookup_table_entry();
                if (!lte)
                        return WIMLIB_ERR_NOMEM;
                lte = new_lookup_table_entry();
                if (!lte)
                        return WIMLIB_ERR_NOMEM;

diff --git a/src/extract_image.c b/src/extract_image.c
index aae779e9bf2f1450f239042b06eb29eb20d9ee7a..7effb4f395d4abab7eff5e7b80b09a38e9b30a18 100644 (file)
--- a/src/extract_image.c
+++ b/src/extract_image.c
@@ -809,7 +809,6 @@ extract_single_image(WIMStruct *w, int image,
 
        struct apply_args args;
        const struct apply_operations *ops;
 
        struct apply_args args;
        const struct apply_operations *ops;

-       tchar *target_realpath;

 
        memset(&args, 0, sizeof(args));
 
 
        memset(&args, 0, sizeof(args));
 

diff --git a/src/hardlink.c b/src/hardlink.c
index e2f6ca0cb77fd29c867a350c4352b3d53044eb9c..f6752ff4603ef37d8d07f388d383f0b6dd22cffd 100644 (file)
--- a/src/hardlink.c
+++ b/src/hardlink.c
@@ -168,25 +168,32 @@ inode_ref_streams(struct wim_inode *inode)
  */
 int
 inode_table_new_dentry(struct wim_inode_table *table, const tchar *name,
  */
 int
 inode_table_new_dentry(struct wim_inode_table *table, const tchar *name,

-                      u64 ino, u64 devno, struct wim_dentry **dentry_ret)
+                      u64 ino, u64 devno, bool noshare,
+                      struct wim_dentry **dentry_ret)

 {
        struct wim_dentry *dentry;
        struct wim_inode *inode;
        int ret;
 
 {
        struct wim_dentry *dentry;
        struct wim_inode *inode;
        int ret;
 

-       ret = new_dentry(name, &dentry);
-       if (ret)
-               return ret;
-
-       inode = inode_table_get_inode(table, ino, devno);
-       if (!inode) {
-               free_dentry(dentry);
-               return WIMLIB_ERR_NOMEM;
+       if (noshare) {
+               ret = new_dentry_with_timeless_inode(name, &dentry);
+               if (ret)
+                       return ret;
+               list_add_tail(&dentry->d_inode->i_list, &table->extra_inodes);
+       } else {
+               ret = new_dentry(name, &dentry);
+               if (ret)
+                       return ret;
+               inode = inode_table_get_inode(table, ino, devno);
+               if (!inode) {
+                       free_dentry(dentry);
+                       return WIMLIB_ERR_NOMEM;
+               }
+               if (inode->i_nlink > 1)
+                       inode_ref_streams(inode);
+               dentry->d_inode = inode;
+               inode_add_dentry(dentry, inode);

        }
        }

-       if (inode->i_nlink > 1)
-               inode_ref_streams(inode);
-       dentry->d_inode = inode;
-       inode_add_dentry(dentry, inode);

        *dentry_ret = dentry;
        return 0;
 }
        *dentry_ret = dentry;
        return 0;
 }

diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c
index 3c9067079c2b8e2bf21d8a09ddb305a7a4ab4547..9896cdcca70292aa10081d0f9457e4d6cfb9d264 100644 (file)
--- a/src/ntfs-capture.c
+++ b/src/ntfs-capture.c
@@ -584,9 +584,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
        /* Create a WIM dentry with an associated inode, which may be shared */
        ret = inode_table_new_dentry(params->inode_table,
                                     path_basename_with_len(path, path_len),
        /* Create a WIM dentry with an associated inode, which may be shared */
        ret = inode_table_new_dentry(params->inode_table,
                                     path_basename_with_len(path, path_len),

-                                    ni->mft_no,
-                                    0,
-                                    &root);
+                                    ni->mft_no, 0, false, &root);

        if (ret)
                return ret;
 
        if (ret)
                return ret;
 

diff --git a/src/wimlib_internal.h b/src/wimlib_internal.h
index 5e390efe1364d7b3afb55ecd371a0c1fd9f39170..1dfc43674cf3679bbfd569dfcf6827ee3a397586 100644 (file)
--- a/src/wimlib_internal.h
+++ b/src/wimlib_internal.h
@@ -474,7 +474,8 @@ init_inode_table(struct wim_inode_table *table, size_t capacity);
 
 extern int
 inode_table_new_dentry(struct wim_inode_table *table, const tchar *name,
 
 extern int
 inode_table_new_dentry(struct wim_inode_table *table, const tchar *name,

-                      u64 ino, u64 devno, struct wim_dentry **dentry_ret);
+                      u64 ino, u64 devno, bool noshare,
+                      struct wim_dentry **dentry_ret);

 
 extern void
 inode_ref_streams(struct wim_inode *inode);
 
 extern void
 inode_ref_streams(struct wim_inode *inode);

diff --git a/src/win32.c b/src/win32.c
index 643832fbdc61dfb151286c1d3d268325afcf44a0..40a41e422bab5b7a5bab8cf4632c794b4ca4aca4 100644 (file)
--- a/src/win32.c
+++ b/src/win32.c
@@ -711,7 +711,6 @@ win32_maybe_rpfix_target(wchar_t *target, size_t *target_nchars_p,
        target = fixup_symlink(target + stripped_chars, capture_root_ino, capture_root_dev);
        if (!target)
                return RP_EXCLUDED;
        target = fixup_symlink(target + stripped_chars, capture_root_ino, capture_root_dev);
        if (!target)
                return RP_EXCLUDED;

-

        target_nchars = wcslen(target);
        wmemmove(orig_target + stripped_chars, target, target_nchars + 1);
        *target_nchars_p = target_nchars + stripped_chars;
        target_nchars = wcslen(target);
        wmemmove(orig_target + stripped_chars, target, target_nchars + 1);
        *target_nchars_p = target_nchars + stripped_chars;


@@ -723,8 +722,8 @@ win32_maybe_rpfix_target(wchar_t *target, size_t *target_nchars_p,
 }
 
 static enum rp_status
 }
 
 static enum rp_status

-win32_do_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p,
-                      u64 capture_root_ino, u64 capture_root_dev)
+win32_try_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p,
+                       u64 capture_root_ino, u64 capture_root_dev)

 {
        const char *p_get;
        char *p_put;
 {
        const char *p_get;
        char *p_put;


@@ -794,73 +793,51 @@ win32_do_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p,
        return status;
 }
 
        return status;
 }
 

-/* Load a reparse point into a WIM inode.  It is just stored in memory.
- *
- * @hFile is the open handle to a reparse point, with permission to read the
- * reparse data.
- *
- * @inode is the WIM inode for the reparse point.
- */

 static int
 static int

-win32_capture_reparse_point(struct wim_dentry **root_p,
-                           HANDLE hFile,
-                           struct wim_inode *inode,
-                           const wchar_t *path,
-                           struct add_image_params *params)
+win32_get_reparse_data(HANDLE hFile, const wchar_t *path,
+                      struct add_image_params *params,
+                      void *reparse_data, size_t *reparse_data_len_ret)

 {
 {

-       DEBUG("Capturing reparse point \"%ls\"", path);
-
-       /* "Reparse point data, including the tag and optional GUID,
-        * cannot exceed 16 kilobytes." - MSDN  */
-       char reparse_point_buf[REPARSE_POINT_MAX_SIZE];

        DWORD bytesReturned;
        DWORD bytesReturned;

-       char *fixed_buf;
-       DWORD fixed_len;
+       u32 reparse_tag;
+       enum rp_status status;

 
 

+       DEBUG("Loading reparse data from \"%ls\"", path);

        if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT,
                             NULL, /* "Not used with this operation; set to NULL" */
                             0, /* "Not used with this operation; set to 0" */
        if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT,
                             NULL, /* "Not used with this operation; set to NULL" */
                             0, /* "Not used with this operation; set to 0" */

-                            reparse_point_buf, /* "A pointer to a buffer that
+                            reparse_data, /* "A pointer to a buffer that

                                                   receives the reparse point data */
                                                   receives the reparse point data */

-                            sizeof(reparse_point_buf), /* "The size of the output
-                                                          buffer, in bytes */
+                            REPARSE_POINT_MAX_SIZE, /* "The size of the output
+                                                       buffer, in bytes */

                             &bytesReturned,
                             NULL))
        {
                DWORD err = GetLastError();
                ERROR("Failed to get reparse data of \"%ls\"", path);
                win32_error(err);
                             &bytesReturned,
                             NULL))
        {
                DWORD err = GetLastError();
                ERROR("Failed to get reparse data of \"%ls\"", path);
                win32_error(err);

-               return WIMLIB_ERR_READ;
+               return -WIMLIB_ERR_READ;

        }
        if (bytesReturned < 8) {
                ERROR("Reparse data on \"%ls\" is invalid", path);
        }
        if (bytesReturned < 8) {
                ERROR("Reparse data on \"%ls\" is invalid", path);

-               return WIMLIB_ERR_READ;
+               return -WIMLIB_ERR_READ;

        }
        }

-       inode->i_reparse_tag = le32_to_cpu(*(u32*)reparse_point_buf);

 
 

+       reparse_tag = le32_to_cpu(*(u32*)reparse_data);

        if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX &&
        if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX &&

-           (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
-            inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
+           (reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
+            reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))

        {
                /* Try doing reparse point fixup */
        {
                /* Try doing reparse point fixup */

-               enum rp_status status;
-               status = win32_do_capture_rpfix(reparse_point_buf,
-                                               &bytesReturned,
-                                               params->capture_root_ino,
-                                               params->capture_root_dev);
-               if (status == RP_EXCLUDED) {
-                       /* Absolute path points out of capture tree.  Free the
-                        * dentry; we're not including it at all. */
-                       free_dentry(*root_p);
-                       *root_p = NULL;
-                       return 0;
-               } else if (status & RP_FIXED) {
-                       /* Absolute path fixup was done. */
-                       inode->i_not_rpfixed = 0;
-               }
+               status = win32_try_capture_rpfix(reparse_data,
+                                                &bytesReturned,
+                                                params->capture_root_ino,
+                                                params->capture_root_dev);
+       } else {
+               status = RP_NOT_FIXED;

        }
        }

-       return inode_set_unnamed_stream(inode, reparse_point_buf + 8,
-                                       bytesReturned - 8, params->lookup_table);
+       *reparse_data_len_ret = bytesReturned;
+       return status;

 }
 
 /* Scans an unnamed or named stream of a Win32 file (not a reparse point
 }
 
 /* Scans an unnamed or named stream of a Win32 file (not a reparse point


@@ -1119,8 +1096,10 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
        struct wim_inode *inode;
        DWORD err;
        u64 file_size;
        struct wim_inode *inode;
        DWORD err;
        u64 file_size;

-       int ret = 0;
-       const wchar_t *basename;
+       int ret;
+       void *reparse_data;
+       size_t reparse_data_len;
+       u16 not_rpfixed;

 
        if (exclude_path(path, path_num_chars, params->config, true)) {
                if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) {
 
        if (exclude_path(path, path_num_chars, params->config, true)) {
                if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) {


@@ -1136,6 +1115,7 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
                        info.scan.excluded = true;
                        params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
                }
                        info.scan.excluded = true;
                        params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
                }

+               ret = 0;

                goto out;
        }
 
                goto out;
        }
 


@@ -1168,31 +1148,40 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
                goto out_close_handle;
        }
 
                goto out_close_handle;
        }
 

+       if (file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+               reparse_data = alloca(REPARSE_POINT_MAX_SIZE);
+               ret = win32_get_reparse_data(hFile, path, params,
+                                            reparse_data, &reparse_data_len);
+               if (ret < 0) {
+                       /* WIMLIB_ERR_* (inverted) */
+                       ret = -ret;
+                       goto out_close_handle;
+               } else if (ret & RP_FIXED) {
+                       not_rpfixed = 0;
+               } else if (ret == RP_EXCLUDED) {
+                       ret = 0;
+                       goto out_close_handle;
+               } else {
+                       not_rpfixed = 1;
+               }
+       }
+

        /* Create a WIM dentry with an associated inode, which may be shared.
         *
         * However, we need to explicitly check for directories and files with
         * only 1 link and refuse to hard link them.  This is because Windows
         * has a bug where it can return duplicate File IDs for files and
         * directories on the FAT filesystem. */
        /* Create a WIM dentry with an associated inode, which may be shared.
         *
         * However, we need to explicitly check for directories and files with
         * only 1 link and refuse to hard link them.  This is because Windows
         * has a bug where it can return duplicate File IDs for files and
         * directories on the FAT filesystem. */

-       basename = path_basename_with_len(path, path_num_chars);
-       if (!(file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-           && file_info.nNumberOfLinks > 1)
-       {
-               ret = inode_table_new_dentry(params->inode_table,
-                                            basename,
-                                            ((u64)file_info.nFileIndexHigh << 32) |
-                                                (u64)file_info.nFileIndexLow,
-                                            file_info.dwVolumeSerialNumber,
-                                            &root);
-               if (ret)
-                       goto out_close_handle;
-       } else {
-               ret = new_dentry_with_inode(basename, &root);
-               if (ret)
-                       goto out_close_handle;
-               list_add_tail(&root->d_inode->i_list, &params->inode_table->extra_inodes);
-       }
-
+       ret = inode_table_new_dentry(params->inode_table,
+                                    path_basename_with_len(path, path_num_chars),
+                                    ((u64)file_info.nFileIndexHigh << 32) |
+                                        (u64)file_info.nFileIndexLow,
+                                    file_info.dwVolumeSerialNumber,
+                                    (file_info.nNumberOfLinks <= 1 ||
+                                       (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)),
+                                    &root);
+       if (ret)
+               goto out_close_handle;

 
        ret = win32_get_short_name(root, path);
        if (ret)
 
        ret = win32_get_short_name(root, path);
        if (ret)


@@ -1224,39 +1213,33 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
        file_size = ((u64)file_info.nFileSizeHigh << 32) |
                     (u64)file_info.nFileSizeLow;
 
        file_size = ((u64)file_info.nFileSizeHigh << 32) |
                     (u64)file_info.nFileSizeLow;
 

-       if (inode_is_directory(inode)) {
-               /* Directory (not a reparse point) --- recurse to children */
+       /* Capture the unnamed data stream (only should be present for regular
+        * files) and any alternate data streams. */
+       ret = win32_capture_streams(path,
+                                   path_num_chars,
+                                   inode,
+                                   params->lookup_table,
+                                   file_size,
+                                   vol_flags);
+       if (ret)
+               goto out_close_handle;

 
 

-               /* But first... directories may have alternate data streams that
-                * need to be captured. */
-               ret = win32_capture_streams(path,
-                                           path_num_chars,
-                                           inode,
-                                           params->lookup_table,
-                                           file_size,
-                                           vol_flags);
-               if (ret)
-                       goto out_close_handle;
+       if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+               /* Reparse point: set the reparse data (which we read already)
+                * */
+               inode->i_not_rpfixed = not_rpfixed;
+               inode->i_reparse_tag = le32_to_cpu(*(u32*)reparse_data);
+               ret = inode_set_unnamed_stream(inode, reparse_data + 8,
+                                              reparse_data_len - 8,
+                                              params->lookup_table);
+       } else if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
+               /* Directory (not a reparse point) --- recurse to children */

                ret = win32_recurse_directory(root,
                                              path,
                                              path_num_chars,
                                              params,
                                              state,
                                              vol_flags);
                ret = win32_recurse_directory(root,
                                              path,
                                              path_num_chars,
                                              params,
                                              state,
                                              vol_flags);

-       } else if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-               /* Reparse point: save the reparse tag and data.  Alternate data
-                * streams are not captured, if it's even possible for a reparse
-                * point to have alternate data streams... */
-               ret = win32_capture_reparse_point(&root, hFile, inode, path, params);
-       } else {
-               /* Not a directory, not a reparse point; capture the default
-                * file contents and any alternate data streams. */
-               ret = win32_capture_streams(path,
-                                           path_num_chars,
-                                           inode,
-                                           params->lookup_table,
-                                           file_size,
-                                           vol_flags);

        }
 out_close_handle:
        CloseHandle(hFile);
        }
 out_close_handle:
        CloseHandle(hFile);