Add support for special files on UNIX
[wimlib] / src / unix_capture.c
1 /*
2  * unix_capture.c:  Capture a directory tree on UNIX.
3  */
4
5 /*
6  * Copyright (C) 2012, 2013, 2014 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 #ifndef __WIN32__
25
26 #ifdef HAVE_CONFIG_H
27 #  include "config.h"
28 #endif
29
30 #include <dirent.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <limits.h> /* for PATH_MAX */
34 #include <sys/stat.h>
35 #include <unistd.h>
36
37 #include "wimlib/capture.h"
38 #include "wimlib/dentry.h"
39 #include "wimlib/error.h"
40 #include "wimlib/lookup_table.h"
41 #include "wimlib/reparse.h"
42 #include "wimlib/timestamp.h"
43 #include "wimlib/unix_data.h"
44
45 #ifdef HAVE_FDOPENDIR
46 #  define my_fdopendir(dirfd_p) fdopendir(*(dirfd_p))
47 #else
48 static DIR *
49 my_fdopendir(int *dirfd_p)
50 {
51         DIR *dir = NULL;
52         int old_pwd;
53
54         old_pwd = open(".", O_RDONLY);
55         if (old_pwd >= 0) {
56                 if (!fchdir(*dirfd_p)) {
57                         dir = opendir(".");
58                         if (dir) {
59                                 close(*dirfd_p);
60                                 *dirfd_p = dirfd(dir);
61                         }
62                         fchdir(old_pwd);
63                 }
64                 close(old_pwd);
65         }
66         return dir;
67 }
68 #endif
69
70 #ifdef HAVE_OPENAT
71 #  define my_openat(full_path, dirfd, relpath, flags) \
72                 openat((dirfd), (relpath), (flags))
73 #else
74 #  define my_openat(full_path, dirfd, relpath, flags) \
75                 open((full_path), (flags))
76 #endif
77
78 #ifdef HAVE_READLINKAT
79 #  define my_readlinkat(full_path, dirfd, relpath, buf, bufsize) \
80                 readlinkat((dirfd), (relpath), (buf), (bufsize))
81 #else
82 #  define my_readlinkat(full_path, dirfd, relpath, buf, bufsize) \
83                 readlink((full_path), (buf), (bufsize))
84 #endif
85
86 #ifdef HAVE_FSTATAT
87 #  define my_fstatat(full_path, dirfd, relpath, stbuf, flags)   \
88         fstatat((dirfd), (relpath), (stbuf), (flags))
89 #else
90 #  define my_fstatat(full_path, dirfd, relpath, stbuf, flags)   \
91         ((flags) & AT_SYMLINK_NOFOLLOW) ? \
92                 lstat((full_path), (stbuf)) : \
93                 stat((full_path), (stbuf))
94 #endif
95
96 #ifndef AT_FDCWD
97 #  define AT_FDCWD      -100
98 #endif
99
100 #ifndef AT_SYMLINK_NOFOLLOW
101 #  define AT_SYMLINK_NOFOLLOW   0x100
102 #endif
103
104 static int
105 unix_scan_regular_file(const char *path, u64 size, struct wim_inode *inode,
106                        struct list_head *unhashed_streams)
107 {
108         struct wim_lookup_table_entry *lte;
109         char *file_on_disk;
110
111         inode->i_attributes = FILE_ATTRIBUTE_NORMAL;
112
113         /* Empty files do not have to have a lookup table entry. */
114         if (!size)
115                 return 0;
116
117         file_on_disk = STRDUP(path);
118         if (!file_on_disk)
119                 return WIMLIB_ERR_NOMEM;
120         lte = new_lookup_table_entry();
121         if (!lte) {
122                 FREE(file_on_disk);
123                 return WIMLIB_ERR_NOMEM;
124         }
125         lte->file_on_disk = file_on_disk;
126         lte->resource_location = RESOURCE_IN_FILE_ON_DISK;
127         lte->size = size;
128         add_unhashed_stream(lte, inode, 0, unhashed_streams);
129         inode->i_lte = lte;
130         return 0;
131 }
132
133 static int
134 unix_build_dentry_tree_recursive(struct wim_dentry **tree_ret,
135                                  char *path, size_t path_len,
136                                  int dirfd, const char *relpath,
137                                  struct add_image_params *params);
138
139 static int
140 unix_scan_directory(struct wim_dentry *dir_dentry,
141                     char *full_path, size_t full_path_len,
142                     int parent_dirfd, const char *dir_relpath,
143                     struct add_image_params *params)
144 {
145
146         int dirfd;
147         DIR *dir;
148         int ret;
149
150         dirfd = my_openat(full_path, parent_dirfd, dir_relpath, O_RDONLY);
151         if (dirfd < 0) {
152                 ERROR_WITH_ERRNO("\"%s\": Can't open directory", full_path);
153                 return WIMLIB_ERR_OPENDIR;
154         }
155
156         dir_dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
157         dir = my_fdopendir(&dirfd);
158         if (!dir) {
159                 ERROR_WITH_ERRNO("\"%s\": Can't open directory", full_path);
160                 close(dirfd);
161                 return WIMLIB_ERR_OPENDIR;
162         }
163
164         ret = 0;
165         for (;;) {
166                 struct dirent *entry;
167                 struct wim_dentry *child;
168                 size_t name_len;
169
170                 errno = 0;
171                 entry = readdir(dir);
172                 if (!entry) {
173                         if (errno) {
174                                 ret = WIMLIB_ERR_READ;
175                                 ERROR_WITH_ERRNO("\"%s\": Error reading directory",
176                                                  full_path);
177                         }
178                         break;
179                 }
180
181                 if (entry->d_name[0] == '.' &&
182                     (entry->d_name[1] == '\0' ||
183                      (entry->d_name[1] == '.' && entry->d_name[2] == '\0')))
184                         continue;
185
186                 full_path[full_path_len] = '/';
187                 name_len = strlen(entry->d_name);
188                 memcpy(&full_path[full_path_len + 1], entry->d_name, name_len + 1);
189                 ret = unix_build_dentry_tree_recursive(&child,
190                                                        full_path,
191                                                        full_path_len + 1 + name_len,
192                                                        dirfd,
193                                                        &full_path[full_path_len + 1],
194                                                        params);
195                 full_path[full_path_len] = '\0';
196                 if (ret)
197                         break;
198                 if (child)
199                         dentry_add_child(dir_dentry, child);
200         }
201         closedir(dir);
202         return ret;
203 }
204
205 /* Given an absolute symbolic link target @dest (UNIX-style, beginning
206  * with '/'), determine whether it points into the directory specified by
207  * @ino and @dev.  If so, return the target modified to be "absolute"
208  * relative to this directory.  Otherwise, return NULL.  */
209 static char *
210 unix_fixup_abslink(char *dest, u64 ino, u64 dev)
211 {
212         char *p = dest;
213
214         do {
215                 char save;
216                 struct stat stbuf;
217                 int ret;
218
219                 /* Skip non-slashes.  */
220                 while (*p && *p != '/')
221                         p++;
222
223                 /* Skip slashes.  */
224                 while (*p && *p == '/')
225                         p++;
226
227                 /* Get inode and device for this prefix.  */
228                 save = *p;
229                 *p = '\0';
230                 ret = stat(dest, &stbuf);
231                 *p = save;
232
233                 if (ret) {
234                         /* stat() failed.  Assume the link points outside the
235                          * directory tree being captured.  */
236                         break;
237                 }
238
239                 if (stbuf.st_ino == ino && stbuf.st_dev == dev) {
240                         /* Link points inside directory tree being captured.
241                          * Return abbreviated path.  */
242                         *--p = '/';
243                         while (p > dest && *(p - 1) == '/')
244                                 p--;
245                         return p;
246                 }
247         } while (*p);
248
249         /* Link does not point inside directory tree being captured.  */
250         return NULL;
251 }
252
253 static int
254 unix_scan_symlink(struct wim_dentry **root_p, const char *full_path,
255                   int dirfd, const char *relpath,
256                   struct wim_inode *inode, struct add_image_params *params)
257 {
258         char deref_name_buf[4096];
259         ssize_t deref_name_len;
260         char *dest;
261         int ret;
262
263         inode->i_attributes = FILE_ATTRIBUTE_REPARSE_POINT;
264         inode->i_reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
265
266         /* The idea here is to call readlink() to get the UNIX target of the
267          * symbolic link, then turn the target into a reparse point data buffer
268          * that contains a relative or absolute symbolic link. */
269         deref_name_len = my_readlinkat(full_path, dirfd, relpath,
270                                        deref_name_buf, sizeof(deref_name_buf) - 1);
271         if (deref_name_len < 0) {
272                 ERROR_WITH_ERRNO("\"%s\": Can't read target of symbolic link",
273                                  full_path);
274                 return WIMLIB_ERR_READLINK;
275         }
276
277         dest = deref_name_buf;
278
279         dest[deref_name_len] = '\0';
280
281         if ((params->add_flags & WIMLIB_ADD_FLAG_RPFIX) &&
282              dest[0] == '/')
283         {
284                 dest = unix_fixup_abslink(dest,
285                                           params->capture_root_ino,
286                                           params->capture_root_dev);
287                 if (!dest) {
288                         /* RPFIX (reparse point fixup) mode:  Ignore
289                          * absolute symbolic link that points out of the
290                          * tree to be captured.  */
291                         free_dentry(*root_p);
292                         *root_p = NULL;
293                         params->progress.scan.cur_path = full_path;
294                         params->progress.scan.symlink_target = deref_name_buf;
295                         return do_capture_progress(params,
296                                                    WIMLIB_SCAN_DENTRY_EXCLUDED_SYMLINK,
297                                                    NULL);
298                 }
299                 inode->i_not_rpfixed = 0;
300         }
301         ret = wim_inode_set_symlink(inode, dest, params->lookup_table);
302         if (ret)
303                 return ret;
304
305         /* Unfortunately, Windows seems to have the concept of "file" symbolic
306          * links as being different from "directory" symbolic links...  so
307          * FILE_ATTRIBUTE_DIRECTORY needs to be set on the symbolic link if the
308          * *target* of the symbolic link is a directory.  */
309         struct stat stbuf;
310         if (my_fstatat(full_path, dirfd, relpath, &stbuf, 0) == 0 &&
311             S_ISDIR(stbuf.st_mode))
312                 inode->i_attributes |= FILE_ATTRIBUTE_DIRECTORY;
313         return 0;
314 }
315
316 static int
317 unix_build_dentry_tree_recursive(struct wim_dentry **tree_ret,
318                                  char *full_path, size_t full_path_len,
319                                  int dirfd, const char *relpath,
320                                  struct add_image_params *params)
321 {
322         struct wim_dentry *tree = NULL;
323         struct wim_inode *inode = NULL;
324         int ret;
325         struct stat stbuf;
326         int stat_flags;
327
328         if (should_exclude_path(full_path + params->capture_root_nchars,
329                                 full_path_len - params->capture_root_nchars,
330                                 params->config))
331         {
332                 ret = 0;
333                 goto out_progress;
334         }
335
336         if (params->add_flags & (WIMLIB_ADD_FLAG_DEREFERENCE |
337                                  WIMLIB_ADD_FLAG_ROOT))
338                 stat_flags = 0;
339         else
340                 stat_flags = AT_SYMLINK_NOFOLLOW;
341
342         ret = my_fstatat(full_path, dirfd, relpath, &stbuf, stat_flags);
343
344         if (ret) {
345                 ERROR_WITH_ERRNO("\"%s\": Can't read metadata", full_path);
346                 ret = WIMLIB_ERR_STAT;
347                 goto out;
348         }
349
350         if (!(params->add_flags & WIMLIB_ADD_FLAG_UNIX_DATA)) {
351                 if (unlikely(!S_ISREG(stbuf.st_mode) &&
352                              !S_ISDIR(stbuf.st_mode) &&
353                              !S_ISLNK(stbuf.st_mode)))
354                 {
355                         if (params->add_flags &
356                             WIMLIB_ADD_FLAG_NO_UNSUPPORTED_EXCLUDE)
357                         {
358                                 ERROR("\"%s\": File type is unsupported",
359                                       full_path);
360                                 ret = WIMLIB_ERR_UNSUPPORTED_FILE;
361                                 goto out;
362                         }
363                         params->progress.scan.cur_path = full_path;
364                         ret = do_capture_progress(params,
365                                                   WIMLIB_SCAN_DENTRY_UNSUPPORTED,
366                                                   NULL);
367                         goto out;
368                 }
369         }
370
371         ret = inode_table_new_dentry(params->inode_table, relpath,
372                                      stbuf.st_ino, stbuf.st_dev,
373                                      S_ISDIR(stbuf.st_mode), &tree);
374         if (ret)
375                 goto out;
376
377         inode = tree->d_inode;
378
379         if (inode->i_nlink > 1) {
380                 /* Already seen this inode?  */
381                 ret = 0;
382                 goto out_progress;
383         }
384
385 #ifdef HAVE_STAT_NANOSECOND_PRECISION
386         inode->i_creation_time = timespec_to_wim_timestamp(stbuf.st_mtim);
387         inode->i_last_write_time = timespec_to_wim_timestamp(stbuf.st_mtim);
388         inode->i_last_access_time = timespec_to_wim_timestamp(stbuf.st_atim);
389 #else
390         inode->i_creation_time = unix_timestamp_to_wim(stbuf.st_mtime);
391         inode->i_last_write_time = unix_timestamp_to_wim(stbuf.st_mtime);
392         inode->i_last_access_time = unix_timestamp_to_wim(stbuf.st_atime);
393 #endif
394         inode->i_resolved = 1;
395         if (params->add_flags & WIMLIB_ADD_FLAG_UNIX_DATA) {
396                 struct wimlib_unix_data unix_data;
397
398                 unix_data.uid = stbuf.st_uid;
399                 unix_data.gid = stbuf.st_gid;
400                 unix_data.mode = stbuf.st_mode;
401                 unix_data.rdev = stbuf.st_rdev;
402                 if (!inode_set_unix_data(inode, &unix_data, UNIX_DATA_ALL)) {
403                         ret = WIMLIB_ERR_NOMEM;
404                         goto out;
405                 }
406         }
407
408         if (params->add_flags & WIMLIB_ADD_FLAG_ROOT) {
409                 params->capture_root_ino = stbuf.st_ino;
410                 params->capture_root_dev = stbuf.st_dev;
411                 params->add_flags &= ~WIMLIB_ADD_FLAG_ROOT;
412         }
413
414         if (S_ISREG(stbuf.st_mode)) {
415                 ret = unix_scan_regular_file(full_path, stbuf.st_size,
416                                              inode, params->unhashed_streams);
417         } else if (S_ISDIR(stbuf.st_mode)) {
418                 ret = unix_scan_directory(tree, full_path, full_path_len,
419                                           dirfd, relpath, params);
420         } else if (S_ISLNK(stbuf.st_mode)) {
421                 ret = unix_scan_symlink(&tree, full_path, dirfd, relpath,
422                                         inode, params);
423                 if (!tree)
424                         goto out;
425         }
426
427         if (ret)
428                 goto out;
429
430 out_progress:
431         params->progress.scan.cur_path = full_path;
432         if (likely(tree))
433                 ret = do_capture_progress(params, WIMLIB_SCAN_DENTRY_OK, inode);
434         else
435                 ret = do_capture_progress(params, WIMLIB_SCAN_DENTRY_EXCLUDED, NULL);
436 out:
437         if (likely(ret == 0))
438                 *tree_ret = tree;
439         else
440                 free_dentry_tree(tree, params->lookup_table);
441         return ret;
442 }
443
444 /*
445  * unix_build_dentry_tree():
446  *      Builds a tree of WIM dentries from an on-disk directory tree (UNIX
447  *      version; no NTFS-specific data is captured).
448  *
449  * @root_ret:   Place to return a pointer to the root of the dentry tree.  Only
450  *              modified if successful.  Set to NULL if the file or directory was
451  *              excluded from capture.
452  *
453  * @root_disk_path:  The path to the root of the directory tree on disk.
454  *
455  * @params:     See doc for `struct add_image_params'.
456  *
457  * @return:     0 on success, nonzero on failure.  It is a failure if any of
458  *              the files cannot be `stat'ed, or if any of the needed
459  *              directories cannot be opened or read.  Failure to add the files
460  *              to the WIM may still occur later when trying to actually read
461  *              the on-disk files during a call to wimlib_write() or
462  *              wimlib_overwrite().
463  */
464 int
465 unix_build_dentry_tree(struct wim_dentry **root_ret,
466                        const char *root_disk_path,
467                        struct add_image_params *params)
468 {
469         size_t path_len;
470         size_t path_bufsz;
471         char *path_buf;
472         int ret;
473
474         path_len = strlen(root_disk_path);
475         path_bufsz = min(32790, PATH_MAX + 1);
476
477         if (path_len >= path_bufsz)
478                 return WIMLIB_ERR_INVALID_PARAM;
479
480         path_buf = MALLOC(path_bufsz);
481         if (!path_buf)
482                 return WIMLIB_ERR_NOMEM;
483         memcpy(path_buf, root_disk_path, path_len + 1);
484
485         params->capture_root_nchars = path_len;
486
487         ret = unix_build_dentry_tree_recursive(root_ret, path_buf, path_len,
488                                                AT_FDCWD, path_buf, params);
489         FREE(path_buf);
490         return ret;
491 }
492
493 #endif /* !__WIN32__ */