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

   1 /*
   2  * inode.c
   3  *
   4  * Functions that operate on WIM inodes.
   5  *
   6  * See dentry.c for a description of the relationship between WIM dentries and
   7  * WIM inodes.
   8  */
   9
  10 /*
  11  * Copyright (C) 2012, 2013, 2014 Eric Biggers
  12  *
  13  * This file is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the Free
  15  * Software Foundation; either version 3 of the License, or (at your option) any
  16  * later version.
  17  *
  18  * This file is distributed in the hope that it will be useful, but WITHOUT
  19  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  20  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  21  * details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this file; if not, see http://www.gnu.org/licenses/.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include "config.h"
  29 #endif
  30
  31 #include <errno.h>
  32
  33 #include "wimlib/assert.h"
  34 #include "wimlib/dentry.h"
  35 #include "wimlib/encoding.h"
  36 #include "wimlib/endianness.h"
  37 #include "wimlib/error.h"
  38 #include "wimlib/inode.h"
  39 #include "wimlib/lookup_table.h"
  40 #include "wimlib/security.h"
  41 #include "wimlib/timestamp.h"
  42
  43 /* Allocate a new inode.  Set the timestamps to the current time.  */
  44 struct wim_inode *
  45 new_inode(void)
  46 {
  47         struct wim_inode *inode = new_timeless_inode();
  48         if (inode) {
  49                 u64 now = now_as_wim_timestamp();
  50                 inode->i_creation_time = now;
  51                 inode->i_last_access_time = now;
  52                 inode->i_last_write_time = now;
  53         }
  54         return inode;
  55 }
  56
  57 /* Allocate a new inode.  Leave the timestamps zeroed out.  */
  58 struct wim_inode *
  59 new_timeless_inode(void)
  60 {
  61         struct wim_inode *inode = CALLOC(1, sizeof(struct wim_inode));
  62         if (inode) {
  63                 inode->i_security_id = -1;
  64                 /*inode->i_nlink = 0;*/
  65                 inode->i_next_stream_id = 1;
  66                 inode->i_not_rpfixed = 1;
  67                 inode->i_canonical_streams = 1;
  68                 INIT_LIST_HEAD(&inode->i_list);
  69                 INIT_LIST_HEAD(&inode->i_dentry);
  70         }
  71         return inode;
  72 }
  73
  74 /* Free memory allocated within an alternate data stream entry.  */
  75 static void
  76 destroy_ads_entry(struct wim_ads_entry *ads_entry)
  77 {
  78         FREE(ads_entry->stream_name);
  79 }
  80
  81 static void
  82 free_inode(struct wim_inode *inode)
  83 {
  84         if (unlikely(inode->i_ads_entries)) {
  85                 for (unsigned i = 0; i < inode->i_num_ads; i++)
  86                         destroy_ads_entry(&inode->i_ads_entries[i]);
  87                 FREE(inode->i_ads_entries);
  88         }
  89         if (unlikely(inode->i_extra))
  90                 FREE(inode->i_extra);
  91         /* HACK: This may instead delete the inode from i_list, but hlist_del()
  92          * behaves the same as list_del(). */
  93         if (!hlist_unhashed(&inode->i_hlist))
  94                 hlist_del(&inode->i_hlist);
  95         FREE(inode);
  96 }
  97
  98 static inline void
  99 free_inode_if_unneeded(struct wim_inode *inode)
 100 {
 101         if (inode->i_nlink)
 102                 return;
 103 #ifdef WITH_FUSE
 104         if (inode->i_num_opened_fds)
 105                 return;
 106 #endif
 107         free_inode(inode);
 108 }
 109
 110 /* Associate a dentry with the specified inode.  */
 111 void
 112 d_associate(struct wim_dentry *dentry, struct wim_inode *inode)
 113 {
 114         wimlib_assert(!dentry->d_inode);
 115
 116         list_add_tail(&dentry->d_alias, &inode->i_dentry);
 117         dentry->d_inode = inode;
 118         inode->i_nlink++;
 119 }
 120
 121 /* Disassociate a dentry from its inode, if any.  Following this, free the inode
 122  * if it is no longer in use.  */
 123 void
 124 d_disassociate(struct wim_dentry *dentry)
 125 {
 126         struct wim_inode *inode = dentry->d_inode;
 127
 128         if (unlikely(!inode))
 129                 return;
 130
 131         wimlib_assert(inode->i_nlink > 0);
 132
 133         list_del(&dentry->d_alias);
 134         dentry->d_inode = NULL;
 135         inode->i_nlink--;
 136
 137         free_inode_if_unneeded(inode);
 138 }
 139
 140 #ifdef WITH_FUSE
 141 void
 142 inode_dec_num_opened_fds(struct wim_inode *inode)
 143 {
 144         wimlib_assert(inode->i_num_opened_fds > 0);
 145
 146         if (--inode->i_num_opened_fds == 0) {
 147                 /* The last file descriptor to this inode was closed.  */
 148                 FREE(inode->i_fds);
 149                 inode->i_fds = NULL;
 150                 inode->i_num_allocated_fds = 0;
 151
 152                 free_inode_if_unneeded(inode);
 153         }
 154 }
 155 #endif
 156
 157 /*
 158  * Returns the alternate data stream entry belonging to @inode that has the
 159  * stream name @stream_name, or NULL if the inode has no alternate data stream
 160  * with that name.
 161  *
 162  * If @p stream_name is the empty string, NULL is returned --- that is, this
 163  * function will not return "unnamed" alternate data stream entries.
 164  *
 165  * If NULL is returned, errno is set.
 166  */
 167 struct wim_ads_entry *
 168 inode_get_ads_entry(struct wim_inode *inode, const tchar *stream_name)
 169 {
 170         int ret;
 171         const utf16lechar *stream_name_utf16le;
 172         size_t stream_name_utf16le_nbytes;
 173         unsigned i;
 174         struct wim_ads_entry *result;
 175
 176         if (inode->i_num_ads == 0) {
 177                 errno = ENOENT;
 178                 return NULL;
 179         }
 180
 181         if (stream_name[0] == T('\0')) {
 182                 errno = ENOENT;
 183                 return NULL;
 184         }
 185
 186         ret = tstr_get_utf16le_and_len(stream_name, &stream_name_utf16le,
 187                                        &stream_name_utf16le_nbytes);
 188         if (ret)
 189                 return NULL;
 190
 191         i = 0;
 192         result = NULL;
 193         do {
 194                 if (!cmp_utf16le_strings(inode->i_ads_entries[i].stream_name,
 195                                          inode->i_ads_entries[i].stream_name_nbytes /
 196                                                 sizeof(utf16lechar),
 197                                          stream_name_utf16le,
 198                                          stream_name_utf16le_nbytes /
 199                                                 sizeof(utf16lechar),
 200                                          default_ignore_case))
 201                 {
 202                         result = &inode->i_ads_entries[i];
 203                         break;
 204                 }
 205         } while (++i != inode->i_num_ads);
 206
 207         tstr_put_utf16le(stream_name_utf16le);
 208
 209         if (!result)
 210                 errno = ENOENT;
 211         return result;
 212 }
 213
 214 static struct wim_ads_entry *
 215 do_inode_add_ads(struct wim_inode *inode,
 216                  utf16lechar *stream_name, size_t stream_name_nbytes)
 217 {
 218         unsigned num_ads;
 219         struct wim_ads_entry *ads_entries;
 220         struct wim_ads_entry *new_entry;
 221
 222         if (unlikely(inode->i_num_ads >= 0xfffe)) {
 223                 ERROR("File \"%"TS"\" has too many alternate data streams!",
 224                       inode_first_full_path(inode));
 225                 errno = EFBIG;
 226                 return NULL;
 227         }
 228         num_ads = inode->i_num_ads + 1;
 229         ads_entries = REALLOC(inode->i_ads_entries,
 230                               num_ads * sizeof(inode->i_ads_entries[0]));
 231         if (!ads_entries)
 232                 return NULL;
 233
 234         inode->i_ads_entries = ads_entries;
 235
 236         new_entry = &inode->i_ads_entries[num_ads - 1];
 237
 238         memset(new_entry, 0, sizeof(struct wim_ads_entry));
 239         new_entry->stream_name = stream_name;
 240         new_entry->stream_name_nbytes = stream_name_nbytes;
 241         new_entry->stream_id = inode->i_next_stream_id++;
 242         inode->i_num_ads = num_ads;
 243         return new_entry;
 244 }
 245
 246 /*
 247  * Add an alternate data stream entry to a WIM inode (UTF-16LE version).  On
 248  * success, returns a pointer to the new entry.  Note that this pointer might
 249  * become invalid if another ADS entry is added to the inode.  On failure,
 250  * returns NULL and sets errno.
 251  */
 252 struct wim_ads_entry *
 253 inode_add_ads_utf16le(struct wim_inode *inode,
 254                       const utf16lechar *stream_name, size_t stream_name_nbytes)
 255 {
 256         utf16lechar *dup = NULL;
 257         struct wim_ads_entry *result;
 258
 259         if (stream_name_nbytes) {
 260                 dup = utf16le_dupz(stream_name, stream_name_nbytes);
 261                 if (!dup)
 262                         return NULL;
 263         }
 264
 265         result = do_inode_add_ads(inode, dup, stream_name_nbytes);
 266         if (!result)
 267                 FREE(dup);
 268         return result;
 269 }
 270
 271 /*
 272  * Add an alternate data stream entry to a WIM inode (tchar version).  On
 273  * success, returns a pointer to the new entry.  Note that this pointer might
 274  * become invalid if another ADS entry is added to the inode.  On failure,
 275  * returns NULL and sets errno.
 276  */
 277 struct wim_ads_entry *
 278 inode_add_ads(struct wim_inode *inode, const tchar *stream_name)
 279 {
 280         utf16lechar *stream_name_utf16le = NULL;
 281         size_t stream_name_utf16le_nbytes = 0;
 282         struct wim_ads_entry *result;
 283
 284         if (stream_name && *stream_name)
 285                 if (tstr_to_utf16le(stream_name,
 286                                     tstrlen(stream_name) * sizeof(tchar),
 287                                     &stream_name_utf16le,
 288                                     &stream_name_utf16le_nbytes))
 289                         return NULL;
 290
 291         result = do_inode_add_ads(inode, stream_name_utf16le,
 292                                   stream_name_utf16le_nbytes);
 293         if (!result)
 294                 FREE(stream_name_utf16le);
 295         return result;
 296 }
 297
 298 /*
 299  * Add an data alternate stream entry to a WIM inode, where the contents of the
 300  * new stream are specified in a data buffer.  The inode must be resolved.
 301  *
 302  * On success, returns a pointer to the new alternate data stream entry.  Note
 303  * that this pointer might become invalid if another ADS entry is added to the
 304  * inode.  On failure, returns NULL and sets errno.
 305  */
 306 struct wim_ads_entry *
 307 inode_add_ads_with_data(struct wim_inode *inode, const tchar *name,
 308                         const void *value, size_t size,
 309                         struct wim_lookup_table *lookup_table)
 310 {
 311         struct wim_ads_entry *new_entry;
 312
 313         wimlib_assert(inode->i_resolved);
 314
 315         new_entry = inode_add_ads(inode, name);
 316         if (unlikely(!new_entry))
 317                 return NULL;
 318
 319         new_entry->lte = new_stream_from_data_buffer(value, size, lookup_table);
 320         if (unlikely(!new_entry->lte)) {
 321                 inode_remove_ads(inode, new_entry, NULL);
 322                 return NULL;
 323         }
 324         return new_entry;
 325 }
 326
 327 /* Remove an alternate data stream from a WIM inode.  */
 328 void
 329 inode_remove_ads(struct wim_inode *inode, struct wim_ads_entry *entry,
 330                  struct wim_lookup_table *lookup_table)
 331 {
 332         struct wim_lookup_table_entry *lte;
 333         unsigned idx = entry - inode->i_ads_entries;
 334
 335         wimlib_assert(idx < inode->i_num_ads);
 336         wimlib_assert(inode->i_resolved);
 337
 338         lte = entry->lte;
 339         if (lte)
 340                 lte_decrement_refcnt(lte, lookup_table);
 341
 342         destroy_ads_entry(entry);
 343
 344         memmove(&inode->i_ads_entries[idx],
 345                 &inode->i_ads_entries[idx + 1],
 346                 (inode->i_num_ads - idx - 1) * sizeof(inode->i_ads_entries[0]));
 347         inode->i_num_ads--;
 348 }
 349
 350 /* Return true iff the specified inode has at least one named data stream.  */
 351 bool
 352 inode_has_named_stream(const struct wim_inode *inode)
 353 {
 354         for (unsigned i = 0; i < inode->i_num_ads; i++)
 355                 if (inode->i_ads_entries[i].stream_name_nbytes)
 356                         return true;
 357         return false;
 358 }
 359
 360 /* Set the unnamed stream of a WIM inode, given a data buffer containing the
 361  * stream contents.  The inode must be resolved and cannot already have an
 362  * unnamed stream.  */
 363 int
 364 inode_set_unnamed_stream(struct wim_inode *inode, const void *data, size_t len,
 365                          struct wim_lookup_table *lookup_table)
 366 {
 367         wimlib_assert(inode->i_resolved);
 368         wimlib_assert(!inode->i_lte);
 369
 370         inode->i_lte = new_stream_from_data_buffer(data, len, lookup_table);
 371         if (!inode->i_lte)
 372                 return WIMLIB_ERR_NOMEM;
 373         return 0;
 374 }
 375
 376 /*
 377  * Resolve an inode's single-instance streams.
 378  *
 379  * This takes each SHA-1 message digest stored in the inode or one of its ADS
 380  * entries and replaces it with a pointer directly to the appropriate 'struct
 381  * wim_lookup_table_entry' currently inserted into @table to represent the
 382  * single-instance stream having that SHA-1 message digest.
 383  *
 384  * If @force is %false:
 385  *      If any of the needed single-instance streams do not exist in @table,
 386  *      return WIMLIB_ERR_RESOURCE_NOT_FOUND and leave the inode unmodified.
 387  * If @force is %true:
 388  *      If any of the needed single-instance streams do not exist in @table,
 389  *      allocate new entries for them and insert them into @table.  This does
 390  *      not, of course, cause these streams to magically exist, but this is
 391  *      needed by the code for extraction from a pipe.
 392  *
 393  * If the inode is already resolved, this function does nothing.
 394  *
 395  * Returns 0 on success; WIMLIB_ERR_NOMEM if out of memory; or
 396  * WIMLIB_ERR_RESOURCE_NOT_FOUND if @force is %false and at least one
 397  * single-instance stream referenced by the inode was missing.
 398  */
 399 int
 400 inode_resolve_streams(struct wim_inode *inode, struct wim_lookup_table *table,
 401                       bool force)
 402 {
 403         const u8 *hash;
 404         struct wim_lookup_table_entry *lte, *ads_lte;
 405
 406         if (inode->i_resolved)
 407                 return 0;
 408
 409         struct wim_lookup_table_entry *ads_ltes[inode->i_num_ads];
 410
 411         /* Resolve the default data stream */
 412         lte = NULL;
 413         hash = inode->i_hash;
 414         if (!is_zero_hash(hash)) {
 415                 lte = lookup_stream(table, hash);
 416                 if (!lte) {
 417                         if (force) {
 418                                 lte = new_lookup_table_entry();
 419                                 if (!lte)
 420                                         return WIMLIB_ERR_NOMEM;
 421                                 copy_hash(lte->hash, hash);
 422                                 lookup_table_insert(table, lte);
 423                         } else {
 424                                 goto stream_not_found;
 425                         }
 426                 }
 427         }
 428
 429         /* Resolve the alternate data streams */
 430         for (unsigned i = 0; i < inode->i_num_ads; i++) {
 431                 struct wim_ads_entry *cur_entry;
 432
 433                 ads_lte = NULL;
 434                 cur_entry = &inode->i_ads_entries[i];
 435                 hash = cur_entry->hash;
 436                 if (!is_zero_hash(hash)) {
 437                         ads_lte = lookup_stream(table, hash);
 438                         if (!ads_lte) {
 439                                 if (force) {
 440                                         ads_lte = new_lookup_table_entry();
 441                                         if (!ads_lte)
 442                                                 return WIMLIB_ERR_NOMEM;
 443                                         copy_hash(ads_lte->hash, hash);
 444                                         lookup_table_insert(table, ads_lte);
 445                                 } else {
 446                                         goto stream_not_found;
 447                                 }
 448                         }
 449                 }
 450                 ads_ltes[i] = ads_lte;
 451         }
 452         inode->i_lte = lte;
 453         for (unsigned i = 0; i < inode->i_num_ads; i++)
 454                 inode->i_ads_entries[i].lte = ads_ltes[i];
 455         inode->i_resolved = 1;
 456         return 0;
 457
 458 stream_not_found:
 459         return stream_not_found_error(inode, hash);
 460 }
 461
 462 /*
 463  * Undo the effects of inode_resolve_streams().
 464  *
 465  * If the inode is not resolved, this function does nothing.
 466  */
 467 void
 468 inode_unresolve_streams(struct wim_inode *inode)
 469 {
 470         if (!inode->i_resolved)
 471                 return;
 472
 473         if (inode->i_lte)
 474                 copy_hash(inode->i_hash, inode->i_lte->hash);
 475         else
 476                 zero_out_hash(inode->i_hash);
 477
 478         for (unsigned i = 0; i < inode->i_num_ads; i++) {
 479                 if (inode->i_ads_entries[i].lte)
 480                         copy_hash(inode->i_ads_entries[i].hash,
 481                                   inode->i_ads_entries[i].lte->hash);
 482                 else
 483                         zero_out_hash(inode->i_ads_entries[i].hash);
 484         }
 485         inode->i_resolved = 0;
 486 }
 487
 488 int
 489 stream_not_found_error(const struct wim_inode *inode, const u8 *hash)
 490 {
 491         if (wimlib_print_errors) {
 492                 tchar hashstr[SHA1_HASH_SIZE * 2 + 1];
 493
 494                 sprint_hash(hash, hashstr);
 495
 496                 ERROR("\"%"TS"\": stream not found\n"
 497                       "        SHA-1 message digest of missing stream:\n"
 498                       "        %"TS"",
 499                       inode_first_full_path(inode), hashstr);
 500         }
 501         return WIMLIB_ERR_RESOURCE_NOT_FOUND;
 502 }
 503
 504 /*
 505  * Return the lookup table entry for the specified stream of the inode, or NULL
 506  * if the specified stream is empty or not available.
 507  *
 508  * stream_idx = 0: default data stream
 509  * stream_idx > 0: alternate data stream
 510  */
 511 struct wim_lookup_table_entry *
 512 inode_stream_lte(const struct wim_inode *inode, unsigned stream_idx,
 513                  const struct wim_lookup_table *table)
 514 {
 515         if (inode->i_resolved)
 516                 return inode_stream_lte_resolved(inode, stream_idx);
 517         if (stream_idx == 0)
 518                 return lookup_stream(table, inode->i_hash);
 519         return lookup_stream(table, inode->i_ads_entries[stream_idx - 1].hash);
 520 }
 521
 522 /*
 523  * Return the lookup table entry for the unnamed data stream of a *resolved*
 524  * inode, or NULL if the inode's unnamed data stream is empty.  Also return the
 525  * 0-based index of the unnamed data stream in *stream_idx_ret.
 526  */
 527 struct wim_lookup_table_entry *
 528 inode_unnamed_stream_resolved(const struct wim_inode *inode,
 529                               unsigned *stream_idx_ret)
 530 {
 531         wimlib_assert(inode->i_resolved);
 532
 533         *stream_idx_ret = 0;
 534         if (likely(inode->i_lte))
 535                 return inode->i_lte;
 536
 537         for (unsigned i = 0; i < inode->i_num_ads; i++) {
 538                 if (inode->i_ads_entries[i].stream_name_nbytes == 0 &&
 539                     inode->i_ads_entries[i].lte)
 540                 {
 541                         *stream_idx_ret = i + 1;
 542                         return inode->i_ads_entries[i].lte;
 543                 }
 544         }
 545         return NULL;
 546 }
 547
 548 /*
 549  * Return the lookup table entry for the unnamed data stream of an inode, or
 550  * NULL if the inode's unnamed data stream is empty or not available.
 551  *
 552  * Note: this is complicated by the fact that WIMGAPI may put the unnamed data
 553  * stream in an alternate data stream entry rather than in the dentry itself.
 554  */
 555 struct wim_lookup_table_entry *
 556 inode_unnamed_lte(const struct wim_inode *inode,
 557                   const struct wim_lookup_table *table)
 558 {
 559         struct wim_lookup_table_entry *lte;
 560
 561         if (inode->i_resolved)
 562                 return inode_unnamed_lte_resolved(inode);
 563
 564         lte = lookup_stream(table, inode->i_hash);
 565         if (likely(lte))
 566                 return lte;
 567
 568         for (unsigned i = 0; i < inode->i_num_ads; i++) {
 569                 if (inode->i_ads_entries[i].stream_name_nbytes)
 570                         continue;
 571                 lte = lookup_stream(table, inode->i_ads_entries[i].hash);
 572                 if (lte)
 573                         return lte;
 574         }
 575         return NULL;
 576 }
 577
 578 /* Return the SHA-1 message digest of the specified stream of the inode, or a
 579  * void SHA-1 of all zeroes if the specified stream is empty.   */
 580 const u8 *
 581 inode_stream_hash(const struct wim_inode *inode, unsigned stream_idx)
 582 {
 583         if (inode->i_resolved) {
 584                 struct wim_lookup_table_entry *lte;
 585
 586                 lte = inode_stream_lte_resolved(inode, stream_idx);
 587                 if (lte)
 588                         return lte->hash;
 589                 return zero_hash;
 590         }
 591         if (stream_idx == 0)
 592                 return inode->i_hash;
 593         return inode->i_ads_entries[stream_idx - 1].hash;
 594 }
 595
 596 /* Return the SHA-1 message digest of the unnamed data stream of the inode, or a
 597  * void SHA-1 of all zeroes if the inode's unnamed data stream is empty.   */
 598 const u8 *
 599 inode_unnamed_stream_hash(const struct wim_inode *inode)
 600 {
 601         const u8 *hash;
 602
 603         for (unsigned i = 0; i <= inode->i_num_ads; i++) {
 604                 if (inode_stream_name_nbytes(inode, i) == 0) {
 605                         hash = inode_stream_hash(inode, i);
 606                         if (!is_zero_hash(hash))
 607                                 return hash;
 608                 }
 609         }
 610         return zero_hash;
 611 }
 612
 613 /* Acquire another reference to each single-instance stream referenced by this
 614  * inode.  This is necessary when creating a hard link to this inode.
 615  *
 616  * The inode must be resolved.  */
 617 void
 618 inode_ref_streams(struct wim_inode *inode)
 619 {
 620         wimlib_assert(inode->i_resolved);
 621
 622         if (inode->i_lte)
 623                 inode->i_lte->refcnt++;
 624         for (unsigned i = 0; i < inode->i_num_ads; i++)
 625                 if (inode->i_ads_entries[i].lte)
 626                         inode->i_ads_entries[i].lte->refcnt++;
 627 }
 628
 629 /* Drop a reference to each single-instance stream referenced by this inode.
 630  * This is necessary when deleting a hard link to this inode.  */
 631 void
 632 inode_unref_streams(struct wim_inode *inode,
 633                     struct wim_lookup_table *lookup_table)
 634 {
 635         for (unsigned i = 0; i <= inode->i_num_ads; i++) {
 636                 struct wim_lookup_table_entry *lte;
 637
 638                 lte = inode_stream_lte(inode, i, lookup_table);
 639                 if (lte)
 640                         lte_decrement_refcnt(lte, lookup_table);
 641         }
 642 }
 643
 644 /*
 645  * Read the alternate data stream entries of a WIM dentry.
 646  *
 647  * @p:
 648  *      Pointer to buffer that starts with the first alternate stream entry.
 649  *
 650  * @inode:
 651  *      Inode to load the alternate data streams into.  @inode->i_num_ads must
 652  *      have been set to the number of alternate data streams that are expected.
 653  *
 654  * @nbytes_remaining_p:
 655  *      Number of bytes of data remaining in the buffer pointed to by @p.
 656  *      On success this will be updated to point just past the ADS entries.
 657  *
 658  * On success, inode->i_ads_entries is set to an array of `struct
 659  * wim_ads_entry's of length inode->i_num_ads.  On failure, @inode is not
 660  * modified.
 661  *
 662  * Return values:
 663  *      WIMLIB_ERR_SUCCESS (0)
 664  *      WIMLIB_ERR_INVALID_METADATA_RESOURCE
 665  *      WIMLIB_ERR_NOMEM
 666  */
 667 int
 668 read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
 669                  size_t *nbytes_remaining_p)
 670 {
 671         size_t nbytes_remaining = *nbytes_remaining_p;
 672         unsigned num_ads;
 673         struct wim_ads_entry *ads_entries;
 674         int ret;
 675
 676         BUILD_BUG_ON(sizeof(struct wim_ads_entry_on_disk) != WIM_ADS_ENTRY_DISK_SIZE);
 677
 678         /* Allocate an array for our in-memory representation of the alternate
 679          * data stream entries. */
 680         num_ads = inode->i_num_ads;
 681         ads_entries = CALLOC(num_ads, sizeof(inode->i_ads_entries[0]));
 682         if (!ads_entries)
 683                 goto out_of_memory;
 684
 685         /* Read the entries into our newly allocated buffer. */
 686         for (unsigned i = 0; i < num_ads; i++) {
 687                 u64 length;
 688                 struct wim_ads_entry *cur_entry;
 689                 const struct wim_ads_entry_on_disk *disk_entry =
 690                         (const struct wim_ads_entry_on_disk*)p;
 691
 692                 cur_entry = &ads_entries[i];
 693                 ads_entries[i].stream_id = i + 1;
 694
 695                 /* Do we have at least the size of the fixed-length data we know
 696                  * need? */
 697                 if (nbytes_remaining < sizeof(struct wim_ads_entry_on_disk))
 698                         goto out_invalid;
 699
 700                 /* Read the length field */
 701                 length = le64_to_cpu(disk_entry->length);
 702
 703                 /* Make sure the length field is neither so small it doesn't
 704                  * include all the fixed-length data nor so large it overflows
 705                  * the metadata resource buffer. */
 706                 if (length < sizeof(struct wim_ads_entry_on_disk) ||
 707                     length > nbytes_remaining)
 708                         goto out_invalid;
 709
 710                 /* Read the rest of the fixed-length data. */
 711
 712                 cur_entry->reserved = le64_to_cpu(disk_entry->reserved);
 713                 copy_hash(cur_entry->hash, disk_entry->hash);
 714                 cur_entry->stream_name_nbytes = le16_to_cpu(disk_entry->stream_name_nbytes);
 715
 716                 /* If stream_name_nbytes != 0, this is a named stream.
 717                  * Otherwise this is an unnamed stream, or in some cases (bugs
 718                  * in Microsoft's software I guess) a meaningless entry
 719                  * distinguished from the real unnamed stream entry, if any, by
 720                  * the fact that the real unnamed stream entry has a nonzero
 721                  * hash field. */
 722                 if (cur_entry->stream_name_nbytes) {
 723                         /* The name is encoded in UTF16-LE, which uses 2-byte
 724                          * coding units, so the length of the name had better be
 725                          * an even number of bytes... */
 726                         if (cur_entry->stream_name_nbytes & 1)
 727                                 goto out_invalid;
 728
 729                         /* Add the length of the stream name to get the length
 730                          * we actually need to read.  Make sure this isn't more
 731                          * than the specified length of the entry. */
 732                         if (sizeof(struct wim_ads_entry_on_disk) +
 733                             cur_entry->stream_name_nbytes > length)
 734                                 goto out_invalid;
 735
 736                         cur_entry->stream_name = utf16le_dupz(disk_entry->stream_name,
 737                                                               cur_entry->stream_name_nbytes);
 738                         if (!cur_entry->stream_name)
 739                                 goto out_of_memory;
 740                 } else {
 741                         /* Mark inode as having weird stream entries.  */
 742                         inode->i_canonical_streams = 0;
 743                 }
 744
 745                 /* It's expected that the size of every ADS entry is a multiple
 746                  * of 8.  However, to be safe, I'm allowing the possibility of
 747                  * an ADS entry at the very end of the metadata resource ending
 748                  * unaligned.  So although we still need to increment the input
 749                  * pointer by @length to reach the next ADS entry, it's possible
 750                  * that less than @length is actually remaining in the metadata
 751                  * resource. We should set the remaining bytes to 0 if this
 752                  * happens. */
 753                 length = (length + 7) & ~7;
 754                 p += length;
 755                 if (nbytes_remaining < length)
 756                         nbytes_remaining = 0;
 757                 else
 758                         nbytes_remaining -= length;
 759         }
 760         inode->i_ads_entries = ads_entries;
 761         inode->i_next_stream_id = inode->i_num_ads + 1;
 762         *nbytes_remaining_p = nbytes_remaining;
 763         ret = 0;
 764         goto out;
 765 out_of_memory:
 766         ret = WIMLIB_ERR_NOMEM;
 767         goto out_free_ads_entries;
 768 out_invalid:
 769         ERROR("An alternate data stream entry is invalid");
 770         ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
 771 out_free_ads_entries:
 772         if (ads_entries) {
 773                 for (unsigned i = 0; i < num_ads; i++)
 774                         destroy_ads_entry(&ads_entries[i]);
 775                 FREE(ads_entries);
 776         }
 777 out:
 778         return ret;
 779 }
 780
 781 /* Check a WIM inode for unusual field values.  */
 782 void
 783 check_inode(struct wim_inode *inode, const struct wim_security_data *sd)
 784 {
 785         /* Check the security ID.  -1 is valid and means "no security
 786          * descriptor".  Anything else has to be a valid index into the WIM
 787          * image's security descriptors table. */
 788         if (inode->i_security_id < -1 ||
 789             (inode->i_security_id >= 0 &&
 790              inode->i_security_id >= sd->num_entries))
 791         {
 792                 WARNING("\"%"TS"\" has an invalid security ID (%d)",
 793                         inode_first_full_path(inode), inode->i_security_id);
 794                 inode->i_security_id = -1;
 795         }
 796
 797         /* Make sure there is only one unnamed data stream. */
 798         unsigned num_unnamed_streams = 0;
 799         for (unsigned i = 0; i <= inode->i_num_ads; i++) {
 800                 const u8 *hash;
 801                 hash = inode_stream_hash(inode, i);
 802                 if (inode_stream_name_nbytes(inode, i) == 0 && !is_zero_hash(hash))
 803                         num_unnamed_streams++;
 804         }
 805         if (num_unnamed_streams > 1) {
 806                 WARNING("\"%"TS"\" has multiple (%u) unnamed streams",
 807                         inode_first_full_path(inode), num_unnamed_streams);
 808                 /* We currently don't treat this as an error and will just end
 809                  * up using the first unnamed data stream in the inode.  */
 810         }
 811 }
 812
 813 /*
 814  * Translate a single-instance stream entry into the pointer contained in the
 815  * inode (or ads entry of an inode) that references it.
 816  *
 817  * This is only possible for "unhashed" streams, which are guaranteed to have
 818  * only one reference, and that reference is guaranteed to be in a resolved
 819  * inode.  (It can't be in an unresolved inode, since that would imply the hash
 820  * is known!)
 821  */
 822 struct wim_lookup_table_entry **
 823 retrieve_lte_pointer(struct wim_lookup_table_entry *lte)
 824 {
 825         wimlib_assert(lte->unhashed);
 826         struct wim_inode *inode = lte->back_inode;
 827         u32 stream_id = lte->back_stream_id;
 828         if (stream_id == 0)
 829                 return &inode->i_lte;
 830         for (unsigned i = 0; i < inode->i_num_ads; i++)
 831                 if (inode->i_ads_entries[i].stream_id == stream_id)
 832                         return &inode->i_ads_entries[i].lte;
 833         wimlib_assert(0);
 834         return NULL;
 835 }