X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=7cd93ed1ab9e42a21aa0dfcaf6ae31d6e5e441c7;hp=16d9b416e8da2cdaa03cb6e921debe609810f3c0;hb=ff556d243953bd6df1399466c452f327feae2ed9;hpb=13c6ce3160fce7c40008d1d182325c8b42450d1e diff --git a/src/dentry.c b/src/dentry.c index 16d9b416..7cd93ed1 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -347,6 +347,18 @@ calculate_dentry_full_path(struct wim_dentry *dentry) return 0; } +static int +do_calculate_dentry_full_path(struct wim_dentry *dentry, void *_ignore) +{ + return calculate_dentry_full_path(dentry); +} + +int +calculate_dentry_tree_full_paths(struct wim_dentry *root) +{ + return for_dentry_in_tree(root, do_calculate_dentry_full_path, NULL); +} + tchar * dentry_full_path(struct wim_dentry *dentry) { @@ -573,13 +585,10 @@ get_parent_dentry(WIMStruct *w, const tchar *path) int print_dentry_full_path(struct wim_dentry *dentry, void *_ignore) { - tchar *full_path = dentry_full_path(dentry); - if (!full_path) - return WIMLIB_ERR_NOMEM; - tprintf(T("%"TS"\n"), full_path); - FREE(full_path); - dentry->_full_path = 0; - dentry->full_path_nbytes = 0; + int ret = calculate_dentry_full_path(dentry); + if (ret) + return ret; + tprintf(T("%"TS"\n"), dentry->_full_path); return 0; } @@ -637,7 +646,15 @@ print_dentry(struct wim_dentry *dentry, void *lookup_table) wim_timestamp_to_str(inode->i_last_write_time, buf, sizeof(buf)); tprintf(T("Last Write Time = %"TS"\n"), buf); - tprintf(T("Reparse Tag = 0x%"PRIx32"\n"), inode->i_reparse_tag); + 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); @@ -692,8 +709,9 @@ new_timeless_inode() if (inode) { inode->i_security_id = -1; inode->i_nlink = 1; - #ifdef WITH_FUSE inode->i_next_stream_id = 1; + inode->i_not_rpfixed = 1; + #ifdef WITH_FUSE if (pthread_mutex_init(&inode->i_mutex, NULL) != 0) { ERROR_WITH_ERRNO("Error initializing mutex"); FREE(inode); @@ -909,7 +927,7 @@ free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table) * @parent: The dentry that will be the parent of @dentry. * @dentry: The dentry to link. */ -bool +struct wim_dentry * dentry_add_child(struct wim_dentry * restrict parent, struct wim_dentry * restrict child) { @@ -930,12 +948,12 @@ dentry_add_child(struct wim_dentry * restrict parent, else if (result > 0) new = &((*new)->rb_right); else - return false; + return this; } child->parent = parent; rb_link_node(&child->rb_node, rb_parent, new); rb_insert_color(&child->rb_node, root); - return true; + return NULL; } /* Unlink a WIM dentry from the directory entry tree. */ @@ -1025,9 +1043,7 @@ do_inode_add_ads(struct wim_inode *inode, const void *stream_name, new_entry = &inode->i_ads_entries[num_ads - 1]; if (init_ads_entry(new_entry, stream_name, stream_name_nbytes, is_utf16le)) return NULL; -#ifdef WITH_FUSE new_entry->stream_id = inode->i_next_stream_id++; -#endif inode->i_num_ads = num_ads; return new_entry; } @@ -1102,6 +1118,43 @@ out: return ret; } +/* Set the unnamed stream of a WIM inode, given a data buffer containing the + * stream contents. */ +int +inode_set_unnamed_stream(struct wim_inode *inode, const void *data, size_t len, + struct wim_lookup_table *lookup_table) +{ + struct wim_lookup_table_entry *lte, *existing_lte; + u8 hash[SHA1_HASH_SIZE]; + void *buf; + + sha1_buffer(data, len, hash); + existing_lte = __lookup_resource(lookup_table, hash); + if (existing_lte) { + wimlib_assert(wim_resource_size(existing_lte) == len); + lte = existing_lte; + lte->refcnt++; + } else { + lte = new_lookup_table_entry(); + if (!lte) + return WIMLIB_ERR_NOMEM; + buf = MALLOC(len); + if (!buf) { + free_lookup_table_entry(lte); + return WIMLIB_ERR_NOMEM; + } + memcpy(buf, data, len); + lte->resource_location = RESOURCE_IN_ATTACHED_BUFFER; + lte->attached_buffer = buf; + lte->resource_entry.original_size = len; + copy_hash(lte->hash, hash); + lookup_table_insert(lookup_table, lte); + } + inode->i_lte = lte; + inode->i_resolved = 1; + return 0; +} + /* Remove an alternate data stream from a WIM inode */ void inode_remove_ads(struct wim_inode *inode, u16 idx, @@ -1201,6 +1254,39 @@ inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode, } #endif /* !__WIN32__ */ +/* Replace weird characters in filenames and alternate data stream names. + * + * In particular we do not want the path separator to appear in any names, as + * that would make it possible for a "malicious" WIM to extract itself to any + * location it wanted to. */ +static void +replace_forbidden_characters(utf16lechar *name) +{ + utf16lechar *p; + + for (p = name; *p; p++) { + #ifdef __WIN32__ + if (wcschr(L"<>:\"/\\|?*", (wchar_t)*p)) + #else + if (*p == '/') + #endif + { + #ifdef __WIN32__ + *p = cpu_to_le16(0xfffd); + #else + *p = '?'; + #endif + if (name) { + WARNING("File, directory, or stream name \"%"WS"\"\n" + " contains forbidden characters; " + "substituting replacement characters.", + name); + name = NULL; + } + } + } +} + /* * Reads the alternate data stream entries of a WIM dentry. * @@ -1278,7 +1364,7 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size) } p = get_u64(p, &length); - p += 8; /* Skip the reserved field */ + p = get_u64(p, &cur_entry->unused); p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash); p = get_u16(p, &cur_entry->stream_name_nbytes); @@ -1328,6 +1414,7 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size) get_bytes(p, cur_entry->stream_name_nbytes, cur_entry->stream_name); cur_entry->stream_name[cur_entry->stream_name_nbytes / 2] = 0; + replace_forbidden_characters(cur_entry->stream_name); } /* It's expected that the size of every ADS entry is a multiple * of 8. However, to be safe, I'm allowing the possibility of @@ -1434,10 +1521,8 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_u32(p, (u32*)&inode->i_security_id); p = get_u64(p, &dentry->subdir_offset); - /* 2 unused fields */ - p += 2 * sizeof(u64); - /*p = get_u64(p, &dentry->unused1);*/ - /*p = get_u64(p, &dentry->unused2);*/ + p = get_u64(p, &inode->i_unused_1); + p = get_u64(p, &inode->i_unused_2); p = get_u64(p, &inode->i_creation_time); p = get_u64(p, &inode->i_last_access_time); @@ -1445,19 +1530,16 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_bytes(p, SHA1_HASH_SIZE, inode->i_hash); - /* - * I don't know what's going on here. It seems like M$ screwed up the + /* I don't know what's going on here. It seems like M$ screwed up the * reparse points, then put the fields in the same place and didn't - * document it. The WIM_HDR_FLAG_RP_FIX flag in the WIM header might - * have something to do with this, but it's not documented. - */ + * document it. */ if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { - /* ??? */ - p += 4; + p = get_u32(p, &inode->i_rp_unknown_1); p = get_u32(p, &inode->i_reparse_tag); - p += 4; + p = get_u16(p, &inode->i_rp_unknown_2); + p = get_u16(p, &inode->i_not_rpfixed); } else { - p = get_u32(p, &inode->i_reparse_tag); + p = get_u32(p, &inode->i_rp_unknown_1); p = get_u64(p, &inode->i_ino); } @@ -1504,6 +1586,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, WARNING("File name in WIM dentry \"%"WS"\" is not " "null-terminated!", file_name); } + replace_forbidden_characters(file_name); } /* Align the calculated size */ @@ -1554,6 +1637,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, WARNING("Short name in WIM dentry \"%"WS"\" is not " "null-terminated!", file_name); } + replace_forbidden_characters(short_name); } /* @@ -1716,20 +1800,21 @@ write_dentry(const struct wim_dentry *dentry, u8 *p) p = put_u32(p, inode->i_attributes); p = put_u32(p, inode->i_security_id); p = put_u64(p, dentry->subdir_offset); - p = put_u64(p, 0); /* unused1 */ - p = put_u64(p, 0); /* unused2 */ + p = put_u64(p, inode->i_unused_1); + p = put_u64(p, inode->i_unused_2); p = put_u64(p, inode->i_creation_time); p = put_u64(p, inode->i_last_access_time); p = put_u64(p, inode->i_last_write_time); hash = inode_stream_hash(inode, 0); p = put_bytes(p, SHA1_HASH_SIZE, hash); if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { - p = put_zeroes(p, 4); + p = put_u32(p, inode->i_rp_unknown_1); p = put_u32(p, inode->i_reparse_tag); - p = put_zeroes(p, 4); + p = put_u16(p, inode->i_rp_unknown_2); + p = put_u16(p, inode->i_not_rpfixed); } else { u64 link_group_id; - p = put_u32(p, 0); + p = put_u32(p, inode->i_rp_unknown_1); if (inode->i_nlink == 1) link_group_id = 0; else @@ -1757,7 +1842,7 @@ write_dentry(const struct wim_dentry *dentry, u8 *p) * alternate data stream entries. */ for (u16 i = 0; i < inode->i_num_ads; i++) { p = put_u64(p, ads_entry_total_length(&inode->i_ads_entries[i])); - p = put_u64(p, 0); /* Unused */ + p = put_u64(p, inode->i_ads_entries[i].unused); hash = inode_stream_hash(inode, i + 1); p = put_bytes(p, SHA1_HASH_SIZE, hash); p = put_u16(p, inode->i_ads_entries[i].stream_name_nbytes);