Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 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/overflow.h>
13 : :
14 : : #include <algorithm>
15 : : #include <assert.h>
16 : : #include <cstddef>
17 : : #include <cstdio>
18 : : #include <ios>
19 : : #include <limits>
20 : : #include <optional>
21 : : #include <stdint.h>
22 : : #include <string.h>
23 : : #include <string>
24 : : #include <utility>
25 : : #include <vector>
26 : :
27 : : namespace util {
28 : 3852713 : inline void Xor(Span<std::byte> write, Span<const std::byte> key, size_t key_offset = 0)
29 : : {
30 [ - + ]: 3852713 : if (key.size() == 0) {
31 : 0 : return;
32 : : }
33 : 3852713 : key_offset %= key.size();
34 : :
35 [ + + ]: 36708591 : for (size_t i = 0, j = key_offset; i != write.size(); i++) {
36 : 32855878 : write[i] ^= key[j++];
37 : :
38 : : // This potentially acts on very many bytes of data, so it's
39 : : // important that we calculate `j`, i.e. the `key` index in this
40 : : // way instead of doing a %, which would effectively be a division
41 : : // for each byte Xor'd -- much slower than need be.
42 [ + + ]: 32855878 : if (j == key.size())
43 : 2070869 : j = 0;
44 : 32855878 : }
45 : 3852713 : }
46 : : } // namespace util
47 : :
48 : : template<typename Stream>
49 : : class OverrideStream
50 : : {
51 : : Stream* stream;
52 : :
53 : : const int nVersion;
54 : :
55 : : public:
56 : 130050 : OverrideStream(Stream* stream_, int nVersion_) : stream{stream_}, nVersion{nVersion_} {}
57 : :
58 : : template<typename T>
59 : 187953 : OverrideStream<Stream>& operator<<(const T& obj)
60 : : {
61 : 187953 : ::Serialize(*this, obj);
62 : 187953 : return (*this);
63 : : }
64 : :
65 : : template<typename T>
66 : 440477 : OverrideStream<Stream>& operator>>(T&& obj)
67 : : {
68 : 440477 : ::Unserialize(*this, obj);
69 : 440477 : return (*this);
70 : : }
71 : :
72 : 564602 : void write(Span<const std::byte> src)
73 : : {
74 : 564602 : stream->write(src);
75 : 564602 : }
76 : :
77 : 10787220 : void read(Span<std::byte> dst)
78 : : {
79 : 10787220 : stream->read(dst);
80 : 10787220 : }
81 : :
82 : 162388 : int GetVersion() const { return nVersion; }
83 : 182972 : size_t size() const { return stream->size(); }
84 : : void ignore(size_t size) { return stream->ignore(size); }
85 : : };
86 : :
87 : : /* Minimal stream for overwriting and/or appending to an existing byte vector
88 : : *
89 : : * The referenced vector will grow as necessary
90 : : */
91 : : class CVectorWriter
92 : : {
93 : : public:
94 : :
95 : : /*
96 : : * @param[in] nVersionIn Serialization Version (including any flags)
97 : : * @param[in] vchDataIn Referenced byte vector to overwrite/append
98 : : * @param[in] nPosIn Starting position. Vector index where writes should start. The vector will initially
99 : : * grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size().
100 : : */
101 : 1634664 : CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn) : nVersion{nVersionIn}, vchData{vchDataIn}, nPos{nPosIn}
102 : : {
103 [ + - ]: 1634664 : if(nPos > vchData.size())
104 : 0 : vchData.resize(nPos);
105 : 1634664 : }
106 : : /*
107 : : * (other params same as above)
108 : : * @param[in] args A list of items to serialize starting at nPosIn.
109 : : */
110 : : template <typename... Args>
111 : 1606097 : CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter{nVersionIn, vchDataIn, nPosIn}
112 : : {
113 : 1606097 : ::SerializeMany(*this, std::forward<Args>(args)...);
114 : 1606097 : }
115 : 23901198 : void write(Span<const std::byte> src)
116 : : {
117 [ + - ]: 23901198 : assert(nPos <= vchData.size());
118 : 23901198 : size_t nOverwrite = std::min(src.size(), vchData.size() - nPos);
119 [ + - ]: 23901198 : if (nOverwrite) {
120 : 0 : memcpy(vchData.data() + nPos, src.data(), nOverwrite);
121 : 0 : }
122 [ + + ]: 23901198 : if (nOverwrite < src.size()) {
123 : 23893133 : vchData.insert(vchData.end(), UCharCast(src.data()) + nOverwrite, UCharCast(src.end()));
124 : 23893133 : }
125 : 23901198 : nPos += src.size();
126 : 23901198 : }
127 : : template<typename T>
128 : 7349865 : CVectorWriter& operator<<(const T& obj)
129 : : {
130 : 7349865 : ::Serialize(*this, obj);
131 : 7349865 : return (*this);
132 : : }
133 : 9570 : int GetVersion() const
134 : : {
135 : 9570 : return nVersion;
136 : : }
137 : :
138 : : private:
139 : : const int nVersion;
140 : : std::vector<unsigned char>& vchData;
141 : : size_t nPos;
142 : : };
143 : :
144 : : /** Minimal stream for reading from an existing byte array by Span.
145 : : */
146 : : class SpanReader
147 : : {
148 : : private:
149 : : const int m_version;
150 : : Span<const unsigned char> m_data;
151 : :
152 : : public:
153 : : /**
154 : : * @param[in] version Serialization Version (including any flags)
155 : : * @param[in] data Referenced byte vector to overwrite/append
156 : : */
157 : 577804 : SpanReader(int version, Span<const unsigned char> data)
158 : 577804 : : m_version{version}, m_data{data} {}
159 : :
160 : : template<typename T>
161 : 398558 : SpanReader& operator>>(T&& obj)
162 : : {
163 : 398558 : ::Unserialize(*this, obj);
164 : 398558 : return (*this);
165 : : }
166 : :
167 : 0 : int GetVersion() const { return m_version; }
168 : :
169 : : size_t size() const { return m_data.size(); }
170 : 88035 : bool empty() const { return m_data.empty(); }
171 : :
172 : 1038948 : void read(Span<std::byte> dst)
173 : : {
174 [ + - ]: 1038948 : if (dst.size() == 0) {
175 : 0 : return;
176 : : }
177 : :
178 : : // Read from the beginning of the buffer
179 [ + + ]: 1038948 : if (dst.size() > m_data.size()) {
180 [ + - ]: 7823 : throw std::ios_base::failure("SpanReader::read(): end of data");
181 : : }
182 : 1031125 : memcpy(dst.data(), m_data.data(), dst.size());
183 : 1031125 : m_data = m_data.subspan(dst.size());
184 : 1031125 : }
185 : : };
186 : :
187 : : /** Double ended buffer combining vector and stream-like interfaces.
188 : : *
189 : : * >> and << read and write unformatted data using the above serialization templates.
190 : : * Fills with data in linear time; some stringstream implementations take N^2 time.
191 : : */
192 : : class DataStream
193 : : {
194 : : protected:
195 : : using vector_type = SerializeData;
196 : : vector_type vch;
197 : 13441982 : vector_type::size_type m_read_pos{0};
198 : :
199 : : public:
200 : : typedef vector_type::allocator_type allocator_type;
201 : : typedef vector_type::size_type size_type;
202 : : typedef vector_type::difference_type difference_type;
203 : : typedef vector_type::reference reference;
204 : : typedef vector_type::const_reference const_reference;
205 : : typedef vector_type::value_type value_type;
206 : : typedef vector_type::iterator iterator;
207 : : typedef vector_type::const_iterator const_iterator;
208 : : typedef vector_type::reverse_iterator reverse_iterator;
209 : :
210 : 10918356 : explicit DataStream() {}
211 : 1921 : explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
212 : 15965608 : explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
213 : :
214 : 468 : std::string str() const
215 : : {
216 [ + - ]: 468 : return std::string{UCharCast(data()), UCharCast(data() + size())};
217 : 0 : }
218 : :
219 : :
220 : : //
221 : : // Vector subset
222 : : //
223 : : const_iterator begin() const { return vch.begin() + m_read_pos; }
224 : 34650 : iterator begin() { return vch.begin() + m_read_pos; }
225 : : const_iterator end() const { return vch.end(); }
226 : 17325 : iterator end() { return vch.end(); }
227 : 12701439 : size_type size() const { return vch.size() - m_read_pos; }
228 : 1159563 : bool empty() const { return vch.size() == m_read_pos; }
229 : 2596282 : void resize(size_type n, value_type c = value_type{}) { vch.resize(n + m_read_pos, c); }
230 : 1377355 : void reserve(size_type n) { vch.reserve(n + m_read_pos); }
231 : : const_reference operator[](size_type pos) const { return vch[pos + m_read_pos]; }
232 : 14217187 : reference operator[](size_type pos) { return vch[pos + m_read_pos]; }
233 : 3383810 : void clear() { vch.clear(); m_read_pos = 0; }
234 : 5334603 : value_type* data() { return vch.data() + m_read_pos; }
235 : 936 : const value_type* data() const { return vch.data() + m_read_pos; }
236 : :
237 : : inline void Compact()
238 : : {
239 : : vch.erase(vch.begin(), vch.begin() + m_read_pos);
240 : : m_read_pos = 0;
241 : : }
242 : :
243 : : bool Rewind(std::optional<size_type> n = std::nullopt)
244 : : {
245 : : // Total rewind if no size is passed
246 : : if (!n) {
247 : : m_read_pos = 0;
248 : : return true;
249 : : }
250 : : // Rewind by n characters if the buffer hasn't been compacted yet
251 : : if (*n > m_read_pos)
252 : : return false;
253 : : m_read_pos -= *n;
254 : : return true;
255 : : }
256 : :
257 : :
258 : : //
259 : : // Stream subset
260 : : //
261 : 0 : bool eof() const { return size() == 0; }
262 : 17036 : int in_avail() const { return size(); }
263 : :
264 : 228746937 : void read(Span<value_type> dst)
265 : : {
266 [ + + ]: 228746937 : if (dst.size() == 0) return;
267 : :
268 : : // Read from the beginning of the buffer
269 : 226346040 : auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
270 [ + + ]: 226346040 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
271 [ + - ]: 584971 : throw std::ios_base::failure("DataStream::read(): end of data");
272 : : }
273 : 225761069 : memcpy(dst.data(), &vch[m_read_pos], dst.size());
274 [ + + ]: 225761069 : if (next_read_pos.value() == vch.size()) {
275 : 12857539 : m_read_pos = 0;
276 : 12857539 : vch.clear();
277 : 12857539 : return;
278 : : }
279 : 212903530 : m_read_pos = next_read_pos.value();
280 : 228161966 : }
281 : :
282 : 382351 : void ignore(size_t num_ignore)
283 : : {
284 : : // Ignore from the beginning of the buffer
285 : 382351 : auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
286 [ + + ]: 382351 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
287 [ + - ]: 9530 : throw std::ios_base::failure("DataStream::ignore(): end of data");
288 : : }
289 [ + + ]: 372821 : if (next_read_pos.value() == vch.size()) {
290 : 1398 : m_read_pos = 0;
291 : 1398 : vch.clear();
292 : 1398 : return;
293 : : }
294 : 371423 : m_read_pos = next_read_pos.value();
295 : 372821 : }
296 : :
297 : 89741685 : void write(Span<const value_type> src)
298 : : {
299 : : // Write to the end of the buffer
300 : 89741685 : vch.insert(vch.end(), src.begin(), src.end());
301 : 89741685 : }
302 : :
303 : : template<typename T>
304 : 11341978 : DataStream& operator<<(const T& obj)
305 : : {
306 : 11341978 : ::Serialize(*this, obj);
307 : 11341978 : return (*this);
308 : : }
309 : :
310 : : template<typename T>
311 : 21595078 : DataStream& operator>>(T&& obj)
312 : : {
313 : 21595078 : ::Unserialize(*this, obj);
314 : 21595078 : return (*this);
315 : : }
316 : :
317 : : /**
318 : : * XOR the contents of this stream with a certain key.
319 : : *
320 : : * @param[in] key The key used to XOR the data in this stream.
321 : : */
322 : 3852713 : void Xor(const std::vector<unsigned char>& key)
323 : : {
324 : 3852713 : util::Xor(MakeWritableByteSpan(*this), MakeByteSpan(key));
325 : 3852713 : }
326 : : };
327 : :
328 : : class CDataStream : public DataStream
329 : : {
330 : : private:
331 : : int nType;
332 : : int nVersion;
333 : :
334 : : public:
335 : 75216 : explicit CDataStream(int nTypeIn, int nVersionIn)
336 : 75216 : : nType{nTypeIn},
337 : 75216 : nVersion{nVersionIn} {}
338 : :
339 : 1033910 : explicit CDataStream(Span<const uint8_t> sp, int type, int version) : CDataStream{AsBytes(sp), type, version} {}
340 : 1044206 : explicit CDataStream(Span<const value_type> sp, int nTypeIn, int nVersionIn)
341 : 1044206 : : DataStream{sp},
342 : 1044206 : nType{nTypeIn},
343 : 1044206 : nVersion{nVersionIn} {}
344 : :
345 : : int GetType() const { return nType; }
346 : 1006352 : void SetVersion(int n) { nVersion = n; }
347 : 3169624 : int GetVersion() const { return nVersion; }
348 : :
349 : : template <typename T>
350 : 7757406 : CDataStream& operator<<(const T& obj)
351 : : {
352 : 7757406 : ::Serialize(*this, obj);
353 : 7757406 : return *this;
354 : : }
355 : :
356 : : template <typename T>
357 : 25076566 : CDataStream& operator>>(T&& obj)
358 : : {
359 : 25076566 : ::Unserialize(*this, obj);
360 : 25076566 : return *this;
361 : : }
362 : : };
363 : :
364 : : template <typename IStream>
365 : : class BitStreamReader
366 : : {
367 : : private:
368 : : IStream& m_istream;
369 : :
370 : : /// Buffered byte read in from the input stream. A new byte is read into the
371 : : /// buffer when m_offset reaches 8.
372 : 635 : uint8_t m_buffer{0};
373 : :
374 : : /// Number of high order bits in m_buffer already returned by previous
375 : : /// Read() calls. The next bit to be returned is at this offset from the
376 : : /// most significant bit position.
377 : 635 : int m_offset{8};
378 : :
379 : : public:
380 : 1270 : explicit BitStreamReader(IStream& istream) : m_istream(istream) {}
381 : :
382 : : /** Read the specified number of bits from the stream. The data is returned
383 : : * in the nbits least significant bits of a 64-bit uint.
384 : : */
385 : 134020 : uint64_t Read(int nbits) {
386 [ + - ]: 134020 : if (nbits < 0 || nbits > 64) {
387 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
388 : : }
389 : :
390 : 134020 : uint64_t data = 0;
391 [ + + ]: 337140 : while (nbits > 0) {
392 [ + + ]: 203120 : if (m_offset == 8) {
393 : 95484 : m_istream >> m_buffer;
394 : 95484 : m_offset = 0;
395 : 95484 : }
396 : :
397 : 203120 : int bits = std::min(8 - m_offset, nbits);
398 : 203120 : data <<= bits;
399 : 203120 : data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
400 : 203120 : m_offset += bits;
401 : 203120 : nbits -= bits;
402 : : }
403 : 134020 : return data;
404 : 0 : }
405 : : };
406 : :
407 : : template <typename OStream>
408 : : class BitStreamWriter
409 : : {
410 : : private:
411 : : OStream& m_ostream;
412 : :
413 : : /// Buffered byte waiting to be written to the output stream. The byte is
414 : : /// written buffer when m_offset reaches 8 or Flush() is called.
415 : 161 : uint8_t m_buffer{0};
416 : :
417 : : /// Number of high order bits in m_buffer already written by previous
418 : : /// Write() calls and not yet flushed to the stream. The next bit to be
419 : : /// written to is at this offset from the most significant bit position.
420 : 161 : int m_offset{0};
421 : :
422 : : public:
423 : 322 : explicit BitStreamWriter(OStream& ostream) : m_ostream(ostream) {}
424 : :
425 : 161 : ~BitStreamWriter()
426 : : {
427 [ + - ]: 161 : Flush();
428 : 161 : }
429 : :
430 : : /** Write the nbits least significant bits of a 64-bit int to the output
431 : : * stream. Data is buffered until it completes an octet.
432 : : */
433 : 43666 : void Write(uint64_t data, int nbits) {
434 [ + - ]: 43666 : if (nbits < 0 || nbits > 64) {
435 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
436 : : }
437 : :
438 [ + + ]: 127826 : while (nbits > 0) {
439 : 84160 : int bits = std::min(8 - m_offset, nbits);
440 : 84160 : m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
441 : 84160 : m_offset += bits;
442 : 84160 : nbits -= bits;
443 : :
444 [ + + ]: 84160 : if (m_offset == 8) {
445 : 45839 : Flush();
446 : 45839 : }
447 : : }
448 : 43666 : }
449 : :
450 : : /** Flush any unwritten bits to the output stream, padding with 0's to the
451 : : * next byte boundary.
452 : : */
453 : 46161 : void Flush() {
454 [ + + ]: 46161 : if (m_offset == 0) {
455 : 204 : return;
456 : : }
457 : :
458 : 45957 : m_ostream << m_buffer;
459 : 45957 : m_buffer = 0;
460 : 45957 : m_offset = 0;
461 : 46161 : }
462 : : };
463 : :
464 : : /** Non-refcounted RAII wrapper for FILE*
465 : : *
466 : : * Will automatically close the file when it goes out of scope if not null.
467 : : * If you're returning the file pointer, return file.release().
468 : : * If you need to close the file early, use file.fclose() instead of fclose(file).
469 : : */
470 : : class AutoFile
471 : : {
472 : : protected:
473 : : std::FILE* m_file;
474 : : const std::vector<std::byte> m_xor;
475 : :
476 : : public:
477 : 140270 : explicit AutoFile(std::FILE* file, std::vector<std::byte> data_xor={}) : m_file{file}, m_xor{std::move(data_xor)} {}
478 : :
479 [ + - ]: 140270 : ~AutoFile() { fclose(); }
480 : :
481 : : // Disallow copies
482 : : AutoFile(const AutoFile&) = delete;
483 : : AutoFile& operator=(const AutoFile&) = delete;
484 : :
485 : 25619 : bool feof() const { return std::feof(m_file); }
486 : :
487 : 140857 : int fclose()
488 : : {
489 [ + + ]: 140857 : if (auto rel{release()}) return std::fclose(rel);
490 : 10603 : return 0;
491 : 140857 : }
492 : :
493 : : /** Get wrapped FILE* with transfer of ownership.
494 : : * @note This will invalidate the AutoFile object, and makes it the responsibility of the caller
495 : : * of this function to clean up the returned FILE*.
496 : : */
497 : 140896 : std::FILE* release()
498 : : {
499 : 140896 : std::FILE* ret{m_file};
500 : 140896 : m_file = nullptr;
501 : 140896 : return ret;
502 : : }
503 : :
504 : : /** Get wrapped FILE* without transfer of ownership.
505 : : * @note Ownership of the FILE* will remain with this class. Use this only if the scope of the
506 : : * AutoFile outlives use of the passed pointer.
507 : : */
508 : 86055 : std::FILE* Get() const { return m_file; }
509 : :
510 : : /** Return true if the wrapped FILE* is nullptr, false otherwise.
511 : : */
512 : 138261 : bool IsNull() const { return m_file == nullptr; }
513 : :
514 : : /** Implementation detail, only used internally. */
515 : : std::size_t detail_fread(Span<std::byte> dst);
516 : :
517 : : //
518 : : // Stream subset
519 : : //
520 : : void read(Span<std::byte> dst);
521 : : void ignore(size_t nSize);
522 : : void write(Span<const std::byte> src);
523 : :
524 : : template <typename T>
525 : 220335 : AutoFile& operator<<(const T& obj)
526 : : {
527 : 220335 : ::Serialize(*this, obj);
528 : 220335 : return *this;
529 : : }
530 : :
531 : : template <typename T>
532 : 1163413 : AutoFile& operator>>(T&& obj)
533 : : {
534 : 1163413 : ::Unserialize(*this, obj);
535 : 1163413 : return *this;
536 : : }
537 : : };
538 : :
539 : : class CAutoFile : public AutoFile
540 : : {
541 : : private:
542 : : const int nVersion;
543 : :
544 : : public:
545 [ + - ]: 137352 : explicit CAutoFile(std::FILE* file, int version, std::vector<std::byte> data_xor = {}) : AutoFile{file, std::move(data_xor)}, nVersion{version} {}
546 : 300057 : int GetVersion() const { return nVersion; }
547 : :
548 : : template<typename T>
549 : 843803 : CAutoFile& operator<<(const T& obj)
550 : : {
551 : 843803 : ::Serialize(*this, obj);
552 : 843803 : return (*this);
553 : : }
554 : :
555 : : template<typename T>
556 : 1085094 : CAutoFile& operator>>(T&& obj)
557 : : {
558 : 1085094 : ::Unserialize(*this, obj);
559 : 1085094 : return (*this);
560 : : }
561 : : };
562 : :
563 : : /** Wrapper around a CAutoFile& that implements a ring buffer to
564 : : * deserialize from. It guarantees the ability to rewind a given number of bytes.
565 : : *
566 : : * Will automatically close the file when it goes out of scope if not null.
567 : : * If you need to close the file early, use file.fclose() instead of fclose(file).
568 : : */
569 : : class BufferedFile
570 : : {
571 : : private:
572 : : CAutoFile& m_src;
573 : 419 : uint64_t nSrcPos{0}; //!< how many bytes have been read from source
574 : 419 : uint64_t m_read_pos{0}; //!< how many bytes have been read from this
575 : : uint64_t nReadLimit; //!< up to which position we're allowed to read
576 : : uint64_t nRewind; //!< how many bytes we guarantee to rewind
577 : : std::vector<std::byte> vchBuf; //!< the buffer
578 : :
579 : : //! read data from the source to fill the buffer
580 : 33308 : bool Fill() {
581 : 33308 : unsigned int pos = nSrcPos % vchBuf.size();
582 : 33308 : unsigned int readNow = vchBuf.size() - pos;
583 : 33308 : unsigned int nAvail = vchBuf.size() - (nSrcPos - m_read_pos) - nRewind;
584 [ + + ]: 33308 : if (nAvail < readNow)
585 : 32529 : readNow = nAvail;
586 [ + - ]: 33308 : if (readNow == 0)
587 : 0 : return false;
588 : 33308 : size_t nBytes{m_src.detail_fread(Span{vchBuf}.subspan(pos, readNow))};
589 [ + + ]: 33308 : if (nBytes == 0) {
590 [ + - + - ]: 21068 : throw std::ios_base::failure{m_src.feof() ? "BufferedFile::Fill: end of file" : "BufferedFile::Fill: fread failed"};
591 : : }
592 : 12240 : nSrcPos += nBytes;
593 : 12240 : return true;
594 : 12240 : }
595 : :
596 : : //! Advance the stream's read pointer (m_read_pos) by up to 'length' bytes,
597 : : //! filling the buffer from the file so that at least one byte is available.
598 : : //! Return a pointer to the available buffer data and the number of bytes
599 : : //! (which may be less than the requested length) that may be accessed
600 : : //! beginning at that pointer.
601 : 2708935 : std::pair<std::byte*, size_t> AdvanceStream(size_t length)
602 : : {
603 [ + - ]: 2708935 : assert(m_read_pos <= nSrcPos);
604 [ + + ]: 2708935 : if (m_read_pos + length > nReadLimit) {
605 [ + - ]: 10379 : throw std::ios_base::failure("Attempt to position past buffer limit");
606 : : }
607 : : // If there are no bytes available, read from the file.
608 [ + + - + ]: 2698556 : if (m_read_pos == nSrcPos && length > 0) Fill();
609 : :
610 : 2698556 : size_t buffer_offset{static_cast<size_t>(m_read_pos % vchBuf.size())};
611 : 2698556 : size_t buffer_available{static_cast<size_t>(vchBuf.size() - buffer_offset)};
612 : 2698556 : size_t bytes_until_source_pos{static_cast<size_t>(nSrcPos - m_read_pos)};
613 : 2698556 : size_t advance{std::min({length, buffer_available, bytes_until_source_pos})};
614 : 2698556 : m_read_pos += advance;
615 : 2698556 : return std::make_pair(&vchBuf[buffer_offset], advance);
616 : 0 : }
617 : :
618 : : public:
619 : 419 : BufferedFile(CAutoFile& file, uint64_t nBufSize, uint64_t nRewindIn)
620 [ + - + - ]: 840 : : m_src{file}, nReadLimit{std::numeric_limits<uint64_t>::max()}, nRewind{nRewindIn}, vchBuf(nBufSize, std::byte{0})
621 : : {
622 [ + + ]: 419 : if (nRewindIn >= nBufSize)
623 [ + - - + ]: 2 : throw std::ios_base::failure("Rewind limit must be less than buffer size");
624 : 419 : }
625 : :
626 : 50925 : int GetVersion() const { return m_src.GetVersion(); }
627 : :
628 : : //! check whether we're at the end of the source file
629 : 928775 : bool eof() const {
630 [ + + ]: 928775 : return m_read_pos == nSrcPos && m_src.feof();
631 : : }
632 : :
633 : : //! read a number of bytes
634 : 2559627 : void read(Span<std::byte> dst)
635 : : {
636 [ + + ]: 5129683 : while (dst.size() > 0) {
637 : 10280224 : auto [buffer_pointer, length]{AdvanceStream(dst.size())};
638 : 7710168 : memcpy(dst.data(), buffer_pointer, length);
639 : 2570056 : dst = dst.subspan(length);
640 : : }
641 : 2559627 : }
642 : :
643 : : //! Move the read position ahead in the stream to the given position.
644 : : //! Use SetPos() to back up in the stream, not SkipTo().
645 : 137922 : void SkipTo(const uint64_t file_pos)
646 : : {
647 [ + - ]: 137922 : assert(file_pos >= m_read_pos);
648 [ + + ]: 276801 : while (m_read_pos < file_pos) AdvanceStream(file_pos - m_read_pos);
649 : 137922 : }
650 : :
651 : : //! return the current reading position
652 : 1100976 : uint64_t GetPos() const {
653 : 1100976 : return m_read_pos;
654 : : }
655 : :
656 : : //! rewind to a given reading position
657 : 976747 : bool SetPos(uint64_t nPos) {
658 : 976747 : size_t bufsize = vchBuf.size();
659 [ + + ]: 976747 : if (nPos + bufsize < nSrcPos) {
660 : : // rewinding too far, rewind as far as possible
661 : 29 : m_read_pos = nSrcPos - bufsize;
662 : 29 : return false;
663 : : }
664 [ + + ]: 976718 : if (nPos > nSrcPos) {
665 : : // can't go this far forward, go as far as possible
666 : 4006 : m_read_pos = nSrcPos;
667 : 4006 : return false;
668 : : }
669 : 972712 : m_read_pos = nPos;
670 : 972712 : return true;
671 : 976747 : }
672 : :
673 : : //! prevent reading beyond a certain position
674 : : //! no argument removes the limit
675 : 1066620 : bool SetLimit(uint64_t nPos = std::numeric_limits<uint64_t>::max()) {
676 [ + + ]: 1066620 : if (nPos < m_read_pos)
677 : 8 : return false;
678 : 1066612 : nReadLimit = nPos;
679 : 1066612 : return true;
680 : 1066620 : }
681 : :
682 : : template<typename T>
683 : 1498537 : BufferedFile& operator>>(T&& obj) {
684 : 1498537 : ::Unserialize(*this, obj);
685 : 1498537 : return (*this);
686 : : }
687 : :
688 : : //! search for a given byte in the stream, and remain positioned on it
689 : 928435 : void FindByte(std::byte byte)
690 : : {
691 : : // For best performance, avoid mod operation within the loop.
692 : 928435 : size_t buf_offset{size_t(m_read_pos % uint64_t(vchBuf.size()))};
693 : 929055 : while (true) {
694 [ + + ]: 929055 : if (m_read_pos == nSrcPos) {
695 : : // No more bytes available; read from the file into the buffer,
696 : : // setting nSrcPos to one beyond the end of the new data.
697 : : // Throws exception if end-of-file reached.
698 : 1373 : Fill();
699 : 1373 : }
700 : 929055 : const size_t len{std::min<size_t>(vchBuf.size() - buf_offset, nSrcPos - m_read_pos)};
701 : 929055 : const auto it_start{vchBuf.begin() + buf_offset};
702 : 929055 : const auto it_find{std::find(it_start, it_start + len, byte)};
703 : 929055 : const size_t inc{size_t(std::distance(it_start, it_find))};
704 : 929055 : m_read_pos += inc;
705 [ + + ]: 929055 : if (inc < len) break;
706 : 620 : buf_offset += inc;
707 [ + - ]: 620 : if (buf_offset >= vchBuf.size()) buf_offset = 0;
708 : : }
709 : 928435 : }
710 : : };
711 : :
712 : : #endif // BITCOIN_STREAMS_H
|
