fw.hpp

 
#pragma once
 
#include <string>
#include <vector>
#include <iterator>
 
namespace radio_tool::fw
{
    class FirmwareSegment
    {
    public:
        FirmwareSegment(const uint16_t& idx, const uint32_t& addr, const uint32_t& size, const std::vector<uint8_t>::const_iterator& begin, const std::vector<uint8_t>::const_iterator& end)
            : index(idx), address(addr), size(size), data(begin, end)
        {
        }
 
        const uint16_t index;
 
        const uint32_t address;
 
        const uint32_t size;
 
        const std::vector<uint8_t> data;
    };
 
    class FirmwareSupport
    {
    public:
        virtual ~FirmwareSupport() = default;
 
        virtual auto Read(const std::string& fw) -> void = 0;
 
        virtual auto Write(const std::string& fw) -> void = 0;
 
        virtual auto ToString() const->std::string = 0;
 
        virtual auto GetRadioModel() const -> const std::string = 0;
 
        virtual auto SetRadioModel(const std::string&) -> void = 0;
 
        virtual auto Decrypt() -> void = 0;
 
        virtual auto Encrypt() -> void = 0;
 
        virtual auto IsCompatible(const FirmwareSupport* Other) const -> bool = 0;
 
        auto GetData() const -> const std::vector<uint8_t>&
        {
            return data;
        }
 
        virtual auto GetDataSegments() const -> const std::vector<FirmwareSegment>
        {
            std::vector<FirmwareSegment> ret;
 
            auto r_idx = 0u;
            auto r_offset = 0u;
            for (const auto& r : memory_ranges)
            {
                ret.push_back(FirmwareSegment(
                    r_idx++,
                    r.first,
                    r.second,
                    data.begin() + r_offset,
                    data.begin() + r_offset + r.second
                ));
                r_offset += r.second;
            }
 
            return ret;
        }
 
        virtual auto AppendSegment(const uint32_t& addr, const std::vector<uint8_t>& new_data) -> void
        {
            auto extra = align != 0 ? new_data.size() % align : 0;
            auto new_size = new_data.size() + (extra > 0 ? align - extra : 0);
            data.reserve(data.size() + new_size);
            std::copy(new_data.begin(), new_data.end(), std::back_inserter(data));
            if (extra > 0)
            {
                std::fill_n(std::back_inserter(data), align - extra, 0xff);
            }
            memory_ranges.push_back({ addr, new_size });
        }
 
    protected:
        FirmwareSupport(const uint32_t& align = 0)
            : align(align)
        { }
 
        const uint32_t align;
 
        std::vector<uint8_t> data;
 
        std::vector<std::pair<uint32_t, uint32_t>> memory_ranges;
    };
} // namespace radio_tool::fw