X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=2656d1dd7f44afc40c57e782737d891232cabb71;hp=94e74cee4f360cb68a2f3c78e47642d7edf7b533;hb=3f9b53a4a214a254bb27ed30994faf2a0fd12375;hpb=c6a1140e085f633273fcf47a6462bd9382ce118a diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c index 94e74cee..2656d1dd 100644 --- a/src/ntfs-capture.c +++ b/src/ntfs-capture.c @@ -58,62 +58,110 @@ attr_record_name(ATTR_RECORD *ar) return (ntfschar*)((u8*)ar + le16_to_cpu(ar->name_offset)); } -/* Calculates the SHA1 message digest of a NTFS attribute. - * - * @ni: The NTFS inode containing the attribute. - * @ar: The ATTR_RECORD describing the attribute. - * @md: If successful, the returned SHA1 message digest. - * @reparse_tag_ret: Optional pointer into which the first 4 bytes of the - * attribute will be written (to get the reparse - * point ID) - * - * Return 0 on success or nonzero on error. - */ -static int -ntfs_attr_sha1sum(ntfs_inode *ni, ATTR_RECORD *ar, - u8 md[SHA1_HASH_SIZE], - bool is_reparse_point, - u32 *reparse_tag_ret) +static ntfs_attr * +open_ntfs_attr(ntfs_inode *ni, struct ntfs_location *loc) { - s64 pos = 0; - s64 bytes_remaining; - char buf[BUFFER_SIZE]; ntfs_attr *na; - SHA_CTX ctx; - na = ntfs_attr_open(ni, ar->type, attr_record_name(ar), - ar->name_length); + na = ntfs_attr_open(ni, + loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA, + loc->stream_name, + loc->stream_name_nchars); if (!na) { - ERROR_WITH_ERRNO("Failed to open NTFS attribute"); - return WIMLIB_ERR_NTFS_3G; + ERROR_WITH_ERRNO("Failed to open attribute of \"%"TS"\" in " + "NTFS volume", loc->path); } + return na; +} - bytes_remaining = na->data_size; +int +read_ntfs_file_prefix(const struct wim_lookup_table_entry *lte, + u64 size, + consume_data_callback_t cb, + void *ctx_or_buf, + int _ignored_flags) +{ + struct ntfs_location *loc = lte->ntfs_loc; + ntfs_volume *vol = loc->ntfs_vol; + ntfs_inode *ni; + ntfs_attr *na; + s64 pos; + s64 bytes_remaining; + void *out_buf; + int ret; - if (is_reparse_point) { - if (ntfs_attr_pread(na, 0, 8, buf) != 8) - goto out_error; - *reparse_tag_ret = le32_to_cpu(*(u32*)buf); - DEBUG("ReparseTag = %#x", *reparse_tag_ret); - pos = 8; - bytes_remaining -= 8; + ni = ntfs_pathname_to_inode(vol, NULL, loc->path); + if (!ni) { + ERROR_WITH_ERRNO("Can't find NTFS inode for \"%"TS"\"", loc->path); + ret = WIMLIB_ERR_NTFS_3G; + goto out; + } + + na = open_ntfs_attr(ni, loc); + if (!na) { + ret = WIMLIB_ERR_NTFS_3G; + goto out_close_ntfs_inode; } - sha1_init(&ctx); + if (cb) + out_buf = alloca(WIM_CHUNK_SIZE); + else + out_buf = ctx_or_buf; + pos = (loc->is_reparse_point) ? 8 : 0; + bytes_remaining = size; while (bytes_remaining) { - s64 to_read = min(bytes_remaining, sizeof(buf)); - if (ntfs_attr_pread(na, pos, to_read, buf) != to_read) - goto out_error; - sha1_update(&ctx, buf, to_read); + s64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE); + if (ntfs_attr_pread(na, pos, to_read, out_buf) != to_read) { + ERROR_WITH_ERRNO("Error reading \"%"TS"\"", loc->path); + ret = WIMLIB_ERR_NTFS_3G; + goto out_close_ntfs_attr; + } pos += to_read; bytes_remaining -= to_read; + if (cb) { + ret = cb(out_buf, to_read, ctx_or_buf); + if (ret) + goto out_close_ntfs_attr; + } else { + out_buf += to_read; + } } - sha1_final(md, &ctx); + ret = 0; +out_close_ntfs_attr: ntfs_attr_close(na); - return 0; -out_error: - ERROR_WITH_ERRNO("Error reading NTFS attribute"); - return WIMLIB_ERR_NTFS_3G; +out_close_ntfs_inode: + ntfs_inode_close(ni); +out: + return ret; +} + +static int +read_reparse_tag(ntfs_inode *ni, struct ntfs_location *loc, + u32 *reparse_tag_ret) +{ + int ret; + u8 buf[8]; + ntfs_attr *na; + + na = open_ntfs_attr(ni, loc); + if (!na) { + ret = WIMLIB_ERR_NTFS_3G; + goto out; + } + + if (ntfs_attr_pread(na, 0, 8, buf) != 8) { + ERROR_WITH_ERRNO("Error reading reparse data"); + ret = WIMLIB_ERR_NTFS_3G; + goto out_close_ntfs_attr; + } + *reparse_tag_ret = le32_to_cpu(*(u32*)buf); + DEBUG("ReparseTag = %#x", *reparse_tag_ret); + ret = 0; +out_close_ntfs_attr: + ntfs_attr_close(na); +out: + return ret; + } /* Load the streams from a file or reparse point in the NTFS volume into the WIM @@ -124,11 +172,10 @@ capture_ntfs_streams(struct wim_inode *inode, char *path, size_t path_len, struct wim_lookup_table *lookup_table, - ntfs_volume **ntfs_vol_p, + ntfs_volume *vol, ATTR_TYPES type) { ntfs_attr_search_ctx *actx; - u8 attr_hash[SHA1_HASH_SIZE]; struct ntfs_location *ntfs_loc = NULL; int ret = 0; struct wim_lookup_table_entry *lte; @@ -147,9 +194,10 @@ capture_ntfs_streams(struct wim_inode *inode, while (!ntfs_attr_lookup(type, NULL, 0, CASE_SENSITIVE, 0, NULL, 0, actx)) { - u32 reparse_tag; u64 data_size = ntfs_get_attribute_value_length(actx->attr); u64 name_length = actx->attr->name_length; + u32 stream_id; + if (data_size == 0) { if (errno != 0) { ERROR_WITH_ERRNO("Failed to get size of attribute of " @@ -160,75 +208,59 @@ capture_ntfs_streams(struct wim_inode *inode, /* Empty stream. No lookup table entry is needed. */ lte = NULL; } else { - if (type == AT_REPARSE_POINT && data_size < 8) { - ERROR("`%s': reparse point buffer too small", - path); - ret = WIMLIB_ERR_NTFS_3G; + ntfs_loc = CALLOC(1, sizeof(*ntfs_loc)); + if (!ntfs_loc) goto out_put_actx; - } - /* Checksum the stream. */ - ret = ntfs_attr_sha1sum(ni, actx->attr, attr_hash, - type == AT_REPARSE_POINT, &reparse_tag); - if (ret != 0) - goto out_put_actx; - - if (type == AT_REPARSE_POINT) - inode->i_reparse_tag = reparse_tag; - - /* Make a lookup table entry for the stream, or use an existing - * one if there's already an identical stream. */ - lte = __lookup_resource(lookup_table, attr_hash); - ret = WIMLIB_ERR_NOMEM; - if (lte) { - lte->refcnt++; - } else { - ntfs_loc = CALLOC(1, sizeof(*ntfs_loc)); - if (!ntfs_loc) - goto out_put_actx; - ntfs_loc->ntfs_vol_p = ntfs_vol_p; - ntfs_loc->path = MALLOC(path_len + 1); - if (!ntfs_loc->path) + ntfs_loc->ntfs_vol = vol; + ntfs_loc->path = MALLOC(path_len + 1); + if (!ntfs_loc->path) + goto out_free_ntfs_loc; + memcpy(ntfs_loc->path, path, path_len + 1); + if (name_length) { + ntfs_loc->stream_name = MALLOC(name_length * 2); + if (!ntfs_loc->stream_name) goto out_free_ntfs_loc; - memcpy(ntfs_loc->path, path, path_len + 1); - if (name_length) { - ntfs_loc->stream_name = MALLOC(name_length * 2); - if (!ntfs_loc->stream_name) - goto out_free_ntfs_loc; - memcpy(ntfs_loc->stream_name, - attr_record_name(actx->attr), - actx->attr->name_length * 2); - ntfs_loc->stream_name_nchars = name_length; - } + memcpy(ntfs_loc->stream_name, + attr_record_name(actx->attr), + actx->attr->name_length * 2); + ntfs_loc->stream_name_nchars = name_length; + } - lte = new_lookup_table_entry(); - if (!lte) - goto out_free_ntfs_loc; - lte->ntfs_loc = ntfs_loc; - lte->resource_location = RESOURCE_IN_NTFS_VOLUME; - if (type == AT_REPARSE_POINT) { - ntfs_loc->is_reparse_point = true; - lte->resource_entry.original_size = data_size - 8; - lte->resource_entry.size = data_size - 8; - } else { - ntfs_loc->is_reparse_point = false; - lte->resource_entry.original_size = data_size; - lte->resource_entry.size = data_size; + lte = new_lookup_table_entry(); + if (!lte) + goto out_free_ntfs_loc; + lte->resource_location = RESOURCE_IN_NTFS_VOLUME; + lte->ntfs_loc = ntfs_loc; + ntfs_loc = NULL; + if (type == AT_REPARSE_POINT) { + if (data_size < 8) { + ERROR("Invalid reparse data (only %u bytes)!", + (unsigned)data_size); + ret = WIMLIB_ERR_NTFS_3G; + goto out_free_lte; } - ntfs_loc = NULL; - copy_hash(lte->hash, attr_hash); - lookup_table_insert(lookup_table, lte); + lte->ntfs_loc->is_reparse_point = true; + lte->resource_entry.original_size = data_size - 8; + ret = read_reparse_tag(ni, lte->ntfs_loc, + &inode->i_reparse_tag); + if (ret) + goto out_free_lte; + } else { + lte->ntfs_loc->is_reparse_point = false; + lte->resource_entry.original_size = data_size; } } if (name_length == 0) { /* Unnamed data stream. Put the reference to it in the * dentry's inode. */ if (inode->i_lte) { - WARNING("Found two un-named data streams for " - "`%s'", path); - free_lookup_table_entry(lte); - } else { - inode->i_lte = lte; + ERROR("Found two un-named data streams for `%s'", + path); + ret = WIMLIB_ERR_NTFS_3G; + goto out_free_lte; } + stream_id = 0; + inode->i_lte = lte; } else { /* Named data stream. Put the reference to it in the * alternate data stream entries */ @@ -240,8 +272,13 @@ capture_ntfs_streams(struct wim_inode *inode, if (!new_ads_entry) goto out_free_lte; wimlib_assert(new_ads_entry->stream_name_nbytes == name_length * 2); + stream_id = new_ads_entry->stream_id; new_ads_entry->lte = lte; } + if (lte) { + lookup_table_insert_unhashed(lookup_table, lte, + inode, stream_id); + } } ret = 0; goto out_put_actx; @@ -398,7 +435,7 @@ struct readdir_ctx { struct sd_set *sd_set; struct dos_name_map *dos_name_map; const struct wimlib_capture_config *config; - ntfs_volume **ntfs_vol_p; + ntfs_volume *vol; int add_image_flags; wimlib_progress_func_t progress_func; }; @@ -414,7 +451,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, struct wim_inode_table *inode_table, struct sd_set *sd_set, const struct wimlib_capture_config *config, - ntfs_volume **ntfs_vol_p, + ntfs_volume *ntfs_vol, int add_image_flags, wimlib_progress_func_t progress_func); @@ -478,7 +515,7 @@ wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, ctx->lookup_table, ctx->inode_table, ctx->sd_set, - ctx->config, ctx->ntfs_vol_p, + ctx->config, ctx->vol, ctx->add_image_flags, ctx->progress_func); if (child) @@ -505,7 +542,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, struct wim_inode_table *inode_table, struct sd_set *sd_set, const struct wimlib_capture_config *config, - ntfs_volume **ntfs_vol_p, + ntfs_volume *vol, int add_image_flags, wimlib_progress_func_t progress_func) { @@ -533,7 +570,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, /* Get file attributes */ struct SECURITY_CONTEXT ctx; memset(&ctx, 0, sizeof(ctx)); - ctx.vol = ni->vol; + ctx.vol = vol; ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ATTRIB, ni, dir_ni, (char *)&attributes, sizeof(u32)); @@ -578,7 +615,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, /* Junction point, symbolic link, or other reparse point */ ret = capture_ntfs_streams(inode, ni, path, path_len, lookup_table, - ntfs_vol_p, AT_REPARSE_POINT); + vol, AT_REPARSE_POINT); } else if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) { /* Normal directory */ @@ -594,7 +631,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, .sd_set = sd_set, .dos_name_map = &dos_name_map, .config = config, - .ntfs_vol_p = ntfs_vol_p, + .vol = vol, .add_image_flags = add_image_flags, .progress_func = progress_func, }; @@ -611,7 +648,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, /* Normal file */ ret = capture_ntfs_streams(inode, ni, path, path_len, lookup_table, - ntfs_vol_p, AT_DATA); + vol, AT_DATA); } if (ret) goto out; @@ -656,6 +693,17 @@ out: return ret; } + +int +do_ntfs_umount(struct _ntfs_volume *vol) +{ + DEBUG("Unmounting NTFS volume"); + if (ntfs_umount(vol, FALSE)) + return WIMLIB_ERR_NTFS_3G; + else + return 0; +} + int build_dentry_tree_ntfs(struct wim_dentry **root_p, const char *device, @@ -670,7 +718,6 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p, ntfs_volume *vol; ntfs_inode *root_ni; int ret; - ntfs_volume **ntfs_vol_p = extra_arg; DEBUG("Mounting NTFS volume `%s' read-only", device); @@ -717,7 +764,7 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p, FILE_NAME_POSIX, lookup_table, inode_table, sd_set, - config, ntfs_vol_p, + config, vol, add_image_flags, progress_func); out_cleanup: @@ -729,7 +776,7 @@ out: ntfs_inode_close(vol->secure_ni); if (ret) { - if (ntfs_umount(vol, FALSE) != 0) { + if (do_ntfs_umount(vol)) { ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", device); if (ret == 0) @@ -738,7 +785,7 @@ out: } else { /* We need to leave the NTFS volume mounted so that we can read * the NTFS files again when we are actually writing the WIM */ - *ntfs_vol_p = vol; + *(ntfs_volume**)extra_arg = vol; } return ret; }