forked from lix-project/lix
jade
917c9bdee7
This also bans various sneaking of negative numbers from the language
into unsuspecting builtins as was exposed while auditing the
consequences of changing the Nix language integer type to a newtype.
It's unlikely that this change comprehensively ensures correctness when
passing integers out of the Nix language and we should probably add a
checked-narrowing function or something similar, but that's out of scope
for the immediate change.
During the development of this I found a few fun facts about the
language:
- You could overflow integers by converting from unsigned JSON values.
- You could overflow unsigned integers by converting negative numbers
into them when going into Nix config, into fetchTree, and into flake
inputs.
The flake inputs and Nix config cannot actually be tested properly
since they both ban thunks, however, we put in checks anyway because
it's possible these could somehow be used to do such shenanigans some
other way.
Note that Lix has banned Nix language integer overflows since the very
first public beta, but threw a SIGILL about them because we run with
-fsanitize=signed-overflow -fsanitize-undefined-trap-on-error in
production builds. Since the Nix language uses signed integers, overflow
was simply undefined behaviour, and since we defined that to trap, it
did.
Trapping on it was a bad UX, but we didn't even entirely notice
that we had done this at all until it was reported as a bug a couple of
months later (which is, to be fair, that flag working as intended), and
it's got enough production time that, aside from code that is IMHO buggy
(and which is, in any case, not in nixpkgs) such as
lix-project/lix#445, we don't think
anyone doing anything reasonable actually depends on wrapping overflow.
Even for weird use cases such as doing funny bit crimes, it doesn't make
sense IMO to have wrapping behaviour, since two's complement arithmetic
overflow behaviour is so *aggressively* not what you want for *any* kind
of mathematics/algorithms. The Nix language exists for package
management, a domain where bit crimes are already only dubiously in
scope to begin with, and it makes a lot more sense for that domain for
the integers to never lose precision, either by throwing errors if they
would, or by being arbitrary-precision.
This change will be ported to CppNix as well, to maintain language
consistency.
Fixes: lix-project/lix#423
Change-Id: I51f253840c4af2ea5422b8a420aa5fafbf8fae75
127 lines
3.5 KiB
C++
127 lines
3.5 KiB
C++
#include "value-to-json.hh"
|
|
#include "eval-inline.hh"
|
|
#include "signals.hh"
|
|
#include "store-api.hh"
|
|
|
|
#include <cstdlib>
|
|
#include <iomanip>
|
|
#include <nlohmann/json.hpp>
|
|
|
|
|
|
namespace nix {
|
|
using json = nlohmann::json;
|
|
json printValueAsJSON(EvalState & state, bool strict,
|
|
Value & v, const PosIdx pos, NixStringContext & context, bool copyToStore)
|
|
{
|
|
checkInterrupt();
|
|
|
|
if (strict) state.forceValue(v, pos);
|
|
|
|
json out;
|
|
|
|
switch (v.type()) {
|
|
|
|
case nInt:
|
|
out = v.integer.value;
|
|
break;
|
|
|
|
case nBool:
|
|
out = v.boolean;
|
|
break;
|
|
|
|
case nString:
|
|
copyContext(v, context);
|
|
out = v.string.s;
|
|
break;
|
|
|
|
case nPath:
|
|
if (copyToStore)
|
|
out = state.store->printStorePath(
|
|
state.copyPathToStore(context, v.path()));
|
|
else
|
|
out = v.path().path.abs();
|
|
break;
|
|
|
|
case nNull:
|
|
// already initialized as null
|
|
break;
|
|
|
|
case nAttrs: {
|
|
auto maybeString = state.tryAttrsToString(pos, v, context, false, false);
|
|
if (maybeString) {
|
|
out = *maybeString;
|
|
break;
|
|
}
|
|
auto i = v.attrs->find(state.sOutPath);
|
|
if (i == v.attrs->end()) {
|
|
out = json::object();
|
|
StringSet names;
|
|
for (auto & j : *v.attrs)
|
|
names.emplace(state.symbols[j.name]);
|
|
for (auto & j : names) {
|
|
Attr & a(*v.attrs->find(state.symbols.create(j)));
|
|
try {
|
|
out[j] = printValueAsJSON(state, strict, *a.value, a.pos, context, copyToStore);
|
|
} catch (Error & e) {
|
|
e.addTrace(state.positions[a.pos],
|
|
HintFmt("while evaluating attribute '%1%'", j));
|
|
throw;
|
|
}
|
|
}
|
|
} else
|
|
return printValueAsJSON(state, strict, *i->value, i->pos, context, copyToStore);
|
|
break;
|
|
}
|
|
|
|
case nList: {
|
|
out = json::array();
|
|
int i = 0;
|
|
for (auto elem : v.listItems()) {
|
|
try {
|
|
out.push_back(printValueAsJSON(state, strict, *elem, pos, context, copyToStore));
|
|
} catch (Error & e) {
|
|
e.addTrace(state.positions[pos],
|
|
HintFmt("while evaluating list element at index %1%", i));
|
|
throw;
|
|
}
|
|
i++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case nExternal:
|
|
return v.external->printValueAsJSON(state, strict, context, copyToStore);
|
|
break;
|
|
|
|
case nFloat:
|
|
out = v.fpoint;
|
|
break;
|
|
|
|
case nThunk:
|
|
case nFunction:
|
|
state.error<TypeError>(
|
|
"cannot convert %1% to JSON",
|
|
showType(v)
|
|
)
|
|
.atPos(v.determinePos(pos))
|
|
.debugThrow();
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void printValueAsJSON(EvalState & state, bool strict,
|
|
Value & v, const PosIdx pos, std::ostream & str, NixStringContext & context, bool copyToStore)
|
|
{
|
|
str << printValueAsJSON(state, strict, v, pos, context, copyToStore);
|
|
}
|
|
|
|
json ExternalValueBase::printValueAsJSON(EvalState & state, bool strict,
|
|
NixStringContext & context, bool copyToStore) const
|
|
{
|
|
state.error<TypeError>("cannot convert %1% to JSON", showType())
|
|
.debugThrow();
|
|
}
|
|
|
|
|
|
}
|