win32: handle excluded reparse points correctly
authorEric Biggers <ebiggers3@gmail.com>
Sat, 27 Apr 2013 00:50:15 +0000 (19:50 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Sat, 27 Apr 2013 00:50:15 +0000 (19:50 -0500)
src/add_image.c
src/dentry.c
src/extract_image.c
src/hardlink.c
src/ntfs-capture.c
src/wimlib_internal.h
src/win32.c

index 8972105..ff97bc1 100644 (file)
@@ -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),
-                                    stbuf.st_ino,
-                                    stbuf.st_dev,
-                                    &root);
+                                    stbuf.st_ino, stbuf.st_dev, false, &root);
        if (ret)
                goto out;
 
index c17e45a..7cd93ed 100644 (file)
@@ -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);
-
        existing_lte = __lookup_resource(lookup_table, hash);
-
        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;
index aae779e..7effb4f 100644 (file)
@@ -809,7 +809,6 @@ extract_single_image(WIMStruct *w, int image,
 
        struct apply_args args;
        const struct apply_operations *ops;
-       tchar *target_realpath;
 
        memset(&args, 0, sizeof(args));
 
index e2f6ca0..f6752ff 100644 (file)
@@ -168,25 +168,32 @@ inode_ref_streams(struct wim_inode *inode)
  */
 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;
 
-       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;
 }
index 3c90670..9896cdc 100644 (file)
@@ -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),
-                                    ni->mft_no,
-                                    0,
-                                    &root);
+                                    ni->mft_no, 0, false, &root);
        if (ret)
                return ret;
 
index 5e390ef..1dfc436 100644 (file)
@@ -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,
-                      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);
index 643832f..40a41e4 100644 (file)
@@ -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_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
-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;
@@ -794,73 +793,51 @@ win32_do_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p,
        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
-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;
-       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" */
-                            reparse_point_buf, /* "A pointer to a buffer that
+                            reparse_data, /* "A pointer to a buffer that
                                                   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);
-               return WIMLIB_ERR_READ;
+               return -WIMLIB_ERR_READ;
        }
        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 &&
-           (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 */
-               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
@@ -1119,8 +1096,10 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
        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) {
@@ -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);
                }
+               ret = 0;
                goto out;
        }
 
@@ -1168,31 +1148,40 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
                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. */
-       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)
@@ -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;
 
-       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);
-       } 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);