Merge "Remove static initializers for `RegisterLegacyCommand`" into main

1 files changed, 1183 insertions, 0 deletions

diff --git a/src/legacy/nix-store.cc b/src/legacy/nix-store.cc
new file mode 100644
index 000000000..e42aa4065
--- /dev/null
+++ b/src/legacy/nix-store.cc
@@ -0,0 +1,1183 @@
+#include "archive.hh"
+#include "derivations.hh"
+#include "dotgraph.hh"
+#include "exit.hh"
+#include "globals.hh"
+#include "build-result.hh"
+#include "store-cast.hh"
+#include "gc-store.hh"
+#include "log-store.hh"
+#include "local-store.hh"
+#include "monitor-fd.hh"
+#include "serve-protocol.hh"
+#include "serve-protocol-impl.hh"
+#include "shared.hh"
+#include "graphml.hh"
+#include "legacy.hh"
+#include "path-with-outputs.hh"
+#include "nix-store.hh"
+
+#include <iostream>
+#include <algorithm>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+namespace nix {
+
+
+using std::cin;
+using std::cout;
+
+
+typedef void (* Operation) (Strings opFlags, Strings opArgs);
+
+
+static Path gcRoot;
+static int rootNr = 0;
+static bool noOutput = false;
+static std::shared_ptr<Store> store;
+
+
+ref<LocalStore> ensureLocalStore()
+{
+    auto store2 = std::dynamic_pointer_cast<LocalStore>(store);
+    if (!store2) throw Error("you don't have sufficient rights to use this command");
+    return ref<LocalStore>(store2);
+}
+
+
+static StorePath useDeriver(const StorePath & path)
+{
+    if (path.isDerivation()) return path;
+    auto info = store->queryPathInfo(path);
+    if (!info->deriver)
+        throw Error("deriver of path '%s' is not known", store->printStorePath(path));
+    return *info->deriver;
+}
+
+
+/* Realise the given path.  For a derivation that means build it; for
+   other paths it means ensure their validity. */
+static PathSet realisePath(StorePathWithOutputs path, bool build = true)
+{
+    auto store2 = std::dynamic_pointer_cast<LocalFSStore>(store);
+
+    if (path.path.isDerivation()) {
+        if (build) store->buildPaths({path.toDerivedPath()});
+        auto outputPaths = store->queryDerivationOutputMap(path.path);
+        Derivation drv = store->derivationFromPath(path.path);
+        rootNr++;
+
+        /* FIXME: Encode this empty special case explicitly in the type. */
+        if (path.outputs.empty())
+            for (auto & i : drv.outputs) path.outputs.insert(i.first);
+
+        PathSet outputs;
+        for (auto & j : path.outputs) {
+            /* Match outputs of a store path with outputs of the derivation that produces it. */
+            DerivationOutputs::iterator i = drv.outputs.find(j);
+            if (i == drv.outputs.end())
+                throw Error("derivation '%s' does not have an output named '%s'",
+                    store2->printStorePath(path.path), j);
+            auto outPath = outputPaths.at(i->first);
+            auto retPath = store->printStorePath(outPath);
+            if (store2) {
+                if (gcRoot == "")
+                    printGCWarning();
+                else {
+                    Path rootName = gcRoot;
+                    if (rootNr > 1) rootName += "-" + std::to_string(rootNr);
+                    if (i->first != "out") rootName += "-" + i->first;
+                    retPath = store2->addPermRoot(outPath, rootName);
+                }
+            }
+            outputs.insert(retPath);
+        }
+        return outputs;
+    }
+
+    else {
+        if (build) store->ensurePath(path.path);
+        else if (!store->isValidPath(path.path))
+            throw Error("path '%s' does not exist and cannot be created", store->printStorePath(path.path));
+        if (store2) {
+            if (gcRoot == "")
+                printGCWarning();
+            else {
+                Path rootName = gcRoot;
+                rootNr++;
+                if (rootNr > 1) rootName += "-" + std::to_string(rootNr);
+                return {store2->addPermRoot(path.path, rootName)};
+            }
+        }
+        return {store->printStorePath(path.path)};
+    }
+}
+
+
+/* Realise the given paths. */
+static void opRealise(Strings opFlags, Strings opArgs)
+{
+    bool dryRun = false;
+    BuildMode buildMode = bmNormal;
+    bool ignoreUnknown = false;
+
+    for (auto & i : opFlags)
+        if (i == "--dry-run") dryRun = true;
+        else if (i == "--repair") buildMode = bmRepair;
+        else if (i == "--check") buildMode = bmCheck;
+        else if (i == "--ignore-unknown") ignoreUnknown = true;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    std::vector<StorePathWithOutputs> paths;
+    for (auto & i : opArgs)
+        paths.push_back(followLinksToStorePathWithOutputs(*store, i));
+
+    uint64_t downloadSize, narSize;
+    StorePathSet willBuild, willSubstitute, unknown;
+    store->queryMissing(
+        toDerivedPaths(paths),
+        willBuild, willSubstitute, unknown, downloadSize, narSize);
+
+    /* Filter out unknown paths from `paths`. */
+    if (ignoreUnknown) {
+        std::vector<StorePathWithOutputs> paths2;
+        for (auto & i : paths)
+            if (!unknown.count(i.path)) paths2.push_back(i);
+        paths = std::move(paths2);
+        unknown = StorePathSet();
+    }
+
+    if (settings.printMissing)
+        printMissing(ref<Store>(store), willBuild, willSubstitute, unknown, downloadSize, narSize);
+
+    if (dryRun) return;
+
+    /* Build all paths at the same time to exploit parallelism. */
+    store->buildPaths(toDerivedPaths(paths), buildMode);
+
+    if (!ignoreUnknown)
+        for (auto & i : paths) {
+            auto paths2 = realisePath(i, false);
+            if (!noOutput)
+                for (auto & j : paths2)
+                    cout << fmt("%1%\n", j);
+        }
+}
+
+
+/* Add files to the Nix store and print the resulting paths. */
+static void opAdd(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+
+    for (auto & i : opArgs)
+        cout << fmt("%s\n", store->printStorePath(store->addToStore(std::string(baseNameOf(i)), i)));
+}
+
+
+/* Preload the output of a fixed-output derivation into the Nix
+   store. */
+static void opAddFixed(Strings opFlags, Strings opArgs)
+{
+    auto method = FileIngestionMethod::Flat;
+
+    for (auto & i : opFlags)
+        if (i == "--recursive") method = FileIngestionMethod::Recursive;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    if (opArgs.empty())
+        throw UsageError("first argument must be hash algorithm");
+
+    HashType hashAlgo = parseHashType(opArgs.front());
+    opArgs.pop_front();
+
+    for (auto & i : opArgs)
+        std::cout << fmt("%s\n", store->printStorePath(store->addToStoreSlow(baseNameOf(i), i, method, hashAlgo).path));
+}
+
+
+/* Hack to support caching in `nix-prefetch-url'. */
+static void opPrintFixedPath(Strings opFlags, Strings opArgs)
+{
+    auto method = FileIngestionMethod::Flat;
+
+    for (auto i : opFlags)
+        if (i == "--recursive") method = FileIngestionMethod::Recursive;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    if (opArgs.size() != 3)
+        throw UsageError("'--print-fixed-path' requires three arguments");
+
+    Strings::iterator i = opArgs.begin();
+    HashType hashAlgo = parseHashType(*i++);
+    std::string hash = *i++;
+    std::string name = *i++;
+
+    cout << fmt("%s\n", store->printStorePath(store->makeFixedOutputPath(name, FixedOutputInfo {
+        .method = method,
+        .hash = Hash::parseAny(hash, hashAlgo),
+        .references = {},
+    })));
+}
+
+
+static StorePathSet maybeUseOutputs(const StorePath & storePath, bool useOutput, bool forceRealise)
+{
+    if (forceRealise) realisePath({storePath});
+    if (useOutput && storePath.isDerivation()) {
+        auto drv = store->derivationFromPath(storePath);
+        StorePathSet outputs;
+        if (forceRealise)
+            return store->queryDerivationOutputs(storePath);
+        for (auto & i : drv.outputsAndOptPaths(*store)) {
+            if (!i.second.second)
+                throw UsageError("Cannot use output path of floating content-addressed derivation until we know what it is (e.g. by building it)");
+            outputs.insert(*i.second.second);
+        }
+        return outputs;
+    }
+    else return {storePath};
+}
+
+
+/* Some code to print a tree representation of a derivation dependency
+   graph.  Topological sorting is used to keep the tree relatively
+   flat. */
+static void printTree(const StorePath & path,
+    const std::string & firstPad, const std::string & tailPad, StorePathSet & done)
+{
+    if (!done.insert(path).second) {
+        cout << fmt("%s%s [...]\n", firstPad, store->printStorePath(path));
+        return;
+    }
+
+    cout << fmt("%s%s\n", firstPad, store->printStorePath(path));
+
+    auto info = store->queryPathInfo(path);
+
+    /* Topologically sort under the relation A < B iff A \in
+       closure(B).  That is, if derivation A is an (possibly indirect)
+       input of B, then A is printed first.  This has the effect of
+       flattening the tree, preventing deeply nested structures.  */
+    auto sorted = store->topoSortPaths(info->references);
+    reverse(sorted.begin(), sorted.end());
+
+    for (const auto &[n, i] : enumerate(sorted)) {
+        bool last = n + 1 == sorted.size();
+        printTree(i,
+            tailPad + (last ? treeLast : treeConn),
+            tailPad + (last ? treeNull : treeLine),
+            done);
+    }
+}
+
+
+/* Perform various sorts of queries. */
+static void opQuery(Strings opFlags, Strings opArgs)
+{
+    enum QueryType
+        { qOutputs, qRequisites, qReferences, qReferrers
+        , qReferrersClosure, qDeriver, qValidDerivers, qBinding, qHash, qSize
+        , qTree, qGraph, qGraphML, qResolve, qRoots };
+    std::optional<QueryType> query;
+    bool useOutput = false;
+    bool includeOutputs = false;
+    bool forceRealise = false;
+    std::string bindingName;
+
+    for (auto & i : opFlags) {
+        std::optional<QueryType> prev = query;
+        if (i == "--outputs") query = qOutputs;
+        else if (i == "--requisites" || i == "-R") query = qRequisites;
+        else if (i == "--references") query = qReferences;
+        else if (i == "--referrers" || i == "--referers") query = qReferrers;
+        else if (i == "--referrers-closure" || i == "--referers-closure") query = qReferrersClosure;
+        else if (i == "--deriver" || i == "-d") query = qDeriver;
+        else if (i == "--valid-derivers") query = qValidDerivers;
+        else if (i == "--binding" || i == "-b") {
+            if (opArgs.size() == 0)
+                throw UsageError("expected binding name");
+            bindingName = opArgs.front();
+            opArgs.pop_front();
+            query = qBinding;
+        }
+        else if (i == "--hash") query = qHash;
+        else if (i == "--size") query = qSize;
+        else if (i == "--tree") query = qTree;
+        else if (i == "--graph") query = qGraph;
+        else if (i == "--graphml") query = qGraphML;
+        else if (i == "--resolve") query = qResolve;
+        else if (i == "--roots") query = qRoots;
+        else if (i == "--use-output" || i == "-u") useOutput = true;
+        else if (i == "--force-realise" || i == "--force-realize" || i == "-f") forceRealise = true;
+        else if (i == "--include-outputs") includeOutputs = true;
+        else throw UsageError("unknown flag '%1%'", i);
+        if (prev && prev != query)
+            throw UsageError("query type '%1%' conflicts with earlier flag", i);
+    }
+
+    if (!query) query = qOutputs;
+
+    RunPager pager;
+
+    switch (*query) {
+
+        case qOutputs: {
+            for (auto & i : opArgs) {
+                auto outputs = maybeUseOutputs(store->followLinksToStorePath(i), true, forceRealise);
+                for (auto & outputPath : outputs)
+                    cout << fmt("%1%\n", store->printStorePath(outputPath));
+            }
+            break;
+        }
+
+        case qRequisites:
+        case qReferences:
+        case qReferrers:
+        case qReferrersClosure: {
+            StorePathSet paths;
+            for (auto & i : opArgs) {
+                auto ps = maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise);
+                for (auto & j : ps) {
+                    if (query == qRequisites) store->computeFSClosure(j, paths, false, includeOutputs);
+                    else if (query == qReferences) {
+                        for (auto & p : store->queryPathInfo(j)->references)
+                            paths.insert(p);
+                    }
+                    else if (query == qReferrers) {
+                        StorePathSet tmp;
+                        store->queryReferrers(j, tmp);
+                        for (auto & i : tmp)
+                            paths.insert(i);
+                    }
+                    else if (query == qReferrersClosure) store->computeFSClosure(j, paths, true);
+                }
+            }
+            auto sorted = store->topoSortPaths(paths);
+            for (StorePaths::reverse_iterator i = sorted.rbegin();
+                 i != sorted.rend(); ++i)
+                cout << fmt("%s\n", store->printStorePath(*i));
+            break;
+        }
+
+        case qDeriver:
+            for (auto & i : opArgs) {
+                auto info = store->queryPathInfo(store->followLinksToStorePath(i));
+                cout << fmt("%s\n", info->deriver ? store->printStorePath(*info->deriver) : "unknown-deriver");
+            }
+            break;
+
+        case qValidDerivers: {
+            StorePathSet result;
+            for (auto & i : opArgs) {
+                auto derivers = store->queryValidDerivers(store->followLinksToStorePath(i));
+                for (const auto &i: derivers) {
+                    result.insert(i);
+                }
+            }
+            auto sorted = store->topoSortPaths(result);
+            for (StorePaths::reverse_iterator i = sorted.rbegin();
+                 i != sorted.rend(); ++i)
+                cout << fmt("%s\n", store->printStorePath(*i));
+            break;
+        }
+
+        case qBinding:
+            for (auto & i : opArgs) {
+                auto path = useDeriver(store->followLinksToStorePath(i));
+                Derivation drv = store->derivationFromPath(path);
+                StringPairs::iterator j = drv.env.find(bindingName);
+                if (j == drv.env.end())
+                    throw Error("derivation '%s' has no environment binding named '%s'",
+                        store->printStorePath(path), bindingName);
+                cout << fmt("%s\n", j->second);
+            }
+            break;
+
+        case qHash:
+        case qSize:
+            for (auto & i : opArgs) {
+                for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise)) {
+                    auto info = store->queryPathInfo(j);
+                    if (query == qHash) {
+                        assert(info->narHash.type == HashType::SHA256);
+                        cout << fmt("%s\n", info->narHash.to_string(Base::Base32, true));
+                    } else if (query == qSize)
+                        cout << fmt("%d\n", info->narSize);
+                }
+            }
+            break;
+
+        case qTree: {
+            StorePathSet done;
+            for (auto & i : opArgs)
+                printTree(store->followLinksToStorePath(i), "", "", done);
+            break;
+        }
+
+        case qGraph: {
+            StorePathSet roots;
+            for (auto & i : opArgs)
+                for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+                    roots.insert(j);
+            printDotGraph(ref<Store>(store), std::move(roots));
+            break;
+        }
+
+        case qGraphML: {
+            StorePathSet roots;
+            for (auto & i : opArgs)
+                for (auto & j : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+                    roots.insert(j);
+            printGraphML(ref<Store>(store), std::move(roots));
+            break;
+        }
+
+        case qResolve: {
+            for (auto & i : opArgs)
+                cout << fmt("%s\n", store->printStorePath(store->followLinksToStorePath(i)));
+            break;
+        }
+
+        case qRoots: {
+            StorePathSet args;
+            for (auto & i : opArgs)
+                for (auto & p : maybeUseOutputs(store->followLinksToStorePath(i), useOutput, forceRealise))
+                    args.insert(p);
+
+            StorePathSet referrers;
+            store->computeFSClosure(
+                args, referrers, true, settings.gcKeepOutputs, settings.gcKeepDerivations);
+
+            auto & gcStore = require<GcStore>(*store);
+            Roots roots = gcStore.findRoots(false);
+            for (auto & [target, links] : roots)
+                if (referrers.find(target) != referrers.end())
+                    for (auto & link : links)
+                        cout << fmt("%1% -> %2%\n", link, gcStore.printStorePath(target));
+            break;
+        }
+
+        default:
+            abort();
+    }
+}
+
+
+static void opPrintEnv(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (opArgs.size() != 1) throw UsageError("'--print-env' requires one derivation store path");
+
+    Path drvPath = opArgs.front();
+    Derivation drv = store->derivationFromPath(store->parseStorePath(drvPath));
+
+    /* Print each environment variable in the derivation in a format
+     * that can be sourced by the shell. */
+    for (auto & i : drv.env)
+        logger->cout("export %1%; %1%=%2%\n", i.first, shellEscape(i.second));
+
+    /* Also output the arguments.  This doesn't preserve whitespace in
+       arguments. */
+    cout << "export _args; _args='";
+    bool first = true;
+    for (auto & i : drv.args) {
+        if (!first) cout << ' ';
+        first = false;
+        cout << shellEscape(i);
+    }
+    cout << "'\n";
+}
+
+
+static void opReadLog(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+
+    auto & logStore = require<LogStore>(*store);
+
+    RunPager pager;
+
+    for (auto & i : opArgs) {
+        auto path = logStore.followLinksToStorePath(i);
+        auto log = logStore.getBuildLog(path);
+        if (!log)
+            throw Error("build log of derivation '%s' is not available", logStore.printStorePath(path));
+        std::cout << *log;
+    }
+}
+
+
+static void opDumpDB(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (!opArgs.empty()) {
+        for (auto & i : opArgs)
+            cout << store->makeValidityRegistration({store->followLinksToStorePath(i)}, true, true);
+    } else {
+        for (auto & i : store->queryAllValidPaths())
+            cout << store->makeValidityRegistration({i}, true, true);
+    }
+}
+
+
+static void registerValidity(bool reregister, bool hashGiven, bool canonicalise)
+{
+    ValidPathInfos infos;
+
+    while (1) {
+        // We use a dummy value because we'll set it below. FIXME be correct by
+        // construction and avoid dummy value.
+        auto hashResultOpt = !hashGiven ? std::optional<HashResult> { {Hash::dummy, -1} } : std::nullopt;
+        auto info = decodeValidPathInfo(*store, cin, hashResultOpt);
+        if (!info) break;
+        if (!store->isValidPath(info->path) || reregister) {
+            /* !!! races */
+            if (canonicalise)
+                canonicalisePathMetaData(store->printStorePath(info->path), {});
+            if (!hashGiven) {
+                HashResult hash = hashPath(HashType::SHA256, store->printStorePath(info->path));
+                info->narHash = hash.first;
+                info->narSize = hash.second;
+            }
+            infos.insert_or_assign(info->path, *info);
+        }
+    }
+
+    ensureLocalStore()->registerValidPaths(infos);
+}
+
+
+static void opLoadDB(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (!opArgs.empty())
+        throw UsageError("no arguments expected");
+    registerValidity(true, true, false);
+}
+
+
+static void opRegisterValidity(Strings opFlags, Strings opArgs)
+{
+    bool reregister = false; // !!! maybe this should be the default
+    bool hashGiven = false;
+
+    for (auto & i : opFlags)
+        if (i == "--reregister") reregister = true;
+        else if (i == "--hash-given") hashGiven = true;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+    registerValidity(reregister, hashGiven, true);
+}
+
+
+static void opCheckValidity(Strings opFlags, Strings opArgs)
+{
+    bool printInvalid = false;
+
+    for (auto & i : opFlags)
+        if (i == "--print-invalid") printInvalid = true;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    for (auto & i : opArgs) {
+        auto path = store->followLinksToStorePath(i);
+        if (!store->isValidPath(path)) {
+            if (printInvalid)
+                cout << fmt("%s\n", store->printStorePath(path));
+            else
+                throw Error("path '%s' is not valid", store->printStorePath(path));
+        }
+    }
+}
+
+
+static void opGC(Strings opFlags, Strings opArgs)
+{
+    bool printRoots = false;
+    GCOptions options;
+    options.action = GCOptions::gcDeleteDead;
+
+    GCResults results;
+
+    /* Do what? */
+    for (auto i = opFlags.begin(); i != opFlags.end(); ++i)
+        if (*i == "--print-roots") printRoots = true;
+        else if (*i == "--print-live") options.action = GCOptions::gcReturnLive;
+        else if (*i == "--print-dead") options.action = GCOptions::gcReturnDead;
+        else if (*i == "--max-freed")
+            options.maxFreed = std::max(getIntArg<int64_t>(*i, i, opFlags.end(), true), (int64_t) 0);
+        else throw UsageError("bad sub-operation '%1%' in GC", *i);
+
+    if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+    auto & gcStore = require<GcStore>(*store);
+
+    if (printRoots) {
+        Roots roots = gcStore.findRoots(false);
+        std::set<std::pair<Path, StorePath>> roots2;
+        // Transpose and sort the roots.
+        for (auto & [target, links] : roots)
+            for (auto & link : links)
+                roots2.emplace(link, target);
+        for (auto & [link, target] : roots2)
+            std::cout << link << " -> " << gcStore.printStorePath(target) << "\n";
+    }
+
+    else {
+        PrintFreed freed(options.action == GCOptions::gcDeleteDead, results);
+        gcStore.collectGarbage(options, results);
+
+        if (options.action != GCOptions::gcDeleteDead)
+            for (auto & i : results.paths)
+                cout << i << std::endl;
+    }
+}
+
+
+/* Remove paths from the Nix store if possible (i.e., if they do not
+   have any remaining referrers and are not reachable from any GC
+   roots). */
+static void opDelete(Strings opFlags, Strings opArgs)
+{
+    GCOptions options;
+    options.action = GCOptions::gcDeleteSpecific;
+
+    for (auto & i : opFlags)
+        if (i == "--ignore-liveness") options.ignoreLiveness = true;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    for (auto & i : opArgs)
+        options.pathsToDelete.insert(store->followLinksToStorePath(i));
+
+    auto & gcStore = require<GcStore>(*store);
+
+    GCResults results;
+    PrintFreed freed(true, results);
+    gcStore.collectGarbage(options, results);
+}
+
+
+/* Dump a path as a Nix archive.  The archive is written to stdout */
+static void opDump(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (opArgs.size() != 1) throw UsageError("only one argument allowed");
+
+    FdSink sink(STDOUT_FILENO);
+    std::string path = *opArgs.begin();
+    sink << dumpPath(path);
+    sink.flush();
+}
+
+
+/* Restore a value from a Nix archive.  The archive is read from stdin. */
+static void opRestore(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (opArgs.size() != 1) throw UsageError("only one argument allowed");
+
+    FdSource source(STDIN_FILENO);
+    restorePath(*opArgs.begin(), source);
+}
+
+
+static void opExport(Strings opFlags, Strings opArgs)
+{
+    for (auto & i : opFlags)
+        throw UsageError("unknown flag '%1%'", i);
+
+    StorePathSet paths;
+
+    for (auto & i : opArgs)
+        paths.insert(store->followLinksToStorePath(i));
+
+    FdSink sink(STDOUT_FILENO);
+    store->exportPaths(paths, sink);
+    sink.flush();
+}
+
+
+static void opImport(Strings opFlags, Strings opArgs)
+{
+    for (auto & i : opFlags)
+        throw UsageError("unknown flag '%1%'", i);
+
+    if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+    FdSource source(STDIN_FILENO);
+    auto paths = store->importPaths(source, NoCheckSigs);
+
+    for (auto & i : paths)
+        cout << fmt("%s\n", store->printStorePath(i)) << std::flush;
+}
+
+
+/* Initialise the Nix databases. */
+static void opInit(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty()) throw UsageError("unknown flag");
+    if (!opArgs.empty())
+        throw UsageError("no arguments expected");
+    /* Doesn't do anything right now; database tables are initialised
+       automatically. */
+}
+
+
+/* Verify the consistency of the Nix environment. */
+static void opVerify(Strings opFlags, Strings opArgs)
+{
+    if (!opArgs.empty())
+        throw UsageError("no arguments expected");
+
+    bool checkContents = false;
+    RepairFlag repair = NoRepair;
+
+    for (auto & i : opFlags)
+        if (i == "--check-contents") checkContents = true;
+        else if (i == "--repair") repair = Repair;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    if (store->verifyStore(checkContents, repair)) {
+        warn("not all store errors were fixed");
+        throw Exit(1);
+    }
+}
+
+
+/* Verify whether the contents of the given store path have not changed. */
+static void opVerifyPath(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty())
+        throw UsageError("no flags expected");
+
+    int status = 0;
+
+    for (auto & i : opArgs) {
+        auto path = store->followLinksToStorePath(i);
+        printMsg(lvlTalkative, "checking path '%s'...", store->printStorePath(path));
+        auto info = store->queryPathInfo(path);
+        HashSink sink(info->narHash.type);
+        sink << store->narFromPath(path);
+        auto current = sink.finish();
+        if (current.first != info->narHash) {
+            printError("path '%s' was modified! expected hash '%s', got '%s'",
+                store->printStorePath(path),
+                info->narHash.to_string(Base::Base32, true),
+                current.first.to_string(Base::Base32, true));
+            status = 1;
+        }
+    }
+
+    throw Exit(status);
+}
+
+
+/* Repair the contents of the given path by redownloading it using a
+   substituter (if available). */
+static void opRepairPath(Strings opFlags, Strings opArgs)
+{
+    if (!opFlags.empty())
+        throw UsageError("no flags expected");
+
+    for (auto & i : opArgs)
+        store->repairPath(store->followLinksToStorePath(i));
+}
+
+/* Optimise the disk space usage of the Nix store by hard-linking
+   files with the same contents. */
+static void opOptimise(Strings opFlags, Strings opArgs)
+{
+    if (!opArgs.empty() || !opFlags.empty())
+        throw UsageError("no arguments expected");
+
+    store->optimiseStore();
+}
+
+/* Serve the nix store in a way usable by a restricted ssh user. */
+static void opServe(Strings opFlags, Strings opArgs)
+{
+    bool writeAllowed = false;
+    for (auto & i : opFlags)
+        if (i == "--write") writeAllowed = true;
+        else throw UsageError("unknown flag '%1%'", i);
+
+    if (!opArgs.empty()) throw UsageError("no arguments expected");
+
+    FdSource in(STDIN_FILENO);
+    FdSink out(STDOUT_FILENO);
+
+    /* Exchange the greeting. */
+    unsigned int magic = readInt(in);
+    if (magic != SERVE_MAGIC_1) throw Error("protocol mismatch");
+    out << SERVE_MAGIC_2 << SERVE_PROTOCOL_VERSION;
+    out.flush();
+    ServeProto::Version clientVersion = readInt(in);
+
+    ServeProto::ReadConn rconn {
+        .from = in,
+        .version = clientVersion,
+    };
+    ServeProto::WriteConn wconn {
+        .version = clientVersion,
+    };
+
+    auto getBuildSettings = [&]() {
+        // FIXME: changing options here doesn't work if we're
+        // building through the daemon.
+        verbosity = lvlError;
+        settings.keepLog = false;
+        settings.useSubstitutes = false;
+        settings.maxSilentTime = readInt(in);
+        settings.buildTimeout = readInt(in);
+        if (GET_PROTOCOL_MINOR(clientVersion) >= 2)
+            settings.maxLogSize = readNum<unsigned long>(in);
+        if (GET_PROTOCOL_MINOR(clientVersion) >= 3) {
+            auto nrRepeats = readInt(in);
+            if (nrRepeats != 0) {
+                throw Error("client requested repeating builds, but this is not currently implemented");
+            }
+            // Ignore 'enforceDeterminism'. It used to be true by
+            // default, but also only never had any effect when
+            // `nrRepeats == 0`.  We have already asserted that
+            // `nrRepeats` in fact is 0, so we can safely ignore this
+            // without doing something other than what the client
+            // asked for.
+            readInt(in);
+
+            settings.runDiffHook = true;
+        }
+        if (GET_PROTOCOL_MINOR(clientVersion) >= 7) {
+            settings.keepFailed = (bool) readInt(in);
+        }
+    };
+
+    while (true) {
+        ServeProto::Command cmd;
+        try {
+            cmd = (ServeProto::Command) readInt(in);
+        } catch (EndOfFile & e) {
+            break;
+        }
+
+        switch (cmd) {
+
+            case ServeProto::Command::QueryValidPaths: {
+                bool lock = readInt(in);
+                bool substitute = readInt(in);
+                auto paths = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+                if (lock && writeAllowed)
+                    for (auto & path : paths)
+                        store->addTempRoot(path);
+
+                if (substitute && writeAllowed) {
+                    store->substitutePaths(paths);
+                }
+
+                auto valid = store->queryValidPaths(paths);
+                out << ServeProto::write(*store, wconn, valid);
+                break;
+            }
+
+            case ServeProto::Command::QueryPathInfos: {
+                auto paths = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+                // !!! Maybe we want a queryPathInfos?
+                for (auto & i : paths) {
+                    try {
+                        auto info = store->queryPathInfo(i);
+                        out << store->printStorePath(info->path);
+                        out << ServeProto::write(*store, wconn, static_cast<const UnkeyedValidPathInfo &>(*info));
+                    } catch (InvalidPath &) {
+                    }
+                }
+                out << "";
+                break;
+            }
+
+            case ServeProto::Command::DumpStorePath:
+                out << store->narFromPath(store->parseStorePath(readString(in)));
+                break;
+
+            case ServeProto::Command::ImportPaths: {
+                if (!writeAllowed) throw Error("importing paths is not allowed");
+                store->importPaths(in, NoCheckSigs); // FIXME: should we skip sig checking?
+                out << 1; // indicate success
+                break;
+            }
+
+            case ServeProto::Command::ExportPaths: {
+                readInt(in); // obsolete
+                store->exportPaths(ServeProto::Serialise<StorePathSet>::read(*store, rconn), out);
+                break;
+            }
+
+            case ServeProto::Command::BuildPaths: {
+
+                if (!writeAllowed) throw Error("building paths is not allowed");
+
+                std::vector<StorePathWithOutputs> paths;
+                for (auto & s : readStrings<Strings>(in))
+                    paths.push_back(parsePathWithOutputs(*store, s));
+
+                getBuildSettings();
+
+                try {
+                    MonitorFdHup monitor(in.fd);
+                    store->buildPaths(toDerivedPaths(paths));
+                    out << 0;
+                } catch (Error & e) {
+                    assert(e.info().status);
+                    out << e.info().status << e.msg();
+                }
+                break;
+            }
+
+            case ServeProto::Command::BuildDerivation: { /* Used by hydra-queue-runner. */
+
+                if (!writeAllowed) throw Error("building paths is not allowed");
+
+                auto drvPath = store->parseStorePath(readString(in));
+                BasicDerivation drv;
+                readDerivation(in, *store, drv, Derivation::nameFromPath(drvPath));
+
+                getBuildSettings();
+
+                MonitorFdHup monitor(in.fd);
+                auto status = store->buildDerivation(drvPath, drv);
+
+                out << ServeProto::write(*store, wconn, status);
+                break;
+            }
+
+            case ServeProto::Command::QueryClosure: {
+                bool includeOutputs = readInt(in);
+                StorePathSet closure;
+                store->computeFSClosure(ServeProto::Serialise<StorePathSet>::read(*store, rconn),
+                    closure, false, includeOutputs);
+                out << ServeProto::write(*store, wconn, closure);
+                break;
+            }
+
+            case ServeProto::Command::AddToStoreNar: {
+                if (!writeAllowed) throw Error("importing paths is not allowed");
+
+                auto path = readString(in);
+                auto deriver = readString(in);
+                ValidPathInfo info {
+                    store->parseStorePath(path),
+                    Hash::parseAny(readString(in), HashType::SHA256),
+                };
+                if (deriver != "")
+                    info.deriver = store->parseStorePath(deriver);
+                info.references = ServeProto::Serialise<StorePathSet>::read(*store, rconn);
+                in >> info.registrationTime >> info.narSize >> info.ultimate;
+                info.sigs = readStrings<StringSet>(in);
+                info.ca = ContentAddress::parseOpt(readString(in));
+
+                if (info.narSize == 0)
+                    throw Error("narInfo is too old and missing the narSize field");
+
+                SizedSource sizedSource(in, info.narSize);
+
+                store->addToStore(info, sizedSource, NoRepair, NoCheckSigs);
+
+                // consume all the data that has been sent before continuing.
+                sizedSource.drainAll();
+
+                out << 1; // indicate success
+
+                break;
+            }
+
+            default:
+                throw Error("unknown serve command %1%", cmd);
+        }
+
+        out.flush();
+    }
+}
+
+
+static void opGenerateBinaryCacheKey(Strings opFlags, Strings opArgs)
+{
+    for (auto & i : opFlags)
+        throw UsageError("unknown flag '%1%'", i);
+
+    if (opArgs.size() != 3) throw UsageError("three arguments expected");
+    auto i = opArgs.begin();
+    std::string keyName = *i++;
+    std::string secretKeyFile = *i++;
+    std::string publicKeyFile = *i++;
+
+    auto secretKey = SecretKey::generate(keyName);
+
+    writeFile(publicKeyFile, secretKey.toPublicKey().to_string());
+    umask(0077);
+    writeFile(secretKeyFile, secretKey.to_string());
+}
+
+
+static void opVersion(Strings opFlags, Strings opArgs)
+{
+    printVersion("nix-store");
+}
+
+
+/* Scan the arguments; find the operation, set global flags, put all
+   other flags in a list, and put all other arguments in another
+   list. */
+static int main_nix_store(int argc, char * * argv)
+{
+    {
+        Strings opFlags, opArgs;
+        Operation op = 0;
+        bool readFromStdIn = false;
+        std::string opName;
+        bool showHelp = false;
+
+        parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
+            Operation oldOp = op;
+
+            if (*arg == "--help")
+                showHelp = true;
+            else if (*arg == "--version")
+                op = opVersion;
+            else if (*arg == "--realise" || *arg == "--realize" || *arg == "-r") {
+                op = opRealise;
+                opName = "-realise";
+            }
+            else if (*arg == "--add" || *arg == "-A"){
+                op = opAdd;
+                opName = "-add";
+            }
+            else if (*arg == "--add-fixed") {
+                op = opAddFixed;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--print-fixed-path")
+                op = opPrintFixedPath;
+            else if (*arg == "--delete") {
+                op = opDelete;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--query" || *arg == "-q") {
+                op = opQuery;
+                opName = "-query";
+            }
+            else if (*arg == "--print-env") {
+                op = opPrintEnv;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--read-log" || *arg == "-l") {
+                op = opReadLog;
+                opName = "-read-log";
+            }
+            else if (*arg == "--dump-db") {
+                op = opDumpDB;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--load-db") {
+                op = opLoadDB;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--register-validity")
+                op = opRegisterValidity;
+            else if (*arg == "--check-validity")
+                op = opCheckValidity;
+            else if (*arg == "--gc") {
+                op = opGC;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--dump") {
+                op = opDump;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--restore") {
+                op = opRestore;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--export") {
+                op = opExport;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--import") {
+                op = opImport;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--init")
+                op = opInit;
+            else if (*arg == "--verify") {
+                op = opVerify;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--verify-path") {
+                op = opVerifyPath;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--repair-path") {
+                op = opRepairPath;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--optimise" || *arg == "--optimize") {
+                op = opOptimise;
+                opName = "-optimise";
+            }
+            else if (*arg == "--serve") {
+                op = opServe;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--generate-binary-cache-key") {
+                op = opGenerateBinaryCacheKey;
+                opName = arg->substr(1);
+            }
+            else if (*arg == "--add-root")
+                gcRoot = absPath(getArg(*arg, arg, end));
+            else if (*arg == "--stdin" && !isatty(STDIN_FILENO))
+                readFromStdIn = true;
+            else if (*arg == "--indirect")
+                ;
+            else if (*arg == "--no-output")
+                noOutput = true;
+            else if (*arg != "" && arg->at(0) == '-') {
+                opFlags.push_back(*arg);
+                if (*arg == "--max-freed" || *arg == "--max-links" || *arg == "--max-atime") /* !!! hack */
+                    opFlags.push_back(getArg(*arg, arg, end));
+            }
+            else
+                opArgs.push_back(*arg);
+
+            if (readFromStdIn && op != opImport && op != opRestore && op != opServe) {
+                 std::string word;
+                 while (std::cin >> word) {
+                       opArgs.emplace_back(std::move(word));
+                 };
+            }
+
+            if (oldOp && oldOp != op)
+                throw UsageError("only one operation may be specified");
+
+            return true;
+        });
+
+        if (showHelp) showManPage("nix-store" + opName);
+        if (!op) throw UsageError("no operation specified");
+
+        if (op != opDump && op != opRestore) /* !!! hack */
+            store = openStore();
+
+        op(std::move(opFlags), std::move(opArgs));
+
+        return 0;
+    }
+}
+
+void registerNixStore() {
+    LegacyCommands::add("nix-store", main_nix_store);
+}
+
+}