Win32: Fix reparse point fixup bugs
[wimlib] / src / reparse.c
1 /*
2  * reparse.c - Handle reparse data.
3  */
4
5 /*
6  * Copyright (C) 2012, 2013 Eric Biggers
7  *
8  * This file is part of wimlib, a library for working with WIM files.
9  *
10  * wimlib is free software; you can redistribute it and/or modify it under the
11  * terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 3 of the License, or (at your option)
13  * any later version.
14  *
15  * wimlib 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
17  * A PARTICULAR PURPOSE. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with wimlib; if not, see http://www.gnu.org/licenses/.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #include "wimlib/assert.h"
29 #include "wimlib/compiler.h"
30 #include "wimlib/endianness.h"
31 #include "wimlib/dentry.h"
32 #include "wimlib/encoding.h"
33 #include "wimlib/error.h"
34 #include "wimlib/lookup_table.h"
35 #include "wimlib/reparse.h"
36 #include "wimlib/resource.h"
37
38 #ifdef __WIN32__
39 #  include "wimlib/win32.h" /* for win32_get_file_and_vol_ids() */
40 #endif
41
42 #ifdef HAVE_ALLOCA_H
43 #  include <alloca.h>
44 #endif
45 #include <errno.h>
46 #include <stdlib.h>
47
48 /* On-disk format of a symbolic link (WIM_IO_REPARSE_TAG_SYMLINK) or junction
49  * point (WIM_IO_REPARSE_TAG_MOUNT_POINT) reparse data buffer.  */
50 struct reparse_buffer_disk {
51         le32 rptag;
52         le16 rpdatalen;
53         le16 rpreserved;
54         le16 substitute_name_offset;
55         le16 substitute_name_nbytes;
56         le16 print_name_offset;
57         le16 print_name_nbytes;
58         union {
59                 struct {
60                         le32 rpflags;
61                         u8 data[REPARSE_POINT_MAX_SIZE - 20];
62                 } _packed_attribute symlink;
63                 struct {
64                         u8 data[REPARSE_POINT_MAX_SIZE - 16];
65                 } _packed_attribute junction;
66         };
67 } _packed_attribute;
68
69 static const utf16lechar volume_junction_prefix[11] = {
70         cpu_to_le16('\\'),
71         cpu_to_le16('\\'),
72         cpu_to_le16('?'),
73         cpu_to_le16('\\'),
74         cpu_to_le16('V'),
75         cpu_to_le16('o'),
76         cpu_to_le16('l'),
77         cpu_to_le16('u'),
78         cpu_to_le16('m'),
79         cpu_to_le16('e'),
80         cpu_to_le16('{'),
81 };
82
83 /* Parse the "substitute name" (link target) from a symbolic link or junction
84  * reparse point.
85  *
86  * Return value is:
87  *
88  * Non-negative integer:
89  *      The name is an absolute symbolic link in one of several formats,
90  *      and the return value is the number of UTF-16LE characters that need to
91  *      be advanced to reach a simple "absolute" path starting with a backslash
92  *      (i.e. skip over \??\ and/or drive letter)
93  * Negative integer:
94  *      SUBST_NAME_IS_VOLUME_JUNCTION:
95  *              The name is a volume junction.
96  *      SUBST_NAME_IS_RELATIVE_LINK:
97  *              The name is a relative symbolic link.
98  *      SUBST_NAME_IS_UNKNOWN:
99  *              The name does not appear to be a valid symbolic link, junction,
100  *              or mount point.
101  */
102 int
103 parse_substitute_name(const utf16lechar *substitute_name,
104                       u16 substitute_name_nbytes, u32 rptag)
105 {
106         u16 substitute_name_nchars = substitute_name_nbytes / 2;
107
108         if (substitute_name_nchars >= 7 &&
109             substitute_name[0] == cpu_to_le16('\\') &&
110             substitute_name[1] == cpu_to_le16('?') &&
111             substitute_name[2] == cpu_to_le16('?') &&
112             substitute_name[3] == cpu_to_le16('\\') &&
113             substitute_name[4] != cpu_to_le16('\0') &&
114             substitute_name[5] == cpu_to_le16(':') &&
115             substitute_name[6] == cpu_to_le16('\\'))
116         {
117                 /* "Full" symlink or junction (\??\x:\ prefixed path) */
118                 return 6;
119         } else if (rptag == WIM_IO_REPARSE_TAG_MOUNT_POINT &&
120                    substitute_name_nchars >= 12 &&
121                    memcmp(substitute_name, volume_junction_prefix,
122                           sizeof(volume_junction_prefix)) == 0 &&
123                    substitute_name[substitute_name_nchars - 1] == cpu_to_le16('\\'))
124         {
125                 /* Volume junction.  Can't really do anything with it. */
126                 return SUBST_NAME_IS_VOLUME_JUNCTION;
127         } else if (rptag == WIM_IO_REPARSE_TAG_SYMLINK &&
128                    substitute_name_nchars >= 3 &&
129                    substitute_name[0] != cpu_to_le16('\0') &&
130                    substitute_name[1] == cpu_to_le16(':') &&
131                    substitute_name[2] == cpu_to_le16('\\'))
132         {
133                 /* "Absolute" symlink, with drive letter */
134                 return 2;
135         } else if (rptag == WIM_IO_REPARSE_TAG_SYMLINK &&
136                    substitute_name_nchars >= 1)
137         {
138                 if (substitute_name[0] == cpu_to_le16('\\'))
139                         /* "Absolute" symlink, without drive letter */
140                         return 0;
141                 else
142                         /* "Relative" symlink, without drive letter */
143                         return SUBST_NAME_IS_RELATIVE_LINK;
144         } else {
145                 return SUBST_NAME_IS_UNKNOWN;
146         }
147 }
148
149 /*
150  * Read the data from a symbolic link, junction, or mount point reparse point
151  * buffer into a `struct reparse_data'.
152  *
153  * See http://msdn.microsoft.com/en-us/library/cc232006(v=prot.10).aspx for a
154  * description of the format of the reparse point buffers.
155  */
156 int
157 parse_reparse_data(const u8 * restrict rpbuf, u16 rpbuflen,
158                    struct reparse_data * restrict rpdata)
159 {
160         u16 substitute_name_offset;
161         u16 print_name_offset;
162         const struct reparse_buffer_disk *rpbuf_disk =
163                 (const struct reparse_buffer_disk*)rpbuf;
164         const u8 *data;
165
166         memset(rpdata, 0, sizeof(*rpdata));
167         if (rpbuflen < 16)
168                 goto out_invalid;
169         rpdata->rptag = le32_to_cpu(rpbuf_disk->rptag);
170         wimlib_assert(rpdata->rptag == WIM_IO_REPARSE_TAG_SYMLINK ||
171                       rpdata->rptag == WIM_IO_REPARSE_TAG_MOUNT_POINT);
172         rpdata->rpdatalen = le16_to_cpu(rpbuf_disk->rpdatalen);
173         rpdata->rpreserved = le16_to_cpu(rpbuf_disk->rpreserved);
174         substitute_name_offset = le16_to_cpu(rpbuf_disk->substitute_name_offset);
175         rpdata->substitute_name_nbytes = le16_to_cpu(rpbuf_disk->substitute_name_nbytes);
176         print_name_offset = le16_to_cpu(rpbuf_disk->print_name_offset);
177         rpdata->print_name_nbytes = le16_to_cpu(rpbuf_disk->print_name_nbytes);
178
179         if ((substitute_name_offset & 1) | (print_name_offset & 1) |
180             (rpdata->substitute_name_nbytes & 1) | (rpdata->print_name_nbytes & 1))
181         {
182                 /* Names would be unaligned... */
183                 goto out_invalid;
184         }
185
186         if (rpdata->rptag == WIM_IO_REPARSE_TAG_SYMLINK) {
187                 if (rpbuflen < 20)
188                         goto out_invalid;
189                 rpdata->rpflags = le32_to_cpu(rpbuf_disk->symlink.rpflags);
190                 data = rpbuf_disk->symlink.data;
191         } else {
192                 data = rpbuf_disk->junction.data;
193         }
194         if ((size_t)substitute_name_offset + rpdata->substitute_name_nbytes +
195             (data - rpbuf) > rpbuflen)
196                 goto out_invalid;
197         if ((size_t)print_name_offset + rpdata->print_name_nbytes +
198             (data - rpbuf) > rpbuflen)
199                 goto out_invalid;
200         rpdata->substitute_name = (utf16lechar*)&data[substitute_name_offset];
201         rpdata->print_name = (utf16lechar*)&data[print_name_offset];
202         return 0;
203 out_invalid:
204         ERROR("Invalid reparse data");
205         return WIMLIB_ERR_INVALID_REPARSE_DATA;
206 }
207
208 /*
209  * Create a reparse point data buffer.
210  *
211  * @rpdata:  Structure that contains the data we need.
212  *
213  * @rpbuf:     Buffer into which to write the reparse point data buffer.  Must be
214  *              at least REPARSE_POINT_MAX_SIZE bytes long.
215  */
216 int
217 make_reparse_buffer(const struct reparse_data * restrict rpdata,
218                     u8 * restrict rpbuf,
219                     u16 * restrict rpbuflen_ret)
220 {
221         struct reparse_buffer_disk *rpbuf_disk =
222                 (struct reparse_buffer_disk*)rpbuf;
223         u8 *data;
224
225         rpbuf_disk->rptag = cpu_to_le32(rpdata->rptag);
226         rpbuf_disk->rpreserved = cpu_to_le16(rpdata->rpreserved);
227         rpbuf_disk->substitute_name_offset = cpu_to_le16(0);
228         rpbuf_disk->substitute_name_nbytes = cpu_to_le16(rpdata->substitute_name_nbytes);
229         rpbuf_disk->print_name_offset = cpu_to_le16(rpdata->substitute_name_nbytes + 2);
230         rpbuf_disk->print_name_nbytes = cpu_to_le16(rpdata->print_name_nbytes);
231
232         if (rpdata->rptag == WIM_IO_REPARSE_TAG_SYMLINK) {
233                 rpbuf_disk->symlink.rpflags = cpu_to_le32(rpdata->rpflags);
234                 data = rpbuf_disk->symlink.data;
235         } else {
236                 data = rpbuf_disk->junction.data;
237         }
238
239         /* We null-terminate the substitute and print names, although this may
240          * not be strictly necessary.  Note that the byte counts should not
241          * include the null terminators. */
242         if (data + rpdata->substitute_name_nbytes +
243             rpdata->print_name_nbytes +
244             2 * sizeof(utf16lechar) - rpbuf > REPARSE_POINT_MAX_SIZE)
245         {
246                 ERROR("Reparse data is too long!");
247                 return WIMLIB_ERR_INVALID_REPARSE_DATA;
248         }
249         data = mempcpy(data, rpdata->substitute_name, rpdata->substitute_name_nbytes);
250         *(utf16lechar*)data = cpu_to_le16(0);
251         data += 2;
252         data = mempcpy(data, rpdata->print_name, rpdata->print_name_nbytes);
253         *(utf16lechar*)data = cpu_to_le16(0);
254         data += 2;
255         rpbuf_disk->rpdatalen = cpu_to_le16(data - rpbuf - 8);
256         *rpbuflen_ret = data - rpbuf;
257         return 0;
258 }
259
260 /*
261  * Read the reparse data from a WIM inode that is a reparse point.
262  *
263  * @rpbuf points to a buffer at least REPARSE_POINT_MAX_SIZE bytes into which
264  * the reparse point data buffer will be reconstructed.
265  *
266  * Note: in the WIM format, the first 8 bytes of the reparse point data buffer
267  * are omitted, presumably because we already know the reparse tag from the
268  * dentry, and we already know the reparse tag length from the lookup table
269  * entry resource length.  However, we reconstruct the first 8 bytes in the
270  * buffer returned by this function.
271  */
272 int
273 wim_inode_get_reparse_data(const struct wim_inode * restrict inode,
274                            u8 * restrict rpbuf,
275                            u16 * restrict rpbuflen_ret)
276 {
277         struct wim_lookup_table_entry *lte;
278         int ret;
279         struct reparse_buffer_disk *rpbuf_disk;
280         u16 rpdatalen;
281
282         wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT);
283
284         lte = inode_unnamed_lte_resolved(inode);
285         if (!lte) {
286                 ERROR("Reparse point has no reparse data!");
287                 return WIMLIB_ERR_INVALID_REPARSE_DATA;
288         }
289
290         if (wim_resource_size(lte) > REPARSE_POINT_MAX_SIZE - 8) {
291                 ERROR("Reparse data is too long!");
292                 return WIMLIB_ERR_INVALID_REPARSE_DATA;
293         }
294         rpdatalen = wim_resource_size(lte);
295
296         /* Read the data from the WIM file */
297         ret = read_full_resource_into_buf(lte, rpbuf + 8);
298         if (ret)
299                 return ret;
300
301         /* Reconstruct the first 8 bytes of the reparse point buffer */
302         rpbuf_disk = (struct reparse_buffer_disk*)rpbuf;
303
304         /* ReparseTag */
305         rpbuf_disk->rptag = cpu_to_le32(inode->i_reparse_tag);
306
307         /* ReparseDataLength */
308         rpbuf_disk->rpdatalen = cpu_to_le16(rpdatalen);
309
310         /* ReparseReserved
311          * XXX this could be one of the unknown fields in the WIM dentry. */
312         rpbuf_disk->rpreserved = cpu_to_le16(0);
313
314         *rpbuflen_ret = rpdatalen + 8;
315         return 0;
316 }
317
318 /* UNIX version of getting and setting the data in reparse points */
319 #if !defined(__WIN32__)
320
321 /* Get the UNIX symlink target from a WIM inode.  The inode may be either a
322  * "real" symlink (reparse tag WIM_IO_REPARSE_TAG_SYMLINK), or it may be a
323  * junction point (reparse tag WIM_IO_REPARSE_TAG_MOUNT_POINT).
324  *
325  * This has similar semantics to the UNIX readlink() function, except the path
326  * argument is swapped out with the `struct wim_inode' for a reparse point, and
327  * on failure a negated error code is returned rather than -1 with errno set.  */
328 ssize_t
329 wim_inode_readlink(const struct wim_inode * restrict inode,
330                    char * restrict buf, size_t bufsize)
331 {
332         int ret;
333         struct reparse_buffer_disk rpbuf_disk _aligned_attribute(8);
334         struct reparse_data rpdata;
335         char *link_target;
336         char *translated_target;
337         size_t link_target_len;
338         u16 rpbuflen;
339
340         wimlib_assert(inode_is_symlink(inode));
341
342         if (wim_inode_get_reparse_data(inode, (u8*)&rpbuf_disk, &rpbuflen))
343                 return -EIO;
344
345         if (parse_reparse_data((const u8*)&rpbuf_disk, rpbuflen, &rpdata))
346                 return -EIO;
347
348         ret = utf16le_to_tstr(rpdata.substitute_name,
349                               rpdata.substitute_name_nbytes,
350                               &link_target, &link_target_len);
351         if (ret)
352                 return -errno;
353
354         translated_target = link_target;
355         ret = parse_substitute_name(rpdata.substitute_name,
356                                     rpdata.substitute_name_nbytes,
357                                     rpdata.rptag);
358         switch (ret) {
359         case SUBST_NAME_IS_RELATIVE_LINK:
360                 goto out_translate_slashes;
361         case SUBST_NAME_IS_VOLUME_JUNCTION:
362                 goto out_have_link;
363         case SUBST_NAME_IS_UNKNOWN:
364                 ERROR("Can't understand reparse point "
365                       "substitute name \"%s\"", link_target);
366                 ret = -EIO;
367                 goto out_free_link_target;
368         default:
369                 translated_target += ret;
370                 link_target_len -= ret;
371                 break;
372         }
373
374 out_translate_slashes:
375         for (size_t i = 0; i < link_target_len; i++)
376                 if (translated_target[i] == '\\')
377                         translated_target[i] = '/';
378 out_have_link:
379         if (link_target_len > bufsize) {
380                 link_target_len = bufsize;
381                 ret = -ENAMETOOLONG;
382         } else {
383                 ret = link_target_len;
384         }
385         memcpy(buf, translated_target, link_target_len);
386 out_free_link_target:
387         FREE(link_target);
388         return ret;
389 }
390
391 int
392 wim_inode_set_symlink(struct wim_inode *inode,
393                       const char *target,
394                       struct wim_lookup_table *lookup_table)
395
396 {
397         struct reparse_buffer_disk rpbuf_disk _aligned_attribute(8);
398         struct reparse_data rpdata;
399         static const char abs_subst_name_prefix[12] = "\\\0?\0?\0\\\0C\0:\0";
400         static const char abs_print_name_prefix[4] = "C\0:\0";
401         utf16lechar *name_utf16le;
402         size_t name_utf16le_nbytes;
403         int ret;
404         u16 rpbuflen;
405
406         DEBUG("Creating reparse point data buffer for UNIX "
407               "symlink target \"%s\"", target);
408         memset(&rpdata, 0, sizeof(rpdata));
409         ret = tstr_to_utf16le(target, strlen(target),
410                               &name_utf16le, &name_utf16le_nbytes);
411         if (ret)
412                 return ret;
413
414         for (size_t i = 0; i < name_utf16le_nbytes / 2; i++)
415                 if (name_utf16le[i] == cpu_to_le16('/'))
416                         name_utf16le[i] = cpu_to_le16('\\');
417
418         /* Compatability notes:
419          *
420          * On UNIX, an absolute symbolic link begins with '/'; everything else
421          * is a relative symbolic link.  (Quite simple compared to the various
422          * ways to provide Windows paths.)
423          *
424          * To change a UNIX relative symbolic link to Windows format, we only
425          * need to translate it to UTF-16LE and replace backslashes with forward
426          * slashes.  We do not make any attempt to handle filename character
427          * problems, such as a link target that itself contains backslashes on
428          * UNIX.  Then, for these relative links, we set the reparse header
429          * @flags field to SYMBOLIC_LINK_RELATIVE.
430          *
431          * For UNIX absolute symbolic links, we must set the @flags field to 0.
432          * Then, there are multiple options as to actually represent the
433          * absolute link targets:
434          *
435          * (1) An absolute path beginning with one backslash character. similar
436          * to UNIX-style, just with a different path separator.  Print name same
437          * as substitute name.
438          *
439          * (2) Absolute path beginning with drive letter followed by a
440          * backslash.  Print name same as substitute name.
441          *
442          * (3) Absolute path beginning with drive letter followed by a
443          * backslash; substitute name prefixed with \??\, otherwise same as
444          * print name.
445          *
446          * We choose option (3) here, and we just assume C: for the drive
447          * letter.  The reasoning for this is:
448          *
449          * (1) Microsoft imagex.exe has a bug where it does not attempt to do
450          * reparse point fixups for these links, even though they are valid
451          * absolute links.  (Note: in this case prefixing the substitute name
452          * with \??\ does not work; it just makes the data unable to be restored
453          * at all.)
454          * (2) Microsoft imagex.exe will fail when doing reparse point fixups
455          * for these.  It apparently contains a bug that causes it to create an
456          * invalid reparse point, which then cannot be restored.
457          * (3) This is the only option I tested for which reparse point fixups
458          * worked properly in Microsoft imagex.exe.
459          *
460          * So option (3) it is.
461          */
462
463         rpdata.rptag = inode->i_reparse_tag;
464         if (target[0] == '/') {
465                 rpdata.substitute_name_nbytes = name_utf16le_nbytes +
466                                                 sizeof(abs_subst_name_prefix);
467                 rpdata.print_name_nbytes = name_utf16le_nbytes +
468                                            sizeof(abs_print_name_prefix);
469                 rpdata.substitute_name = alloca(rpdata.substitute_name_nbytes);
470                 rpdata.print_name = alloca(rpdata.print_name_nbytes);
471                 memcpy(rpdata.substitute_name, abs_subst_name_prefix,
472                        sizeof(abs_subst_name_prefix));
473                 memcpy(rpdata.print_name, abs_print_name_prefix,
474                        sizeof(abs_print_name_prefix));
475                 memcpy((void*)rpdata.substitute_name + sizeof(abs_subst_name_prefix),
476                        name_utf16le, name_utf16le_nbytes);
477                 memcpy((void*)rpdata.print_name + sizeof(abs_print_name_prefix),
478                        name_utf16le, name_utf16le_nbytes);
479         } else {
480                 rpdata.substitute_name_nbytes = name_utf16le_nbytes;
481                 rpdata.print_name_nbytes = name_utf16le_nbytes;
482                 rpdata.substitute_name = name_utf16le;
483                 rpdata.print_name = name_utf16le;
484                 rpdata.rpflags = SYMBOLIC_LINK_RELATIVE;
485         }
486
487         ret = make_reparse_buffer(&rpdata, (u8*)&rpbuf_disk, &rpbuflen);
488         if (ret == 0) {
489                 ret = inode_set_unnamed_stream(inode,
490                                                (u8*)&rpbuf_disk + 8,
491                                                rpbuflen - 8,
492                                                lookup_table);
493         }
494         FREE(name_utf16le);
495         return ret;
496 }
497
498 #include <sys/stat.h>
499
500 static int
501 unix_get_ino_and_dev(const char *path, u64 *ino_ret, u64 *dev_ret)
502 {
503         struct stat stbuf;
504         if (stat(path, &stbuf)) {
505                 if (errno != ENOENT)
506                         WARNING_WITH_ERRNO("Failed to stat \"%s\"", path);
507                 /* Treat as a link pointing outside the capture root (it
508                  * most likely is). */
509                 return WIMLIB_ERR_STAT;
510         } else {
511                 *ino_ret = stbuf.st_ino;
512                 *dev_ret = stbuf.st_dev;
513                 return 0;
514         }
515 }
516
517 #endif /* !defined(__WIN32__) */
518
519 #ifdef __WIN32__
520 #  define RP_PATH_SEPARATOR L'\\'
521 #  define is_rp_path_separator(c) ((c) == L'\\' || (c) == L'/')
522 #  define os_get_ino_and_dev win32_get_file_and_vol_ids
523 #else
524 #  define RP_PATH_SEPARATOR '/'
525 #  define is_rp_path_separator(c) ((c) == '/')
526 #  define os_get_ino_and_dev unix_get_ino_and_dev
527 #endif
528
529 /* Fix up absolute symbolic link targets--- mostly shared between UNIX and
530  * Windows */
531 tchar *
532 capture_fixup_absolute_symlink(tchar *dest,
533                                u64 capture_root_ino, u64 capture_root_dev)
534 {
535         tchar *p = dest;
536
537 #ifdef __WIN32__
538         /* Skip drive letter */
539         if (!is_rp_path_separator(*dest))
540                 p += 2;
541 #endif
542
543         DEBUG("Fixing symlink or junction \"%"TS"\"", dest);
544         for (;;) {
545                 tchar save;
546                 int ret;
547                 u64 ino;
548                 u64 dev;
549
550                 while (is_rp_path_separator(*p))
551                         p++;
552
553                 save = *p;
554                 *p = T('\0');
555                 ret = os_get_ino_and_dev(dest, &ino, &dev);
556                 *p = save;
557
558                 if (ret) /* stat() failed before we got to the capture root---
559                             assume the link points outside it. */
560                         return NULL;
561
562                 if (ino == capture_root_ino && dev == capture_root_dev) {
563                         /* Link points inside capture root.  Return abbreviated
564                          * path. */
565                         if (*p == T('\0'))
566                                 *(p - 1) = RP_PATH_SEPARATOR;
567                         while (p - 1 >= dest && is_rp_path_separator(*(p - 1)))
568                                 p--;
569                 #ifdef __WIN32__
570                         if (!is_rp_path_separator(dest[0])) {
571                                 *--p = dest[1];
572                                 *--p = dest[0];
573                         }
574                 #endif
575                         wimlib_assert(p >= dest);
576                         return p;
577                 }
578
579                 if (*p == T('\0')) {
580                         /* Link points outside capture root. */
581                         return NULL;
582                 }
583
584                 do {
585                         p++;
586                 } while (!is_rp_path_separator(*p) && *p != T('\0'));
587         }
588 }