1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
#include "lix/libutil/references.hh"
#include "lix/libutil/strings.hh"
#include "lix/libutil/hash.hh"
#include "lix/libutil/logging.hh"
#include <cstdlib>
#include <mutex>
#include <algorithm>
namespace nix {
static size_t refLength = 32; /* characters */
static void search(
std::string_view s,
StringSet & hashes,
StringSet & seen)
{
static std::once_flag initialised;
static bool isBase32[256];
std::call_once(initialised, [](){
for (unsigned int i = 0; i < 256; ++i) isBase32[i] = false;
for (unsigned int i = 0; i < base32Chars.size(); ++i)
isBase32[(unsigned char) base32Chars[i]] = true;
});
for (size_t i = 0; i + refLength <= s.size(); ) {
int j;
bool match = true;
for (j = refLength - 1; j >= 0; --j)
if (!isBase32[(unsigned char) s[i + j]]) {
i += j + 1;
match = false;
break;
}
if (!match) continue;
std::string ref(s.substr(i, refLength));
if (hashes.erase(ref)) {
debug("found reference to '%1%' at offset '%2%'", ref, i);
seen.insert(ref);
}
++i;
}
}
void RefScanSink::operator () (std::string_view data)
{
/* It's possible that a reference spans the previous and current
fragment, so search in the concatenation of the tail of the
previous fragment and the start of the current fragment. */
auto s = tail;
auto tailLen = std::min(data.size(), refLength);
s.append(data.data(), tailLen); // NOLINT(bugprone-suspicious-stringview-data-usage)
search(s, hashes, seen);
search(data, hashes, seen);
auto rest = refLength - tailLen;
if (rest < tail.size())
tail = tail.substr(tail.size() - rest);
tail.append(data.data() + data.size() - tailLen, tailLen);
}
RewritingSource::RewritingSource(const std::string & from, const std::string & to, Source & inner)
: RewritingSource({{from, to}}, inner)
{
}
RewritingSource::RewritingSource(StringMap rewrites, Source & inner)
: RewritingSource(may_change_size, std::move(rewrites), inner)
{
for (auto & [from, to] : this->rewrites) {
assert(from.size() == to.size());
}
}
RewritingSource::RewritingSource(may_change_size_t, StringMap rewrites, Source & inner)
: maxRewriteSize([&, result = size_t(0)]() mutable {
for (auto & [k, v] : rewrites) {
result = std::max(result, k.size());
}
return result;
}())
, initials([&]() -> std::string {
std::string initials;
for (const auto & [k, v] : rewrites) {
assert(!k.empty());
initials.push_back(k[0]);
}
std::ranges::sort(initials);
auto [firstDupe, _end] = std::ranges::unique(initials);
return {initials.begin(), firstDupe};
}())
, rewrites(std::move(rewrites))
, inner(&inner)
{
}
size_t RewritingSource::read(char * data, size_t len)
{
if (rewrites.empty()) {
return inner->read(data, len);
}
if (unreturned.empty()) {
// always make sure to have at least *two* full rewrites in the buffer,
// otherwise we may end up incorrectly rewriting if the replacement map
// contains keys that are proper infixes of other keys in the map. take
// for example the set { ab -> cc, babb -> bbbb } on the input babb. if
// we feed the input bytewise without additional windowing we will miss
// the full babb match once the second b has been seen and bab has been
// rewritten to ccb, even though babb occurs first in the input string.
while (inner && buffered.size() < std::max(2 * maxRewriteSize, len)) {
try {
auto read = inner->read(data, std::min(2 * maxRewriteSize, len));
buffered.append(data, read);
} catch (EndOfFile &) {
inner = nullptr;
}
}
if (buffered.empty() && !inner) {
throw EndOfFile("rewritten source exhausted");
}
const size_t reserved = inner ? maxRewriteSize : 0;
size_t j = 0;
while ((j = buffered.find_first_of(initials, j)) < buffered.size() - reserved) {
size_t skip = 1;
for (const auto & [from, to] : rewrites) {
if (buffered.compare(j, from.size(), from) == 0) {
buffered.replace(j, from.size(), to);
skip = to.size();
break;
}
}
j += skip;
}
rewritten = std::move(buffered);
buffered = rewritten.substr(rewritten.size() - reserved);
unreturned = rewritten;
unreturned.remove_suffix(reserved);
}
len = std::min(len, unreturned.size());
memcpy(data, unreturned.data(), len);
unreturned.remove_prefix(len);
return len;
}
HashResult computeHashModulo(HashType ht, const std::string & modulus, Source & source)
{
struct LengthSink : Sink
{
Sink & inner;
uint64_t length = 0;
LengthSink(Sink & inner) : inner(inner) {}
void operator()(std::string_view data) override
{
length += data.size();
inner(data);
}
};
HashSink hashSink(ht);
RewritingSource rewritingSource(modulus, std::string(modulus.size(), 0), source);
LengthSink lengthSink{hashSink};
rewritingSource.drainInto(lengthSink);
/* Hash the positions of the self-references. This ensures that a
NAR with self-references and a NAR with some of the
self-references already zeroed out do not produce a hash
collision. FIXME: proof. */
// NOTE(horrors) RewritingSink didn't track any matches!
//for (auto & pos : rewritingSource.matches)
// hashSink(fmt("|%d", pos));
auto h = hashSink.finish();
return {h.first, lengthSink.length};
}
}
|