diff options
Diffstat (limited to '')
| -rw-r--r-- | unit/atf-src/tools/fs.cpp | 744 |
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()); +} |