mirror of
https://github.com/google/fuse-archive.git
synced 2026-11-20 16:41:43 +00:00
599 lines
19 KiB
C++
599 lines
19 KiB
C++
// Copyright 2021 The Fuse-Archive Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// fuse-archive mounts an archive or compressed file (e.g. foo.tar, foo.tar.gz,
|
|
// foo.xz, foo.zip) as a read-only FUSE file system
|
|
// (https://en.wikipedia.org/wiki/Filesystem_in_Userspace).
|
|
|
|
#include <archive.h>
|
|
#include <archive_entry.h>
|
|
#include <fcntl.h>
|
|
#include <fuse.h>
|
|
#include <langinfo.h>
|
|
#include <locale.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/types.h>
|
|
#include <syslog.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cassert>
|
|
#include <cctype>
|
|
#include <cerrno>
|
|
#include <chrono>
|
|
#include <climits>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <exception>
|
|
#include <functional>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <limits>
|
|
#include <locale>
|
|
#include <memory>
|
|
#include <new>
|
|
#include <ostream>
|
|
#include <span>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <system_error>
|
|
#include <tuple>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "lib/common.h"
|
|
#include "lib/file_descriptor.h"
|
|
#include "lib/fuse_ops.h"
|
|
#include "lib/hashed_string.h"
|
|
#include "lib/node.h"
|
|
#include "lib/path.h"
|
|
#include "lib/reader.h"
|
|
#include "lib/tree.h"
|
|
#include "lib/util.h"
|
|
|
|
#define PROGRAM_NAME "fuse-archive"
|
|
#define PROGRAM_VERSION "1.25"
|
|
|
|
// ---- Compile-time Configuration
|
|
|
|
namespace {
|
|
|
|
using namespace ::fuse_archive;
|
|
|
|
// ---- Context
|
|
|
|
struct Context {
|
|
static_assert(sizeof(Cache) == sizeof(int));
|
|
static_assert(sizeof(LogLevel) == sizeof(int));
|
|
|
|
Options options;
|
|
LogLevel log_level = LogLevel::INFO;
|
|
int help = 0;
|
|
int version = 0;
|
|
int can_use_external_filters = 1;
|
|
int unsafe_path = 0;
|
|
std::vector<std::string> archives;
|
|
};
|
|
|
|
// ---- Globals
|
|
|
|
fuse_opt const g_fuse_opts[] = {
|
|
{"--help", offsetof(Context, help), 1},
|
|
{"-h", offsetof(Context, help), 1},
|
|
{"--version", offsetof(Context, version), 1},
|
|
{"-V", offsetof(Context, version), 1},
|
|
{"--verbose", offsetof(Context, log_level), int(LogLevel::DEBUG)},
|
|
{"verbose", offsetof(Context, log_level), int(LogLevel::DEBUG)},
|
|
{"-v", offsetof(Context, log_level), int(LogLevel::DEBUG)},
|
|
{"--quiet", offsetof(Context, log_level), int(LogLevel::ERROR)},
|
|
{"quiet", offsetof(Context, log_level), int(LogLevel::ERROR)},
|
|
{"-q", offsetof(Context, log_level), int(LogLevel::ERROR)},
|
|
{"--redact", offsetof(Context, options.redact), 1},
|
|
{"redact", offsetof(Context, options.redact), 1},
|
|
{"force", offsetof(Context, options.force), 1},
|
|
{"unsafe_path", offsetof(Context, unsafe_path), 1},
|
|
{"precache", offsetof(Context, options.cache), int(Cache::Full)},
|
|
{"lazycache", offsetof(Context, options.cache), int(Cache::Lazy)},
|
|
{"nocache", offsetof(Context, options.cache), int(Cache::None)},
|
|
{"memcache", offsetof(Context, options.memcache), 1},
|
|
{"nomerge", offsetof(Context, options.merge), 0},
|
|
{"notrim", offsetof(Context, options.trim), 0},
|
|
{"nodirs", offsetof(Context, options.dirs), 0},
|
|
{"nospecials", offsetof(Context, options.specials), 0},
|
|
{"nosymlinks", offsetof(Context, options.symlinks), 0},
|
|
{"noholes", offsetof(Context, options.holes), 0},
|
|
{"nohardlinks", offsetof(Context, options.hardlinks), 0},
|
|
{"noxattrs", offsetof(Context, options.xattrs), 0},
|
|
{"nobidding", offsetof(Context, options.bidding), 0},
|
|
{"noexternal", offsetof(Context, can_use_external_filters), 0},
|
|
{"enforce_permissions", offsetof(Context, options.enforce_permissions), 1},
|
|
{"default_permissions", offsetof(Context, options.enforce_permissions), 1},
|
|
#if FUSE_USE_VERSION >= 30
|
|
{"direct_io", offsetof(Context, options.direct_io), 1},
|
|
#endif
|
|
{"dmask=%o", offsetof(Context, options.dmask)},
|
|
{"fmask=%o", offsetof(Context, options.fmask)},
|
|
{"maxfilters=%d", offsetof(Context, options.max_filter_count)},
|
|
FUSE_OPT_END,
|
|
};
|
|
|
|
// Path of the mount point.
|
|
|
|
// Processes one command line argument.
|
|
int ProcessArg(void* data, const char* const arg, int const key, fuse_args*) {
|
|
assert(data);
|
|
Context& ctx = *static_cast<Context*>(data);
|
|
constexpr int KEEP = 1;
|
|
constexpr int DISCARD = 0;
|
|
|
|
switch (key) {
|
|
case FUSE_OPT_KEY_NONOPT:
|
|
ctx.archives.push_back(arg);
|
|
return DISCARD;
|
|
}
|
|
|
|
return KEEP;
|
|
}
|
|
|
|
// Ensures that the default encoding is UTF-8.
|
|
void EnsureUtf8() {
|
|
// libarchive (especially for reading 7z) has locale-dependent behavior.
|
|
// Non-ASCII paths can trigger "Pathname cannot be converted from UTF-16LE to
|
|
// current locale" warnings from archive_read_next_header and
|
|
// archive_entry_pathname_utf8 subsequently returning nullptr.
|
|
//
|
|
// Calling setlocale to enforce a UTF-8 encoding can avoid that. Try various
|
|
// arguments and pick the first one that is supported and produces UTF-8.
|
|
const char* const locales[] = {
|
|
// As of 2021, many systems (including Debian) support "C.UTF-8".
|
|
"C.UTF-8",
|
|
// However, "C.UTF-8" is not a POSIX standard and glibc 2.34 (released
|
|
// 2021-08-01) does not support it. It may come to glibc 2.35 (see the
|
|
// sourceware.org commit link below), but until then and on older
|
|
// systems, try the popular "en_US.UTF-8".
|
|
//
|
|
// https://sourceware.org/git/?p=glibc.git;a=commit;h=466f2be6c08070e9113ae2fdc7acd5d8828cba50
|
|
"en_US.UTF-8",
|
|
// As a final fallback, an empty string means to use the relevant
|
|
// environment variables (LANG, LC_ALL, etc).
|
|
"",
|
|
};
|
|
|
|
std::string_view const want = "UTF-8";
|
|
|
|
for (const char* const locale : locales) {
|
|
if (setlocale(LC_ALL, locale) && want == nl_langinfo(CODESET)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
LOG(ERROR) << "Cannot ensure UTF-8 encoding";
|
|
throw ExitCode::GENERIC_FAILURE;
|
|
}
|
|
|
|
// Guard that executes the given function upon destruction.
|
|
struct Cleanup {
|
|
std::function<void()> fn;
|
|
|
|
~Cleanup() {
|
|
if (fn) {
|
|
fn();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Formatter for numbers using thousand separators.
|
|
class NumPunct : public std::numpunct<char> {
|
|
private:
|
|
char do_thousands_sep() const override { return ','; }
|
|
std::string do_grouping() const override { return "\3"; }
|
|
};
|
|
|
|
// Prints usage on standard output.
|
|
void PrintUsage() {
|
|
std::cout
|
|
<< R"(Mount one or several archives or compressed files as a read-only FUSE file system.
|
|
|
|
Usage:
|
|
)" PROGRAM_NAME
|
|
R"( [options] archive [mount_point]
|
|
)" PROGRAM_NAME
|
|
R"( [options] archive... mount_point
|
|
|
|
general options:
|
|
-o opt,[opt...] mount options
|
|
-h --help print help
|
|
-V --version print version
|
|
|
|
)" PROGRAM_NAME R"( options:
|
|
-q -o quiet do not print progress messages
|
|
-v -o verbose print more log messages
|
|
-o redact redact paths from log messages
|
|
-o force continue despite errors
|
|
-o unsafe_path do not sanitize PATH for external programs
|
|
-o maxfilters=N max number of filters (default 1)
|
|
-o precache pre-emptive caching of uncompressed data (default)
|
|
-o lazycache incremental caching of uncompressed data
|
|
-o nocache no caching of uncompressed data
|
|
-o memcache caching in memory
|
|
-o nomerge don't merge multiple archives in the same directory
|
|
-o notrim don't trim the base of the tree
|
|
-o nodirs no directories
|
|
-o nospecials no special files (FIFOs, sockets, devices)
|
|
-o nosymlinks no symlinks
|
|
-o noholes no sparse files
|
|
-o nohardlinks no hard links
|
|
-o noxattrs no extended attributes
|
|
-o nobidding rely on file extension to detect archive format
|
|
-o noexternal do not use external programs for decompression
|
|
-o enforce_permissions enforce standard UNIX permissions
|
|
-o dmask=M directory permission mask in octal (default 0022)
|
|
-o fmask=M file permission mask in octal (default 0022))"
|
|
#if FUSE_USE_VERSION >= 30
|
|
R"(
|
|
-o direct_io use direct I/O)"
|
|
#endif
|
|
"\n\n"
|
|
<< std::flush;
|
|
}
|
|
|
|
// Value to use for PATH when it should be empty or disabled. Using "/dev/null"
|
|
// ensures that any attempt to execute an external program via PATH will fail
|
|
// with ENOTDIR, avoiding unintended fallbacks to system defaults or the
|
|
// current directory.
|
|
static const char safe_empty_path[] = "/dev/null";
|
|
|
|
// Limits the PATH environment variable to a predefined set of safe system
|
|
// directories. This prevents the execution of untrusted external filters from
|
|
// non-standard locations while allowing those necessary for archive processing.
|
|
void SetSafePath() {
|
|
std::string out;
|
|
|
|
if (const char* const p = getenv("PATH")) {
|
|
for (std::string_view in = p; !in.empty();) {
|
|
// Split PATH by ':' and normalize each directory.
|
|
size_t const i = in.find(':');
|
|
std::string_view const dir =
|
|
Path(in.substr(0, i)).WithoutTrailingSeparator();
|
|
|
|
// Recognized safe system locations.
|
|
static const std::unordered_set<std::string_view> safe_dirs = {
|
|
"/usr/bin", "/bin", "/usr/local/bin",
|
|
#ifdef __APPLE__
|
|
"/opt/homebrew/bin", "/opt/local/bin",
|
|
#endif
|
|
};
|
|
|
|
// Only keep directories that are in the safe list.
|
|
if (safe_dirs.contains(dir)) {
|
|
if (!out.empty()) {
|
|
out += ':';
|
|
}
|
|
out += dir;
|
|
}
|
|
|
|
if (i == std::string_view::npos) {
|
|
break;
|
|
}
|
|
|
|
in.remove_prefix(i + 1);
|
|
}
|
|
}
|
|
|
|
if (out.empty()) {
|
|
out = safe_empty_path;
|
|
}
|
|
|
|
LOG(DEBUG) << "Setting PATH to " << Path(out);
|
|
if (setenv("PATH", out.c_str(), true) < 0) {
|
|
PLOG(ERROR) << "Cannot set PATH to " << Path(out);
|
|
throw ExitCode::GENERIC_FAILURE;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Formats command line arguments.
|
|
std::ostream& operator<<(std::ostream& out, const fuse_args& args) {
|
|
std::string_view sep;
|
|
for (int i = 0; i < args.argc; ++i) {
|
|
out << sep << std::quoted(args.argv[i]);
|
|
sep = " ";
|
|
}
|
|
|
|
assert(!args.argv[args.argc]);
|
|
return out;
|
|
}
|
|
|
|
// ---- Main
|
|
|
|
int main(int const argc, char** const argv) try {
|
|
// Ensure that numbers in debug messages have thousands separators.
|
|
// It makes big numbers much easier to read (eg sizes expressed in bytes).
|
|
std::locale::global(std::locale(std::locale::classic(), new NumPunct));
|
|
openlog(PROGRAM_NAME, LOG_PERROR, LOG_USER);
|
|
SetLogLevel(LogLevel::INFO);
|
|
|
|
EnsureUtf8();
|
|
|
|
Tree* tree = nullptr;
|
|
|
|
fuse_args args = FUSE_ARGS_INIT(argc, argv);
|
|
|
|
#ifdef __SANITIZE_ADDRESS__
|
|
// When running with ASAN, clean up everything at exit so that we can verify
|
|
// that no memory has leaked.
|
|
Cleanup const global_cleanup_guard([&tree, &args] {
|
|
Timer const timer;
|
|
LOG(INFO) << "Cleaning up";
|
|
delete tree;
|
|
tree = nullptr;
|
|
delete g_unique_strings;
|
|
g_unique_strings = nullptr;
|
|
fuse_opt_free_args(&args);
|
|
LOG(INFO) << "Cleaned up in " << timer;
|
|
});
|
|
#endif
|
|
|
|
Context ctx;
|
|
if (fuse_opt_parse(&args, &ctx, g_fuse_opts, &ProcessArg) < 0) {
|
|
LOG(ERROR) << "Cannot parse command line arguments";
|
|
throw ExitCode::GENERIC_FAILURE;
|
|
}
|
|
|
|
g_redact = ctx.options.redact;
|
|
SetLogLevel(ctx.log_level);
|
|
|
|
if (!ctx.options.dirs) {
|
|
ctx.options.hardlinks = false;
|
|
}
|
|
|
|
const fuse_operations ops = GetFuseOperations();
|
|
|
|
if (ctx.help) {
|
|
PrintUsage();
|
|
|
|
#if FUSE_USE_VERSION >= 30
|
|
// Forward --help to libfuse so that it can print its own help.
|
|
fuse_opt_add_arg(&args, "--help");
|
|
|
|
// Pass an empty program name to libfuse's help output so that it doesn't
|
|
// print the "Usage: " line again.
|
|
char empty_argv0[] = "";
|
|
char* const old_argv0 = args.argv[0];
|
|
args.argv[0] = empty_argv0;
|
|
|
|
fuse_main(args.argc, args.argv, &ops, tree);
|
|
|
|
args.argv[0] = old_argv0;
|
|
return EXIT_SUCCESS;
|
|
#else
|
|
dup2(STDOUT_FILENO, STDERR_FILENO);
|
|
fuse_opt_add_arg(&args, "-ho"); // I think ho means "help output".
|
|
fuse_main(args.argc, args.argv, &ops, tree);
|
|
_exit(EXIT_SUCCESS);
|
|
#endif
|
|
}
|
|
|
|
if (ctx.version) {
|
|
std::cout << PROGRAM_NAME " " PROGRAM_VERSION "\n";
|
|
std::cout << archive_version_details() << "\n";
|
|
std::cout.flush();
|
|
|
|
// Forward --version to libfuse so that it can print its own version.
|
|
fuse_opt_add_arg(&args, "--version");
|
|
|
|
#if FUSE_USE_VERSION >= 30
|
|
fuse_main(args.argc, args.argv, &ops, tree);
|
|
return EXIT_SUCCESS;
|
|
#else
|
|
dup2(STDOUT_FILENO, STDERR_FILENO);
|
|
fuse_main(args.argc, args.argv, &ops, tree);
|
|
_exit(EXIT_SUCCESS);
|
|
#endif
|
|
}
|
|
|
|
if (ctx.archives.empty()) {
|
|
PrintUsage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// Sanitize PATH.
|
|
if (ctx.can_use_external_filters) {
|
|
if (ctx.unsafe_path) {
|
|
LOG(DEBUG) << "Keeping unsafe path " << Path(getenv("PATH") ?: "");
|
|
} else {
|
|
SetSafePath();
|
|
}
|
|
} else if (setenv("PATH", safe_empty_path, 1) < 0) {
|
|
PLOG(ERROR) << "Cannot reset PATH";
|
|
throw ExitCode::GENERIC_FAILURE;
|
|
}
|
|
|
|
// Determine where the mount point should be.
|
|
// The last non-option argument is the mount point, unless only one such
|
|
// argument was provided, in which case it is both the archive and the base
|
|
// for the mount point name.
|
|
std::string mount_point;
|
|
bool const mount_point_specified_by_user = ctx.archives.size() > 1;
|
|
if (mount_point_specified_by_user) {
|
|
mount_point = std::move(ctx.archives.back());
|
|
ctx.archives.pop_back();
|
|
} else {
|
|
mount_point = Path(ctx.archives.front())
|
|
.WithoutTrailingSeparator()
|
|
.Split()
|
|
.second.WithoutExtension();
|
|
}
|
|
|
|
std::string mount_point_parent, mount_point_basename;
|
|
std::tie(mount_point_parent, mount_point_basename) =
|
|
Path(mount_point).WithoutTrailingSeparator().Split();
|
|
|
|
if (mount_point_basename.empty()) {
|
|
LOG(ERROR) << "Cannot use " << Path(mount_point) << " as a mount point";
|
|
throw ExitCode::CANNOT_CREATE_MOUNT_POINT;
|
|
}
|
|
|
|
// Get a file descriptor to the parent directory of the mount point.
|
|
FileDescriptor mount_point_parent_fd(
|
|
open(!mount_point_parent.empty() ? mount_point_parent.c_str() : ".",
|
|
#if defined(O_PATH)
|
|
O_DIRECTORY | O_PATH)); // Linux, FreeBSD >= 13
|
|
#elif defined(O_EXEC)
|
|
O_DIRECTORY | O_EXEC)); // FreeBSD <= 12
|
|
#else
|
|
O_DIRECTORY | O_RDONLY)); // OpenBSD, macOS
|
|
#endif
|
|
|
|
if (!mount_point_parent_fd.IsValid()) {
|
|
PLOG(ERROR) << "Cannot access directory " << Path(mount_point_parent);
|
|
throw ExitCode::CANNOT_CREATE_MOUNT_POINT;
|
|
}
|
|
|
|
// Force single-threading if not fully cached.
|
|
// When using lazy cache or no cache, we should only use one FUSE thread
|
|
// because libarchive is not thread-safe.
|
|
if (ctx.options.cache != Cache::Full) {
|
|
fuse_opt_add_arg(&args, "-s");
|
|
}
|
|
|
|
// Mount the file system in read-only mode.
|
|
fuse_opt_add_arg(&args, "-r");
|
|
|
|
#if FUSE_USE_VERSION < 30
|
|
// Respect inode numbers.
|
|
fuse_opt_add_arg(&args, "-o");
|
|
fuse_opt_add_arg(&args, "use_ino");
|
|
#endif
|
|
|
|
if (ctx.options.enforce_permissions) {
|
|
fuse_opt_add_arg(&args, "-o");
|
|
fuse_opt_add_arg(&args, "default_permissions");
|
|
}
|
|
|
|
// Read archive and build tree.
|
|
Timer timer;
|
|
|
|
tree = new Tree();
|
|
tree->SetOptions(ctx.options);
|
|
|
|
// Create cache file if necessary.
|
|
if (ctx.options.cache != Cache::None) {
|
|
tree->SetCacheFd(CreateCacheFile(ctx.options.memcache));
|
|
}
|
|
|
|
tree->Load(ctx.archives);
|
|
|
|
// Log some debug messages.
|
|
if (LOG_IS_ON(DEBUG)) {
|
|
if (ctx.archives.size() > 1) {
|
|
LOG(DEBUG) << "Loaded " << ctx.archives.size() << " archives in "
|
|
<< timer;
|
|
} else {
|
|
LOG(DEBUG) << "Loaded " << Path(ctx.archives.front()) << " in " << timer;
|
|
}
|
|
|
|
LOG(DEBUG) << "The file system contains " << tree->GetNodeCount() - 1
|
|
<< " items totalling " << i64(tree->GetBlockCount()) * block_size
|
|
<< " bytes";
|
|
|
|
if (Stat z; ctx.options.cache == Cache::Full &&
|
|
fstat(tree->GetCacheFd(), &z) == 0) {
|
|
LOG(DEBUG) << "The cache takes " << i64(z.st_blocks) * block_size
|
|
<< " bytes of disk space";
|
|
assert(z.st_size == tree->GetCacheSize());
|
|
}
|
|
}
|
|
|
|
// Create the mount point if it does not already exist.
|
|
Cleanup mount_point_guard;
|
|
{
|
|
auto const n = mount_point_basename.size();
|
|
int i = 0;
|
|
while (true) {
|
|
mount_point = mount_point_parent;
|
|
Path::Append(&mount_point, mount_point_basename);
|
|
|
|
if (mkdirat(mount_point_parent_fd, mount_point_basename.c_str(), 0777) ==
|
|
0) {
|
|
LOG(INFO) << "Created mount point " << Path(mount_point);
|
|
|
|
// Set the cleanup function that will eventually remove this mount
|
|
// point.
|
|
mount_point_guard.fn = [&mount_point_parent_fd, mount_point_basename,
|
|
mount_point]() {
|
|
if (unlinkat(mount_point_parent_fd, mount_point_basename.c_str(),
|
|
AT_REMOVEDIR) == 0) {
|
|
LOG(INFO) << "Removed mount point " << Path(mount_point);
|
|
} else {
|
|
PLOG(ERROR) << "Cannot remove mount point " << Path(mount_point);
|
|
}
|
|
};
|
|
|
|
break;
|
|
}
|
|
|
|
if (errno != EEXIST) {
|
|
PLOG(ERROR) << "Cannot create mount point " << Path(mount_point);
|
|
throw ExitCode::CANNOT_CREATE_MOUNT_POINT;
|
|
}
|
|
|
|
if (mount_point_specified_by_user) {
|
|
LOG(DEBUG) << "Using existing mount point " << Path(mount_point);
|
|
mount_point_parent_fd.Close();
|
|
break;
|
|
}
|
|
|
|
LOG(DEBUG) << "Mount point " << Path(mount_point) << " already exists";
|
|
|
|
mount_point_basename.resize(n);
|
|
mount_point_basename += StrCat(" (", ++i, ")");
|
|
}
|
|
}
|
|
|
|
// The mount point is in place.
|
|
if (mount_point.starts_with('-')) {
|
|
// If the mount point name starts with a '-', libfuse will think it is an
|
|
// option. Prepended "./" to avoid this.
|
|
fuse_opt_add_arg(&args, StrCat("./", mount_point).c_str());
|
|
} else {
|
|
fuse_opt_add_arg(&args, mount_point.c_str());
|
|
}
|
|
|
|
// Start serving the filesystem.
|
|
LOG(DEBUG) << "Calling fuse_main() with " << args;
|
|
int const res = fuse_main(args.argc, args.argv, &ops, tree);
|
|
|
|
LOG(DEBUG) << "Returning " << ExitCode(res);
|
|
return res;
|
|
} catch (ExitCode const e) {
|
|
LOG(DEBUG) << "Returning " << e;
|
|
return static_cast<int>(e);
|
|
} catch (const std::exception& e) {
|
|
LOG(ERROR) << e.what();
|
|
LOG(DEBUG) << "Returning " << ExitCode::GENERIC_FAILURE;
|
|
return static_cast<int>(ExitCode::GENERIC_FAILURE);
|
|
}
|