wimlib.net Git - wimlib/blob - 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                 WARNING("Image with index %"PRIu64" has no name\n",
 399                                         image_info->index);
 400                 image_info->name = MALLOC(1);
 401                 if (!image_info->name) {
 402                         ERROR("Out of memory!\n");
 403                         return WIMLIB_ERR_NOMEM;
 404                 }
 405                 image_info->name[0] = '\0';
 406                 return 0;
 407         }
 408
 409         return 0;
 410 }
 411
 412 /* Reads the information from a <WIM> element, which should be the root element
 413  * of the XML tree. */
 414 static int xml_read_wim_info(const xmlNode *wim_node, struct wim_info **wim_info_ret)
 415 {
 416         struct wim_info *wim_info;
 417         xmlNode *child;
 418         int ret;
 419         uint num_images;
 420         struct image_info *cur_image_info;
 421
 422         wim_info = CALLOC(1, sizeof(struct wim_info));
 423         if (!wim_info) {
 424                 ERROR("Out of memory!\n");
 425                 return WIMLIB_ERR_NOMEM;
 426         }
 427
 428         /* Count how many images there are. */
 429         num_images = 0;
 430         for_node_child(wim_node, child)
 431                 if (node_is_element(child) && node_name_is(child, "IMAGE"))
 432                         num_images++;
 433
 434         if (num_images == 0)
 435                 goto done;
 436
 437         /* Allocate the array of struct image_infos and fill them in. */
 438         wim_info->images = CALLOC(num_images, sizeof(wim_info->images[0]));
 439         if (!wim_info->images) {
 440                 ret = WIMLIB_ERR_NOMEM;
 441                 ERROR("Out of memory!\n");
 442                 goto err;
 443         }
 444         wim_info->num_images = num_images;
 445         cur_image_info = wim_info->images;
 446         for_node_child(wim_node, child) {
 447                 if (!node_is_element(child))
 448                         continue;
 449                 if (node_name_is(child, "IMAGE")) {
 450                         DEBUG("Found <IMAGE> tag\n");
 451                         ret = xml_read_image_info(child, cur_image_info++);
 452                         if (ret != 0)
 453                                 goto err;
 454                 } else if (node_name_is(child, "TOTALBYTES")) {
 455                         wim_info->total_bytes = node_get_u64(child);
 456                 }
 457         }
 458
 459         /* Sort the array of struct image_infos by image index. */
 460         qsort(wim_info->images, wim_info->num_images,
 461               sizeof(struct image_info), sort_by_index);
 462 done:
 463         *wim_info_ret = wim_info;
 464         return 0;
 465 err:
 466         free_wim_info(wim_info);
 467         return ret;
 468 }
 469
 470 /* Prints the information contained in a struct windows_info structure. */
 471 static void print_windows_info(const struct windows_info *windows_info)
 472 {
 473         uint i;
 474         const struct windows_version *windows_version;
 475
 476         printf("Architecture:           %s\n", get_arch(windows_info->arch));
 477         printf("Product Name:           %s\n", windows_info->product_name);
 478         printf("Edition ID:             %s\n", windows_info->edition_id);
 479         printf("Installation Type:      %s\n", windows_info->installation_type);
 480         if (windows_info->hal)
 481                 printf("HAL:                    %s\n", windows_info->hal);
 482         printf("Product Type:           %s\n", windows_info->product_type);
 483         if (windows_info->product_suite)
 484                 printf("Product Suite:          %s\n", windows_info->product_suite);
 485         printf("Languages:              ");
 486         for (i = 0; i < windows_info->num_languages; i++) {
 487                 fputs(windows_info->languages[i], stdout);
 488                 putchar(' ');
 489         }
 490         putchar('\n');
 491         printf("Default Language:       %s\n", windows_info->default_language);
 492         printf("System Root:            %s\n", windows_info->system_root);
 493         if (windows_info->windows_version_exists) {
 494                 windows_version = &windows_info->windows_version;
 495                 printf("Major Version:          %"PRIu64"\n",
 496                                 windows_version->major);
 497                 printf("Minor Version:          %"PRIu64"\n",
 498                                 windows_version->minor);
 499                 printf("Build:                  %"PRIu64"\n",
 500                                 windows_version->build);
 501                 printf("Service Pack Build:     %"PRIu64"\n",
 502                                 windows_version->sp_build);
 503                 printf("Service Pack Level:     %"PRIu64"\n",
 504                                 windows_version->sp_level);
 505         }
 506 }
 507
 508
 509 /* Writes the information contained in a struct windows_version structure to the XML
 510  * document being constructed in memory.  This is the <VERSION> element inside
 511  * the <WINDOWS> element. */
 512 static int xml_write_windows_version(xmlTextWriter *writer,
 513                                         const struct windows_version *version)
 514 {
 515         int rc;
 516         rc = xmlTextWriterStartElement(writer, "VERSION");
 517         if (rc < 0)
 518                 return rc;
 519
 520         rc = xmlTextWriterWriteFormatElement(writer, "MAJOR", "%"PRIu64,
 521                                                                 version->major);
 522         if (rc < 0)
 523                 return rc;
 524
 525         rc = xmlTextWriterWriteFormatElement(writer, "MINOR", "%"PRIu64,
 526                                                                 version->minor);
 527         if (rc < 0)
 528                 return rc;
 529
 530         rc = xmlTextWriterWriteFormatElement(writer, "BUILD", "%"PRIu64,
 531                                                                 version->build);
 532         if (rc < 0)
 533                 return rc;
 534
 535         rc = xmlTextWriterWriteFormatElement(writer, "SPBUILD", "%"PRIu64,
 536                                                                 version->sp_build);
 537         if (rc < 0)
 538                 return rc;
 539
 540         rc = xmlTextWriterWriteFormatElement(writer, "SPLEVEL", "%"PRIu64,
 541                                                                 version->sp_level);
 542         if (rc < 0)
 543                 return rc;
 544
 545         return xmlTextWriterEndElement(writer); /* </VERSION> */
 546 }
 547
 548 /* Writes the information contained in a struct windows_info structure to the XML
 549  * document being constructed in memory. This is the <WINDOWS> element. */
 550 static int xml_write_windows_info(xmlTextWriter *writer,
 551                                         const struct windows_info *windows_info)
 552 {
 553         int rc;
 554         rc = xmlTextWriterStartElement(writer, "WINDOWS");
 555         if (rc < 0)
 556                 return rc;
 557
 558
 559         rc = xmlTextWriterWriteFormatElement(writer, "ARCH", "%"PRIu64,
 560                                                         windows_info->arch);
 561         if (rc < 0)
 562                 return rc;
 563
 564         if (windows_info->product_name) {
 565                 rc = xmlTextWriterWriteElement(writer, "PRODUCTNAME",
 566                                                         windows_info->product_name);
 567                 if (rc < 0)
 568                         return rc;
 569         }
 570
 571         if (windows_info->edition_id) {
 572                 rc = xmlTextWriterWriteElement(writer, "EDITIONID",
 573                                                         windows_info->edition_id);
 574                 if (rc < 0)
 575                         return rc;
 576         }
 577
 578         if (windows_info->installation_type) {
 579                 rc = xmlTextWriterWriteElement(writer, "INSTALLATIONTYPE",
 580                                                         windows_info->installation_type);
 581                 if (rc < 0)
 582                         return rc;
 583         }
 584
 585         if (windows_info->hal) {
 586                 rc = xmlTextWriterWriteElement(writer, "HAL",
 587                                                         windows_info->hal);
 588                 if (rc < 0)
 589                         return rc;
 590         }
 591
 592         if (windows_info->system_root) {
 593                 rc = xmlTextWriterWriteElement(writer, "SYSTEMROOT",
 594                                                 windows_info->system_root);
 595                         if (rc < 0)
 596                                 return rc;
 597         }
 598
 599         if (windows_info->product_type) {
 600                 rc = xmlTextWriterWriteElement(writer, "PRODUCTTYPE",
 601                                                 windows_info->product_type);
 602                 if (rc < 0)
 603                         return rc;
 604         }
 605
 606         if (windows_info->product_suite) {
 607                 rc = xmlTextWriterWriteElement(writer, "PRODUCTSUITE",
 608                                                 windows_info->product_suite);
 609                         if (rc < 0)
 610                                 return rc;
 611         }
 612
 613         if (windows_info->num_languages) {
 614                 rc = xmlTextWriterStartElement(writer, "LANGUAGES");
 615                 if (rc < 0)
 616                         return rc;
 617
 618                 for (int i = 0; i < windows_info->num_languages; i++) {
 619                         rc = xmlTextWriterWriteElement(writer, "LANGUAGE",
 620                                                         windows_info->languages[i]);
 621                         if (rc < 0)
 622                                 return rc;
 623                 }
 624                 rc = xmlTextWriterWriteElement(writer, "DEFAULT",
 625                                                 windows_info->default_language);
 626                 if (rc < 0)
 627                         return rc;
 628
 629                 rc = xmlTextWriterEndElement(writer); /* </LANGUAGES> */
 630                 if (rc < 0)
 631                         return rc;
 632         }
 633
 634         if (windows_info->windows_version_exists) {
 635                 rc = xml_write_windows_version(writer, &windows_info->windows_version);
 636                 if (rc < 0)
 637                         return rc;
 638         }
 639
 640         return xmlTextWriterEndElement(writer); /* </WINDOWS> */
 641 }
 642
 643 /* Writes a time element to the XML document being constructed in memory. */
 644 static int xml_write_time(xmlTextWriter *writer, const char *element_name,
 645                                                                 u64 time)
 646 {
 647         int rc;
 648         rc = xmlTextWriterStartElement(writer, element_name);
 649         if (rc < 0)
 650                 return rc;
 651
 652         rc = xmlTextWriterWriteFormatElement(writer, "HIGHPART",
 653                                         "0x%"PRIX32, (u32)(time >> 32));
 654         if (rc < 0)
 655                 return rc;
 656
 657         rc = xmlTextWriterWriteFormatElement(writer, "LOWPART",
 658                                                 "0x%"PRIX32, (u32)time);
 659         if (rc < 0)
 660                 return rc;
 661
 662         rc = xmlTextWriterEndElement(writer); /* </@element_name> */
 663         if (rc < 0)
 664                 return rc;
 665         return 0;
 666 }
 667
 668
 669 /* Writes an <IMAGE> element to the XML document. */
 670 static int xml_write_image_info(xmlTextWriter *writer,
 671                                 const struct image_info *image_info)
 672 {
 673         int rc;
 674         rc = xmlTextWriterStartElement(writer, "IMAGE");
 675         if (rc < 0)
 676                 return rc;
 677
 678         rc = xmlTextWriterWriteFormatAttribute(writer, "INDEX", "%"PRIu64,
 679                                                 image_info->index);
 680         if (rc < 0)
 681                 return rc;
 682
 683         rc = xmlTextWriterWriteFormatElement(writer, "DIRCOUNT", "%"PRIu64,
 684                                                 image_info->dir_count);
 685         if (rc < 0)
 686                 return rc;
 687
 688         rc = xmlTextWriterWriteFormatElement(writer, "FILECOUNT", "%"PRIu64,
 689                                                 image_info->file_count);
 690         if (rc < 0)
 691                 return rc;
 692
 693         rc = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
 694                                                 image_info->total_bytes);
 695         if (rc < 0)
 696                 return rc;
 697
 698         rc = xmlTextWriterWriteFormatElement(writer, "HARDLINKBYTES", "%"PRIu64,
 699                                                 image_info->hard_link_bytes);
 700         if (rc < 0)
 701                 return rc;
 702
 703         rc = xml_write_time(writer, "CREATIONTIME",
 704                                                 image_info->creation_time);
 705         if (rc < 0)
 706                 return rc;
 707
 708         rc = xml_write_time(writer, "LASTMODIFICATIONTIME",
 709                                                 image_info->last_modification_time);
 710         if (rc < 0)
 711                 return rc;
 712
 713         if (image_info->windows_info_exists) {
 714                 rc = xml_write_windows_info(writer, &image_info->windows_info);
 715                 if (rc < 0)
 716                         return rc;
 717         } else {
 718                 DEBUG("<WINDOWS> tag does not exist.\n");
 719         }
 720
 721         if (image_info->name) {
 722                 rc = xmlTextWriterWriteElement(writer, "NAME", image_info->name);
 723                 if (rc < 0)
 724                         return rc;
 725         }
 726         if (image_info->description) {
 727                 rc = xmlTextWriterWriteElement(writer, "DESCRIPTION",
 728                                                         image_info->description);
 729                 if (rc < 0)
 730                         return rc;
 731         }
 732         if (image_info->display_name) {
 733                 rc = xmlTextWriterWriteElement(writer, "DISPLAYNAME",
 734                                                 image_info->display_name);
 735                 if (rc < 0)
 736                         return rc;
 737         }
 738         if (image_info->display_description) {
 739                 rc = xmlTextWriterWriteElement(writer, "DISPLAYDESCRIPTION",
 740                                                 image_info->display_description);
 741                 if (rc < 0)
 742                         return rc;
 743         }
 744
 745         if (image_info->flags) {
 746                 rc = xmlTextWriterWriteElement(writer, "FLAGS",
 747                                 image_info->flags);
 748                 if (rc < 0)
 749                         return rc;
 750         }
 751
 752         return xmlTextWriterEndElement(writer); /* </IMAGE> */
 753 }
 754
 755
 756
 757 /* Makes space for another image in the XML information and return a pointer to
 758  * it.*/
 759 static struct image_info *add_image_info_struct(struct wim_info *wim_info)
 760 {
 761         struct image_info *images;
 762
 763         images = CALLOC(wim_info->num_images + 1, sizeof(struct image_info));
 764         if (!images)
 765                 return NULL;
 766         memcpy(images, wim_info->images,
 767                         wim_info->num_images * sizeof(struct image_info));
 768         FREE(wim_info->images);
 769         wim_info->images = images;
 770         wim_info->num_images++;
 771         return &images[wim_info->num_images - 1];
 772 }
 773
 774 static int clone_windows_info(const struct windows_info *old,
 775                               struct windows_info *new)
 776 {
 777         uint i;
 778
 779         if (old->product_name && !(new->product_name = STRDUP(old->product_name)))
 780                 return WIMLIB_ERR_NOMEM;
 781         if (old->edition_id && !(new->edition_id = STRDUP(old->edition_id)))
 782                 return WIMLIB_ERR_NOMEM;
 783         if (old->installation_type && !(new->installation_type =
 784                                         STRDUP(old->installation_type)))
 785                 return WIMLIB_ERR_NOMEM;
 786         if (old->hal && !(new->hal = STRDUP(old->hal)))
 787                 return WIMLIB_ERR_NOMEM;
 788         if (old->product_type && !(new->product_type = STRDUP(old->product_type)))
 789                 return WIMLIB_ERR_NOMEM;
 790         if (old->product_suite && !(new->product_suite = STRDUP(old->product_suite)))
 791                 return WIMLIB_ERR_NOMEM;
 792
 793         if (old->languages) {
 794                 new->languages = CALLOC(old->num_languages, sizeof(char*));
 795                 if (!new->languages)
 796                         return WIMLIB_ERR_NOMEM;
 797                 new->num_languages = old->num_languages;
 798                 for (i = 0; i < new->num_languages; i++) {
 799                         if (!old->languages[i])
 800                                 continue;
 801                         new->languages[i] = STRDUP(old->languages[i]);
 802                         if (!new->languages[i])
 803                                 return WIMLIB_ERR_NOMEM;
 804                 }
 805         }
 806         if (old->default_language &&
 807                         !(new->default_language = STRDUP(old->default_language)))
 808                 return WIMLIB_ERR_NOMEM;
 809         if (old->system_root && !(new->system_root = STRDUP(old->system_root)))
 810                 return WIMLIB_ERR_NOMEM;
 811         return 0;
 812 }
 813
 814 static int clone_image_info(const struct image_info *old, struct image_info *new)
 815 {
 816         int ret;
 817
 818         new->dir_count              = old->dir_count;
 819         new->file_count             = old->file_count;
 820         new->total_bytes            = old->total_bytes;
 821         new->hard_link_bytes        = old->hard_link_bytes;
 822         new->creation_time          = old->creation_time;
 823         new->last_modification_time = old->last_modification_time;
 824
 825         if (!(new->name = STRDUP(old->name)))
 826                 return WIMLIB_ERR_NOMEM;
 827
 828         if (old->description)
 829                 if (!(new->description = STRDUP(old->description)))
 830                         return WIMLIB_ERR_NOMEM;
 831
 832         if (old->display_name)
 833                 if (!(new->display_name = STRDUP(old->display_name)))
 834                         return WIMLIB_ERR_NOMEM;
 835
 836         if (old->display_description)
 837                 if (!(new->display_description = STRDUP(old->display_description)))
 838                         return WIMLIB_ERR_NOMEM;
 839
 840         if (old->flags)
 841                 if (!(new->flags = STRDUP(old->flags)))
 842                         return WIMLIB_ERR_NOMEM;
 843
 844         if (old->windows_info_exists) {
 845                 new->windows_info_exists = true;
 846                 return clone_windows_info(&old->windows_info,
 847                                           &new->windows_info);
 848         }
 849         return 0;
 850 }
 851
 852 /* Copies the XML information for an image between WIM files.
 853  *
 854  * @dest_image_name and @dest_image_description are ignored if they are NULL;
 855  * otherwise, they are used to override the image name and/or image description
 856  * from the XML data in the source WIM file. */
 857 int xml_export_image(const struct wim_info *old_wim_info,
 858                      int image,
 859                      struct wim_info **new_wim_info_p,
 860                      const char *dest_image_name,
 861                      const char *dest_image_description)
 862 {
 863         struct wim_info *new_wim_info;
 864         struct image_info *image_info;
 865         int ret;
 866         char *name;
 867         char *desc;
 868
 869         DEBUG("Copying XML data between WIM files for source image %d\n",
 870                         image);
 871
 872         wimlib_assert(image >= 1 && image <= old_wim_info->num_images);
 873
 874
 875         if (*new_wim_info_p) {
 876                 new_wim_info = *new_wim_info_p;
 877         } else {
 878                 new_wim_info = CALLOC(1, sizeof(struct wim_info));
 879                 if (!new_wim_info)
 880                         goto err;
 881         }
 882
 883         image_info = add_image_info_struct(new_wim_info);
 884         if (!image_info)
 885                 goto err;
 886
 887         ret = clone_image_info(&old_wim_info->images[image - 1], image_info);
 888         if (ret != 0)
 889                 goto err;
 890
 891         image_info->index = new_wim_info->num_images;
 892
 893         if (dest_image_name) {
 894                 FREE(image_info->name);
 895                 image_info->name = STRDUP(dest_image_name);
 896                 if (!image_info->name)
 897                         goto err;
 898         }
 899         if (dest_image_description) {
 900                 FREE(image_info->description);
 901                 image_info->description = STRDUP(dest_image_description);
 902                 if (!image_info->description)
 903                         goto err;
 904         }
 905         *new_wim_info_p = new_wim_info;
 906         return 0;
 907 err:
 908         ERROR("Out of memory!\n");
 909         free_wim_info(new_wim_info);
 910         return WIMLIB_ERR_NOMEM;
 911 }
 912
 913 /* Removes an image from the XML information. */
 914 void xml_delete_image(struct wim_info **wim_info_p, int image)
 915 {
 916         struct wim_info *wim_info;
 917         int i;
 918
 919         DEBUG("Deleting image %d from the XML data\n", image);
 920
 921         wim_info = *wim_info_p;
 922
 923         wimlib_assert(wim_info);
 924         wimlib_assert(image >= 1 && image <= wim_info->num_images);
 925
 926         destroy_image_info(&wim_info->images[image - 1]);
 927
 928         for (i = image - 1; i < wim_info->num_images - 1; i++) {
 929                 memcpy(&wim_info->images[i], &wim_info->images[i + 1],
 930                                         sizeof(struct image_info));
 931                 wim_info->images[i].index--;
 932         }
 933
 934         if (--wim_info->num_images == 0) {
 935                 free_wim_info(wim_info);
 936                 *wim_info_p = NULL;
 937         }
 938 }
 939
 940 size_t xml_get_max_image_name_len(const WIMStruct *w)
 941 {
 942         size_t len = 0;
 943         uint i;
 944         uint num_images = w->wim_info->num_images;
 945         for (i = 0; i < num_images; i++)
 946                 len = max(len, strlen(w->wim_info->images[i].name));
 947         return len;
 948 }
 949
 950 #ifdef ENABLE_CUSTOM_MEMORY_ALLOCATOR
 951 void xml_set_memory_allocator(void *(*malloc_func)(size_t),
 952                                    void (*free_func)(void *),
 953                                    void *(*realloc_func)(void *, size_t))
 954 {
 955         xmlMemSetup(free_func, malloc_func, realloc_func, STRDUP);
 956 }
 957 #endif
 958
 959 void xml_update_image_info(WIMStruct *w, int image)
 960 {
 961         struct image_info *image_info;
 962         struct dentry *root;
 963
 964         DEBUG("Updating the image info for image %d\n", image);
 965
 966         image_info = &w->wim_info->images[image - 1];
 967         root = w->image_metadata[image - 1].root_dentry;
 968
 969         calculate_dir_tree_statistics(root, w->lookup_table,
 970                                       &image_info->dir_count,
 971                                       &image_info->file_count,
 972                                       &image_info->total_bytes,
 973                                       &image_info->hard_link_bytes);
 974
 975         image_info->last_modification_time = get_timestamp();
 976 }
 977
 978 /* Adds an image to the XML information. */
 979 int xml_add_image(WIMStruct *w, struct dentry *root_dentry, const char *name,
 980                   const char *description, const char *flags_element)
 981 {
 982         struct wim_info *wim_info;
 983         struct image_info *image_info;
 984
 985         wimlib_assert(name);
 986
 987         DEBUG("Adding image: name = %s, description = %s, flags_element = %s\n",
 988                         name, description, flags_element);
 989
 990         /* If this is the first image, allocate the struct wim_info.  Otherwise
 991          * use the existing struct wim_info. */
 992         if (w->wim_info) {
 993                 wim_info = w->wim_info;
 994         } else {
 995                 DEBUG("Allocing struct wim_info with 1 image\n");
 996                 wim_info = CALLOC(1, sizeof(struct wim_info));
 997                 if (!wim_info) {
 998                         ERROR("Could not allocate WIM information struct--- "
 999                                         "out of memory!\n");
1000                         return WIMLIB_ERR_NOMEM;
1001                 }
1002         }
1003
1004         image_info = add_image_info_struct(wim_info);
1005         if (!image_info)
1006                 goto err_nomem1;
1007
1008         if (!(image_info->name = STRDUP(name)))
1009                 goto err_nomem2;
1010
1011         if (description && !(image_info->description = STRDUP(description)))
1012                 goto err_nomem2;
1013         if (flags_element && !(image_info->flags = STRDUP(flags_element)))
1014                 goto err_nomem2;
1015
1016         w->wim_info = wim_info;
1017         image_info->index = wim_info->num_images;
1018         image_info->creation_time = get_timestamp();
1019         xml_update_image_info(w, image_info->index);
1020         return 0;
1021
1022 err_nomem2:
1023         destroy_image_info(image_info);
1024 err_nomem1:
1025         if (w->wim_info)
1026                 wim_info->num_images--;
1027         else
1028                 FREE(wim_info);
1029         ERROR("Out of memory!\n");
1030         return WIMLIB_ERR_NOMEM;
1031 }
1032
1033 /* Prints information about the specified image from struct wim_info structure.
1034  * @image may be WIM_ALL_IMAGES. */
1035 void print_image_info(const struct wim_info *wim_info, int image)
1036 {
1037         uint i;
1038         const struct image_info *image_info;
1039         const char *desc;
1040         time_t ctime;
1041         time_t mtime;
1042
1043         DEBUG("Printing the image info for image %d\n", image);
1044
1045         if (image == WIM_ALL_IMAGES) {
1046                 for (i = 1; i <= wim_info->num_images; i++)
1047                         print_image_info(wim_info, i);
1048         } else {
1049                 image_info = &wim_info->images[image - 1];
1050
1051                 printf("Index:                  %"PRIu64"\n",
1052                         image_info->index);
1053                 printf("Name:                   %s\n",
1054                         image_info->name);
1055
1056                 /* Always print the Description: part even if there is no
1057                  * description. */
1058                 if (image_info->description)
1059                         desc = image_info->description;
1060                 else
1061                         desc = "";
1062                 printf("Description:            %s\n", desc);
1063
1064                 if (image_info->display_name)
1065                         printf("Display Name:           %s\n",
1066                                 image_info->display_name);
1067
1068                 if (image_info->display_description)
1069                         printf("Display Description:    %s\n",
1070                                 image_info->display_description);
1071
1072                 printf("Directory Count:        %"PRIu64"\n",
1073                                 image_info->dir_count);
1074                 printf("File Count:             %"PRIu64"\n",
1075                                 image_info->file_count);
1076                 printf("Total Bytes:            %"PRIu64"\n",
1077                                 image_info->total_bytes);
1078                 printf("Hard Link Bytes:        %"PRIu64"\n",
1079                                 image_info->hard_link_bytes);
1080
1081                 ctime = ms_timestamp_to_unix(image_info->creation_time);
1082                 mtime = ms_timestamp_to_unix(image_info->last_modification_time);
1083
1084                 printf("Creation Time:          %s", asctime(localtime(&ctime)));
1085                 printf("Last Modification Time: %s", asctime(localtime(&mtime)));
1086                 if (image_info->windows_info_exists)
1087                         print_windows_info(&image_info->windows_info);
1088                 if (image_info->flags)
1089                         printf("Flags:                  %s\n", image_info->flags);
1090                 putchar('\n');
1091         }
1092 }
1093
1094 /*
1095  * Reads the XML data from a WIM file.
1096  */
1097 int read_xml_data(FILE *fp, const struct resource_entry *res, u8 **xml_data_ret,
1098                   struct wim_info **info_ret)
1099 {
1100         u8 *xml_data;
1101         xmlDoc *doc;
1102         xmlNode *root;
1103         int ret;
1104
1105         DEBUG("XML data is %"PRIu64" bytes long.\n", (u64)res->size);
1106
1107         if (resource_is_compressed(res)) {
1108                 ERROR("XML data is supposed to be uncompressed!\n");
1109                 ret = WIMLIB_ERR_XML;
1110                 goto err0;
1111         }
1112         if (res->size < 2) {
1113                 ERROR("XML data must be at least 2 bytes!\n");
1114                 ret = WIMLIB_ERR_XML;
1115                 goto err0;
1116         }
1117
1118         xml_data = MALLOC(res->size + 2);
1119         if (!xml_data) {
1120                 ret = WIMLIB_ERR_NOMEM;
1121                 goto err0;
1122         }
1123         ret = read_full_resource(fp, res->size, res->size, res->offset,
1124                                  WIM_COMPRESSION_TYPE_NONE, xml_data);
1125         if (ret != 0)
1126                 goto err1;
1127
1128         xml_data[res->size] = 0;
1129         xml_data[res->size + 1] = 0;
1130
1131         DEBUG("Parsing XML using libxml2 to create XML tree.\n");
1132
1133         doc = xmlReadMemory(xml_data, res->size, "noname.xml", "UTF-16", 0);
1134
1135
1136         if (!doc) {
1137                 ERROR("Failed to parse XML data!\n");
1138                 ret = WIMLIB_ERR_XML;
1139                 goto err1;
1140         }
1141
1142         DEBUG("Constructing WIM information structure from XML tree.\n");
1143
1144         root = xmlDocGetRootElement(doc);
1145         if (!root) {
1146                 ERROR("Empty XML document!\n");
1147                 ret = WIMLIB_ERR_XML;
1148                 goto err2;
1149         }
1150
1151         if (!node_is_element(root) || !node_name_is(root, "WIM")) {
1152                 ERROR("Expected <WIM> for the root XML element! "
1153                                 "(found <%s>)\n", root->name);
1154                 ret = WIMLIB_ERR_XML;
1155                 goto err2;
1156         }
1157
1158         ret = xml_read_wim_info(root, info_ret);
1159         if (ret != 0)
1160                 goto err2;
1161
1162         DEBUG("Freeing XML tree.\n");
1163
1164         xmlFreeDoc(doc);
1165         xmlCleanupParser();
1166         *xml_data_ret = xml_data;
1167         return 0;
1168 err2:
1169         xmlFreeDoc(doc);
1170 err1:
1171         FREE(xml_data);
1172 err0:
1173         xmlCleanupParser();
1174         return ret;
1175 }
1176
1177 #define CHECK_RET  ({   if (ret < 0)  { \
1178                                 ERROR("Error writing XML data!\n"); \
1179                                 ret = WIMLIB_ERR_WRITE; \
1180                                 goto err2; \
1181                         } })
1182
1183 /*
1184  * Writes XML data to a WIM file.
1185  */
1186 int write_xml_data(const struct wim_info *wim_info, int image, FILE *out)
1187 {
1188         xmlBuffer     *buf;
1189         xmlTextWriter *writer;
1190         char          *utf16_str;
1191         int ret;
1192         off_t total_bytes;
1193         int num_images;
1194         int i;
1195         const xmlChar *content;
1196         size_t len;
1197         size_t utf16_len;
1198         size_t bytes_written;
1199
1200         wimlib_assert(image == WIM_ALL_IMAGES ||
1201                         (wim_info != NULL && image >= 1 &&
1202                          image <= wim_info->num_images));
1203
1204         /* The contents of the <TOTALBYTES> element in the XML data, under the
1205          * <WIM> element not the <IMAGE> element, is the size of the WIM file
1206          * excluding the XML data and integrity table.  Which is the current
1207          * offset, since the XML data goes at the end of the WIM file before the
1208          * integrity table. */
1209         total_bytes = ftello(out);
1210         if (total_bytes == -1)
1211                 return WIMLIB_ERR_WRITE;
1212
1213         DEBUG("Creating XML buffer and text writer\n");
1214         buf = xmlBufferCreate();
1215         if (!buf) {
1216                 ERROR("Failed to allocate XML buffer!\n");
1217                 ret = WIMLIB_ERR_NOMEM;
1218                 goto err0;
1219         }
1220         writer = xmlNewTextWriterMemory(buf, 0);
1221         if (!writer) {
1222                 ERROR("Failed to allocate XML writer!\n");
1223                 ret = WIMLIB_ERR_NOMEM;
1224                 goto err1;
1225         }
1226
1227         /* XXX */
1228         /* M$'s WIM files do not have XML declarations, so do not write one.
1229          * I'm not sure how we can force the document to be written in UTF-16
1230          * without calling xmlTextWriterStartDocument(), though, so currently it
1231          * is composed in a buffer UTF-8, then converted to UTF-16. */
1232 #if 0
1233         ret = xmlTextWriterStartDocument(writer, NULL, "UTF-16", NULL);
1234         CHECK_RET;
1235 #endif
1236
1237         DEBUG("Writing <WIM> element\n");
1238         ret = xmlTextWriterStartElement(writer, "WIM");
1239         CHECK_RET;
1240
1241         ret = xmlTextWriterWriteFormatElement(writer, "TOTALBYTES", "%"PRIu64,
1242                                               total_bytes);
1243         CHECK_RET;
1244
1245         if (wim_info)
1246                 num_images = wim_info->num_images;
1247         else
1248                 num_images = 0;
1249         DEBUG("Writing %u <IMAGE> elements\n", num_images);
1250
1251         for (i = 1; i <= num_images; i++) {
1252                 if (image != WIM_ALL_IMAGES && i != image)
1253                         continue;
1254                 DEBUG("Writing <IMAGE> element for image %d\n", i);
1255                 ret = xml_write_image_info(writer, &wim_info->images[i - 1]);
1256                 CHECK_RET;
1257         }
1258
1259         ret = xmlTextWriterEndElement(writer);
1260         CHECK_RET;
1261
1262         ret = xmlTextWriterEndDocument(writer);
1263         CHECK_RET;
1264
1265         DEBUG("Done composing XML document. Now converting to UTF-16 and "
1266                         "writing it to the output file.\n");
1267
1268         content = xmlBufferContent(buf);
1269         len = xmlBufferLength(buf);
1270
1271         utf16_str = utf8_to_utf16(content, len, &utf16_len);
1272         if (!utf16_str) {
1273                 ret = WIMLIB_ERR_NOMEM;
1274                 goto err2;
1275         }
1276
1277         if ((putc(0xff, out)) == EOF || (putc(0xfe, out) == EOF) ||
1278                 ((bytes_written = fwrite(utf16_str, 1, utf16_len, out))
1279                                 != utf16_len)) {
1280                 ERROR("Error writing XML data: %m\n");
1281                 ret = WIMLIB_ERR_WRITE;
1282                 goto err3;
1283         }
1284
1285         DEBUG("Cleaning up.\n");
1286
1287         ret = 0;
1288 err3:
1289         FREE(utf16_str);
1290 err2:
1291         xmlFreeTextWriter(writer);
1292 err1:
1293         xmlBufferFree(buf);
1294 err0:
1295         return ret;
1296 }
1297
1298 /* Returns the name of the specified image. */
1299 WIMLIBAPI const char *wimlib_get_image_name(const WIMStruct *w, int image)
1300 {
1301         DEBUG("Getting the name of image %d\n", image);
1302         if (image < 1 || image > w->hdr.image_count)
1303                 return NULL;
1304
1305         return w->wim_info->images[image - 1].name;
1306 }
1307
1308 /* Returns the description of the specified image. */
1309 WIMLIBAPI const char *wimlib_get_image_description(const WIMStruct *w,
1310                                                    int image)
1311 {
1312         DEBUG("Getting the description of image %d\n", image);
1313         if (image < 1 || image > w->hdr.image_count)
1314                 return NULL;
1315
1316         return w->wim_info->images[image - 1].description;
1317 }
1318
1319 /* Determines if an image name is already used by some image in the WIM. */
1320 WIMLIBAPI bool wimlib_image_name_in_use(const WIMStruct *w, const char *name)
1321 {
1322         int i;
1323
1324         DEBUG("Checking to see if the image name `%s' is already "
1325                                                 "in use\n", name);
1326         if (!name || !w->wim_info)
1327                 return false;
1328         for (i = 1; i <= w->wim_info->num_images; i++)
1329                 if (strcmp(w->wim_info->images[i - 1].name, name) == 0)
1330                         return true;
1331
1332         return false;
1333 }
1334
1335 WIMLIBAPI int wimlib_extract_xml_data(WIMStruct *w, FILE *fp)
1336 {
1337         DEBUG("Extracting the XML data.\n");
1338         if (fwrite(w->xml_data, 1, w->hdr.xml_res_entry.size, fp) !=
1339                         w->hdr.xml_res_entry.size) {
1340                 ERROR("Failed to extract XML data!\n");
1341                 return WIMLIB_ERR_WRITE;
1342         }
1343         return 0;
1344 }
1345
1346 /* Sets the name of an image in the WIM. */
1347 WIMLIBAPI int wimlib_set_image_name(WIMStruct *w, int image, const char *name)
1348 {
1349         char *p;
1350         int i;
1351
1352         DEBUG("Setting the name of image %d to %s\n", image, name);
1353
1354         if (!name || !*name) {
1355                 ERROR("Must specify a non-empty string for the image "
1356                                 "name!\n");
1357                 return WIMLIB_ERR_INVALID_PARAM;
1358         }
1359         if (image < 1 || image > w->hdr.image_count) {
1360                 ERROR("%d is not a valid image!\n", image);
1361                 return WIMLIB_ERR_INVALID_IMAGE;
1362         }
1363
1364         for (i = 1; i <= w->hdr.image_count; i++) {
1365                 if (i == image)
1366                         continue;
1367                 if (strcmp(w->wim_info->images[i - 1].name, name) == 0) {
1368                         ERROR("The name `%s' is already used for image %d!\n",
1369                                         name, i);
1370                         return WIMLIB_ERR_IMAGE_NAME_COLLISION;
1371                 }
1372         }
1373
1374         p = STRDUP(name);
1375         if (!p) {
1376                 ERROR("Out of memory!\n");
1377                 return WIMLIB_ERR_NOMEM;
1378         }
1379         FREE(w->wim_info->images[image - 1].name);
1380         w->wim_info->images[image - 1].name = p;
1381         return 0;
1382 }
1383
1384 /* Sets the description of an image in the WIM. */
1385 WIMLIBAPI int wimlib_set_image_descripton(WIMStruct *w, int image,
1386                                           const char *description)
1387 {
1388         char *p;
1389
1390         DEBUG("Setting the description of image %d to %s\n", image,
1391               description);
1392
1393         if (image < 1 || image > w->hdr.image_count) {
1394                 ERROR("%d is not a valid image!\n", image);
1395                 return WIMLIB_ERR_INVALID_IMAGE;
1396         }
1397         if (description) {
1398                 p = STRDUP(description);
1399                 if (!p) {
1400                         ERROR("Out of memory!\n");
1401                         return WIMLIB_ERR_NOMEM;
1402                 }
1403         } else {
1404                 p = NULL;
1405         }
1406         FREE(w->wim_info->images[image - 1].description);
1407         w->wim_info->images[image - 1].description = p;
1408         return 0;
1409 }