#include <cstring>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <vector>
#include <absl/strings/ascii.h>
#include <absl/strings/str_split.h>
#include <glog/logging.h>
#include "libexpr/attr-path.hh"
#include "libexpr/common-eval-args.hh"
#include "libexpr/eval-inline.hh"
#include "libexpr/eval.hh"
#include "libexpr/get-drvs.hh"
#include "libmain/shared.hh"
#include "libstore/derivations.hh"
#include "libstore/globals.hh"
#include "libstore/store-api.hh"
#include "libutil/affinity.hh"
#include "libutil/util.hh"
#include "nix/legacy.hh"
using namespace nix;
using namespace std::string_literals;
/* Recreate the effect of the perl shellwords function, breaking up a
* string into arguments like a shell word, including escapes
*/
std::vector<std::string> shellwords(const std::string& s) {
std::regex whitespace("^(\\s+).*");
auto begin = s.cbegin();
std::vector<std::string> res;
std::string cur;
enum state { sBegin, sQuote };
state st = sBegin;
auto it = begin;
for (; it != s.cend(); ++it) {
if (st == sBegin) {
std::smatch match;
if (regex_search(it, s.cend(), match, whitespace)) {
cur.append(begin, it);
res.push_back(cur);
cur.clear();
it = match[1].second;
begin = it;
}
}
switch (*it) {
case '"':
cur.append(begin, it);
begin = it + 1;
st = st == sBegin ? sQuote : sBegin;
break;
case '\\':
/* perl shellwords mostly just treats the next char as part of the
* string with no special processing */
cur.append(begin, it);
begin = ++it;
break;
}
}
cur.append(begin, it);
if (!cur.empty()) {
res.push_back(cur);
}
return res;
}
static void _main(int argc, char** argv) {
auto dryRun = false;
auto runEnv = std::regex_search(argv[0], std::regex("nix-shell$"));
auto pure = false;
auto fromArgs = false;
auto packages = false;
// Same condition as bash uses for interactive shells
auto interactive =
(isatty(STDIN_FILENO) != 0) && (isatty(STDERR_FILENO) != 0);
Strings attrPaths;
Strings left;
RepairFlag repair = NoRepair;
Path gcRoot;
BuildMode buildMode = bmNormal;
bool readStdin = false;
std::string envCommand; // interactive shell
Strings envExclude;
auto myName = runEnv ? "nix-shell" : "nix-build";
auto inShebang = false;
std::string script;
std::vector<std::string> savedArgs;
AutoDelete tmpDir(createTempDir("", myName));
std::string outLink = "./result";
// List of environment variables kept for --pure
std::set<std::string> keepVars{
"HOME", "USER", "LOGNAME", "DISPLAY", "PATH", "TERM",
"IN_NIX_SHELL", "TZ", "PAGER", "NIX_BUILD_SHELL", "SHLVL"};
Strings args;
for (int i = 1; i < argc; ++i) {
args.push_back(argv[i]);
}
// Heuristic to see if we're invoked as a shebang script, namely,
// if we have at least one argument, it's the name of an
// executable file, and it starts with "#!".
if (runEnv && argc > 1 &&
!std::regex_search(argv[1], std::regex("nix-shell"))) {
script = argv[1];
try {
Strings lines = absl::StrSplit(readFile(script), absl::ByChar('\n'));
if (std::regex_search(lines.front(), std::regex("^#!"))) {
lines.pop_front();
inShebang = true;
for (int i = 2; i < argc; ++i) {
savedArgs.emplace_back(argv[i]);
}
args.clear();
for (auto line : lines) {
line = absl::StripTrailingAsciiWhitespace(line);
std::smatch match;
if (std::regex_match(line, match,
std::regex("^#!\\s*nix-shell (.*)$"))) {
for (const auto& word : shellwords(match[1].str())) {
args.push_back(word);
}
}
}
}
} catch (SysError&) {
}
}
struct MyArgs : LegacyArgs, MixEvalArgs {
using LegacyArgs::LegacyArgs;
};
MyArgs myArgs(
myName, [&](Strings::iterator& arg, const Strings::iterator& end) {
if (*arg == "--help") {
deletePath(tmpDir);
showManPage(myName);
}
else if (*arg == "--version") {
printVersion(myName);
} else if (*arg == "--add-drv-link" || *arg == "--indirect") {
; // obsolete
} else if (*arg == "--no-out-link" || *arg == "--no-link") {
outLink = (Path)tmpDir + "/result";
} else if (*arg == "--attr" || *arg == "-A") {
attrPaths.push_back(getArg(*arg, arg, end));
} else if (*arg == "--drv-link") {
getArg(*arg, arg, end); // obsolete
} else if (*arg == "--out-link" || *arg == "-o") {
outLink = getArg(*arg, arg, end);
} else if (*arg == "--add-root") {
gcRoot = getArg(*arg, arg, end);
} else if (*arg == "--dry-run") {
dryRun = true;
} else if (*arg == "--repair") {
repair = Repair;
buildMode = bmRepair;
}
else if (*arg == "--run-env") { // obsolete
runEnv = true;
} else if (*arg == "--command" || *arg == "--run") {
if (*arg == "--run") {
interactive = false;
}
envCommand = getArg(*arg, arg, end) + "\nexit";
}
else if (*arg == "--check") {
buildMode = bmCheck;
} else if (*arg == "--exclude") {
envExclude.push_back(getArg(*arg, arg, end));
} else if (*arg == "--expr" || *arg == "-E") {
fromArgs = true;
} else if (runEnv && *arg == "--pure") {
pure = true;
} else if (runEnv && *arg == "--impure") {
pure = false;
} else if (*arg == "--packages" || *arg == "-p") {
packages = true;
} else if (inShebang && *arg == "-i") {
auto interpreter = getArg(*arg, arg, end);
interactive = false;
auto execArgs = "";
// Überhack to support Perl. Perl examines the shebang and
// executes it unless it contains the string "perl" or "indir",
// or (undocumented) argv[0] does not contain "perl". Exploit
// the latter by doing "exec -a".
if (std::regex_search(interpreter, std::regex("perl"))) {
execArgs = "-a PERL";
}
std::ostringstream joined;
for (const auto& i : savedArgs) {
joined << shellEscape(i) << ' ';
}
if (std::regex_search(interpreter, std::regex("ruby"))) {
// Hack for Ruby. Ruby also examines the shebang. It tries to
// read the shebang to understand which packages to read from. Since
// this is handled via nix-shell -p, we wrap our ruby script
// execution in ruby -e 'load' which ignores the shebangs.
envCommand = (format("exec %1% %2% -e 'load(\"%3%\")' -- %4%") %
execArgs % interpreter % script % joined.str())
.str();
} else {
envCommand = (format("exec %1% %2% %3% %4%") % execArgs %
interpreter % script % joined.str())
.str();
}
}
else if (*arg == "--keep") {
keepVars.insert(getArg(*arg, arg, end));
} else if (*arg == "-") {
readStdin = true;
} else if (*arg != "" && arg->at(0) == '-') {
return false;
} else {
left.push_back(*arg);
}
return true;
});
myArgs.parseCmdline(args);
initPlugins();
if (packages && fromArgs) {
throw UsageError("'-p' and '-E' are mutually exclusive");
}
auto store = openStore();
auto state = std::make_unique<EvalState>(myArgs.searchPath, store);
state->repair = repair;
Bindings& autoArgs = *myArgs.getAutoArgs(*state);
if (packages) {
std::ostringstream joined;
joined << "with import <nixpkgs> { }; (pkgs.runCommandCC or "
"pkgs.runCommand) \"shell\" { buildInputs = [ ";
for (const auto& i : left) {
joined << '(' << i << ") ";
}
joined << "]; } \"\"";
fromArgs = true;
left = {joined.str()};
} else if (!fromArgs) {
if (left.empty() && runEnv && pathExists("shell.nix")) {
left = {"shell.nix"};
}
if (left.empty()) {
left = {"default.nix"};
}
}
if (runEnv) {
setenv("IN_NIX_SHELL", pure ? "pure" : "impure", 1);
}
DrvInfos drvs;
/* Parse the expressions. */
std::vector<Expr*> exprs;
if (readStdin) {
exprs = {state->parseStdin()};
} else {
for (const auto& i : left) {
if (fromArgs) {
exprs.push_back(state->parseExprFromString(i, absPath(".")));
} else {
auto absolute = i;
try {
absolute = canonPath(absPath(i), true);
} catch (Error& e) {
};
if (store->isStorePath(absolute) &&
std::regex_match(absolute, std::regex(".*\\.drv(!.*)?"))) {
drvs.push_back(DrvInfo(*state, store, absolute));
} else {
/* If we're in a #! script, interpret filenames
relative to the script. */
exprs.push_back(
state->parseExprFromFile(resolveExprPath(state->checkSourcePath(
lookupFileArg(*state, inShebang && !packages
? absPath(i, absPath(dirOf(script)))
: i)))));
}
}
}
}
/* Evaluate them into derivations. */
if (attrPaths.empty()) {
attrPaths = {""};
}
for (auto e : exprs) {
Value vRoot;
state->eval(e, vRoot);
for (auto& i : attrPaths) {
Value& v(*findAlongAttrPath(*state, i, autoArgs, vRoot));
state->forceValue(v);
getDerivations(*state, v, "", autoArgs, drvs, false);
}
}
state->printStats();
auto buildPaths = [&](const PathSet& paths) {
/* Note: we do this even when !printMissing to efficiently
fetch binary cache data. */
unsigned long long downloadSize;
unsigned long long narSize;
PathSet willBuild;
PathSet willSubstitute;
PathSet unknown;
store->queryMissing(paths, willBuild, willSubstitute, unknown, downloadSize,
narSize);
if (settings.printMissing) {
printMissing(ref<Store>(store), willBuild, willSubstitute, unknown,
downloadSize, narSize);
}
if (!dryRun) {
store->buildPaths(paths, buildMode);
}
};
if (runEnv) {
if (drvs.size() != 1) {
throw UsageError("nix-shell requires a single derivation");
}
auto& drvInfo = drvs.front();
auto drv = store->derivationFromPath(drvInfo.queryDrvPath());
PathSet pathsToBuild;
/* Figure out what bash shell to use. If $NIX_BUILD_SHELL
is not set, then build bashInteractive from
<nixpkgs>. */
auto shell = getEnv("NIX_BUILD_SHELL", "");
if (shell.empty()) {
try {
auto expr = state->parseExprFromString(
"(import <nixpkgs> {}).bashInteractive", absPath("."));
Value v;
state->eval(expr, v);
auto drv = getDerivation(*state, v, false);
if (!drv) {
throw Error(
"the 'bashInteractive' attribute in <nixpkgs> did not evaluate "
"to a derivation");
}
pathsToBuild.insert(drv->queryDrvPath());
shell = drv->queryOutPath() + "/bin/bash";
} catch (Error& e) {
LOG(WARNING) << e.what() << "; will use bash from your environment";
shell = "bash";
}
}
// Build or fetch all dependencies of the derivation.
for (const auto& input : drv.inputDrvs) {
if (std::all_of(envExclude.cbegin(), envExclude.cend(),
[&](const std::string& exclude) {
return !std::regex_search(input.first,
std::regex(exclude));
})) {
pathsToBuild.insert(makeDrvPathWithOutputs(input.first, input.second));
}
}
for (const auto& src : drv.inputSrcs) {
pathsToBuild.insert(src);
}
buildPaths(pathsToBuild);
if (dryRun) {
return;
}
// Set the environment.
auto env = getEnv();
auto tmp = getEnv("TMPDIR", getEnv("XDG_RUNTIME_DIR", "/tmp"));
if (pure) {
decltype(env) newEnv;
for (auto& i : env) {
if (keepVars.count(i.first) != 0u) {
newEnv.emplace(i);
}
}
env = newEnv;
// NixOS hack: prevent /etc/bashrc from sourcing /etc/profile.
env["__ETC_PROFILE_SOURCED"] = "1";
}
env["NIX_BUILD_TOP"] = env["TMPDIR"] = env["TEMPDIR"] = env["TMP"] =
env["TEMP"] = tmp;
env["NIX_STORE"] = store->storeDir;
env["NIX_BUILD_CORES"] = std::to_string(settings.buildCores);
StringSet passAsFile = absl::StrSplit(get(drv.env, "passAsFile", ""),
absl::ByAnyChar(" \t\n\r"));
bool keepTmp = false;
int fileNr = 0;
for (auto& var : drv.env) {
if (passAsFile.count(var.first) != 0u) {
keepTmp = true;
std::string fn = ".attr-" + std::to_string(fileNr++);
Path p = (Path)tmpDir + "/" + fn;
writeFile(p, var.second);
env[var.first + "Path"] = p;
} else {
env[var.first] = var.second;
}
}
restoreAffinity();
/* Run a shell using the derivation's environment. For
convenience, source $stdenv/setup to setup additional
environment variables and shell functions. Also don't
lose the current $PATH directories. */
auto rcfile = (Path)tmpDir + "/rc";
writeFile(
rcfile,
fmt((keepTmp ? "" : "rm -rf '%1%'; "s) +
"[ -n \"$PS1\" ] && [ -e ~/.bashrc ] && source ~/.bashrc; "
"%2%"
"dontAddDisableDepTrack=1; "
"[ -e $stdenv/setup ] && source $stdenv/setup; "
"%3%"
"PATH=\"%4%:$PATH\"; "
"SHELL=%5%; "
"set +e; "
R"s([ -n "$PS1" ] && PS1='\n\[\033[1;32m\][nix-shell:\w]\$\[\033[0m\] '; )s"
"if [ \"$(type -t runHook)\" = function ]; then runHook "
"shellHook; fi; "
"unset NIX_ENFORCE_PURITY; "
"shopt -u nullglob; "
"unset TZ; %6%"
"%7%",
(Path)tmpDir, (pure ? "" : "p=$PATH; "),
(pure ? "" : "PATH=$PATH:$p; unset p; "), dirOf(shell), shell,
(getenv("TZ") != nullptr
? (std::string("export TZ='") + getenv("TZ") + "'; ")
: ""),
envCommand));
Strings envStrs;
for (auto& i : env) {
envStrs.push_back(i.first + "=" + i.second);
}
auto args = interactive ? Strings{"bash", "--rcfile", rcfile}
: Strings{"bash", rcfile};
auto envPtrs = stringsToCharPtrs(envStrs);
environ = envPtrs.data();
auto argPtrs = stringsToCharPtrs(args);
restoreSignals();
execvp(shell.c_str(), argPtrs.data());
throw SysError("executing shell '%s'", shell);
}
PathSet pathsToBuild;
std::map<Path, Path> drvPrefixes;
std::map<Path, Path> resultSymlinks;
std::vector<Path> outPaths;
for (auto& drvInfo : drvs) {
auto drvPath = drvInfo.queryDrvPath();
auto outPath = drvInfo.queryOutPath();
auto outputName = drvInfo.queryOutputName();
if (outputName.empty()) {
throw Error("derivation '%s' lacks an 'outputName' attribute", drvPath);
}
pathsToBuild.insert(drvPath + "!" + outputName);
std::string drvPrefix;
auto i = drvPrefixes.find(drvPath);
if (i != drvPrefixes.end()) {
drvPrefix = i->second;
} else {
drvPrefix = outLink;
if (!drvPrefixes.empty() != 0u) {
drvPrefix += fmt("-%d", drvPrefixes.size() + 1);
}
drvPrefixes[drvPath] = drvPrefix;
}
std::string symlink = drvPrefix;
if (outputName != "out") {
symlink += "-" + outputName;
}
resultSymlinks[symlink] = outPath;
outPaths.push_back(outPath);
}
buildPaths(pathsToBuild);
if (dryRun) {
return;
}
for (auto& symlink : resultSymlinks) {
if (auto store2 = store.dynamic_pointer_cast<LocalFSStore>()) {
store2->addPermRoot(symlink.second, absPath(symlink.first), true);
}
}
for (auto& path : outPaths) {
std::cout << path << '\n';
}
}
static RegisterLegacyCommand s1("nix-build", _main);
static RegisterLegacyCommand s2("nix-shell", _main);
