return make_ref<LocalBinaryCache>(getLocalStore(), "/tmp/binary-cache");

    return make_ref<LocalBinaryCache>(getLocalStore(),
        "/tmp/binary-cache",
        "/home/eelco/Misc/Keys/test.nixos.org/secret",
        "/home/eelco/Misc/Keys/test.nixos.org/public");

#include "nar-info.hh"

LocalBinaryCache::LocalBinaryCache(ref<Store> localStore, const Path & binaryCacheDir)
    : localStore(localStore), binaryCacheDir(binaryCacheDir)

LocalBinaryCache::LocalBinaryCache(ref<Store> localStore, const Path & binaryCacheDir,
    const Path & secretKeyFile, const Path & publicKeyFile)
    : localStore(localStore)
    , binaryCacheDir(binaryCacheDir)

    Path cacheInfoFile = binaryCacheDir + "/nix-cache-info";
    if (!pathExists(cacheInfoFile))
        writeFile(cacheInfoFile, "StoreDir: " + settings.nixStore + "\n");
    if (secretKeyFile != "")
        secretKey = std::unique_ptr<SecretKey>(new SecretKey(readFile(secretKeyFile)));
    if (publicKeyFile != "") {
        publicKeys = std::unique_ptr<PublicKeys>(new PublicKeys);
        auto key = PublicKey(readFile(publicKeyFile));
        publicKeys->emplace(key.name, key);
    }

    NarInfo narInfo(info);

    size_t narSize = nar.size();
    Hash narHash = hashString(htSHA256, nar);

    narInfo.narSize = nar.size();
    narInfo.narHash = hashString(htSHA256, nar);

    if (info.hash.type != htUnknown && info.hash != narHash)

    if (info.narHash.type != htUnknown && info.narHash != narInfo.narHash)

        % info.path % narSize);

        % info.path % info.narSize);

    narInfo.compression = "xz";

    Hash narXzHash = hashString(htSHA256, narXz);

    narInfo.fileHash = hashString(htSHA256, narXz);
    narInfo.fileSize = narXz.size();

    string narFileRel = "nar/" + printHash32(narXzHash) + ".nar.xz";
    Path narFile = binaryCacheDir + "/" + narFileRel;

    narInfo.url = "nar/" + printHash32(narInfo.fileHash) + ".nar.xz";
    Path narFile = binaryCacheDir + "/" + narInfo.url;

    Strings refs;
    for (auto & r : info.references)
        refs.push_back(baseNameOf(r));
    std::string narInfo;
    narInfo += "StorePath: " + info.path + "\n";
    narInfo += "URL: " + narFileRel + "\n";
    narInfo += "Compression: xz\n";
    narInfo += "FileHash: sha256:" + printHash32(narXzHash) + "\n";
    narInfo += "FileSize: " + std::to_string(narXz.size()) + "\n";
    narInfo += "NarHash: sha256:" + printHash32(narHash) + "\n";
    narInfo += "NarSize: " + std::to_string(narSize) + "\n";
    narInfo += "References: " + concatStringsSep(" ", refs) + "\n";

    if (secretKey) narInfo.sign(*secretKey);

    // FIXME: add signature
    atomicWrite(narInfoFile, narInfo);

    atomicWrite(narInfoFile, narInfo.to_string());

LocalBinaryCache::NarInfo LocalBinaryCache::readNarInfo(const Path & storePath)

NarInfo LocalBinaryCache::readNarInfo(const Path & storePath)

    NarInfo res;

    if (!pathExists(narInfoFile))
        abort();
    std::string narInfo = readFile(narInfoFile);
    auto corrupt = [&]() {
        throw Error(format("corrupt NAR info file ‘%1%’") % narInfoFile);
    };
    size_t pos = 0;
    while (pos < narInfo.size()) {
        size_t colon = narInfo.find(':', pos);
        if (colon == std::string::npos) corrupt();
        std::string name(narInfo, pos, colon - pos);
        size_t eol = narInfo.find('\n', colon + 2);
        if (eol == std::string::npos) corrupt();
        std::string value(narInfo, colon + 2, eol - colon - 2);
        if (name == "StorePath") {
            res.info.path = value;
            if (value != storePath) corrupt();
            res.info.path = value;
        }
        else if (name == "References") {
            auto refs = tokenizeString<Strings>(value, " ");
            if (!res.info.references.empty()) corrupt();
            for (auto & r : refs)
                res.info.references.insert(settings.nixStore + "/" + r);
        }
        else if (name == "URL") {
            res.narUrl = value;
        }
        else if (name == "Compression") {
            res.compression = value;
        }

    NarInfo narInfo = NarInfo(readFile(narInfoFile), narInfoFile);
    assert(narInfo.path == storePath);

        pos = eol + 1;

    if (publicKeys) {
        if (!narInfo.checkSignature(*publicKeys))
            throw Error(format("invalid signature on NAR info file ‘%1%’") % narInfoFile);

    if (res.info.path.empty() || res.narUrl.empty()) corrupt();

    return res;

    return narInfo;

    Path narInfoFile = narInfoFileFor(storePath);
    printMsg(lvlDebug, format("checking %1% -> %2%") % storePath % narInfoFile);
    return pathExists(narInfoFile);

    return pathExists(narInfoFileFor(storePath));

    auto nar = readFile(binaryCacheDir + "/" + res.narUrl);

    auto nar = readFile(binaryCacheDir + "/" + res.url);

    sink << exportMagic << storePath << res.info.references << res.info.deriver << 0;

    sink << exportMagic << storePath << res.references << res.deriver << 0;

    return readNarInfo(storePath).info;

    return ValidPathInfo(readNarInfo(storePath));

#include "crypto.hh"

struct NarInfo;

    std::unique_ptr<SecretKey> secretKey;
    std::unique_ptr<PublicKeys> publicKeys;

    LocalBinaryCache(ref<Store> localStore, const Path & binaryCacheDir);

    LocalBinaryCache(ref<Store> localStore, const Path & binaryCacheDir,
        const Path & secretKeyFile, const Path & publicKeyFile);

    struct NarInfo
    {
        ValidPathInfo info;
        std::string narUrl;
        std::string compression = "none";
    };