Update wimlib.h documentation
[wimlib] / src / xml.c
1 /*
2  * xml.c
3  *
4  * Deals with the XML information in WIM files.  Uses the C library libxml2.
5  */
6
7 /*
8  * Copyright (C) 2012 Eric Biggers
9  *
10  * This file is part of wimlib, a library for working with WIM files.
11  *
12  * wimlib is free software; you can redistribute it and/or modify it under the
13  * terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 3 of the License, or (at your option)
15  * any later version.
16  *
17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
24  */
25
26 #include "wimlib_internal.h"
27 #include "dentry.h"
28 #include "xml.h"
29 #include "timestamp.h"
30 #include "lookup_table.h"
31 #include <string.h>
32 #include <time.h>
33 #include <libxml/parser.h>
34 #include <libxml/tree.h>
35 #include <libxml/xmlwriter.h>
36
37 /* Structures used to form an in-memory representation of the XML data (other
38  * than the raw parse tree from libxml). */
39
40 struct windows_version {
41         u64 major;
42         u64 minor;
43         u64 build;
44         u64 sp_build;
45         u64 sp_level;
46 };
47
48 struct windows_info {
49         u64    arch;
50         char  *product_name;
51         char  *edition_id;
52         char  *installation_type;
53         char  *hal;
54         char  *product_type;
55         char  *product_suite;
56         char **languages;
57         char  *default_language;
58         u64    num_languages;
59         char  *system_root;
60         bool   windows_version_exists;
61         struct windows_version windows_version;
62 };
63
64 struct image_info {
65         u64   index;
66         u64   dir_count;
67         u64   file_count;
68         u64   total_bytes;
69         u64   hard_link_bytes;
70         u64   creation_time;
71         u64   last_modification_time;
72         bool  windows_info_exists;
73         struct windows_info windows_info;
74         char *name;
75         char *description;
76         char  *display_name;
77         char  *display_description;
78         union {
79                 char  *flags;
80                 struct lookup_table *lookup_table;
81         };
82 };
83
84
85 /* Returns a statically allocated string that is a string representation of the
86  * architecture number. */
87 static const char *get_arch(int arch)
88 {
89         static char buf[20];
90         switch (arch) {
91         case 0:
92                 return "x86";
93         case 6:
94                 return "ia64";
95         case 9:
96                 return "x86_64";
97         /* XXX Are there other arch values? */
98         default:
99                 snprintf(buf, sizeof(buf), "%d (unknown)", arch);
100                 return buf;
101         }
102 }
103
104
105 /* Iterate through the children of an xmlNode. */
106 #define for_node_child(parent, child)   \
107         for (child = parent->children; child != NULL; child = child->next)
108
109 /* Utility functions for xmlNodes */
110 static inline bool node_is_element(xmlNode *node)
111 {
112         return node->type == XML_ELEMENT_NODE;
113 }
114
115 static inline bool node_is_text(xmlNode *node)
116 {
117         return node->type == XML_TEXT_NODE;
118 }
119
120 static inline bool node_is_attribute(xmlNode *node)
121 {
122         return node->type == XML_ATTRIBUTE_NODE;
123 }
124
125 static inline bool node_name_is(xmlNode *node, const char *name)
126 {
127         /* For now, both upper case and lower case element names are accepted. */
128         return strcasecmp((const char *)node->name, name) == 0;
129 }
130
131 /* Finds the text node that is a child of an element node and returns its
132  * content converted to a 64-bit unsigned integer.  Returns 0 if no text node is
133  * found. */
134 static u64 node_get_u64(const xmlNode *u64_node)
135 {
136         xmlNode *child;
137         for_node_child(u64_node, child)
138                 if (node_is_text(child))
139                         return strtoull((const char *)child->content, NULL, 10);
140         return 0;
141 }
142
143 /* Like node_get_u64(), but expects a number in base 16. */
144 static u64 node_get_hex_u64(const xmlNode *u64_node)
145 {
146         xmlNode *child;
147         for_node_child(u64_node, child)
148                 if (node_is_text(child))
149                         return strtoull(child->content, NULL, 16);
150         return 0;
151 }
152
153 static int node_get_string(const xmlNode *string_node, char **str)
154 {
155         xmlNode *child;
156         char *p = NULL;
157
158         for_node_child(string_node, child) {
159                 if (node_is_text(child) && child->content) {
160                         p = STRDUP(child->content);
161                         if (!p) {
162                                 ERROR("Out of memory");
163                                 return WIMLIB_ERR_NOMEM;
164                         }
165                         break;
166                 }
167         }
168         *str = p;
169         return 0;
170 }
171
172 /* Returns the timestamp from a time node.  It has child elements <HIGHPART> and
173  * <LOWPART> that are then used to construct a 64-bit timestamp. */
174 static u64 node_get_timestamp(const xmlNode *time_node)
175 {
176         u32 high_part = 0;
177         u32 low_part = 0;
178         xmlNode *child;
179         for_node_child(time_node, child) {
180                 if (!node_is_element(child))
181                         continue;
182                 if (node_name_is(child, "HIGHPART"))
183                         high_part = node_get_hex_u64(child);
184                 else if (node_name_is(child, "LOWPART"))
185                         low_part = node_get_hex_u64(child);
186         }
187         return (u64)low_part | ((u64)high_part << 32);
188 }
189
190 /* Used to sort an array of struct image_infos by their image indices. */
191 static int sort_by_index(const void *p1, const void *p2)
192 {
193         u64 index_1 = ((struct image_info*)p1)->index;
194         u64 index_2 = ((struct image_info*)p1)->index;
195         if (index_1 < index_2)
196                 return -1;
197         else if (index_1 > index_2)
198                 return 1;
199         else
200                 return 0;
201 }
202
203
204 /* Frees memory allocated inside a struct windows_info structure. */
205 static void destroy_windows_info(struct windows_info *windows_info)
206 {
207         uint i;
208
209         FREE(windows_info->product_name);
210         FREE(windows_info->edition_id);
211         FREE(windows_info->installation_type);
212         FREE(windows_info->hal);
213         FREE(windows_info->product_type);
214         FREE(windows_info->product_suite);
215         for (i = 0; i < windows_info->num_languages; i++)
216                 FREE(windows_info->languages[i]);
217         FREE(windows_info->languages);
218         FREE(windows_info->default_language);
219         FREE(windows_info->system_root);
220 }
221
222 /* Frees memory allocated inside a struct image_info structure. */
223 static void destroy_image_info(struct image_info *image_info)
224 {
225         FREE(image_info->name);
226         FREE(image_info->description);
227         FREE(image_info->flags);
228         FREE(image_info->display_name);
229         FREE(image_info->display_description);
230         destroy_windows_info(&image_info->windows_info);
231         memset(image_info, 0, sizeof(struct image_info));
232 }
233
234 void free_wim_info(struct wim_info *info)
235 {
236         uint i;
237         if (info) {
238                 if (info->images) {
239                         for (i = 0; i < info->num_images; i++)
240                                 destroy_image_info(&info->images[i]);
241                         FREE(info->images);
242                 }
243                 FREE(info);
244         }
245 }
246
247 /* Reads the information from a <VERSION> element inside the <WINDOWS> element.
248  * */
249 static void xml_read_windows_version(const xmlNode *version_node,
250                                      struct windows_version* windows_version)
251 {
252         xmlNode *child;
253         for_node_child(version_node, child) {
254                 if (!node_is_element(child))
255                         continue;
256                 if (node_name_is(child, "MAJOR"))
257                         windows_version->major    = node_get_u64(child);
258                 else if (node_name_is(child, "MINOR"))
259                         windows_version->minor    = node_get_u64(child);
260                 else if (node_name_is(child, "BUILD"))
261                         windows_version->build    = node_get_u64(child);
262                 else if (node_name_is(child, "SPBUILD"))
263                         windows_version->sp_build = node_get_u64(child);
264                 else if (node_name_is(child, "SPLEVEL"))
265                         windows_version->sp_level = node_get_u64(child);
266         }
267 }
268
269 /* Reads the information from a <LANGUAGE> element inside a <WINDOWS> element.
270  * */
271 static int xml_read_languages(const xmlNode *languages_node,
272                               char ***languages_ret,
273                               u64 *num_languages_ret,
274                               char **default_language_ret)
275 {
276         xmlNode *child;
277         uint i;
278         uint num_languages;
279         char **languages;
280         int ret;
281
282         num_languages = 0;
283         for_node_child(languages_node, child)
284                 if (node_is_element(child) && node_name_is(child, "LANGUAGE"))
285                         num_languages++;
286
287         languages = CALLOC(num_languages, sizeof(char*));
288         if (!languages) {
289                 ERROR("Out of memory");
290                 return WIMLIB_ERR_NOMEM;
291         }
292
293         *languages_ret = languages;
294         *num_languages_ret = num_languages;
295
296         i = 0;
297         ret = 0;
298         for_node_child(languages_node, child) {
299                 if (!node_is_element(child))
300                         continue;
301                 if (node_name_is(child, "LANGUAGE"))
302                         ret = node_get_string(child, &languages[i++]);
303                 else if (node_name_is(child, "DEFAULT"))
304                         ret = node_get_string(child, default_language_ret);
305                 if (ret != 0)
306                         return ret;
307         }
308         return ret;
309 }
310
311 /* Reads the information from a <WINDOWS> element inside an <IMAGE> element. */
312 static int xml_read_windows_info(const xmlNode *windows_node,
313                                  struct windows_info *windows_info)
314 {
315         xmlNode *child;
316         int ret = 0;
317
318         for_node_child(windows_node, child) {
319                 if (!node_is_element(child))
320                         continue;
321                 if (node_name_is(child, "ARCH")) {
322                         windows_info->arch = node_get_u64(child);
323                 } else if (node_name_is(child, "PRODUCTNAME")) {
324                         ret = node_get_string(child,
325                                               &windows_info->product_name);
326                 } else if (node_name_is(child, "EDITIONID")) {
327                         ret = node_get_string(child,
328                                               &windows_info->edition_id);
329                 } else if (node_name_is(child, "INSTALLATIONTYPE")) {
330                         ret = node_get_string(child,
331                                               &windows_info->installation_type);
332                 } else if (node_name_is(child, "PRODUCTTYPE")) {
333                         ret = node_get_string(child,
334                                               &windows_info->product_type);
335                 } else if (node_name_is(child, "PRODUCTSUITE")) {
336                         ret = node_get_string(child,
337                                               &windows_info->product_suite);
338                 } else if (node_name_is(child, "LANGUAGES")) {
339                         ret = xml_read_languages(child,
340                                                  &windows_info->languages,
341                                                  &windows_info->num_languages,
342                                                  &windows_info->default_language);
343                 } else if (node_name_is(child, "VERSION")) {
344                         xml_read_windows_version(child,
345                                                 &windows_info->windows_version);
346                         windows_info->windows_version_exists = true;
347                 } else if (node_name_is(child, "SYSTEMROOT")) {
348                         ret = node_get_string(child, &windows_info->system_root);
349                 } else if (node_name_is(child, "HAL")) {
350                         ret = node_get_string(child, &windows_info->hal);
351                 }
352
353                 if (ret != 0)
354                         return ret;
355         }
356         return ret;
357 }
358
359 /* Reads the information from an <IMAGE> element. */
360 static int xml_read_image_info(xmlNode *image_node,
361                                struct image_info *image_info)
362 {
363         xmlNode *child;
364         xmlChar *index_prop;
365         int ret;
366
367         index_prop = xmlGetProp(image_node, "INDEX");
368         if (index_prop) {
369                 char *tmp;
370                 image_info->index = strtoul(index_prop, &tmp, 10);
371                 FREE(index_prop);
372         } else {
373                 image_info->index = 0;
374         }
375
376         ret = 0;
377         for_node_child(image_node, child) {
378                 if (!node_is_element(child))
379                         continue;
380                 if (node_name_is(child, "DIRCOUNT"))
381                         image_info->dir_count = node_get_u64(child);
382                 else if (node_name_is(child, "FILECOUNT"))
383                         image_info->file_count = node_get_u64(child);
384                 else if (node_name_is(child, "TOTALBYTES"))
385                         image_info->total_bytes = node_get_u64(child);
386                 else if (node_name_is(child, "HARDLINKBYTES"))
387                         image_info->hard_link_bytes = node_get_u64(child);
388                 else if (node_name_is(child, "CREATIONTIME"))
389                         image_info->creation_time = node_get_timestamp(child);
390                 else if (node_name_is(child, "LASTMODIFICATIONTIME"))
391                         image_info->last_modification_time = node_get_timestamp(child);
392                 else if (node_name_is(child, "WINDOWS")) {
393                         DEBUG("Found <WINDOWS> tag");
394                         ret = xml_read_windows_info(child,
395                                                     &image_info->windows_info);
396                         image_info->windows_info_exists = true;
397                 } else if (node_name_is(child, "NAME")) {
398                         ret = node_get_string(child, &image_info->name);
399                 } else if (node_name_is(child, "DESCRIPTION")) {
400                         ret = node_get_string(child, &image_info->description);
401                 } else if (node_name_is(child, "FLAGS")) {
402                         ret = node_get_string(child, &image_info->flags);
403                 } else if (node_name_is(child, "DISPLAYNAME")) {
404                         ret = node_get_string(child, &image_info->display_name);
405                 } else if (node_name_is(child, "DISPLAYDESCRIPTION")) {
406                         ret = node_get_string(child, &image_info->display_description);
407                 }
408                 if (ret != 0)
409                         return ret;
410         }
411         if (!image_info->name) {
412                 WARNING("Image with index %"PRIu64" has no name",
413                         image_info->index);
414                 image_info->name = MALLOC(1);
415                 if (!image_info->name) {
416                         ERROR("Out of memory");
417                         return WIMLIB_ERR_NOMEM;
418                 }
419                 image_info->name[0] = '\0';
420         }
421         return ret;
422 }
423
424 /* Reads the information from a <WIM> element, which should be the root element
425  * of the XML tree. */
426 static int xml_read_wim_info(const xmlNode *wim_node,
427                              struct wim_info **wim_info_ret)
428 {
429         struct wim_info *wim_info;
430         xmlNode *child;
431         int ret;
432         uint num_images;
433         struct image_info *cur_image_info;
434
435         wim_info = CALLOC(1, sizeof(struct wim_info));
436         if (!wim_info) {
437                 ERROR("Out of memory");
438                 return WIMLIB_ERR_NOMEM;
439         }
440
441         /* Count how many images there are. */
442         num_images = 0;
443         for_node_child(wim_node, child)
444                 if (node_is_element(child) && node_name_is(child, "IMAGE"))
445                         num_images++;
446
447         if (num_images == 0)
448                 goto done;
449
450         /* Allocate the array of struct image_infos and fill them in. */
451         wim_info->images = CALLOC(num_images, sizeof(wim_info->images[0]));
452         if (!wim_info->images) {
453                 ret = WIMLIB_ERR_NOMEM;
454                 ERROR("Out of memory!");
455                 goto err;
456         }
457         wim_info->num_images = num_images;
458         cur_image_info = wim_info->images;
459         for_node_child(wim_node, child) {
460                 if (!node_is_element(child))
461                         continue;
462                 if (node_name_is(child, "IMAGE")) {
463                         DEBUG("Found <IMAGE> tag");
464                         ret = xml_read_image_info(child, cur_image_info++);
465                         if (ret != 0)
466                                 goto err;
467                 } else if (node_name_is(child, "TOTALBYTES")) {
468                         wim_info->total_bytes = node_get_u64(child);
469                 }
470         }
471
472         /* Sort the array of struct image_infos by image index. */
473         qsort(wim_info->images, wim_info->num_images,
474               sizeof(struct image_info), sort_by_index);
475 done:
476         *wim_info_ret = wim_info;
477         return 0;
478 err:
479         free_wim_info(wim_info);
480         return ret;
481 }
482
483 /* Prints the information contained in a struct windows_info structure. */
484 static void print_windows_info(const struct windows_info *windows_info)
485 {
486         uint i;
487         const struct windows_version *windows_version;
488
489         printf("Architecture:           %s\n", get_arch(windows_info->arch));
490
491         if (windows_info->product_name)
492                 printf("Product Name:           %s\n",
493                        windows_info->product_name);
494
495         if (windows_info->edition_id)
496                 printf("Edition ID:             %s\n",
497                        windows_info->edition_id);
498
499         if (windows_info->installation_type)
500                 printf("Installation Type:      %s\n",
501                        windows_info->installation_type);
502
503         if (windows_info->hal)
504                 printf("HAL:                    %s\n", windows_info->hal);
505
506         if (windows_info->product_type)
507                 printf("Product Type:           %s\n",
508                        windows_info->product_type);
509
510         if (windows_info->product_suite)
511                 printf("Product Suite:          %s\n",
512                        windows_info->product_suite);
513         printf("Languages:              ");
514         for (i = 0; i < windows_info->num_languages; i++) {
515                 fputs(windows_info->languages[i], stdout);
516                 putchar(' ');
517         }
518         putchar('\n');
519         if (windows_info->default_language)
520                 printf("Default Language:       %s\n",
521                        windows_info->default_language);
522         if (windows_info->system_root)
523                 printf("System Root:            %s\n",
524                        windows_info->system_root);
525         if (windows_info->windows_version_exists) {
526                 windows_version = &windows_info->windows_version;
527                 printf("Major Version:          %"PRIu64"\n",
528                                 windows_version->major);
529                 printf("Minor Version:          %"PRIu64"\n",
530                                 windows_version->minor);
531                 printf("Build:                  %"PRIu64"\n",
532                                 windows_version->build);
533                 printf("Service Pack Build:     %"PRIu64"\n",
534                                 windows_version->sp_build);
535                 printf("Service Pack Level:     %"PRIu64"\n",
536                                 windows_version->sp_level);
537         }
538 }
539
540
541 /* Writes the information contained in a struct windows_version structure to the XML
542  * document being constructed in memory.  This is the <VERSION> element inside
543  * the <WINDOWS> element. */
544 static int xml_write_windows_version(xmlTextWriter *writer,
545                                      const struct windows_version *version)
546 {
547         int rc;
548         rc = xmlTextWriterStartElement(writer, "VERSION");
549         if (rc < 0)
550                 return rc;
551
552         rc = xmlTextWriterWriteFormatElement(writer, "MAJOR", "%"PRIu64,
553                                                                 version->major);
554         if (rc < 0)
555                 return rc;
556
557         rc = xmlTextWriterWriteFormatElement(writer, "MINOR", "%"PRIu64,
558                                                                 version->minor);
559         if (rc < 0)
560                 return rc;
561
562         rc = xmlTextWriterWriteFormatElement(writer, "BUILD", "%"PRIu64,
563                                                                 version->build);
564         if (rc < 0)
565                 return rc;
566
567         rc = xmlTextWriterWriteFormatElement(writer, "SPBUILD", "%"PRIu64,
568                                                                 version->sp_build);
569         if (rc < 0)
570                 return rc;
571
572         rc = xmlTextWriterWriteFormatElement(writer, "SPLEVEL", "%"PRIu64,
573                                                                 version->sp_level);
574         if (rc < 0)
575                 return rc;
576
577         return xmlTextWriterEndElement(writer); /* </VERSION> */
578 }
579
580 /* Writes the information contained in a struct windows_info structure to the XML
581  * document being constructed in memory. This is the <WINDOWS> element. */
582 static int xml_write_windows_info(xmlTextWriter *writer,
583                                   const struct windows_info *windows_info)
584 {
585         int rc;
586         rc = xmlTextWriterStartElement(writer, "WINDOWS");
587         if (rc < 0)
588                 return rc;
589
590
591         rc = xmlTextWriterWriteFormatElement(writer, "ARCH", "%"PRIu64,
592                                                         windows_info->arch);
593         if (rc < 0)
594                 return rc;
595
596         if (windows_info->product_name) {
597                 rc = xmlTextWriterWriteElement(writer, "PRODUCTNAME",
598                                                         windows_info->product_name);
599                 if (rc < 0)
600                         return rc;
601         }
602
603         if (windows_info->edition_id) {
604                 rc = xmlTextWriterWriteElement(writer, "EDITIONID",
605                                                         windows_info->edition_id);
606                 if (rc < 0)
607                         return rc;
608         }
609
610         if (windows_info->installation_type) {
611                 rc = xmlTextWriterWriteElement(writer, "INSTALLATIONTYPE",
612                                                         windows_info->installation_type);
613                 if (rc < 0)
614                         return rc;
615         }
616
617         if (windows_info->hal) {
618                 rc = xmlTextWriterWriteElement(writer, "HAL",
619                                                         windows_info->hal);
620                 if (rc < 0)
621                         return rc;
622         }
623
624         if (windows_info->system_root) {
625                 rc = xmlTextWriterWriteElement(writer, "SYSTEMROOT",
626                                                 windows_info->system_root);
627                         if (rc < 0)
628                                 return rc;
629         }
630
631         if (windows_info->product_type) {
632                 rc = xmlTextWriterWriteElement(writer, "PRODUCTTYPE",
633                                                 windows_info->product_type);
634                 if (rc < 0)
635                         return rc;
636         }
637
638         if (windows_info->product_suite) {
639                 rc = xmlTextWriterWriteElement(writer, "PRODUCTSUITE",
640                                                 windows_info->product_suite);
641                         if (rc < 0)
642                                 return rc;
643         }
644
645         if (windows_info->num_languages) {
646                 rc = xmlTextWriterStartElement(writer, "LANGUAGES");
647                 if (rc < 0)
648                         return rc;
649
650                 for (int i = 0; i < windows_info->num_languages; i++) {
651                         rc = xmlTextWriterWriteElement(writer, "LANGUAGE",
652                                                         windows_info->languages[i]);
653                         if (rc < 0)
654                                 return rc;
655                 }
656                 rc = xmlTextWriterWriteElement(writer, "DEFAULT",
657                                                 windows_info->default_language);
658                 if (rc < 0)
659                         return rc;
660
661                 rc = xmlTextWriterEndElement(writer); /* </LANGUAGES> */
662                 if (rc < 0)
663                         return rc;
664         }
665
666         if (windows_info->windows_version_exists) {
667                 rc = xml_write_windows_version(writer, &windows_info->windows_version);
668                 if (rc < 0)
669                         return rc;
670         }
671
672         return xmlTextWriterEndElement(writer); /* </WINDOWS> */
673 }
674
675 /* Writes a time element to the XML document being constructed in memory. */
676 static int xml_write_time(xmlTextWriter *writer, const char *element_name,
677                           u64 time)
678 {
679         int rc;
680         rc = xmlTextWriterStartElement(writer, element_name);
681         if (rc < 0)
682                 return rc;
683
684         rc = xmlTextWriterWriteFormatElement(writer, "HIGHPART",
685                                         "0x%"PRIX32, (u32)(time >> 32));
686         if (rc < 0)
687                 return rc;
688
689         rc = xmlTextWriterWriteFormatElement(writer, "LOWPART",
690                                                 "0x%"PRIX32, (u32)time);
691         if (rc < 0)
692                 return rc;
693
694         rc = xmlTextWriterEndElement(writer); /* </@element_name> */
695         if (rc < 0)
696                 return rc;
697         return 0;
698 }
699
700
701 /* Writes an <IMAGE> element to the XML document. */
702 static int xml_write_image_info(xmlTextWriter *writer,
703                                 const struct image_info *image_info)
704 {
705         int rc;
706         rc = xmlTextWriterStartElement(writer, "IMAGE");
707         if (rc < 0)
708                 return rc;
709
710         rc = xmlTextWriterWriteFormatAttribute(writer, "INDEX", "%"PRIu64,
711                                                 image_info->index);
712         if (rc < 0)
713                 return rc;
714
715         rc = xmlTextWriterWriteFormatElement(writer, "DIRCOUNT", "%"PRIu64,
716                                                 image_info->dir_count);
717         if (rc < 0)
718                 return rc;
719
720         rc = xmlTextWriterWriteFormatElement(writer, "FILECOUNT", "%"PRIu64,
721                                                 image_info->file_count);
722         if (rc < 0)
723                 return rc;
724
725         rc = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
726                                                 image_info->total_bytes);
727         if (rc < 0)
728                 return rc;
729
730         rc = xmlTextWriterWriteFormatElement(writer, "HARDLINKBYTES", "%"PRIu64,
731                                                 image_info->hard_link_bytes);
732         if (rc < 0)
733                 return rc;
734
735         rc = xml_write_time(writer, "CREATIONTIME",
736                                                 image_info->creation_time);
737         if (rc < 0)
738                 return rc;
739
740         rc = xml_write_time(writer, "LASTMODIFICATIONTIME",
741                                                 image_info->last_modification_time);
742         if (rc < 0)
743                 return rc;
744
745         if (image_info->windows_info_exists) {
746                 rc = xml_write_windows_info(writer, &image_info->windows_info);
747                 if (rc < 0)
748                         return rc;
749         } else {
750                 DEBUG("<WINDOWS> tag does not exist.");
751         }
752
753         if (image_info->name) {
754                 rc = xmlTextWriterWriteElement(writer, "NAME", image_info->name);
755                 if (rc < 0)
756                         return rc;
757         }
758         if (image_info->description) {
759                 rc = xmlTextWriterWriteElement(writer, "DESCRIPTION",
760                                                         image_info->description);
761                 if (rc < 0)
762                         return rc;
763         }
764         if (image_info->display_name) {
765                 rc = xmlTextWriterWriteElement(writer, "DISPLAYNAME",
766                                                 image_info->display_name);
767                 if (rc < 0)
768                         return rc;
769         }
770         if (image_info->display_description) {
771                 rc = xmlTextWriterWriteElement(writer, "DISPLAYDESCRIPTION",
772                                                 image_info->display_description);
773                 if (rc < 0)
774                         return rc;
775         }
776
777         if (image_info->flags) {
778                 rc = xmlTextWriterWriteElement(writer, "FLAGS",
779                                 image_info->flags);
780                 if (rc < 0)
781                         return rc;
782         }
783
784         return xmlTextWriterEndElement(writer); /* </IMAGE> */
785 }
786
787
788
789 /* Makes space for another image in the XML information and return a pointer to
790  * it.*/
791 static struct image_info *add_image_info_struct(struct wim_info *wim_info)
792 {
793         struct image_info *images;
794
795         images = CALLOC(wim_info->num_images + 1, sizeof(struct image_info));
796         if (!images)
797                 return NULL;
798         memcpy(images, wim_info->images,
799                wim_info->num_images * sizeof(struct image_info));
800         FREE(wim_info->images);
801         wim_info->images = images;
802         wim_info->num_images++;
803         return &images[wim_info->num_images - 1];
804 }
805
806 static int clone_windows_info(const struct windows_info *old,
807                               struct windows_info *new)
808 {
809         uint i;
810
811         if (old->product_name && !(new->product_name = STRDUP(old->product_name)))
812                 return WIMLIB_ERR_NOMEM;
813         if (old->edition_id && !(new->edition_id = STRDUP(old->edition_id)))
814                 return WIMLIB_ERR_NOMEM;
815         if (old->installation_type && !(new->installation_type =
816                                         STRDUP(old->installation_type)))
817                 return WIMLIB_ERR_NOMEM;
818         if (old->hal && !(new->hal = STRDUP(old->hal)))
819                 return WIMLIB_ERR_NOMEM;
820         if (old->product_type && !(new->product_type = STRDUP(old->product_type)))
821                 return WIMLIB_ERR_NOMEM;
822         if (old->product_suite && !(new->product_suite = STRDUP(old->product_suite)))
823                 return WIMLIB_ERR_NOMEM;
824
825         if (old->languages) {
826                 new->languages = CALLOC(old->num_languages, sizeof(char*));
827                 if (!new->languages)
828                         return WIMLIB_ERR_NOMEM;
829                 new->num_languages = old->num_languages;
830                 for (i = 0; i < new->num_languages; i++) {
831                         if (!old->languages[i])
832                                 continue;
833                         new->languages[i] = STRDUP(old->languages[i]);
834                         if (!new->languages[i])
835                                 return WIMLIB_ERR_NOMEM;
836                 }
837         }
838         if (old->default_language &&
839                         !(new->default_language = STRDUP(old->default_language)))
840                 return WIMLIB_ERR_NOMEM;
841         if (old->system_root && !(new->system_root = STRDUP(old->system_root)))
842                 return WIMLIB_ERR_NOMEM;
843         if (old->windows_version_exists) {
844                 new->windows_version_exists = true;
845                 memcpy(&new->windows_version, &old->windows_version,
846                        sizeof(old->windows_version));
847         }
848         return 0;
849 }
850
851 static int clone_image_info(const struct image_info *old, struct image_info *new)
852 {
853         new->dir_count              = old->dir_count;
854         new->file_count             = old->file_count;
855         new->total_bytes            = old->total_bytes;
856         new->hard_link_bytes        = old->hard_link_bytes;
857         new->creation_time          = old->creation_time;
858         new->last_modification_time = old->last_modification_time;
859
860         if (!(new->name = STRDUP(old->name)))
861                 return WIMLIB_ERR_NOMEM;
862
863         if (old->description)
864                 if (!(new->description = STRDUP(old->description)))
865                         return WIMLIB_ERR_NOMEM;
866
867         if (old->display_name)
868                 if (!(new->display_name = STRDUP(old->display_name)))
869                         return WIMLIB_ERR_NOMEM;
870
871         if (old->display_description)
872                 if (!(new->display_description = STRDUP(old->display_description)))
873                         return WIMLIB_ERR_NOMEM;
874
875         if (old->flags)
876                 if (!(new->flags = STRDUP(old->flags)))
877                         return WIMLIB_ERR_NOMEM;
878
879         if (old->windows_info_exists) {
880                 new->windows_info_exists = true;
881                 return clone_windows_info(&old->windows_info,
882                                           &new->windows_info);
883         }
884         return 0;
885 }
886
887 /* Copies the XML information for an image between WIM files.
888  *
889  * @dest_image_name and @dest_image_description are ignored if they are NULL;
890  * otherwise, they are used to override the image name and/or image description
891  * from the XML data in the source WIM file.
892  *
893  * On failure, WIMLIB_ERR_NOMEM is returned and no changes are made.  Otherwise,
894  * 0 is returned and the WIM information at *new_wim_info_p is modified.
895  */
896 int xml_export_image(const struct wim_info *old_wim_info,
897                      int image,
898                      struct wim_info **new_wim_info_p,
899                      const char *dest_image_name,
900                      const char *dest_image_description)
901 {
902         struct wim_info *new_wim_info;
903         struct image_info *image_info;
904         int ret;
905
906         DEBUG("Copying XML data between WIM files for source image %d.", image);
907
908         wimlib_assert(image >= 1 && image <= old_wim_info->num_images);
909
910         if (*new_wim_info_p) {
911                 new_wim_info = *new_wim_info_p;
912         } else {
913                 new_wim_info = CALLOC(1, sizeof(struct wim_info));
914                 if (!new_wim_info)
915                         goto err;
916         }
917
918         image_info = add_image_info_struct(new_wim_info);
919         if (!image_info)
920                 goto err;
921
922         ret = clone_image_info(&old_wim_info->images[image - 1], image_info);
923         if (ret != 0)
924                 goto err;
925
926         image_info->index = new_wim_info->num_images;
927
928         if (dest_image_name) {
929                 FREE(image_info->name);
930                 image_info->name = STRDUP(dest_image_name);
931                 if (!image_info->name)
932                         goto err;
933         }
934         if (dest_image_description) {
935                 FREE(image_info->description);
936                 image_info->description = STRDUP(dest_image_description);
937                 if (!image_info->description)
938                         goto err;
939         }
940         *new_wim_info_p = new_wim_info;
941         return 0;
942 err:
943         ERROR("Out of memory");
944         free_wim_info(new_wim_info);
945         return WIMLIB_ERR_NOMEM;
946 }
947
948 /* Removes an image from the XML information. */
949 void xml_delete_image(struct wim_info **wim_info_p, int image)
950 {
951         struct wim_info *wim_info;
952         int i;
953
954         DEBUG("Deleting image %d from the XML data.", image);
955
956         wim_info = *wim_info_p;
957
958         wimlib_assert(wim_info);
959         wimlib_assert(image >= 1 && image <= wim_info->num_images);
960
961         destroy_image_info(&wim_info->images[image - 1]);
962
963         for (i = image - 1; i < wim_info->num_images - 1; i++) {
964                 memcpy(&wim_info->images[i], &wim_info->images[i + 1],
965                                         sizeof(struct image_info));
966                 wim_info->images[i].index--;
967         }
968
969         if (--wim_info->num_images == 0) {
970                 free_wim_info(wim_info);
971                 *wim_info_p = NULL;
972         }
973 }
974
975 size_t xml_get_max_image_name_len(const WIMStruct *w)
976 {
977         size_t len = 0;
978         uint i;
979         uint num_images = w->wim_info->num_images;
980         for (i = 0; i < num_images; i++)
981                 len = max(len, strlen(w->wim_info->images[i].name));
982         return len;
983 }
984
985 #ifdef ENABLE_CUSTOM_MEMORY_ALLOCATOR
986 void xml_set_memory_allocator(void *(*malloc_func)(size_t),
987                                    void (*free_func)(void *),
988                                    void *(*realloc_func)(void *, size_t))
989 {
990         xmlMemSetup(free_func, malloc_func, realloc_func, STRDUP);
991 }
992 #endif
993
994 static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
995 {
996         struct image_info *info = arg;
997         struct lookup_table *lookup_table = info->lookup_table;
998         const struct inode *inode = dentry->d_inode;
999         struct lookup_table_entry *lte;
1000
1001         /* Update directory count and file count.
1002          *
1003          * Each dentry counts as either a file or a directory, but not both.
1004          * The root directory is an exception: it is not counted at all.
1005          *
1006          * Symbolic links and junction points (and presumably other reparse
1007          * points) count as regular files.  This is despite the fact that
1008          * junction points have FILE_ATTRIBUTE_DIRECTORY set.
1009          */
1010         if (dentry_is_root(dentry))
1011                 return 0;
1012
1013         if (inode_is_directory(inode))
1014                 info->dir_count++;
1015         else
1016                 info->file_count++;
1017
1018         /*
1019          * Update total bytes and hard link bytes.
1020          *
1021          * Unfortunately there are some inconsistencies/bugs in the way this is
1022          * done.
1023          *
1024          * If there are no alternate data streams in the image, the "total
1025          * bytes" is the sum of the size of the un-named data stream of each
1026          * inode times the link count of that inode.  In other words, it would
1027          * be the total number of bytes of regular files you would have if you
1028          * extracted the full image without any hard-links.  The "hard link
1029          * bytes" is equal to the "total bytes" minus the size of the un-named
1030          * data stream of each inode.  In other words, the "hard link bytes"
1031          * counts the size of the un-named data stream for all the links to each
1032          * inode except the first one.
1033          *
1034          * Reparse points and directories don't seem to be counted in either the
1035          * total bytes or the hard link bytes.
1036          *
1037          * And now we get to the most confusing part, the alternate data
1038          * streams.  They are not counted in the "total bytes".  However, if the
1039          * link count of an inode with alternate data streams is 2 or greater,
1040          * the size of all the alternate data streams is included in the "hard
1041          * link bytes", and this size is multiplied by the link count (NOT one
1042          * less than the link count).
1043          */
1044         lte = inode_unnamed_lte(inode, info->lookup_table);
1045         if (lte) {
1046                 info->total_bytes += wim_resource_size(lte);
1047                 if (!dentry_is_first_in_inode(dentry))
1048                         info->hard_link_bytes += wim_resource_size(lte);
1049         }
1050
1051         if (inode->link_count >= 2 && dentry_is_first_in_inode(dentry)) {
1052                 for (unsigned i = 0; i < inode->num_ads; i++) {
1053                         if (inode->ads_entries[i].stream_name_len) {
1054                                 lte = inode_stream_lte(inode, i + 1, lookup_table);
1055                                 if (lte) {
1056                                         info->hard_link_bytes += inode->link_count *
1057                                                                  wim_resource_size(lte);
1058                                 }
1059                         }
1060                 }
1061         }
1062         return 0;
1063 }
1064
1065 void xml_update_image_info(WIMStruct *w, int image)
1066 {
1067         struct image_info *image_info;
1068         char *flags_save;
1069
1070         DEBUG("Updating the image info for image %d", image);
1071
1072         image_info = &w->wim_info->images[image - 1];
1073
1074         image_info->file_count      = 0;
1075         image_info->dir_count       = 0;
1076         image_info->total_bytes     = 0;
1077         image_info->hard_link_bytes = 0;
1078
1079         flags_save = image_info->flags;
1080         image_info->lookup_table = w->lookup_table;
1081
1082         for_dentry_in_tree(w->image_metadata[image - 1].root_dentry,
1083                            calculate_dentry_statistics,
1084                            image_info);
1085
1086         image_info->lookup_table = NULL;
1087         image_info->flags = flags_save;
1088         image_info->last_modification_time = get_wim_timestamp();
1089 }
1090
1091 /* Adds an image to the XML information. */
1092 int xml_add_image(WIMStruct *w, const char *name)
1093 {
1094         struct wim_info *wim_info;
1095         struct image_info *image_info;
1096
1097         wimlib_assert(name);
1098
1099         DEBUG("Adding image: name = %s", name);
1100
1101         /* If this is the first image, allocate the struct wim_info.  Otherwise
1102          * use the existing struct wim_info. */
1103         if (w->wim_info) {
1104                 wim_info = w->wim_info;
1105         } else {
1106                 DEBUG("Allocing struct wim_info with 1 image");
1107                 wim_info = CALLOC(1, sizeof(struct wim_info));
1108                 if (!wim_info) {
1109                         ERROR("Could not allocate WIM information struct--- "
1110                               "out of memory");
1111                         return WIMLIB_ERR_NOMEM;
1112                 }
1113         }
1114
1115         image_info = add_image_info_struct(wim_info);
1116         if (!image_info)
1117                 goto out_free_wim_info;
1118
1119         if (!(image_info->name = STRDUP(name)))
1120                 goto out_destroy_image_info;
1121
1122         w->wim_info = wim_info;
1123         image_info->index = wim_info->num_images;
1124         image_info->creation_time = get_wim_timestamp();
1125         xml_update_image_info(w, image_info->index);
1126         return 0;
1127
1128 out_destroy_image_info:
1129         destroy_image_info(image_info);
1130         wim_info->num_images--;
1131 out_free_wim_info:
1132         if (wim_info != w->wim_info)
1133                 FREE(wim_info);
1134         ERROR("Out of memory");
1135         return WIMLIB_ERR_NOMEM;
1136 }
1137
1138 /* Prints information about the specified image from struct wim_info structure.
1139  * */
1140 void print_image_info(const struct wim_info *wim_info, int image)
1141 {
1142         const struct image_info *image_info;
1143         const char *desc;
1144         time_t time;
1145         char *p;
1146
1147         wimlib_assert(image >= 1 && image <= wim_info->num_images);
1148
1149         image_info = &wim_info->images[image - 1];
1150
1151         printf("Index:                  %"PRIu64"\n", image_info->index);
1152         printf("Name:                   %s\n", image_info->name);
1153
1154         /* Always print the Description: part even if there is no
1155          * description. */
1156         if (image_info->description)
1157                 desc = image_info->description;
1158         else
1159                 desc = "";
1160         printf("Description:            %s\n", desc);
1161
1162         if (image_info->display_name)
1163                 printf("Display Name:           %s\n",
1164                        image_info->display_name);
1165
1166         if (image_info->display_description)
1167                 printf("Display Description:    %s\n",
1168                        image_info->display_description);
1169
1170         printf("Directory Count:        %"PRIu64"\n", image_info->dir_count);
1171         printf("File Count:             %"PRIu64"\n", image_info->file_count);
1172         printf("Total Bytes:            %"PRIu64"\n", image_info->total_bytes);
1173         printf("Hard Link Bytes:        %"PRIu64"\n", image_info->hard_link_bytes);
1174
1175         time = wim_timestamp_to_unix(image_info->creation_time);
1176         p = asctime(gmtime(&time));
1177         *(strrchr(p, '\n')) = '\0';
1178
1179         printf("Creation Time:          %s UTC\n", p);
1180
1181         time = wim_timestamp_to_unix(image_info->last_modification_time);
1182         p = asctime(gmtime(&time));
1183         *(strrchr(p, '\n')) = '\0';
1184
1185         printf("Last Modification Time: %s UTC\n", p);
1186         if (image_info->windows_info_exists)
1187                 print_windows_info(&image_info->windows_info);
1188         if (image_info->flags)
1189                 printf("Flags:                  %s\n", image_info->flags);
1190         putchar('\n');
1191 }
1192
1193 /*
1194  * Reads the XML data from a WIM file.
1195  */
1196 int read_xml_data(FILE *fp, const struct resource_entry *res,
1197                   u8 **xml_data_ret, struct wim_info **info_ret)
1198 {
1199         u8 *xml_data;
1200         xmlDoc *doc;
1201         xmlNode *root;
1202         int ret;
1203
1204         DEBUG("XML data is %"PRIu64" bytes at offset %"PRIu64"",
1205               (u64)res->size, res->offset);
1206
1207         if (resource_is_compressed(res)) {
1208                 ERROR("XML data is supposed to be uncompressed");
1209                 ret = WIMLIB_ERR_XML;
1210                 goto out_cleanup_parser;
1211         }
1212         if (res->size < 2) {
1213                 ERROR("XML data must be at least 2 bytes");
1214                 ret = WIMLIB_ERR_XML;
1215                 goto out_cleanup_parser;
1216         }
1217
1218         xml_data = MALLOC(res->size + 2);
1219         if (!xml_data) {
1220                 ret = WIMLIB_ERR_NOMEM;
1221                 goto out_cleanup_parser;
1222         }
1223         ret = read_uncompressed_resource(fp, res->offset, res->size, xml_data);
1224         if (ret != 0)
1225                 goto out_free_xml_data;
1226
1227         xml_data[res->size] = 0;
1228         xml_data[res->size + 1] = 0;
1229
1230         DEBUG("Parsing XML using libxml2 to create XML tree.");
1231
1232         doc = xmlReadMemory(xml_data, res->size, "noname.xml", "UTF-16", 0);
1233
1234
1235         if (!doc) {
1236                 ERROR("Failed to parse XML data");
1237                 ret = WIMLIB_ERR_XML;
1238                 goto out_free_xml_data;
1239         }
1240
1241         DEBUG("Constructing WIM information structure from XML tree.");
1242
1243         root = xmlDocGetRootElement(doc);
1244         if (!root) {
1245                 ERROR("Empty XML document");
1246                 ret = WIMLIB_ERR_XML;
1247                 goto out_free_doc;
1248         }
1249
1250         if (!node_is_element(root) || !node_name_is(root, "WIM")) {
1251                 ERROR("Expected <WIM> for the root XML element (found <%s>)",
1252                       root->name);
1253                 ret = WIMLIB_ERR_XML;
1254                 goto out_free_doc;
1255         }
1256
1257         ret = xml_read_wim_info(root, info_ret);
1258         if (ret != 0)
1259                 goto out_free_doc;
1260
1261         DEBUG("Freeing XML tree.");
1262
1263         xmlFreeDoc(doc);
1264         xmlCleanupParser();
1265         *xml_data_ret = xml_data;
1266         return 0;
1267 out_free_doc:
1268         xmlFreeDoc(doc);
1269 out_free_xml_data:
1270         FREE(xml_data);
1271 out_cleanup_parser:
1272         xmlCleanupParser();
1273         return ret;
1274 }
1275
1276 #define CHECK_RET  ({   if (ret < 0)  { \
1277                                 ERROR("Error writing XML data"); \
1278                                 ret = WIMLIB_ERR_WRITE; \
1279                                 goto out_free_text_writer; \
1280                         } })
1281
1282 /*
1283  * Writes XML data to a WIM file.
1284  *
1285  * If @total_bytes is non-zero, it specifies what to write to the TOTALBYTES
1286  * element in the XML data.  If zero, TOTALBYTES is given the default value of
1287  * the offset of the XML data.
1288  */
1289 int write_xml_data(const struct wim_info *wim_info, int image, FILE *out,
1290                    u64 total_bytes, struct resource_entry *out_res_entry)
1291 {
1292         xmlBuffer     *buf;
1293         xmlTextWriter *writer;
1294         char          *utf16_str;
1295         int ret;
1296         const xmlChar *content;
1297         size_t len;
1298         size_t utf16_len;
1299         size_t bytes_written;
1300         off_t start_offset, end_offset;
1301
1302         wimlib_assert(image == WIMLIB_ALL_IMAGES ||
1303                         (wim_info != NULL && image >= 1 &&
1304                          image <= wim_info->num_images));
1305
1306         start_offset = ftello(out);
1307         if (start_offset == -1)
1308                 return WIMLIB_ERR_WRITE;
1309
1310         /* The contents of the <TOTALBYTES> element in the XML data, under the
1311          * <WIM> element not the <IMAGE> element, is (for non-spit WIMs) the
1312          * size of the WIM file excluding the XML data and integrity table,
1313          * which is the current offset, since the XML data goes at the end of
1314          * the WIM file before the integrity table. */
1315         if (total_bytes == 0) {
1316                 total_bytes = ftello(out);
1317                 if (total_bytes == (u64)-1)
1318                         return WIMLIB_ERR_WRITE;
1319         }
1320
1321         DEBUG("Creating XML buffer and text writer.");
1322         buf = xmlBufferCreate();
1323         if (!buf) {
1324                 ERROR("Failed to allocate XML buffer");
1325                 ret = WIMLIB_ERR_NOMEM;
1326                 goto out;
1327         }
1328         writer = xmlNewTextWriterMemory(buf, 0);
1329         if (!writer) {
1330                 ERROR("Failed to allocate XML writer");
1331                 ret = WIMLIB_ERR_NOMEM;
1332                 goto out_buffer_free;
1333         }
1334
1335         /* XXX */
1336         /* M$'s WIM files do not have XML declarations, so do not write one.
1337          * I'm not sure how we can force the document to be written in UTF-16
1338          * without calling xmlTextWriterStartDocument(), though, so currently it
1339          * is composed in a buffer UTF-8, then converted to UTF-16. */
1340 #if 0
1341         ret = xmlTextWriterStartDocument(writer, NULL, "UTF-16", NULL);
1342         CHECK_RET;
1343 #endif
1344
1345         DEBUG("Writing <WIM> element");
1346         ret = xmlTextWriterStartElement(writer, "WIM");
1347         CHECK_RET;
1348
1349         ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
1350                                               total_bytes);
1351         CHECK_RET;
1352
1353         if (wim_info != NULL) {
1354                 DEBUG("Writing %d <IMAGE> elements", (int)wim_info->num_images);
1355                 for (int i = 1; i <= (int)wim_info->num_images; i++) {
1356                         if (image != WIMLIB_ALL_IMAGES && i != image)
1357                                 continue;
1358                         DEBUG("Writing <IMAGE> element for image %d", i);
1359                         ret = xml_write_image_info(writer, &wim_info->images[i - 1]);
1360                         CHECK_RET;
1361                 }
1362         }
1363
1364         ret = xmlTextWriterEndElement(writer);
1365         CHECK_RET;
1366
1367         ret = xmlTextWriterEndDocument(writer);
1368         CHECK_RET;
1369
1370         xmlFreeTextWriter(writer);
1371         writer = NULL;
1372         DEBUG("Done composing XML document. Now converting to UTF-16 and "
1373               "writing it to the output file.");
1374
1375         content = xmlBufferContent(buf);
1376         len = xmlBufferLength(buf);
1377
1378         DEBUG("XML UTF-8 length = %zu", len);
1379
1380         utf16_str = utf8_to_utf16(content, len, &utf16_len);
1381         if (!utf16_str) {
1382                 ret = WIMLIB_ERR_NOMEM;
1383                 goto out_free_text_writer;
1384         }
1385
1386         DEBUG("XML UTF-16 length = %zu", utf16_len);
1387
1388         if ((putc(0xff, out)) == EOF || (putc(0xfe, out) == EOF) ||
1389                 ((bytes_written = fwrite(utf16_str, 1, utf16_len, out))
1390                                 != utf16_len)) {
1391                 ERROR_WITH_ERRNO("Error writing XML data");
1392                 ret = WIMLIB_ERR_WRITE;
1393                 goto out_free_utf16_str;
1394         }
1395
1396         DEBUG("Cleaning up.");
1397
1398         end_offset = ftello(out);
1399         if (end_offset == -1) {
1400                 ret = WIMLIB_ERR_WRITE;
1401                 goto out_free_utf16_str;
1402         }
1403
1404         out_res_entry->offset        = start_offset;
1405         out_res_entry->size          = end_offset - start_offset;
1406         out_res_entry->original_size = end_offset - start_offset;
1407         out_res_entry->flags         = WIM_RESHDR_FLAG_METADATA;
1408         ret = 0;
1409 out_free_utf16_str:
1410         FREE(utf16_str);
1411 out_free_text_writer:
1412         xmlFreeTextWriter(writer);
1413 out_buffer_free:
1414         xmlBufferFree(buf);
1415 out:
1416         return ret;
1417 }
1418
1419 /* Returns the name of the specified image. */
1420 WIMLIBAPI const char *wimlib_get_image_name(const WIMStruct *w, int image)
1421 {
1422         DEBUG("Getting the name of image %d", image);
1423         if (image < 1 || image > w->hdr.image_count)
1424                 return NULL;
1425
1426         return w->wim_info->images[image - 1].name;
1427 }
1428
1429 /* Returns the description of the specified image. */
1430 WIMLIBAPI const char *wimlib_get_image_description(const WIMStruct *w,
1431                                                    int image)
1432 {
1433         DEBUG("Getting the description of image %d", image);
1434         if (image < 1 || image > w->hdr.image_count)
1435                 return NULL;
1436
1437         return w->wim_info->images[image - 1].description;
1438 }
1439
1440 /* Determines if an image name is already used by some image in the WIM. */
1441 WIMLIBAPI bool wimlib_image_name_in_use(const WIMStruct *w, const char *name)
1442 {
1443         int i;
1444
1445         DEBUG("Checking to see if the image name `%s' is already in use", name);
1446         if (!name || !*name || !w->wim_info)
1447                 return false;
1448         for (i = 1; i <= w->wim_info->num_images; i++)
1449                 if (strcmp(w->wim_info->images[i - 1].name, name) == 0)
1450                         return true;
1451
1452         return false;
1453 }
1454
1455 WIMLIBAPI int wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
1456 {
1457         DEBUG("Extracting the XML data.");
1458         if (!w->xml_data)
1459                 return WIMLIB_ERR_INVALID_PARAM;
1460
1461         if (fwrite(w->xml_data, 1, w->hdr.xml_res_entry.size, fp) !=
1462                         w->hdr.xml_res_entry.size) {
1463                 ERROR_WITH_ERRNO("Failed to extract XML data");
1464                 return WIMLIB_ERR_WRITE;
1465         }
1466         return 0;
1467 }
1468
1469 /* Sets the name of an image in the WIM. */
1470 WIMLIBAPI int wimlib_set_image_name(WIMStruct *w, int image, const char *name)
1471 {
1472         char *p;
1473         int i;
1474
1475         DEBUG("Setting the name of image %d to %s", image, name);
1476
1477         if (!w)
1478                 return WIMLIB_ERR_INVALID_PARAM;
1479
1480         if (!name || !*name) {
1481                 ERROR("Must specify a non-empty string for the image name");
1482                 return WIMLIB_ERR_INVALID_PARAM;
1483         }
1484         if (image < 1 || image > w->hdr.image_count) {
1485                 ERROR("%d is not a valid image", image);
1486                 return WIMLIB_ERR_INVALID_IMAGE;
1487         }
1488
1489         for (i = 1; i <= w->hdr.image_count; i++) {
1490                 if (i == image)
1491                         continue;
1492                 if (strcmp(w->wim_info->images[i - 1].name, name) == 0) {
1493                         ERROR("The name `%s' is already used for image %d",
1494                               name, i);
1495                         return WIMLIB_ERR_IMAGE_NAME_COLLISION;
1496                 }
1497         }
1498
1499         p = STRDUP(name);
1500         if (!p) {
1501                 ERROR("Out of memory");
1502                 return WIMLIB_ERR_NOMEM;
1503         }
1504         FREE(w->wim_info->images[image - 1].name);
1505         w->wim_info->images[image - 1].name = p;
1506         return 0;
1507 }
1508
1509 /* Sets the description of an image in the WIM. */
1510 WIMLIBAPI int wimlib_set_image_descripton(WIMStruct *w, int image,
1511                                           const char *description)
1512 {
1513         char *p;
1514
1515         DEBUG("Setting the description of image %d to %s", image, description);
1516
1517         if (!w)
1518                 return WIMLIB_ERR_INVALID_PARAM;
1519
1520         if (image < 1 || image > w->hdr.image_count) {
1521                 ERROR("%d is not a valid image", image);
1522                 return WIMLIB_ERR_INVALID_IMAGE;
1523         }
1524         if (description) {
1525                 p = STRDUP(description);
1526                 if (!p) {
1527                         ERROR("Out of memory");
1528                         return WIMLIB_ERR_NOMEM;
1529                 }
1530         } else {
1531                 p = NULL;
1532         }
1533         FREE(w->wim_info->images[image - 1].description);
1534         w->wim_info->images[image - 1].description = p;
1535         return 0;
1536 }
1537
1538 WIMLIBAPI int wimlib_set_image_flags(WIMStruct *w, int image,
1539                                      const char *flags)
1540 {
1541         char *p;
1542
1543         DEBUG("Setting the flags of image %d to %s", image, flags);
1544
1545         if (image < 1 || image > w->hdr.image_count) {
1546                 ERROR("%d is not a valid image", image);
1547                 return WIMLIB_ERR_INVALID_IMAGE;
1548         }
1549         if (flags) {
1550                 p = STRDUP(flags);
1551                 if (!p) {
1552                         ERROR("Out of memory");
1553                         return WIMLIB_ERR_NOMEM;
1554                 }
1555         } else {
1556                 p = NULL;
1557         }
1558         FREE(w->wim_info->images[image - 1].flags);
1559         w->wim_info->images[image - 1].flags = p;
1560         return 0;
1561 }