]> wimlib.net Git - wimlib/blobdiff - src/ntfs-apply.c
NTFS filename namespace issues...
[wimlib] / src / ntfs-apply.c
index c00be57fe743e9740b884b81066ea7a0f8aaf38d..39de5d678d8291761363a57a4804766944e9d7f7 100644 (file)
@@ -58,7 +58,7 @@ static int extract_wim_chunk_to_ntfs_attr(const u8 *buf, size_t len,
  * Extracts a WIM resource to a NTFS attribute.
  */
 static int
  * Extracts a WIM resource to a NTFS attribute.
  */
 static int
-extract_wim_resource_to_ntfs_attr(const struct lookup_table_entry *lte,
+extract_wim_resource_to_ntfs_attr(const struct wim_lookup_table_entry *lte,
                                  ntfs_attr *na)
 {
        return extract_wim_resource(lte, wim_resource_size(lte),
                                  ntfs_attr *na)
 {
        return extract_wim_resource(lte, wim_resource_size(lte),
@@ -81,22 +81,22 @@ extract_wim_resource_to_ntfs_attr(const struct lookup_table_entry *lte,
  *
  * Returns 0 on success, nonzero on failure.
  */
  *
  * Returns 0 on success, nonzero on failure.
  */
-static int write_ntfs_data_streams(ntfs_inode *ni, const struct dentry *dentry,
+static int write_ntfs_data_streams(ntfs_inode *ni, const struct wim_dentry *dentry,
                                   union wimlib_progress_info *progress_info)
 {
        int ret = 0;
        unsigned stream_idx = 0;
        ntfschar *stream_name = AT_UNNAMED;
        u32 stream_name_len = 0;
                                   union wimlib_progress_info *progress_info)
 {
        int ret = 0;
        unsigned stream_idx = 0;
        ntfschar *stream_name = AT_UNNAMED;
        u32 stream_name_len = 0;
-       const struct inode *inode = dentry->d_inode;
-       struct lookup_table_entry *lte;
+       const struct wim_inode *inode = dentry->d_inode;
+       struct wim_lookup_table_entry *lte;
 
        DEBUG("Writing %u NTFS data stream%s for `%s'",
 
        DEBUG("Writing %u NTFS data stream%s for `%s'",
-             inode->num_ads + 1,
-             (inode->num_ads == 0 ? "" : "s"),
+             inode->i_num_ads + 1,
+             (inode->i_num_ads == 0 ? "" : "s"),
              dentry->full_path_utf8);
 
              dentry->full_path_utf8);
 
-       lte = inode->lte;
+       lte = inode->i_lte;
        while (1) {
                if (stream_name_len) {
                        /* Create an empty named stream. */
        while (1) {
                if (stream_name_len) {
                        /* Create an empty named stream. */
@@ -148,13 +148,13 @@ static int write_ntfs_data_streams(ntfs_inode *ni, const struct dentry *dentry,
                         * have been extracted. */
                        progress_info->extract.completed_bytes += wim_resource_size(lte);
                }
                         * have been extracted. */
                        progress_info->extract.completed_bytes += wim_resource_size(lte);
                }
-               if (stream_idx == inode->num_ads) /* Has the last stream been extracted? */
+               if (stream_idx == inode->i_num_ads) /* Has the last stream been extracted? */
                        break;
 
                /* Get the name and lookup table entry for the next stream. */
                        break;
 
                /* Get the name and lookup table entry for the next stream. */
-               stream_name = (ntfschar*)inode->ads_entries[stream_idx].stream_name;
-               stream_name_len = inode->ads_entries[stream_idx].stream_name_len / 2;
-               lte = inode->ads_entries[stream_idx].lte;
+               stream_name = (ntfschar*)inode->i_ads_entries[stream_idx].stream_name;
+               stream_name_len = inode->i_ads_entries[stream_idx].stream_name_len / 2;
+               lte = inode->i_ads_entries[stream_idx].lte;
                stream_idx++;
        }
        return ret;
                stream_idx++;
        }
        return ret;
@@ -162,7 +162,7 @@ static int write_ntfs_data_streams(ntfs_inode *ni, const struct dentry *dentry,
 
 /* Open the NTFS inode that corresponds to the parent of a WIM dentry.  Returns
  * the opened inode, or NULL on failure. */
 
 /* Open the NTFS inode that corresponds to the parent of a WIM dentry.  Returns
  * the opened inode, or NULL on failure. */
-static ntfs_inode *dentry_open_parent_ni(const struct dentry *dentry,
+static ntfs_inode *dentry_open_parent_ni(const struct wim_dentry *dentry,
                                         ntfs_volume *vol)
 {
        char *p;
                                         ntfs_volume *vol)
 {
        char *p;
@@ -192,15 +192,21 @@ static ntfs_inode *dentry_open_parent_ni(const struct dentry *dentry,
  *
  * The hard link is named @from_dentry->file_name and is located under the
  * directory specified by @dir_ni, and it is made to point to the previously
  *
  * The hard link is named @from_dentry->file_name and is located under the
  * directory specified by @dir_ni, and it is made to point to the previously
- * extracted file located at @inode->extracted_file.
+ * extracted file located at @inode->i_extracted_file.
  *
  * Or, in other words, this adds a new name @from_dentry->full_path_utf8 to an
  *
  * Or, in other words, this adds a new name @from_dentry->full_path_utf8 to an
- * existing NTFS inode which already has a name @inode->extracted_file.
+ * existing NTFS inode which already has a name @inode->i_extracted_file.
+ *
+ * The new name is made in the POSIX namespace (this is the behavior of
+ * ntfs_link()).  I am assuming this is an acceptable behavior; however, it's
+ * possible that the original name was actually in the Win32 namespace.  Note
+ * that the WIM format does not provide enough information to distinguish Win32
+ * names from POSIX names in all cases.
  *
  * Return 0 on success, nonzero on failure.
  */
  *
  * Return 0 on success, nonzero on failure.
  */
-static int apply_ntfs_hardlink(const struct dentry *from_dentry,
-                              const struct inode *inode,
+static int apply_ntfs_hardlink(const struct wim_dentry *from_dentry,
+                              const struct wim_inode *inode,
                               ntfs_inode **dir_ni_p)
 {
        int ret;
                               ntfs_inode **dir_ni_p)
 {
        int ret;
@@ -218,12 +224,12 @@ static int apply_ntfs_hardlink(const struct dentry *from_dentry,
        }
 
        DEBUG("Extracting NTFS hard link `%s' => `%s'",
        }
 
        DEBUG("Extracting NTFS hard link `%s' => `%s'",
-             from_dentry->full_path_utf8, inode->extracted_file);
+             from_dentry->full_path_utf8, inode->i_extracted_file);
 
 
-       to_ni = ntfs_pathname_to_inode(vol, NULL, inode->extracted_file);
+       to_ni = ntfs_pathname_to_inode(vol, NULL, inode->i_extracted_file);
        if (!to_ni) {
                ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
        if (!to_ni) {
                ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
-                                inode->extracted_file);
+                                inode->i_extracted_file);
                return WIMLIB_ERR_NTFS_3G;
        }
 
                return WIMLIB_ERR_NTFS_3G;
        }
 
@@ -241,7 +247,7 @@ static int apply_ntfs_hardlink(const struct dentry *from_dentry,
        if (ntfs_inode_close_in_dir(to_ni, dir_ni) || ret != 0) {
                ERROR_WITH_ERRNO("Could not create hard link `%s' => `%s'",
                                 from_dentry->full_path_utf8,
        if (ntfs_inode_close_in_dir(to_ni, dir_ni) || ret != 0) {
                ERROR_WITH_ERRNO("Could not create hard link `%s' => `%s'",
                                 from_dentry->full_path_utf8,
-                                inode->extracted_file);
+                                inode->i_extracted_file);
                ret = WIMLIB_ERR_NTFS_3G;
        }
        return ret;
                ret = WIMLIB_ERR_NTFS_3G;
        }
        return ret;
@@ -261,20 +267,20 @@ static int apply_ntfs_hardlink(const struct dentry *from_dentry,
 static int
 apply_file_attributes_and_security_data(ntfs_inode *ni,
                                        ntfs_inode *dir_ni,
 static int
 apply_file_attributes_and_security_data(ntfs_inode *ni,
                                        ntfs_inode *dir_ni,
-                                       const struct dentry *dentry,
+                                       const struct wim_dentry *dentry,
                                        const WIMStruct *w)
 {
        int ret;
        struct SECURITY_CONTEXT ctx;
        u32 attributes_le32;
                                        const WIMStruct *w)
 {
        int ret;
        struct SECURITY_CONTEXT ctx;
        u32 attributes_le32;
-       const struct inode *inode;
+       const struct wim_inode *inode;
 
        inode = dentry->d_inode;
 
        DEBUG("Setting NTFS file attributes on `%s' to %#"PRIx32,
 
        inode = dentry->d_inode;
 
        DEBUG("Setting NTFS file attributes on `%s' to %#"PRIx32,
-             dentry->full_path_utf8, inode->attributes);
+             dentry->full_path_utf8, inode->i_attributes);
 
 
-       attributes_le32 = cpu_to_le32(inode->attributes);
+       attributes_le32 = cpu_to_le32(inode->i_attributes);
        memset(&ctx, 0, sizeof(ctx));
        ctx.vol = ni->vol;
        ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ATTRIB,
        memset(&ctx, 0, sizeof(ctx));
        ctx.vol = ni->vol;
        ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ATTRIB,
@@ -286,19 +292,19 @@ apply_file_attributes_and_security_data(ntfs_inode *ni,
                       dentry->full_path_utf8);
                return WIMLIB_ERR_NTFS_3G;
        }
                       dentry->full_path_utf8);
                return WIMLIB_ERR_NTFS_3G;
        }
-       if (inode->security_id != -1) {
+       if (inode->i_security_id != -1) {
                const char *desc;
                const struct wim_security_data *sd;
 
                sd = wim_const_security_data(w);
                const char *desc;
                const struct wim_security_data *sd;
 
                sd = wim_const_security_data(w);
-               wimlib_assert(inode->security_id < sd->num_entries);
-               desc = (const char *)sd->descriptors[inode->security_id];
+               wimlib_assert(inode->i_security_id < sd->num_entries);
+               desc = (const char *)sd->descriptors[inode->i_security_id];
                DEBUG("Applying security descriptor %d to `%s'",
                DEBUG("Applying security descriptor %d to `%s'",
-                     inode->security_id, dentry->full_path_utf8);
+                     inode->i_security_id, dentry->full_path_utf8);
 
                ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ACL,
                                                 ni, dir_ni, desc,
 
                ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ACL,
                                                 ni, dir_ni, desc,
-                                                sd->sizes[inode->security_id], 0);
+                                                sd->sizes[inode->i_security_id], 0);
 
                if (ret != 0) {
                        ERROR_WITH_ERRNO("Failed to set security data on `%s'",
 
                if (ret != 0) {
                        ERROR_WITH_ERRNO("Failed to set security data on `%s'",
@@ -313,10 +319,10 @@ apply_file_attributes_and_security_data(ntfs_inode *ni,
  * Transfers the reparse data from a WIM inode (which must represent a reparse
  * point) to a NTFS inode.
  */
  * Transfers the reparse data from a WIM inode (which must represent a reparse
  * point) to a NTFS inode.
  */
-static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry,
+static int apply_reparse_data(ntfs_inode *ni, const struct wim_dentry *dentry,
                              union wimlib_progress_info *progress_info)
 {
                              union wimlib_progress_info *progress_info)
 {
-       struct lookup_table_entry *lte;
+       struct wim_lookup_table_entry *lte;
        int ret = 0;
 
        lte = inode_unnamed_lte_resolved(dentry->d_inode);
        int ret = 0;
 
        lte = inode_unnamed_lte_resolved(dentry->d_inode);
@@ -337,7 +343,7 @@ static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry,
 
        u8 reparse_data_buf[8 + wim_resource_size(lte)];
        u8 *p = reparse_data_buf;
 
        u8 reparse_data_buf[8 + wim_resource_size(lte)];
        u8 *p = reparse_data_buf;
-       p = put_u32(p, dentry->d_inode->reparse_tag); /* ReparseTag */
+       p = put_u32(p, dentry->d_inode->i_reparse_tag); /* ReparseTag */
        p = put_u16(p, wim_resource_size(lte)); /* ReparseDataLength */
        p = put_u16(p, 0); /* Reserved */
 
        p = put_u16(p, wim_resource_size(lte)); /* ReparseDataLength */
        p = put_u16(p, 0); /* Reserved */
 
@@ -356,60 +362,6 @@ static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry,
        return 0;
 }
 
        return 0;
 }
 
-static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
-                               struct apply_args *args);
-
-/*
- * If @dentry is part of a hard link group, search for hard-linked dentries in
- * the same directory that have a nonempty DOS (short) filename.  There should
- * be exactly 0 or 1 such dentries.  If there is 1, extract that dentry first,
- * so that the DOS name is correctly associated with the corresponding long name
- * in the Win32 namespace, and not any of the additional names in the POSIX
- * namespace created from hard links.
- */
-static int preapply_dentry_with_dos_name(struct dentry *dentry,
-                                        ntfs_inode **dir_ni_p,
-                                        struct apply_args *args)
-{
-       struct dentry *other;
-       struct dentry *dentry_with_dos_name;
-
-       dentry_with_dos_name = NULL;
-       inode_for_each_dentry(other, dentry->d_inode) {
-               if (other != dentry && (dentry->parent == other->parent)
-                   && other->short_name_len)
-               {
-                       if (dentry_with_dos_name) {
-                               ERROR("Found multiple DOS names for file `%s' "
-                                     "in the same directory",
-                                     dentry_with_dos_name->full_path_utf8);
-                               return WIMLIB_ERR_INVALID_DENTRY;
-                       }
-                       dentry_with_dos_name = other;
-               }
-       }
-       /* If there's a dentry with a DOS name, extract it first */
-       if (dentry_with_dos_name && !dentry_with_dos_name->is_extracted) {
-               char *p;
-               const char *dir_name;
-               char orig;
-               int ret;
-               ntfs_volume *vol = (*dir_ni_p)->vol;
-
-               DEBUG("pre-applying DOS name `%s'",
-                     dentry_with_dos_name->full_path_utf8);
-               ret = do_apply_dentry_ntfs(dentry_with_dos_name,
-                                          *dir_ni_p, args);
-               if (ret != 0)
-                       return ret;
-
-               *dir_ni_p = dentry_open_parent_ni(dentry, vol);
-               if (!*dir_ni_p)
-                       return WIMLIB_ERR_NTFS_3G;
-       }
-       return 0;
-}
-
 /*
  * Applies a WIM dentry to a NTFS filesystem.
  *
 /*
  * Applies a WIM dentry to a NTFS filesystem.
  *
@@ -418,50 +370,37 @@ static int preapply_dentry_with_dos_name(struct dentry *dentry,
  *
  * @return:  0 on success; nonzero on failure.
  */
  *
  * @return:  0 on success; nonzero on failure.
  */
-static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
+static int do_apply_dentry_ntfs(struct wim_dentry *dentry, ntfs_inode *dir_ni,
                                struct apply_args *args)
 {
        int ret = 0;
        mode_t type;
        ntfs_inode *ni = NULL;
        ntfs_volume *vol = dir_ni->vol;
                                struct apply_args *args)
 {
        int ret = 0;
        mode_t type;
        ntfs_inode *ni = NULL;
        ntfs_volume *vol = dir_ni->vol;
-       struct inode *inode = dentry->d_inode;
+       struct wim_inode *inode = dentry->d_inode;
        dentry->is_extracted = 1;
 
        dentry->is_extracted = 1;
 
-       if (inode->attributes & FILE_ATTRIBUTE_DIRECTORY) {
+       if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
                type = S_IFDIR;
        } else {
                type = S_IFDIR;
        } else {
-               /* If this dentry is hard-linked to any other dentries in the
-                * same directory, make sure to apply the one (if any) with a
-                * DOS name first.  Otherwise, NTFS-3g might not assign the file
-                * names correctly. */
-               if (dentry->short_name_len == 0) {
-                       ret = preapply_dentry_with_dos_name(dentry,
-                                                           &dir_ni, args);
-                       if (ret != 0)
-                               return ret;
-               }
                type = S_IFREG;
                type = S_IFREG;
-               if (inode->link_count > 1) {
+               if (inode->i_nlink > 1) {
                        /* Inode has multiple dentries referencing it. */
 
                        /* Inode has multiple dentries referencing it. */
 
-                       if (inode->extracted_file) {
+                       if (inode->i_extracted_file) {
                                /* Already extracted another dentry in the hard
                                 * link group.  Make a hard link instead of
                                 * extracting the file data. */
                                ret = apply_ntfs_hardlink(dentry, inode,
                                                          &dir_ni);
                                /* Already extracted another dentry in the hard
                                 * link group.  Make a hard link instead of
                                 * extracting the file data. */
                                ret = apply_ntfs_hardlink(dentry, inode,
                                                          &dir_ni);
-                               if (ret == 0)
-                                       goto out_set_dos_name;
-                               else
-                                       goto out_close_dir_ni;
+                               goto out_close_dir_ni;
                        } else {
                                /* None of the dentries of this inode have been
                                 * extracted yet, so go ahead and extract the
                                 * first one. */
                        } else {
                                /* None of the dentries of this inode have been
                                 * extracted yet, so go ahead and extract the
                                 * first one. */
-                               FREE(inode->extracted_file);
-                               inode->extracted_file = STRDUP(dentry->full_path_utf8);
-                               if (!inode->extracted_file) {
+                               FREE(inode->i_extracted_file);
+                               inode->i_extracted_file = STRDUP(dentry->full_path_utf8);
+                               if (!inode->i_extracted_file) {
                                        ret = WIMLIB_ERR_NOMEM;
                                        goto out_close_dir_ni;
                                }
                                        ret = WIMLIB_ERR_NOMEM;
                                        goto out_close_dir_ni;
                                }
@@ -486,7 +425,7 @@ static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
 
        /* Write the data streams, unless this is a directory or reparse point
         * */
 
        /* Write the data streams, unless this is a directory or reparse point
         * */
-       if (!(inode->attributes & (FILE_ATTRIBUTE_REPARSE_POINT |
+       if (!(inode->i_attributes & (FILE_ATTRIBUTE_REPARSE_POINT |
                                   FILE_ATTRIBUTE_DIRECTORY))) {
                ret = write_ntfs_data_streams(ni, dentry, &args->progress);
                if (ret != 0)
                                   FILE_ATTRIBUTE_DIRECTORY))) {
                ret = write_ntfs_data_streams(ni, dentry, &args->progress);
                if (ret != 0)
@@ -499,16 +438,14 @@ static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
        if (ret != 0)
                goto out_close_dir_ni;
 
        if (ret != 0)
                goto out_close_dir_ni;
 
-       if (inode->attributes & FILE_ATTR_REPARSE_POINT) {
+       if (inode->i_attributes & FILE_ATTR_REPARSE_POINT) {
                ret = apply_reparse_data(ni, dentry, &args->progress);
                if (ret != 0)
                        goto out_close_dir_ni;
        }
 
                ret = apply_reparse_data(ni, dentry, &args->progress);
                if (ret != 0)
                        goto out_close_dir_ni;
        }
 
-out_set_dos_name:
        /* Set DOS (short) name if given */
        if (dentry->short_name_len != 0) {
        /* Set DOS (short) name if given */
        if (dentry->short_name_len != 0) {
-
                char *short_name_utf8;
                size_t short_name_utf8_len;
                ret = utf16_to_utf8(dentry->short_name,
                char *short_name_utf8;
                size_t short_name_utf8_len;
                ret = utf16_to_utf8(dentry->short_name,
@@ -518,20 +455,6 @@ out_set_dos_name:
                if (ret != 0)
                        goto out_close_dir_ni;
 
                if (ret != 0)
                        goto out_close_dir_ni;
 
-               if (!ni) {
-                       /* Hardlink was made; linked inode needs to be looked up
-                        * again.  */
-                       ni = ntfs_pathname_to_inode(vol, dir_ni,
-                                                   dentry->file_name_utf8);
-                       if (!ni) {
-                               ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
-                                                dentry->full_path_utf8);
-                               FREE(short_name_utf8);
-                               ret = WIMLIB_ERR_NTFS_3G;
-                               goto out_close_dir_ni;
-                       }
-               }
-
                DEBUG("Setting short (DOS) name of `%s' to %s",
                      dentry->full_path_utf8, short_name_utf8);
 
                DEBUG("Setting short (DOS) name of `%s' to %s",
                      dentry->full_path_utf8, short_name_utf8);
 
@@ -544,9 +467,8 @@ out_set_dos_name:
                        ret = WIMLIB_ERR_NTFS_3G;
                }
                /* inodes have been closed by ntfs_set_ntfs_dos_name(). */
                        ret = WIMLIB_ERR_NTFS_3G;
                }
                /* inodes have been closed by ntfs_set_ntfs_dos_name(). */
-               return ret;
+               goto out;
        }
        }
-
 out_close_dir_ni:
        if (dir_ni) {
                if (ni) {
 out_close_dir_ni:
        if (dir_ni) {
                if (ni) {
@@ -563,13 +485,12 @@ out_close_dir_ni:
                        ERROR_WITH_ERRNO("Failed to close inode of directory "
                                         "containing `%s'", dentry->full_path_utf8);
                }
                        ERROR_WITH_ERRNO("Failed to close inode of directory "
                                         "containing `%s'", dentry->full_path_utf8);
                }
-       } else {
-               wimlib_assert(ni == NULL);
        }
        }
+out:
        return ret;
 }
 
        return ret;
 }
 
-static int apply_root_dentry_ntfs(const struct dentry *dentry,
+static int apply_root_dentry_ntfs(const struct wim_dentry *dentry,
                                  ntfs_volume *vol, const WIMStruct *w)
 {
        ntfs_inode *ni;
                                  ntfs_volume *vol, const WIMStruct *w)
 {
        ntfs_inode *ni;
@@ -590,26 +511,94 @@ static int apply_root_dentry_ntfs(const struct dentry *dentry,
 }
 
 /* Applies a WIM dentry to the NTFS volume */
 }
 
 /* Applies a WIM dentry to the NTFS volume */
-int apply_dentry_ntfs(struct dentry *dentry, void *arg)
+int apply_dentry_ntfs(struct wim_dentry *dentry, void *arg)
 {
        struct apply_args *args = arg;
        ntfs_volume *vol = args->vol;
        WIMStruct *w = args->w;
 {
        struct apply_args *args = arg;
        ntfs_volume *vol = args->vol;
        WIMStruct *w = args->w;
-       ntfs_inode *dir_ni;
+       struct wim_dentry *orig_dentry;
+       struct wim_dentry *other;
+       int ret;
 
 
+       /* Treat the root dentry specially. */
        if (dentry_is_root(dentry))
                return apply_root_dentry_ntfs(dentry, vol, w);
        if (dentry_is_root(dentry))
                return apply_root_dentry_ntfs(dentry, vol, w);
+       /* NTFS filename namespaces need careful consideration.  A name for a
+        * NTFS file may be in either the POSIX, Win32, DOS, or Win32+DOS
+        * namespaces.  The following list of assumptions and facts clarify the
+        * way that WIM dentries are mapped to NTFS files.  The statements
+        * marked ASSUMPTION are statements I am assuming to be true due to the
+        * lack of documentation; they are verified in verify_dentry() and
+        * verify_inode() in verify.c.
+        *
+        * - ASSUMPTION: The root WIM dentry has neither a "long name" nor a
+        *   "short name".
+        *
+        * - ASSUMPTION: Every WIM dentry other than the root directory provides
+        *   a non-empty "long name" and a possibly empty "short name".  The
+        *   "short name" corresponds to the DOS name of the file, while the
+        *   "long name" may be Win32 or POSIX.
+        *
+        *   XXX It may actually be legal to have a short name but no long name
+        *
+        * - FACT: If a dentry has a "long name" but no "short name", then it is
+        *   ambigious whether the name is POSIX or Win32+DOS, unless the name
+        *   is a valid POSIX name but not a valid Win32+DOS name.  wimlib
+        *   currently will always create POSIX names for these files, as this
+        *   is the behavior of the ntfs_create() and ntfs_link() functions.
+        *
+        * - FACT: Multiple WIM dentries may correspond to the same underlying
+        *   inode, as provided at this point in the code by the d_inode member.
+        */
+
+
+       /* Currently wimlib does not apply DOS names to hard linked files due to
+        * issues with ntfs-3g, so the following is commented out. */
+#if 0
+again:
+       /*
+        * libntfs-3g requires that for an NTFS inode with a DOS name, the
+        * corresponding long name be extracted first so that the DOS name is
+        * associated with the correct long name.  Note that by the last
+        * ASSUMPTION above, a NTFS inode can have at most one DOS name (i.e. a
+        * WIM inode can have at most one non-empty short name).
+        *
+        * Therefore, search for an alias of this dentry that has a short name,
+        * and extract it first unless it was already extracted.
+        */
+       orig_dentry = NULL;
+       if (!dentry->d_inode->i_dos_name_extracted) {
+               inode_for_each_dentry(other, dentry->d_inode) {
+                       if (other->short_name_len && other != dentry &&
+                           !other->is_extracted)
+                       {
+                               orig_dentry = dentry;
+                               dentry = other;
+                               break;
+                       }
+               }
+               dentry->d_inode->i_dos_name_extracted = 1;
+       }
+#endif
 
 
-       dir_ni = dentry_open_parent_ni(dentry, vol);
+       ntfs_inode *dir_ni = dentry_open_parent_ni(dentry, vol);
        if (dir_ni)
        if (dir_ni)
-               return do_apply_dentry_ntfs(dentry, dir_ni, arg);
+               ret = do_apply_dentry_ntfs(dentry, dir_ni, arg);
        else
        else
-               return WIMLIB_ERR_NTFS_3G;
+               ret = WIMLIB_ERR_NTFS_3G;
+
+#if 0
+       if (ret == 0 && orig_dentry) {
+               dentry = orig_dentry;
+               goto again;
+       }
+#endif
+       return ret;
 }
 
 /* Transfers the 100-nanosecond precision timestamps from a WIM dentry to a NTFS
  * inode */
 }
 
 /* Transfers the 100-nanosecond precision timestamps from a WIM dentry to a NTFS
  * inode */
-int apply_dentry_timestamps_ntfs(struct dentry *dentry, void *arg)
+int apply_dentry_timestamps_ntfs(struct wim_dentry *dentry, void *arg)
 {
        struct apply_args *args = arg;
        ntfs_volume *vol = args->vol;
 {
        struct apply_args *args = arg;
        ntfs_volume *vol = args->vol;
@@ -628,9 +617,9 @@ int apply_dentry_timestamps_ntfs(struct dentry *dentry, void *arg)
        }
 
        p = buf;
        }
 
        p = buf;
-       p = put_u64(p, dentry->d_inode->creation_time);
-       p = put_u64(p, dentry->d_inode->last_write_time);
-       p = put_u64(p, dentry->d_inode->last_access_time);
+       p = put_u64(p, dentry->d_inode->i_creation_time);
+       p = put_u64(p, dentry->d_inode->i_last_write_time);
+       p = put_u64(p, dentry->d_inode->i_last_access_time);
        ret = ntfs_inode_set_times(ni, (const char*)buf, 3 * sizeof(u64), 0);
        if (ret != 0) {
                ERROR_WITH_ERRNO("Failed to set NTFS timestamps on `%s'",
        ret = ntfs_inode_set_times(ni, (const char*)buf, 3 * sizeof(u64), 0);
        if (ret != 0) {
                ERROR_WITH_ERRNO("Failed to set NTFS timestamps on `%s'",