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 : 7384856 : inline void Xor(Span<std::byte> write, Span<const std::byte> key, size_t key_offset = 0)
29 : : {
30 [ - + ]: 7384856 : if (key.size() == 0) {
31 : 0 : return;
32 : : }
33 : 7384856 : key_offset %= key.size();
34 : :
35 [ + + ]: 81457070 : for (size_t i = 0, j = key_offset; i != write.size(); i++) {
36 : 74072214 : 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 [ + + ]: 74072214 : if (j == key.size())
43 : 5703006 : j = 0;
44 : 74072214 : }
45 : 7384856 : }
46 : : } // namespace util
47 : :
48 : : /* Minimal stream for overwriting and/or appending to an existing byte vector
49 : : *
50 : : * The referenced vector will grow as necessary
51 : : */
52 : : class VectorWriter
53 : : {
54 : : public:
55 : : /*
56 : : * @param[in] vchDataIn Referenced byte vector to overwrite/append
57 : : * @param[in] nPosIn Starting position. Vector index where writes should start. The vector will initially
58 : : * grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size().
59 : : */
60 : 559165 : VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}
61 : : {
62 [ + - ]: 559165 : if(nPos > vchData.size())
63 : 0 : vchData.resize(nPos);
64 : 559165 : }
65 : : /*
66 : : * (other params same as above)
67 : : * @param[in] args A list of items to serialize starting at nPosIn.
68 : : */
69 : : template <typename... Args>
70 : 498300 : VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : VectorWriter{vchDataIn, nPosIn}
71 : : {
72 : 498300 : ::SerializeMany(*this, std::forward<Args>(args)...);
73 : 498300 : }
74 : 4389686 : void write(Span<const std::byte> src)
75 : : {
76 [ + - ]: 4389686 : assert(nPos <= vchData.size());
77 : 4389686 : size_t nOverwrite = std::min(src.size(), vchData.size() - nPos);
78 [ + - ]: 4389686 : if (nOverwrite) {
79 : 0 : memcpy(vchData.data() + nPos, src.data(), nOverwrite);
80 : 0 : }
81 [ + + ]: 4389686 : if (nOverwrite < src.size()) {
82 : 4368684 : vchData.insert(vchData.end(), UCharCast(src.data()) + nOverwrite, UCharCast(src.end()));
83 : 4368684 : }
84 : 4389686 : nPos += src.size();
85 : 4389686 : }
86 : : template <typename T>
87 : 845072 : VectorWriter& operator<<(const T& obj)
88 : : {
89 : 845072 : ::Serialize(*this, obj);
90 : 845072 : return (*this);
91 : : }
92 : :
93 : : private:
94 : : std::vector<unsigned char>& vchData;
95 : : size_t nPos;
96 : : };
97 : :
98 : : /** Minimal stream for reading from an existing byte array by Span.
99 : : */
100 : : class SpanReader
101 : : {
102 : : private:
103 : : Span<const unsigned char> m_data;
104 : :
105 : : public:
106 : : /**
107 : : * @param[in] data Referenced byte vector to overwrite/append
108 : : */
109 : 844700 : explicit SpanReader(Span<const unsigned char> data) : m_data{data} {}
110 : :
111 : : template<typename T>
112 : 977204 : SpanReader& operator>>(T&& obj)
113 : : {
114 : 977204 : ::Unserialize(*this, obj);
115 : 977204 : return (*this);
116 : : }
117 : :
118 : : size_t size() const { return m_data.size(); }
119 : 184669 : bool empty() const { return m_data.empty(); }
120 : :
121 : 1952980 : void read(Span<std::byte> dst)
122 : : {
123 [ + - ]: 1952980 : if (dst.size() == 0) {
124 : 0 : return;
125 : : }
126 : :
127 : : // Read from the beginning of the buffer
128 [ + + ]: 1952980 : if (dst.size() > m_data.size()) {
129 [ + - - + : 12487 : throw std::ios_base::failure("SpanReader::read(): end of data");
+ - ]
130 : : }
131 : 1940493 : memcpy(dst.data(), m_data.data(), dst.size());
132 : 1940493 : m_data = m_data.subspan(dst.size());
133 : 1952980 : }
134 : :
135 : : void ignore(size_t n)
136 : : {
137 : : m_data = m_data.subspan(n);
138 : : }
139 : : };
140 : :
141 : : /** Double ended buffer combining vector and stream-like interfaces.
142 : : *
143 : : * >> and << read and write unformatted data using the above serialization templates.
144 : : * Fills with data in linear time; some stringstream implementations take N^2 time.
145 : : */
146 : : class DataStream
147 : : {
148 : : protected:
149 : : using vector_type = SerializeData;
150 : : vector_type vch;
151 : 38197298 : vector_type::size_type m_read_pos{0};
152 : :
153 : : public:
154 : : typedef vector_type::allocator_type allocator_type;
155 : : typedef vector_type::size_type size_type;
156 : : typedef vector_type::difference_type difference_type;
157 : : typedef vector_type::reference reference;
158 : : typedef vector_type::const_reference const_reference;
159 : : typedef vector_type::value_type value_type;
160 : : typedef vector_type::iterator iterator;
161 : : typedef vector_type::const_iterator const_iterator;
162 : : typedef vector_type::reverse_iterator reverse_iterator;
163 : :
164 : 47527904 : explicit DataStream() {}
165 : 1527408 : explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
166 : 28866692 : explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
167 : :
168 : 1152 : std::string str() const
169 : : {
170 [ + - ]: 1152 : return std::string{UCharCast(data()), UCharCast(data() + size())};
171 : 0 : }
172 : :
173 : :
174 : : //
175 : : // Vector subset
176 : : //
177 : : const_iterator begin() const { return vch.begin() + m_read_pos; }
178 : 6305794 : iterator begin() { return vch.begin() + m_read_pos; }
179 : : const_iterator end() const { return vch.end(); }
180 : 6303151 : iterator end() { return vch.end(); }
181 : 16371948 : size_type size() const { return vch.size() - m_read_pos; }
182 : 1824082 : bool empty() const { return vch.size() == m_read_pos; }
183 : 527039 : void resize(size_type n, value_type c = value_type{}) { vch.resize(n + m_read_pos, c); }
184 : 10029933 : void reserve(size_type n) { vch.reserve(n + m_read_pos); }
185 : : const_reference operator[](size_type pos) const { return vch[pos + m_read_pos]; }
186 : 9424454 : reference operator[](size_type pos) { return vch[pos + m_read_pos]; }
187 : 2411959 : void clear() { vch.clear(); m_read_pos = 0; }
188 : 11370935 : value_type* data() { return vch.data() + m_read_pos; }
189 : 2304 : const value_type* data() const { return vch.data() + m_read_pos; }
190 : :
191 : : inline void Compact()
192 : : {
193 : : vch.erase(vch.begin(), vch.begin() + m_read_pos);
194 : : m_read_pos = 0;
195 : : }
196 : :
197 : : bool Rewind(std::optional<size_type> n = std::nullopt)
198 : : {
199 : : // Total rewind if no size is passed
200 : : if (!n) {
201 : : m_read_pos = 0;
202 : : return true;
203 : : }
204 : : // Rewind by n characters if the buffer hasn't been compacted yet
205 : : if (*n > m_read_pos)
206 : : return false;
207 : : m_read_pos -= *n;
208 : : return true;
209 : : }
210 : :
211 : :
212 : : //
213 : : // Stream subset
214 : : //
215 : 0 : bool eof() const { return size() == 0; }
216 : 623 : int in_avail() const { return size(); }
217 : :
218 : 429337568 : void read(Span<value_type> dst)
219 : : {
220 [ + + ]: 429337568 : if (dst.size() == 0) return;
221 : :
222 : : // Read from the beginning of the buffer
223 : 424975616 : auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
224 [ + + ]: 424975616 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
225 [ + - + - ]: 278775 : throw std::ios_base::failure("DataStream::read(): end of data");
226 : : }
227 : 424696841 : memcpy(dst.data(), &vch[m_read_pos], dst.size());
228 [ + + ]: 424696841 : if (next_read_pos.value() == vch.size()) {
229 : 28112599 : m_read_pos = 0;
230 : 28112599 : vch.clear();
231 : 28112599 : return;
232 : : }
233 : 396584242 : m_read_pos = next_read_pos.value();
234 : 429337568 : }
235 : :
236 : 623920 : void ignore(size_t num_ignore)
237 : : {
238 : : // Ignore from the beginning of the buffer
239 : 623920 : auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
240 [ + + ]: 623920 : if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
241 [ + - + - ]: 11096 : throw std::ios_base::failure("DataStream::ignore(): end of data");
242 : : }
243 [ + + ]: 612824 : if (next_read_pos.value() == vch.size()) {
244 : 1378 : m_read_pos = 0;
245 : 1378 : vch.clear();
246 : 1378 : return;
247 : : }
248 : 611446 : m_read_pos = next_read_pos.value();
249 : 623920 : }
250 : :
251 : 234571419 : void write(Span<const value_type> src)
252 : : {
253 : : // Write to the end of the buffer
254 : 234571419 : vch.insert(vch.end(), src.begin(), src.end());
255 : 234571419 : }
256 : :
257 : : template<typename T>
258 : 58920677 : DataStream& operator<<(const T& obj)
259 : : {
260 : 58920677 : ::Serialize(*this, obj);
261 : 58920677 : return (*this);
262 : : }
263 : :
264 : : template<typename T>
265 : 70867381 : DataStream& operator>>(T&& obj)
266 : : {
267 : 70867381 : ::Unserialize(*this, obj);
268 : 70867381 : return (*this);
269 : : }
270 : :
271 : : /**
272 : : * XOR the contents of this stream with a certain key.
273 : : *
274 : : * @param[in] key The key used to XOR the data in this stream.
275 : : */
276 : 7353524 : void Xor(const std::vector<unsigned char>& key)
277 : : {
278 : 7353524 : util::Xor(MakeWritableByteSpan(*this), MakeByteSpan(key));
279 : 7353524 : }
280 : : };
281 : :
282 : : template <typename IStream>
283 : : class BitStreamReader
284 : : {
285 : : private:
286 : : IStream& m_istream;
287 : :
288 : : /// Buffered byte read in from the input stream. A new byte is read into the
289 : : /// buffer when m_offset reaches 8.
290 : 1383 : uint8_t m_buffer{0};
291 : :
292 : : /// Number of high order bits in m_buffer already returned by previous
293 : : /// Read() calls. The next bit to be returned is at this offset from the
294 : : /// most significant bit position.
295 : 1383 : int m_offset{8};
296 : :
297 : : public:
298 : 2766 : explicit BitStreamReader(IStream& istream) : m_istream(istream) {}
299 : :
300 : : /** Read the specified number of bits from the stream. The data is returned
301 : : * in the nbits least significant bits of a 64-bit uint.
302 : : */
303 : 432636 : uint64_t Read(int nbits) {
304 [ + - ]: 432636 : if (nbits < 0 || nbits > 64) {
305 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
306 : : }
307 : :
308 : 432636 : uint64_t data = 0;
309 [ + + ]: 1135951 : while (nbits > 0) {
310 [ + + ]: 703315 : if (m_offset == 8) {
311 : 362834 : m_istream >> m_buffer;
312 : 362834 : m_offset = 0;
313 : 362834 : }
314 : :
315 : 703315 : int bits = std::min(8 - m_offset, nbits);
316 : 703315 : data <<= bits;
317 : 703315 : data |= static_cast<uint8_t>(m_buffer << m_offset) >> (8 - bits);
318 : 703315 : m_offset += bits;
319 : 703315 : nbits -= bits;
320 : 703315 : }
321 : 865272 : return data;
322 : 432636 : }
323 : : };
324 : :
325 : : template <typename OStream>
326 : : class BitStreamWriter
327 : : {
328 : : private:
329 : : OStream& m_ostream;
330 : :
331 : : /// Buffered byte waiting to be written to the output stream. The byte is
332 : : /// written buffer when m_offset reaches 8 or Flush() is called.
333 : 255 : uint8_t m_buffer{0};
334 : :
335 : : /// Number of high order bits in m_buffer already written by previous
336 : : /// Write() calls and not yet flushed to the stream. The next bit to be
337 : : /// written to is at this offset from the most significant bit position.
338 : 255 : int m_offset{0};
339 : :
340 : : public:
341 : 510 : explicit BitStreamWriter(OStream& ostream) : m_ostream(ostream) {}
342 : :
343 : 255 : ~BitStreamWriter()
344 : : {
345 [ + - ]: 255 : Flush();
346 : 255 : }
347 : :
348 : : /** Write the nbits least significant bits of a 64-bit int to the output
349 : : * stream. Data is buffered until it completes an octet.
350 : : */
351 : 76344 : void Write(uint64_t data, int nbits) {
352 [ + - ]: 76344 : if (nbits < 0 || nbits > 64) {
353 [ # # ]: 0 : throw std::out_of_range("nbits must be between 0 and 64");
354 : : }
355 : :
356 [ + + ]: 223236 : while (nbits > 0) {
357 : 146892 : int bits = std::min(8 - m_offset, nbits);
358 : 146892 : m_buffer |= (data << (64 - nbits)) >> (64 - 8 + m_offset);
359 : 146892 : m_offset += bits;
360 : 146892 : nbits -= bits;
361 : :
362 [ + + ]: 146892 : if (m_offset == 8) {
363 : 80042 : Flush();
364 : 80042 : }
365 : 146892 : }
366 : 76344 : }
367 : :
368 : : /** Flush any unwritten bits to the output stream, padding with 0's to the
369 : : * next byte boundary.
370 : : */
371 : 80552 : void Flush() {
372 [ + + ]: 80552 : if (m_offset == 0) {
373 : 314 : return;
374 : : }
375 : :
376 : 80238 : m_ostream << m_buffer;
377 : 80238 : m_buffer = 0;
378 : 80238 : m_offset = 0;
379 : 80552 : }
380 : : };
381 : :
382 : : /** Non-refcounted RAII wrapper for FILE*
383 : : *
384 : : * Will automatically close the file when it goes out of scope if not null.
385 : : * If you're returning the file pointer, return file.release().
386 : : * If you need to close the file early, use file.fclose() instead of fclose(file).
387 : : */
388 : : class AutoFile
389 : : {
390 : : protected:
391 : : std::FILE* m_file;
392 : : std::vector<std::byte> m_xor;
393 : :
394 : : public:
395 : 210569 : explicit AutoFile(std::FILE* file, std::vector<std::byte> data_xor={}) : m_file{file}, m_xor{std::move(data_xor)} {}
396 : :
397 [ + - ]: 210569 : ~AutoFile() { fclose(); }
398 : :
399 : : // Disallow copies
400 : : AutoFile(const AutoFile&) = delete;
401 : : AutoFile& operator=(const AutoFile&) = delete;
402 : :
403 : 8695 : bool feof() const { return std::feof(m_file); }
404 : :
405 : 211020 : int fclose()
406 : : {
407 [ + + - + : 211020 : if (auto rel{release()}) return std::fclose(rel);
+ ]
408 : 22320 : return 0;
409 : 211020 : }
410 : :
411 : : /** Get wrapped FILE* with transfer of ownership.
412 : : * @note This will invalidate the AutoFile object, and makes it the responsibility of the caller
413 : : * of this function to clean up the returned FILE*.
414 : : */
415 : 211058 : std::FILE* release()
416 : : {
417 : 211058 : std::FILE* ret{m_file};
418 : 211058 : m_file = nullptr;
419 : 422116 : return ret;
420 : 211058 : }
421 : :
422 : : /** Get wrapped FILE* without transfer of ownership.
423 : : * @note Ownership of the FILE* will remain with this class. Use this only if the scope of the
424 : : * AutoFile outlives use of the passed pointer.
425 : : */
426 : 176419 : std::FILE* Get() const { return m_file; }
427 : :
428 : : /** Return true if the wrapped FILE* is nullptr, false otherwise.
429 : : */
430 : 206653 : bool IsNull() const { return m_file == nullptr; }
431 : :
432 : : /** Continue with a different XOR key */
433 : 1363 : void SetXor(std::vector<std::byte> data_xor) { m_xor = data_xor; }
434 : :
435 : : /** Implementation detail, only used internally. */
436 : : std::size_t detail_fread(Span<std::byte> dst);
437 : :
438 : : void seek(int64_t offset, int origin);
439 : : int64_t tell();
440 : :
441 : : //
442 : : // Stream subset
443 : : //
444 : : void read(Span<std::byte> dst);
445 : : void ignore(size_t nSize);
446 : : void write(Span<const std::byte> src);
447 : :
448 : : template <typename T>
449 : 1525506 : AutoFile& operator<<(const T& obj)
450 : : {
451 : 1525506 : ::Serialize(*this, obj);
452 : 1525506 : return *this;
453 : : }
454 : :
455 : : template <typename T>
456 : 3085373 : AutoFile& operator>>(T&& obj)
457 : : {
458 : 3085373 : ::Unserialize(*this, obj);
459 : 3085373 : return *this;
460 : : }
461 : : };
462 : :
463 : : /** Wrapper around an AutoFile& that implements a ring buffer to
464 : : * deserialize from. It guarantees the ability to rewind a given number of bytes.
465 : : *
466 : : * Will automatically close the file when it goes out of scope if not null.
467 : : * If you need to close the file early, use file.fclose() instead of fclose(file).
468 : : */
469 : : class BufferedFile
470 : : {
471 : : private:
472 : : AutoFile& m_src;
473 : 989 : uint64_t nSrcPos{0}; //!< how many bytes have been read from source
474 : 989 : uint64_t m_read_pos{0}; //!< how many bytes have been read from this
475 : : uint64_t nReadLimit; //!< up to which position we're allowed to read
476 : : uint64_t nRewind; //!< how many bytes we guarantee to rewind
477 : : std::vector<std::byte> vchBuf; //!< the buffer
478 : :
479 : : //! read data from the source to fill the buffer
480 : 597904 : bool Fill() {
481 : 597904 : unsigned int pos = nSrcPos % vchBuf.size();
482 : 597904 : unsigned int readNow = vchBuf.size() - pos;
483 : 597904 : unsigned int nAvail = vchBuf.size() - (nSrcPos - m_read_pos) - nRewind;
484 [ + + ]: 597904 : if (nAvail < readNow)
485 : 422603 : readNow = nAvail;
486 [ + - ]: 597904 : if (readNow == 0)
487 : 0 : return false;
488 : 597904 : size_t nBytes{m_src.detail_fread(Span{vchBuf}.subspan(pos, readNow))};
489 [ + + ]: 597904 : if (nBytes == 0) {
490 [ + - + - : 2319 : throw std::ios_base::failure{m_src.feof() ? "BufferedFile::Fill: end of file" : "BufferedFile::Fill: fread failed"};
- + + - ]
491 : : }
492 : 595585 : nSrcPos += nBytes;
493 : 595585 : return true;
494 : 600223 : }
495 : :
496 : : //! Advance the stream's read pointer (m_read_pos) by up to 'length' bytes,
497 : : //! filling the buffer from the file so that at least one byte is available.
498 : : //! Return a pointer to the available buffer data and the number of bytes
499 : : //! (which may be less than the requested length) that may be accessed
500 : : //! beginning at that pointer.
501 : 8121452 : std::pair<std::byte*, size_t> AdvanceStream(size_t length)
502 : : {
503 [ + - ]: 8121452 : assert(m_read_pos <= nSrcPos);
504 [ + + ]: 8121452 : if (m_read_pos + length > nReadLimit) {
505 [ + - - + : 24875 : throw std::ios_base::failure("Attempt to position past buffer limit");
+ - ]
506 : : }
507 : : // If there are no bytes available, read from the file.
508 [ + + - + ]: 8096577 : if (m_read_pos == nSrcPos && length > 0) Fill();
509 : :
510 : 8096577 : size_t buffer_offset{static_cast<size_t>(m_read_pos % vchBuf.size())};
511 : 8096577 : size_t buffer_available{static_cast<size_t>(vchBuf.size() - buffer_offset)};
512 : 8096577 : size_t bytes_until_source_pos{static_cast<size_t>(nSrcPos - m_read_pos)};
513 : 8096577 : size_t advance{std::min({length, buffer_available, bytes_until_source_pos})};
514 : 8096577 : m_read_pos += advance;
515 : 8096577 : return std::make_pair(&vchBuf[buffer_offset], advance);
516 : 8121452 : }
517 : :
518 : : public:
519 : 989 : BufferedFile(AutoFile& file, uint64_t nBufSize, uint64_t nRewindIn)
520 [ + - + - ]: 2002 : : m_src{file}, nReadLimit{std::numeric_limits<uint64_t>::max()}, nRewind{nRewindIn}, vchBuf(nBufSize, std::byte{0})
521 : : {
522 [ + + ]: 989 : if (nRewindIn >= nBufSize)
523 [ + - - + : 24 : throw std::ios_base::failure("Rewind limit must be less than buffer size");
+ - ]
524 : 989 : }
525 : :
526 : : //! check whether we're at the end of the source file
527 : 3046783 : bool eof() const {
528 [ + + ]: 3046783 : return m_read_pos == nSrcPos && m_src.feof();
529 : : }
530 : :
531 : : //! read a number of bytes
532 : 7287520 : void read(Span<std::byte> dst)
533 : : {
534 [ + + ]: 15087997 : while (dst.size() > 0) {
535 : 31201908 : auto [buffer_pointer, length]{AdvanceStream(dst.size())};
536 : 23401431 : memcpy(dst.data(), buffer_pointer, length);
537 : 15600954 : dst = dst.subspan(length);
538 : 7800477 : }
539 : 7287520 : }
540 : :
541 : : //! Move the read position ahead in the stream to the given position.
542 : : //! Use SetPos() to back up in the stream, not SkipTo().
543 : 319644 : void SkipTo(const uint64_t file_pos)
544 : : {
545 [ + - ]: 319644 : assert(file_pos >= m_read_pos);
546 [ + + ]: 640619 : while (m_read_pos < file_pos) AdvanceStream(file_pos - m_read_pos);
547 : 319644 : }
548 : :
549 : : //! return the current reading position
550 : 3446990 : uint64_t GetPos() const {
551 : 3446990 : return m_read_pos;
552 : : }
553 : :
554 : : //! rewind to a given reading position
555 : 3161661 : bool SetPos(uint64_t nPos) {
556 : 3161661 : size_t bufsize = vchBuf.size();
557 [ + + ]: 3161661 : if (nPos + bufsize < nSrcPos) {
558 : : // rewinding too far, rewind as far as possible
559 : 596 : m_read_pos = nSrcPos - bufsize;
560 : 596 : return false;
561 : : }
562 [ + + ]: 3161065 : if (nPos > nSrcPos) {
563 : : // can't go this far forward, go as far as possible
564 : 982 : m_read_pos = nSrcPos;
565 : 982 : return false;
566 : : }
567 : 3160083 : m_read_pos = nPos;
568 : 3160083 : return true;
569 : 3161661 : }
570 : :
571 : : //! prevent reading beyond a certain position
572 : : //! no argument removes the limit
573 : 3367066 : bool SetLimit(uint64_t nPos = std::numeric_limits<uint64_t>::max()) {
574 [ + + ]: 3367066 : if (nPos < m_read_pos)
575 : 342 : return false;
576 : 3366724 : nReadLimit = nPos;
577 : 3366724 : return true;
578 : 3367066 : }
579 : :
580 : : template<typename T>
581 : 3906305 : BufferedFile& operator>>(T&& obj) {
582 : 3906305 : ::Unserialize(*this, obj);
583 : 3906305 : return (*this);
584 : : }
585 : :
586 : : //! search for a given byte in the stream, and remain positioned on it
587 : 3048321 : void FindByte(std::byte byte)
588 : : {
589 : : // For best performance, avoid mod operation within the loop.
590 : 3048321 : size_t buf_offset{size_t(m_read_pos % uint64_t(vchBuf.size()))};
591 : 3117231 : while (true) {
592 [ + + ]: 3117231 : if (m_read_pos == nSrcPos) {
593 : : // No more bytes available; read from the file into the buffer,
594 : : // setting nSrcPos to one beyond the end of the new data.
595 : : // Throws exception if end-of-file reached.
596 : 71376 : Fill();
597 : 71376 : }
598 : 3117231 : const size_t len{std::min<size_t>(vchBuf.size() - buf_offset, nSrcPos - m_read_pos)};
599 : 3117231 : const auto it_start{vchBuf.begin() + buf_offset};
600 : 3117231 : const auto it_find{std::find(it_start, it_start + len, byte)};
601 : 3117231 : const size_t inc{size_t(std::distance(it_start, it_find))};
602 : 3117231 : m_read_pos += inc;
603 [ + + ]: 3117231 : if (inc < len) break;
604 : 69682 : buf_offset += inc;
605 [ + + ]: 69682 : if (buf_offset >= vchBuf.size()) buf_offset = 0;
606 [ - + + ]: 3117231 : }
607 : 3048321 : }
608 : : };
609 : :
610 : : #endif // BITCOIN_STREAMS_H
|