X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fxml.c;h=ff7925204017f869fca3b9f5a5169fd80c6b5951;hb=e1d56fdf58008263a04c3b61453dddaee51a9ea1;hp=8132671a29dd6313ef2a680ff0f69584661efeae;hpb=7c08b0b067f48e80226e6b5466fd95feb43139e6;p=wimlib

diff --git a/src/xml.c b/src/xml.c
index 8132671a..ff792520 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -10,16 +10,16 @@
  * This file is part of wimlib, a library for working with WIM files.
  *
  * wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
+ * terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option)
  * any later version.
  *
  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
  * details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
@@ -27,6 +27,7 @@
 #include "dentry.h"
 #include "xml.h"
 #include "timestamp.h"
+#include "lookup_table.h"
 #include <string.h>
 #include <time.h>
 #include <libxml/parser.h>
@@ -74,7 +75,10 @@ struct image_info {
 	char *description;
 	char  *display_name;
 	char  *display_description;
-	char  *flags;
+	union {
+		char  *flags;
+		struct lookup_table *lookup_table;
+	};
 };
 
 
@@ -814,13 +818,16 @@ static int clone_windows_info(const struct windows_info *old,
 		return WIMLIB_ERR_NOMEM;
 	if (old->system_root && !(new->system_root = STRDUP(old->system_root)))
 		return WIMLIB_ERR_NOMEM;
+	if (old->windows_version_exists) {
+		new->windows_version_exists = true;
+		memcpy(&new->windows_version, &old->windows_version,
+		       sizeof(old->windows_version));
+	}
 	return 0;
 }
 
 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;
@@ -859,7 +866,11 @@ static int clone_image_info(const struct image_info *old, struct image_info *new
  *
  * @dest_image_name and @dest_image_description are ignored if they are NULL;
  * otherwise, they are used to override the image name and/or image description
- * from the XML data in the source WIM file. */
+ * from the XML data in the source WIM file.
+ *
+ * On failure, WIMLIB_ERR_NOMEM is returned and no changes are made.  Otherwise,
+ * 0 is returned and the WIM information at *new_wim_info_p is modified.
+ */
 int xml_export_image(const struct wim_info *old_wim_info, 
 		     int image, 
 		     struct wim_info **new_wim_info_p, 
@@ -869,14 +880,11 @@ 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);
 
 	wimlib_assert(image >= 1 && image <= old_wim_info->num_images);
 
-
 	if (*new_wim_info_p) {
 		new_wim_info = *new_wim_info_p;
 	} else {
@@ -961,36 +969,113 @@ void xml_set_memory_allocator(void *(*malloc_func)(size_t),
 }
 #endif
 
+static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
+{
+	struct image_info *info = arg; 
+	struct lookup_table *lookup_table = info->lookup_table;
+	const struct inode *inode = dentry->d_inode;
+	struct lookup_table_entry *lte;
+
+	/* Update directory count and file count.
+	 *
+	 * Each dentry counts as either a file or a directory, but not both.
+	 * The root directory is an exception: it is not counted.
+	 *
+	 * Symbolic links and junction points (and presumably other reparse
+	 * points) count as regular files.  This is despite the fact that
+	 * junction points have FILE_ATTRIBUTE_DIRECTORY set.
+	 */
+	if (dentry_is_root(dentry))
+		return 0;
+
+	if (inode_is_directory(inode))
+		info->dir_count++;
+	else
+		info->file_count++;
+
+	/* 
+	 * Update total bytes and hard link bytes.
+	 *
+	 * Unfortunately there are some inconsistencies/bugs in the way this is
+	 * done.
+	 *
+	 * If there are no alternate data streams in the image, the "total
+	 * bytes" is the sum of the size of the un-named data stream of each
+	 * inode times the link count of that inode.  In other words, it would
+	 * be the total number of bytes of regular files you would have if you
+	 * extracted the full image without any hard-links.  The "hard link
+	 * bytes" is equal to the "total bytes" minus the size of the un-named
+	 * data stream of each inode.  In other words, the "hard link bytes"
+	 * counts the size of the un-named data stream for all the links to each
+	 * inode except the first one.
+	 *
+	 * Reparse points and directories don't seem to be counted in either the
+	 * total bytes or the hard link bytes.
+	 *
+	 * And now we get to the most confusing part, the alternate data
+	 * streams.  They are not counted in the "total bytes".  However, if the
+	 * link count of an inode with alternate data streams is 2 or greater,
+	 * the size of all the alternate data streams is included in the "hard
+	 * link bytes", and this size is multiplied by the link count (NOT one
+	 * less than the link count).
+	 */
+	lte = inode_unnamed_lte(inode, info->lookup_table);
+	if (lte) {
+		info->total_bytes += wim_resource_size(lte);
+		if (!dentry_is_first_in_inode(dentry))
+			info->hard_link_bytes += wim_resource_size(lte);
+	}
+
+	if (inode->link_count >= 2 && dentry_is_first_in_inode(dentry)) {
+		for (unsigned i = 0; i < inode->num_ads; i++) {
+			if (inode->ads_entries[i].stream_name_len) {
+				lte = inode_stream_lte(inode, i + 1, lookup_table);
+				if (lte) {
+					info->hard_link_bytes += inode->link_count *
+								 wim_resource_size(lte);
+				}
+			}
+		}
+	}
+	return 0;
+}
+
 void xml_update_image_info(WIMStruct *w, int image)
 {
 	struct image_info *image_info;
 	struct dentry *root; 
+	char *flags_save;
 
 	DEBUG("Updating the image info for image %d", image);
 
 	image_info = &w->wim_info->images[image - 1];
-	root = w->image_metadata[image - 1].root_dentry;
 
-	calculate_dir_tree_statistics(root, w->lookup_table, 
-				      &image_info->dir_count,
-				      &image_info->file_count, 
-				      &image_info->total_bytes,
-				      &image_info->hard_link_bytes);
+	image_info->file_count      = 0;
+	image_info->dir_count       = 0;
+	image_info->total_bytes     = 0;
+	image_info->hard_link_bytes = 0;
 
+	flags_save = image_info->flags;
+	image_info->lookup_table = w->lookup_table;
+
+	for_dentry_in_tree(w->image_metadata[image - 1].root_dentry,
+			   calculate_dentry_statistics,
+			   image_info);
+			   
+	image_info->lookup_table = NULL;
+	image_info->flags = flags_save;
 	image_info->last_modification_time = get_wim_timestamp();
 }
 
 /* Adds an image to the XML information. */
-int xml_add_image(WIMStruct *w, struct dentry *root_dentry, const char *name, 
-		  const char *description, const char *flags_element)
+int xml_add_image(WIMStruct *w, const char *name)
 {
 	struct wim_info *wim_info;
 	struct image_info *image_info;
 
 	wimlib_assert(name);
 
-	DEBUG("Adding image: name = %s, description = %s, flags_element = %s",
-	      name, description, flags_element);
+	DEBUG("Adding image: name = %s", name);
 
 	/* If this is the first image, allocate the struct wim_info.  Otherwise
 	 * use the existing struct wim_info. */
@@ -1013,11 +1098,6 @@ int xml_add_image(WIMStruct *w, struct dentry *root_dentry, const char *name,
 	if (!(image_info->name = STRDUP(name)))
 		goto out_destroy_image_info;
 
-	if (description && !(image_info->description = STRDUP(description)))
-		goto out_destroy_image_info;
-	if (flags_element && !(image_info->flags = STRDUP(flags_element)))
-		goto out_destroy_image_info;
-		
 	w->wim_info = wim_info;
 	image_info->index = wim_info->num_images;
 	image_info->creation_time = get_wim_timestamp();
@@ -1042,14 +1122,15 @@ void print_image_info(const struct wim_info *wim_info, int image)
 	uint i;
 	const struct image_info *image_info;
 	const char *desc;
-	time_t ctime;
-	time_t mtime;
 
 
 	if (image == WIM_ALL_IMAGES) {
 		for (i = 1; i <= wim_info->num_images; i++)
 			print_image_info(wim_info, i);
 	} else {
+		time_t time;
+		char *p;
+
 		image_info = &wim_info->images[image - 1];
 
 		printf("Index:                  %"PRIu64"\n", 
@@ -1082,11 +1163,17 @@ void print_image_info(const struct wim_info *wim_info, int image)
 		printf("Hard Link Bytes:        %"PRIu64"\n", 
 				image_info->hard_link_bytes);
 
-		ctime = wim_timestamp_to_unix(image_info->creation_time);
-		mtime = wim_timestamp_to_unix(image_info->last_modification_time);
+		time = wim_timestamp_to_unix(image_info->creation_time);
+		p = asctime(gmtime(&time));
+		*(strrchr(p, '\n')) = '\0';
+
+		printf("Creation Time:          %s UTC\n", p);
 
-		printf("Creation Time:          %s", asctime(localtime(&ctime)));
-		printf("Last Modification Time: %s", asctime(localtime(&mtime)));
+		time = wim_timestamp_to_unix(image_info->last_modification_time);
+		p = asctime(gmtime(&time));
+		*(strrchr(p, '\n')) = '\0';
+
+		printf("Last Modification Time: %s UTC\n", p);
 		if (image_info->windows_info_exists)
 			print_windows_info(&image_info->windows_info);
 		if (image_info->flags)
@@ -1112,23 +1199,22 @@ int read_xml_data(FILE *fp, const struct resource_entry *res, u8 **xml_data_ret,
 	if (resource_is_compressed(res)) {
 		ERROR("XML data is supposed to be uncompressed");
 		ret = WIMLIB_ERR_XML;
-		goto err0;
+		goto out_cleanup_parser;
 	}
 	if (res->size < 2) {
 		ERROR("XML data must be at least 2 bytes");
 		ret = WIMLIB_ERR_XML;
-		goto err0;
+		goto out_cleanup_parser;
 	}
 
 	xml_data = MALLOC(res->size + 2);
 	if (!xml_data) {
 		ret = WIMLIB_ERR_NOMEM;
-		goto err0;
+		goto out_cleanup_parser;
 	}
-	ret = read_full_resource(fp, res->size, res->size, res->offset, 
-				 WIM_COMPRESSION_TYPE_NONE, xml_data);
+	ret = read_uncompressed_resource(fp, res->offset, res->size, xml_data);
 	if (ret != 0)
-		goto err1;
+		goto out_free_xml_data;
 
 	xml_data[res->size] = 0;
 	xml_data[res->size + 1] = 0;
@@ -1141,7 +1227,7 @@ int read_xml_data(FILE *fp, const struct resource_entry *res, u8 **xml_data_ret,
 	if (!doc) {
 		ERROR("Failed to parse XML data");
 		ret = WIMLIB_ERR_XML;
-		goto err1;
+		goto out_free_xml_data;
 	}
 
 	DEBUG("Constructing WIM information structure from XML tree.");
@@ -1150,19 +1236,19 @@ int read_xml_data(FILE *fp, const struct resource_entry *res, u8 **xml_data_ret,
 	if (!root) {
 		ERROR("Empty XML document");
 		ret = WIMLIB_ERR_XML;
-		goto err2;
+		goto out_free_doc;
 	}
 
 	if (!node_is_element(root) || !node_name_is(root, "WIM")) {
 		ERROR("Expected <WIM> for the root XML element (found <%s>)",
 		      root->name);
 		ret = WIMLIB_ERR_XML;
-		goto err2;
+		goto out_free_doc;
 	}
 
 	ret = xml_read_wim_info(root, info_ret);
 	if (ret != 0)
-		goto err2;
+		goto out_free_doc;
 
 	DEBUG("Freeing XML tree.");
 
@@ -1170,11 +1256,11 @@ int read_xml_data(FILE *fp, const struct resource_entry *res, u8 **xml_data_ret,
 	xmlCleanupParser();
 	*xml_data_ret = xml_data;
 	return 0;
-err2:
+out_free_doc:
 	xmlFreeDoc(doc);
-err1:
+out_free_xml_data:
 	FREE(xml_data);
-err0:
+out_cleanup_parser:
 	xmlCleanupParser();
 	return ret;
 }
@@ -1361,6 +1447,9 @@ WIMLIBAPI int wimlib_set_image_name(WIMStruct *w, int image, const char *name)
 
 	DEBUG("Setting the name of image %d to %s", image, name);
 
+	if (!w)
+		return WIMLIB_ERR_INVALID_PARAM;
+
 	if (!name || !*name) {
 		ERROR("Must specify a non-empty string for the image name");
 		return WIMLIB_ERR_INVALID_PARAM;
@@ -1398,6 +1487,9 @@ WIMLIBAPI int wimlib_set_image_descripton(WIMStruct *w, int image,
 
 	DEBUG("Setting the description of image %d to %s", image, description);
 
+	if (!w)
+		return WIMLIB_ERR_INVALID_PARAM;
+
 	if (image < 1 || image > w->hdr.image_count) {
 		ERROR("%d is not a valid image", image);
 		return WIMLIB_ERR_INVALID_IMAGE;
@@ -1415,3 +1507,28 @@ WIMLIBAPI int wimlib_set_image_descripton(WIMStruct *w, int image,
 	w->wim_info->images[image - 1].description = p;
 	return 0;
 }
+
+WIMLIBAPI int wimlib_set_image_flags(WIMStruct *w, int image,
+				     const char *flags)
+{
+	char *p;
+
+	DEBUG("Setting the flags of image %d to %s", image, flags);
+
+	if (image < 1 || image > w->hdr.image_count) {
+		ERROR("%d is not a valid image", image);
+		return WIMLIB_ERR_INVALID_IMAGE;
+	}
+	if (flags) {
+		p = STRDUP(flags);
+		if (!p) {
+			ERROR("Out of memory");
+			return WIMLIB_ERR_NOMEM;
+		}
+	} else {
+		p = NULL;
+	}
+	FREE(w->wim_info->images[image - 1].flags);
+	w->wim_info->images[image - 1].flags = p;
+	return 0;
+}