Improve handling of invalid filenames
[wimlib] / src / unix_apply.c
index 97c1c83b2e3c0ac593184f0aa436441bfe98f3e8..b1d914827beec90c9ac3f6e69067cd19161eaaa9 100644 (file)
@@ -1,8 +1,32 @@
-#include "config.h"
+/*
+ * unix_apply.c - Code to apply files from a WIM image on UNIX.
+ */
+
+/*
+ * Copyright (C) 2012, 2013 Eric Biggers
+ *
+ * This file is part of wimlib, a library for working with WIM files.
+ *
+ * wimlib is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wimlib; if not, see http://www.gnu.org/licenses/.
+ */
 
-#ifdef HAVE_UTIME_H
-#  include <utime.h>
+#ifndef __WIN32__
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
 #endif
+
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <unistd.h>
+#ifdef HAVE_UTIME_H
+#  include <utime.h>
+#endif
 
-#include "timestamp.h"
-#include "wimlib_internal.h"
-#include "lookup_table.h"
+#include "wimlib/apply.h"
+#include "wimlib/error.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/reparse.h"
+#include "wimlib/timestamp.h"
 
 /* Returns the number of components of @path.  */
 static unsigned
@@ -42,10 +71,10 @@ path_next_part(const char *path)
 }
 
 static int
-extract_regular_file_linked(struct wim_dentry *dentry,
-                           const char *output_path,
-                           struct apply_args *args,
-                           struct wim_lookup_table_entry *lte)
+unix_extract_regular_file_linked(struct wim_dentry *dentry,
+                                const char *output_path,
+                                struct apply_args *args,
+                                struct wim_lookup_table_entry *lte)
 {
        /* This mode overrides the normal hard-link extraction and
         * instead either symlinks or hardlinks *all* identical files in
@@ -66,8 +95,13 @@ extract_regular_file_linked(struct wim_dentry *dentry,
                char *p;
                const char *p2;
                size_t i;
+               const struct wim_dentry *d;
 
-               num_path_components = get_num_path_components(dentry->_full_path) - 1;
+               num_path_components = 0;
+               for (d = dentry; d != args->extract_root; d = d->parent)
+                       num_path_components++;
+               wimlib_assert(num_path_components > 0);
+               num_path_components--;
                num_output_dir_path_components = get_num_path_components(args->target);
 
                if (args->extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) {
@@ -177,10 +211,10 @@ dir_apply_unix_data(const char *dir, const struct wimlib_unix_data *unix_data,
 }
 
 static int
-extract_regular_file_unlinked(struct wim_dentry *dentry,
-                             struct apply_args *args,
-                             const char *output_path,
-                             struct wim_lookup_table_entry *lte)
+unix_extract_regular_file_unlinked(struct wim_dentry *dentry,
+                                  struct apply_args *args,
+                                  const char *output_path,
+                                  struct wim_lookup_table_entry *lte)
 {
        /* Normal mode of extraction.  Regular files and hard links are
         * extracted in the way that they appear in the WIM. */
@@ -269,9 +303,9 @@ out:
 }
 
 static int
-extract_regular_file(struct wim_dentry *dentry,
-                    struct apply_args *args,
-                    const char *output_path)
+unix_extract_regular_file(struct wim_dentry *dentry,
+                         struct apply_args *args,
+                         const char *output_path)
 {
        struct wim_lookup_table_entry *lte;
        const struct wim_inode *inode = dentry->d_inode;
@@ -282,20 +316,22 @@ extract_regular_file(struct wim_dentry *dentry,
                                           WIMLIB_EXTRACT_FLAG_HARDLINK)))
        {
                if (lte->extracted_file) {
-                       return extract_regular_file_linked(dentry, output_path, args, lte);
+                       return unix_extract_regular_file_linked(dentry,
+                                                               output_path,
+                                                               args, lte);
                } else {
                        lte->extracted_file = STRDUP(output_path);
                        if (!lte->extracted_file)
                                return WIMLIB_ERR_NOMEM;
                }
        }
-       return extract_regular_file_unlinked(dentry, args, output_path, lte);
+       return unix_extract_regular_file_unlinked(dentry, args, output_path, lte);
 }
 
 static int
-extract_symlink(struct wim_dentry *dentry,
-               struct apply_args *args,
-               const char *output_path)
+unix_extract_symlink(struct wim_dentry *dentry,
+                    struct apply_args *args,
+                    const char *output_path)
 {
        char target[4096 + args->target_realpath_len];
        char *fixed_target;
@@ -308,7 +344,7 @@ extract_symlink(struct wim_dentry *dentry,
 
        if (ret <= 0) {
                ERROR("Could not read the symbolic link from dentry `%s'",
-                     dentry->_full_path);
+                     dentry_full_path(dentry));
                return WIMLIB_ERR_INVALID_DENTRY;
        }
        target[args->target_realpath_len + ret] = '\0';
@@ -349,37 +385,33 @@ extract_symlink(struct wim_dentry *dentry,
 }
 
 static int
-extract_directory(struct wim_dentry *dentry, const tchar *output_path,
-                 int extract_flags)
+unix_extract_directory(struct wim_dentry *dentry, const char *output_path,
+                      int extract_flags)
 {
        int ret;
        struct stat stbuf;
 
-       ret = tstat(output_path, &stbuf);
+       ret = stat(output_path, &stbuf);
        if (ret == 0) {
                if (S_ISDIR(stbuf.st_mode)) {
-                       /*if (!is_root)*/
-                               /*WARNING("`%s' already exists", output_path);*/
                        goto dir_exists;
                } else {
-                       ERROR("`%"TS"' is not a directory", output_path);
+                       ERROR("\"%s\" is not a directory", output_path);
                        return WIMLIB_ERR_MKDIR;
                }
        } else {
                if (errno != ENOENT) {
-                       ERROR_WITH_ERRNO("Failed to stat `%"TS"'", output_path);
+                       ERROR_WITH_ERRNO("Failed to stat \"%s\"", output_path);
                        return WIMLIB_ERR_STAT;
                }
        }
 
-       if (tmkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
-       {
-               ERROR_WITH_ERRNO("Cannot create directory `%"TS"'", output_path);
+       if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
+               ERROR_WITH_ERRNO("Cannot create directory \"%s\"", output_path);
                return WIMLIB_ERR_MKDIR;
        }
 dir_exists:
        ret = 0;
-#ifndef __WIN32__
        if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
                struct wimlib_unix_data unix_data;
                ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL);
@@ -391,7 +423,6 @@ dir_exists:
                        ret = dir_apply_unix_data(output_path, &unix_data,
                                                  extract_flags);
        }
-#endif
        return ret;
 }
 
@@ -402,11 +433,11 @@ unix_do_apply_dentry(const char *output_path, size_t output_path_len,
        const struct wim_inode *inode = dentry->d_inode;
 
        if (inode_is_symlink(inode))
-               return extract_symlink(dentry, args, output_path);
+               return unix_extract_symlink(dentry, args, output_path);
        else if (inode_is_directory(inode))
-               return extract_directory(dentry, output_path, args->extract_flags);
+               return unix_extract_directory(dentry, output_path, args->extract_flags);
        else
-               return extract_regular_file(dentry, args, output_path);
+               return unix_extract_regular_file(dentry, args, output_path);
 }
 
 int
@@ -468,3 +499,5 @@ unix_do_apply_dentry_timestamps(const char *output_path,
        }
        return 0;
 }
+
+#endif /* !__WIN32__ */