1
0
Fork 0
forked from lix-project/lix
lix/src/nix/hash.cc
eldritch horrors 11f4a5bc7e libutil: return a source from readFile
don't consume a sink, return a source instead. the only reason to not do
this is a very slight reduction in dynamic allocations, but since we are
going to *at least* do disk io that will not be a lot of overhead anyway

Change-Id: Iae2f879ec64c3c3ac1d5310eeb6a85e696d4614a
2024-06-19 10:50:12 +00:00

228 lines
6.2 KiB
C++

#include "command.hh"
#include "hash.hh"
#include "content-address.hh"
#include "legacy.hh"
#include "shared.hh"
#include "references.hh"
#include "archive.hh"
using namespace nix;
struct CmdHashBase : Command
{
FileIngestionMethod mode;
Base base = SRI;
bool truncate = false;
HashType ht = htSHA256;
std::vector<std::string> paths;
std::optional<std::string> modulus;
CmdHashBase(FileIngestionMethod mode) : mode(mode)
{
addFlag({
.longName = "sri",
.description = "Print the hash in SRI format.",
.handler = {&base, SRI},
});
addFlag({
.longName = "base64",
.description = "Print the hash in base-64 format.",
.handler = {&base, Base64},
});
addFlag({
.longName = "base32",
.description = "Print the hash in base-32 (Nix-specific) format.",
.handler = {&base, Base32},
});
addFlag({
.longName = "base16",
.description = "Print the hash in base-16 format.",
.handler = {&base, Base16},
});
addFlag(Flag::mkHashTypeFlag("type", &ht));
#if 0
addFlag({
.longName = "modulo",
.description = "Compute the hash modulo the specified string.",
.labels = {"modulus"},
.handler = {&modulus},
});
#endif\
expectArgs({
.label = "paths",
.handler = {&paths},
.completer = completePath
});
}
std::string description() override
{
switch (mode) {
case FileIngestionMethod::Flat:
return "print cryptographic hash of a regular file";
case FileIngestionMethod::Recursive:
return "print cryptographic hash of the NAR serialisation of a path";
default:
assert(false);
};
}
void run() override
{
for (auto path : paths) {
std::unique_ptr<AbstractHashSink> hashSink;
if (modulus)
hashSink = std::make_unique<HashModuloSink>(ht, *modulus);
else
hashSink = std::make_unique<HashSink>(ht);
switch (mode) {
case FileIngestionMethod::Flat:
readFileSource(path)->drainInto(*hashSink);
break;
case FileIngestionMethod::Recursive:
dumpPath(path, *hashSink);
break;
}
Hash h = hashSink->finish().first;
if (truncate && h.hashSize > 20) h = compressHash(h, 20);
logger->cout(h.to_string(base, base == SRI));
}
}
};
struct CmdToBase : Command
{
Base base;
std::optional<HashType> ht;
std::vector<std::string> args;
CmdToBase(Base base) : base(base)
{
addFlag(Flag::mkHashTypeOptFlag("type", &ht));
expectArgs("strings", &args);
}
std::string description() override
{
return fmt("convert a hash to %s representation",
base == Base16 ? "base-16" :
base == Base32 ? "base-32" :
base == Base64 ? "base-64" :
"SRI");
}
void run() override
{
for (auto s : args)
logger->cout(Hash::parseAny(s, ht).to_string(base, base == SRI));
}
};
struct CmdHash : NixMultiCommand
{
CmdHash()
: MultiCommand({
{"file", []() { return make_ref<CmdHashBase>(FileIngestionMethod::Flat);; }},
{"path", []() { return make_ref<CmdHashBase>(FileIngestionMethod::Recursive); }},
{"to-base16", []() { return make_ref<CmdToBase>(Base16); }},
{"to-base32", []() { return make_ref<CmdToBase>(Base32); }},
{"to-base64", []() { return make_ref<CmdToBase>(Base64); }},
{"to-sri", []() { return make_ref<CmdToBase>(SRI); }},
})
{ }
std::string description() override
{
return "compute and convert cryptographic hashes";
}
Category category() override { return catUtility; }
void run() override
{
if (!command)
throw UsageError("'nix hash' requires a sub-command.");
command->second->run();
}
};
static auto rCmdHash = registerCommand<CmdHash>("hash");
/* Legacy nix-hash command. */
static int compatNixHash(int argc, char * * argv)
{
std::optional<HashType> ht;
bool flat = false;
Base base = Base16;
bool truncate = false;
enum { opHash, opTo } op = opHash;
std::vector<std::string> ss;
parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
if (*arg == "--help")
showManPage("nix-hash");
else if (*arg == "--version")
printVersion("nix-hash");
else if (*arg == "--flat") flat = true;
else if (*arg == "--base16") base = Base16;
else if (*arg == "--base32") base = Base32;
else if (*arg == "--base64") base = Base64;
else if (*arg == "--sri") base = SRI;
else if (*arg == "--truncate") truncate = true;
else if (*arg == "--type") {
std::string s = getArg(*arg, arg, end);
ht = parseHashType(s);
}
else if (*arg == "--to-base16") {
op = opTo;
base = Base16;
}
else if (*arg == "--to-base32") {
op = opTo;
base = Base32;
}
else if (*arg == "--to-base64") {
op = opTo;
base = Base64;
}
else if (*arg == "--to-sri") {
op = opTo;
base = SRI;
}
else if (*arg != "" && arg->at(0) == '-')
return false;
else
ss.push_back(*arg);
return true;
});
if (op == opHash) {
CmdHashBase cmd(flat ? FileIngestionMethod::Flat : FileIngestionMethod::Recursive);
if (!ht.has_value()) ht = htMD5;
cmd.ht = ht.value();
cmd.base = base;
cmd.truncate = truncate;
cmd.paths = ss;
cmd.run();
}
else {
CmdToBase cmd(base);
cmd.args = ss;
if (ht.has_value()) cmd.ht = ht;
cmd.run();
}
return 0;
}
static RegisterLegacyCommand r_nix_hash("nix-hash", compatNixHash);