Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #ifndef BITCOIN_STREAMS_H
7 : : #define BITCOIN_STREAMS_H
8 : :
9 : : #include <serialize.h>
10 : : #include <span.h>
11 : : #include <support/allocators/zeroafterfree.h>
12 : : #include <util/check.h>
13 : : #include <util/log.h>
14 : : #include <util/obfuscation.h>
15 : : #include <util/overflow.h>
16 : : #include <util/syserror.h>
17 : :
18 : : #include <algorithm>
19 : : #include <cassert>
20 : : #include <cstddef>
21 : : #include <cstdint>
22 : : #include <cstdio>
23 : : #include <cstring>
24 : : #include <ios>
25 : : #include <limits>
26 : : #include <optional>
27 : : #include <string>
28 : : #include <vector>
29 : :
30 : : /* Minimal stream for overwriting and/or appending to an existing byte vector
31 : : *
32 : : * The referenced vector will grow as necessary
33 : : */
34 : : class VectorWriter
35 : : {
36 : : public:
37 : : /*
38 : : * @param[in] vchDataIn Referenced byte vector to overwrite/append
39 : : * @param[in] nPosIn Starting position. Vector index where writes should start. The vector will initially
40 : : * grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size().
41 : : */
42 : 788086 : VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}
43 : : {
44 [ - + - + ]: 788086 : if(nPos > vchData.size())
45 : 0 : vchData.resize(nPos);
46 : 788086 : }
47 : : /*
48 : : * (other params same as above)
49 : : * @param[in] args A list of items to serialize starting at nPosIn.
50 : : */
51 : : template <typename... Args>
52 [ + - ][ + - : 705022 : VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : VectorWriter{vchDataIn, nPosIn}
+ - + - ]
[ + - - -
+ - - - -
- - - + -
+ - - - -
- - - - -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
53 : : {
54 [ + - ][ + - : 705022 : ::SerializeMany(*this, std::forward<Args>(args)...);
+ - + - ]
[ + - - -
+ - - - -
- - - + -
+ - - - -
- - - - -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
55 : 262615 : }
56 : 6435208 : void write(std::span<const std::byte> src)
57 : : {
58 [ - + - + ]: 6435208 : assert(nPos <= vchData.size());
59 [ + + ]: 6435208 : size_t nOverwrite = std::min(src.size(), vchData.size() - nPos);
60 [ - + ]: 6435208 : if (nOverwrite) {
61 : 0 : memcpy(vchData.data() + nPos, src.data(), nOverwrite);
62 : : }
63 [ + + ]: 6435208 : if (nOverwrite < src.size()) {
64 : 6345226 : vchData.insert(vchData.end(), UCharCast(src.data()) + nOverwrite, UCharCast(src.data() + src.size()));
65 : : }
66 : 6435208 : nPos += src.size();
67 : 6435208 : }
68 : : template <typename T>
69 : 1298280 : VectorWriter& operator<<(const T& obj)
70 : : {
71 [ + - + - : 1298280 : ::Serialize(*this, obj);
+ - + - +
- + - +
- ][ + - +
- + - +
- ]
72 : 123023 : return (*this);
73 : : }
74 : :
75 : : private:
76 : : std::vector<unsigned char>& vchData;
77 : : size_t nPos;
78 : : };
79 : :
80 : : /** Minimal stream for reading from an existing byte array by std::span.
81 : : */
82 : : class SpanReader
83 : : {
84 : : private:
85 : : std::span<const std::byte> m_data;
86 : :
87 : : public:
88 : : /**
89 : : * @param[in] data Referenced byte vector to overwrite/append
90 : : */
91 : 3213820 : explicit SpanReader(std::span<const unsigned char> data) : m_data{std::as_bytes(data)} {}
92 [ + + ]: 441185 : explicit SpanReader(std::span<const std::byte> data) : m_data{data} {}
93 : :
94 : : template<typename T>
95 : 39974366 : SpanReader& operator>>(T&& obj)
96 : : {
97 [ + + + + : 39909435 : ::Unserialize(*this, obj);
+ + ]
[ + + + + ]
[ + + # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ][ + +
+ + + + +
+ + + + +
+ - + - +
- + + + -
+ + + - +
- + + + -
+ + + + +
+ + + + -
+ + + - +
- + - + -
+ - + + +
+ + - + +
+ + ][ # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ + + + +
+ + + + #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ][ - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - +
+ - - - -
- - # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ - - + +
+ - + + +
+ + + + +
+ + + + +
- + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + -
+ - + + +
+ + - + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
- - - - -
- + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + ][ -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- + + ]
98 : 19722187 : return (*this);
99 : : }
100 : :
101 [ + + + + : 304751 : size_t size() const { return m_data.size(); }
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + ]
102 [ + + + + : 3126484 : bool empty() const { return m_data.empty(); }
# # # # #
# # # # #
# # # # ]
[ + + + +
+ + + + +
+ + + + +
+ + + + ]
[ - - - -
- - - - -
- - - - -
- - - - +
+ ][ + + ]
103 : :
104 : 360550095 : void read(std::span<std::byte> dst)
105 : : {
106 [ + + ]: 360550095 : if (dst.size() == 0) {
107 : : return;
108 : : }
109 : :
110 : : // Read from the beginning of the buffer
111 [ + + ]: 353659080 : if (dst.size() > m_data.size()) {
112 [ + - ]: 1083482 : throw std::ios_base::failure("SpanReader::read(): end of data");
113 : : }
114 : 353117339 : memcpy(dst.data(), m_data.data(), dst.size());
115 : 353117339 : m_data = m_data.subspan(dst.size());
116 : : }
117 : :
118 : 5570 : void ignore(size_t n)
119 : : {
120 [ + + ]: 5570 : if (n > m_data.size()) {
121 [ + - ]: 2660 : throw std::ios_base::failure("SpanReader::ignore(): end of data");
122 : : }
123 : 4240 : m_data = m_data.subspan(n);
124 : 4240 : }
125 : : };
126 : :
127 : : /** Double ended buffer combining vector and stream-like interfaces.
128 : : *
129 : : * >> and << read and write unformatted data using the above serialization templates.
130 : : * Fills with data in linear time; some stringstream implementations take N^2 time.
131 : : */
132 [ + - ]: 27064136 : class DataStream
[ + + + - ]
[ - - - -
- - ]
133 : : {
134 : : protected:
135 : : using vector_type = SerializeData;
136 : : vector_type vch;
137 : : vector_type::size_type m_read_pos{0};
138 : :
139 : : public:
140 : : typedef vector_type::allocator_type allocator_type;
141 : : typedef vector_type::size_type size_type;
142 : : typedef vector_type::difference_type difference_type;
143 : : typedef vector_type::reference reference;
144 : : typedef vector_type::const_reference const_reference;
145 : : typedef vector_type::value_type value_type;
146 : : typedef vector_type::iterator iterator;
147 : : typedef vector_type::const_iterator const_iterator;
148 : : typedef vector_type::reverse_iterator reverse_iterator;
149 : :
150 : : explicit DataStream() = default;
151 : 12823 : explicit DataStream(std::span<const uint8_t> sp) : DataStream{std::as_bytes(sp)} {}
152 : 4203943 : explicit DataStream(std::span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
153 : :
154 : 421 : std::string str() const
155 : : {
156 : 1263 : return std::string{UCharCast(data()), UCharCast(data() + size())};
157 : : }
158 : :
159 : :
160 : : //
161 : : // Vector subset
162 : : //
163 : : const_iterator begin() const { return vch.begin() + m_read_pos; }
164 : 1787634 : iterator begin() { return vch.begin() + m_read_pos; }
165 : : const_iterator end() const { return vch.end(); }
166 [ # # # # ]: 934569 : iterator end() { return vch.end(); }
[ + - ]
167 [ - + + - : 16188256 : size_type size() const { return vch.size() - m_read_pos; }
- + - + -
+ + - # #
# # ][ - +
+ - - + +
- - + + -
- + + - ]
[ - + + +
- + + + -
+ + - - +
+ - - + +
+ - + + +
+ + + + +
+ + + +
- ][ # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ -
+ - + + -
- + - + +
- - + - +
- + - + -
- - + + -
- + + - -
+ + - - +
+ - - - -
- ][ - + +
+ - + +
+ ][ - - -
- - + # #
# # # # #
# # # #
# ][ # # #
# # # # #
# # # # #
# # # # #
# # ][ # #
# # # # #
# # # # #
# # # # #
# ][ - + ]
[ - + + + ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ -
+ - + + -
- + - + #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
168 [ - + - + : 77762 : bool empty() const { return vch.size() == m_read_pos; }
- + - + ]
[ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + ]
[ - + + +
- + + + -
+ + + - +
+ + ]
169 : 870583 : void resize(size_type n, value_type c = value_type{}) { vch.resize(n + m_read_pos, c); }
170 [ # # # # : 7083488 : void reserve(size_type n) { vch.reserve(n + m_read_pos); }
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ][ + -
+ - - - -
- - - - -
- - - - +
- + - + -
+ - + - +
- - - - -
- - + - +
- - - + -
+ - - - -
- + - + -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - + -
+ - - - -
- - - - -
- - - - ]
[ # # # #
# # # # ]
[ + - # #
# # # # #
# # # # #
# # ][ + -
+ - + - +
- + - ][ #
# # # # #
# # # # #
# ][ + - +
- + - + -
+ - + - +
- - - ]
171 : : const_reference operator[](size_type pos) const { return vch[pos + m_read_pos]; }
172 [ + + ]: 5706109 : reference operator[](size_type pos) { return vch[pos + m_read_pos]; }
173 [ + + + + : 6456525 : void clear() { vch.clear(); m_read_pos = 0; }
# # # # #
# ][ # # #
# # # # #
# # ][ # #
# # # # ]
[ + - + -
+ - + - +
- + - + -
+ - + - +
- + - ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# ][ + - +
- + - + -
+ - + - +
- - - ]
174 [ - + # # : 13364521 : value_type* data() { return vch.data() + m_read_pos; }
# # # # ]
[ - + - +
- + - + ]
[ - + - +
- + - + -
+ - + - +
- + - - -
+ - + - +
- + - - ]
[ # # # #
# # # # #
# ]
[ - + - + ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ - + - +
- + # # #
# # # # #
# # # # #
# # # #
# ][ - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ ][ - + -
+ - + - +
- + - + -
+ - + ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ][ # # #
# # # # #
# # # # #
# # # # #
# # ]
175 [ - + ]: 90068 : const value_type* data() const { return vch.data() + m_read_pos; }
176 : :
177 : : inline void Compact()
178 : : {
179 : : vch.erase(vch.begin(), vch.begin() + m_read_pos);
180 : : m_read_pos = 0;
181 : : }
182 : :
183 : : bool Rewind(std::optional<size_type> n = std::nullopt)
184 : : {
185 : : // Total rewind if no size is passed
186 : : if (!n) {
187 : : m_read_pos = 0;
188 : : return true;
189 : : }
190 : : // Rewind by n characters if the buffer hasn't been compacted yet
191 : : if (*n > m_read_pos)
192 : : return false;
193 : : m_read_pos -= *n;
194 : : return true;
195 : : }
196 : :
197 : :
198 : : //
199 : : // Stream subset
200 : : //
201 [ - + + + ]: 154 : int in_avail() const { return size(); }
202 : :
203 : 200034848 : void read(std::span<value_type> dst)
204 : : {
205 [ + + ]: 200034848 : if (dst.size() == 0) return;
206 : :
207 : : // Read from the beginning of the buffer
208 [ + - ]: 200020881 : auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
209 [ + - - + : 200020881 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
+ + ]
210 [ + - ]: 21280 : throw std::ios_base::failure("DataStream::read(): end of data");
211 : : }
212 [ - + ]: 200010241 : memcpy(dst.data(), &vch[m_read_pos], dst.size());
213 [ - + + + ]: 200010241 : if (next_read_pos.value() == vch.size()) {
214 : 22094987 : m_read_pos = 0;
215 [ + - ]: 22094987 : vch.clear();
216 : 22094987 : return;
217 : : }
218 : 177915254 : m_read_pos = next_read_pos.value();
219 : : }
220 : :
221 : 796758 : void ignore(size_t num_ignore)
222 : : {
223 : : // Ignore from the beginning of the buffer
224 : 796758 : auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
225 [ + - - + : 796758 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
+ + ]
226 [ + - ]: 3756 : throw std::ios_base::failure("DataStream::ignore(): end of data");
227 : : }
228 [ + + ]: 794880 : if (next_read_pos.value() == vch.size()) {
229 : 317 : m_read_pos = 0;
230 [ + + ]: 317 : vch.clear();
231 : 317 : return;
232 : : }
233 : 794563 : m_read_pos = next_read_pos.value();
234 : : }
235 : :
236 : 299838513 : void write(std::span<const value_type> src)
237 : : {
238 : : // Write to the end of the buffer
239 : 299838513 : vch.insert(vch.end(), src.begin(), src.end());
240 : 299838513 : }
241 : :
242 : : template<typename T>
243 : 74555524 : DataStream& operator<<(const T& obj)
244 : : {
245 [ + - + - ]: 71377798 : ::Serialize(*this, obj);
[ - - - -
- - - - -
- - - - -
- - + - +
- + - +
- ][ + - +
- + - + -
+ - # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ][ - - -
- - - - -
- - - - -
- - - + -
+ - + - +
- + - + -
+ - + - +
- # # ][ #
# # # # #
# # # # #
# ][ + - +
- + - + -
+ - + - +
- + - + -
+ - + - #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ][ - -
- - - - -
- - - - -
- - - - -
- - - - -
+ - + - -
- - - - -
- - - - -
- + - + -
+ - + - +
- + - - -
- - - - +
- + - - -
+ - + - -
- - - + -
+ - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
+ - + - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - ][ #
# # # # #
# # # # #
# # # # #
# # ][ + - ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
246 : 14165295 : return (*this);
247 : : }
248 : :
249 : : template <typename T>
250 : 29048254 : DataStream& operator>>(T&& obj)
251 : : {
252 [ + + ]: 28997900 : ::Unserialize(*this, obj);
[ + + + + ]
[ + - + -
+ - + - +
- + - + -
+ - + - +
- + - ][ +
- + - + -
+ - + - #
# # # # #
# # # # #
# ][ # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ + + + +
+ + + + +
+ + + + +
+ - + + +
+ + + + +
+ + + + +
+ + + - -
+ + + + +
+ + + + -
+ + + + +
+ ][ + - +
- + - # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
253 : 7462450 : return (*this);
254 : : }
255 : :
256 : : /** Compute total memory usage of this object (own memory + any dynamic memory). */
257 : : size_t GetMemoryUsage() const noexcept;
258 : : };
259 : :
260 : : template <typename IStream>
261 : : class BitStreamReader
262 : : {
263 : : private:
264 : : IStream& m_istream;
265 : :
266 : : /// Buffered byte read in from the input stream. A new byte is read into the
267 : : /// buffer when m_offset reaches 8.
268 : : uint8_t m_buffer{0};
269 : :
270 : : /// Number of high order bits in m_buffer already returned by previous
271 : : /// Read() calls. The next bit to be returned is at this offset from the
272 : : /// most significant bit position.
273 : : int m_offset{8};
274 : :
275 : : public:
276 [ + - ]: 2148 : explicit BitStreamReader(IStream& istream) : m_istream(istream) {}
277 : :
278 : : /** Read the specified number of bits from the stream. The data is returned
279 : : * in the nbits least significant bits of a 64-bit uint.
280 : : */
281 : 2307352 : uint64_t Read(int nbits) {
282 [ + - ]: 2307352 : if (nbits < 0 || nbits > 64) {
283 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
284 : : }
285 : :
286 : : uint64_t data = 0;
287 [ + + ]: 6737994 : while (nbits > 0) {
288 [ + + ]: 4454518 : if (m_offset == 8) {
289 : 2579320 : m_istream >> m_buffer;
290 : 2555444 : m_offset = 0;
291 : : }
292 : :
293 [ + + ]: 4430642 : int bits = std::min(8 - m_offset, nbits);
294 : 4430642 : data <<= bits;
295 : 4430642 : data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
296 : 4430642 : m_offset += bits;
297 : 4430642 : nbits -= bits;
298 : : }
299 : 2283476 : return data;
300 : : }
301 : : };
302 : :
303 : : template <typename OStream>
304 : : class BitStreamWriter
305 : : {
306 : : private:
307 : : OStream& m_ostream;
308 : :
309 : : /// Buffered byte waiting to be written to the output stream. The byte is
310 : : /// written buffer when m_offset reaches 8 or Flush() is called.
311 : : uint8_t m_buffer{0};
312 : :
313 : : /// Number of high order bits in m_buffer already written by previous
314 : : /// Write() calls and not yet flushed to the stream. The next bit to be
315 : : /// written to is at this offset from the most significant bit position.
316 : : int m_offset{0};
317 : :
318 : : public:
319 [ + + ]: 379 : explicit BitStreamWriter(OStream& ostream) : m_ostream(ostream) {}
320 : :
321 : 379 : ~BitStreamWriter()
322 : : {
323 : 379 : Flush();
324 : 379 : }
325 : :
326 : : /** Write the nbits least significant bits of a 64-bit int to the output
327 : : * stream. Data is buffered until it completes an octet.
328 : : */
329 : 139021 : void Write(uint64_t data, int nbits) {
330 [ + - ]: 139021 : if (nbits < 0 || nbits > 64) {
331 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
332 : : }
333 : :
334 [ + + ]: 406485 : while (nbits > 0) {
335 [ + + ]: 267464 : int bits = std::min(8 - m_offset, nbits);
336 : 267464 : m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
337 : 267464 : m_offset += bits;
338 : 267464 : nbits -= bits;
339 : :
340 [ + + ]: 267464 : if (m_offset == 8) {
341 : 145705 : Flush();
342 : : }
343 : : }
344 : 139021 : }
345 : :
346 : : /** Flush any unwritten bits to the output stream, padding with 0's to the
347 : : * next byte boundary.
348 : : */
349 : 146463 : void Flush() {
350 [ + + ]: 146463 : if (m_offset == 0) {
351 : : return;
352 : : }
353 : :
354 : 146000 : m_ostream << m_buffer;
355 : 146000 : m_buffer = 0;
356 : 146000 : m_offset = 0;
357 : : }
358 : : };
359 : :
360 : : /** Non-refcounted RAII wrapper for FILE*
361 : : *
362 : : * Will automatically close the file when it goes out of scope if not null.
363 : : * If you're returning the file pointer, return file.release().
364 : : * If you need to close the file early, use autofile.fclose() instead of fclose(underlying_FILE).
365 : : *
366 : : * @note If the file has been written to, then the caller must close it
367 : : * explicitly with the `fclose()` method, check if it returns an error and treat
368 : : * such an error as if the `write()` method failed. The OS's `fclose(3)` may
369 : : * fail to flush to disk data that has been previously written, rendering the
370 : : * file corrupt.
371 : : */
372 : : class AutoFile
373 : : {
374 : : protected:
375 : : std::FILE* m_file;
376 : : Obfuscation m_obfuscation;
377 : : std::optional<int64_t> m_position;
378 : : bool m_was_written{false};
379 : :
380 : : public:
381 : : explicit AutoFile(std::FILE* file, const Obfuscation& obfuscation = {});
382 : :
383 : 209155 : ~AutoFile()
384 : : {
385 [ + + ]: 209155 : if (m_was_written) {
386 : : // Callers that wrote to the file must have closed it explicitly
387 : : // with the fclose() method and checked that the close succeeded.
388 : : // This is because here in the destructor we have no way to signal
389 : : // errors from fclose() which, after write, could mean the file is
390 : : // corrupted and must be handled properly at the call site.
391 : : // Destructors in C++ cannot signal an error to the callers because
392 : : // they do not return a value and are not allowed to throw exceptions.
393 : 376887 : Assume(IsNull());
394 : : }
395 : :
396 [ + + ]: 11774 : if (fclose() != 0) {
397 : 2802 : LogError("Failed to close file: %s", SysErrorString(errno));
398 : : }
399 : 209155 : }
400 : :
401 : : // Disallow copies
402 : : AutoFile(const AutoFile&) = delete;
403 : : AutoFile& operator=(const AutoFile&) = delete;
404 : :
405 : 13989 : bool feof() const { return std::feof(m_file); }
406 : :
407 : 380493 : [[nodiscard]] int fclose()
408 : : {
409 [ + - ]: 182425 : if (auto rel{release()}) return std::fclose(rel);
[ + - + - ]
[ + - + -
+ - ]
410 : : return 0;
411 : : }
412 : :
413 : : /** Get wrapped FILE* with transfer of ownership.
414 : : * @note This will invalidate the AutoFile object, and makes it the responsibility of the caller
415 : : * of this function to clean up the returned FILE*.
416 : : */
417 : 380543 : std::FILE* release()
418 : : {
419 : 380543 : std::FILE* ret{m_file};
420 : 380543 : m_file = nullptr;
421 [ + + + + : 380543 : return ret;
+ + ]
[ + - - - ]
[ # # # #
# # ][ + -
+ - + - -
- ][ # # #
# # # # #
# # ]
422 : : }
423 : :
424 : : /** Return true if the wrapped FILE* is nullptr, false otherwise.
425 : : */
426 [ - + # # ]: 577341 : bool IsNull() const { return m_file == nullptr; }
[ + + - - ]
[ + + + +
+ + ][ - -
- - - + +
+ - + - -
- - ][ # #
# # # # #
# # # ]
427 : :
428 : : /** Continue with a different XOR key */
429 : 1982 : void SetObfuscation(const Obfuscation& obfuscation) { m_obfuscation = obfuscation; }
430 : :
431 : : /** Implementation detail, only used internally. */
432 : : std::size_t detail_fread(std::span<std::byte> dst);
433 : :
434 : : /** Wrapper around fseek(). Will throw if seeking is not possible. */
435 : : void seek(int64_t offset, int origin);
436 : :
437 : : /** Find position within the file. Will throw if unknown. */
438 : : int64_t tell();
439 : :
440 : : /** Return the size of the file. Will throw if unknown. */
441 : : int64_t size();
442 : :
443 : : /** Wrapper around FileCommit(). */
444 : : bool Commit();
445 : :
446 : : /** Wrapper around TruncateFile(). */
447 : : bool Truncate(unsigned size);
448 : :
449 : : //! Write a mutable buffer more efficiently than write(), obfuscating the buffer in-place.
450 : : void write_buffer(std::span<std::byte> src);
451 : :
452 : : //
453 : : // Stream subset
454 : : //
455 : : void read(std::span<std::byte> dst);
456 : : void ignore(size_t nSize);
457 : : void write(std::span<const std::byte> src);
458 : :
459 : : template <typename T>
460 : 2191024 : AutoFile& operator<<(const T& obj)
461 : : {
462 [ + + + + ]: 2182650 : ::Serialize(*this, obj);
[ + - # # ]
[ - - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ][ + + +
- + - + -
+ - + - +
- + - ][ #
# # # # #
# # # # #
# # # # #
# # ][ + -
+ + + - +
+ - - - -
- - + + +
- ][ # # #
# # # #
# ]
463 : 419332 : return *this;
464 : : }
465 : :
466 : : template <typename T>
467 : 6501855 : AutoFile& operator>>(T&& obj)
468 : : {
469 [ + + + + ]: 6489168 : ::Unserialize(*this, obj);
[ - - + +
+ + + + +
- + + + +
+ - + - -
- + - - -
- - ][ + +
+ + + + +
+ + - +
+ ][ # # ]
[ + - + -
+ - # # ]
[ + + + +
+ + + + +
+ + + + +
+ + + + ]
[ + + + +
+ + + + #
# # # # #
# # # # ]
470 : 2772631 : return *this;
471 : : }
472 : : };
473 : :
474 : : using DataBuffer = std::vector<std::byte>;
475 : :
476 : : /** Wrapper around an AutoFile& that implements a ring buffer to
477 : : * deserialize from. It guarantees the ability to rewind a given number of bytes.
478 : : *
479 : : * Will automatically close the file when it goes out of scope if not null.
480 : : * If you need to close the file early, use file.fclose() instead of fclose(file).
481 : : */
482 : 1054 : class BufferedFile
483 : : {
484 : : private:
485 : : AutoFile& m_src;
486 : : uint64_t nSrcPos{0}; //!< how many bytes have been read from source
487 : : uint64_t m_read_pos{0}; //!< how many bytes have been read from this
488 : : uint64_t nReadLimit; //!< up to which position we're allowed to read
489 : : uint64_t nRewind; //!< how many bytes we guarantee to rewind
490 : : DataBuffer vchBuf;
491 : :
492 : : //! read data from the source to fill the buffer
493 : 448494 : bool Fill() {
494 [ - + ]: 448494 : unsigned int pos = nSrcPos % vchBuf.size();
495 : 448494 : unsigned int readNow = vchBuf.size() - pos;
496 : 448494 : unsigned int nAvail = vchBuf.size() - (nSrcPos - m_read_pos) - nRewind;
497 [ + + ]: 448494 : if (nAvail < readNow)
498 : 420084 : readNow = nAvail;
499 [ + - ]: 448494 : if (readNow == 0)
500 : : return false;
501 : 448494 : size_t nBytes{m_src.detail_fread(std::span{vchBuf}.subspan(pos, readNow))};
502 [ + + ]: 448158 : if (nBytes == 0) {
503 [ + + + - ]: 9372 : throw std::ios_base::failure{m_src.feof() ? "BufferedFile::Fill: end of file" : "BufferedFile::Fill: fread failed"};
504 : : }
505 : 443472 : nSrcPos += nBytes;
506 : 443472 : return true;
507 : : }
508 : :
509 : : //! Advance the stream's read pointer (m_read_pos) by up to 'length' bytes,
510 : : //! filling the buffer from the file so that at least one byte is available.
511 : : //! Return a pointer to the available buffer data and the number of bytes
512 : : //! (which may be less than the requested length) that may be accessed
513 : : //! beginning at that pointer.
514 : 8062979 : std::pair<std::byte*, size_t> AdvanceStream(size_t length)
515 : : {
516 [ - + ]: 8062979 : assert(m_read_pos <= nSrcPos);
517 [ + + ]: 8062979 : if (m_read_pos + length > nReadLimit) {
518 [ + - ]: 52646 : throw std::ios_base::failure("Attempt to position past buffer limit");
519 : : }
520 : : // If there are no bytes available, read from the file.
521 [ + + + - ]: 8036656 : if (m_read_pos == nSrcPos && length > 0) Fill();
522 : :
523 [ - + ]: 8032658 : size_t buffer_offset{static_cast<size_t>(m_read_pos % vchBuf.size())};
524 : 8032658 : size_t buffer_available{static_cast<size_t>(vchBuf.size() - buffer_offset)};
525 : 8032658 : size_t bytes_until_source_pos{static_cast<size_t>(nSrcPos - m_read_pos)};
526 : 8032658 : size_t advance{std::min({length, buffer_available, bytes_until_source_pos})};
527 : 8032658 : m_read_pos += advance;
528 : 8032658 : return std::make_pair(&vchBuf[buffer_offset], advance);
529 : : }
530 : :
531 : : public:
532 : 1075 : BufferedFile(AutoFile& file LIFETIMEBOUND, uint64_t nBufSize, uint64_t nRewindIn)
533 : 1075 : : m_src{file}, nReadLimit{std::numeric_limits<uint64_t>::max()}, nRewind{nRewindIn}, vchBuf(nBufSize, std::byte{0})
534 : : {
535 [ + + ]: 1075 : if (nRewindIn >= nBufSize)
536 [ + - ]: 42 : throw std::ios_base::failure("Rewind limit must be less than buffer size");
537 : 1075 : }
538 : :
539 : : //! check whether we're at the end of the source file
540 : 2673635 : bool eof() const {
541 [ + + + + ]: 2673635 : return m_read_pos == nSrcPos && m_src.feof();
542 : : }
543 : :
544 : : //! read a number of bytes
545 : 7386678 : void read(std::span<std::byte> dst)
546 : : {
547 [ + + ]: 15100867 : while (dst.size() > 0) {
548 : 7743421 : auto [buffer_pointer, length]{AdvanceStream(dst.size())};
549 : 7714189 : memcpy(dst.data(), buffer_pointer, length);
550 : 7714189 : dst = dst.subspan(length);
551 : : }
552 : 7357446 : }
553 : :
554 : : //! Move the read position ahead in the stream to the given position.
555 : : //! Use SetPos() to back up in the stream, not SkipTo().
556 : 322880 : void SkipTo(const uint64_t file_pos)
557 : : {
558 [ + - ]: 322880 : assert(file_pos >= m_read_pos);
559 [ + + ]: 641349 : while (m_read_pos < file_pos) AdvanceStream(file_pos - m_read_pos);
560 : 321791 : }
561 : :
562 : : //! return the current reading position
563 : 3080644 : uint64_t GetPos() const {
564 [ + + + + : 3080644 : return m_read_pos;
+ - ]
565 : : }
566 : :
567 : : //! rewind to a given reading position
568 : 2795991 : bool SetPos(uint64_t nPos) {
569 [ - + ]: 2795991 : size_t bufsize = vchBuf.size();
570 [ + + ]: 2795991 : if (nPos + bufsize < nSrcPos) {
571 : : // rewinding too far, rewind as far as possible
572 : 780 : m_read_pos = nSrcPos - bufsize;
573 : 780 : return false;
574 : : }
575 [ + + ]: 2795211 : if (nPos > nSrcPos) {
576 : : // can't go this far forward, go as far as possible
577 : 1259 : m_read_pos = nSrcPos;
578 : 1259 : return false;
579 : : }
580 : 2793952 : m_read_pos = nPos;
581 : 2793952 : return true;
582 : : }
583 : :
584 : : //! prevent reading beyond a certain position
585 : : //! no argument removes the limit
586 : 2998043 : bool SetLimit(uint64_t nPos = std::numeric_limits<uint64_t>::max()) {
587 [ + + ]: 324659 : if (nPos < m_read_pos)
588 : : return false;
589 : 2997599 : nReadLimit = nPos;
590 [ + + ]: 2997599 : return true;
591 : : }
592 : :
593 : : template<typename T>
594 : 3530740 : BufferedFile& operator>>(T&& obj) {
595 [ + + + + ]: 3530740 : ::Unserialize(*this, obj);
[ + + + +
+ + + + ]
596 : 3471761 : return (*this);
597 : : }
598 : :
599 : : //! search for a given byte in the stream, and remain positioned on it
600 : 2675946 : void FindByte(std::byte byte)
601 : : {
602 : : // For best performance, avoid mod operation within the loop.
603 [ - + ]: 2675946 : size_t buf_offset{size_t(m_read_pos % uint64_t(vchBuf.size()))};
604 : 2752589 : while (true) {
605 [ + + ]: 2752589 : if (m_read_pos == nSrcPos) {
606 : : // No more bytes available; read from the file into the buffer,
607 : : // setting nSrcPos to one beyond the end of the new data.
608 : : // Throws exception if end-of-file reached.
609 : 78836 : Fill();
610 : : }
611 [ - + + + ]: 2751565 : const size_t len{std::min<size_t>(vchBuf.size() - buf_offset, nSrcPos - m_read_pos)};
612 [ + + ]: 2751565 : const auto it_start{vchBuf.begin() + buf_offset};
613 : 2751565 : const auto it_find{std::find(it_start, it_start + len, byte)};
614 [ + + ]: 2751565 : const size_t inc{size_t(std::distance(it_start, it_find))};
615 : 2751565 : m_read_pos += inc;
616 [ + + ]: 2751565 : if (inc < len) break;
617 : 76643 : buf_offset += inc;
618 [ + + ]: 76643 : if (buf_offset >= vchBuf.size()) buf_offset = 0;
619 : : }
620 : 2674922 : }
621 : : };
622 : :
623 : : /**
624 : : * Wrapper that buffers reads from an underlying stream.
625 : : * Requires underlying stream to support read() and detail_fread() calls
626 : : * to support fixed-size and variable-sized reads, respectively.
627 : : */
628 : : template <typename S>
629 : 0 : class BufferedReader
630 : : {
631 : : S& m_src;
632 : : DataBuffer m_buf;
633 : : size_t m_buf_pos;
634 : :
635 : : public:
636 : : //! Requires stream ownership to prevent leaving the stream at an unexpected position after buffered reads.
637 : 0 : explicit BufferedReader(S&& stream LIFETIMEBOUND, size_t size = 1 << 16)
638 : : requires std::is_rvalue_reference_v<S&&>
639 [ # # # # ]: 0 : : m_src{stream}, m_buf(size), m_buf_pos{size} {}
640 : :
641 : 0 : void read(std::span<std::byte> dst)
642 : : {
643 [ # # # # : 0 : if (const auto available{std::min(dst.size(), m_buf.size() - m_buf_pos)}) {
# # ]
644 : 0 : std::copy_n(m_buf.begin() + m_buf_pos, available, dst.begin());
645 : 0 : m_buf_pos += available;
646 : 0 : dst = dst.subspan(available);
647 : : }
648 [ # # ]: 0 : if (dst.size()) {
649 [ # # # # ]: 0 : assert(m_buf_pos == m_buf.size());
650 : 0 : m_src.read(dst);
651 : :
652 : 0 : m_buf_pos = 0;
653 [ # # ]: 0 : m_buf.resize(m_src.detail_fread(m_buf));
654 : : }
655 : 0 : }
656 : :
657 : : template <typename T>
658 : 0 : BufferedReader& operator>>(T&& obj)
659 : : {
660 [ # # ]: 0 : Unserialize(*this, obj);
661 : 0 : return *this;
662 : : }
663 : : };
664 : :
665 : : /**
666 : : * Wrapper that buffers writes to an underlying stream.
667 : : * Requires underlying stream to support write_buffer() method
668 : : * for efficient buffer flushing and obfuscation.
669 : : */
670 : : template <typename S>
671 : : class BufferedWriter
672 : : {
673 : : S& m_dst;
674 : : DataBuffer m_buf;
675 : : size_t m_buf_pos{0};
676 : :
677 : : public:
678 [ + - + - : 163856 : explicit BufferedWriter(S& stream LIFETIMEBOUND, size_t size = 1 << 16) : m_dst{stream}, m_buf(size) {}
+ - + - ]
679 : :
680 [ + - + - ]: 163856 : ~BufferedWriter() { flush(); }
681 : :
682 : 163856 : void flush()
683 : : {
684 [ + - - + ]: 163856 : if (m_buf_pos) m_dst.write_buffer(std::span{m_buf}.first(m_buf_pos));
685 : 163856 : m_buf_pos = 0;
686 : 163856 : }
687 : :
688 : 2921342 : void write(std::span<const std::byte> src)
689 : : {
690 [ - + + - : 11685368 : while (const auto available{std::min(src.size(), m_buf.size() - m_buf_pos)}) {
+ + ]
691 : 2921342 : std::copy_n(src.begin(), available, m_buf.begin() + m_buf_pos);
692 : 2921342 : m_buf_pos += available;
693 [ - + - + ]: 2921342 : if (m_buf_pos == m_buf.size()) flush();
694 : 2921342 : src = src.subspan(available);
695 : : }
696 : 2921342 : }
697 : :
698 : : template <typename T>
699 : 646452 : BufferedWriter& operator<<(const T& obj)
700 : : {
701 [ - - + - : 482596 : Serialize(*this, obj);
+ - + - +
- + - + -
+ - + - +
- ]
702 : 327716 : return *this;
703 : : }
704 : : };
705 : :
706 : : #endif // BITCOIN_STREAMS_H
|
