disk_reader.cpp

Go to the documentation of this file.

#include "disk_reader.hpp"
#include "i18n.hpp"
 
#include <cerrno>
#include <cstring>
 
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#ifdef __linux__
#include <linux/fs.h>
#include <sys/ioctl.h>
#endif
 
DiskReader::DiskReader()
: fd_(-1),
is_block_device_(false),
size_(0),
logical_sector_size_(512) {}
 
DiskReader::~DiskReader() {
    close();
}
 
void DiskReader::close() {
    if (fd_ >= 0) {
        ::close(fd_);
        fd_ = -1;
    }
    is_block_device_ = false;
    size_ = 0;
    logical_sector_size_ = 512;
    path_.clear();
}
 
bool DiskReader::open_readonly(const std::string& path, std::string& error) {
    close();
 
    struct stat st {};
    if (::stat(path.c_str(), &st) != 0) {
        error = std::string("stat failed: ") + std::strerror(errno);
        return false;
    }
 
    if (!S_ISREG(st.st_mode) && !S_ISBLK(st.st_mode)) {
        error = trs("source is neither a regular file nor a block device");
        return false;
    }
 
    fd_ = ::open(path.c_str(), O_RDONLY | O_CLOEXEC);
    if (fd_ < 0) {
        error = std::string("open failed: ") + std::strerror(errno);
        return false;
    }
 
    path_ = path;
    is_block_device_ = S_ISBLK(st.st_mode);
 
    if (is_block_device_) {
        #ifdef __linux__
        unsigned long long bytes = 0;
        if (::ioctl(fd_, BLKGETSIZE64, &bytes) != 0) {
            error = std::string("BLKGETSIZE64 failed: ") + std::strerror(errno);
            close();
            return false;
        }
        size_ = static_cast<uint64_t>(bytes);
 
        unsigned int sector = 512;
        if (::ioctl(fd_, BLKSSZGET, &sector) == 0 && sector > 0) {
            logical_sector_size_ = sector;
        }
        #else
        error = trs("block-device support is Linux-only in this build");
        close();
        return false;
        #endif
    } else {
        size_ = static_cast<uint64_t>(st.st_size);
        logical_sector_size_ = 512;
    }
 
    return true;
}
 
bool DiskReader::is_open() const {
    return fd_ >= 0;
}
 
bool DiskReader::is_block_device() const {
    return is_block_device_;
}
 
uint64_t DiskReader::size() const {
    return size_;
}
 
uint32_t DiskReader::logical_sector_size() const {
    return logical_sector_size_;
}
 
const std::string& DiskReader::path() const {
    return path_;
}
 
bool DiskReader::read_at(uint64_t offset, void* buffer, size_t len) {
    if (fd_ < 0 || buffer == nullptr) return false;
    if (len == 0) return true;
    // Bug #1 fix: avoid uint64_t overflow on offset + len
    if (offset > size_ || len > size_ - offset) return false;
 
    auto* ptr = static_cast<unsigned char*>(buffer);
    size_t done = 0;
 
    while (done < len) {
        const auto n = ::pread(fd_, ptr + done, len - done, static_cast<off_t>(offset + done));
        if (n <= 0) {
            return false;
        }
        done += static_cast<size_t>(n);
    }
 
    return true;
}
 
std::vector<std::byte> DiskReader::read_block(uint64_t offset, size_t len) {
    std::vector<std::byte> out(len);
    if (!read_at(offset, out.data(), len)) {
        out.clear();
    }
    return out;
}