summaryrefslogtreecommitdiffstats
path: root/unit/atf-src/tools/fs.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--unit/atf-src/tools/fs.cpp744
1 files changed, 744 insertions, 0 deletions
diff --git a/unit/atf-src/tools/fs.cpp b/unit/atf-src/tools/fs.cpp
new file mode 100644
index 0000000..deed28c
--- /dev/null
+++ b/unit/atf-src/tools/fs.cpp
@@ -0,0 +1,744 @@
+//
+// Automated Testing Framework (atf)
+//
+// Copyright (c) 2007 The NetBSD Foundation, Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
+// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+extern "C" {
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <dirent.h>
+#include <libgen.h>
+#include <unistd.h>
+}
+
+#include <cassert>
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+
+#include "auto_array.hpp"
+#include "env.hpp"
+#include "exceptions.hpp"
+#include "fs.hpp"
+#include "process.hpp"
+#include "text.hpp"
+#include "user.hpp"
+
+namespace impl = tools::fs;
+#define IMPL_NAME "tools::fs"
+
+// ------------------------------------------------------------------------
+// Auxiliary functions.
+// ------------------------------------------------------------------------
+
+static void cleanup_aux(const impl::path&, dev_t, bool);
+static void cleanup_aux_dir(const impl::path&, const impl::file_info&,
+ bool);
+static void do_unmount(const impl::path&);
+static bool safe_access(const impl::path&, int, int);
+
+static const int access_f = 1 << 0;
+static const int access_r = 1 << 1;
+static const int access_w = 1 << 2;
+static const int access_x = 1 << 3;
+
+//!
+//! An implementation of access(2) but using the effective user value
+//! instead of the real one. Also avoids false positives for root when
+//! asking for execute permissions, which appear in SunOS.
+//!
+static
+void
+eaccess(const tools::fs::path& p, int mode)
+{
+ assert(mode & access_f || mode & access_r ||
+ mode & access_w || mode & access_x);
+
+ struct stat st;
+ if (lstat(p.c_str(), &st) == -1)
+ throw tools::system_error(IMPL_NAME "::eaccess",
+ "Cannot get information from file " +
+ p.str(), errno);
+
+ /* Early return if we are only checking for existence and the file
+ * exists (stat call returned). */
+ if (mode & access_f)
+ return;
+
+ bool ok = false;
+ if (tools::user::is_root()) {
+ if (!ok && !(mode & access_x)) {
+ /* Allow root to read/write any file. */
+ ok = true;
+ }
+
+ if (!ok && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
+ /* Allow root to execute the file if any of its execution bits
+ * are set. */
+ ok = true;
+ }
+ } else {
+ if (!ok && (tools::user::euid() == st.st_uid)) {
+ ok = ((mode & access_r) && (st.st_mode & S_IRUSR)) ||
+ ((mode & access_w) && (st.st_mode & S_IWUSR)) ||
+ ((mode & access_x) && (st.st_mode & S_IXUSR));
+ }
+ if (!ok && tools::user::is_member_of_group(st.st_gid)) {
+ ok = ((mode & access_r) && (st.st_mode & S_IRGRP)) ||
+ ((mode & access_w) && (st.st_mode & S_IWGRP)) ||
+ ((mode & access_x) && (st.st_mode & S_IXGRP));
+ }
+ if (!ok && ((tools::user::euid() != st.st_uid) &&
+ !tools::user::is_member_of_group(st.st_gid))) {
+ ok = ((mode & access_r) && (st.st_mode & S_IROTH)) ||
+ ((mode & access_w) && (st.st_mode & S_IWOTH)) ||
+ ((mode & access_x) && (st.st_mode & S_IXOTH));
+ }
+ }
+
+ if (!ok)
+ throw tools::system_error(IMPL_NAME "::eaccess", "Access check failed",
+ EACCES);
+}
+
+//!
+//! \brief A controlled version of access(2).
+//!
+//! This function reimplements the standard access(2) system call to
+//! safely control its exit status and raise an exception in case of
+//! failure.
+//!
+static
+bool
+safe_access(const impl::path& p, int mode, int experr)
+{
+ try {
+ eaccess(p, mode);
+ return true;
+ } catch (const tools::system_error& e) {
+ if (e.code() == experr)
+ return false;
+ else
+ throw e;
+ }
+}
+
+// The cleanup routines below are tricky: they are executed immediately after
+// a test case's death, and after we have forcibly killed any stale processes.
+// However, even if the processes are dead, this does not mean that the file
+// system we are scanning is stable. In particular, if the test case has
+// mounted file systems through fuse/puffs, the fact that the processes died
+// does not mean that the file system is truly unmounted.
+//
+// The code below attempts to cope with this by catching errors and either
+// ignoring them or retrying the actions on the same file/directory a few times
+// before giving up.
+static const int max_retries = 5;
+static const int retry_delay_in_seconds = 1;
+
+// The erase parameter in this routine is to control nested mount points.
+// We want to descend into a mount point to unmount anything that is
+// mounted under it, but we do not want to delete any files while doing
+// this traversal. In other words, we erase files until we cross the
+// first mount point, and after that point we only scan and unmount.
+static
+void
+cleanup_aux(const impl::path& p, dev_t parent_device, bool erase)
+{
+ try {
+ impl::file_info fi(p);
+
+ if (fi.get_type() == impl::file_info::dir_type)
+ cleanup_aux_dir(p, fi, fi.get_device() == parent_device);
+
+ if (fi.get_device() != parent_device)
+ do_unmount(p);
+
+ if (erase) {
+ if (fi.get_type() == impl::file_info::dir_type)
+ impl::rmdir(p);
+ else
+ impl::remove(p);
+ }
+ } catch (const tools::system_error& e) {
+ if (e.code() != ENOENT && e.code() != ENOTDIR)
+ throw e;
+ }
+}
+
+static
+void
+cleanup_aux_dir(const impl::path& p, const impl::file_info& fi,
+ bool erase)
+{
+ if (erase && ((fi.get_mode() & S_IRWXU) != S_IRWXU)) {
+ int retries = max_retries;
+retry_chmod:
+ if (chmod(p.c_str(), fi.get_mode() | S_IRWXU) == -1) {
+ if (retries > 0) {
+ retries--;
+ ::sleep(retry_delay_in_seconds);
+ goto retry_chmod;
+ } else {
+ throw tools::system_error(IMPL_NAME "::cleanup(" +
+ p.str() + ")", "chmod(2) failed",
+ errno);
+ }
+ }
+ }
+
+ std::set< std::string > subdirs;
+ {
+ bool ok = false;
+ int retries = max_retries;
+ while (!ok) {
+ assert(retries > 0);
+ try {
+ const impl::directory d(p);
+ subdirs = d.names();
+ ok = true;
+ } catch (const tools::system_error& e) {
+ retries--;
+ if (retries == 0)
+ throw e;
+ ::sleep(retry_delay_in_seconds);
+ }
+ }
+ assert(ok);
+ }
+
+ for (std::set< std::string >::const_iterator iter = subdirs.begin();
+ iter != subdirs.end(); iter++) {
+ const std::string& name = *iter;
+ if (name != "." && name != "..")
+ cleanup_aux(p / name, fi.get_device(), erase);
+ }
+}
+
+static
+void
+do_unmount(const impl::path& in_path)
+{
+ // At least, FreeBSD's unmount(2) requires the path to be absolute.
+ // Let's make it absolute in all cases just to be safe that this does
+ // not affect other systems.
+ const impl::path& abs_path = in_path.is_absolute() ?
+ in_path : in_path.to_absolute();
+
+#if defined(HAVE_UNMOUNT)
+ int retries = max_retries;
+retry_unmount:
+ if (unmount(abs_path.c_str(), 0) == -1) {
+ if (errno == EBUSY && retries > 0) {
+ retries--;
+ ::sleep(retry_delay_in_seconds);
+ goto retry_unmount;
+ } else {
+ throw tools::system_error(IMPL_NAME "::cleanup(" + in_path.str() +
+ ")", "unmount(2) failed", errno);
+ }
+ }
+#else
+ // We could use umount(2) instead if it was available... but
+ // trying to do so under, e.g. Linux, is a nightmare because we
+ // also have to update /etc/mtab to match what we did. It is
+ // stools::fser to just leave the system-specific umount(8) tool deal
+ // with it, at least for now.
+
+ const impl::path prog("umount");
+ tools::process::argv_array argv("umount", abs_path.c_str(), NULL);
+
+ tools::process::status s = tools::process::exec(prog, argv,
+ tools::process::stream_inherit(), tools::process::stream_inherit());
+ if (!s.exited() || s.exitstatus() != EXIT_SUCCESS)
+ throw std::runtime_error("Call to unmount failed");
+#endif
+}
+
+static
+std::string
+normalize(const std::string& in)
+{
+ assert(!in.empty());
+
+ std::string out;
+
+ std::string::size_type pos = 0;
+ do {
+ const std::string::size_type next_pos = in.find('/', pos);
+
+ const std::string component = in.substr(pos, next_pos - pos);
+ if (!component.empty()) {
+ if (pos == 0)
+ out += component;
+ else if (component != ".")
+ out += "/" + component;
+ }
+
+ if (next_pos == std::string::npos)
+ pos = next_pos;
+ else
+ pos = next_pos + 1;
+ } while (pos != std::string::npos);
+
+ return out.empty() ? "/" : out;
+}
+
+// ------------------------------------------------------------------------
+// The "path" class.
+// ------------------------------------------------------------------------
+
+impl::path::path(const std::string& s) :
+ m_data(normalize(s))
+{
+}
+
+impl::path::~path(void)
+{
+}
+
+const char*
+impl::path::c_str(void)
+ const
+{
+ return m_data.c_str();
+}
+
+std::string
+impl::path::str(void)
+ const
+{
+ return m_data;
+}
+
+bool
+impl::path::is_absolute(void)
+ const
+{
+ return !m_data.empty() && m_data[0] == '/';
+}
+
+bool
+impl::path::is_root(void)
+ const
+{
+ return m_data == "/";
+}
+
+impl::path
+impl::path::branch_path(void)
+ const
+{
+ const std::string::size_type endpos = m_data.rfind('/');
+ if (endpos == std::string::npos)
+ return path(".");
+ else if (endpos == 0)
+ return path("/");
+ else
+ return path(m_data.substr(0, endpos));
+}
+
+std::string
+impl::path::leaf_name(void)
+ const
+{
+ std::string::size_type begpos = m_data.rfind('/');
+ if (begpos == std::string::npos)
+ begpos = 0;
+ else
+ begpos++;
+
+ return m_data.substr(begpos);
+}
+
+impl::path
+impl::path::to_absolute(void)
+ const
+{
+ assert(!is_absolute());
+ return get_current_dir() / m_data;
+}
+
+bool
+impl::path::operator==(const path& p)
+ const
+{
+ return m_data == p.m_data;
+}
+
+bool
+impl::path::operator!=(const path& p)
+ const
+{
+ return m_data != p.m_data;
+}
+
+impl::path
+impl::path::operator/(const std::string& p)
+ const
+{
+ return path(m_data + "/" + normalize(p));
+}
+
+impl::path
+impl::path::operator/(const path& p)
+ const
+{
+ return path(m_data) / p.m_data;
+}
+
+bool
+impl::path::operator<(const path& p)
+ const
+{
+ return std::strcmp(m_data.c_str(), p.m_data.c_str()) < 0;
+}
+
+// ------------------------------------------------------------------------
+// The "file_info" class.
+// ------------------------------------------------------------------------
+
+const int impl::file_info::blk_type = 1;
+const int impl::file_info::chr_type = 2;
+const int impl::file_info::dir_type = 3;
+const int impl::file_info::fifo_type = 4;
+const int impl::file_info::lnk_type = 5;
+const int impl::file_info::reg_type = 6;
+const int impl::file_info::sock_type = 7;
+const int impl::file_info::wht_type = 8;
+
+impl::file_info::file_info(const path& p)
+{
+ if (lstat(p.c_str(), &m_sb) == -1)
+ throw system_error(IMPL_NAME "::file_info",
+ "Cannot get information of " + p.str() + "; " +
+ "lstat(2) failed", errno);
+
+ int type = m_sb.st_mode & S_IFMT;
+ switch (type) {
+ case S_IFBLK: m_type = blk_type; break;
+ case S_IFCHR: m_type = chr_type; break;
+ case S_IFDIR: m_type = dir_type; break;
+ case S_IFIFO: m_type = fifo_type; break;
+ case S_IFLNK: m_type = lnk_type; break;
+ case S_IFREG: m_type = reg_type; break;
+ case S_IFSOCK: m_type = sock_type; break;
+#if defined(S_IFWHT)
+ case S_IFWHT: m_type = wht_type; break;
+#endif
+ default:
+ throw system_error(IMPL_NAME "::file_info", "Unknown file type "
+ "error", EINVAL);
+ }
+}
+
+impl::file_info::~file_info(void)
+{
+}
+
+dev_t
+impl::file_info::get_device(void)
+ const
+{
+ return m_sb.st_dev;
+}
+
+ino_t
+impl::file_info::get_inode(void)
+ const
+{
+ return m_sb.st_ino;
+}
+
+mode_t
+impl::file_info::get_mode(void)
+ const
+{
+ return m_sb.st_mode & ~S_IFMT;
+}
+
+off_t
+impl::file_info::get_size(void)
+ const
+{
+ return m_sb.st_size;
+}
+
+int
+impl::file_info::get_type(void)
+ const
+{
+ return m_type;
+}
+
+bool
+impl::file_info::is_owner_readable(void)
+ const
+{
+ return m_sb.st_mode & S_IRUSR;
+}
+
+bool
+impl::file_info::is_owner_writable(void)
+ const
+{
+ return m_sb.st_mode & S_IWUSR;
+}
+
+bool
+impl::file_info::is_owner_executable(void)
+ const
+{
+ return m_sb.st_mode & S_IXUSR;
+}
+
+bool
+impl::file_info::is_group_readable(void)
+ const
+{
+ return m_sb.st_mode & S_IRGRP;
+}
+
+bool
+impl::file_info::is_group_writable(void)
+ const
+{
+ return m_sb.st_mode & S_IWGRP;
+}
+
+bool
+impl::file_info::is_group_executable(void)
+ const
+{
+ return m_sb.st_mode & S_IXGRP;
+}
+
+bool
+impl::file_info::is_other_readable(void)
+ const
+{
+ return m_sb.st_mode & S_IROTH;
+}
+
+bool
+impl::file_info::is_other_writable(void)
+ const
+{
+ return m_sb.st_mode & S_IWOTH;
+}
+
+bool
+impl::file_info::is_other_executable(void)
+ const
+{
+ return m_sb.st_mode & S_IXOTH;
+}
+
+// ------------------------------------------------------------------------
+// The "directory" class.
+// ------------------------------------------------------------------------
+
+impl::directory::directory(const path& p)
+{
+ DIR* dp = ::opendir(p.c_str());
+ if (dp == NULL)
+ throw system_error(IMPL_NAME "::directory::directory(" +
+ p.str() + ")", "opendir(3) failed", errno);
+
+ struct dirent* dep;
+ while ((dep = ::readdir(dp)) != NULL) {
+ path entryp = p / dep->d_name;
+ insert(value_type(dep->d_name, file_info(entryp)));
+ }
+
+ if (::closedir(dp) == -1)
+ throw system_error(IMPL_NAME "::directory::directory(" +
+ p.str() + ")", "closedir(3) failed", errno);
+}
+
+std::set< std::string >
+impl::directory::names(void)
+ const
+{
+ std::set< std::string > ns;
+
+ for (const_iterator iter = begin(); iter != end(); iter++)
+ ns.insert((*iter).first);
+
+ return ns;
+}
+
+// ------------------------------------------------------------------------
+// The "temp_dir" class.
+// ------------------------------------------------------------------------
+
+impl::temp_dir::temp_dir(const path& p)
+{
+ tools::auto_array< char > buf(new char[p.str().length() + 1]);
+ std::strcpy(buf.get(), p.c_str());
+ if (::mkdtemp(buf.get()) == NULL)
+ throw tools::system_error(IMPL_NAME "::temp_dir::temp_dir(" +
+ p.str() + ")", "mkdtemp(3) failed",
+ errno);
+
+ m_path.reset(new path(buf.get()));
+}
+
+impl::temp_dir::~temp_dir(void)
+{
+ cleanup(*m_path);
+}
+
+const impl::path&
+impl::temp_dir::get_path(void)
+ const
+{
+ return *m_path;
+}
+
+// ------------------------------------------------------------------------
+// Free functions.
+// ------------------------------------------------------------------------
+
+bool
+impl::exists(const path& p)
+{
+ try {
+ eaccess(p, access_f);
+ return true;
+ } catch (const system_error& e) {
+ if (e.code() == ENOENT)
+ return false;
+ else
+ throw;
+ }
+}
+
+bool
+impl::have_prog_in_path(const std::string& prog)
+{
+ assert(prog.find('/') == std::string::npos);
+
+ // Do not bother to provide a default value for PATH. If it is not
+ // there something is broken in the user's environment.
+ if (!tools::env::has("PATH"))
+ throw std::runtime_error("PATH not defined in the environment");
+ std::vector< std::string > dirs =
+ tools::text::split(tools::env::get("PATH"), ":");
+
+ bool found = false;
+ for (std::vector< std::string >::const_iterator iter = dirs.begin();
+ !found && iter != dirs.end(); iter++) {
+ const path& dir = path(*iter);
+
+ if (is_executable(dir / prog))
+ found = true;
+ }
+ return found;
+}
+
+bool
+impl::is_executable(const path& p)
+{
+ if (!exists(p))
+ return false;
+ return safe_access(p, access_x, EACCES);
+}
+
+void
+impl::remove(const path& p)
+{
+ if (file_info(p).get_type() == file_info::dir_type)
+ throw tools::system_error(IMPL_NAME "::remove(" + p.str() + ")",
+ "Is a directory",
+ EPERM);
+ if (::unlink(p.c_str()) == -1)
+ throw tools::system_error(IMPL_NAME "::remove(" + p.str() + ")",
+ "unlink(" + p.str() + ") failed",
+ errno);
+}
+
+void
+impl::rmdir(const path& p)
+{
+ if (::rmdir(p.c_str())) {
+ if (errno == EEXIST) {
+ /* Some operating systems (e.g. OpenSolaris 200906) return
+ * EEXIST instead of ENOTEMPTY for non-empty directories.
+ * Homogenize the return value so that callers don't need
+ * to bother about differences in operating systems. */
+ errno = ENOTEMPTY;
+ }
+ throw system_error(IMPL_NAME "::rmdir", "Cannot remove directory",
+ errno);
+ }
+}
+
+impl::path
+impl::change_directory(const path& dir)
+{
+ path olddir = get_current_dir();
+
+ if (olddir != dir) {
+ if (::chdir(dir.c_str()) == -1)
+ throw tools::system_error(IMPL_NAME "::chdir(" + dir.str() + ")",
+ "chdir(2) failed", errno);
+ }
+
+ return olddir;
+}
+
+void
+impl::cleanup(const path& p)
+{
+ impl::file_info fi(p);
+ cleanup_aux(p, fi.get_device(), true);
+}
+
+impl::path
+impl::get_current_dir(void)
+{
+ std::auto_ptr< char > cwd;
+#if defined(HAVE_GETCWD_DYN)
+ cwd.reset(getcwd(NULL, 0));
+#else
+ cwd.reset(getcwd(NULL, MAXPATHLEN));
+#endif
+ if (cwd.get() == NULL)
+ throw tools::system_error(IMPL_NAME "::get_current_dir()",
+ "getcwd() failed", errno);
+
+ return path(cwd.get());
+}