X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fiterate_dir.c;h=451143a765f9015236345f40f01640e07d646a7a;hp=cc5c63b89c4b52626c5bea06d24304cf89194b70;hb=7b587995ba7f2fb4e3a8d23f4be0ad91f1ab066a;hpb=668c363a59c521f48eecbc4dd549c07a3e36179e diff --git a/src/iterate_dir.c b/src/iterate_dir.c index cc5c63b8..451143a7 100644 --- a/src/iterate_dir.c +++ b/src/iterate_dir.c @@ -6,22 +6,20 @@ */ /* - * Copyright (C) 2013 Eric Biggers + * Copyright (C) 2013, 2015 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more + * This file is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef HAVE_CONFIG_H @@ -29,59 +27,92 @@ #endif #include "wimlib.h" +#include "wimlib/blob_table.h" #include "wimlib/dentry.h" #include "wimlib/encoding.h" -#include "wimlib/lookup_table.h" #include "wimlib/metadata.h" #include "wimlib/paths.h" #include "wimlib/security.h" #include "wimlib/timestamp.h" +#include "wimlib/unix_data.h" #include "wimlib/util.h" #include "wimlib/wim.h" static int -init_wimlib_dentry(struct wimlib_dir_entry *wdentry, - struct wim_dentry *dentry, - const WIMStruct *wim, - int flags) +stream_to_wimlib_stream_entry(const struct wim_inode *inode, + const struct wim_inode_stream *strm, + struct wimlib_stream_entry *wstream, + const struct blob_table *blob_table, + int flags) { - int ret; - size_t dummy; - const struct wim_inode *inode = dentry->d_inode; - struct wim_lookup_table_entry *lte; + const struct blob_descriptor *blob; const u8 *hash; -#if TCHAR_IS_UTF16LE - wdentry->filename = dentry->file_name; - wdentry->dos_name = dentry->short_name; -#else - if (dentry_has_long_name(dentry)) { - ret = utf16le_to_tstr(dentry->file_name, - dentry->file_name_nbytes, - (tchar**)&wdentry->filename, - &dummy); + if (stream_is_named(strm)) { + size_t dummy; + int ret; + + ret = utf16le_get_tstr(strm->stream_name, + utf16le_len_bytes(strm->stream_name), + &wstream->stream_name, &dummy); if (ret) return ret; } - if (dentry_has_short_name(dentry)) { - ret = utf16le_to_tstr(dentry->short_name, - dentry->short_name_nbytes, - (tchar**)&wdentry->dos_name, - &dummy); - if (ret) - return ret; + + blob = stream_blob(strm, blob_table); + if (blob) { + blob_to_wimlib_resource_entry(blob, &wstream->resource); + } else if (!is_zero_hash((hash = stream_hash(strm)))) { + if (flags & WIMLIB_ITERATE_DIR_TREE_FLAG_RESOURCES_NEEDED) + return blob_not_found_error(inode, hash); + copy_hash(wstream->resource.sha1_hash, hash); + wstream->resource.is_missing = 1; } -#endif + return 0; +} + +static int +get_default_stream_type(const struct wim_inode *inode) +{ + if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED) + return STREAM_TYPE_EFSRPC_RAW_DATA; + if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) + return STREAM_TYPE_REPARSE_POINT; + return STREAM_TYPE_DATA; +} + +static int +init_wimlib_dentry(struct wimlib_dir_entry *wdentry, struct wim_dentry *dentry, + WIMStruct *wim, int flags) +{ + int ret; + size_t dummy; + const struct wim_inode *inode = dentry->d_inode; + const struct wim_inode_stream *strm; + struct wimlib_unix_data unix_data; + + ret = utf16le_get_tstr(dentry->file_name, dentry->file_name_nbytes, + &wdentry->filename, &dummy); + if (ret) + return ret; + + ret = utf16le_get_tstr(dentry->short_name, dentry->short_name_nbytes, + &wdentry->dos_name, &dummy); + if (ret) + return ret; + ret = calculate_dentry_full_path(dentry); if (ret) return ret; wdentry->full_path = dentry->_full_path; - for (struct wim_dentry *d = dentry; !dentry_is_root(d); d = d->parent) + for (struct wim_dentry *d = dentry; !dentry_is_root(d); d = d->d_parent) wdentry->depth++; - if (inode->i_security_id >= 0) { - const struct wim_security_data *sd = wim_const_security_data(wim); + if (inode_has_security_descriptor(inode)) { + struct wim_security_data *sd; + + sd = wim_get_current_security_data(wim); wdentry->security_descriptor = sd->descriptors[inode->i_security_id]; wdentry->security_descriptor_size = sd->sizes[inode->i_security_id]; } @@ -92,47 +123,37 @@ init_wimlib_dentry(struct wimlib_dir_entry *wdentry, wdentry->creation_time = wim_timestamp_to_timespec(inode->i_creation_time); wdentry->last_write_time = wim_timestamp_to_timespec(inode->i_last_write_time); wdentry->last_access_time = wim_timestamp_to_timespec(inode->i_last_access_time); + if (inode_get_unix_data(inode, &unix_data)) { + wdentry->unix_uid = unix_data.uid; + wdentry->unix_gid = unix_data.gid; + wdentry->unix_mode = unix_data.mode; + wdentry->unix_rdev = unix_data.rdev; + } - lte = inode_unnamed_lte(inode, wim->lookup_table); - if (lte) { - lte_to_wimlib_resource_entry(lte, &wdentry->streams[0].resource); - } else if (!is_zero_hash(hash = inode_unnamed_stream_hash(inode))) { - if (flags & WIMLIB_ITERATE_DIR_TREE_FLAG_RESOURCES_NEEDED) - return stream_not_found_error(inode, hash); - copy_hash(wdentry->streams[0].resource.sha1_hash, hash); - wdentry->streams[0].resource.is_missing = 1; + strm = inode_get_unnamed_stream(inode, get_default_stream_type(inode)); + if (strm) { + ret = stream_to_wimlib_stream_entry(inode, strm, + &wdentry->streams[0], + wim->blob_table, flags); + if (ret) + return ret; } - for (unsigned i = 0; i < inode->i_num_ads; i++) { - if (!ads_entry_is_named_stream(&inode->i_ads_entries[i])) + for (unsigned i = 0; i < inode->i_num_streams; i++) { + + strm = &inode->i_streams[i]; + + if (!stream_is_named_data_stream(strm)) continue; - lte = inode_stream_lte(inode, i + 1, wim->lookup_table); + wdentry->num_named_streams++; - if (lte) { - lte_to_wimlib_resource_entry(lte, &wdentry->streams[ - wdentry->num_named_streams].resource); - } else if (!is_zero_hash(hash = inode_stream_hash(inode, i + 1))) { - if (flags & WIMLIB_ITERATE_DIR_TREE_FLAG_RESOURCES_NEEDED) - return stream_not_found_error(inode, hash); - copy_hash(wdentry->streams[ - wdentry->num_named_streams].resource.sha1_hash, hash); - wdentry->streams[ - wdentry->num_named_streams].resource.is_missing = 1; - } - #if TCHAR_IS_UTF16LE - wdentry->streams[wdentry->num_named_streams].stream_name = - inode->i_ads_entries[i].stream_name; - #else - size_t dummy; - ret = utf16le_to_tstr(inode->i_ads_entries[i].stream_name, - inode->i_ads_entries[i].stream_name_nbytes, - (tchar**)&wdentry->streams[ - wdentry->num_named_streams].stream_name, - &dummy); + ret = stream_to_wimlib_stream_entry(inode, strm, + &wdentry->streams[ + wdentry->num_named_streams], + wim->blob_table, flags); if (ret) return ret; - #endif } return 0; } @@ -140,36 +161,13 @@ init_wimlib_dentry(struct wimlib_dir_entry *wdentry, static void free_wimlib_dentry(struct wimlib_dir_entry *wdentry) { -#if !TCHAR_IS_UTF16LE - FREE((tchar*)wdentry->filename); - FREE((tchar*)wdentry->dos_name); + utf16le_put_tstr(wdentry->filename); + utf16le_put_tstr(wdentry->dos_name); for (unsigned i = 1; i <= wdentry->num_named_streams; i++) - FREE((tchar*)wdentry->streams[i].stream_name); -#endif + utf16le_put_tstr(wdentry->streams[i].stream_name); FREE(wdentry); } -struct iterate_dir_tree_ctx { - WIMStruct *wim; - int flags; - wimlib_iterate_dir_tree_callback_t cb; - void *user_ctx; -}; - -static int -do_iterate_dir_tree(WIMStruct *wim, - struct wim_dentry *dentry, int flags, - wimlib_iterate_dir_tree_callback_t cb, - void *user_ctx); - -static int -call_do_iterate_dir_tree(struct wim_dentry *dentry, void *_ctx) -{ - struct iterate_dir_tree_ctx *ctx = _ctx; - return do_iterate_dir_tree(ctx->wim, dentry, ctx->flags, - ctx->cb, ctx->user_ctx); -} - static int do_iterate_dir_tree(WIMStruct *wim, struct wim_dentry *dentry, int flags, @@ -181,7 +179,7 @@ do_iterate_dir_tree(WIMStruct *wim, wdentry = CALLOC(1, sizeof(struct wimlib_dir_entry) + - (1 + dentry->d_inode->i_num_ads) * + (1 + dentry->d_inode->i_num_streams) * sizeof(struct wimlib_stream_entry)); if (wdentry == NULL) goto out; @@ -199,13 +197,26 @@ do_iterate_dir_tree(WIMStruct *wim, if (flags & (WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE | WIMLIB_ITERATE_DIR_TREE_FLAG_CHILDREN)) { - struct iterate_dir_tree_ctx ctx = { - .wim = wim, - .flags = flags &= ~WIMLIB_ITERATE_DIR_TREE_FLAG_CHILDREN, - .cb = cb, - .user_ctx = user_ctx, - }; - ret = for_dentry_child(dentry, call_do_iterate_dir_tree, &ctx); + struct wim_dentry *child; + + ret = 0; + if (default_ignore_case) { + for_dentry_child_case_insensitive(child, dentry) { + ret = do_iterate_dir_tree(wim, child, + flags & ~WIMLIB_ITERATE_DIR_TREE_FLAG_CHILDREN, + cb, user_ctx); + if (ret) + break; + } + } else { + for_dentry_child(child, dentry) { + ret = do_iterate_dir_tree(wim, child, + flags & ~WIMLIB_ITERATE_DIR_TREE_FLAG_CHILDREN, + cb, user_ctx); + if (ret) + break; + } + } } out_free_wimlib_dentry: free_wimlib_dentry(wdentry); @@ -250,6 +261,11 @@ wimlib_iterate_dir_tree(WIMStruct *wim, int image, const tchar *_path, path = canonicalize_wim_path(_path); if (path == NULL) return WIMLIB_ERR_NOMEM; + + ret = wim_checksum_unhashed_blobs(wim); + if (ret) + return ret; + struct image_iterate_dir_tree_ctx ctx = { .path = path, .flags = flags,