X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=f447468eb6b044a91cb3ab72c7232ec0bcac86ad;hp=d692633ab490200667c1d68aac443fa47b417464;hb=78da4e026457e507e0d4fc930dcfe2855075dc11;hpb=4498586932ab670cf4791d8cf991d9b3e0ce1545 diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c index d692633a..f447468e 100644 --- a/src/ntfs-capture.c +++ b/src/ntfs-capture.c @@ -52,80 +52,132 @@ #include #endif -static inline ntfschar *attr_record_name(ATTR_RECORD *ar) +static inline ntfschar * +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; } - sha1_init(&ctx); + na = open_ntfs_attr(ni, loc); + if (!na) { + ret = WIMLIB_ERR_NTFS_3G; + goto out_close_ntfs_inode; + } + + 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 * lookup table */ -static int capture_ntfs_streams(struct wim_dentry *dentry, ntfs_inode *ni, - char path[], size_t path_len, - struct wim_lookup_table *lookup_table, - ntfs_volume **ntfs_vol_p, - ATTR_TYPES type) +static int +capture_ntfs_streams(struct wim_inode *inode, + ntfs_inode *ni, + char *path, + size_t path_len, + struct wim_lookup_table *lookup_table, + 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 ntfs_location *ntfs_loc; + int ret; struct wim_lookup_table_entry *lte; DEBUG2("Capturing NTFS data streams from `%s'", path); @@ -142,133 +194,111 @@ static int capture_ntfs_streams(struct wim_dentry *dentry, ntfs_inode *ni, while (!ntfs_attr_lookup(type, NULL, 0, CASE_SENSITIVE, 0, NULL, 0, actx)) { - char *stream_name_utf8; - 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 " - "`%s'", path); - ret = WIMLIB_ERR_NTFS_3G; - goto out_put_actx; - } /* Empty stream. No lookup table entry is needed. */ lte = NULL; + ntfs_loc = 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) { + ret = WIMLIB_ERR_NOMEM; 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) - dentry->d_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_utf8 = MALLOC(path_len + 1); - if (!ntfs_loc->path_utf8) + ntfs_loc->ntfs_vol = vol; + ntfs_loc->path = MALLOC(path_len + 1); + if (!ntfs_loc->path) { + ret = WIMLIB_ERR_NOMEM; + 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) { + ret = WIMLIB_ERR_NOMEM; goto out_free_ntfs_loc; - memcpy(ntfs_loc->path_utf8, path, path_len + 1); - if (name_length) { - ntfs_loc->stream_name_utf16 = MALLOC(name_length * 2); - if (!ntfs_loc->stream_name_utf16) - goto out_free_ntfs_loc; - memcpy(ntfs_loc->stream_name_utf16, - attr_record_name(actx->attr), - actx->attr->name_length * 2); - ntfs_loc->stream_name_utf16_num_chars = 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) { + ret = WIMLIB_ERR_NOMEM; + 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; - DEBUG("Add resource for `%s' (size = %"PRIu64")", - dentry->file_name_utf8, - lte->resource_entry.original_size); - 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 0 - if (dentry->d_inode->i_lte) { - ERROR("Found two un-named data streams for " - "`%s'", path); + if (inode->i_lte) { + ERROR("Found two un-named data streams for `%s'", + path); ret = WIMLIB_ERR_NTFS_3G; goto out_free_lte; } - dentry->d_inode->i_lte = lte; - #else - if (dentry->d_inode->i_lte) { - WARNING("Found two un-named data streams for " - "`%s'", path); - free_lookup_table_entry(lte); - } else { - dentry->d_inode->i_lte = lte; - } - #endif + stream_id = 0; + inode->i_lte = lte; } else { /* Named data stream. Put the reference to it in the * alternate data stream entries */ struct wim_ads_entry *new_ads_entry; - size_t stream_name_utf8_len; - ret = utf16_to_utf8((const char*)attr_record_name(actx->attr), - name_length * 2, - &stream_name_utf8, - &stream_name_utf8_len); - if (ret != 0) + new_ads_entry = inode_add_ads_utf16le(inode, + attr_record_name(actx->attr), + name_length * 2); + if (!new_ads_entry) { + ret = WIMLIB_ERR_NOMEM; goto out_free_lte; - new_ads_entry = inode_add_ads(dentry->d_inode, stream_name_utf8); - FREE(stream_name_utf8); - if (!new_ads_entry) - goto out_free_lte; - - wimlib_assert(new_ads_entry->stream_name_len == name_length * 2); - + } + 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); + } + } + if (errno == ENOENT) { + ret = 0; + } else { + ERROR_WITH_ERRNO("Error listing NTFS attributes from `%s'", + path); + ret = WIMLIB_ERR_NTFS_3G; } - ret = 0; goto out_put_actx; out_free_lte: free_lookup_table_entry(lte); out_free_ntfs_loc: if (ntfs_loc) { - FREE(ntfs_loc->path_utf8); - FREE(ntfs_loc->stream_name_utf16); + FREE(ntfs_loc->path); + FREE(ntfs_loc->stream_name); FREE(ntfs_loc); } out_put_actx: @@ -276,7 +306,7 @@ out_put_actx: if (ret == 0) DEBUG2("Successfully captured NTFS streams from `%s'", path); else - ERROR("Failed to capture NTFS streams from `%s", path); + ERROR("Failed to capture NTFS streams from `%s'", path); return ret; } @@ -288,33 +318,33 @@ struct dos_name_map { struct dos_name_node { struct rb_node rb_node; char dos_name[24]; - int name_len_bytes; + int name_nbytes; u64 ntfs_ino; }; /* Inserts a new DOS name into the map */ -static int insert_dos_name(struct dos_name_map *map, - const ntfschar *dos_name, int name_len, - u64 ntfs_ino) +static int +insert_dos_name(struct dos_name_map *map, const ntfschar *dos_name, + size_t name_nbytes, u64 ntfs_ino) { struct dos_name_node *new_node; struct rb_node **p; struct rb_root *root; struct rb_node *rb_parent; - DEBUG("DOS name_len = %d", name_len); + DEBUG("DOS name_len = %zu", name_nbytes); new_node = MALLOC(sizeof(struct dos_name_node)); if (!new_node) return -1; /* DOS names are supposed to be 12 characters max (that's 24 bytes, * assuming 2-byte ntfs characters) */ - wimlib_assert(name_len * sizeof(ntfschar) <= sizeof(new_node->dos_name)); + wimlib_assert(name_nbytes <= sizeof(new_node->dos_name)); /* Initialize the DOS name, DOS name length, and NTFS inode number of * the red-black tree node */ - memcpy(new_node->dos_name, dos_name, name_len * sizeof(ntfschar)); - new_node->name_len_bytes = name_len * sizeof(ntfschar); + memcpy(new_node->dos_name, dos_name, name_nbytes); + new_node->name_nbytes = name_nbytes; new_node->ntfs_ino = ntfs_ino; /* Insert the red-black tree node */ @@ -364,7 +394,8 @@ lookup_dos_name(const struct dos_name_map *map, u64 ntfs_ino) return NULL; } -static int set_dentry_dos_name(struct wim_dentry *dentry, void *arg) +static int +set_dentry_dos_name(struct wim_dentry *dentry, void *arg) { const struct dos_name_map *map = arg; const struct dos_name_node *node; @@ -372,12 +403,13 @@ static int set_dentry_dos_name(struct wim_dentry *dentry, void *arg) if (dentry->is_win32_name) { node = lookup_dos_name(map, dentry->d_inode->i_ino); if (node) { - dentry->short_name = MALLOC(node->name_len_bytes); + dentry->short_name = MALLOC(node->name_nbytes + 2); if (!dentry->short_name) return WIMLIB_ERR_NOMEM; memcpy(dentry->short_name, node->dos_name, - node->name_len_bytes); - dentry->short_name_len = node->name_len_bytes; + node->name_nbytes); + dentry->short_name[node->name_nbytes / 2] = 0; + dentry->short_name_nbytes = node->name_nbytes; DEBUG("Assigned DOS name to ino %"PRIu64, dentry->d_inode->i_ino); } else { @@ -389,7 +421,8 @@ static int set_dentry_dos_name(struct wim_dentry *dentry, void *arg) return 0; } -static void free_dos_name_tree(struct rb_node *node) { +static void +free_dos_name_tree(struct rb_node *node) { if (node) { free_dos_name_tree(node->rb_left); free_dos_name_tree(node->rb_right); @@ -397,7 +430,8 @@ static void free_dos_name_tree(struct rb_node *node) { } } -static void destroy_dos_name_map(struct dos_name_map *map) +static void +destroy_dos_name_map(struct dos_name_map *map) { free_dos_name_tree(map->rb_root.rb_node); } @@ -408,62 +442,69 @@ struct readdir_ctx { char *path; size_t path_len; struct wim_lookup_table *lookup_table; + struct wim_inode_table *inode_table; struct sd_set *sd_set; struct dos_name_map *dos_name_map; - const struct capture_config *config; - ntfs_volume **ntfs_vol_p; + const struct wimlib_capture_config *config; + ntfs_volume *vol; int add_image_flags; wimlib_progress_func_t progress_func; }; static int -build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, ntfs_inode *dir_ni, - ntfs_inode *ni, char path[], size_t path_len, +build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, + ntfs_inode *dir_ni, + ntfs_inode *ni, + char *path, + size_t path_len, int name_type, struct wim_lookup_table *lookup_table, + struct wim_inode_table *inode_table, struct sd_set *sd_set, - const struct capture_config *config, - ntfs_volume **ntfs_vol_p, + const struct wimlib_capture_config *config, + ntfs_volume *ntfs_vol, int add_image_flags, wimlib_progress_func_t progress_func); -static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, - const int name_len, const int name_type, - const s64 pos, const MFT_REF mref, - const unsigned dt_type) +static int +wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, + const int name_nchars, const int name_type, + const s64 pos, const MFT_REF mref, + const unsigned dt_type) { struct readdir_ctx *ctx; - size_t utf8_name_len; - char *utf8_name; + size_t mbs_name_nbytes; + char *mbs_name; struct wim_dentry *child; int ret; size_t path_len; + size_t name_nbytes = name_nchars * sizeof(ntfschar); ctx = dirent; if (name_type & FILE_NAME_DOS) { /* If this is the entry for a DOS name, store it for later. */ ret = insert_dos_name(ctx->dos_name_map, name, - name_len, mref & MFT_REF_MASK_CPU); + name_nbytes, mref & MFT_REF_MASK_CPU); /* Return now if an error occurred or if this is just a DOS name * and not a Win32+DOS name. */ if (ret != 0 || name_type == FILE_NAME_DOS) - return ret; + goto out; } - ret = utf16_to_utf8((const char*)name, name_len * 2, - &utf8_name, &utf8_name_len); - if (ret != 0) - return -1; + ret = utf16le_to_tstr(name, name_nbytes, + &mbs_name, &mbs_name_nbytes); + if (ret) + goto out; - if (utf8_name[0] == '.' && - (utf8_name[1] == '\0' || - (utf8_name[1] == '.' && utf8_name[2] == '\0'))) { + if (mbs_name[0] == '.' && + (mbs_name[1] == '\0' || + (mbs_name[1] == '.' && mbs_name[2] == '\0'))) { /* . or .. entries * * note: name_type is POSIX for these, so DOS names will not * have been inserted for them. */ ret = 0; - goto out_free_utf8_name; + goto out_free_mbs_name; } /* Open the inode for this directory entry and recursively capture the @@ -471,25 +512,29 @@ static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, ntfs_inode *ni = ntfs_inode_open(ctx->dir_ni->vol, mref); if (!ni) { ERROR_WITH_ERRNO("Failed to open NTFS inode"); - goto out_free_utf8_name; + ret = -1; + goto out_free_mbs_name; } path_len = ctx->path_len; if (path_len != 1) ctx->path[path_len++] = '/'; - memcpy(ctx->path + path_len, utf8_name, utf8_name_len + 1); - path_len += utf8_name_len; + memcpy(ctx->path + path_len, mbs_name, mbs_name_nbytes + 1); + path_len += mbs_name_nbytes; child = NULL; ret = build_dentry_tree_ntfs_recursive(&child, ctx->dir_ni, ni, ctx->path, path_len, name_type, - ctx->lookup_table, ctx->sd_set, - ctx->config, ctx->ntfs_vol_p, + ctx->lookup_table, + ctx->inode_table, + ctx->sd_set, + ctx->config, ctx->vol, ctx->add_image_flags, ctx->progress_func); if (child) dentry_add_child(ctx->parent, child); ntfs_inode_close(ni); -out_free_utf8_name: - FREE(utf8_name); +out_free_mbs_name: + FREE(mbs_name); +out: return ret; } @@ -497,27 +542,31 @@ out_free_utf8_name: * At the same time, update the WIM lookup table with lookup table entries for * the NTFS streams, and build an array of security descriptors. */ -static int build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, - ntfs_inode *dir_ni, - ntfs_inode *ni, - char path[], - size_t path_len, - int name_type, - struct wim_lookup_table *lookup_table, - struct sd_set *sd_set, - const struct capture_config *config, - ntfs_volume **ntfs_vol_p, - int add_image_flags, - wimlib_progress_func_t progress_func) +static int +build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret, + ntfs_inode *dir_ni, + ntfs_inode *ni, + char *path, + size_t path_len, + int name_type, + struct wim_lookup_table *lookup_table, + struct wim_inode_table *inode_table, + struct sd_set *sd_set, + const struct wimlib_capture_config *config, + ntfs_volume *vol, + int add_image_flags, + wimlib_progress_func_t progress_func) { u32 attributes; int ret; struct wim_dentry *root; + struct wim_inode *inode; + ATTR_TYPES stream_type; - if (exclude_path(path, config, false)) { + if (exclude_path(path, path_len, config, false)) { /* Exclude a file or directory tree based on the capture * configuration file */ - if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE) + if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE) && progress_func) { union wimlib_progress_info info; @@ -525,14 +574,15 @@ static int build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, info.scan.excluded = true; progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info); } - *root_p = NULL; - return 0; + root = NULL; + ret = 0; + goto out; } /* 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)); @@ -551,35 +601,48 @@ static int build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info); } - /* Create the new WIM dentry */ - root = new_dentry_with_timeless_inode(path_basename(path)); - if (!root) { - if (errno == EILSEQ) - return WIMLIB_ERR_INVALID_UTF8_STRING; - else if (errno == ENOMEM) - return WIMLIB_ERR_NOMEM; - else - return WIMLIB_ERR_ICONV_NOT_AVAILABLE; - } - *root_p = root; + /* Create a WIM dentry with an associated inode, which may be shared */ + ret = inode_table_new_dentry(inode_table, + path_basename_with_len(path, path_len), + ni->mft_no, + 0, + &root); + if (ret) + return ret; + + inode = root->d_inode; - if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name */ + if (inode->i_nlink > 1) /* Shared inode; nothing more to do */ + goto out; + + if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name (rather than POSIX) */ root->is_win32_name = 1; - root->d_inode->i_creation_time = le64_to_cpu(ni->creation_time); - root->d_inode->i_last_write_time = le64_to_cpu(ni->last_data_change_time); - root->d_inode->i_last_access_time = le64_to_cpu(ni->last_access_time); - root->d_inode->i_attributes = le32_to_cpu(attributes); - root->d_inode->i_ino = ni->mft_no; - root->d_inode->i_resolved = 1; - - if (attributes & FILE_ATTR_REPARSE_POINT) { - /* Junction point, symbolic link, or other reparse point */ - ret = capture_ntfs_streams(root, ni, path, path_len, - lookup_table, ntfs_vol_p, - AT_REPARSE_POINT); - } else if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) { - - /* Normal directory */ + inode->i_creation_time = le64_to_cpu(ni->creation_time); + inode->i_last_write_time = le64_to_cpu(ni->last_data_change_time); + inode->i_last_access_time = le64_to_cpu(ni->last_access_time); + inode->i_attributes = le32_to_cpu(attributes); + inode->i_resolved = 1; + + if (attributes & FILE_ATTR_REPARSE_POINT) + stream_type = AT_REPARSE_POINT; + else + stream_type = AT_DATA; + + /* Capture the file's streams; more specifically, this is supposed to: + * + * - Regular files: capture unnamed data stream and any named data + * streams + * - Directories: capture any named data streams + * - Reparse points: capture reparse data only + */ + ret = capture_ntfs_streams(inode, ni, path, path_len, lookup_table, + vol, stream_type); + if (ret) + goto out; + + if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) { + + /* Recurse to directory children */ s64 pos = 0; struct dos_name_map dos_name_map = { .rb_root = {.rb_node = NULL} }; struct readdir_ctx ctx = { @@ -588,10 +651,11 @@ static int build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, .path = path, .path_len = path_len, .lookup_table = lookup_table, + .inode_table = inode_table, .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, }; @@ -604,64 +668,75 @@ static int build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, &dos_name_map); } destroy_dos_name_map(&dos_name_map); - } else { - /* Normal file */ - ret = capture_ntfs_streams(root, ni, path, path_len, - lookup_table, ntfs_vol_p, - AT_DATA); + if (ret) + goto out; } - if (ret != 0) - return ret; - /* Get security descriptor */ - char _sd[1]; - char *sd = _sd; - errno = 0; - ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL, - ni, dir_ni, sd, - sizeof(sd)); - if (ret > sizeof(sd)) { - sd = alloca(ret); + if (!(add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) { + /* Get security descriptor */ + char _sd[1]; + char *sd = _sd; + errno = 0; ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL, - ni, dir_ni, sd, ret); - } - if (ret > 0) { - root->d_inode->i_security_id = sd_set_add_sd(sd_set, sd, ret); - if (root->d_inode->i_security_id == -1) { - ERROR("Out of memory"); - return WIMLIB_ERR_NOMEM; + ni, dir_ni, sd, + sizeof(sd)); + if (ret > sizeof(sd)) { + sd = alloca(ret); + ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL, + ni, dir_ni, sd, ret); + } + if (ret > 0) { + inode->i_security_id = sd_set_add_sd(sd_set, sd, ret); + if (inode->i_security_id == -1) { + ERROR("Out of memory"); + ret = WIMLIB_ERR_NOMEM; + goto out; + } + DEBUG("Added security ID = %u for `%s'", + inode->i_security_id, path); + ret = 0; + } else if (ret < 0) { + ERROR_WITH_ERRNO("Failed to get security information from " + "`%s'", path); + ret = WIMLIB_ERR_NTFS_3G; + } else { + inode->i_security_id = -1; + DEBUG("No security ID for `%s'", path); } - DEBUG("Added security ID = %u for `%s'", - root->d_inode->i_security_id, path); - ret = 0; - } else if (ret < 0) { - ERROR_WITH_ERRNO("Failed to get security information from " - "`%s'", path); - ret = WIMLIB_ERR_NTFS_3G; - } else { - root->d_inode->i_security_id = -1; - DEBUG("No security ID for `%s'", path); } +out: + if (ret == 0) + *root_ret = root; + else + free_dentry_tree(root, lookup_table); return ret; } -int build_dentry_tree_ntfs(struct wim_dentry **root_p, - const char *device, - struct wim_lookup_table *lookup_table, - struct wim_security_data *sd, - const struct capture_config *config, - int add_image_flags, - wimlib_progress_func_t progress_func, - void *extra_arg) + +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, + struct wim_lookup_table *lookup_table, + struct wim_inode_table *inode_table, + struct sd_set *sd_set, + const struct wimlib_capture_config *config, + int add_image_flags, + wimlib_progress_func_t progress_func, + void *extra_arg) { ntfs_volume *vol; ntfs_inode *root_ni; int ret; - struct sd_set sd_set = { - .sd = sd, - .rb_root = {NULL}, - }; - ntfs_volume **ntfs_vol_p = extra_arg; DEBUG("Mounting NTFS volume `%s' read-only", device); @@ -693,8 +768,8 @@ int build_dentry_tree_ntfs(struct wim_dentry **root_p, goto out; } - /* Currently we assume that all the UTF-8 paths fit into this length and - * there is no check for overflow. */ + /* Currently we assume that all the paths fit into this length and there + * is no check for overflow. */ char *path = MALLOC(32768); if (!path) { ERROR("Could not allocate memory for NTFS pathname"); @@ -706,21 +781,21 @@ int build_dentry_tree_ntfs(struct wim_dentry **root_p, path[1] = '\0'; ret = build_dentry_tree_ntfs_recursive(root_p, NULL, root_ni, path, 1, FILE_NAME_POSIX, lookup_table, - &sd_set, - config, ntfs_vol_p, + inode_table, + sd_set, + config, vol, add_image_flags, progress_func); out_cleanup: FREE(path); ntfs_inode_close(root_ni); - destroy_sd_set(&sd_set); out: ntfs_index_ctx_put(vol->secure_xsii); ntfs_index_ctx_put(vol->secure_xsdh); 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) @@ -729,7 +804,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; }