field_codec_crc.h

// Copyright 2024:
//   GobySoft, LLC (2013-)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Dynamic Compact Control Language Library
// ("DCCL").
//
// DCCL is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// DCCL is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
#ifndef DCCLV4FIELDCODECCRCN
#define DCCLV4FIELDCODECCRCN
 
#include <cstdint>
#include <sstream>
#include <string>
 
#include "field_codec_default.h"
 
namespace dccl
{
namespace v4
{
 
inline uint16_t crc16(const char* data, size_t size)
{
    uint16_t crc = 0xFFFF;
    for (size_t i = 0; i < size; ++i)
    {
        crc ^= static_cast<uint16_t>(static_cast<uint8_t>(data[i])) << 8;
        for (int bit = 0; bit < 8; ++bit)
        {
            if (crc & 0x8000)
                crc = static_cast<uint16_t>((crc << 1) ^ 0x1021);
            else
                crc = static_cast<uint16_t>(crc << 1);
        }
    }
    return crc;
}
 
inline uint32_t crc32(const char* data, size_t size)
{
    uint32_t crc = 0xFFFFFFFF;
    for (size_t i = 0; i < size; ++i)
    {
        crc ^= static_cast<uint8_t>(data[i]);
        for (int bit = 0; bit < 8; ++bit)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xEDB88320;
            else
                crc >>= 1;
        }
    }
    return crc ^ 0xFFFFFFFF;
}
 
template <int CRCBits> class CRCCodecBase : public v4::DefaultNumericFieldCodec<uint32>
{
  public:
    CRCCodecBase() { this->set_force_use_required(); }
 
    double min() override { return 0; }
    double max() override { return (CRCBits == 32) ? static_cast<double>(0xFFFFFFFFu) : static_cast<double>(0xFFFFu); }
 
  private:
    Bitset encode() override
    {
        return this->v4::DefaultNumericFieldCodec<uint32>::encode(compute_crc_encode());
    }
 
    uint32 pre_encode(const uint32& /*field_value*/) override { return compute_crc_encode(); }
 
    uint32 post_decode(const uint32& wire_value) override
    {
        uint32 expected = compute_crc_decode();
        uint32 received = wire_value;
        if (expected != received)
        {
            std::stringstream ss;
            ss << "CRC mismatch. Expected: 0x" << std::hex << expected << ", received: 0x"
               << received
               << ". Message data may be corrupted.";
            throw(Exception(ss.str(), this->root_descriptor()));
        }
        return wire_value;
    }
 
    void validate() override
    {
        // min() and max() are hardcoded - skip the parent's has_min/has_max checks and
        // call validate_numeric_bounds() directly to verify type range constraints.
        this->validate_numeric_bounds();
 
        // the CRC is computed over the bits of the message it belongs to, and only the root
        // message's bits are recovered while decoding
        FieldCodecBase::require(this->this_descriptor() == this->root_descriptor(),
                                "CRC codecs are only supported in the root message, not in an "
                                "embedded message");
    }
 
    uint32 compute_crc_encode() const
    {
        const Bitset* bits = this->root_bitset();
        if (!bits)
            return 0;
        Bitset bits_copy = *bits;
        std::string byte_str = bits_copy.to_byte_string();
        return compute_crc(byte_str.data(), byte_str.size());
    }
 
    uint32 compute_crc_decode() const
    {
        const Bitset* bits = this->root_bitset();
        if (!bits)
            return 0;
        // decoded_bits_ already contains only the bits before the CRC field - no trimming needed.
        Bitset bits_copy = *bits;
        std::string byte_str = bits_copy.to_byte_string();
        return compute_crc(byte_str.data(), byte_str.size());
    }
 
    static uint32 compute_crc(const char* data, size_t size)
    {
        if (CRCBits == 16)
            return crc16(data, size);
        else
            return crc32(data, size);
    }
};
 
class CRC16Codec : public CRCCodecBase<16>
{
};
 
class CRC32Codec : public CRCCodecBase<32>
{
};
 
} // namespace v4
} // namespace dccl
 
#endif