tchar *display_name;
tchar *display_description;
tchar *flags;
- struct wim_lookup_table *lookup_table; /* Temporary field only */
+ struct wim_lookup_table *lookup_table; /* temporary field */
};
struct xml_string_spec {
- const utf8char *name;
+ const char *name;
size_t offset;
};
return T("x86_64");
/* XXX Are there other arch values? */
default:
- return NULL;
+ return T("unknown");
}
}
}
static inline bool
-node_name_is(xmlNode *node, const utf8char *name)
+node_name_is(xmlNode *node, const char *name)
{
/* For now, both upper case and lower case element names are accepted. */
return strcasecmp((const char *)node->name, name) == 0;
}
-/* Finds the text node that is a child of an element node and returns its
- * content converted to a 64-bit unsigned integer. Returns 0 if no text node is
- * found. */
static u64
-node_get_u64(const xmlNode *u64_node)
+node_get_number(const xmlNode *u64_node, int base)
{
xmlNode *child;
for_node_child(u64_node, child)
if (node_is_text(child))
- return strtoull((const char *)child->content, NULL, 10);
+ return strtoull(child->content, NULL, base);
return 0;
}
+/* Finds the text node that is a child of an element node and returns its
+ * content converted to a 64-bit unsigned integer. Returns 0 if no text node is
+ * found. */
+static u64
+node_get_u64(const xmlNode *u64_node)
+{
+ return node_get_number(u64_node, 10);
+}
+
/* Like node_get_u64(), but expects a number in base 16. */
static u64
node_get_hex_u64(const xmlNode *u64_node)
{
- xmlNode *child;
- for_node_child(u64_node, child)
- if (node_is_text(child))
- return strtoull(child->content, NULL, 16);
- return 0;
+ return node_get_number(u64_node, 16);
}
static int
const struct windows_version *windows_version;
tprintf(T("Architecture: %"TS"\n"),
- get_arch(windows_info->arch) ?: T("unknown"));
+ get_arch(windows_info->arch));
if (windows_info->product_name) {
tprintf(T("Product Name: %"TS"\n"),
const tchar *tstr)
{
if (tstr) {
- utf8char *utf8_str;
+ char *utf8_str;
int rc = tstr_to_utf8_simple(tstr, &utf8_str);
if (rc)
return rc;
/* Writes a time element to the XML document being constructed in memory. */
static int
-xml_write_time(xmlTextWriter *writer, const utf8char *element_name, u64 time)
+xml_write_time(xmlTextWriter *writer, const char *element_name, u64 time)
{
int rc;
rc = xmlTextWriterStartElement(writer, element_name);
if (image_info->windows_info_exists) {
rc = xml_write_windows_info(writer, &image_info->windows_info);
- if (rc < 0)
+ if (rc)
return rc;
}
ret = dup_strings_from_specs(old, new, windows_info_xml_string_specs,
ARRAY_LEN(windows_info_xml_string_specs));
+ if (ret)
+ return ret;
if (old->languages) {
new->languages = CALLOC(old->num_languages, sizeof(new->languages[0]));
{
struct wim_info *wim_info;
- DEBUG("Deleting image %d from the XML data.", image);
-
wim_info = *wim_info_p;
+ wimlib_assert(image >= 1 && image <= wim_info->num_images);
+ DEBUG("Deleting image %d from the XML data.", image);
destroy_image_info(&wim_info->images[image - 1]);
calculate_dentry_statistics(struct wim_dentry *dentry, void *arg)
{
struct image_info *info = arg;
- struct wim_lookup_table *lookup_table = info->lookup_table;
const struct wim_inode *inode = dentry->d_inode;
struct wim_lookup_table_entry *lte;
if (inode->i_nlink >= 2 && dentry_is_first_in_inode(dentry)) {
for (unsigned i = 0; i < inode->i_num_ads; i++) {
if (inode->i_ads_entries[i].stream_name_nbytes) {
- lte = inode_stream_lte(inode, i + 1, lookup_table);
+ lte = inode_stream_lte(inode, i + 1, info->lookup_table);
if (lte) {
info->hard_link_bytes += inode->i_nlink *
wim_resource_size(lte);
image_info->dir_count = 0;
image_info->total_bytes = 0;
image_info->hard_link_bytes = 0;
-
image_info->lookup_table = w->lookup_table;
- for_dentry_in_tree(w->image_metadata[image - 1].root_dentry,
+
+ for_dentry_in_tree(w->image_metadata[image - 1]->root_dentry,
calculate_dentry_statistics,
image_info);
image_info->last_modification_time = get_wim_timestamp();
wim_timestamp_to_str(image_info->creation_time, buf, sizeof(buf));
tprintf(T("Creation Time: %"TS"\n"), buf);
- wim_timestamp_to_str(image_info->creation_time, buf, sizeof(buf));
+ wim_timestamp_to_str(image_info->last_modification_time, buf, sizeof(buf));
tprintf(T("Last Modification Time: %"TS"\n"), buf);
if (image_info->windows_info_exists)
print_windows_info(&image_info->windows_info);
* Reads the XML data from a WIM file.
*/
int
-read_xml_data(FILE *fp, const struct resource_entry *res_entry,
- utf16lechar **xml_data_ret, struct wim_info **info_ret)
+read_xml_data(int in_fd,
+ const struct resource_entry *res_entry,
+ struct wim_info **info_ret)
{
utf16lechar *xml_data;
xmlDoc *doc;
goto out;
}
- ret = read_uncompressed_resource(fp, res_entry->offset,
- res_entry->size, xml_data);
- if (ret != 0)
+ if (full_pread(in_fd, xml_data,
+ res_entry->size, res_entry->offset) != res_entry->size)
+ {
+ ERROR_WITH_ERRNO("Error reading XML data");
+ ret = WIMLIB_ERR_READ;
goto out_free_xml_data;
+ }
/* Null-terminate just in case */
((u8*)xml_data)[res_entry->size] = 0;
}
if (!node_is_element(root) || !node_name_is(root, "WIM")) {
- ERROR("Expected <WIM> for the root XML element (found <%s>)",
- root->name);
+ ERROR("Expected <WIM> for the root XML element");
ret = WIMLIB_ERR_XML;
goto out_free_doc;
}
-
ret = xml_read_wim_info(root, info_ret);
- if (ret != 0)
- goto out_free_doc;
-
- *xml_data_ret = xml_data;
- xml_data = NULL;
out_free_doc:
DEBUG("Freeing XML tree.");
xmlFreeDoc(doc);
* the offset of the XML data.
*/
int
-write_xml_data(const struct wim_info *wim_info, int image, FILE *out,
+write_xml_data(const struct wim_info *wim_info, int image, int out_fd,
u64 total_bytes, struct resource_entry *out_res_entry)
{
xmlCharEncodingHandler *encoding_handler;
(wim_info != NULL && image >= 1 &&
image <= wim_info->num_images));
- start_offset = ftello(out);
+ start_offset = filedes_offset(out_fd);
if (start_offset == -1)
return WIMLIB_ERR_WRITE;
/* 2 bytes endianness marker for UTF-16LE. This is _required_ for WIM
* XML data. */
- if ((putc(0xff, out)) == EOF || (putc(0xfe, out) == EOF)) {
+ static u8 bom[2] = {0xff, 0xfe};
+ if (full_write(out_fd, bom, 2) != 2) {
ERROR_WITH_ERRNO("Error writing XML data");
return WIMLIB_ERR_WRITE;
}
goto out;
}
- out_buffer = xmlOutputBufferCreateFile(out, encoding_handler);
+ out_buffer = xmlOutputBufferCreateFd(out_fd, encoding_handler);
if (!out_buffer) {
ERROR("Failed to allocate xmlOutputBuffer");
ret = WIMLIB_ERR_NOMEM;
DEBUG("Ended XML document");
- /* Call xmlFreeTextWriter() before ftello() because the former will
- * flush the file stream. */
- xmlFreeTextWriter(writer);
- writer = NULL;
-
- end_offset = ftello(out);
+ end_offset = filedes_offset(out_fd);
if (end_offset == -1) {
ret = WIMLIB_ERR_WRITE;
} else {
if (!name || !*name)
return false;
for (int i = 1; i <= w->hdr.image_count; i++)
- if (tstrcmp(w->wim_info->images[i - 1].name, name) == 0)
+ if (!tstrcmp(w->wim_info->images[i - 1].name, name))
return true;
return false;
}
WIMLIBAPI int
wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
{
- size_t bytes_written;
+ size_t size;
+ void *buf;
+ int ret;
- if (!w->xml_data)
- return WIMLIB_ERR_INVALID_PARAM;
- bytes_written = fwrite(w->xml_data, 1, w->hdr.xml_res_entry.size, fp);
- if (bytes_written != w->hdr.xml_res_entry.size) {
+ size = w->hdr.xml_res_entry.size;
+ if (sizeof(size_t) < sizeof(u64))
+ if (size != w->hdr.xml_res_entry.size)
+ return WIMLIB_ERR_INVALID_PARAM;
+
+ buf = MALLOC(size);
+ if (!buf)
+ return WIMLIB_ERR_NOMEM;
+
+ if (full_pread(w->in_fd,
+ buf,
+ w->hdr.xml_res_entry.size,
+ w->hdr.xml_res_entry.offset) != w->hdr.xml_res_entry.size)
+ {
+ ERROR_WITH_ERRNO("Error reading XML data");
+ ret = WIMLIB_ERR_READ;
+ goto out_free_buf;
+ }
+
+ if (fwrite(buf, 1, size, fp) != size) {
ERROR_WITH_ERRNO("Failed to extract XML data");
- return WIMLIB_ERR_WRITE;
+ ret = WIMLIB_ERR_WRITE;
+ } else {
+ ret = 0;
}
- return 0;
+out_free_buf:
+ FREE(buf);
+ return ret;
}
/* Sets the name of an image in the WIM. */
git://wimlib.net / wimlib / blobdiff