501 *  Will automatically close the file when it goes out of scope if not null.
502 *  If you need to close the file early, use file.fclose() instead of fclose(file).
503 */
504class BufferedFile
505{
506private:
507    AutoFile& m_src;
508    uint64_t nSrcPos{0};  //!< how many bytes have been read from source
509    uint64_t m_read_pos{0}; //!< how many bytes have been read from this
510    uint64_t nReadLimit;  //!< up to which position we're allowed to read
511    uint64_t nRewind;     //!< how many bytes we guarantee to rewind
512    DataBuffer vchBuf;
513
514    //! read data from the source to fill the buffer
515    bool Fill() {
516        unsigned int pos = nSrcPos % vchBuf.size();
517        unsigned int readNow = vchBuf.size() - pos;
518        unsigned int nAvail = vchBuf.size() - (nSrcPos - m_read_pos) - nRewind;
519        if (nAvail < readNow)
520            readNow = nAvail;
521        if (readNow == 0)
522            return false;
523        size_t nBytes{m_src.detail_fread(std::span{vchBuf}.subspan(pos, readNow))};
524        if (nBytes == 0) {
525            throw std::ios_base::failure{m_src.feof() ? "BufferedFile::Fill: end of file" : "BufferedFile::Fill: fread failed"};
526        }
527        nSrcPos += nBytes;
528        return true;
529    }
530
531    //! Advance the stream's read pointer (m_read_pos) by up to 'length' bytes,
532    //! filling the buffer from the file so that at least one byte is available.
533    //! Return a pointer to the available buffer data and the number of bytes
534    //! (which may be less than the requested length) that may be accessed
535    //! beginning at that pointer.
536    std::pair<std::byte*, size_t> AdvanceStream(size_t length)
537    {
538        assert(m_read_pos <= nSrcPos);
539        if (m_read_pos + length > nReadLimit) {
540            throw std::ios_base::failure("Attempt to position past buffer limit");
541        }
542        // If there are no bytes available, read from the file.
543        if (m_read_pos == nSrcPos && length > 0) Fill();
544
545        size_t buffer_offset{static_cast<size_t>(m_read_pos % vchBuf.size())};
546        size_t buffer_available{static_cast<size_t>(vchBuf.size() - buffer_offset)};
547        size_t bytes_until_source_pos{static_cast<size_t>(nSrcPos - m_read_pos)};
548        size_t advance{std::min({length, buffer_available, bytes_until_source_pos})};
549        m_read_pos += advance;
550        return std::make_pair(&vchBuf[buffer_offset], advance);
551    }
552
553public:
554    BufferedFile(AutoFile& file LIFETIMEBOUND, uint64_t nBufSize, uint64_t nRewindIn)
555        : m_src{file}, nReadLimit{std::numeric_limits<uint64_t>::max()}, nRewind{nRewindIn}, vchBuf(nBufSize, std::byte{0})
556    {
557        if (nRewindIn >= nBufSize)
558            throw std::ios_base::failure("Rewind limit must be less than buffer size");
559    }
560
561    //! check whether we're at the end of the source file
562    bool eof() const {
563        return m_read_pos == nSrcPos && m_src.feof();
564    }
565
566    //! read a number of bytes
567    void read(std::span<std::byte> dst)
568    {
569        while (dst.size() > 0) {
570            auto [buffer_pointer, length]{AdvanceStream(dst.size())};
571            memcpy(dst.data(), buffer_pointer, length);
572            dst = dst.subspan(length);
573        }
574    }
575
576    //! Move the read position ahead in the stream to the given position.
577    //! Use SetPos() to back up in the stream, not SkipTo().
578    void SkipTo(const uint64_t file_pos)
579    {
580        assert(file_pos >= m_read_pos);
581        while (m_read_pos < file_pos) AdvanceStream(file_pos - m_read_pos);
582    }
583
584    //! return the current reading position
585    uint64_t GetPos() const {
586        return m_read_pos;
587    }
588
589    //! rewind to a given reading position
590    bool SetPos(uint64_t nPos) {
591        size_t bufsize = vchBuf.size();
592        if (nPos + bufsize < nSrcPos) {
593            // rewinding too far, rewind as far as possible
594            m_read_pos = nSrcPos - bufsize;
595            return false;
596        }
597        if (nPos > nSrcPos) {
598            // can't go this far forward, go as far as possible
599            m_read_pos = nSrcPos;
600            return false;
601        }
602        m_read_pos = nPos;
603        return true;
604    }
605
606    //! prevent reading beyond a certain position
607    //! no argument removes the limit
608    bool SetLimit(uint64_t nPos = std::numeric_limits<uint64_t>::max()) {
609        if (nPos < m_read_pos)
610            return false;
611        nReadLimit = nPos;
612        return true;
613    }
614
615    template<typename T>
616    BufferedFile& operator>>(T&& obj) {
617        ::Unserialize(*this, obj);
618        return (*this);
619    }
620
621    //! search for a given byte in the stream, and remain positioned on it
622    void FindByte(std::byte byte)
623    {
624        // For best performance, avoid mod operation within the loop.
625        size_t buf_offset{size_t(m_read_pos % uint64_t(vchBuf.size()))};
626        while (true) {
627            if (m_read_pos == nSrcPos) {
628                // No more bytes available; read from the file into the buffer,
629                // setting nSrcPos to one beyond the end of the new data.
630                // Throws exception if end-of-file reached.
631                Fill();
632            }
633            const size_t len{std::min<size_t>(vchBuf.size() - buf_offset, nSrcPos - m_read_pos)};
634            const auto it_start{vchBuf.begin() + buf_offset};
635            const auto it_find{std::find(it_start, it_start + len, byte)};
636            const size_t inc{size_t(std::distance(it_start, it_find))};
637            m_read_pos += inc;
638            if (inc < len) break;
639            buf_offset += inc;
640            if (buf_offset >= vchBuf.size()) buf_offset = 0;
641        }
642    }
643};
644
645/**
646 * Wrapper that buffers reads from an underlying stream.
647 * Requires underlying stream to support read() and detail_fread() calls
648 * to support fixed-size and variable-sized reads, respectively.
649 */
650template <typename S>
651class BufferedReader
652{
653    S& m_src;
654    DataBuffer m_buf;
655    size_t m_buf_pos;
656
657public:
658    //! Requires stream ownership to prevent leaving the stream at an unexpected position after buffered reads.
659    explicit BufferedReader(S&& stream LIFETIMEBOUND, size_t size = 1 << 16)
660        requires std::is_rvalue_reference_v<S&&>
661        : m_src{stream}, m_buf(size), m_buf_pos{size} {}
662
663    void read(std::span<std::byte> dst)
664    {
665        if (const auto available{std::min(dst.size(), m_buf.size() - m_buf_pos)}) {
666            std::copy_n(m_buf.begin() + m_buf_pos, available, dst.begin());
667            m_buf_pos += available;
668            dst = dst.subspan(available);
669        }
670        if (dst.size()) {
671            assert(m_buf_pos == m_buf.size());
672            m_src.read(dst);
673
674            m_buf_pos = 0;
675            m_buf.resize(m_src.detail_fread(m_buf));
676        }
677    }
678
679    template <typename T>
680    BufferedReader& operator>>(T&& obj)
681    {
682        Unserialize(*this, obj);
683        return *this;
684    }
685};
686
687/**
688 * Wrapper that buffers writes to an underlying stream.
689 * Requires underlying stream to support write_buffer() method
690 * for efficient buffer flushing and obfuscation.
691 */
692template <typename S>
693class BufferedWriter
694{
695    S& m_dst;
696    DataBuffer m_buf;
697    size_t m_buf_pos{0};
698
699public:
700    explicit BufferedWriter(S& stream LIFETIMEBOUND, size_t size = 1 << 16) : m_dst{stream}, m_buf(size) {}
701
702    ~BufferedWriter() { flush(); }
703
704    void flush()
705    {
706        if (m_buf_pos) m_dst.write_buffer(std::span{m_buf}.first(m_buf_pos));
707        m_buf_pos = 0;
708    }
709
710    void write(std::span<const std::byte> src)
711    {
712        while (const auto available{std::min(src.size(), m_buf.size() - m_buf_pos)}) {
713            std::copy_n(src.begin(), available, m_buf.begin() + m_buf_pos);
714            m_buf_pos += available;
715            if (m_buf_pos == m_buf.size()) flush();
716            src = src.subspan(available);
717        }
718    }
719
720    template <typename T>
721    BufferedWriter& operator<<(const T& obj)
722    {
723        Serialize(*this, obj);
724        return *this;
725    }
726};
727
728#endif // BITCOIN_STREAMS_H
729