yaesu_fw.cpp

 
#include <radio_tool/fw/yaesu_fw.hpp>
#include <radio_tool/util.hpp>
 
using namespace radio_tool::fw;
 
auto YaesuFW::Read(const std::string& file) -> void
{
    auto i = std::ifstream(file, std::ios_base::binary);
    if (i.is_open())
    {
        // Compute binary file size
        i.seekg(0, std::ios_base::end);
        auto binarySize = i.tellg();
        i.seekg(0);
 
        // Read binary
        data.resize(binarySize);
        i.read((char*)data.data(), binarySize);
 
        // Pad with 0xFF until multiple of 1KiB
        data.resize(binarySize + ((1024 - binarySize % 1024) % 1024), 0xFF);
    }
    i.close();
}
 
auto YaesuFW::Write(const std::string& file) -> void
{
    std::ofstream fout(file, std::ios_base::binary);
    if (fout.is_open())
    {
        // write firmware data
        fout.write((char*)data.data(), data.size());
        fout.close();
    }
}
 
auto YaesuFW::ToString() const -> std::string
{
    std::stringstream out;
    out << "== Yaesu Firmware == " << std::endl
        << "Size:  " << radio_tool::FormatBytes(data.size()) << std::endl;
    return out.str();
}
 
auto YaesuFW::Decrypt() -> void {}
auto YaesuFW::Encrypt() -> void {}
auto YaesuFW::SetRadioModel(const std::string&) -> void {}
auto YaesuFW::GetRadioModel() const -> const std::string
{
    return "Unknown";
}
 
auto YaesuFW::SupportsFirmwareFile(const std::string& file) -> bool
{
    std::ifstream i;
    i.open(file, i.binary);
    if (i.is_open())
    {
        return true;
    }
    else
    {
        throw std::runtime_error("Can't open firmware file");
    }
}
 
auto YaesuFW::SupportsRadioModel(const std::string& model) -> bool
{
    return true;
}
 
auto YaesuFW::IsCompatible(const FirmwareSupport* Other) const -> bool
{
    if (typeid(Other) != typeid(this)) {
        return false;
    }
 
    auto afw = dynamic_cast<const YaesuFW*>(Other);
    return afw->radio_model == radio_model;
}