wimlib.net Git - wimlib/blob - src/lookup_table.c

   1 /*
   2  * lookup_table.c
   3  *
   4  * Lookup table, implemented as a hash table, that maps SHA1 message digests to
   5  * data streams.
   6  */
   7
   8 /*
   9  * Copyright (C) 2012, 2013 Eric Biggers
  10  *
  11  * This file is part of wimlib, a library for working with WIM files.
  12  *
  13  * wimlib is free software; you can redistribute it and/or modify it under the
  14  * terms of the GNU General Public License as published by the Free
  15  * Software Foundation; either version 3 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  20  * A PARTICULAR PURPOSE. See the GNU General Public License for more
  21  * details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  25  */
  26
  27 #include "wimlib_internal.h"
  28 #include "lookup_table.h"
  29 #include "buffer_io.h"
  30 #include <errno.h>
  31
  32 #ifdef WITH_FUSE
  33 #include <unistd.h>
  34 #endif
  35
  36 struct wim_lookup_table *new_lookup_table(size_t capacity)
  37 {
  38         struct wim_lookup_table *table;
  39         struct hlist_head *array;
  40
  41         table = MALLOC(sizeof(struct wim_lookup_table));
  42         if (table) {
  43                 array = CALLOC(capacity, sizeof(array[0]));
  44                 if (array) {
  45                         table->num_entries = 0;
  46                         table->capacity = capacity;
  47                         table->array = array;
  48                 } else {
  49                         FREE(table);
  50                         table = NULL;
  51                         ERROR("Failed to allocate memory for lookup table with capacity %zu",
  52                               capacity);
  53                 }
  54         }
  55         return table;
  56 }
  57
  58 struct wim_lookup_table_entry *
  59 new_lookup_table_entry()
  60 {
  61         struct wim_lookup_table_entry *lte;
  62
  63         lte = CALLOC(1, sizeof(struct wim_lookup_table_entry));
  64         if (lte) {
  65                 lte->part_number  = 1;
  66                 lte->refcnt       = 1;
  67         } else {
  68                 ERROR("Out of memory (tried to allocate %zu bytes for "
  69                       "lookup table entry)",
  70                       sizeof(struct wim_lookup_table_entry));
  71         }
  72         return lte;
  73 }
  74
  75 struct wim_lookup_table_entry *
  76 clone_lookup_table_entry(const struct wim_lookup_table_entry *old)
  77 {
  78         struct wim_lookup_table_entry *new;
  79
  80         new = MALLOC(sizeof(*new));
  81         if (!new)
  82                 return NULL;
  83
  84         memcpy(new, old, sizeof(*old));
  85         new->extracted_file = NULL;
  86         switch (new->resource_location) {
  87         case RESOURCE_IN_STAGING_FILE:
  88         case RESOURCE_IN_FILE_ON_DISK:
  89 #if defined(__CYGWIN__) || defined(__WIN32__)
  90         case RESOURCE_WIN32:
  91 #endif
  92                 BUILD_BUG_ON((void*)&old->file_on_disk !=
  93                              (void*)&old->staging_file_name);
  94                 new->staging_file_name = STRDUP(old->staging_file_name);
  95                 if (!new->staging_file_name)
  96                         goto out_free;
  97                 break;
  98         case RESOURCE_IN_ATTACHED_BUFFER:
  99                 new->attached_buffer = MALLOC(wim_resource_size(old));
 100                 if (!new->attached_buffer)
 101                         goto out_free;
 102                 memcpy(new->attached_buffer, old->attached_buffer,
 103                        wim_resource_size(old));
 104                 break;
 105 #ifdef WITH_NTFS_3G
 106         case RESOURCE_IN_NTFS_VOLUME:
 107                 if (old->ntfs_loc) {
 108                         struct ntfs_location *loc;
 109                         loc = MALLOC(sizeof(*loc));
 110                         if (!loc)
 111                                 goto out_free;
 112                         memcpy(loc, old->ntfs_loc, sizeof(*loc));
 113                         loc->path_utf8 = NULL;
 114                         loc->stream_name_utf16 = NULL;
 115                         new->ntfs_loc = loc;
 116                         loc->path_utf8 = STRDUP(old->ntfs_loc->path_utf8);
 117                         if (!loc->path_utf8)
 118                                 goto out_free;
 119                         loc->stream_name_utf16 = MALLOC(loc->stream_name_utf16_num_chars * 2);
 120                         if (!loc->stream_name_utf16)
 121                                 goto out_free;
 122                         memcpy(loc->stream_name_utf16,
 123                                old->ntfs_loc->stream_name_utf16,
 124                                loc->stream_name_utf16_num_chars * 2);
 125                 }
 126                 break;
 127 #endif
 128         default:
 129                 break;
 130         }
 131         return new;
 132 out_free:
 133         free_lookup_table_entry(new);
 134         return NULL;
 135 }
 136
 137 void free_lookup_table_entry(struct wim_lookup_table_entry *lte)
 138 {
 139         if (lte) {
 140                 switch (lte->resource_location) {
 141                 case RESOURCE_IN_STAGING_FILE:
 142                 case RESOURCE_IN_ATTACHED_BUFFER:
 143                 case RESOURCE_IN_FILE_ON_DISK:
 144 #if defined(__CYGWIN__) || defined(__WIN32__)
 145                 case RESOURCE_WIN32:
 146 #endif
 147                         BUILD_BUG_ON((void*)&lte->file_on_disk !=
 148                                      (void*)&lte->staging_file_name);
 149                         BUILD_BUG_ON((void*)&lte->file_on_disk !=
 150                                      (void*)&lte->attached_buffer);
 151                         FREE(lte->file_on_disk);
 152                         break;
 153 #ifdef WITH_NTFS_3G
 154                 case RESOURCE_IN_NTFS_VOLUME:
 155                         if (lte->ntfs_loc) {
 156                                 FREE(lte->ntfs_loc->path_utf8);
 157                                 FREE(lte->ntfs_loc->stream_name_utf16);
 158                                 FREE(lte->ntfs_loc);
 159                         }
 160                         break;
 161 #endif
 162                 default:
 163                         break;
 164                 }
 165                 FREE(lte);
 166         }
 167 }
 168
 169 static int do_free_lookup_table_entry(struct wim_lookup_table_entry *entry,
 170                                       void *ignore)
 171 {
 172         free_lookup_table_entry(entry);
 173         return 0;
 174 }
 175
 176
 177 void free_lookup_table(struct wim_lookup_table *table)
 178 {
 179         DEBUG2("Freeing lookup table");
 180         if (table) {
 181                 if (table->array) {
 182                         for_lookup_table_entry(table,
 183                                                do_free_lookup_table_entry,
 184                                                NULL);
 185                         FREE(table->array);
 186                 }
 187                 FREE(table);
 188         }
 189 }
 190
 191 /*
 192  * Inserts an entry into the lookup table.
 193  *
 194  * @table:      A pointer to the lookup table.
 195  * @lte:        A pointer to the entry to insert.
 196  */
 197 void lookup_table_insert(struct wim_lookup_table *table,
 198                          struct wim_lookup_table_entry *lte)
 199 {
 200         size_t i = lte->hash_short % table->capacity;
 201         hlist_add_head(&lte->hash_list, &table->array[i]);
 202
 203         /* XXX Make the table grow when too many entries have been inserted. */
 204         table->num_entries++;
 205 }
 206
 207 static void finalize_lte(struct wim_lookup_table_entry *lte)
 208 {
 209         #ifdef WITH_FUSE
 210         if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
 211                 unlink(lte->staging_file_name);
 212                 list_del(&lte->staging_list);
 213         }
 214         #endif
 215         free_lookup_table_entry(lte);
 216 }
 217
 218 /* Decrements the reference count for the lookup table entry @lte.  If its
 219  * reference count reaches 0, it is unlinked from the lookup table.  If,
 220  * furthermore, the entry has no opened file descriptors associated with it, the
 221  * entry is freed.  */
 222 void lte_decrement_refcnt(struct wim_lookup_table_entry *lte,
 223                           struct wim_lookup_table *table)
 224 {
 225         wimlib_assert(lte != NULL);
 226         wimlib_assert(lte->refcnt != 0);
 227         if (--lte->refcnt == 0) {
 228                 lookup_table_unlink(table, lte);
 229         #ifdef WITH_FUSE
 230                 if (lte->num_opened_fds == 0)
 231         #endif
 232                         finalize_lte(lte);
 233         }
 234 }
 235
 236 #ifdef WITH_FUSE
 237 void lte_decrement_num_opened_fds(struct wim_lookup_table_entry *lte)
 238 {
 239         if (lte->num_opened_fds != 0)
 240                 if (--lte->num_opened_fds == 0 && lte->refcnt == 0)
 241                         finalize_lte(lte);
 242 }
 243 #endif
 244
 245 /* Calls a function on all the entries in the WIM lookup table.  Stop early and
 246  * return nonzero if any call to the function returns nonzero. */
 247 int for_lookup_table_entry(struct wim_lookup_table *table,
 248                            int (*visitor)(struct wim_lookup_table_entry *, void *),
 249                            void *arg)
 250 {
 251         struct wim_lookup_table_entry *lte;
 252         struct hlist_node *pos, *tmp;
 253         int ret;
 254
 255         for (size_t i = 0; i < table->capacity; i++) {
 256                 hlist_for_each_entry_safe(lte, pos, tmp, &table->array[i],
 257                                           hash_list)
 258                 {
 259                         ret = visitor(lte, arg);
 260                         if (ret != 0)
 261                                 return ret;
 262                 }
 263         }
 264         return 0;
 265 }
 266
 267
 268 /*
 269  * Reads the lookup table from a WIM file.
 270  */
 271 int read_lookup_table(WIMStruct *w)
 272 {
 273         u64 num_entries;
 274         u8 buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
 275         int ret;
 276         struct wim_lookup_table *table;
 277         struct wim_lookup_table_entry *cur_entry = NULL, *duplicate_entry;
 278
 279         if (resource_is_compressed(&w->hdr.lookup_table_res_entry)) {
 280                 ERROR("Didn't expect a compressed lookup table!");
 281                 ERROR("Ask the author to implement support for this.");
 282                 return WIMLIB_ERR_COMPRESSED_LOOKUP_TABLE;
 283         }
 284
 285         DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
 286               w->hdr.lookup_table_res_entry.offset,
 287               w->hdr.lookup_table_res_entry.original_size);
 288
 289         if (fseeko(w->fp, w->hdr.lookup_table_res_entry.offset, SEEK_SET) != 0)
 290         {
 291                 ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
 292                                  "lookup table",
 293                                  w->hdr.lookup_table_res_entry.offset);
 294                 return WIMLIB_ERR_READ;
 295         }
 296
 297         num_entries = w->hdr.lookup_table_res_entry.original_size /
 298                       WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE;
 299         table = new_lookup_table(num_entries * 2 + 1);
 300         if (!table)
 301                 return WIMLIB_ERR_NOMEM;
 302
 303         while (num_entries--) {
 304                 const u8 *p;
 305
 306                 if (fread(buf, 1, sizeof(buf), w->fp) != sizeof(buf)) {
 307                         if (feof(w->fp)) {
 308                                 ERROR("Unexpected EOF in WIM lookup table!");
 309                         } else {
 310                                 ERROR_WITH_ERRNO("Error reading WIM lookup "
 311                                                  "table");
 312                         }
 313                         ret = WIMLIB_ERR_READ;
 314                         goto out;
 315                 }
 316                 cur_entry = new_lookup_table_entry();
 317                 if (!cur_entry) {
 318                         ret = WIMLIB_ERR_NOMEM;
 319                         goto out;
 320                 }
 321                 cur_entry->wim = w;
 322                 cur_entry->resource_location = RESOURCE_IN_WIM;
 323
 324                 p = get_resource_entry(buf, &cur_entry->resource_entry);
 325                 p = get_u16(p, &cur_entry->part_number);
 326                 p = get_u32(p, &cur_entry->refcnt);
 327                 p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
 328
 329                 if (cur_entry->part_number != w->hdr.part_number) {
 330                         ERROR("A lookup table entry in part %hu of the WIM "
 331                               "points to part %hu",
 332                               w->hdr.part_number, cur_entry->part_number);
 333                         ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 334                         goto out_free_cur_entry;
 335                 }
 336
 337                 if (is_zero_hash(cur_entry->hash)) {
 338                         ERROR("The WIM lookup table contains an entry with a "
 339                               "SHA1 message digest of all 0's");
 340                         ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 341                         goto out_free_cur_entry;
 342                 }
 343
 344                 /* Ordinarily, no two streams should share the same SHA1 message
 345                  * digest.  However, this constraint can be broken for metadata
 346                  * resources--- two identical images will have the same metadata
 347                  * resource, but their lookup table entries are not shared. */
 348                 duplicate_entry = __lookup_resource(table, cur_entry->hash);
 349                 if (duplicate_entry
 350                     && !((duplicate_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA)
 351                           && cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA))
 352                 {
 353                 #ifdef ENABLE_ERROR_MESSAGES
 354                         ERROR("The WIM lookup table contains two entries with the "
 355                               "same SHA1 message digest!");
 356                         ERROR("The first entry is:");
 357                         print_lookup_table_entry(duplicate_entry, stderr);
 358                         ERROR("The second entry is:");
 359                         print_lookup_table_entry(cur_entry, stderr);
 360                 #endif
 361                         ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 362                         goto out_free_cur_entry;
 363                 }
 364
 365                 if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
 366                     && (cur_entry->resource_entry.size !=
 367                         cur_entry->resource_entry.original_size))
 368                 {
 369                 #ifdef ENABLE_ERROR_MESSAGES
 370                         ERROR("Found uncompressed resource with original size "
 371                               "not the same as compressed size");
 372                         ERROR("The lookup table entry for the resource is as follows:");
 373                         print_lookup_table_entry(cur_entry, stderr);
 374                 #endif
 375                         ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 376                         goto out_free_cur_entry;
 377                 }
 378                 if ((cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA)
 379                     && cur_entry->refcnt != 1)
 380                 {
 381                 #ifdef ENABLE_ERROR_MESSAGES
 382                         ERROR("Found metadata resource with refcnt != 1:");
 383                         print_lookup_table_entry(cur_entry, stderr);
 384                 #endif
 385                         ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 386                         goto out_free_cur_entry;
 387                 }
 388                 lookup_table_insert(table, cur_entry);
 389
 390         }
 391         DEBUG("Done reading lookup table.");
 392         w->lookup_table = table;
 393         return 0;
 394 out_free_cur_entry:
 395         FREE(cur_entry);
 396 out:
 397         free_lookup_table(table);
 398         return ret;
 399 }
 400
 401
 402 /*
 403  * Writes a lookup table entry to the output file.
 404  */
 405 int write_lookup_table_entry(struct wim_lookup_table_entry *lte, void *__out)
 406 {
 407         FILE *out;
 408         u8 buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
 409         u8 *p;
 410
 411         out = __out;
 412
 413         /* Don't write entries that have not had file resources or metadata
 414          * resources written for them. */
 415         if (lte->out_refcnt == 0)
 416                 return 0;
 417
 418         if (lte->output_resource_entry.flags & WIM_RESHDR_FLAG_METADATA) {
 419                 DEBUG("Writing metadata entry at %"PRIu64" "
 420                       "(orig size = %"PRIu64")",
 421                       ftello(out), lte->output_resource_entry.original_size);
 422         }
 423
 424         p = put_resource_entry(buf, &lte->output_resource_entry);
 425         p = put_u16(p, lte->part_number);
 426         p = put_u32(p, lte->out_refcnt);
 427         p = put_bytes(p, SHA1_HASH_SIZE, lte->hash);
 428         if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) {
 429                 ERROR_WITH_ERRNO("Failed to write lookup table entry");
 430                 return WIMLIB_ERR_WRITE;
 431         }
 432         return 0;
 433 }
 434
 435 /* Writes the lookup table to the output file. */
 436 int write_lookup_table(struct wim_lookup_table *table, FILE *out,
 437                        struct resource_entry *out_res_entry)
 438 {
 439         off_t start_offset, end_offset;
 440         int ret;
 441
 442         start_offset = ftello(out);
 443         if (start_offset == -1)
 444                 return WIMLIB_ERR_WRITE;
 445
 446         ret = for_lookup_table_entry(table, write_lookup_table_entry, out);
 447         if (ret != 0)
 448                 return ret;
 449
 450         end_offset = ftello(out);
 451         if (end_offset == -1)
 452                 return WIMLIB_ERR_WRITE;
 453
 454         out_res_entry->offset        = start_offset;
 455         out_res_entry->size          = end_offset - start_offset;
 456         out_res_entry->original_size = end_offset - start_offset;
 457         out_res_entry->flags         = WIM_RESHDR_FLAG_METADATA;
 458
 459         return 0;
 460 }
 461
 462
 463 int lte_zero_real_refcnt(struct wim_lookup_table_entry *lte, void *ignore)
 464 {
 465         lte->real_refcnt = 0;
 466         return 0;
 467 }
 468
 469 int lte_zero_out_refcnt(struct wim_lookup_table_entry *lte, void *ignore)
 470 {
 471         lte->out_refcnt = 0;
 472         return 0;
 473 }
 474
 475 int lte_free_extracted_file(struct wim_lookup_table_entry *lte, void *ignore)
 476 {
 477         if (lte->extracted_file != NULL) {
 478                 FREE(lte->extracted_file);
 479                 lte->extracted_file = NULL;
 480         }
 481         return 0;
 482 }
 483
 484 void print_lookup_table_entry(const struct wim_lookup_table_entry *lte,
 485                               FILE *out)
 486 {
 487         if (!lte) {
 488                 putc('\n', out);
 489                 return;
 490         }
 491         fprintf(out, "Offset            = %"PRIu64" bytes\n",
 492                lte->resource_entry.offset);
 493         fprintf(out, "Size              = %"PRIu64" bytes\n",
 494                (u64)lte->resource_entry.size);
 495         fprintf(out, "Original size     = %"PRIu64" bytes\n",
 496                lte->resource_entry.original_size);
 497         fprintf(out, "Part Number       = %hu\n", lte->part_number);
 498         fprintf(out, "Reference Count   = %u\n", lte->refcnt);
 499         fprintf(out, "Hash              = 0x");
 500         print_hash(lte->hash);
 501         putc('\n', out);
 502         fprintf(out, "Flags             = ");
 503         u8 flags = lte->resource_entry.flags;
 504         if (flags & WIM_RESHDR_FLAG_COMPRESSED)
 505                 fputs("WIM_RESHDR_FLAG_COMPRESSED, ", out);
 506         if (flags & WIM_RESHDR_FLAG_FREE)
 507                 fputs("WIM_RESHDR_FLAG_FREE, ", out);
 508         if (flags & WIM_RESHDR_FLAG_METADATA)
 509                 fputs("WIM_RESHDR_FLAG_METADATA, ", out);
 510         if (flags & WIM_RESHDR_FLAG_SPANNED)
 511                 fputs("WIM_RESHDR_FLAG_SPANNED, ", out);
 512         putc('\n', out);
 513         switch (lte->resource_location) {
 514         case RESOURCE_IN_WIM:
 515                 if (lte->wim->filename) {
 516                         fprintf(out, "WIM file          = `%s'\n",
 517                                lte->wim->filename);
 518                 }
 519                 break;
 520         case RESOURCE_IN_FILE_ON_DISK:
 521                 fprintf(out, "File on Disk      = `%s'\n", lte->file_on_disk);
 522                 break;
 523         case RESOURCE_IN_STAGING_FILE:
 524                 fprintf(out, "Staging File      = `%s'\n", lte->staging_file_name);
 525                 break;
 526         default:
 527                 break;
 528         }
 529         putc('\n', out);
 530 }
 531
 532 static int do_print_lookup_table_entry(struct wim_lookup_table_entry *lte,
 533                                        void *fp)
 534 {
 535         print_lookup_table_entry(lte, (FILE*)fp);
 536         return 0;
 537 }
 538
 539 /*
 540  * Prints the lookup table of a WIM file.
 541  */
 542 WIMLIBAPI void wimlib_print_lookup_table(WIMStruct *w)
 543 {
 544         for_lookup_table_entry(w->lookup_table,
 545                                do_print_lookup_table_entry,
 546                                stdout);
 547 }
 548
 549 /* Given a SHA1 message digest, return the corresponding entry in the WIM's
 550  * lookup table, or NULL if there is none.  */
 551 struct wim_lookup_table_entry *
 552 __lookup_resource(const struct wim_lookup_table *table, const u8 hash[])
 553 {
 554         size_t i;
 555         struct wim_lookup_table_entry *lte;
 556         struct hlist_node *pos;
 557
 558         wimlib_assert(table != NULL);
 559         wimlib_assert(hash != NULL);
 560
 561         i = *(size_t*)hash % table->capacity;
 562         hlist_for_each_entry(lte, pos, &table->array[i], hash_list)
 563                 if (hashes_equal(hash, lte->hash))
 564                         return lte;
 565         return NULL;
 566 }
 567
 568 #ifdef WITH_FUSE
 569 /*
 570  * Finds the dentry, lookup table entry, and stream index for a WIM file stream,
 571  * given a path name.
 572  *
 573  * This is only for pre-resolved inodes.
 574  */
 575 int lookup_resource(WIMStruct *w, const char *path,
 576                     int lookup_flags,
 577                     struct wim_dentry **dentry_ret,
 578                     struct wim_lookup_table_entry **lte_ret,
 579                     u16 *stream_idx_ret)
 580 {
 581         struct wim_dentry *dentry;
 582         struct wim_lookup_table_entry *lte;
 583         u16 stream_idx;
 584         const char *stream_name = NULL;
 585         struct wim_inode *inode;
 586         char *p = NULL;
 587
 588         if (lookup_flags & LOOKUP_FLAG_ADS_OK) {
 589                 stream_name = path_stream_name(path);
 590                 if (stream_name) {
 591                         p = (char*)stream_name - 1;
 592                         *p = '\0';
 593                 }
 594         }
 595
 596         dentry = get_dentry(w, path);
 597         if (p)
 598                 *p = ':';
 599         if (!dentry)
 600                 return -ENOENT;
 601
 602         inode = dentry->d_inode;
 603
 604         wimlib_assert(inode->i_resolved);
 605
 606         if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
 607               && inode_is_directory(inode))
 608                 return -EISDIR;
 609
 610         if (stream_name) {
 611                 struct wim_ads_entry *ads_entry;
 612                 u16 ads_idx;
 613                 ads_entry = inode_get_ads_entry(inode, stream_name,
 614                                                 &ads_idx);
 615                 if (ads_entry) {
 616                         stream_idx = ads_idx + 1;
 617                         lte = ads_entry->lte;
 618                         goto out;
 619                 } else {
 620                         return -ENOENT;
 621                 }
 622         } else {
 623                 lte = inode->i_lte;
 624                 stream_idx = 0;
 625         }
 626 out:
 627         if (dentry_ret)
 628                 *dentry_ret = dentry;
 629         if (lte_ret)
 630                 *lte_ret = lte;
 631         if (stream_idx_ret)
 632                 *stream_idx_ret = stream_idx;
 633         return 0;
 634 }
 635 #endif
 636
 637 /* Resolve an inode's lookup table entries
 638  *
 639  * This replaces the SHA1 hash fields (which are used to lookup an entry in the
 640  * lookup table) with pointers directly to the lookup table entries.  A circular
 641  * linked list of streams sharing the same lookup table entry is created.
 642  *
 643  * This function always succeeds; unresolved lookup table entries are given a
 644  * NULL pointer.
 645  */
 646 void inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table)
 647 {
 648
 649         if (!inode->i_resolved) {
 650                 struct wim_lookup_table_entry *lte;
 651                 /* Resolve the default file stream */
 652                 lte = __lookup_resource(table, inode->i_hash);
 653                 inode->i_lte = lte;
 654                 inode->i_resolved = 1;
 655
 656                 /* Resolve the alternate data streams */
 657                 for (u16 i = 0; i < inode->i_num_ads; i++) {
 658                         struct wim_ads_entry *cur_entry = &inode->i_ads_entries[i];
 659                         lte = __lookup_resource(table, cur_entry->hash);
 660                         cur_entry->lte = lte;
 661                 }
 662         }
 663 }
 664
 665 void inode_unresolve_ltes(struct wim_inode *inode)
 666 {
 667         if (inode->i_resolved) {
 668                 if (inode->i_lte)
 669                         copy_hash(inode->i_hash, inode->i_lte->hash);
 670                 else
 671                         zero_out_hash(inode->i_hash);
 672
 673                 for (u16 i = 0; i < inode->i_num_ads; i++) {
 674                         if (inode->i_ads_entries[i].lte)
 675                                 copy_hash(inode->i_ads_entries[i].hash,
 676                                           inode->i_ads_entries[i].lte->hash);
 677                         else
 678                                 zero_out_hash(inode->i_ads_entries[i].hash);
 679                 }
 680                 inode->i_resolved = 0;
 681         }
 682 }
 683
 684 /*
 685  * Returns the lookup table entry for stream @stream_idx of the inode, where
 686  * stream_idx = 0 means the default un-named file stream, and stream_idx >= 1
 687  * corresponds to an alternate data stream.
 688  *
 689  * This works for both resolved and un-resolved dentries.
 690  */
 691 struct wim_lookup_table_entry *
 692 inode_stream_lte(const struct wim_inode *inode, unsigned stream_idx,
 693                  const struct wim_lookup_table *table)
 694 {
 695         if (inode->i_resolved)
 696                 return inode_stream_lte_resolved(inode, stream_idx);
 697         else
 698                 return inode_stream_lte_unresolved(inode, stream_idx, table);
 699 }
 700
 701
 702 /* Return the lookup table entry for the unnamed data stream of an inode, or
 703  * NULL if there is none.
 704  *
 705  * You'd think this would be easier than it actually is, since the unnamed data
 706  * stream should be the one referenced from the inode itself.  Alas, if there
 707  * are named data streams, Microsoft's "imagex.exe" program will put the unnamed
 708  * data stream in one of the alternate data streams instead of inside the WIM
 709  * dentry itself.  So we need to check the alternate data streams too.
 710  *
 711  * Also, note that a dentry may appear to have more than one unnamed stream, but
 712  * if the SHA1 message digest is all 0's then the corresponding stream does not
 713  * really "count" (this is the case for the inode's own file stream when the
 714  * file stream that should be there is actually in one of the alternate stream
 715  * entries.).  This is despite the fact that we may need to extract such a
 716  * missing entry as an empty file or empty named data stream.
 717  */
 718 struct wim_lookup_table_entry *
 719 inode_unnamed_lte(const struct wim_inode *inode,
 720                   const struct wim_lookup_table *table)
 721 {
 722         if (inode->i_resolved)
 723                 return inode_unnamed_lte_resolved(inode);
 724         else
 725                 return inode_unnamed_lte_unresolved(inode, table);
 726 }
 727
 728 static int lte_add_stream_size(struct wim_lookup_table_entry *lte,
 729                                void *total_bytes_p)
 730 {
 731         *(u64*)total_bytes_p += lte->resource_entry.size;
 732         return 0;
 733 }
 734
 735 u64 lookup_table_total_stream_size(struct wim_lookup_table *table)
 736 {
 737         u64 total_size = 0;
 738         for_lookup_table_entry(table, lte_add_stream_size, &total_size);
 739         return total_size;
 740 }