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