X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fntfs-3g_apply.c;h=4b6bc394a99565941ca2a828e2a274dcc8e0b911;hb=58ccad75516dcb536515cfb672e150670f44b957;hp=0a3dcaca50f77d5b97b9b1cb743fd70e0cd3c3e6;hpb=56f6607d5ecb59ab50f97c8b99f7fc92b9c67a39;p=wimlib diff --git a/src/ntfs-3g_apply.c b/src/ntfs-3g_apply.c index 0a3dcaca..4b6bc394 100644 --- a/src/ntfs-3g_apply.c +++ b/src/ntfs-3g_apply.c @@ -30,6 +30,7 @@ # include "config.h" #endif +#include #include #include @@ -53,9 +54,10 @@ static int ntfs_3g_get_supported_features(const char *target, struct wim_features *supported_features) { - supported_features->archive_files = 1; + supported_features->readonly_files = 1; supported_features->hidden_files = 1; supported_features->system_files = 1; + supported_features->archive_files = 1; supported_features->compressed_files = 1; supported_features->not_context_indexed_files = 1; supported_features->named_data_streams = 1; @@ -321,15 +323,37 @@ ntfs_3g_restore_reparse_point(ntfs_inode *ni, const struct wim_inode *inode, if (ntfs_set_ntfs_reparse_data(ni, (const char *)&ctx->rpbuf, REPARSE_DATA_OFFSET + blob_size, 0)) { + int err = errno; ERROR_WITH_ERRNO("Failed to set reparse data on \"%s\"", dentry_full_path( inode_first_extraction_dentry(inode))); + if (err == EINVAL && !(inode->i_reparse_tag & 0x80000000)) { + WARNING("This reparse point had a non-Microsoft reparse " + "tag. The preceding error may have been caused " + "by a known bug in libntfs-3g where it does not " + "correctly validate non-Microsoft reparse " + "points. This bug may be fixed in the 2016 " + "release of libntfs-3g."); + } return WIMLIB_ERR_SET_REPARSE_DATA; } return 0; } +static bool +ntfs_3g_has_empty_attributes(const struct wim_inode *inode) +{ + for (unsigned i = 0; i < inode->i_num_streams; i++) { + const struct wim_inode_stream *strm = &inode->i_streams[i]; + + if (stream_blob_resolved(strm) == NULL && + (strm->stream_type == STREAM_TYPE_REPARSE_POINT || + stream_is_named_data_stream(strm))) + return true; + } + return false; +} /* * Create empty attributes (named data streams and potentially a reparse point) @@ -337,13 +361,14 @@ ntfs_3g_restore_reparse_point(ntfs_inode *ni, const struct wim_inode *inode, * * 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. + * + * Keep this in sync with ntfs_3g_has_empty_attributes()! */ static int ntfs_3g_create_empty_attributes(ntfs_inode *ni, const struct wim_inode *inode, struct ntfs_3g_apply_ctx *ctx) { - for (unsigned i = 0; i < inode->i_num_streams; i++) { const struct wim_inode_stream *strm = &inode->i_streams[i]; @@ -415,15 +440,24 @@ ntfs_3g_set_metadata(ntfs_inode *ni, const struct wim_inode *inode, desc_size = sd->sizes[inode->i_security_id]; ret = ntfs_3g_set_security_descriptor(ni, desc, desc_size); - if (ret) { - if (wimlib_print_errors) { - ERROR_WITH_ERRNO("Failed to set security descriptor " - "on \"%s\" in NTFS volume", - dentry_full_path(one_dentry)); + + if (unlikely(ret)) { + int err = errno; + ERROR_WITH_ERRNO("Failed to set security descriptor on " + "\"%s\" in NTFS volume", + dentry_full_path(one_dentry)); + if (err == EINVAL && wimlib_print_errors) { fprintf(wimlib_error_file, "The security descriptor is: "); print_byte_field(desc, desc_size, wimlib_error_file); fprintf(wimlib_error_file, "\n"); + fprintf(wimlib_error_file, + "\nThis error occurred because libntfs-3g thinks " + "the security descriptor is invalid. If you " + "are extracting a Windows 10 image, this may be " + "caused by a known bug in libntfs-3g. See: " + "https://wimlib.net/forums/viewtopic.php?f=1&t=4 " + "for more information.\n\n"); } return ret; } @@ -470,8 +504,6 @@ ntfs_3g_create_dirs_recursive(ntfs_inode *dir_ni, struct wim_dentry *dir, ret = report_file_created(&ctx->common); if (!ret) ret = ntfs_3g_set_metadata(ni, child->d_inode, ctx); - if (!ret) - ret = ntfs_3g_create_empty_attributes(ni, child->d_inode, ctx); if (!ret) ret = ntfs_3g_create_dirs_recursive(ni, child, ctx); @@ -507,7 +539,9 @@ ntfs_3g_create_directories(struct wim_dentry *root, root->d_inode->i_mft_no = FILE_root; - ret = ntfs_3g_create_dirs_recursive(root_ni, root, ctx); + ret = ntfs_3g_set_metadata(root_ni, root->d_inode, ctx); + if (!ret) + ret = ntfs_3g_create_dirs_recursive(root_ni, root, ctx); if (ntfs_inode_close(root_ni) && !ret) { ERROR_WITH_ERRNO("Error closing root of NTFS volume"); @@ -516,18 +550,44 @@ ntfs_3g_create_directories(struct wim_dentry *root, if (ret) return ret; - /* Set the DOS name of any directory that has one. */ + /* Set the DOS name of any directory that has one. In addition, create + * empty attributes for directories that have them. Note that creating + * an empty reparse point attribute must happen *after* setting the + * DOS name in order to work around a case where + * ntfs_set_ntfs_dos_name() fails with EOPNOTSUPP. */ list_for_each_entry(dentry, dentry_list, d_extraction_list_node) { - if (!(dentry->d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)) - continue; - if (!dentry_has_short_name(dentry)) + const struct wim_inode *inode = dentry->d_inode; + + if (!(inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)) continue; - ret = ntfs_3g_restore_dos_name(NULL, NULL, dentry, ctx->vol); - if (ret) - return ret; - ret = report_file_created(&ctx->common); - if (ret) - return ret; + if (dentry_has_short_name(dentry)) { + ret = ntfs_3g_restore_dos_name(NULL, NULL, dentry, + ctx->vol); + if (ret) + return ret; + ret = report_file_created(&ctx->common); + if (ret) + return ret; + } + if (ntfs_3g_has_empty_attributes(inode)) { + ntfs_inode *ni; + + ret = WIMLIB_ERR_NTFS_3G; + ni = ntfs_inode_open(ctx->vol, inode->i_mft_no); + if (ni) { + ret = ntfs_3g_create_empty_attributes(ni, inode, + ctx); + if (ntfs_inode_close(ni) && !ret) + ret = WIMLIB_ERR_NTFS_3G; + } + if (ret) { + ERROR_WITH_ERRNO("Failed to create empty " + "attributes of directory " + "\"%s\" in NTFS volume", + dentry_full_path(dentry)); + return ret; + } + } } return 0; } @@ -704,6 +764,7 @@ ntfs_3g_begin_extract_blob_instance(struct blob_descriptor *blob, struct ntfs_3g_apply_ctx *ctx) { struct wim_dentry *one_dentry = inode_first_extraction_dentry(inode); + ntfschar *stream_name; size_t stream_name_nchars; ntfs_attr *attr; @@ -726,22 +787,29 @@ ntfs_3g_begin_extract_blob_instance(struct blob_descriptor *blob, /* It's a data stream (may be unnamed or named). */ wimlib_assert(strm->stream_type == STREAM_TYPE_DATA); - stream_name_nchars = utf16le_len_chars(strm->stream_name); + if (unlikely(stream_is_named(strm))) { + stream_name = strm->stream_name; + stream_name_nchars = utf16le_len_chars(stream_name); - if (stream_name_nchars && - (ntfs_attr_add(ni, AT_DATA, strm->stream_name, - stream_name_nchars, NULL, 0))) - { - ERROR_WITH_ERRNO("Failed to create named data stream of \"%s\"", - dentry_full_path(one_dentry)); - return WIMLIB_ERR_NTFS_3G; + if (ntfs_attr_add(ni, AT_DATA, stream_name, + stream_name_nchars, NULL, 0)) + { + ERROR_WITH_ERRNO("Failed to create named data stream of \"%s\"", + dentry_full_path(one_dentry)); + return WIMLIB_ERR_NTFS_3G; + } + } else { + /* Don't pass an empty string other than AT_UNNAMED to + * ntfs_attr_open() --- it violates assumptions made by + * libntfs-3g. */ + stream_name = AT_UNNAMED; + stream_name_nchars = 0; } /* This should be ensured by extract_blob_list() */ wimlib_assert(ctx->num_open_attrs < MAX_OPEN_FILES); - attr = ntfs_attr_open(ni, AT_DATA, strm->stream_name, - stream_name_nchars); + attr = ntfs_attr_open(ni, AT_DATA, stream_name, stream_name_nchars); if (!attr) { ERROR_WITH_ERRNO("Failed to open data stream of \"%s\"", dentry_full_path(one_dentry)); @@ -833,16 +901,35 @@ out: return ret; } +/* Note: contrary to its documentation, ntfs_attr_pwrite() can return a short + * count in non-error cases --- specifically, when writing to a compressed + * attribute and the requested count exceeds the size of an NTFS "compression + * block". Therefore, we must continue calling ntfs_attr_pwrite() until all + * bytes have been written or a real error has occurred. */ +static bool +ntfs_3g_full_pwrite(ntfs_attr *na, u64 offset, size_t size, const u8 *data) +{ + while (size) { + s64 res = ntfs_attr_pwrite(na, offset, size, data); + if (unlikely(res <= 0)) + return false; + wimlib_assert(res <= size); + offset += res; + size -= res; + data += res; + } + return true; +} + static int ntfs_3g_extract_chunk(const void *chunk, size_t size, void *_ctx) { struct ntfs_3g_apply_ctx *ctx = _ctx; - s64 res; for (unsigned i = 0; i < ctx->num_open_attrs; i++) { - res = ntfs_attr_pwrite(ctx->open_attrs[i], - ctx->offset, size, chunk); - if (res != size) { + if (!ntfs_3g_full_pwrite(ctx->open_attrs[i], + ctx->offset, size, chunk)) + { ERROR_WITH_ERRNO("Error writing data to NTFS volume"); return WIMLIB_ERR_NTFS_3G; }