* along with wimlib; if not, see http://www.gnu.org/licenses/.
*/
-#include "dentry.h"
-#include "lookup_table.h"
-#include "timestamp.h"
-#include "wimlib_internal.h"
-#include "xml.h"
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
-#include <string.h>
+#include "wimlib/dentry.h"
+#include "wimlib/encoding.h"
+#include "wimlib/error.h"
+#include "wimlib/file_io.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/metadata.h"
+#include "wimlib/resource.h"
+#include "wimlib/timestamp.h"
+#include "wimlib/xml.h"
+
+#include <libxml/encoding.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlwriter.h>
-#include <libxml/encoding.h>
#include <limits.h>
+#include <string.h>
+#include <unistd.h>
/* Structures used to form an in-memory representation of the XML data (other
* than the raw parse tree from libxml). */
tchar *display_name;
tchar *display_description;
tchar *flags;
+ struct wim_lookup_table *lookup_table; /* temporary field */
+};
+
+/* A struct wim_info structure corresponds to the entire XML data for a WIM file. */
+struct wim_info {
+ u64 total_bytes;
+ int num_images;
+ /* Array of `struct image_info's, one for each image in the WIM that is
+ * mentioned in the XML data. */
+ struct image_info *images;
};
struct xml_string_spec {
};
#undef ELEM
+u64
+wim_info_get_total_bytes(const struct wim_info *info)
+{
+ if (info)
+ return info->total_bytes;
+ else
+ return 0;
+}
+
+u64
+wim_info_get_image_hard_link_bytes(const struct wim_info *info, int image)
+{
+ if (info)
+ return info->images[image - 1].hard_link_bytes;
+ else
+ return 0;
+}
+
+u64
+wim_info_get_image_total_bytes(const struct wim_info *info, int image)
+{
+ if (info)
+ return info->images[image - 1].total_bytes;
+ else
+ return 0;
+}
+
+unsigned
+wim_info_get_num_images(const struct wim_info *info)
+{
+ if (info)
+ return info->num_images;
+ else
+ return 0;
+}
+
+/* Architecture constants are from w64 mingw winnt.h */
+#define PROCESSOR_ARCHITECTURE_INTEL 0
+#define PROCESSOR_ARCHITECTURE_MIPS 1
+#define PROCESSOR_ARCHITECTURE_ALPHA 2
+#define PROCESSOR_ARCHITECTURE_PPC 3
+#define PROCESSOR_ARCHITECTURE_SHX 4
+#define PROCESSOR_ARCHITECTURE_ARM 5
+#define PROCESSOR_ARCHITECTURE_IA64 6
+#define PROCESSOR_ARCHITECTURE_ALPHA64 7
+#define PROCESSOR_ARCHITECTURE_MSIL 8
+#define PROCESSOR_ARCHITECTURE_AMD64 9
+#define PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 10
/* Returns a statically allocated string that is a string representation of the
* architecture number. */
get_arch(int arch)
{
switch (arch) {
- case 0:
+ case PROCESSOR_ARCHITECTURE_INTEL:
return T("x86");
- case 6:
+ case PROCESSOR_ARCHITECTURE_MIPS:
+ return T("MIPS");
+ case PROCESSOR_ARCHITECTURE_ARM:
+ return T("ARM");
+ case PROCESSOR_ARCHITECTURE_IA64:
return T("ia64");
- case 9:
+ case PROCESSOR_ARCHITECTURE_AMD64:
return T("x86_64");
- /* XXX Are there other arch values? */
default:
return T("unknown");
}
}
if (!image_info->name) {
tchar *empty_name;
- WARNING("Image with index %d has no name", image_info->index);
- empty_name = TMALLOC(1);
+ /*WARNING("Image with index %d has no name", image_info->index);*/
+ empty_name = MALLOC(sizeof(tchar));
if (!empty_name)
return WIMLIB_ERR_NOMEM;
*empty_name = T('\0');
}
size_t
-xml_get_max_image_name_len(const WIMStruct *w)
+xml_get_max_image_name_len(const WIMStruct *wim)
{
size_t max_len = 0;
- if (w->wim_info) {
- for (int i = 0; i < w->wim_info->num_images; i++) {
- size_t len = tstrlen(w->wim_info->images[i].name);
- if (len > max_len)
- max_len = len;
- }
- }
+ for (u32 i = 0; i < wim->hdr.image_count; i++)
+ max_len = max(max_len, tstrlen(wim->wim_info->images[i].name));
return max_len;
}
* link bytes", and this size is multiplied by the link count (NOT one
* less than the link count).
*/
- lte = inode_unnamed_lte_resolved(inode);
+ lte = inode_unnamed_lte(inode, info->lookup_table);
if (lte) {
info->total_bytes += wim_resource_size(lte);
if (!dentry_is_first_in_inode(dentry))
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_resolved(inode, i + 1);
+ lte = inode_stream_lte(inode, i + 1, info->lookup_table);
if (lte) {
info->hard_link_bytes += inode->i_nlink *
wim_resource_size(lte);
* But, see calculate_dentry_statistics().
*/
void
-xml_update_image_info(WIMStruct *w, int image)
+xml_update_image_info(WIMStruct *wim, int image)
{
struct image_info *image_info;
DEBUG("Updating the image info for image %d", image);
- image_info = &w->wim_info->images[image - 1];
+ image_info = &wim->wim_info->images[image - 1];
image_info->file_count = 0;
image_info->dir_count = 0;
image_info->total_bytes = 0;
image_info->hard_link_bytes = 0;
+ image_info->lookup_table = wim->lookup_table;
- for_dentry_in_tree(w->image_metadata[image - 1]->root_dentry,
+ for_dentry_in_tree(wim->image_metadata[image - 1]->root_dentry,
calculate_dentry_statistics,
image_info);
image_info->last_modification_time = get_wim_timestamp();
/* Adds an image to the XML information. */
int
-xml_add_image(WIMStruct *w, const tchar *name)
+xml_add_image(WIMStruct *wim, const tchar *name)
{
struct wim_info *wim_info;
struct image_info *image_info;
/* If this is the first image, allocate the struct wim_info. Otherwise
* use the existing struct wim_info. */
- if (w->wim_info) {
- wim_info = w->wim_info;
+ if (wim->wim_info) {
+ wim_info = wim->wim_info;
} else {
wim_info = CALLOC(1, sizeof(struct wim_info));
if (!wim_info)
if (!(image_info->name = TSTRDUP(name)))
goto out_destroy_image_info;
- w->wim_info = wim_info;
+ wim->wim_info = wim_info;
image_info->index = wim_info->num_images;
image_info->creation_time = get_wim_timestamp();
- xml_update_image_info(w, image_info->index);
+ xml_update_image_info(wim, image_info->index);
return 0;
out_destroy_image_info:
destroy_image_info(image_info);
wim_info->num_images--;
out_free_wim_info:
- if (wim_info != w->wim_info)
+ if (wim_info != wim->wim_info)
FREE(wim_info);
return WIMLIB_ERR_NOMEM;
}
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);
}
void
-libxml_global_init()
+libxml_global_init(void)
{
xmlInitParser();
xmlInitCharEncodingHandlers();
}
void
-libxml_global_cleanup()
+libxml_global_cleanup(void)
{
xmlCleanupParser();
xmlCleanupCharEncodingHandlers();
}
-/*
- * Reads the XML data from a WIM file.
- */
+/* Reads the XML data from a WIM file. */
int
-read_xml_data(filedes_t in_fd,
- const struct resource_entry *res_entry,
- struct wim_info **info_ret)
+read_wim_xml_data(WIMStruct *wim)
{
- utf16lechar *xml_data;
+ void *buf;
+ u8 *xml_data;
xmlDoc *doc;
xmlNode *root;
int ret;
+ const struct resource_entry *res_entry;
- DEBUG("XML data is %"PRIu64" bytes at offset %"PRIu64"",
- (u64)res_entry->size, res_entry->offset);
-
- if (resource_is_compressed(res_entry)) {
- ERROR("XML data is supposed to be uncompressed");
- ret = WIMLIB_ERR_XML;
- goto out;
- }
+ res_entry = &wim->hdr.xml_res_entry;
- if (res_entry->size < 2) {
- ERROR("XML data must be at least 2 bytes long");
- ret = WIMLIB_ERR_XML;
- goto out;
- }
+ DEBUG("Reading XML data: %"PRIu64" bytes at offset %"PRIu64"",
+ (u64)res_entry->size, res_entry->offset);
- xml_data = MALLOC(res_entry->size + 3);
- if (!xml_data) {
- ret = WIMLIB_ERR_NOMEM;
+ ret = res_entry_to_data(res_entry, wim, &buf);
+ if (ret)
goto out;
- }
-
- 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;
- ((u8*)xml_data)[res_entry->size + 1] = 0;
- ((u8*)xml_data)[res_entry->size + 2] = 0;
-
- DEBUG("Parsing XML using libxml2 to create XML tree");
-
- doc = xmlReadMemory((const char *)xml_data,
- res_entry->size, "noname.xml", "UTF-16", 0);
+ xml_data = buf;
+ doc = xmlReadMemory((const char *)xml_data, res_entry->original_size,
+ NULL, "UTF-16LE", 0);
if (!doc) {
ERROR("Failed to parse XML data");
ret = WIMLIB_ERR_XML;
goto out_free_xml_data;
}
- DEBUG("Constructing WIM information structure from XML tree.");
-
root = xmlDocGetRootElement(doc);
- if (!root) {
- ERROR("WIM XML data is an empty XML document");
+ if (!root || !node_is_element(root) || !node_name_is(root, "WIM")) {
+ ERROR("WIM XML data is invalid");
ret = WIMLIB_ERR_XML;
goto out_free_doc;
}
- if (!node_is_element(root) || !node_name_is(root, "WIM")) {
- ERROR("Expected <WIM> for the root XML element");
- ret = WIMLIB_ERR_XML;
- goto out_free_doc;
- }
- ret = xml_read_wim_info(root, info_ret);
+ ret = xml_read_wim_info(root, &wim->wim_info);
out_free_doc:
- DEBUG("Freeing XML tree.");
xmlFreeDoc(doc);
out_free_xml_data:
FREE(xml_data);
return ret;
}
-#define CHECK_RET ({ if (ret < 0) { \
- ERROR("Error writing XML data"); \
- ret = WIMLIB_ERR_WRITE; \
- goto out_free_text_writer; \
- } })
-
-/*
- * Writes XML data to a WIM file.
+/* Prepares an in-memory buffer containing the UTF-16LE XML data for a WIM file.
*
- * If @total_bytes is non-zero, it specifies what to write to the TOTALBYTES
- * element in the XML data. If zero, TOTALBYTES is given the default value of
- * the offset of the XML data.
+ * total_bytes is the number to write in <TOTALBYTES>, or
+ * WIM_TOTALBYTES_USE_EXISTING to use the existing value in memory, or
+ * WIM_TOTALBYTES_OMIT to omit <TOTALBYTES> entirely.
*/
-int
-write_xml_data(const struct wim_info *wim_info, int image, int out_fd,
- u64 total_bytes, struct resource_entry *out_res_entry)
+static int
+prepare_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
+ u8 **xml_data_ret, size_t *xml_len_ret)
{
xmlCharEncodingHandler *encoding_handler;
- xmlOutputBuffer *out_buffer;
+ xmlBuffer *buf;
+ xmlOutputBuffer *outbuf;
xmlTextWriter *writer;
int ret;
- off_t start_offset;
- off_t end_offset;
-
- wimlib_assert(image == WIMLIB_ALL_IMAGES ||
- (wim_info != NULL && image >= 1 &&
- image <= wim_info->num_images));
-
- start_offset = filedes_offset(out_fd);
- if (start_offset == -1)
- return WIMLIB_ERR_WRITE;
-
- DEBUG("Writing XML data for image %d at offset %"PRIu64,
- image, start_offset);
-
- /* 2 bytes endianness marker for UTF-16LE. This is _required_ for WIM
- * XML data. */
- 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;
- }
+ int first, last;
+ const xmlChar *content;
+ int len;
+ u8 *xml_data;
+ size_t xml_len;
- /* The contents of the <TOTALBYTES> element in the XML data, under the
- * <WIM> element (not the <IMAGE> element), is for non-split WIMs the
- * size of the WIM file excluding the XML data and integrity table.
- * This should be equal to the current position in the output stream,
- * since the XML data and integrity table are the last elements of the
- * WIM.
- *
- * For split WIMs, <TOTALBYTES> takes into account the entire WIM, not
- * just the current part. In that case, @total_bytes should be passed
- * in to this function. */
- if (total_bytes == 0)
- total_bytes = start_offset;
+ /* Open an xmlTextWriter that writes to an in-memory buffer using
+ * UTF-16LE encoding. */
- /* The encoding of the XML data must be UTF-16LE. */
encoding_handler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF16LE);
if (!encoding_handler) {
ERROR("Failed to get XML character encoding handler for UTF-16LE");
goto out;
}
- out_buffer = xmlOutputBufferCreateFd(out_fd, encoding_handler);
- if (!out_buffer) {
- ERROR("Failed to allocate xmlOutputBuffer");
+ buf = xmlBufferCreate();
+ if (!buf) {
+ ERROR("Failed to create xmlBuffer");
ret = WIMLIB_ERR_NOMEM;
goto out;
}
- writer = xmlNewTextWriter(out_buffer);
+ outbuf = xmlOutputBufferCreateBuffer(buf, encoding_handler);
+ if (!outbuf) {
+ ERROR("Failed to allocate xmlOutputBuffer");
+ ret = WIMLIB_ERR_NOMEM;
+ goto out_buffer_free;
+ }
+
+ writer = xmlNewTextWriter(outbuf);
if (!writer) {
ERROR("Failed to allocate xmlTextWriter");
ret = WIMLIB_ERR_NOMEM;
goto out_output_buffer_close;
}
- DEBUG("Writing <WIM> element");
+ /* Write the XML document. */
ret = xmlTextWriterStartElement(writer, "WIM");
- CHECK_RET;
-
- ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
- total_bytes);
- CHECK_RET;
-
- if (wim_info != NULL) {
- int first, last;
- if (image == WIMLIB_ALL_IMAGES) {
- first = 1;
- last = wim_info->num_images;
- } else {
- first = image;
- last = image;
+ if (ret < 0)
+ goto out_write_error;
+
+ /* The contents of the <TOTALBYTES> element in the XML data, under the
+ * <WIM> element (not the <IMAGE> element), is for non-split WIMs the
+ * size of the WIM file excluding the XML data and integrity table.
+ * For split WIMs, <TOTALBYTES> takes into account the entire WIM, not
+ * just the current part. */
+ if (total_bytes != WIM_TOTALBYTES_OMIT) {
+ if (total_bytes == WIM_TOTALBYTES_USE_EXISTING) {
+ if (wim->wim_info)
+ total_bytes = wim->wim_info->total_bytes;
+ else
+ total_bytes = 0;
}
- DEBUG("Writing %d <IMAGE> elements", last - first + 1);
- for (int i = first; i <= last; i++) {
- ret = xml_write_image_info(writer, &wim_info->images[i - 1]);
- if (ret) {
- CHECK_RET;
- goto out_free_text_writer;
- }
+ ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES",
+ "%"PRIu64, total_bytes);
+ if (ret < 0)
+ goto out_write_error;
+ }
+
+ if (image == WIMLIB_ALL_IMAGES) {
+ first = 1;
+ last = wim->hdr.image_count;
+ } else {
+ first = image;
+ last = image;
+ }
+
+ for (int i = first; i <= last; i++) {
+ ret = xml_write_image_info(writer, &wim->wim_info->images[i - 1]);
+ if (ret) {
+ if (ret < 0)
+ goto out_write_error;
+ goto out_free_text_writer;
}
}
ret = xmlTextWriterEndElement(writer);
- CHECK_RET;
+ if (ret < 0)
+ goto out_write_error;
ret = xmlTextWriterEndDocument(writer);
- CHECK_RET;
+ if (ret < 0)
+ goto out_write_error;
- DEBUG("Ended XML document");
+ ret = xmlTextWriterFlush(writer);
+ if (ret < 0)
+ goto out_write_error;
- end_offset = filedes_offset(out_fd);
- if (end_offset == -1) {
- ret = WIMLIB_ERR_WRITE;
- } else {
- ret = 0;
- out_res_entry->offset = start_offset;
- out_res_entry->size = end_offset - start_offset;
- out_res_entry->original_size = end_offset - start_offset;
- out_res_entry->flags = WIM_RESHDR_FLAG_METADATA;
+ /* Retrieve the buffer into which the document was written. */
+
+ content = xmlBufferContent(buf);
+ len = xmlBufferLength(buf);
+
+ /* Copy the data into a new buffer, and prefix it with the UTF-16LE BOM
+ * (byte order mark), which is required by MS's software to understand
+ * the data. */
+
+ xml_len = len + 2;
+ xml_data = MALLOC(xml_len);
+ if (!xml_data) {
+ ret = WIMLIB_ERR_NOMEM;
+ goto out_free_text_writer;
}
+ xml_data[0] = 0xff;
+ xml_data[1] = 0xfe;
+ memcpy(&xml_data[2], content, len);
+
+ /* Clean up libxml objects and return success. */
+ *xml_data_ret = xml_data;
+ *xml_len_ret = xml_len;
+ ret = 0;
out_free_text_writer:
- /* xmlFreeTextWriter will free the attached xmlOutputBuffer. */
+ /* xmlFreeTextWriter will free the attached xmlOutputBuffer. */
xmlFreeTextWriter(writer);
- out_buffer = NULL;
+ goto out_buffer_free;
out_output_buffer_close:
- if (out_buffer != NULL)
- xmlOutputBufferClose(out_buffer);
+ xmlOutputBufferClose(outbuf);
+out_buffer_free:
+ xmlBufferFree(buf);
out:
- if (ret == 0)
- DEBUG("Successfully wrote XML data");
return ret;
+
+out_write_error:
+ ERROR("Error writing XML data");
+ ret = WIMLIB_ERR_WRITE;
+ goto out_free_text_writer;
}
-/* Returns the name of the specified image. */
+/* Writes the XML data to a WIM file. */
+int
+write_wim_xml_data(WIMStruct *wim, int image, u64 total_bytes,
+ struct resource_entry *out_res_entry,
+ int write_resource_flags)
+{
+ int ret;
+ u8 *xml_data;
+ size_t xml_len;
+
+ DEBUG("Writing WIM XML data (image=%d, offset=%"PRIu64")",
+ image, total_bytes, wim->out_fd.offset);
+
+ ret = prepare_wim_xml_data(wim, image, total_bytes,
+ &xml_data, &xml_len);
+ if (ret)
+ return ret;
+
+ /* Write the XML data uncompressed. Although wimlib can handle
+ * compressed XML data, MS software cannot. */
+ ret = write_wim_resource_from_buffer(xml_data,
+ xml_len,
+ WIM_RESHDR_FLAG_METADATA,
+ &wim->out_fd,
+ WIMLIB_COMPRESSION_TYPE_NONE,
+ out_res_entry,
+ NULL,
+ write_resource_flags);
+ FREE(xml_data);
+ return ret;
+}
+
+/* API function documented in wimlib.h */
WIMLIBAPI const tchar *
-wimlib_get_image_name(const WIMStruct *w, int image)
+wimlib_get_image_name(const WIMStruct *wim, int image)
{
- if (image < 1 || image > w->hdr.image_count)
+ if (image < 1 || image > wim->hdr.image_count)
return NULL;
- return w->wim_info->images[image - 1].name;
+ return wim->wim_info->images[image - 1].name;
}
-/* Returns the description of the specified image. */
+/* API function documented in wimlib.h */
WIMLIBAPI const tchar *
-wimlib_get_image_description(const WIMStruct *w, int image)
+wimlib_get_image_description(const WIMStruct *wim, int image)
{
- if (image < 1 || image > w->hdr.image_count)
+ if (image < 1 || image > wim->hdr.image_count)
return NULL;
- return w->wim_info->images[image - 1].description;
+ return wim->wim_info->images[image - 1].description;
}
-/* Determines if an image name is already used by some image in the WIM. */
+/* API function documented in wimlib.h */
WIMLIBAPI bool
-wimlib_image_name_in_use(const WIMStruct *w, const tchar *name)
+wimlib_image_name_in_use(const WIMStruct *wim, const tchar *name)
{
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))
+ for (int i = 1; i <= wim->hdr.image_count; i++)
+ if (!tstrcmp(wim->wim_info->images[i - 1].name, name))
return true;
return false;
}
-/* Extracts the raw XML data to a file stream. */
+/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
+wimlib_extract_xml_data(WIMStruct *wim, FILE *fp)
{
size_t size;
void *buf;
int ret;
- 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 (!wim->filename)
+ return WIMLIB_ERR_INVALID_PARAM;
- 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;
- }
+ ret = res_entry_to_data(&wim->hdr.xml_res_entry, wim, &buf);
+ if (ret)
+ goto out;
+ size = wim->hdr.xml_res_entry.original_size;
if (fwrite(buf, 1, size, fp) != size) {
ERROR_WITH_ERRNO("Failed to extract XML data");
ret = WIMLIB_ERR_WRITE;
- } else {
- ret = 0;
+ goto out_free_buf;
}
+
+ ret = 0;
out_free_buf:
FREE(buf);
+out:
return ret;
}
-/* Sets the name of an image in the WIM. */
+/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_set_image_name(WIMStruct *w, int image, const tchar *name)
+wimlib_set_image_name(WIMStruct *wim, int image, const tchar *name)
{
tchar *p;
int i;
+ int ret;
DEBUG("Setting the name of image %d to %"TS, image, name);
- if (!name || !*name) {
- ERROR("Must specify a non-empty string for the image name");
- return WIMLIB_ERR_INVALID_PARAM;
- }
+ ret = can_modify_wim(wim);
+ if (ret)
+ return ret;
+
+ if (name == NULL)
+ name = T("");
- if (image < 1 || image > w->hdr.image_count) {
+ if (image < 1 || image > wim->hdr.image_count) {
ERROR("%d is not a valid image", image);
return WIMLIB_ERR_INVALID_IMAGE;
}
- for (i = 1; i <= w->hdr.image_count; i++) {
+ for (i = 1; i <= wim->hdr.image_count; i++) {
if (i == image)
continue;
- if (tstrcmp(w->wim_info->images[i - 1].name, name) == 0) {
+ if (!tstrcmp(wim->wim_info->images[i - 1].name, name)) {
ERROR("The name \"%"TS"\" is already in use in the WIM!",
name);
return WIMLIB_ERR_IMAGE_NAME_COLLISION;
if (!p)
return WIMLIB_ERR_NOMEM;
- FREE(w->wim_info->images[image - 1].name);
- w->wim_info->images[image - 1].name = p;
+ FREE(wim->wim_info->images[image - 1].name);
+ wim->wim_info->images[image - 1].name = p;
return 0;
}
static int
-do_set_image_info_str(WIMStruct *w, int image, const tchar *tstr,
+do_set_image_info_str(WIMStruct *wim, int image, const tchar *tstr,
size_t offset)
{
tchar *tstr_copy;
tchar **dest_tstr_p;
+ int ret;
+
+ ret = can_modify_wim(wim);
+ if (ret)
+ return ret;
- if (image < 1 || image > w->hdr.image_count) {
+ if (image < 1 || image > wim->hdr.image_count) {
ERROR("%d is not a valid image", image);
return WIMLIB_ERR_INVALID_IMAGE;
}
} else {
tstr_copy = NULL;
}
- dest_tstr_p = (tchar**)((void*)&w->wim_info->images[image - 1] + offset);
+ dest_tstr_p = (tchar**)((void*)&wim->wim_info->images[image - 1] + offset);
FREE(*dest_tstr_p);
*dest_tstr_p = tstr_copy;
return 0;
}
-/* Sets the description of an image in the WIM. */
+/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_set_image_descripton(WIMStruct *w, int image,
+wimlib_set_image_descripton(WIMStruct *wim, int image,
const tchar *description)
{
- return do_set_image_info_str(w, image, description,
+ return do_set_image_info_str(wim, image, description,
offsetof(struct image_info, description));
}
-/* Set the <FLAGS> element of a WIM image */
+/* API function documented in wimlib.h */
WIMLIBAPI int
-wimlib_set_image_flags(WIMStruct *w, int image, const tchar *flags)
+wimlib_set_image_flags(WIMStruct *wim, int image, const tchar *flags)
{
- return do_set_image_info_str(w, image, flags,
+ return do_set_image_info_str(wim, image, flags,
offsetof(struct image_info, flags));
}
git://wimlib.net / wimlib / blobdiff