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

   1 /*
   2  * symlink.c
   3  *
   4  * Code to read and set symbolic links in WIM files.
   5  */
   6
   7 /*
   8  * Copyright (C) 2012, 2013 Eric Biggers
   9  *
  10  * This file is part of wimlib, a library for working with WIM files.
  11  *
  12  * wimlib is free software; you can redistribute it and/or modify it under the
  13  * terms of the GNU General Public License as published by the Free
  14  * Software Foundation; either version 3 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
  20  * details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  24  */
  25
  26 #include "dentry.h"
  27 #include "buffer_io.h"
  28 #include "lookup_table.h"
  29 #include "sha1.h"
  30 #include <errno.h>
  31
  32 /* UNIX version of getting and setting the data in reparse points */
  33 #if !defined(__WIN32__)
  34
  35 #include <sys/stat.h>
  36
  37 /*
  38  * Find the symlink target of a symbolic link or junction point in the WIM.
  39  *
  40  * See http://msdn.microsoft.com/en-us/library/cc232006(v=prot.10).aspx for a
  41  * description of the format of the so-called "reparse point data buffers".
  42  *
  43  * But, in the WIM format, the first 8 bytes of the reparse point data buffer
  44  * are omitted, presumably because we already know the reparse tag from the
  45  * dentry, and we already know the reparse tag length from the lookup table
  46  * entry resource length.
  47  */
  48 static ssize_t
  49 get_symlink_name(const void *resource, size_t resource_len, char *buf,
  50                  size_t buf_len, u32 reparse_tag)
  51 {
  52         const void *p = resource;
  53         u16 substitute_name_offset;
  54         u16 substitute_name_len;
  55         u16 print_name_offset;
  56         u16 print_name_len;
  57         char *link_target;
  58         char *translated_target;
  59         size_t link_target_len;
  60         ssize_t ret;
  61         unsigned header_size;
  62         bool translate_slashes;
  63
  64         if (resource_len < 12)
  65                 return -EIO;
  66         p = get_u16(p, &substitute_name_offset);
  67         p = get_u16(p, &substitute_name_len);
  68         p = get_u16(p, &print_name_offset);
  69         p = get_u16(p, &print_name_len);
  70
  71         wimlib_assert(reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
  72                       reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT);
  73
  74         if (reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)
  75                 header_size = 8;
  76         else {
  77                 header_size = 12;
  78                 p += 4;
  79         }
  80         if (header_size + substitute_name_offset + substitute_name_len > resource_len)
  81                 return -EIO;
  82
  83         ret = utf16le_to_tstr((const utf16lechar*)(p + substitute_name_offset),
  84                               substitute_name_len,
  85                               &link_target, &link_target_len);
  86         if (ret)
  87                 return -errno;
  88
  89         if (link_target_len + 1 > buf_len) {
  90                 ret = -ENAMETOOLONG;
  91                 goto out;
  92         }
  93
  94         DEBUG("Interpeting substitute name \"%s\" (ReparseTag=0x%x)",
  95               link_target, reparse_tag);
  96         translate_slashes = true;
  97         translated_target = link_target;
  98         if (link_target_len >= 7 &&
  99             translated_target[0] == '\\' &&
 100             translated_target[1] == '?' &&
 101             translated_target[2] == '?' &&
 102             translated_target[3] == '\\' &&
 103             translated_target[4] != '\0' &&
 104             translated_target[5] == ':' &&
 105             translated_target[6] == '\\')
 106         {
 107                 /* "Full" symlink or junction (\??\x:\ prefixed path) */
 108                 translated_target += 6;
 109                 link_target_len -= 6;
 110         } else if (reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT &&
 111                    link_target_len >= 12 &&
 112                    memcmp(translated_target, "\\\\?\\Volume{", 11) == 0 &&
 113                    translated_target[link_target_len - 1] == '\\')
 114         {
 115                 /* Volume junction.  Can't really do anything with it. */
 116                 translate_slashes = false;
 117         } else if (reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK &&
 118                    link_target_len >= 3 &&
 119                    translated_target[0] != '\0' &&
 120                    translated_target[1] == ':' &&
 121                    translated_target[2] == '\\')
 122         {
 123                 /* "Absolute" symlink, with drive letter */
 124                 translated_target += 2;
 125                 link_target_len -= 2;
 126         } else if (reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK &&
 127                    link_target_len >= 1)
 128         {
 129                 if (translated_target[0] == '\\')
 130                         /* "Absolute" symlink, without drive letter */
 131                         ;
 132                 else
 133                         /* "Relative" symlink, without drive letter */
 134                         ;
 135         } else {
 136                 ERROR("Invalid reparse point: \"%s\"", translated_target);
 137                 ret = -EIO;
 138                 goto out;
 139         }
 140
 141         if (translate_slashes)
 142                 for (size_t i = 0; i < link_target_len; i++)
 143                         if (translated_target[i] == '\\')
 144                                 translated_target[i] = '/';
 145         memcpy(buf, translated_target, link_target_len + 1);
 146         ret = link_target_len;
 147 out:
 148         FREE(link_target);
 149         return ret;
 150 }
 151
 152 #define SYMBOLIC_LINK_RELATIVE 0x00000001
 153
 154 /* Given a UNIX symlink target, prepare the corresponding symbolic link reparse
 155  * data buffer. */
 156 static int
 157 make_symlink_reparse_data_buf(const char *symlink_target,
 158                               size_t *len_ret, void **buf_ret)
 159 {
 160         int ret;
 161         utf16lechar *name_utf16le;
 162         size_t name_utf16le_nbytes;
 163         size_t substitute_name_nbytes;
 164         size_t print_name_nbytes;
 165         static const char abs_subst_name_prefix[12] = "\\\0?\0?\0\\\0C\0:\0";
 166         static const char abs_print_name_prefix[4] = "C\0:\0";
 167         u32 flags;
 168         size_t len;
 169         void *buf;
 170         void *p;
 171
 172         ret = tstr_to_utf16le(symlink_target, strlen(symlink_target),
 173                               &name_utf16le, &name_utf16le_nbytes);
 174         if (ret)
 175                 return ret;
 176
 177         for (size_t i = 0; i < name_utf16le_nbytes / 2; i++)
 178                 if (name_utf16le[i] == cpu_to_le16('/'))
 179                         name_utf16le[i] = cpu_to_le16('\\');
 180
 181         /* Compatability notes:
 182          *
 183          * On UNIX, an absolute symbolic link begins with '/'; everything else
 184          * is a relative symbolic link.  (Quite simple compared to the various
 185          * ways to provide Windows paths.)
 186          *
 187          * To change a UNIX relative symbolic link to Windows format, we only
 188          * need to translate it to UTF-16LE and replace backslashes with forward
 189          * slashes.  We do not make any attempt to handle filename character
 190          * problems, such as a link target that itself contains backslashes on
 191          * UNIX.  Then, for these relative links, we set the reparse header
 192          * @flags field to SYMBOLIC_LINK_RELATIVE.
 193          *
 194          * For UNIX absolute symbolic links, we must set the @flags field to 0.
 195          * Then, there are multiple options as to actually represent the
 196          * absolute link targets:
 197          *
 198          * (1) An absolute path beginning with one backslash character. similar
 199          * to UNIX-style, just with a different path separator.  Print name same
 200          * as substitute name.
 201          *
 202          * (2) Absolute path beginning with drive letter followed by a
 203          * backslash.  Print name same as substitute name.
 204          *
 205          * (3) Absolute path beginning with drive letter followed by a
 206          * backslash; substitute name prefixed with \??\, otherwise same as
 207          * print name.
 208          *
 209          * We choose option (3) here, and we just assume C: for the drive
 210          * letter.  The reasoning for this is:
 211          *
 212          * (1) Microsoft imagex.exe has a bug where it does not attempt to do
 213          * reparse point fixups for these links, even though they are valid
 214          * absolute links.  (Note: in this case prefixing the substitute name
 215          * with \??\ does not work; it just makes the data unable to be restored
 216          * at all.)
 217          * (2) Microsoft imagex.exe will fail when doing reparse point fixups
 218          * for these.  It apparently contains a bug that causes it to create an
 219          * invalid reparse point, which then cannot be restored.
 220          * (3) This is the only option I tested for which reparse point fixups
 221          * worked properly in Microsoft imagex.exe.
 222          *
 223          * So option (3) it is.
 224          */
 225
 226         substitute_name_nbytes = name_utf16le_nbytes;
 227         print_name_nbytes = name_utf16le_nbytes;
 228         if (symlink_target[0] == '/') {
 229                 substitute_name_nbytes += sizeof(abs_subst_name_prefix);
 230                 print_name_nbytes += sizeof(abs_print_name_prefix);
 231         }
 232
 233         len = 12 + substitute_name_nbytes + print_name_nbytes +
 234                         2 * sizeof(utf16lechar);
 235         buf = MALLOC(len);
 236
 237         if (!buf) {
 238                 ret = WIMLIB_ERR_NOMEM;
 239                 goto out_free_name_utf16le;
 240         }
 241
 242         p = buf;
 243
 244         /* Substitute name offset */
 245         p = put_u16(p, 0);
 246
 247         /* Substitute name length */
 248         p = put_u16(p, substitute_name_nbytes);
 249
 250         /* Print name offset */
 251         p = put_u16(p, substitute_name_nbytes + sizeof(utf16lechar));
 252
 253         /* Print name length */
 254         p = put_u16(p, print_name_nbytes);
 255
 256         /* Flags */
 257         flags = 0;
 258         if (symlink_target[0] != '/')
 259                 flags |= SYMBOLIC_LINK_RELATIVE;
 260         p = put_u32(p, flags);
 261
 262         /* Substitute name */
 263         if (symlink_target[0] == '/')
 264                 p = put_bytes(p, sizeof(abs_subst_name_prefix), abs_subst_name_prefix);
 265         p = put_bytes(p, name_utf16le_nbytes, name_utf16le);
 266         p = put_u16(p, 0);
 267
 268         /* Print name */
 269         if (symlink_target[0] == '/')
 270                 p = put_bytes(p, sizeof(abs_print_name_prefix), abs_print_name_prefix);
 271         p = put_bytes(p, name_utf16le_nbytes, name_utf16le);
 272         p = put_u16(p, 0);
 273
 274         *len_ret = len;
 275         *buf_ret = buf;
 276         ret = 0;
 277 out_free_name_utf16le:
 278         FREE(name_utf16le);
 279         return ret;
 280 }
 281
 282 /* Get the symlink target from a WIM inode.
 283  *
 284  * The inode may be either a "real" symlink (reparse tag
 285  * WIM_IO_REPARSE_TAG_SYMLINK), or it may be a junction point (reparse tag
 286  * WIM_IO_REPARSE_TAG_MOUNT_POINT).
 287  */
 288 ssize_t
 289 inode_readlink(const struct wim_inode *inode, char *buf, size_t buf_len,
 290                const WIMStruct *w, bool threadsafe)
 291 {
 292         const struct wim_lookup_table_entry *lte;
 293         int ret;
 294
 295         wimlib_assert(inode_is_symlink(inode));
 296
 297         lte = inode_unnamed_lte(inode, w->lookup_table);
 298         if (!lte)
 299                 return -EIO;
 300
 301         if (wim_resource_size(lte) > REPARSE_POINT_MAX_SIZE)
 302                 return -EIO;
 303
 304         u8 res_buf[wim_resource_size(lte)];
 305         ret = read_full_resource_into_buf(lte, res_buf, threadsafe);
 306         if (ret)
 307                 return -EIO;
 308         return get_symlink_name(res_buf, wim_resource_size(lte), buf,
 309                                 buf_len, inode->i_reparse_tag);
 310 }
 311
 312 /*
 313  * Sets @inode to be a symbolic link pointing to @target.
 314  *
 315  * A lookup table entry for the symbolic link data buffer is created and
 316  * inserted into @lookup_table, unless there is an existing lookup table entry
 317  * for the exact same data, in which its reference count is incremented.
 318  *
 319  * The lookup table entry is returned in @lte_ret.
 320  *
 321  * On failure @dentry and @lookup_table are not modified.
 322  */
 323 int
 324 inode_set_symlink(struct wim_inode *inode,
 325                   const char *target,
 326                   struct wim_lookup_table *lookup_table,
 327                   struct wim_lookup_table_entry **lte_ret)
 328
 329 {
 330         int ret;
 331         size_t symlink_buf_len;
 332         struct wim_lookup_table_entry *lte = NULL, *existing_lte;
 333         u8 symlink_buf_hash[SHA1_HASH_SIZE];
 334         void *symlink_buf;
 335
 336         ret = make_symlink_reparse_data_buf(target, &symlink_buf_len,
 337                                             &symlink_buf);
 338         if (ret)
 339                 return ret;
 340
 341         DEBUG("Made symlink reparse data buf (len = %zu, name len = %zu)",
 342                         symlink_buf_len, symlink_buf_len);
 343
 344         sha1_buffer(symlink_buf, symlink_buf_len, symlink_buf_hash);
 345
 346         existing_lte = __lookup_resource(lookup_table, symlink_buf_hash);
 347
 348         if (existing_lte) {
 349                 lte = existing_lte;
 350                 FREE(symlink_buf);
 351                 symlink_buf = NULL;
 352         } else {
 353                 DEBUG("Creating new lookup table entry for symlink buf");
 354                 lte = new_lookup_table_entry();
 355                 if (!lte) {
 356                         ret = WIMLIB_ERR_NOMEM;
 357                         goto out_free_symlink_buf;
 358                 }
 359                 lte->resource_location            = RESOURCE_IN_ATTACHED_BUFFER;
 360                 lte->attached_buffer              = symlink_buf;
 361                 lte->resource_entry.original_size = symlink_buf_len;
 362                 copy_hash(lte->hash, symlink_buf_hash);
 363         }
 364
 365         inode->i_lte = lte;
 366         inode->i_resolved = 1;
 367
 368         DEBUG("Loaded symlink buf");
 369
 370         if (existing_lte)
 371                 lte->refcnt++;
 372         else
 373                 lookup_table_insert(lookup_table, lte);
 374         if (lte_ret)
 375                 *lte_ret = lte;
 376         return 0;
 377 out_free_symlink_buf:
 378         FREE(symlink_buf);
 379         return ret;
 380 }
 381
 382 static int
 383 unix_get_ino_and_dev(const char *path, u64 *ino_ret, u64 *dev_ret)
 384 {
 385         struct stat stbuf;
 386         if (stat(path, &stbuf)) {
 387                 WARNING_WITH_ERRNO("Failed to stat \"%s\"", path);
 388                 /* Treat as a link pointing outside the capture root (it
 389                  * most likely is). */
 390                 return WIMLIB_ERR_STAT;
 391         } else {
 392                 *ino_ret = stbuf.st_ino;
 393                 *dev_ret = stbuf.st_dev;
 394                 return 0;
 395         }
 396 }
 397
 398 #endif /* !defined(__WIN32__) */
 399
 400 #ifdef __WIN32__
 401 #  include "win32.h"
 402 #  define RP_PATH_SEPARATOR L'\\'
 403 #  define os_get_ino_and_dev win32_get_file_and_vol_ids
 404 #else
 405 #  define RP_PATH_SEPARATOR '/'
 406 #  define os_get_ino_and_dev unix_get_ino_and_dev
 407 #endif
 408
 409 /* Fix up reparse points--- mostly shared between UNIX and Windows */
 410 tchar *
 411 fixup_symlink(tchar *dest, u64 capture_root_ino, u64 capture_root_dev)
 412 {
 413         tchar *p = dest;
 414
 415 #ifdef __WIN32__
 416         /* Skip over drive letter */
 417         if (*p != RP_PATH_SEPARATOR)
 418                 p += 2;
 419 #endif
 420
 421         DEBUG("Fixing symlink or junction \"%"TS"\"", dest);
 422         for (;;) {
 423                 tchar save;
 424                 int ret;
 425                 u64 ino;
 426                 u64 dev;
 427
 428                 while (*p == RP_PATH_SEPARATOR)
 429                         p++;
 430
 431                 save = *p;
 432                 *p = T('\0');
 433                 ret = os_get_ino_and_dev(dest, &ino, &dev);
 434                 *p = save;
 435
 436                 if (ino == capture_root_ino && dev == capture_root_dev) {
 437                         /* Link points inside capture root.  Return abbreviated
 438                          * path. */
 439                         if (*p == T('\0'))
 440                                 *(p - 1) = RP_PATH_SEPARATOR;
 441                         while (p - 1 >= dest && *(p - 1) == RP_PATH_SEPARATOR)
 442                                 p--;
 443                 #ifdef __WIN32__
 444                         /* Add back drive letter */
 445                         if (*dest != RP_PATH_SEPARATOR) {
 446                                 *--p = *(dest + 1);
 447                                 *--p = *dest;
 448                         }
 449                 #endif
 450                         wimlib_assert(p >= dest);
 451                         return p;
 452                 }
 453
 454                 if (*p == T('\0')) {
 455                         /* Link points outside capture root. */
 456                         return NULL;
 457                 }
 458
 459                 do {
 460                         p++;
 461                 } while (*p != RP_PATH_SEPARATOR && *p != T('\0'));
 462         }
 463 }
 464