LCOV - code coverage report
Current view: top level - src - streams.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 89.2 % 74 66
Test Date: 2025-07-04 04:08:43 Functions: 81.8 % 11 9
Branches: 67.9 % 106 72

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2009-present The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or https://opensource.org/license/mit/.
       4                 :             : 
       5                 :             : #include <memusage.h>
       6                 :             : #include <span.h>
       7                 :             : #include <streams.h>
       8                 :             : #include <util/fs_helpers.h>
       9                 :             : 
      10                 :             : #include <array>
      11                 :             : 
      12                 :      233085 : AutoFile::AutoFile(std::FILE* file, std::vector<std::byte> data_xor)
      13         [ +  + ]:      233085 :     : m_file{file}, m_xor{std::move(data_xor)}
      14                 :             : {
      15         [ +  + ]:      233085 :     if (!IsNull()) {
      16         [ +  - ]:      210370 :         auto pos{std::ftell(m_file)};
      17         [ +  + ]:      210370 :         if (pos >= 0) m_position = pos;
      18                 :             :     }
      19                 :      233085 : }
      20                 :             : 
      21                 :    29263088 : std::size_t AutoFile::detail_fread(std::span<std::byte> dst)
      22                 :             : {
      23   [ +  +  +  - ]:    29263088 :     if (!m_file) throw std::ios_base::failure("AutoFile::read: file handle is nullptr");
      24         [ +  - ]:    29262406 :     size_t ret = std::fread(dst.data(), 1, dst.size(), m_file);
      25         [ +  + ]:    29262406 :     if (!m_xor.empty()) {
      26   [ +  +  +  - ]:      728055 :         if (!m_position.has_value()) throw std::ios_base::failure("AutoFile::read: position unknown");
      27         [ -  + ]:      727589 :         util::Xor(dst.subspan(0, ret), m_xor, *m_position);
      28                 :             :     }
      29         [ +  + ]:    29261940 :     if (m_position.has_value()) *m_position += ret;
      30                 :    29261940 :     return ret;
      31                 :             : }
      32                 :             : 
      33                 :         227 : void AutoFile::seek(int64_t offset, int origin)
      34                 :             : {
      35         [ -  + ]:         227 :     if (IsNull()) {
      36         [ #  # ]:           0 :         throw std::ios_base::failure("AutoFile::seek: file handle is nullptr");
      37                 :             :     }
      38         [ -  + ]:         227 :     if (std::fseek(m_file, offset, origin) != 0) {
      39   [ #  #  #  # ]:           0 :         throw std::ios_base::failure(feof() ? "AutoFile::seek: end of file" : "AutoFile::seek: fseek failed");
      40                 :             :     }
      41         [ +  + ]:         227 :     if (origin == SEEK_SET) {
      42                 :          91 :         m_position = offset;
      43   [ +  +  +  - ]:         136 :     } else if (origin == SEEK_CUR && m_position.has_value()) {
      44                 :          75 :         *m_position += offset;
      45                 :             :     } else {
      46                 :          61 :         int64_t r{std::ftell(m_file)};
      47         [ -  + ]:          61 :         if (r < 0) {
      48         [ #  # ]:           0 :             throw std::ios_base::failure("AutoFile::seek: ftell failed");
      49                 :             :         }
      50                 :          61 :         m_position = r;
      51                 :             :     }
      52                 :         227 : }
      53                 :             : 
      54                 :          61 : int64_t AutoFile::tell()
      55                 :             : {
      56   [ -  +  -  - ]:          61 :     if (!m_position.has_value()) throw std::ios_base::failure("AutoFile::tell: position unknown");
      57                 :          61 :     return *m_position;
      58                 :             : }
      59                 :             : 
      60                 :    28862141 : void AutoFile::read(std::span<std::byte> dst)
      61                 :             : {
      62         [ +  + ]:    28862141 :     if (detail_fread(dst) != dst.size()) {
      63   [ +  +  +  - ]:        4930 :         throw std::ios_base::failure(feof() ? "AutoFile::read: end of file" : "AutoFile::read: fread failed");
      64                 :             :     }
      65                 :    28857258 : }
      66                 :             : 
      67                 :        1338 : void AutoFile::ignore(size_t nSize)
      68                 :             : {
      69   [ +  +  +  - ]:        1338 :     if (!m_file) throw std::ios_base::failure("AutoFile::ignore: file handle is nullptr");
      70                 :             :     unsigned char data[4096];
      71         [ +  + ]:        1955 :     while (nSize > 0) {
      72         [ +  + ]:        1295 :         size_t nNow = std::min<size_t>(nSize, sizeof(data));
      73   [ -  +  +  + ]:        2590 :         if (std::fread(data, 1, nNow, m_file) != nNow) {
      74   [ +  +  +  - ]:         765 :             throw std::ios_base::failure(feof() ? "AutoFile::ignore: end of file" : "AutoFile::ignore: fread failed");
      75                 :             :         }
      76                 :         799 :         nSize -= nNow;
      77         [ +  + ]:         799 :         if (m_position.has_value()) *m_position += nNow;
      78                 :             :     }
      79                 :         660 : }
      80                 :             : 
      81                 :     1584132 : void AutoFile::write(std::span<const std::byte> src)
      82                 :             : {
      83   [ +  +  +  - ]:     1584132 :     if (!m_file) throw std::ios_base::failure("AutoFile::write: file handle is nullptr");
      84         [ +  + ]:     1582931 :     if (m_xor.empty()) {
      85         [ +  + ]:     1508900 :         if (std::fwrite(src.data(), 1, src.size(), m_file) != src.size()) {
      86         [ +  - ]:        2646 :             throw std::ios_base::failure("AutoFile::write: write failed");
      87                 :             :         }
      88                 :     1506254 :         m_was_written = true;
      89         [ +  + ]:     1506254 :         if (m_position.has_value()) *m_position += src.size();
      90                 :             :     } else {
      91                 :             :         std::array<std::byte, 4096> buf;
      92         [ +  + ]:      147256 :         while (src.size()) {
      93         [ +  - ]:      147690 :             auto buf_now{std::span{buf}.first(std::min<size_t>(src.size(), buf.size()))};
      94                 :       73845 :             std::copy_n(src.begin(), buf_now.size(), buf_now.begin());
      95                 :       73845 :             write_buffer(buf_now);
      96                 :       73225 :             src = src.subspan(buf_now.size());
      97                 :             :         }
      98                 :             :     }
      99                 :     1579665 : }
     100                 :             : 
     101                 :      266584 : void AutoFile::write_buffer(std::span<std::byte> src)
     102                 :             : {
     103   [ -  +  -  - ]:      266584 :     if (!m_file) throw std::ios_base::failure("AutoFile::write_buffer: file handle is nullptr");
     104         [ +  - ]:      266584 :     if (m_xor.size()) {
     105   [ +  +  +  - ]:      266584 :         if (!m_position) throw std::ios_base::failure("AutoFile::write_buffer: obfuscation position unknown");
     106                 :      266284 :         util::Xor(src, m_xor, *m_position); // obfuscate in-place
     107                 :             :     }
     108         [ +  + ]:      266284 :     if (std::fwrite(src.data(), 1, src.size(), m_file) != src.size()) {
     109         [ +  - ]:         320 :         throw std::ios_base::failure("AutoFile::write_buffer: write failed");
     110                 :             :     }
     111                 :      265964 :     m_was_written = true;
     112         [ +  - ]:      265964 :     if (m_position) *m_position += src.size();
     113                 :      265964 : }
     114                 :             : 
     115                 :           0 : bool AutoFile::Commit()
     116                 :             : {
     117                 :           0 :     return ::FileCommit(m_file);
     118                 :             : }
     119                 :             : 
     120                 :           0 : bool AutoFile::Truncate(unsigned size)
     121                 :             : {
     122                 :           0 :     m_was_written = true;
     123                 :           0 :     return ::TruncateFile(m_file, size);
     124                 :             : }
     125                 :             : 
     126                 :      293260 : size_t DataStream::GetMemoryUsage() const noexcept
     127                 :             : {
     128         [ +  + ]:      293260 :     return sizeof(*this) + memusage::DynamicUsage(vch);
     129                 :             : }
        

Generated by: LCOV version 2.0-1