changing the compression type from None to LZX with no chunk size
explicitly specified, for example).
+ 'wiminfo' no longer accepts the '--metadata' option. Use the new
+ '--detailed' option to 'wimdir' instead. (This is primarily for
+ debugging.)
+
Version 1.6.0:
Support for extracting and updating the new version 3584 WIMs has been
added. These WIMs typically pack many streams ("files") together into a
\fB--path\fR=\fIPATH\fR
List the files recursively from the \fIPATH\fR directory instead of from the
root directory.
+.TP
+\fB--detailed\fR
+List detailed information about each file.
.SH NOTES
\fB@IMAGEX_PROGNAME@ dir\fR supports split WIMs, but it will only work on the
first part of the split WIM.
.PP
-The DOS names of files are not displayed.
-.PP
-Alternate (named) data streams are not displayed.
+DOS names and alternate (named) data streams are not listed unless the
+\fB--detailed\fR mode is used.
.SH EXAMPLES
List all files in the first image of 'boot.wim':
.RS
\fB--lookup-table\fR
Prints all the entries in the stream lookup table of the WIM.
.TP
-\fB--metadata\fR
-Prints the metadata, including the security data and the directory entry tree
-but not the XML data, for the specified image. If no image is specified, the
-metadata for all images is printed. This only works on standalone WIMs or on
-the first part of a split WIM.
-.TP
\fB--xml\fR
Prints the raw XML data from the WIM. Note: the XML data will be encoded using
UTF-16LE, and it will begin with a byte-order mark.
.SH SEE ALSO
.BR @IMAGEX_PROGNAME@ (1)
+.BR @IMAGEX_PROGNAME@-dir (1)
extern void
wimlib_print_header(const WIMStruct *wim) _wimlib_deprecated;
-/**
- * @ingroup G_wim_information
- *
- * Deprecated in favor of wimlib_iterate_dir_tree(), which provides the
- * information in a way that can be accessed programatically.
- */
-extern int
-wimlib_print_metadata(WIMStruct *wim, int image) _wimlib_deprecated;
-
/**
* @ingroup G_nonstandalone_wims
*
void *udata, unsigned ulen)
_wimlib_deprecated;
+
/**
* @}
*/
+/** @ingroup G_wim_information
+ *
+ * Deprecated and will return ::WIMLIB_ERR_UNSUPPORTED. Use
+ * wimlib_iterate_dir_tree() instead. */
+extern int
+wimlib_print_metadata(WIMStruct *wim, int image)
+ _wimlib_deprecated;
+
#ifdef __cplusplus
}
u16 *stream_idx_ret);
#endif
-extern int
-print_dentry(struct wim_dentry *dentry, void *lookup_table);
-
-extern int
-print_dentry_full_path(struct wim_dentry *entry, void *ignore);
-
extern int
calculate_dentry_full_path(struct wim_dentry *dentry);
clone_lookup_table_entry(const struct wim_lookup_table_entry *lte)
_malloc_attribute;
-extern void
-print_lookup_table_entry(const struct wim_lookup_table_entry *lte, FILE *out);
-
extern void
lte_decrement_refcnt(struct wim_lookup_table_entry *lte,
struct wim_lookup_table *table);
{
_setmode(fd, _O_BINARY);
}
+
+#include <sddl.h>
+
+static wchar_t *
+get_security_descriptor_string(PSECURITY_DESCRIPTOR desc)
+{
+ wchar_t *str = NULL;
+ /* 53 characters!!! */
+ ConvertSecurityDescriptorToStringSecurityDescriptorW(
+ desc,
+ SDDL_REVISION_1,
+ OWNER_SECURITY_INFORMATION |
+ GROUP_SECURITY_INFORMATION |
+ DACL_SECURITY_INFORMATION |
+ SACL_SECURITY_INFORMATION,
+ &str,
+ NULL);
+ return str;
+}
+
+void
+win32_print_security_descriptor(const uint8_t *sd, size_t size)
+{
+ wchar_t *str;
+ const wchar_t *printstr;
+
+ /* 'size' is ignored here due to the crappy Windows APIs. Oh well, this
+ * is just for debugging anyway. */
+ str = get_security_descriptor_string((PSECURITY_DESCRIPTOR)sd);
+ if (str)
+ printstr = str;
+ else
+ printstr = L"(invalid)";
+
+ wprintf(L"Security Descriptor = %ls\n", printstr);
+
+ LocalFree(str);
+}
#include <stddef.h>
#include <stdbool.h>
+#include <inttypes.h>
#include <wchar.h>
extern wchar_t *
extern wchar_t *
win32_wbasename(wchar_t *path);
+extern void
+win32_print_security_descriptor(const uint8_t *sd, size_t size);
+
extern void
set_fd_to_binary_mode(int fd);
# define tbasename win32_wbasename
# define OS_PREFERRED_PATH_SEPARATOR L'\\'
# define OS_PREFERRED_PATH_SEPARATOR_STRING L"\\"
+# define print_security_descriptor win32_print_security_descriptor
#else /* __WIN32__ */
# include <glob.h>
# include <getopt.h>
# define tbasename basename
# define OS_PREFERRED_PATH_SEPARATOR '/'
# define OS_PREFERRED_PATH_SEPARATOR_STRING "/"
+# define print_security_descriptor default_print_security_descriptor
static inline void set_fd_to_binary_mode(int fd)
{
}
IMAGEX_DELTA_FROM_OPTION,
IMAGEX_DEREFERENCE_OPTION,
IMAGEX_DEST_DIR_OPTION,
+ IMAGEX_DETAILED_OPTION,
IMAGEX_EXTRACT_XML_OPTION,
IMAGEX_FLAGS_OPTION,
IMAGEX_FORCE_OPTION,
};
static const struct option dir_options[] = {
- {T("path"), required_argument, NULL, IMAGEX_PATH_OPTION},
+ {T("path"), required_argument, NULL, IMAGEX_PATH_OPTION},
+ {T("detailed"), no_argument, NULL, IMAGEX_DETAILED_OPTION},
{NULL, 0, NULL, 0},
};
goto out;
}
+struct print_dentry_options {
+ bool detailed;
+};
+
+static void
+print_dentry_full_path(const struct wimlib_dir_entry *dentry)
+{
+ tprintf(T("%"TS"\n"), dentry->full_path);
+}
+
+static const struct {
+ uint32_t flag;
+ const tchar *name;
+} file_attr_flags[] = {
+ {WIMLIB_FILE_ATTRIBUTE_READONLY, T("READONLY")},
+ {WIMLIB_FILE_ATTRIBUTE_HIDDEN, T("HIDDEN")},
+ {WIMLIB_FILE_ATTRIBUTE_SYSTEM, T("SYSTEM")},
+ {WIMLIB_FILE_ATTRIBUTE_DIRECTORY, T("DIRECTORY")},
+ {WIMLIB_FILE_ATTRIBUTE_ARCHIVE, T("ARCHIVE")},
+ {WIMLIB_FILE_ATTRIBUTE_DEVICE, T("DEVICE")},
+ {WIMLIB_FILE_ATTRIBUTE_NORMAL, T("NORMAL")},
+ {WIMLIB_FILE_ATTRIBUTE_TEMPORARY, T("TEMPORARY")},
+ {WIMLIB_FILE_ATTRIBUTE_SPARSE_FILE, T("SPARSE_FILE")},
+ {WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT, T("REPARSE_POINT")},
+ {WIMLIB_FILE_ATTRIBUTE_COMPRESSED, T("COMPRESSED")},
+ {WIMLIB_FILE_ATTRIBUTE_OFFLINE, T("OFFLINE")},
+ {WIMLIB_FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, T("NOT_CONTENT_INDEXED")},
+ {WIMLIB_FILE_ATTRIBUTE_ENCRYPTED, T("ENCRYPTED")},
+ {WIMLIB_FILE_ATTRIBUTE_VIRTUAL, T("VIRTUAL")},
+};
+
+#define TIMESTR_MAX 100
+
+static void
+timespec_to_string(const struct timespec *spec, tchar *buf)
+{
+ time_t t = spec->tv_sec;
+ struct tm tm;
+ gmtime_r(&t, &tm);
+ tstrftime(buf, TIMESTR_MAX, T("%a %b %d %H:%M:%S %Y UTC"), &tm);
+ buf[TIMESTR_MAX - 1] = '\0';
+}
+
+static void
+print_time(const tchar *type, const struct timespec *spec)
+{
+ tchar timestr[TIMESTR_MAX];
+
+ timespec_to_string(spec, timestr);
+
+ tprintf(T("%-20"TS"= %"TS"\n"), type, timestr);
+}
+
+static void print_byte_field(const uint8_t field[], size_t len)
+{
+ while (len--)
+ tprintf(T("%02hhx"), *field++);
+}
+
+static void
+print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
+{
+ tputs(T("WIM Information:"));
+ tputs(T("----------------"));
+ tprintf(T("Path: %"TS"\n"), wimfile);
+ tprintf(T("GUID: 0x"));
+ print_byte_field(info->guid, sizeof(info->guid));
+ tputchar(T('\n'));
+ tprintf(T("Version: %u\n"), info->wim_version);
+ tprintf(T("Image Count: %d\n"), info->image_count);
+ tprintf(T("Compression: %"TS"\n"),
+ wimlib_get_compression_type_string(info->compression_type));
+ tprintf(T("Chunk Size: %"PRIu32" bytes\n"),
+ info->chunk_size);
+ tprintf(T("Part Number: %d/%d\n"), info->part_number, info->total_parts);
+ tprintf(T("Boot Index: %d\n"), info->boot_index);
+ tprintf(T("Size: %"PRIu64" bytes\n"), info->total_bytes);
+ tprintf(T("Integrity Info: %"TS"\n"),
+ info->has_integrity_table ? T("yes") : T("no"));
+ tprintf(T("Relative path junction: %"TS"\n"),
+ info->has_rpfix ? T("yes") : T("no"));
+ tprintf(T("Pipable: %"TS"\n"),
+ info->pipable ? T("yes") : T("no"));
+ tputchar(T('\n'));
+}
+
+static int
+print_resource(const struct wimlib_resource_entry *resource,
+ void *_ignore)
+{
+ tprintf(T("Hash = 0x"));
+ print_byte_field(resource->sha1_hash, sizeof(resource->sha1_hash));
+ tputchar(T('\n'));
+
+ if (!resource->is_missing) {
+ tprintf(T("Uncompressed size = %"PRIu64" bytes\n"),
+ resource->uncompressed_size);
+ if (resource->packed) {
+ tprintf(T("Raw compressed size = %"PRIu64" bytes\n"),
+ resource->raw_resource_compressed_size);
+
+ tprintf(T("Raw offset in WIM = %"PRIu64" bytes\n"),
+ resource->raw_resource_offset_in_wim);
+
+ tprintf(T("Offset in raw = %"PRIu64" bytes\n"),
+ resource->offset);
+ } else {
+ tprintf(T("Compressed size = %"PRIu64" bytes\n"),
+ resource->compressed_size);
+
+ tprintf(T("Offset in WIM = %"PRIu64" bytes\n"),
+ resource->offset);
+ }
+
+ tprintf(T("Part Number = %u\n"), resource->part_number);
+ tprintf(T("Reference Count = %u\n"), resource->reference_count);
+
+ tprintf(T("Flags = "));
+ if (resource->is_compressed)
+ tprintf(T("WIM_RESHDR_FLAG_COMPRESSED "));
+ if (resource->is_metadata)
+ tprintf(T("WIM_RESHDR_FLAG_METADATA "));
+ if (resource->is_free)
+ tprintf(T("WIM_RESHDR_FLAG_FREE "));
+ if (resource->is_spanned)
+ tprintf(T("WIM_RESHDR_FLAG_SPANNED "));
+ if (resource->packed)
+ tprintf(T("WIM_RESHDR_FLAG_PACKED_STREAMS "));
+ tputchar(T('\n'));
+ }
+ tputchar(T('\n'));
+ return 0;
+}
+
+static void
+print_lookup_table(WIMStruct *wim)
+{
+ wimlib_iterate_lookup_table(wim, 0, print_resource, NULL);
+}
+
+static void
+default_print_security_descriptor(const uint8_t *sd, size_t size)
+{
+ tprintf(T("Security Descriptor = "));
+ print_byte_field(sd, size);
+ tputchar(T('\n'));
+}
+
+static void
+print_dentry_detailed(const struct wimlib_dir_entry *dentry)
+{
+
+ tprintf(T(
+"----------------------------------------------------------------------------\n"));
+ tprintf(T("Full Path = \"%"TS"\"\n"), dentry->full_path);
+ if (dentry->dos_name)
+ tprintf(T("Short Name = \"%"TS"\"\n"), dentry->dos_name);
+ tprintf(T("Attributes = 0x%08x\n"), dentry->attributes);
+ for (size_t i = 0; i < ARRAY_LEN(file_attr_flags); i++)
+ if (file_attr_flags[i].flag & dentry->attributes)
+ tprintf(T(" FILE_ATTRIBUTE_%"TS" is set\n"),
+ file_attr_flags[i].name);
+
+ if (dentry->security_descriptor) {
+ print_security_descriptor(dentry->security_descriptor,
+ dentry->security_descriptor_size);
+ }
+
+ print_time(T("Creation Time"), &dentry->creation_time);
+ print_time(T("Last Write Time"), &dentry->last_write_time);
+ print_time(T("Last Access Time"), &dentry->last_access_time);
+
+
+ if (dentry->attributes & WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT)
+ tprintf(T("Reparse Tag = 0x%"PRIx32"\n"), dentry->reparse_tag);
+
+ tprintf(T("Link Group ID = 0x%016"PRIx64"\n"), dentry->hard_link_group_id);
+ tprintf(T("Link Count = %"PRIu32"\n"), dentry->num_links);
+
+ for (uint32_t i = 0; i <= dentry->num_named_streams; i++) {
+ if (dentry->streams[i].stream_name) {
+ tprintf(T("\tData stream \"%"TS"\":\n"),
+ dentry->streams[i].stream_name);
+ } else {
+ tprintf(T("\tUnnamed data stream:\n"));
+ }
+ print_resource(&dentry->streams[i].resource, NULL);
+ }
+}
+
static int
-print_full_path(const struct wimlib_dir_entry *wdentry, void *_ignore)
+print_dentry(const struct wimlib_dir_entry *dentry, void *_options)
{
- int ret = tprintf(T("%"TS"\n"), wdentry->full_path);
- return (ret >= 0) ? 0 : -1;
+ const struct print_dentry_options *options = _options;
+ if (!options->detailed)
+ print_dentry_full_path(dentry);
+ else
+ print_dentry_detailed(dentry);
+ return 0;
}
/* Print the files contained in an image(s) in a WIM file. */
int ret;
const tchar *path = T("");
int c;
+ struct print_dentry_options options = {
+ .detailed = false,
+ };
for_opt(c, dir_options) {
switch (c) {
case IMAGEX_PATH_OPTION:
path = optarg;
break;
+ case IMAGEX_DETAILED_OPTION:
+ options.detailed = true;
+ break;
default:
goto out_usage;
}
ret = wimlib_iterate_dir_tree(wim, image, path,
WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE,
- print_full_path, NULL);
+ print_dentry, &options);
out_wimlib_free:
wimlib_free(wim);
out:
goto out_free_refglobs;
}
-static void print_byte_field(const uint8_t field[], size_t len)
-{
- while (len--)
- tprintf(T("%02hhx"), *field++);
-}
-
-static void
-print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
-{
- tputs(T("WIM Information:"));
- tputs(T("----------------"));
- tprintf(T("Path: %"TS"\n"), wimfile);
- tprintf(T("GUID: 0x"));
- print_byte_field(info->guid, sizeof(info->guid));
- tputchar(T('\n'));
- tprintf(T("Version: %u\n"), info->wim_version);
- tprintf(T("Image Count: %d\n"), info->image_count);
- tprintf(T("Compression: %"TS"\n"),
- wimlib_get_compression_type_string(info->compression_type));
- tprintf(T("Chunk Size: %"PRIu32" bytes\n"),
- info->chunk_size);
- tprintf(T("Part Number: %d/%d\n"), info->part_number, info->total_parts);
- tprintf(T("Boot Index: %d\n"), info->boot_index);
- tprintf(T("Size: %"PRIu64" bytes\n"), info->total_bytes);
- tprintf(T("Integrity Info: %"TS"\n"),
- info->has_integrity_table ? T("yes") : T("no"));
- tprintf(T("Relative path junction: %"TS"\n"),
- info->has_rpfix ? T("yes") : T("no"));
- tprintf(T("Pipable: %"TS"\n"),
- info->pipable ? T("yes") : T("no"));
- tputchar(T('\n'));
-}
-
-static int
-print_resource(const struct wimlib_resource_entry *resource,
- void *_ignore)
-{
- tprintf(T("Uncompressed size = %"PRIu64" bytes\n"),
- resource->uncompressed_size);
- if (resource->packed) {
- tprintf(T("Raw compressed size = %"PRIu64" bytes\n"),
- resource->raw_resource_compressed_size);
-
- tprintf(T("Raw offset in WIM = %"PRIu64" bytes\n"),
- resource->raw_resource_offset_in_wim);
-
- tprintf(T("Offset in raw = %"PRIu64" bytes\n"),
- resource->offset);
- } else {
- tprintf(T("Compressed size = %"PRIu64" bytes\n"),
- resource->compressed_size);
-
- tprintf(T("Offset in WIM = %"PRIu64" bytes\n"),
- resource->offset);
- }
-
- tprintf(T("Part Number = %u\n"), resource->part_number);
- tprintf(T("Reference Count = %u\n"), resource->reference_count);
-
- tprintf(T("Hash = 0x"));
- print_byte_field(resource->sha1_hash, sizeof(resource->sha1_hash));
- tputchar(T('\n'));
-
- tprintf(T("Flags = "));
- if (resource->is_compressed)
- tprintf(T("WIM_RESHDR_FLAG_COMPRESSED "));
- if (resource->is_metadata)
- tprintf(T("WIM_RESHDR_FLAG_METADATA "));
- if (resource->is_free)
- tprintf(T("WIM_RESHDR_FLAG_FREE "));
- if (resource->is_spanned)
- tprintf(T("WIM_RESHDR_FLAG_SPANNED "));
- if (resource->packed)
- tprintf(T("WIM_RESHDR_FLAG_PACKED_STREAMS "));
- tputchar(T('\n'));
- tputchar(T('\n'));
- return 0;
-}
-
-static void
-print_lookup_table(WIMStruct *wim)
-{
- wimlib_iterate_lookup_table(wim, 0, print_resource, NULL);
-}
-
/* Prints information about a WIM file; also can mark an image as bootable,
* change the name of an image, or change the description of an image. */
static int
bool header = false;
bool lookup_table = false;
bool xml = false;
- bool metadata = false;
bool short_header = true;
const tchar *xml_out_file = NULL;
const tchar *wimfile;
short_header = false;
break;
case IMAGEX_METADATA_OPTION:
- metadata = true;
- short_header = false;
- break;
+ imagex_error(T("The --metadata option has been removed. "
+ "Use 'wimdir --detail' instead."));
+ goto out_err;
default:
goto out_usage;
}
if (short_header)
wimlib_print_available_images(wim, image);
- if (metadata) {
- ret = wimlib_print_metadata(wim, image);
- if (ret)
- goto out_wimlib_free;
- }
ret = 0;
} else {
),
[CMD_DIR] =
T(
-" %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--path=PATH]\n"
+" %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--path=PATH] [--detailed]\n"
),
[CMD_EXPORT] =
T(
}
#endif /* WITH_FUSE */
-/* Prints the full path of a dentry. */
-int
-print_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
-{
- int ret = calculate_dentry_full_path(dentry);
- if (ret)
- return ret;
- tprintf(T("%"TS"\n"), dentry->_full_path);
- return 0;
-}
-
-/* We want to be able to show the names of the file attribute flags that are
- * set. */
-struct file_attr_flag {
- u32 flag;
- const tchar *name;
-};
-struct file_attr_flag file_attr_flags[] = {
- {FILE_ATTRIBUTE_READONLY, T("READONLY")},
- {FILE_ATTRIBUTE_HIDDEN, T("HIDDEN")},
- {FILE_ATTRIBUTE_SYSTEM, T("SYSTEM")},
- {FILE_ATTRIBUTE_DIRECTORY, T("DIRECTORY")},
- {FILE_ATTRIBUTE_ARCHIVE, T("ARCHIVE")},
- {FILE_ATTRIBUTE_DEVICE, T("DEVICE")},
- {FILE_ATTRIBUTE_NORMAL, T("NORMAL")},
- {FILE_ATTRIBUTE_TEMPORARY, T("TEMPORARY")},
- {FILE_ATTRIBUTE_SPARSE_FILE, T("SPARSE_FILE")},
- {FILE_ATTRIBUTE_REPARSE_POINT, T("REPARSE_POINT")},
- {FILE_ATTRIBUTE_COMPRESSED, T("COMPRESSED")},
- {FILE_ATTRIBUTE_OFFLINE, T("OFFLINE")},
- {FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,T("NOT_CONTENT_INDEXED")},
- {FILE_ATTRIBUTE_ENCRYPTED, T("ENCRYPTED")},
- {FILE_ATTRIBUTE_VIRTUAL, T("VIRTUAL")},
-};
-
-/* Prints a directory entry. @lookup_table is a pointer to the lookup table, if
- * available. If the dentry is unresolved and the lookup table is NULL, the
- * lookup table entries will not be printed. Otherwise, they will be. */
-int
-print_dentry(struct wim_dentry *dentry, void *lookup_table)
-{
- const u8 *hash;
- struct wim_lookup_table_entry *lte;
- const struct wim_inode *inode = dentry->d_inode;
- tchar buf[50];
-
- tprintf(T("[DENTRY]\n"));
- tprintf(T("Length = %"PRIu64"\n"), dentry->length);
- tprintf(T("Attributes = 0x%x\n"), inode->i_attributes);
- for (size_t i = 0; i < ARRAY_LEN(file_attr_flags); i++)
- if (file_attr_flags[i].flag & inode->i_attributes)
- tprintf(T(" FILE_ATTRIBUTE_%"TS" is set\n"),
- file_attr_flags[i].name);
- tprintf(T("Security ID = %d\n"), inode->i_security_id);
- tprintf(T("Subdir offset = %"PRIu64"\n"), dentry->subdir_offset);
-
- wim_timestamp_to_str(inode->i_creation_time, buf, sizeof(buf));
- tprintf(T("Creation Time = %"TS"\n"), buf);
-
- wim_timestamp_to_str(inode->i_last_access_time, buf, sizeof(buf));
- tprintf(T("Last Access Time = %"TS"\n"), buf);
-
- wim_timestamp_to_str(inode->i_last_write_time, buf, sizeof(buf));
- tprintf(T("Last Write Time = %"TS"\n"), buf);
-
- if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
- tprintf(T("Reparse Tag = 0x%"PRIx32"\n"), inode->i_reparse_tag);
- tprintf(T("Reparse Point Flags = 0x%"PRIx16"\n"),
- inode->i_not_rpfixed);
- tprintf(T("Reparse Point Unknown 2 = 0x%"PRIx32"\n"),
- inode->i_rp_unknown_2);
- }
- tprintf(T("Reparse Point Unknown 1 = 0x%"PRIx32"\n"),
- inode->i_rp_unknown_1);
- tprintf(T("Hard Link Group = 0x%"PRIx64"\n"), inode->i_ino);
- tprintf(T("Hard Link Group Size = %"PRIu32"\n"), inode->i_nlink);
- tprintf(T("Number of Alternate Data Streams = %hu\n"), inode->i_num_ads);
- if (dentry_has_long_name(dentry))
- wimlib_printf(T("Filename = \"%"WS"\"\n"), dentry->file_name);
- if (dentry_has_short_name(dentry))
- wimlib_printf(T("Short Name \"%"WS"\"\n"), dentry->short_name);
- if (dentry->_full_path)
- tprintf(T("Full Path = \"%"TS"\"\n"), dentry->_full_path);
-
- lte = inode_stream_lte(dentry->d_inode, 0, lookup_table);
- if (lte) {
- print_lookup_table_entry(lte, stdout);
- } else {
- hash = inode_stream_hash(inode, 0);
- if (hash) {
- tprintf(T("Hash = 0x"));
- print_hash(hash, stdout);
- tputchar(T('\n'));
- tputchar(T('\n'));
- }
- }
- for (u16 i = 0; i < inode->i_num_ads; i++) {
- tprintf(T("[Alternate Stream Entry %u]\n"), i);
- wimlib_printf(T("Name = \"%"WS"\"\n"),
- inode->i_ads_entries[i].stream_name);
- tprintf(T("Name Length (UTF16 bytes) = %hu\n"),
- inode->i_ads_entries[i].stream_name_nbytes);
- hash = inode_stream_hash(inode, i + 1);
- if (hash) {
- tprintf(T("Hash = 0x"));
- print_hash(hash, stdout);
- tputchar(T('\n'));
- }
- print_lookup_table_entry(inode_stream_lte(inode, i + 1, lookup_table),
- stdout);
- }
- return 0;
-}
-
/* Initializations done on every `struct wim_dentry'. */
static void
dentry_common_init(struct wim_dentry *dentry)
}
if (cur_entry->refcnt != 1) {
- if (wimlib_print_errors) {
- ERROR("Found metadata resource with refcnt != 1:");
- print_lookup_table_entry(cur_entry, stderr);
- }
+ ERROR("Found metadata resource with refcnt != 1");
ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
goto err;
}
* resource. */
duplicate_entry = lookup_stream(table, cur_entry->hash);
if (duplicate_entry) {
- if (wimlib_print_errors) {
- WARNING("The WIM lookup table contains two entries with the "
- "same SHA1 message digest!");
- WARNING("The first entry is:");
- print_lookup_table_entry(duplicate_entry, stderr);
- WARNING("The second entry is:");
- print_lookup_table_entry(cur_entry, stderr);
- }
+ WARNING("The WIM lookup table contains two entries "
+ "with the same SHA1 message digest!");
free_lookup_table_entry(cur_entry);
continue;
}
return 0;
}
-void
-print_lookup_table_entry(const struct wim_lookup_table_entry *lte, FILE *out)
-{
- if (lte == NULL) {
- tputc(T('\n'), out);
- return;
- }
-
-
- tprintf(T("Uncompressed size = %"PRIu64" bytes\n"),
- lte->size);
- if (lte->flags & WIM_RESHDR_FLAG_PACKED_STREAMS) {
- tprintf(T("Offset = %"PRIu64" bytes\n"),
- lte->offset_in_res);
-
- tprintf(T("Raw uncompressed size = %"PRIu64" bytes\n"),
- lte->rspec->uncompressed_size);
-
- tprintf(T("Raw compressed size = %"PRIu64" bytes\n"),
- lte->rspec->size_in_wim);
-
- tprintf(T("Raw offset = %"PRIu64" bytes\n"),
- lte->rspec->offset_in_wim);
- } else if (lte->resource_location == RESOURCE_IN_WIM) {
- tprintf(T("Compressed size = %"PRIu64" bytes\n"),
- lte->rspec->size_in_wim);
-
- tprintf(T("Offset = %"PRIu64" bytes\n"),
- lte->rspec->offset_in_wim);
- }
-
- tfprintf(out, T("Reference Count = %u\n"), lte->refcnt);
-
- if (lte->unhashed) {
- tfprintf(out, T("(Unhashed: inode %p, stream_id = %u)\n"),
- lte->back_inode, lte->back_stream_id);
- } else {
- tfprintf(out, T("Hash = 0x"));
- print_hash(lte->hash, out);
- tputc(T('\n'), out);
- }
-
- tfprintf(out, T("Flags = "));
- u8 flags = lte->flags;
- if (flags & WIM_RESHDR_FLAG_COMPRESSED)
- tfputs(T("WIM_RESHDR_FLAG_COMPRESSED, "), out);
- if (flags & WIM_RESHDR_FLAG_FREE)
- tfputs(T("WIM_RESHDR_FLAG_FREE, "), out);
- if (flags & WIM_RESHDR_FLAG_METADATA)
- tfputs(T("WIM_RESHDR_FLAG_METADATA, "), out);
- if (flags & WIM_RESHDR_FLAG_SPANNED)
- tfputs(T("WIM_RESHDR_FLAG_SPANNED, "), out);
- if (flags & WIM_RESHDR_FLAG_PACKED_STREAMS)
- tfputs(T("WIM_RESHDR_FLAG_PACKED_STREAMS, "), out);
- tputc(T('\n'), out);
- switch (lte->resource_location) {
- case RESOURCE_IN_WIM:
- if (lte->rspec->wim->filename) {
- tfprintf(out, T("WIM file = `%"TS"'\n"),
- lte->rspec->wim->filename);
- }
- break;
-#ifdef __WIN32__
- case RESOURCE_WIN32_ENCRYPTED:
-#endif
- case RESOURCE_IN_FILE_ON_DISK:
- tfprintf(out, T("File on Disk = `%"TS"'\n"),
- lte->file_on_disk);
- break;
-#ifdef WITH_FUSE
- case RESOURCE_IN_STAGING_FILE:
- tfprintf(out, T("Staging File = `%"TS"'\n"),
- lte->staging_file_name);
- break;
-#endif
- default:
- break;
- }
- tputc(T('\n'), out);
-}
-
void
lte_to_wimlib_resource_entry(const struct wim_lookup_table_entry *lte,
struct wimlib_resource_entry *wentry)
return (*ctx->cbs.consume_chunk)(chunk, size, ctx->cbs.consume_chunk_ctx);
}
+static void
+get_sha1_string(const u8 md[SHA1_HASH_SIZE], tchar *str)
+{
+ for (size_t i = 0; i < SHA1_HASH_SIZE; i++)
+ str += tsprintf(str, T("%02x"), md[i]);
+}
+
/* Callback for finishing reading a stream while calculating its SHA1 message
* digest. */
static int
* that it is the same as the calculated value. */
if (!hashes_equal(hash, lte->hash)) {
if (wimlib_print_errors) {
- ERROR("Invalid SHA1 message digest "
- "on the following WIM stream:");
- print_lookup_table_entry(lte, stderr);
+ tchar expected_hashstr[SHA1_HASH_SIZE * 2 + 1];
+ tchar actual_hashstr[SHA1_HASH_SIZE * 2 + 1];
+ get_sha1_string(lte->hash, expected_hashstr);
+ get_sha1_string(hash, actual_hashstr);
+ ERROR("The stream is corrupted!\n"
+ " (Expected SHA1=%s,\n"
+ " got SHA1=%s)",
+ expected_hashstr, actual_hashstr);
}
ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
errno = EINVAL;
#include "wimlib/endianness.h"
#include "wimlib/error.h"
#include "wimlib/security.h"
-#include "wimlib/security_descriptor.h"
#include "wimlib/sha1.h"
#include "wimlib/util.h"
return p;
}
-static void
-print_acl(const wimlib_ACL *acl, const tchar *type, size_t max_size)
-{
- const u8 *p;
-
- if (max_size < sizeof(wimlib_ACL))
- return;
-
- u8 revision = acl->revision;
- u16 acl_size = le16_to_cpu(acl->acl_size);
- u16 ace_count = le16_to_cpu(acl->ace_count);
-
- tprintf(T(" [%"TS" ACL]\n"), type);
- tprintf(T(" Revision = %u\n"), revision);
- tprintf(T(" ACL Size = %u\n"), acl_size);
- tprintf(T(" ACE Count = %u\n"), ace_count);
-
- p = (const u8*)acl + sizeof(wimlib_ACL);
- for (u16 i = 0; i < ace_count; i++) {
- if (max_size < p + sizeof(wimlib_ACCESS_ALLOWED_ACE) - (const u8*)acl)
- break;
- const wimlib_ACCESS_ALLOWED_ACE *aaa = (const wimlib_ACCESS_ALLOWED_ACE*)p;
- tprintf(T(" [ACE]\n"));
- tprintf(T(" ACE type = %d\n"), aaa->hdr.type);
- tprintf(T(" ACE flags = 0x%x\n"), aaa->hdr.flags);
- tprintf(T(" ACE size = %u\n"), le16_to_cpu(aaa->hdr.size));
- tprintf(T(" ACE mask = %x\n"), le32_to_cpu(aaa->mask));
- tprintf(T(" SID start = %u\n"), le32_to_cpu(aaa->sid_start));
- p += le16_to_cpu(aaa->hdr.size);
- }
- tputchar(T('\n'));
-}
-
-static void
-print_sid(const wimlib_SID *sid, const tchar *type, size_t max_size)
-{
- if (max_size < sizeof(wimlib_SID))
- return;
-
- tprintf(T(" [%"TS" SID]\n"), type);
- tprintf(T(" Revision = %u\n"), sid->revision);
- tprintf(T(" Subauthority count = %u\n"), sid->sub_authority_count);
- tprintf(T(" Identifier authority = "));
- print_byte_field(sid->identifier_authority,
- sizeof(sid->identifier_authority), stdout);
- tputchar(T('\n'));
- if (max_size < sizeof(wimlib_SID) + (size_t)sid->sub_authority_count * sizeof(u32))
- return;
- for (u8 i = 0; i < sid->sub_authority_count; i++) {
- tprintf(T(" Subauthority %u = %u\n"),
- i, le32_to_cpu(sid->sub_authority[i]));
- }
- tputchar(T('\n'));
-}
-
-static void
-print_security_descriptor(const wimlib_SECURITY_DESCRIPTOR_RELATIVE *descr,
- size_t size)
-{
- u8 revision = descr->revision;
- u16 control = le16_to_cpu(descr->control);
- u32 owner_offset = le32_to_cpu(descr->owner_offset);
- u32 group_offset = le32_to_cpu(descr->group_offset);
- u32 dacl_offset = le32_to_cpu(descr->dacl_offset);
- u32 sacl_offset = le32_to_cpu(descr->sacl_offset);
-
- tprintf(T("Revision = %u\n"), revision);
- tprintf(T("Security Descriptor Control = %#x\n"), control);
- tprintf(T("Owner offset = %u\n"), owner_offset);
- tprintf(T("Group offset = %u\n"), group_offset);
- tprintf(T("Discretionary ACL offset = %u\n"), dacl_offset);
- tprintf(T("System ACL offset = %u\n"), sacl_offset);
-
- if (owner_offset != 0 && owner_offset <= size)
- print_sid((const wimlib_SID*)((const u8*)descr + owner_offset),
- T("Owner"), size - owner_offset);
-
- if (group_offset != 0 && group_offset <= size)
- print_sid((const wimlib_SID*)((const u8*)descr + group_offset),
- T("Group"), size - group_offset);
-
- if (dacl_offset != 0 && dacl_offset <= size)
- print_acl((const wimlib_ACL*)((const u8*)descr + dacl_offset),
- T("Discretionary"), size - dacl_offset);
-
- if (sacl_offset != 0 && sacl_offset <= size)
- print_acl((const wimlib_ACL*)((const u8*)descr + sacl_offset),
- T("System"), size - sacl_offset);
-}
-
-/*
- * Prints the security data for a WIM file.
- */
-void
-print_wim_security_data(const struct wim_security_data *sd)
-{
- tputs(T("[SECURITY DATA]"));
- tprintf(T("Length = %"PRIu32" bytes\n"), sd->total_length);
- tprintf(T("Number of Entries = %"PRIu32"\n"), sd->num_entries);
-
- for (u32 i = 0; i < sd->num_entries; i++) {
- tprintf(T("[SECURITY_DESCRIPTOR_RELATIVE %"PRIu32", length = %"PRIu64"]\n"),
- i, sd->sizes[i]);
- print_security_descriptor((const wimlib_SECURITY_DESCRIPTOR_RELATIVE*)sd->descriptors[i],
- sd->sizes[i]);
- tputchar(T('\n'));
- }
- tputchar(T('\n'));
-}
-
void
free_wim_security_data(struct wim_security_data *sd)
{
#include <stdlib.h>
#include <unistd.h>
-static int
-image_print_metadata(WIMStruct *wim)
-{
- DEBUG("Printing metadata for image %d", wim->current_image);
- print_wim_security_data(wim_security_data(wim));
- return for_dentry_in_tree(wim_root_dentry(wim), print_dentry,
- wim->lookup_table);
-}
-
static int
wim_default_pack_compression_type(void)
{
if (imd->root_dentry || imd->modified) {
ret = 0;
} else {
- #ifdef ENABLE_DEBUG
- DEBUG("Reading metadata resource specified by the following "
- "lookup table entry:");
- print_lookup_table_entry(imd->metadata_lte, stderr);
- #endif
ret = read_metadata_resource(wim, imd);
if (ret)
wim->current_image = WIMLIB_NO_IMAGE;
print_image_info(wim->wim_info, i);
}
-
-/* API function documented in wimlib.h */
+/* TODO: Deprecated; remove this. */
WIMLIBAPI int
wimlib_print_metadata(WIMStruct *wim, int image)
{
- return for_image(wim, image, image_print_metadata);
+ return WIMLIB_ERR_UNSUPPORTED;
}
/* API function documented in wimlib.h */
error "Failed to extract WIM XML data"
fi
echo "Testing printing WIM metadata"
-if ! imagex info --metadata dir.wim > /dev/null; then
+if ! imagex dir --detailed dir.wim > /dev/null; then
error "Failed to print WIM metadata"
fi
rm -rf dir.wim tmp dir.xml
git://wimlib.net / wimlib / commitdiff