From ed828dc4cbf4eabc9f8b32cb4c6a86a04e087f7a Mon Sep 17 00:00:00 2001 From: Eric Biggers Date: Tue, 28 Aug 2012 21:41:47 -0500 Subject: [PATCH] Fix various issues --- src/dentry.c | 35 ++++++++++++++++++++++------------- src/extract.c | 1 - src/hardlink.c | 26 +++++++++++++++----------- src/integrity.c | 5 ++--- src/lookup_table.c | 4 +++- src/lookup_table.h | 4 ---- src/modify.c | 27 +++++++++++++++++---------- src/mount.c | 28 +++++++++------------------- src/ntfs-apply.c | 33 +++++++++------------------------ src/ntfs-capture.c | 15 ++++++--------- src/resource.c | 15 ++++++--------- src/security.c | 2 +- src/sha1.h | 2 +- src/symlink.c | 14 ++++++++------ src/xml.c | 4 ---- tests/test-imagex | 2 ++ 16 files changed, 101 insertions(+), 116 deletions(-) diff --git a/src/dentry.c b/src/dentry.c index 9854f85f..fbc62b86 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -502,10 +502,6 @@ int print_dentry(struct dentry *dentry, void *lookup_table) #endif /* Translate the timestamps into something readable */ - time_t creat_time = wim_timestamp_to_unix(dentry->creation_time); - time_t access_time = wim_timestamp_to_unix(dentry->last_access_time); - time_t mod_time = wim_timestamp_to_unix(dentry->last_write_time); - time = wim_timestamp_to_unix(dentry->creation_time); p = asctime(gmtime(&time)); *(strrchr(p, '\n')) = '\0'; @@ -651,7 +647,6 @@ void put_dentry(struct dentry *dentry) } dentry->ads_entries_status = ADS_ENTRIES_USER; } - struct list_head *next; list_del(&dentry->link_group_list); free_dentry(dentry); } @@ -812,6 +807,8 @@ int change_dentry_name(struct dentry *dentry, const char *new_name) ret = get_names(&dentry->file_name, &dentry->file_name_utf8, &dentry->file_name_len, &dentry->file_name_utf8_len, new_name); + FREE(dentry->short_name); + dentry->short_name_len = 0; if (ret == 0) dentry->length = dentry_correct_length(dentry); return ret; @@ -941,7 +938,7 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry, u64 length_no_padding; u64 total_length; size_t utf8_len; - const char *p_save = p; + const u8 *p_save = p; /* Read the base stream entry, excluding the stream name. */ if (remaining_size < WIM_ADS_ENTRY_DISK_SIZE) { @@ -972,7 +969,7 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry, if (remaining_size < length_no_padding) { ERROR("Stream entries go past end of metadata resource"); ERROR("(remaining_size = %"PRIu64" bytes, " - "length_no_padding = %"PRIu16" bytes)", + "length_no_padding = %"PRIu64" bytes)", remaining_size, length_no_padding); ret = WIMLIB_ERR_INVALID_DENTRY; goto out_free_ads_entries; @@ -1062,7 +1059,7 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, char *short_name = NULL; u16 short_name_len; u16 file_name_len; - size_t file_name_utf8_len; + size_t file_name_utf8_len = 0; int ret; dentry_common_init(dentry); @@ -1324,14 +1321,11 @@ int verify_dentry(struct dentry *dentry, void *wim) /* Make sure there is only one un-named stream. */ unsigned num_unnamed_streams = 0; - unsigned unnamed_stream_idx; for (unsigned i = 0; i <= dentry->num_ads; i++) { const u8 *hash; hash = dentry_stream_hash_unresolved(dentry, i); - if (!dentry_stream_name_len(dentry, i) && !is_zero_hash(hash)) { + if (!dentry_stream_name_len(dentry, i) && !is_zero_hash(hash)) num_unnamed_streams++; - unnamed_stream_idx = i; - } } if (num_unnamed_streams > 1) { ERROR("Dentry `%s' has multiple (%u) un-named streams", @@ -1339,6 +1333,22 @@ int verify_dentry(struct dentry *dentry, void *wim) goto out; } + /* Cannot have a short name but no long name */ + if (dentry->short_name_len && !dentry->file_name_len) { + ERROR("Dentry `%s' has a short name but no long name", + dentry->full_path_utf8); + goto out; + } + + /* Make sure root dentry is unnamed */ + if (dentry_is_root(dentry)) { + if (dentry->file_name_len) { + ERROR("The root dentry is named `%s', but it must " + "be unnamed", dentry->file_name_utf8); + goto out; + } + } + #if 0 /* Check timestamps */ if (dentry->last_access_time < dentry->creation_time || @@ -1364,7 +1374,6 @@ out: static u8 *write_dentry(const struct dentry *dentry, u8 *p) { u8 *orig_p = p; - unsigned padding; const u8 *hash; /* We calculate the correct length of the dentry ourselves because the diff --git a/src/extract.c b/src/extract.c index b27c4432..80cacf79 100644 --- a/src/extract.c +++ b/src/extract.c @@ -123,7 +123,6 @@ static int extract_regular_file_unlinked(WIMStruct *w, * extracted in the way that they appear in the WIM. */ int out_fd; - const struct resource_entry *res_entry; int ret; const struct list_head *head = &dentry->link_group_list; diff --git a/src/hardlink.c b/src/hardlink.c index 23344ad9..3d010831 100644 --- a/src/hardlink.c +++ b/src/hardlink.c @@ -194,8 +194,6 @@ static void free_link_group_list(struct link_group *group) /* Frees a link group table. */ void free_link_group_table(struct link_group_table *table) { - struct link_group *single, *next; - if (table) { if (table->array) for (size_t i = 0; i < table->capacity; i++) @@ -205,8 +203,9 @@ void free_link_group_table(struct link_group_table *table) } } -u64 assign_link_group_ids_to_list(struct link_group *group, u64 id, - struct link_group **extra_groups) +static u64 +assign_link_group_ids_to_list(struct link_group *group, u64 id, + struct link_group **extra_groups) { struct dentry *dentry; struct list_head *cur_head; @@ -439,7 +438,6 @@ fix_nominal_link_group(struct link_group *group, int ret; size_t num_true_link_groups; struct list_head *head; - u64 link_group_id; LIST_HEAD(dentries_with_data_streams); LIST_HEAD(dentries_with_no_data_streams); @@ -472,11 +470,17 @@ fix_nominal_link_group(struct link_group *group, * link group to be a true link group */ if (list_empty(&dentries_with_data_streams)) { #ifdef ENABLE_DEBUG - DEBUG("Found link group of size %zu without any data streams:", - dentry_link_group_size(dentry)); - print_dentry_list(dentry); - DEBUG("We are going to interpret it as true link group, provided " - "that the dentries are consistent."); + { + size_t size = dentry_link_group_size(dentry); + if (size > 1) { + DEBUG("Found link group of size %zu without " + "any data streams:", size); + print_dentry_list(dentry); + DEBUG("We are going to interpret it as true " + "link group, provided that the dentries " + "are consistent."); + } + } #endif return fix_true_link_group(container_of(group->dentry_list, struct dentry, @@ -568,7 +572,7 @@ next_dentry_2: ERROR("Out of memory"); return WIMLIB_ERR_NOMEM; } - group->link_group_id = link_group_id; + group->link_group_id = dentry->link_group_id; group->dentry_list = &dentry->link_group_list; group->next = *new_groups; *new_groups = group; diff --git a/src/integrity.c b/src/integrity.c index 12968bf9..f50d03ab 100644 --- a/src/integrity.c +++ b/src/integrity.c @@ -49,7 +49,7 @@ static int verify_integrity(FILE *fp, u64 num_bytes, u32 chunk_size, const u8 *sha1sums, int show_progress, int *status) { - char *chunk_buf; + u8 *chunk_buf; u8 resblock[SHA1_HASH_SIZE]; u64 bytes_remaining; size_t bytes_to_read; @@ -117,7 +117,6 @@ int check_wim_integrity(WIMStruct *w, int show_progress, int *status) { struct resource_entry *res_entry; - int ctype; u8 *buf = NULL; int ret; u32 integrity_table_size; @@ -251,7 +250,7 @@ int write_integrity_table(FILE *out, u64 end_header_offset, u64 bytes_remaining; u8 *buf; u8 *p; - char *chunk_buf; + u8 *chunk_buf; u32 num_entries; u32 integrity_table_size; int ret; diff --git a/src/lookup_table.c b/src/lookup_table.c index 92fb8a9f..007cd9ea 100644 --- a/src/lookup_table.c +++ b/src/lookup_table.c @@ -344,6 +344,8 @@ void print_lookup_table_entry(const struct lookup_table_entry *lte) case RESOURCE_IN_STAGING_FILE: printf("Staging File = `%s'\n", lte->staging_file_name); break; + default: + break; } putchar('\n'); } @@ -397,7 +399,7 @@ int lookup_resource(WIMStruct *w, const char *path, struct dentry *dentry; struct lookup_table_entry *lte; unsigned stream_idx; - const char *stream_name; + const char *stream_name = NULL; char *p = NULL; if (lookup_flags & LOOKUP_FLAG_ADS_OK) { diff --git a/src/lookup_table.h b/src/lookup_table.h index 3a653bfb..56e03058 100644 --- a/src/lookup_table.h +++ b/src/lookup_table.h @@ -334,9 +334,7 @@ static inline const u8 *dentry_stream_hash(const struct dentry *dentry, static inline struct lookup_table_entry * dentry_unnamed_lte_resolved(const struct dentry *dentry) { - struct lookup_table_entry *lte; wimlib_assert(dentry->resolved); - for (unsigned i = 0; i <= dentry->num_ads; i++) if (dentry_stream_name_len(dentry, i) == 0 && !is_zero_hash(dentry_stream_hash_resolved(dentry, i))) @@ -348,9 +346,7 @@ static inline struct lookup_table_entry * dentry_unnamed_lte_unresolved(const struct dentry *dentry, const struct lookup_table *table) { - struct lookup_table_entry *lte; wimlib_assert(!dentry->resolved); - for (unsigned i = 0; i <= dentry->num_ads; i++) if (dentry_stream_name_len(dentry, i) == 0 && !is_zero_hash(dentry_stream_hash_unresolved(dentry, i))) diff --git a/src/modify.c b/src/modify.c index c979162a..3a40c90e 100644 --- a/src/modify.c +++ b/src/modify.c @@ -85,6 +85,7 @@ static int build_dentry_tree(struct dentry **root_ret, const char *root_disk_pat int ret = 0; int (*stat_fn)(const char *restrict, struct stat *restrict); struct dentry *root; + const char *filename; if (exclude_path(root_disk_path, config, true)) { if (add_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE) @@ -117,11 +118,17 @@ static int build_dentry_tree(struct dentry **root_ret, const char *root_disk_pat } if (!S_ISREG(root_stbuf.st_mode) && !S_ISDIR(root_stbuf.st_mode) && !S_ISLNK(root_stbuf.st_mode)) { - ERROR("`%s' is not a regular file, directory, or symbolic link."); + ERROR("`%s' is not a regular file, directory, or symbolic link.", + root_disk_path); return WIMLIB_ERR_SPECIAL_FILE; } - root = new_dentry(path_basename(root_disk_path)); + if (add_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) + filename = ""; + else + filename = path_basename(root_disk_path); + + root = new_dentry(filename); if (!root) return WIMLIB_ERR_NOMEM; @@ -166,7 +173,6 @@ static int build_dentry_tree(struct dentry **root_ret, const char *root_disk_pat closedir(dir); } else if (dentry_is_symlink(root)) { /* Archiving a symbolic link */ - size_t symlink_buf_len; char deref_name_buf[4096]; ssize_t deref_name_len; @@ -286,6 +292,7 @@ static int add_lte_to_dest_wim(struct dentry *dentry, void *arg) * * @w: The WIMStruct for the WIM file. * @root_dentry: The root of the directory tree for the image. + * @sd: The security data for the image. */ static int add_new_dentry_tree(WIMStruct *w, struct dentry *root_dentry, struct wim_security_data *sd) @@ -313,7 +320,7 @@ static int add_new_dentry_tree(WIMStruct *w, struct dentry *root_dentry, lgt = new_link_group_table(9001); if (!lgt) - goto out_free_security_data; + goto out_free_metadata_lte; metadata_lte->resource_entry.flags = WIM_RESHDR_FLAG_METADATA; random_hash(metadata_lte->hash); @@ -333,8 +340,6 @@ static int add_new_dentry_tree(WIMStruct *w, struct dentry *root_dentry, /* Change the current image to the new one. */ return wimlib_select_image(w, w->hdr.image_count); -out_free_security_data: - FREE(sd); out_free_metadata_lte: FREE(metadata_lte); out_free_imd: @@ -573,7 +578,6 @@ static int init_capture_config(const char *_config_str, size_t config_len, char *p; char *eol; char *next_p; - size_t next_bytes_remaining; size_t bytes_remaining; enum pattern_type type = NONE; int ret; @@ -627,6 +631,7 @@ static int init_capture_config(const char *_config_str, size_t config_len, if (eol - p > 2 && isalpha(*p) && *(p + 1) == ':') p += 2; + ret = 0; if (strcmp(p, "[ExclusionList]") == 0) type = EXCLUSION_LIST; else if (strcmp(p, "[ExclusionException]") == 0) @@ -635,7 +640,11 @@ static int init_capture_config(const char *_config_str, size_t config_len, type = COMPRESSION_EXCLUSION_LIST; else if (strcmp(p, "[AlignmentList]") == 0) type = ALIGNMENT_LIST; - else switch (type) { + else if (p[0] == '[' && strrchr(p, ']')) { + ERROR("Unknown capture configuration section `%s'", p); + ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG; + goto out_destroy; + } else switch (type) { case EXCLUSION_LIST: DEBUG("Adding pattern \"%s\" to exclusion list", p); ret = pattern_list_add_pattern(&config->exclusion_list, p); @@ -742,7 +751,6 @@ int do_add_image(WIMStruct *w, const char *dir, const char *name, void *extra_arg) { struct dentry *root_dentry = NULL; - struct image_metadata *imd; struct wim_security_data *sd; struct capture_config config; struct link_group_table *lgt; @@ -834,7 +842,6 @@ out_destroy_imd: return ret; out_free_dentry_tree: free_dentry_tree(root_dentry, w->lookup_table); -out_free_sd: free_security_data(sd); out_destroy_config: destroy_capture_config(&config); diff --git a/src/mount.c b/src/mount.c index 8a9640c3..82abe7d9 100644 --- a/src/mount.c +++ b/src/mount.c @@ -196,7 +196,7 @@ static void remove_ads(struct dentry *dentry, wimlib_assert(dentry->resolved); - lte = lte_decrement_refcnt(lte, lookup_table); + lte = lte_decrement_refcnt(ads_entry->lte, lookup_table); if (lte) list_del(&ads_entry->lte_group_list.list); dentry_remove_ads(dentry, ads_entry); @@ -224,6 +224,7 @@ int dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf) lte = dentry_unnamed_lte_resolved(dentry); if (lte) { if (lte->resource_location == RESOURCE_IN_STAGING_FILE) { + wimlib_assert(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE); wimlib_assert(lte->staging_file_name); struct stat native_stat; if (stat(lte->staging_file_name, &native_stat) != 0) { @@ -310,7 +311,6 @@ static int create_staging_file(char **name_ret, int open_flags) static struct lookup_table_entry * lte_extract_fds(struct lookup_table_entry *old_lte, u64 link_group) { - int ret; u16 num_transferred_fds; struct lookup_table_entry *new_lte; @@ -466,7 +466,7 @@ static int extract_resource_to_staging_dir(struct dentry *dentry, new_lte = old_lte; } else { DEBUG("Splitting lookup table entry " - "(link_group_size = %u, lte refcnt = %u)", + "(link_group_size = %zu, lte refcnt = %u)", link_group_size, old_lte->refcnt); /* Split a hard link group away from the "lookup table * entry" hard link group (i.e. we had two hard link @@ -861,8 +861,6 @@ static int rebuild_wim(WIMStruct *w, bool check_integrity) if (ret != 0) return ret; } - if (ret != 0) - return ret; xml_update_image_info(w, w->current_image); @@ -983,8 +981,6 @@ static int wimfs_ftruncate(const char *path, off_t size, */ static int wimfs_getattr(const char *path, struct stat *stbuf) { - const char *stream_name; - char *p = NULL; struct dentry *dentry; int ret; @@ -1027,7 +1023,7 @@ static int wimfs_getxattr(const char *path, const char *name, char *value, return res_size; if (res_size > size) return -ERANGE; - ret = read_full_wim_resource(lte, value); + ret = read_full_wim_resource(lte, (u8*)value); if (ret != 0) return -EIO; return res_size; @@ -1152,7 +1148,6 @@ static int wimfs_mkdir(const char *path, mode_t mode) static int wimfs_mknod(const char *path, mode_t mode, dev_t rdev) { const char *stream_name; - const char *file_name; if ((mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS) && (stream_name = path_stream_name(path))) { /* Make an alternate data stream */ @@ -1207,7 +1202,6 @@ static int wimfs_open(const char *path, struct fuse_file_info *fi) { struct dentry *dentry; struct lookup_table_entry *lte; - u8 *dentry_hash; int ret; struct wimlib_fd *fd; unsigned stream_idx; @@ -1325,7 +1319,8 @@ static int wimfs_read(const char *path, char *buf, size_t size, size = min(size, res_entry->original_size - offset); - if (read_wim_resource(fd->lte, buf, size, offset, false) != 0) + if (read_wim_resource(fd->lte, (u8*)buf, + size, offset, false) != 0) return -EIO; return size; } @@ -1375,7 +1370,6 @@ static int wimfs_readlink(const char *path, char *buf, size_t buf_len) /* Close a file. */ static int wimfs_release(const char *path, struct fuse_file_info *fi) { - int ret; struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh; if (!fd) { @@ -1410,7 +1404,6 @@ static int wimfs_removexattr(const char *path, const char *name) { struct dentry *dentry; struct ads_entry *ads_entry; - int ret; if (!(mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR)) return -ENOTSUP; @@ -1525,8 +1518,6 @@ static int wimfs_setxattr(const char *path, const char *name, struct lookup_table_entry *existing_lte; struct lookup_table_entry *lte; u8 value_hash[SHA1_HASH_SIZE]; - int ret; - int fd; if (!(mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR)) return -ENOTSUP; @@ -1551,7 +1542,7 @@ static int wimfs_setxattr(const char *path, const char *name, if (!new_ads_entry) return -ENOMEM; - sha1_buffer(value, size, value_hash); + sha1_buffer((const u8*)value, size, value_hash); existing_lte = __lookup_resource(w->lookup_table, value_hash); @@ -1559,7 +1550,7 @@ static int wimfs_setxattr(const char *path, const char *name, lte = existing_lte; lte->refcnt++; } else { - char *value_copy; + u8 *value_copy; lte = new_lookup_table_entry(); if (!lte) return -ENOMEM; @@ -1661,7 +1652,6 @@ static int wimfs_unlink(const char *path) struct dentry *dentry; struct lookup_table_entry *lte; int ret; - u8 *dentry_hash; unsigned stream_idx; ret = lookup_resource(w, path, get_lookup_flags(), &dentry, @@ -1780,7 +1770,7 @@ static int check_lte_refcnt(struct lookup_table_entry *lte, void *ignore) struct stream_list_head *head; WARNING("The following lookup table entry has a reference count " "of %u, but", lte->refcnt); - WARNING("We found %u references to it", lte_group_size); + WARNING("We found %zu references to it", lte_group_size); next = lte->lte_group_list.next; head = container_of(next, struct stream_list_head, list); if (head->type == STREAM_TYPE_NORMAL) { diff --git a/src/ntfs-apply.c b/src/ntfs-apply.c index 3ec0ae75..e8e86c1e 100644 --- a/src/ntfs-apply.c +++ b/src/ntfs-apply.c @@ -61,7 +61,7 @@ extract_wim_resource_to_ntfs_attr(const struct lookup_table_entry *lte, ntfs_attr *na) { u64 bytes_remaining = wim_resource_size(lte); - char buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; + u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; u64 offset = 0; int ret = 0; u8 hash[SHA1_HASH_SIZE]; @@ -141,15 +141,6 @@ static int write_ntfs_data_streams(ntfs_inode *ni, const struct dentry *dentry, return ret; } -static bool in_same_dir(const char *path1, const char *path2) -{ - const char *p1 = strrchr(path1, '/'); - const char *p2 = strrchr(path2, '/'); - if (p1 - path1 != p2 - path2) - return false; - return memcmp(path1, path2, p1 - path1) == 0; -} - /* * Makes a NTFS hard link * @@ -201,8 +192,7 @@ static int wim_apply_hardlink_ntfs(const struct dentry *from_dentry, *p = '\0'; dir_name = from_dentry->full_path_utf8; - dir_ni = ntfs_pathname_to_inode(vol, NULL, - from_dentry->full_path_utf8); + dir_ni = ntfs_pathname_to_inode(vol, NULL, dir_name); if (!dir_ni) { ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'", from_dentry->full_path_utf8); @@ -250,7 +240,7 @@ apply_file_attributes_and_security_data(ntfs_inode *ni, SACL_SECURITY_INFORMATION; if (!ntfs_inode_set_security(ni, selection, - sd->descriptors[dentry->security_id])) + (const char*)sd->descriptors[dentry->security_id])) { ERROR_WITH_ERRNO("Failed to set security data on `%s'", dentry->full_path_utf8); @@ -284,8 +274,8 @@ static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry, return WIMLIB_ERR_INVALID_DENTRY; } - char reparse_data_buf[8 + wim_resource_size(lte)]; - char *p = reparse_data_buf; + u8 reparse_data_buf[8 + wim_resource_size(lte)]; + u8 *p = reparse_data_buf; p = put_u32(p, dentry->reparse_tag); /* ReparseTag */ p = put_u16(p, wim_resource_size(lte)); /* ReparseDataLength */ p = put_u16(p, 0); /* Reserved */ @@ -294,7 +284,7 @@ static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry, if (ret != 0) return ret; - ret = ntfs_set_ntfs_reparse_data(ni, reparse_data_buf, + ret = ntfs_set_ntfs_reparse_data(ni, (char*)reparse_data_buf, wim_resource_size(lte) + 8, 0); if (ret != 0) { ERROR_WITH_ERRNO("Failed to set NTFS reparse data on `%s'", @@ -543,7 +533,6 @@ out_close_dir_ni: ret = WIMLIB_ERR_NTFS_3G; ERROR_WITH_ERRNO("Failed to close directory inode"); } -out_close_ni: if (ni && ntfs_inode_close(ni) != 0) { if (ret == 0) ret = WIMLIB_ERR_NTFS_3G; @@ -582,10 +571,8 @@ static int wim_apply_dentry_ntfs(struct dentry *dentry, void *arg) int extract_flags = args->extract_flags; WIMStruct *w = args->w; ntfs_inode *dir_ni; - int ret; char *p; char orig; - ntfs_inode *close_after_dir; const char *dir_name; if (dentry->extracted_file) @@ -626,10 +613,8 @@ static int wim_apply_dentry_timestamps(struct dentry *dentry, void *arg) { struct ntfs_apply_args *args = arg; ntfs_volume *vol = args->vol; - int extract_flags = args->extract_flags; - WIMStruct *w = args->w; - char *p; - char buf[24]; + u8 *p; + u8 buf[24]; ntfs_inode *ni; int ret = 0; @@ -647,7 +632,7 @@ static int wim_apply_dentry_timestamps(struct dentry *dentry, void *arg) p = put_u64(p, dentry->creation_time); p = put_u64(p, dentry->last_write_time); p = put_u64(p, dentry->last_access_time); - ret = ntfs_inode_set_times(ni, buf, 3 * sizeof(u64), 0); + ret = ntfs_inode_set_times(ni, (const char*)buf, 3 * sizeof(u64), 0); if (ret != 0) { ERROR_WITH_ERRNO("Failed to set NTFS timestamps on `%s'", dentry->full_path_utf8); diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c index 9dc0b9d4..51434ac0 100644 --- a/src/ntfs-capture.c +++ b/src/ntfs-capture.c @@ -121,7 +121,7 @@ static int lookup_sd(const u8 hash[SHA1_HASH_SIZE], struct sd_node *root) * the security ID for it. If a new security descriptor cannot be allocated, * return -1. */ -static int sd_set_add_sd(struct sd_set *sd_set, const u8 *descriptor, +static int sd_set_add_sd(struct sd_set *sd_set, const char descriptor[], size_t size) { u8 hash[SHA1_HASH_SIZE]; @@ -132,7 +132,7 @@ static int sd_set_add_sd(struct sd_set *sd_set, const u8 *descriptor, u8 *descr_copy; struct wim_security_data *sd; - sha1_buffer(descriptor, size, hash); + sha1_buffer((const u8*)descriptor, size, hash); security_id = lookup_sd(hash, sd_set->root); if (security_id >= 0) return security_id; @@ -242,7 +242,7 @@ static int capture_ntfs_streams(struct dentry *dentry, ntfs_inode *ni, ntfs_attr_search_ctx *actx; u8 attr_hash[SHA1_HASH_SIZE]; - struct ntfs_location *ntfs_loc; + struct ntfs_location *ntfs_loc = NULL; struct lookup_table_entry *lte; int ret = 0; @@ -275,8 +275,6 @@ static int capture_ntfs_streams(struct dentry *dentry, ntfs_inode *ni, if (lte) { lte->refcnt++; } else { - struct ntfs_location *ntfs_loc; - ntfs_loc = CALLOC(1, sizeof(*ntfs_loc)); if (!ntfs_loc) goto out_put_actx; @@ -317,7 +315,7 @@ static int capture_ntfs_streams(struct dentry *dentry, ntfs_inode *ni, dentry->lte = lte; } else { struct ads_entry *new_ads_entry; - stream_name_utf8 = utf16_to_utf8((const u8*)attr_record_name(actx->attr), + stream_name_utf8 = utf16_to_utf8((const char*)attr_record_name(actx->attr), actx->attr->name_length, &stream_name_utf16_len); if (!stream_name_utf8) @@ -385,7 +383,7 @@ static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, ret = -1; - utf8_name = utf16_to_utf8((const u8*)name, name_len * 2, + utf8_name = utf16_to_utf8((const char*)name, name_len * 2, &utf8_name_len); if (!utf8_name) goto out; @@ -421,7 +419,6 @@ static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, child->file_name_utf8, ctx->parent->file_name_utf8); link_dentry(child, ctx->parent); } -out_close_ni: ntfs_inode_close(ni); out_free_utf8_name: FREE(utf8_name); @@ -511,7 +508,7 @@ static int build_dentry_tree_ntfs_recursive(struct dentry **root_p, DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, NULL, 0, &sd_size); - u8 sd[sd_size]; + char sd[sd_size]; ret = ntfs_inode_get_security(ni, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | diff --git a/src/resource.c b/src/resource.c index aaa0dac4..084cae99 100644 --- a/src/resource.c +++ b/src/resource.c @@ -599,7 +599,6 @@ static int compress_chunk(const u8 chunk[], unsigned chunk_size, unsigned *compressed_chunk_len_ret, int ctype) { - unsigned compressed_chunk_sz; int (*compress)(const void *, unsigned, void *, unsigned *); switch (ctype) { case WIM_COMPRESSION_TYPE_LZX: @@ -644,7 +643,6 @@ static int write_wim_resource_chunk(const u8 chunk[], unsigned chunk_size, } else { u8 *compressed_chunk = alloca(chunk_size); int ret; - unsigned compressed_chunk_len; ret = compress_chunk(chunk, chunk_size, compressed_chunk, &out_chunk_size, out_ctype); @@ -678,7 +676,7 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab, { size_t bytes_written; if (fseeko(out_fp, chunk_tab->file_offset, SEEK_SET) != 0) { - ERROR_WITH_ERRNO("Failed to seek to byte "PRIu64" of output " + ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of output " "WIM file", chunk_tab->file_offset); return WIMLIB_ERR_WRITE; } @@ -772,7 +770,7 @@ static int write_wim_resource(struct lookup_table_entry *lte, return 0; /* Buffer for reading chunks for the resource */ - char buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; + u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; /* If we are writing a compressed resource and not doing a raw copy, we * need to initialize the chunk table */ @@ -888,7 +886,7 @@ static int write_wim_resource(struct lookup_table_entry *lte, /* Oops! We compressed the resource to larger than the original * size. Write the resource uncompressed instead. */ if (fseeko(out_fp, file_offset, SEEK_SET) != 0) { - ERROR_WITH_ERRNO("Failed to seek to byte "PRIu64" " + ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" " "of output WIM file", file_offset); ret = WIMLIB_ERR_WRITE; goto out_fclose; @@ -973,7 +971,7 @@ int extract_wim_resource_to_fd(const struct lookup_table_entry *lte, int fd, u64 size) { u64 bytes_remaining = size; - char buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; + u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; u64 offset = 0; int ret = 0; u8 hash[SHA1_HASH_SIZE]; @@ -1099,7 +1097,6 @@ int write_dentry_resources(struct dentry *dentry, void *wim_p) int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) { u8 *buf; - int ctype; u32 dentry_offset; int ret; struct dentry *dentry; @@ -1120,7 +1117,7 @@ int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) * no security descriptors) and WIM_DENTRY_DISK_SIZE is for the root * dentry. */ if (metadata_len < 8 + WIM_DENTRY_DISK_SIZE) { - ERROR("Expected at least %zu bytes for the metadata resource", + ERROR("Expected at least %u bytes for the metadata resource", 8 + WIM_DENTRY_DISK_SIZE); return WIMLIB_ERR_INVALID_RESOURCE_SIZE; } @@ -1235,7 +1232,7 @@ int write_metadata_resource(WIMStruct *w) int ret; u64 subdir_offset; struct dentry *root; - struct lookup_table_entry *lte, *duplicate_lte; + struct lookup_table_entry *lte; u64 metadata_original_size; const struct wim_security_data *sd; const unsigned random_tail_len = 20; diff --git a/src/security.c b/src/security.c index 2e83d0e9..8fda950c 100644 --- a/src/security.c +++ b/src/security.c @@ -61,7 +61,7 @@ int read_security_data(const u8 metadata_resource[], u64 metadata_resource_len, p = metadata_resource; p = get_u32(p, &sd->total_length); - p = get_u32(p, &sd->num_entries); + p = get_u32(p, (u32*)&sd->num_entries); if (sd->num_entries > 0x7fffffff) { ERROR("Security data has too many entries!"); diff --git a/src/sha1.h b/src/sha1.h index e153f533..a0d63356 100644 --- a/src/sha1.h +++ b/src/sha1.h @@ -46,7 +46,7 @@ static inline bool is_zero_hash(const u8 hash[SHA1_HASH_SIZE]) return true; } -static void zero_hash(u8 hash[SHA1_HASH_SIZE]) +static inline void zero_hash(u8 hash[SHA1_HASH_SIZE]) { memset(hash, 0, SHA1_HASH_SIZE); } diff --git a/src/symlink.c b/src/symlink.c index 3773fb05..60f5ebb6 100644 --- a/src/symlink.c +++ b/src/symlink.c @@ -80,7 +80,7 @@ static ssize_t get_symlink_name(const u8 *resource, size_t resource_len, } if (header_size + substitute_name_offset + substitute_name_len > resource_len) return -EIO; - link_target = utf16_to_utf8(p + substitute_name_offset, + link_target = utf16_to_utf8((const char *)p + substitute_name_offset, substitute_name_len, &link_target_len); @@ -135,20 +135,22 @@ void *make_symlink_reparse_data_buf(const char *symlink_target, size_t *len_ret) for (size_t i = 0; i < utf16_len / 2; i++) if (((u16*)name_utf16)[i] == to_le16('/')) ((u16*)name_utf16)[i] = to_le16('\\'); - size_t len = 12 + utf16_len * 2; + size_t len = 12 + utf16_len * 2 + 4; void *buf = MALLOC(len); if (!buf) goto out; /* XXX Fix absolute paths */ u8 *p = buf; - p = put_u16(p, utf16_len); /* Substitute name offset */ + p = put_u16(p, utf16_len + 2); /* Substitute name offset */ p = put_u16(p, utf16_len); /* Substitute name length */ p = put_u16(p, 0); /* Print name offset */ p = put_u16(p, utf16_len); /* Print name length */ p = put_u32(p, 1); - p = put_bytes(p, utf16_len, name_utf16); - p = put_bytes(p, utf16_len, name_utf16); + p = put_bytes(p, utf16_len, (const u8*)name_utf16); + p = put_u16(p, 0); + p = put_bytes(p, utf16_len, (const u8*)name_utf16); + p = put_u16(p, 0); /*DEBUG("utf16_len = %zu, len = %zu", utf16_len, len);*/ *len_ret = len; out: @@ -175,7 +177,7 @@ ssize_t dentry_readlink(const struct dentry *dentry, char *buf, size_t buf_len, if (wim_resource_size(lte) > 10000) return -EIO; - char res_buf[wim_resource_size(lte)]; + u8 res_buf[wim_resource_size(lte)]; ret = read_full_wim_resource(lte, res_buf); if (ret != 0) return -EIO; diff --git a/src/xml.c b/src/xml.c index 943fb834..d7302e1b 100644 --- a/src/xml.c +++ b/src/xml.c @@ -819,8 +819,6 @@ static int clone_windows_info(const struct windows_info *old, static int clone_image_info(const struct image_info *old, struct image_info *new) { - int ret; - new->dir_count = old->dir_count; new->file_count = old->file_count; new->total_bytes = old->total_bytes; @@ -869,8 +867,6 @@ int xml_export_image(const struct wim_info *old_wim_info, struct wim_info *new_wim_info; struct image_info *image_info; int ret; - char *name; - char *desc; DEBUG("Copying XML data between WIM files for source image %d.", image); diff --git a/tests/test-imagex b/tests/test-imagex index f1f2154a..faae7d4b 100755 --- a/tests/test-imagex +++ b/tests/test-imagex @@ -19,6 +19,8 @@ cleanup() { rm -rf dir* tmp* *.wim *.swm } trap cleanup exit +fusermount -u tmp || true +rm -rf tmp || true # Make test directory mkdir dir -- 2.43.0