Always specify AT_UNNAMED when opening unnamed stream with libntfs-3g

[wimlib] / src / ntfs-3g_capture.c

diff --git a/src/ntfs-3g_capture.c b/src/ntfs-3g_capture.c
index 7efed22b921b91c933df0284d76ea82924d73cc8..d9a7f2f6f1c1abadf8028e748fd32e267976a4d9 100644 (file)
--- a/src/ntfs-3g_capture.c
+++ b/src/ntfs-3g_capture.c
@@ -70,7 +70,7 @@ struct ntfs_location {
        u64 mft_no;
        ATTR_TYPES attr_type;
        u32 attr_name_nchars;
-       utf16lechar *attr_name;
+       ntfschar *attr_name;
        u64 sort_key;
 };
 
@@ -167,7 +167,8 @@ void
 free_ntfs_location(struct ntfs_location *loc)
 {
        put_ntfs_volume(loc->volume);
-       FREE(loc->attr_name);
+       if (loc->attr_name != AT_UNNAMED)
+               FREE(loc->attr_name);
        FREE(loc);
 }
 
@@ -177,7 +178,7 @@ clone_ntfs_location(const struct ntfs_location *loc)
        struct ntfs_location *new = memdup(loc, sizeof(*loc));
        if (!new)
                goto err0;
-       if (loc->attr_name) {
+       if (loc->attr_name != AT_UNNAMED) {
                new->attr_name = utf16le_dup(loc->attr_name);
                if (!new->attr_name)
                        goto err1;
@@ -265,6 +266,44 @@ set_attr_sort_key(ntfs_inode *ni, struct ntfs_location *loc)
        return 0;
 }
 
+/*
+ * Add a new stream to the specified inode, with duplicate checking.
+ *
+ * This works around a problem where NTFS-3g can list multiple unnamed data
+ * streams for a single file.  In this case we can only keep one.  We'll prefer
+ * one that is nonempty.
+ */
+static int
+add_stream(struct wim_inode *inode, const char *path, int stream_type,
+          const utf16lechar *stream_name, struct blob_descriptor **blob_p,
+          struct list_head *unhashed_blobs)
+{
+       struct blob_descriptor *blob = *blob_p;
+       struct wim_inode_stream *strm;
+
+       strm = inode_get_stream(inode, stream_type, stream_name);
+       if (unlikely(strm)) {
+               /* Stream already existed.  */
+               if (!blob)
+                       return 0;
+               if (stream_blob_resolved(strm)) {
+                       WARNING("\"%s\" has multiple nonempty streams "
+                               "with the same type and name!  Only the first "
+                               "will be saved.", path);
+                       return 0;
+               }
+               inode_replace_stream_blob(inode, strm, blob, NULL);
+       } else {
+               strm = inode_add_stream(inode, stream_type, stream_name, blob);
+               if (unlikely(!strm))
+                       return WIMLIB_ERR_NOMEM;
+       }
+       prepare_unhashed_blob(blob, inode, strm->stream_id, unhashed_blobs);
+       *blob_p = NULL;
+       return 0;
+
+}
+
 /* Save information about an NTFS attribute (stream) to a WIM inode.  */
 static int
 scan_ntfs_attr(struct wim_inode *inode,
@@ -278,8 +317,7 @@ scan_ntfs_attr(struct wim_inode *inode,
        u64 data_size = ntfs_get_attribute_value_length(record);
        const u32 name_nchars = record->name_length;
        struct blob_descriptor *blob = NULL;
-       utf16lechar *stream_name = NULL;
-       struct wim_inode_stream *strm;
+       utf16lechar *stream_name = (utf16lechar *)NO_STREAM_NAME;
        int ret;
 
        if (unlikely(name_nchars)) {
@@ -317,7 +355,7 @@ scan_ntfs_attr(struct wim_inode *inode,
                        goto out_cleanup;
                }
 
-               blob->ntfs_loc = CALLOC(1, sizeof(struct ntfs_location));
+               blob->ntfs_loc = MALLOC(sizeof(struct ntfs_location));
                if (unlikely(!blob->ntfs_loc)) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto out_cleanup;
@@ -326,16 +364,19 @@ scan_ntfs_attr(struct wim_inode *inode,
                blob->blob_location = BLOB_IN_NTFS_VOLUME;
                blob->size = data_size;
                blob->ntfs_loc->volume = get_ntfs_volume(volume);
-               blob->ntfs_loc->attr_type = type;
                blob->ntfs_loc->mft_no = ni->mft_no;
+               blob->ntfs_loc->attr_type = type;
 
                if (unlikely(name_nchars)) {
+                       blob->ntfs_loc->attr_name_nchars = name_nchars;
                        blob->ntfs_loc->attr_name = utf16le_dup(stream_name);
                        if (!blob->ntfs_loc->attr_name) {
                                ret = WIMLIB_ERR_NOMEM;
                                goto out_cleanup;
                        }
-                       blob->ntfs_loc->attr_name_nchars = name_nchars;
+               } else {
+                       blob->ntfs_loc->attr_name_nchars = 0;
+                       blob->ntfs_loc->attr_name = AT_UNNAMED;
                }
 
                ret = set_attr_sort_key(ni, blob->ntfs_loc);
@@ -343,20 +384,12 @@ scan_ntfs_attr(struct wim_inode *inode,
                        goto out_cleanup;
        }
 
-       strm = inode_add_stream(inode,
-                               attr_type_to_wimlib_stream_type(type),
-                               stream_name ? stream_name : NO_STREAM_NAME,
-                               blob);
-       if (unlikely(!strm)) {
-               ret = WIMLIB_ERR_NOMEM;
-               goto out_cleanup;
-       }
-       prepare_unhashed_blob(blob, inode, strm->stream_id, unhashed_blobs);
-       blob = NULL;
-       ret = 0;
+       ret = add_stream(inode, path, attr_type_to_wimlib_stream_type(type),
+                        stream_name, &blob, unhashed_blobs);
 out_cleanup:
        free_blob_descriptor(blob);
-       FREE(stream_name);
+       if (stream_name != NO_STREAM_NAME)
+               FREE(stream_name);
        return ret;
 }