217 lines
5.8 KiB
C++
217 lines
5.8 KiB
C++
#include "nar-accessor.hh"
|
|
#include "archive.hh"
|
|
#include "json.hh"
|
|
|
|
#include <map>
|
|
#include <stack>
|
|
#include <algorithm>
|
|
|
|
namespace nix {
|
|
|
|
struct NarMember
|
|
{
|
|
FSAccessor::Type type;
|
|
|
|
bool isExecutable;
|
|
|
|
/* If this is a regular file, position of the contents of this
|
|
file in the NAR. */
|
|
size_t start, size;
|
|
|
|
std::string target;
|
|
|
|
/* If this is a directory, all the children of the directory. */
|
|
std::map<std::string, NarMember> children;
|
|
};
|
|
|
|
struct NarIndexer : ParseSink, StringSource
|
|
{
|
|
NarMember root;
|
|
std::stack<NarMember*> parents;
|
|
|
|
std::string currentStart;
|
|
bool isExec = false;
|
|
|
|
NarIndexer(const std::string & nar) : StringSource(nar)
|
|
{
|
|
}
|
|
|
|
void createMember(const Path & path, NarMember member) {
|
|
size_t level = std::count(path.begin(), path.end(), '/');
|
|
while(parents.size() > level) {
|
|
parents.pop();
|
|
}
|
|
|
|
if(parents.empty()) {
|
|
root = std::move(member);
|
|
parents.push(&root);
|
|
} else {
|
|
if(parents.top()->type != FSAccessor::Type::tDirectory) {
|
|
throw Error(format("NAR file missing parent directory of path '%1%'") % path);
|
|
}
|
|
auto result = parents.top()->children.emplace(baseNameOf(path), std::move(member));
|
|
parents.push(&result.first->second);
|
|
}
|
|
}
|
|
|
|
void createDirectory(const Path & path) override
|
|
{
|
|
createMember(path, {FSAccessor::Type::tDirectory, false, 0, 0 });
|
|
}
|
|
|
|
void createRegularFile(const Path & path) override
|
|
{
|
|
createMember(path, {FSAccessor::Type::tRegular, false, 0, 0 });
|
|
}
|
|
|
|
void isExecutable() override
|
|
{
|
|
parents.top()->isExecutable = true;
|
|
}
|
|
|
|
void preallocateContents(unsigned long long size) override
|
|
{
|
|
currentStart = string(s, pos, 16);
|
|
assert(size <= std::numeric_limits<size_t>::max());
|
|
parents.top()->size = (size_t)size;
|
|
parents.top()->start = pos;
|
|
}
|
|
|
|
void receiveContents(unsigned char * data, unsigned int len) override
|
|
{
|
|
// Sanity check
|
|
if (!currentStart.empty()) {
|
|
assert(len < 16 || currentStart == string((char *) data, 16));
|
|
currentStart.clear();
|
|
}
|
|
}
|
|
|
|
void createSymlink(const Path & path, const string & target) override
|
|
{
|
|
createMember(path,
|
|
NarMember{FSAccessor::Type::tSymlink, false, 0, 0, target});
|
|
}
|
|
|
|
NarMember* find(const Path & path)
|
|
{
|
|
Path canon = path == "" ? "" : canonPath(path);
|
|
NarMember* current = &root;
|
|
auto end = path.end();
|
|
for(auto it = path.begin(); it != end; ) {
|
|
// because it != end, the remaining component is non-empty so we need
|
|
// a directory
|
|
if(current->type != FSAccessor::Type::tDirectory) return nullptr;
|
|
|
|
// skip slash (canonPath above ensures that this is always a slash)
|
|
assert(*it == '/');
|
|
it += 1;
|
|
|
|
// lookup current component
|
|
auto next = std::find(it, end, '/');
|
|
auto child = current->children.find(std::string(it, next));
|
|
if(child == current->children.end()) return nullptr;
|
|
current = &child->second;
|
|
|
|
it = next;
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
NarMember& at(const Path & path) {
|
|
auto result = find(path);
|
|
if(result == nullptr) {
|
|
throw Error(format("NAR file does not contain path '%1%'") % path);
|
|
}
|
|
return *result;
|
|
}
|
|
};
|
|
|
|
struct NarAccessor : public FSAccessor
|
|
{
|
|
ref<const std::string> nar;
|
|
NarIndexer indexer;
|
|
|
|
NarAccessor(ref<const std::string> nar) : nar(nar), indexer(*nar)
|
|
{
|
|
parseDump(indexer, indexer);
|
|
}
|
|
|
|
Stat stat(const Path & path) override
|
|
{
|
|
auto i = indexer.find(path);
|
|
if (i == nullptr)
|
|
return {FSAccessor::Type::tMissing, 0, false};
|
|
return {i->type, i->size, i->isExecutable};
|
|
}
|
|
|
|
StringSet readDirectory(const Path & path) override
|
|
{
|
|
auto i = indexer.at(path);
|
|
|
|
if (i.type != FSAccessor::Type::tDirectory)
|
|
throw Error(format("path '%1%' inside NAR file is not a directory") % path);
|
|
|
|
StringSet res;
|
|
for(auto&& child : i.children) {
|
|
res.insert(child.first);
|
|
|
|
}
|
|
return res;
|
|
}
|
|
|
|
std::string readFile(const Path & path) override
|
|
{
|
|
auto i = indexer.at(path);
|
|
if (i.type != FSAccessor::Type::tRegular)
|
|
throw Error(format("path '%1%' inside NAR file is not a regular file") % path);
|
|
return std::string(*nar, i.start, i.size);
|
|
}
|
|
|
|
std::string readLink(const Path & path) override
|
|
{
|
|
auto i = indexer.at(path);
|
|
if (i.type != FSAccessor::Type::tSymlink)
|
|
throw Error(format("path '%1%' inside NAR file is not a symlink") % path);
|
|
return i.target;
|
|
}
|
|
};
|
|
|
|
ref<FSAccessor> makeNarAccessor(ref<const std::string> nar)
|
|
{
|
|
return make_ref<NarAccessor>(nar);
|
|
}
|
|
|
|
void listNar(JSONPlaceholder & res, ref<FSAccessor> accessor, const Path & path)
|
|
{
|
|
auto st = accessor->stat(path);
|
|
|
|
auto obj = res.object();
|
|
|
|
switch (st.type) {
|
|
case FSAccessor::Type::tRegular:
|
|
obj.attr("type", "regular");
|
|
obj.attr("size", st.fileSize);
|
|
if (st.isExecutable)
|
|
obj.attr("executable", true);
|
|
break;
|
|
case FSAccessor::Type::tDirectory:
|
|
obj.attr("type", "directory");
|
|
{
|
|
auto res2 = obj.object("entries");
|
|
for (auto & name : accessor->readDirectory(path)) {
|
|
auto res3 = res2.placeholder(name);
|
|
listNar(res3, accessor, path + "/" + name);
|
|
}
|
|
}
|
|
break;
|
|
case FSAccessor::Type::tSymlink:
|
|
obj.attr("type", "symlink");
|
|
obj.attr("target", accessor->readLink(path));
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
}
|