#include "libmain/shared.hh"
#include <algorithm>
#include <cctype>
#include <csignal>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <mutex>
#include <utility>
#include <glog/logging.h>
#include <openssl/crypto.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include "libstore/globals.hh"
#include "libstore/store-api.hh"
#include "libutil/util.hh"
namespace nix {
static bool gcWarning = true;
void printGCWarning() {
if (!gcWarning) {
return;
}
static bool haveWarned = false;
if (!haveWarned) {
haveWarned = true;
LOG(WARNING) << "you did not specify '--add-root'; "
<< "the result might be removed by the garbage collector";
}
}
void printMissing(const ref<Store>& store, const PathSet& paths) {
unsigned long long downloadSize = 0;
unsigned long long narSize = 0;
PathSet willBuild;
PathSet willSubstitute;
PathSet unknown;
store->queryMissing(paths, willBuild, willSubstitute, unknown, downloadSize,
narSize);
printMissing(store, willBuild, willSubstitute, unknown, downloadSize,
narSize);
}
void printMissing(const ref<Store>& store, const PathSet& willBuild,
const PathSet& willSubstitute, const PathSet& unknown,
unsigned long long downloadSize, unsigned long long narSize) {
if (!willBuild.empty()) {
LOG(INFO) << "these derivations will be built:";
Paths sorted = store->topoSortPaths(willBuild);
reverse(sorted.begin(), sorted.end());
for (auto& i : sorted) {
LOG(INFO) << " " << i;
}
}
if (!willSubstitute.empty()) {
LOG(INFO) << "these paths will be fetched ("
<< (downloadSize / (1024.0 * 1024.0)) << " MiB download, "
<< (narSize / (1024.0 * 1024.0)) << "MiB unpacked):";
for (auto& i : willSubstitute) {
LOG(INFO) << i;
}
}
if (!unknown.empty()) {
LOG(INFO) << "don't know how to build these paths"
<< (settings.readOnlyMode
? " (may be caused by read-only store access)"
: "")
<< ":";
for (auto& i : unknown) {
LOG(INFO) << i;
}
}
}
std::string getArg(const std::string& opt, Strings::iterator& i,
const Strings::iterator& end) {
++i;
if (i == end) {
throw UsageError(format("'%1%' requires an argument") % opt);
}
return *i;
}
#if OPENSSL_VERSION_NUMBER < 0x10101000L
/* OpenSSL is not thread-safe by default - it will randomly crash
unless the user supplies a mutex locking function. So let's do
that. */
static std::vector<std::mutex> opensslLocks;
static void opensslLockCallback(int mode, int type, const char* file,
int line) {
if (mode & CRYPTO_LOCK)
opensslLocks[type].lock();
else
opensslLocks[type].unlock();
}
#endif
static void sigHandler(int signo) {}
void initNix() {
/* Turn on buffering for cerr. */
#if HAVE_PUBSETBUF
static char buf[1024];
std::cerr.rdbuf()->pubsetbuf(buf, sizeof(buf));
#endif
#if OPENSSL_VERSION_NUMBER < 0x10101000L
/* Initialise OpenSSL locking. */
opensslLocks = std::vector<std::mutex>(CRYPTO_num_locks());
CRYPTO_set_locking_callback(opensslLockCallback);
#endif
loadConfFile();
startSignalHandlerThread();
/* Reset SIGCHLD to its default. */
struct sigaction act {};
sigemptyset(&act.sa_mask);
act.sa_handler = SIG_DFL;
act.sa_flags = 0;
if (sigaction(SIGCHLD, &act, nullptr) != 0) {
throw SysError("resetting SIGCHLD");
}
/* Install a dummy SIGUSR1 handler for use with pthread_kill(). */
act.sa_handler = sigHandler;
if (sigaction(SIGUSR1, &act, nullptr) != 0) {
throw SysError("handling SIGUSR1");
}
/* Register a SIGSEGV handler to detect stack overflows. */
detectStackOverflow();
/* There is no privacy in the Nix system ;-) At least not for
now. In particular, store objects should be readable by
everybody. */
umask(0022);
/* Initialise the PRNG. */
struct timeval tv {};
gettimeofday(&tv, nullptr);
srandom(tv.tv_usec);
}
LegacyArgs::LegacyArgs(
const std::string& programName,
std::function<bool(Strings::iterator& arg, const Strings::iterator& end)>
parseArg)
: MixCommonArgs(programName), parseArg(std::move(parseArg)) {
mkFlag()
.longName("no-build-output")
.shortName('Q')
.description("do not show build output")
.set(&settings.verboseBuild, false);
mkFlag()
.longName("keep-failed")
.shortName('K')
.description("keep temporary directories of failed builds")
.set(&(bool&)settings.keepFailed, true);
mkFlag()
.longName("keep-going")
.shortName('k')
.description("keep going after a build fails")
.set(&(bool&)settings.keepGoing, true);
mkFlag()
.longName("fallback")
.description("build from source if substitution fails")
.set(&(bool&)settings.tryFallback, true);
auto intSettingAlias = [&](char shortName, const std::string& longName,
const std::string& description,
const std::string& dest) {
mkFlag<unsigned int>(shortName, longName, description, [=](unsigned int n) {
settings.set(dest, std::to_string(n));
});
};
intSettingAlias(0, "cores",
"maximum number of CPU cores to use inside a build", "cores");
intSettingAlias(0, "max-silent-time",
"number of seconds of silence before a build is killed",
"max-silent-time");
intSettingAlias(0, "timeout", "number of seconds before a build is killed",
"timeout");
mkFlag(0, "readonly-mode", "do not write to the Nix store",
&settings.readOnlyMode);
mkFlag(0, "no-gc-warning", "disable warning about not using '--add-root'",
&gcWarning, false);
mkFlag()
.longName("store")
.label("store-uri")
.description("URI of the Nix store to use")
.dest(&(std::string&)settings.storeUri);
}
bool LegacyArgs::processFlag(Strings::iterator& pos, Strings::iterator end) {
if (MixCommonArgs::processFlag(pos, end)) {
return true;
}
bool res = parseArg(pos, end);
if (res) {
++pos;
}
return res;
}
bool LegacyArgs::processArgs(const Strings& args, bool finish) {
if (args.empty()) {
return true;
}
assert(args.size() == 1);
Strings ss(args);
auto pos = ss.begin();
if (!parseArg(pos, ss.end())) {
throw UsageError(format("unexpected argument '%1%'") % args.front());
}
return true;
}
void parseCmdLine(
int argc, char** argv,
std::function<bool(Strings::iterator& arg, const Strings::iterator& end)>
parseArg) {
parseCmdLine(baseNameOf(argv[0]), argvToStrings(argc, argv),
std::move(parseArg));
}
void parseCmdLine(
const std::string& programName, const Strings& args,
std::function<bool(Strings::iterator& arg, const Strings::iterator& end)>
parseArg) {
LegacyArgs(programName, std::move(parseArg)).parseCmdline(args);
}
void printVersion(const std::string& programName) {
std::cout << format("%1% (Nix) %2%") % programName % nixVersion << std::endl;
// TODO(tazjin): figure out what the fuck this is
/*if (verbosity > lvlInfo) {
Strings cfg;
#if HAVE_BOEHMGC
cfg.push_back("gc");
#endif
#if HAVE_SODIUM
cfg.push_back("signed-caches");
#endif
std::cout << "Features: " << concatStringsSep(", ", cfg) << "\n";
std::cout << "Configuration file: " << settings.nixConfDir + "/nix.conf"
<< "\n";
std::cout << "Store directory: " << settings.nixStore << "\n";
std::cout << "State directory: " << settings.nixStateDir << "\n";
} */
throw Exit();
}
void showManPage(const std::string& name) {
restoreSignals();
setenv("MANPATH", settings.nixManDir.c_str(), 1);
execlp("man", "man", name.c_str(), nullptr);
throw SysError(format("command 'man %1%' failed") % name.c_str());
}
int handleExceptions(const std::string& programName,
const std::function<void()>& fun) {
ReceiveInterrupts receiveInterrupts; // FIXME: need better place for this
std::string error = ANSI_RED "error:" ANSI_NORMAL " ";
try {
try {
fun();
} catch (...) {
/* Subtle: we have to make sure that any `interrupted'
condition is discharged before we reach printMsg()
below, since otherwise it will throw an (uncaught)
exception. */
setInterruptThrown();
throw;
}
} catch (Exit& e) {
return e.status;
} catch (UsageError& e) {
LOG(INFO) << e.what();
LOG(INFO) << "Try '" << programName << " --help' for more information.";
return 1;
} catch (BaseError& e) {
LOG(ERROR) << error << (settings.showTrace ? e.prefix() : "") << e.msg();
if (!e.prefix().empty() && !settings.showTrace) {
LOG(INFO) << "(use '--show-trace' to show detailed location information)";
}
return e.status;
} catch (std::bad_alloc& e) {
LOG(ERROR) << error << "failed to allocate: " << e.what();
return 1;
} catch (std::exception& e) {
LOG(ERROR) << error << e.what();
return 1;
}
return 0;
}
RunPager::RunPager() {
if (isatty(STDOUT_FILENO) == 0) {
return;
}
char* pager = getenv("NIX_PAGER");
if (pager == nullptr) {
pager = getenv("PAGER");
}
if (pager && (std::string(pager) == "" || std::string(pager) == "cat")) {
return;
}
Pipe toPager;
toPager.create();
pid = startProcess([&]() {
if (dup2(toPager.readSide.get(), STDIN_FILENO) == -1) {
throw SysError("dupping stdin");
}
if (getenv("LESS") == nullptr) {
setenv("LESS", "FRSXMK", 1);
}
restoreSignals();
if (pager != nullptr) {
execl("/bin/sh", "sh", "-c", pager, nullptr);
}
execlp("pager", "pager", nullptr);
execlp("less", "less", nullptr);
execlp("more", "more", nullptr);
throw SysError(format("executing '%1%'") % pager);
});
pid.setKillSignal(SIGINT);
if (dup2(toPager.writeSide.get(), STDOUT_FILENO) == -1) {
throw SysError("dupping stdout");
}
}
RunPager::~RunPager() {
try {
if (pid != -1) {
std::cout.flush();
close(STDOUT_FILENO);
pid.wait();
}
} catch (...) {
ignoreException();
}
}
std::string showBytes(unsigned long long bytes) {
return (format("%.2f MiB") % (bytes / (1024.0 * 1024.0))).str();
}
PrintFreed::~PrintFreed() {
if (show) {
std::cout << format("%1% store paths deleted, %2% freed\n") %
results.paths.size() % showBytes(results.bytesFreed);
}
}
Exit::~Exit() = default;
} // namespace nix
