X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=4f9e9f7a7aca69682eeb2c69f5fa4546bf3720aa;hp=683a11e6f618db93c1996ed57e51804e687fcf4e;hb=a3bb2e86f2640f5d593d00250a627d3dcc9747a2;hpb=16176f3b7ce78da85646e814bd2f3ffe5babb82b diff --git a/src/dentry.c b/src/dentry.c index 683a11e6..4f9e9f7a 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -76,36 +76,46 @@ ads_entry_has_name(const struct wim_ads_entry *entry, memcmp(entry->stream_name, name, name_nbytes) == 0; } -/* Duplicates a multibyte string into a UTF-16LE string and returns the string - * and its length, in bytes, in the pointer arguments. Frees any existing - * string at the return location before overwriting it. */ +/* Duplicates a string of system-dependent encoding into a UTF-16LE string and + * returns the string and its length, in bytes, in the pointer arguments. Frees + * any existing string at the return location before overwriting it. */ static int -get_utf16le_name(const mbchar *name, utf16lechar **name_utf16le_ret, +get_utf16le_name(const tchar *name, utf16lechar **name_utf16le_ret, u16 *name_utf16le_nbytes_ret) { utf16lechar *name_utf16le; size_t name_utf16le_nbytes; int ret; +#if TCHAR_IS_UTF16LE + name_utf16le_nbytes = tstrlen(name) * sizeof(utf16lechar); + name_utf16le = MALLOC(name_utf16le_nbytes + sizeof(utf16lechar)); + if (!name_utf16le) + return WIMLIB_ERR_NOMEM; + memcpy(name_utf16le, name, name_utf16le_nbytes + sizeof(utf16lechar)); + ret = 0; +#else - ret = mbs_to_utf16le(name, strlen(name), &name_utf16le, - &name_utf16le_nbytes); + ret = tstr_to_utf16le(name, tstrlen(name), &name_utf16le, + &name_utf16le_nbytes); if (ret == 0) { if (name_utf16le_nbytes > 0xffff) { FREE(name_utf16le); - ERROR("Multibyte string \"%s\" is too long!", name); + ERROR("Multibyte string \"%"TS"\" is too long!", name); ret = WIMLIB_ERR_INVALID_UTF8_STRING; - } else { - FREE(*name_utf16le_ret); - *name_utf16le_ret = name_utf16le; - *name_utf16le_nbytes_ret = name_utf16le_nbytes; } } +#endif + if (ret == 0) { + FREE(*name_utf16le_ret); + *name_utf16le_ret = name_utf16le; + *name_utf16le_nbytes_ret = name_utf16le_nbytes; + } return ret; } /* Sets the name of a WIM dentry from a multibyte string. */ int -set_dentry_name(struct wim_dentry *dentry, const mbchar *new_name) +set_dentry_name(struct wim_dentry *dentry, const tchar *new_name) { int ret; ret = get_utf16le_name(new_name, &dentry->file_name, @@ -264,54 +274,67 @@ for_dentry_in_tree_depth(struct wim_dentry *root, } /* Calculate the full path of @dentry. The full path of its parent must have - * already been calculated. */ + * already been calculated, or it must be the root dentry. */ int calculate_dentry_full_path(struct wim_dentry *dentry, void *ignore) { - char *full_path; + tchar *full_path; u32 full_path_nbytes; wimlib_assert(dentry_is_root(dentry) || dentry->parent->full_path != NULL); if (dentry_is_root(dentry)) { - full_path = MALLOC(2); + full_path = TSTRDUP(T("/")); if (!full_path) return WIMLIB_ERR_NOMEM; - full_path[0] = '/'; - full_path[1] = '\0'; - full_path_nbytes = 1; + full_path_nbytes = 1 * sizeof(tchar); } else { - char *parent_full_path; - u32 parent_full_path_nbytes; const struct wim_dentry *parent; - size_t name_mbs_nbytes; - int ret; + tchar *parent_full_path; + u32 parent_full_path_nbytes; + size_t filename_nbytes; - ret = utf16le_to_mbs_nbytes(dentry->file_name, - dentry->file_name_nbytes, - &name_mbs_nbytes); - if (ret) - return ret; parent = dentry->parent; if (dentry_is_root(parent)) { - parent_full_path = ""; + parent_full_path = T(""); parent_full_path_nbytes = 0; } else { parent_full_path = parent->full_path; parent_full_path_nbytes = parent->full_path_nbytes; } - full_path_nbytes = parent_full_path_nbytes + 1 + - name_mbs_nbytes; - full_path = MALLOC(full_path_nbytes + 1); + + /* Append this dentry's name as a tchar string to the full path + * of the parent followed by the path separator */ + #if TCHAR_IS_UTF16LE + filename_nbytes = dentry->file_name_nbytes; + #else + { + int ret = utf16le_to_tstr_nbytes(dentry->file_name, + dentry->file_name_nbytes, + &filename_nbytes); + if (ret) + return ret; + } + #endif + + full_path_nbytes = parent_full_path_nbytes + sizeof(tchar) + + filename_nbytes; + full_path = MALLOC(full_path_nbytes + sizeof(tchar)); if (!full_path) return WIMLIB_ERR_NOMEM; memcpy(full_path, parent_full_path, parent_full_path_nbytes); - full_path[parent_full_path_nbytes] = '/'; - - utf16le_to_mbs_buf(dentry->file_name, - dentry->file_name_nbytes, - &full_path[parent_full_path_nbytes + 1]); + full_path[parent_full_path_nbytes / sizeof(tchar)] = T('/'); + #if TCHAR_IS_UTF16LE + memcpy(&full_path[parent_full_path_nbytes / sizeof(tchar) + 1], + dentry->file_name, + filename_nbytes + sizeof(tchar)); + #else + utf16le_to_tstr_buf(dentry->file_name, + dentry->file_name_nbytes, + &full_path[parent_full_path_nbytes / + sizeof(tchar) + 1]); + #endif } FREE(dentry->full_path); dentry->full_path = full_path; @@ -413,15 +436,19 @@ get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry, /* Returns the child of @dentry that has the file name @name. Returns NULL if * no child has the name. */ struct wim_dentry * -get_dentry_child_with_name(const struct wim_dentry *dentry, const mbchar *name) +get_dentry_child_with_name(const struct wim_dentry *dentry, const tchar *name) { +#if TCHAR_IS_UTF16LE + return get_dentry_child_with_utf16le_name(dentry, name, + tstrlen(name) * sizeof(tchar)); +#else utf16lechar *utf16le_name; size_t utf16le_name_nbytes; int ret; struct wim_dentry *child; - ret = mbs_to_utf16le(name, strlen(name), - &utf16le_name, &utf16le_name_nbytes); + ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar), + &utf16le_name, &utf16le_name_nbytes); if (ret) { child = NULL; } else { @@ -431,35 +458,25 @@ get_dentry_child_with_name(const struct wim_dentry *dentry, const mbchar *name) FREE(utf16le_name); } return child; +#endif } -/* Returns the dentry corresponding to the @path, or NULL if there is no such - * dentry. */ -struct wim_dentry * -get_dentry(WIMStruct *w, const mbchar *path) +static struct wim_dentry * +get_dentry_utf16le(WIMStruct *w, const utf16lechar *path, + size_t path_nbytes) { - utf16lechar *path_utf16le; - size_t path_utf16le_nbytes; - int ret; struct wim_dentry *cur_dentry, *parent_dentry; - utf16lechar *p, *pp; - - ret = mbs_to_utf16le(path, strlen(path), &path_utf16le, - &path_utf16le_nbytes); - if (ret) - return NULL; - - parent_dentry = wim_root_dentry(w); - p = path_utf16le; + const utf16lechar *p, *pp; + cur_dentry = parent_dentry = wim_root_dentry(w); + p = path; while (1) { while (*p == cpu_to_le16('/')) p++; - cur_dentry = parent_dentry; if (*p == '\0') break; pp = p; - while (*pp != cpu_to_le16('/') && *pp != '\0') + while (*pp != cpu_to_le16('/') && *pp != cpu_to_le16('\0')) pp++; cur_dentry = get_dentry_child_with_utf16le_name(parent_dentry, p, @@ -469,7 +486,6 @@ get_dentry(WIMStruct *w, const mbchar *path) p = pp; parent_dentry = cur_dentry; } - FREE(path_utf16le); if (cur_dentry == NULL) { if (dentry_is_directory(parent_dentry)) errno = ENOENT; @@ -479,8 +495,31 @@ get_dentry(WIMStruct *w, const mbchar *path) return cur_dentry; } +/* Returns the dentry corresponding to the @path, or NULL if there is no such + * dentry. */ +struct wim_dentry * +get_dentry(WIMStruct *w, const tchar *path) +{ +#if TCHAR_IS_UTF16LE + return get_dentry_utf16le(w, path, tstrlen(path) * sizeof(tchar)); +#else + utf16lechar *path_utf16le; + size_t path_utf16le_nbytes; + int ret; + struct wim_dentry *dentry; + + ret = tstr_to_utf16le(path, tstrlen(path) * sizeof(tchar), + &path_utf16le, &path_utf16le_nbytes); + if (ret) + return NULL; + dentry = get_dentry_utf16le(w, path_utf16le, path_utf16le_nbytes); + FREE(path_utf16le); + return dentry; +#endif +} + struct wim_inode * -wim_pathname_to_inode(WIMStruct *w, const mbchar *path) +wim_pathname_to_inode(WIMStruct *w, const tchar *path) { struct wim_dentry *dentry; dentry = get_dentry(w, path); @@ -490,15 +529,30 @@ wim_pathname_to_inode(WIMStruct *w, const mbchar *path) return NULL; } +/* Takes in a path of length @len in @buf, and transforms it into a string for + * the path of its parent directory. */ +static void +to_parent_name(tchar *buf, size_t len) +{ + ssize_t i = (ssize_t)len - 1; + while (i >= 0 && buf[i] == T('/')) + i--; + while (i >= 0 && buf[i] != T('/')) + i--; + while (i >= 0 && buf[i] == T('/')) + i--; + buf[i + 1] = T('\0'); +} + /* Returns the dentry that corresponds to the parent directory of @path, or NULL * if the dentry is not found. */ struct wim_dentry * -get_parent_dentry(WIMStruct *w, const mbchar *path) +get_parent_dentry(WIMStruct *w, const tchar *path) { - size_t path_len = strlen(path); - mbchar buf[path_len + 1]; + size_t path_len = tstrlen(path); + tchar buf[path_len + 1]; - memcpy(buf, path, path_len + 1); + tmemcpy(buf, path, path_len + 1); to_parent_name(buf, path_len); return get_dentry(w, buf); } @@ -508,7 +562,7 @@ int print_dentry_full_path(struct wim_dentry *dentry, void *ignore) { if (dentry->full_path) - puts(dentry->full_path); + tprintf(T("%"TS"\n"), dentry->full_path); return 0; } @@ -516,24 +570,24 @@ print_dentry_full_path(struct wim_dentry *dentry, void *ignore) * set. */ struct file_attr_flag { u32 flag; - const char *name; + const tchar *name; }; struct file_attr_flag file_attr_flags[] = { - {FILE_ATTRIBUTE_READONLY, "READONLY"}, - {FILE_ATTRIBUTE_HIDDEN, "HIDDEN"}, - {FILE_ATTRIBUTE_SYSTEM, "SYSTEM"}, - {FILE_ATTRIBUTE_DIRECTORY, "DIRECTORY"}, - {FILE_ATTRIBUTE_ARCHIVE, "ARCHIVE"}, - {FILE_ATTRIBUTE_DEVICE, "DEVICE"}, - {FILE_ATTRIBUTE_NORMAL, "NORMAL"}, - {FILE_ATTRIBUTE_TEMPORARY, "TEMPORARY"}, - {FILE_ATTRIBUTE_SPARSE_FILE, "SPARSE_FILE"}, - {FILE_ATTRIBUTE_REPARSE_POINT, "REPARSE_POINT"}, - {FILE_ATTRIBUTE_COMPRESSED, "COMPRESSED"}, - {FILE_ATTRIBUTE_OFFLINE, "OFFLINE"}, - {FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,"NOT_CONTENT_INDEXED"}, - {FILE_ATTRIBUTE_ENCRYPTED, "ENCRYPTED"}, - {FILE_ATTRIBUTE_VIRTUAL, "VIRTUAL"}, + {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 @@ -545,37 +599,37 @@ 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; - char buf[50]; + tchar buf[50]; - printf("[DENTRY]\n"); - printf("Length = %"PRIu64"\n", dentry->length); - printf("Attributes = 0x%x\n", inode->i_attributes); + 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) - printf(" FILE_ATTRIBUTE_%s is set\n", + tprintf(T(" FILE_ATTRIBUTE_%"TS" is set\n"), file_attr_flags[i].name); - printf("Security ID = %d\n", inode->i_security_id); - printf("Subdir offset = %"PRIu64"\n", dentry->subdir_offset); + 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)); - printf("Creation Time = %s\n", buf); + tprintf(T("Creation Time = %"TS"\n"), buf); wim_timestamp_to_str(inode->i_last_access_time, buf, sizeof(buf)); - printf("Last Access Time = %s\n", buf); + tprintf(T("Last Access Time = %"TS"\n"), buf); wim_timestamp_to_str(inode->i_last_write_time, buf, sizeof(buf)); - printf("Last Write Time = %s\n", buf); + tprintf(T("Last Write Time = %"TS"\n"), buf); - printf("Reparse Tag = 0x%"PRIx32"\n", inode->i_reparse_tag); - printf("Hard Link Group = 0x%"PRIx64"\n", inode->i_ino); - printf("Hard Link Group Size = %"PRIu32"\n", inode->i_nlink); - printf("Number of Alternate Data Streams = %hu\n", inode->i_num_ads); + tprintf(T("Reparse Tag = 0x%"PRIx32"\n"), inode->i_reparse_tag); + 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("Filename = \"%W\"\n", dentry->file_name); + wimlib_printf(T("Filename = \"%"WS"\"\n"), dentry->file_name); if (dentry_has_short_name(dentry)) - wimlib_printf("Short Name \"%W\"\n", dentry->short_name); + wimlib_printf(T("Short Name \"%"WS"\"\n"), dentry->short_name); if (dentry->full_path) - printf("Full Path = \"%s\"\n", dentry->full_path); + tprintf(T("Full Path = \"%"TS"\"\n"), dentry->full_path); lte = inode_stream_lte(dentry->d_inode, 0, lookup_table); if (lte) { @@ -583,22 +637,23 @@ print_dentry(struct wim_dentry *dentry, void *lookup_table) } else { hash = inode_stream_hash(inode, 0); if (hash) { - printf("Hash = 0x"); + tprintf(T("Hash = 0x")); print_hash(hash); - putchar('\n'); - putchar('\n'); + tputchar(T('\n')); + tputchar(T('\n')); } } for (u16 i = 0; i < inode->i_num_ads; i++) { - printf("[Alternate Stream Entry %u]\n", i); - wimlib_printf("Name = \"%W\"\n", inode->i_ads_entries[i].stream_name); - printf("Name Length (UTF16) = %u\n", + 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) { - printf("Hash = 0x"); + tprintf(T("Hash = 0x")); print_hash(hash); - putchar('\n'); + tputchar(T('\n')); } print_lookup_table_entry(inode_stream_lte(inode, i + 1, lookup_table), stdout); @@ -648,7 +703,8 @@ new_inode() } /* Creates an unlinked directory entry. */ -int new_dentry(const mbchar *name, struct wim_dentry **dentry_ret) +int +new_dentry(const tchar *name, struct wim_dentry **dentry_ret) { struct wim_dentry *dentry; int ret; @@ -664,14 +720,15 @@ int new_dentry(const mbchar *name, struct wim_dentry **dentry_ret) *dentry_ret = dentry; } else { FREE(dentry); - ERROR("Failed to set name on new dentry with name \"%s\"", name); + ERROR("Failed to set name on new dentry with name \"%"TS"\"", + name); } return ret; } static int -__new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret, +__new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret, bool timeless) { struct wim_dentry *dentry; @@ -696,13 +753,13 @@ __new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret, } int -new_dentry_with_timeless_inode(const mbchar *name, struct wim_dentry **dentry_ret) +new_dentry_with_timeless_inode(const tchar *name, struct wim_dentry **dentry_ret) { return __new_dentry_with_inode(name, dentry_ret, true); } int -new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret) +new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret) { return __new_dentry_with_inode(name, dentry_ret, false); } @@ -724,7 +781,7 @@ init_ads_entry(struct wim_ads_entry *ads_entry, const void *name, ads_entry->stream_name = p; ads_entry->stream_name_nbytes = name_nbytes; } else { - if (name && *(const char*)name) { + if (name && *(const tchar*)name != T('\0')) { ret = get_utf16le_name(name, &ads_entry->stream_name, &ads_entry->stream_name_nbytes); } @@ -739,7 +796,8 @@ destroy_ads_entry(struct wim_ads_entry *ads_entry) } /* Frees an inode. */ -void free_inode(struct wim_inode *inode) +void +free_inode(struct wim_inode *inode) { if (inode) { if (inode->i_ads_entries) { @@ -761,7 +819,8 @@ void free_inode(struct wim_inode *inode) /* Decrements link count on an inode and frees it if the link count reaches 0. * */ -static void put_inode(struct wim_inode *inode) +static void +put_inode(struct wim_inode *inode) { wimlib_assert(inode->i_nlink != 0); if (--inode->i_nlink == 0) { @@ -779,7 +838,8 @@ static void put_inode(struct wim_inode *inode) * The corresponding inode (if any) is freed only if its link count is * decremented to 0. */ -void free_dentry(struct wim_dentry *dentry) +void +free_dentry(struct wim_dentry *dentry) { FREE(dentry->file_name); FREE(dentry->short_name); @@ -789,7 +849,8 @@ void free_dentry(struct wim_dentry *dentry) FREE(dentry); } -void put_dentry(struct wim_dentry *dentry) +void +put_dentry(struct wim_dentry *dentry) { wimlib_assert(dentry->refcnt != 0); if (--dentry->refcnt == 0) @@ -798,7 +859,8 @@ void put_dentry(struct wim_dentry *dentry) /* This function is passed as an argument to for_dentry_in_tree_depth() in order * to free a directory tree. */ -static int do_free_dentry(struct wim_dentry *dentry, void *__lookup_table) +static int +do_free_dentry(struct wim_dentry *dentry, void *__lookup_table) { struct wim_lookup_table *lookup_table = __lookup_table; unsigned i; @@ -827,13 +889,15 @@ static int do_free_dentry(struct wim_dentry *dentry, void *__lookup_table) * table entries corresponding to the dentries will be * decremented. */ -void free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table) +void +free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table) { if (root) for_dentry_in_tree_depth(root, do_free_dentry, lookup_table); } -int increment_dentry_refcnt(struct wim_dentry *dentry, void *ignore) +int +increment_dentry_refcnt(struct wim_dentry *dentry, void *ignore) { dentry->refcnt++; return 0; @@ -889,24 +953,34 @@ unlink_dentry(struct wim_dentry *dentry) * stream name @stream_name. */ struct wim_ads_entry * -inode_get_ads_entry(struct wim_inode *inode, const mbchar *stream_name, +inode_get_ads_entry(struct wim_inode *inode, const tchar *stream_name, u16 *idx_ret) { if (inode->i_num_ads == 0) { return NULL; } else { - int ret; - utf16lechar *stream_name_utf16le; size_t stream_name_utf16le_nbytes; u16 i; struct wim_ads_entry *result; - ret = mbs_to_utf16le(stream_name, strlen(stream_name), - &stream_name_utf16le, - &stream_name_utf16le_nbytes); - if (ret) - return NULL; + #if TCHAR_IS_UTF16LE + const utf16lechar *stream_name_utf16le; + + stream_name_utf16le = stream_name; + stream_name_utf16le_nbytes = tstrlen(stream_name) * sizeof(tchar); + #else + utf16lechar *stream_name_utf16le; + { + int ret = tstr_to_utf16le(stream_name, + tstrlen(stream_name) * + sizeof(tchar), + &stream_name_utf16le, + &stream_name_utf16le_nbytes); + if (ret) + return NULL; + } + #endif i = 0; result = NULL; do { @@ -920,7 +994,9 @@ inode_get_ads_entry(struct wim_inode *inode, const mbchar *stream_name, break; } } while (++i != inode->i_num_ads); + #if !TCHAR_IS_UTF16LE FREE(stream_name_utf16le); + #endif return result; } } @@ -933,8 +1009,6 @@ do_inode_add_ads(struct wim_inode *inode, const void *stream_name, struct wim_ads_entry *ads_entries; struct wim_ads_entry *new_entry; - DEBUG("Add alternate data stream \"%s\"", stream_name); - if (inode->i_num_ads >= 0xfffe) { ERROR("Too many alternate data streams in one inode!"); return NULL; @@ -963,6 +1037,7 @@ inode_add_ads_utf16le(struct wim_inode *inode, const utf16lechar *stream_name, size_t stream_name_nbytes) { + DEBUG("Add alternate data stream \"%"WS"\"", stream_name); return do_inode_add_ads(inode, stream_name, stream_name_nbytes, true); } @@ -971,13 +1046,16 @@ inode_add_ads_utf16le(struct wim_inode *inode, * NULL if memory could not be allocated. */ struct wim_ads_entry * -inode_add_ads(struct wim_inode *inode, const char *stream_name) +inode_add_ads(struct wim_inode *inode, const tchar *stream_name) { - return do_inode_add_ads(inode, stream_name, strlen(stream_name), false); + DEBUG("Add alternate data stream \"%"TS"\"", stream_name); + return do_inode_add_ads(inode, stream_name, + tstrlen(stream_name) * sizeof(tchar), + TCHAR_IS_UTF16LE); } int -inode_add_ads_with_data(struct wim_inode *inode, const mbchar *name, +inode_add_ads_with_data(struct wim_inode *inode, const tchar *name, const void *value, size_t size, struct wim_lookup_table *lookup_table) { @@ -1000,25 +1078,24 @@ inode_add_ads_with_data(struct wim_inode *inode, const mbchar *name, u8 *value_copy; lte = new_lookup_table_entry(); if (!lte) - goto out_free_ads_entry; + goto out_remove_ads_entry; value_copy = MALLOC(size); if (!value_copy) { FREE(lte); - goto out_free_ads_entry; + goto out_remove_ads_entry; } memcpy(value_copy, value, size); lte->resource_location = RESOURCE_IN_ATTACHED_BUFFER; lte->attached_buffer = value_copy; lte->resource_entry.original_size = size; lte->resource_entry.size = size; - lte->resource_entry.flags = 0; copy_hash(lte->hash, value_hash); lookup_table_insert(lookup_table, lte); } new_ads_entry->lte = lte; ret = 0; goto out; -out_free_ads_entry: +out_remove_ads_entry: inode_remove_ads(inode, new_ads_entry - inode->i_ads_entries, lookup_table); out: @@ -1038,7 +1115,7 @@ inode_remove_ads(struct wim_inode *inode, u16 idx, ads_entry = &inode->i_ads_entries[idx]; - DEBUG("Remove alternate data stream \"%W\"", ads_entry->stream_name); + DEBUG("Remove alternate data stream \"%"WS"\"", ads_entry->stream_name); lte = ads_entry->lte; if (lte) @@ -1081,7 +1158,7 @@ inode_get_unix_data(const struct wim_inode *inode, if (size != sizeof(struct wimlib_unix_data)) return BAD_UNIX_DATA; - ret = read_full_wim_resource(lte, (u8*)unix_data, 0); + ret = read_full_wim_resource(lte, unix_data, 0); if (ret) return ret; @@ -1115,7 +1192,7 @@ inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode, if (which & UNIX_DATA_MODE || !have_good_unix_data) unix_data.mode = mode; ret = inode_add_ads_with_data(inode, WIMLIB_UNIX_DATA_TAG, - (const u8*)&unix_data, + &unix_data, sizeof(struct wimlib_unix_data), lookup_table); if (ret == 0 && have_unix_data) @@ -1424,7 +1501,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_bytes(p, file_name_nbytes + 2, file_name); if (file_name[file_name_nbytes / 2] != 0) { file_name[file_name_nbytes / 2] = 0; - WARNING("File name in WIM dentry \"%W\" is not " + WARNING("File name in WIM dentry \"%"WS"\" is not " "null-terminated!", file_name); } } @@ -1456,9 +1533,9 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, * u64 reserved1; (always 0) * u64 reserved2; (always 0) * };*/ - /*DEBUG("Dentry for file or directory `%s' has %"PRIu64" extra "*/ - /*"bytes of data",*/ - /*file_name_utf8, dentry->length - calculated_size);*/ + /*DEBUG("Dentry for file or directory `%"WS"' has %"PRIu64" "*/ + /*"extra bytes of data", file_name,*/ + /*dentry->length - calculated_size);*/ } /* Read the short filename if present. Note: if there is no short @@ -1474,7 +1551,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_bytes(p, short_name_nbytes + 2, short_name); if (short_name[short_name_nbytes / 2] != 0) { short_name[short_name_nbytes / 2] = 0; - WARNING("Short name in WIM dentry \"%W\" is not " + WARNING("Short name in WIM dentry \"%"WS"\" is not " "null-terminated!", file_name); } } @@ -1514,7 +1591,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, goto out; } ERROR("Failed to read alternate data stream " - "entries of WIM dentry \"%W\"", file_name); + "entries of WIM dentry \"%"WS"\"", file_name); goto out_free_short_name; } out: