DoIpLayer.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <cstring>
#include "Layer.h"
#include "Logger.h"
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct doiphdr
    {
        uint8_t protocolVersion;
        uint8_t invertProtocolVersion;
        uint16_t payloadType;
        uint32_t payloadLength;
    };
#pragma pack(pop)
    static_assert(sizeof(doiphdr) == 8, "DoIP header must be exactly 8 bytes.");
 
    namespace DoIpConstants
    {
        static constexpr size_t DOIP_HEADER_LEN = sizeof(doiphdr);
 
        static constexpr size_t DOIP_EID_LEN = 6;
 
        static constexpr size_t DOIP_GID_LEN = 6;
 
        static constexpr size_t DOIP_VIN_LEN = 17;
 
        static constexpr size_t DOIP_RESERVED_ISO_LEN = 4;
 
        static constexpr size_t DOIP_RESERVED_OEM_LEN = 4;
 
        static constexpr size_t DOIP_SOURCE_ADDRESS_LEN = 2;
 
        static constexpr size_t DOIP_TARGET_ADDRESS_LEN = 2;
    }  // namespace DoIpConstants
 
    enum class DoIpActivationTypes : uint8_t
    {
        DEFAULT = 0x00U,
 
        WWH_OBD = 0x01U,
 
        CENTRAL_SECURITY = 0xE0U,
 
        UNKNOWN
    };
 
    enum class DoIpGenericHeaderNackCodes : uint8_t
    {
        INCORRECT_PATTERN = 0x00U,
 
        UNKNOWN_PAYLOAD_TYPE = 0x01U,
 
        MESSAGE_TOO_LARGE = 0x02U,
 
        OUT_OF_MEMORY = 0x03U,
 
        INVALID_PAYLOAD_LENGTH = 0x04U,
 
        UNKNOWN
    };
 
    enum class DoIpActionCodes : uint8_t
    {
        NO_FURTHER_ACTION_REQUIRED = 0x00U,
 
        RESERVED_ISO_0x01 = 0x01U,
 
        RESERVED_ISO_0x02 = 0x02U,
 
        RESERVED_ISO_0x03 = 0x03U,
 
        RESERVED_ISO_0x04 = 0x04U,
 
        RESERVED_ISO_0x05 = 0x05U,
 
        RESERVED_ISO_0x06 = 0x06U,
 
        RESERVED_ISO_0x07 = 0x07U,
 
        RESERVED_ISO_0x08 = 0x08U,
 
        RESERVED_ISO_0x09 = 0x09U,
 
        RESERVED_ISO_0x0A = 0x0AU,
 
        RESERVED_ISO_0x0B = 0x0BU,
 
        RESERVED_ISO_0x0C = 0x0CU,
 
        RESERVED_ISO_0x0D = 0x0DU,
 
        RESERVED_ISO_0x0E = 0x0EU,
 
        RESERVED_ISO_0x0F = 0x0FU,
 
        ROUTING_ACTIVATION_REQUIRED = 0x10U,
 
        UNKNOWN
    };
 
    enum class DoIpRoutingResponseCodes : uint8_t
    {
        UNKNOWN_SOURCE_ADDRESS = 0x00U,
 
        NO_FREE_SOCKET = 0x01U,
 
        WRONG_SOURCE_ADDRESS = 0x02U,
 
        SOURCE_ADDRESS_ALREADY_REGISTERED = 0x03U,
 
        MISSING_AUTHENTICATION = 0x04U,
 
        REJECTED_CONFIRMATION = 0x05U,
 
 
        UNSUPPORTED_ACTIVATION_TYPE = 0x06U,
 
        ENCRYPTED_CONNECTION_TLS = 0x07U,
 
        RESERVED_ISO_0x08 = 0x08U,
 
        RESERVED_ISO_0x09 = 0x09U,
 
        RESERVED_ISO_0x0A = 0x0AU,
 
        RESERVED_ISO_0x0B = 0x0BU,
 
        RESERVED_ISO_0x0C = 0x0CU,
 
        RESERVED_ISO_0x0D = 0x0DU,
 
        RESERVED_ISO_0x0E = 0x0EU,
 
        RESERVED_ISO_0x0F = 0x0FU,
 
        ROUTING_SUCCESSFULLY_ACTIVATED = 0x10U,
 
        CONFIRMATION_REQUIRED = 0x11U,
 
        UNKNOWN
    };
 
    enum class DoIpDiagnosticMessageNackCodes : uint8_t
    {
        RESERVED_ISO_0x00 = 0x00U,
 
        RESERVED_ISO_0x01 = 0x01U,
 
        INVALID_SOURCE_ADDRESS = 0x02U,
 
        INVALID_TARGET_ADDRESS = 0x03U,
 
        MESSAGE_TOO_LARGE = 0x04U,
 
        OUT_OF_MEMORY = 0x05U,
 
        TARGET_UNREACHABLE = 0x06U,
 
        UNKNOWN_NETWORK = 0x07U,
 
        TRANSPORT_PROTOCOL_ERROR = 0x08U,
 
        UNKNOWN
    };
 
    enum class DoIpDiagnosticPowerModeCodes : uint8_t
    {
        NOT_READY = 0x00U,
 
        READY = 0x01U,
 
        NOT_SUPPORTED = 0x02U,
 
        UNKNOWN
    };
 
    enum class DoIpDiagnosticAckCodes : uint8_t
    {
        ACK = 0x00U,
 
        UNKNOWN
    };
 
    enum class DoIpEntityStatusResponseCode : uint8_t
    {
        GATEWAY = 0x00U,
 
        NODE = 0x01U,
 
        UNKNOWN
    };
 
    enum class DoIpSyncStatus : uint8_t
    {
        VIN_AND_OR_GID_ARE_SINCHRONIZED = 0x00,
 
        RESERVED_ISO_0x01 = 0x01U,
 
        RESERVED_ISO_0x02 = 0x02U,
 
        RESERVED_ISO_0x03 = 0x03U,
 
        RESERVED_ISO_0x04 = 0x04U,
 
        RESERVED_ISO_0x05 = 0x05U,
 
        RESERVED_ISO_0x06 = 0x06U,
 
        RESERVED_ISO_0x07 = 0x07U,
 
        RESERVED_ISO_0x08 = 0x08U,
 
        RESERVED_ISO_0x09 = 0x09U,
 
        RESERVED_ISO_0x0A = 0x0AU,
 
        RESERVED_ISO_0x0B = 0x0BU,
 
        RESERVED_ISO_0x0C = 0x0CU,
 
        RESERVED_ISO_0x0D = 0x0DU,
 
        RESERVED_ISO_0x0E = 0x0EU,
 
        RESERVED_ISO_0x0F = 0x0FU,
 
        VIN_AND_OR_GID_ARE_NOT_SINCHRONIZED = 0x10U,
 
        UNKNOWN
    };
 
    enum class DoIpProtocolVersion : uint8_t
    {
        RESERVED_VER = 0x00U,
 
        ISO13400_2010 = 0x01U,
 
        ISO13400_2012 = 0x02U,
 
        ISO13400_2019 = 0x03U,
 
        ISO13400_2019_AMD1 = 0x04U,
 
        DEFAULT_VALUE = 0xFFU,
 
        UNKNOWN = 0xEF
    };
 
    enum class DoIpPayloadTypes : uint16_t
    {
        GENERIC_HEADER_NACK = 0x0000U,
 
        VEHICLE_IDENTIFICATION_REQUEST = 0x0001U,
 
        VEHICLE_IDENTIFICATION_REQUEST_WITH_EID = 0x0002U,
 
        VEHICLE_IDENTIFICATION_REQUEST_WITH_VIN = 0x0003U,
 
        VEHICLE_ANNOUNCEMENT_MESSAGE = 0x0004U,
 
        ROUTING_ACTIVATION_REQUEST = 0x0005U,
 
        ROUTING_ACTIVATION_RESPONSE = 0x0006U,
 
        ALIVE_CHECK_REQUEST = 0x0007U,
 
        ALIVE_CHECK_RESPONSE = 0x0008U,
 
        ENTITY_STATUS_REQUEST = 0x4001U,
 
        ENTITY_STATUS_RESPONSE = 0x4002U,
 
        DIAGNOSTIC_POWER_MODE_REQUEST = 0x4003U,
 
        DIAGNOSTIC_POWER_MODE_RESPONSE = 0x4004U,
 
        DIAGNOSTIC_MESSAGE = 0x8001U,
 
        DIAGNOSTIC_MESSAGE_ACK = 0x8002U,
 
        DIAGNOSTIC_MESSAGE_NACK = 0x8003U
    };
 
    enum class DoIpPorts : uint16_t
    {
        TCP_UDP_PORT = 13400U,
 
        TLS_PORT = 3496U
    };
 
    using namespace DoIpConstants;
 
    class DoIpLayer : public Layer
    {
    public:
        virtual DoIpPayloadTypes getPayloadType() const = 0;
 
        std::string getPayloadTypeAsStr() const;
 
        DoIpProtocolVersion getProtocolVersion() const;
 
        std::string getProtocolVersionAsStr() const;
 
        void setProtocolVersion(DoIpProtocolVersion version);
 
        void setProtocolVersion(uint8_t rawVersion);
 
        uint8_t getInvertProtocolVersion() const;
 
        void setInvertProtocolVersion(uint8_t iVersion);
 
        uint32_t getPayloadLength() const;
 
        void setPayloadLength(uint32_t length);
 
        static DoIpLayer* parseDoIpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        static inline bool isDoIpPort(uint16_t port);
 
        static bool isDataValid(uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        std::string toString() const override;
 
        void computeCalculateFields() override
        {}
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
    private:
        void setPayloadType(DoIpPayloadTypes payloadType);
 
        static inline bool isPayloadTypeValid(uint16_t type);
 
        static inline bool isProtocolVersionValid(uint8_t version, uint8_t inVersion, DoIpPayloadTypes type);
 
        static inline bool isPayloadLengthValid(uint32_t payloadLength, size_t dataLen);
 
    protected:
        // protected c'tors, this class cannot be instantiated by users
        DoIpLayer(size_t length);
 
        DoIpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        doiphdr* getDoIpHeader() const
        {
            return reinterpret_cast<doiphdr*>(m_Data);
        }
 
        void setHeaderFields(DoIpProtocolVersion version, DoIpPayloadTypes type, uint32_t length);
    };
 
    // inline methods definition
    inline bool DoIpLayer::isDoIpPort(uint16_t port)
    {
        auto portAsEnum = static_cast<DoIpPorts>(port);
        return (portAsEnum == DoIpPorts::TCP_UDP_PORT || portAsEnum == DoIpPorts::TLS_PORT);
    }
 
    inline bool DoIpLayer::isProtocolVersionValid(uint8_t version, uint8_t inVersion, DoIpPayloadTypes type)
    {
        const DoIpProtocolVersion parsedVersion = static_cast<DoIpProtocolVersion>(version);
 
        switch (parsedVersion)
        {
        case DoIpProtocolVersion::RESERVED_VER:
        {
            PCPP_LOG_DEBUG("[Malformed doip packet]: Reserved ISO DoIP protocol version detected: 0x"
                           << std::hex << static_cast<int>(version));
            return false;
        }
        case DoIpProtocolVersion::DEFAULT_VALUE:
            if (type != DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_VIN &&
                type != DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_EID &&
                type != DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST)
            {
                PCPP_LOG_DEBUG("[Malformed doip packet]: Invalid/unsupported DoIP version!");
                return false;
            }
        case DoIpProtocolVersion::ISO13400_2010:
        case DoIpProtocolVersion::ISO13400_2012:
        case DoIpProtocolVersion::ISO13400_2019:
        case DoIpProtocolVersion::ISO13400_2019_AMD1:
        {
            if (version != static_cast<uint8_t>(~inVersion))
            {
                PCPP_LOG_DEBUG("[Malformed doip packet]: Protocol version and inverse version mismatch! Version: 0x"
                               << std::hex << static_cast<int>(version) << ", Inverted: 0x"
                               << static_cast<int>(inVersion));
                return false;
            }
            return true;
        }
        default:
            PCPP_LOG_DEBUG("[Malformed doip packet]: Unknown DoIP protocol version: 0x" << std::hex
                                                                                        << static_cast<int>(version));
            return false;
        }
    }
 
    inline bool DoIpLayer::isPayloadTypeValid(uint16_t type)
    {
        const DoIpPayloadTypes payloadType = static_cast<DoIpPayloadTypes>(type);
 
        switch (payloadType)
        {
        case DoIpPayloadTypes::GENERIC_HEADER_NACK:
        case DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST:
        case DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_EID:
        case DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_VIN:
        case DoIpPayloadTypes::VEHICLE_ANNOUNCEMENT_MESSAGE:
        case DoIpPayloadTypes::ROUTING_ACTIVATION_REQUEST:
        case DoIpPayloadTypes::ROUTING_ACTIVATION_RESPONSE:
        case DoIpPayloadTypes::ALIVE_CHECK_REQUEST:
        case DoIpPayloadTypes::ALIVE_CHECK_RESPONSE:
        case DoIpPayloadTypes::ENTITY_STATUS_REQUEST:
        case DoIpPayloadTypes::ENTITY_STATUS_RESPONSE:
        case DoIpPayloadTypes::DIAGNOSTIC_POWER_MODE_REQUEST:
        case DoIpPayloadTypes::DIAGNOSTIC_POWER_MODE_RESPONSE:
        case DoIpPayloadTypes::DIAGNOSTIC_MESSAGE:
        case DoIpPayloadTypes::DIAGNOSTIC_MESSAGE_ACK:
        case DoIpPayloadTypes::DIAGNOSTIC_MESSAGE_NACK:
            return true;
 
        default:
            PCPP_LOG_DEBUG("[Malformed doip packet]: Invalid DoIP payload type: 0x" << std::hex << type);
            return false;
        }
    }
 
    inline bool DoIpLayer::isPayloadLengthValid(uint32_t payloadLength, size_t dataLen)
    {
        const size_t actualPayloadLen = dataLen - DOIP_HEADER_LEN;
 
        if (payloadLength != actualPayloadLen)
        {
            PCPP_LOG_DEBUG("[Malformed doip packet]: Payload length mismatch: expected "
                           << payloadLength << " bytes, but got " << actualPayloadLen << " bytes.");
            return false;
        }
 
        return true;
    }
 
    //~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpGenericHeaderNack|
    //~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpGenericHeaderNack : public DoIpLayer
    {
    public:
        DoIpGenericHeaderNack(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit DoIpGenericHeaderNack(DoIpGenericHeaderNackCodes nackCode);
 
        DoIpGenericHeaderNackCodes getNackCode() const;
 
        void setNackCode(DoIpGenericHeaderNackCodes code);
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::GENERIC_HEADER_NACK;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct generic_header_nack : doiphdr
        {
            uint8_t nackCode;
        };
#pragma pack(pop)
        generic_header_nack* getGenericHeaderNack() const
        {
            return reinterpret_cast<generic_header_nack*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(generic_header_nack);
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpVehicleIdentificationRequest|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpVehicleIdentificationRequest : public DoIpLayer
    {
    public:
        DoIpVehicleIdentificationRequest(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : DoIpLayer(data, dataLen, prevLayer, packet)
        {}
 
        DoIpVehicleIdentificationRequest();
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == DOIP_HEADER_LEN);  // No payload
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpVehicleIdentificationRequestWithEID|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpVehicleIdentificationRequestWithEID : public DoIpLayer
    {
    public:
        DoIpVehicleIdentificationRequestWithEID(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit DoIpVehicleIdentificationRequestWithEID(const std::array<uint8_t, DOIP_EID_LEN>& eid = {});
 
        std::array<uint8_t, DOIP_EID_LEN> getEID() const;
 
        void setEID(const std::array<uint8_t, DOIP_EID_LEN>& eid);
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_EID;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct vehicle_identification_request_with_eid : doiphdr
        {
            std::array<uint8_t, DOIP_EID_LEN> eid;
        };
#pragma pack(pop)
        vehicle_identification_request_with_eid* getVehicleIdentificationRequestWEID() const
        {
            return reinterpret_cast<vehicle_identification_request_with_eid*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(vehicle_identification_request_with_eid);
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpVehicleIdentificationRequestWithVIN|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpVehicleIdentificationRequestWithVIN : public DoIpLayer
    {
    public:
        DoIpVehicleIdentificationRequestWithVIN(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit DoIpVehicleIdentificationRequestWithVIN(const std::array<uint8_t, DOIP_VIN_LEN>& vin = {});
 
        std::array<uint8_t, DOIP_VIN_LEN> getVIN() const;
 
        void setVIN(const std::array<uint8_t, DOIP_VIN_LEN>& vin);
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::VEHICLE_IDENTIFICATION_REQUEST_WITH_VIN;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct vehicle_identification_request_with_vin : doiphdr
        {
            std::array<uint8_t, DOIP_VIN_LEN> vin;
        };
#pragma pack(pop)
        vehicle_identification_request_with_vin* getVehicleIdentificationRequestWVIN() const
        {
            return reinterpret_cast<vehicle_identification_request_with_vin*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(vehicle_identification_request_with_vin);
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpVehicleAnnouncementMessage|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpVehicleAnnouncementMessage : public DoIpLayer
    {
    public:
        DoIpVehicleAnnouncementMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpVehicleAnnouncementMessage(const std::array<uint8_t, DOIP_VIN_LEN>& vin, uint16_t logicalAddress,
                                       const std::array<uint8_t, DOIP_EID_LEN>& eid,
                                       const std::array<uint8_t, DOIP_GID_LEN>& gid, DoIpActionCodes actionCode);
 
        std::array<uint8_t, DOIP_VIN_LEN> getVIN() const;
 
        void setVIN(const std::array<uint8_t, DOIP_VIN_LEN>& vin);
 
        uint16_t getLogicalAddress() const;
 
        void setLogicalAddress(uint16_t address);
 
        std::array<uint8_t, DOIP_EID_LEN> getEID() const;
 
        void setEID(const std::array<uint8_t, DOIP_EID_LEN>& eid);
 
        std::array<uint8_t, DOIP_GID_LEN> getGID() const;
 
        void setGID(const std::array<uint8_t, DOIP_GID_LEN>& gid);
 
        DoIpActionCodes getFurtherActionRequired() const;
 
        void setFurtherActionRequired(DoIpActionCodes action);
 
        DoIpSyncStatus getSyncStatus() const;
 
        void setSyncStatus(DoIpSyncStatus sync);
 
        bool hasSyncStatus() const;
 
        void clearSyncStatus();
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::VEHICLE_ANNOUNCEMENT_MESSAGE;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN || dataLen == OPT_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct vehicle_announcement_message : doiphdr
        {
            std::array<uint8_t, DOIP_VIN_LEN> vin;
 
            uint16_t logicalAddress;
 
            std::array<uint8_t, DOIP_EID_LEN> eid;
 
            std::array<uint8_t, DOIP_GID_LEN> gid;
 
            uint8_t actionCode;
        };
#pragma pack(pop)
 
        vehicle_announcement_message* getVehicleAnnouncementMessage() const
        {
            return reinterpret_cast<vehicle_announcement_message*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(vehicle_announcement_message);
        static constexpr size_t SYNC_STATUS_OFFSET = FIXED_LEN;
        static constexpr size_t SYNC_STATUS_LEN = sizeof(uint8_t);
        static constexpr size_t OPT_LEN = FIXED_LEN + SYNC_STATUS_LEN;
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpRoutingActivationRequest|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpRoutingActivationRequest : public DoIpLayer
    {
    public:
        DoIpRoutingActivationRequest(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpRoutingActivationRequest(uint16_t sourceAddress, DoIpActivationTypes activationType);
 
        uint16_t getSourceAddress() const;
 
        void setSourceAddress(uint16_t value);
 
        DoIpActivationTypes getActivationType() const;
 
        void setActivationType(DoIpActivationTypes activationType);
 
        std::array<uint8_t, DOIP_RESERVED_ISO_LEN> getReservedIso() const;
 
        void setReservedIso(const std::array<uint8_t, DOIP_RESERVED_ISO_LEN>& reservedIso);
 
        std::array<uint8_t, DOIP_RESERVED_OEM_LEN> getReservedOem() const;
 
        void setReservedOem(const std::array<uint8_t, DOIP_RESERVED_OEM_LEN>& reservedOem);
 
        bool hasReservedOem() const;
 
        void clearReservedOem();
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ROUTING_ACTIVATION_REQUEST;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN || dataLen == OPT_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct routing_activation_request : doiphdr
        {
            uint16_t sourceAddress;
 
            uint8_t activationType;
 
            std::array<uint8_t, DOIP_RESERVED_ISO_LEN> reservedIso;
        };
#pragma pack(pop)
 
        routing_activation_request* getRoutingActivationRequest() const
        {
            return reinterpret_cast<routing_activation_request*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(routing_activation_request);
        static constexpr size_t RESERVED_OEM_OFFSET = FIXED_LEN;
        static constexpr size_t OPT_LEN = FIXED_LEN + DOIP_RESERVED_OEM_LEN;
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpRoutingActivationResponse|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpRoutingActivationResponse : public DoIpLayer
    {
    public:
        DoIpRoutingActivationResponse(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpRoutingActivationResponse(uint16_t logicalAddressExternalTester, uint16_t sourceAddress,
                                      DoIpRoutingResponseCodes responseCode);
 
        uint16_t getLogicalAddressExternalTester() const;
 
        void setLogicalAddressExternalTester(uint16_t addr);
 
        uint16_t getSourceAddress() const;
 
        void setSourceAddress(uint16_t sourceAddress);
 
        DoIpRoutingResponseCodes getResponseCode() const;
 
        void setResponseCode(DoIpRoutingResponseCodes code);
 
        std::array<uint8_t, DOIP_RESERVED_ISO_LEN> getReservedIso() const;
 
        void setReservedIso(const std::array<uint8_t, DOIP_RESERVED_ISO_LEN>& reservedIso);
 
        std::array<uint8_t, DOIP_RESERVED_OEM_LEN> getReservedOem() const;
 
        void setReservedOem(const std::array<uint8_t, DOIP_RESERVED_OEM_LEN>& reservedOem);
 
        bool hasReservedOem() const;
 
        void clearReservedOem();
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ROUTING_ACTIVATION_RESPONSE;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN || dataLen == OPT_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct routing_activation_response : doiphdr
        {
            uint16_t logicalAddressExternalTester;
 
            uint16_t sourceAddress;
 
            uint8_t responseCode;
 
            std::array<uint8_t, DOIP_RESERVED_ISO_LEN> reservedIso;
        };
#pragma pack(pop)
        routing_activation_response* getRoutingActivationResponse() const
        {
            return reinterpret_cast<routing_activation_response*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(routing_activation_response);
        static constexpr size_t RESERVED_OEM_OFFSET = FIXED_LEN;
        static constexpr size_t OPT_LEN = FIXED_LEN + DOIP_RESERVED_OEM_LEN;
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpAliveCheckRequest|
    //~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpAliveCheckRequest : public DoIpLayer
    {
    public:
        DoIpAliveCheckRequest(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : DoIpLayer(data, dataLen, prevLayer, packet)
        {}
 
        DoIpAliveCheckRequest();
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ALIVE_CHECK_REQUEST;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == DOIP_HEADER_LEN);  // No payload
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpAliveCheckResponse|
    //~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpAliveCheckResponse : public DoIpLayer
    {
    public:
        DoIpAliveCheckResponse(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit DoIpAliveCheckResponse(uint16_t sourceAddress);
 
        uint16_t getSourceAddress() const;
 
        void setSourceAddress(uint16_t address);
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ALIVE_CHECK_RESPONSE;
        }
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct alive_check_response : doiphdr
        {
            uint16_t sourceAddress;
        };
#pragma pack(pop)
        alive_check_response* getAliveCheckResponse() const
        {
            return reinterpret_cast<alive_check_response*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(alive_check_response);
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpEntityStatusRequest|
    //~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpEntityStatusRequest : public DoIpLayer
    {
    public:
        DoIpEntityStatusRequest(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : DoIpLayer(data, dataLen, prevLayer, packet)
        {}
 
        DoIpEntityStatusRequest();
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ENTITY_STATUS_REQUEST;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == DOIP_HEADER_LEN);  // No payload
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpEntityStatusResponse|
    //~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpEntityStatusResponse : public DoIpLayer
    {
    public:
        DoIpEntityStatusResponse(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpEntityStatusResponse(DoIpEntityStatusResponseCode nodeType, uint8_t maxConcurrentSockets,
                                 uint8_t currentlyOpenSockets);
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::ENTITY_STATUS_RESPONSE;
        }
 
        DoIpEntityStatusResponseCode getNodeType() const;
 
        uint8_t getMaxConcurrentSockets() const;
 
        uint8_t getCurrentlyOpenSockets() const;
 
        uint32_t getMaxDataSize() const;
 
        void setNodeType(DoIpEntityStatusResponseCode status);
 
        void setMaxConcurrentSockets(uint8_t sockets);
 
        void setCurrentlyOpenSockets(uint8_t sockets);
 
        void setMaxDataSize(uint32_t data);
 
        bool hasMaxDataSize() const;
 
        void clearMaxDataSize();
 
        std::string getSummary() const;
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN || dataLen == OPT_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct entity_status_response : doiphdr
        {
            uint8_t nodeType;
 
            uint8_t maxConcurrentSockets;
 
            uint8_t currentlyOpenSockets;
        };
#pragma pack(pop)
 
        entity_status_response* getEntityStatusResponse() const
        {
            return reinterpret_cast<entity_status_response*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(entity_status_response);
        static constexpr size_t MAX_DATA_SIZE_OFFSET = FIXED_LEN;
        static constexpr size_t MAX_DATA_SIZE_LEN = sizeof(uint32_t);
        static constexpr size_t OPT_LEN = FIXED_LEN + MAX_DATA_SIZE_LEN;
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticPowerModeRequest|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticPowerModeRequest : public DoIpLayer
    {
    public:
        DoIpDiagnosticPowerModeRequest(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : DoIpLayer(data, dataLen, prevLayer, packet)
        {}
 
        DoIpDiagnosticPowerModeRequest();
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::DIAGNOSTIC_POWER_MODE_REQUEST;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == DOIP_HEADER_LEN);  // No payload
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticPowerModeResponse|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticPowerModeResponse : public DoIpLayer
    {
    public:
        DoIpDiagnosticPowerModeResponse(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        explicit DoIpDiagnosticPowerModeResponse(DoIpDiagnosticPowerModeCodes modeCode);
 
        DoIpDiagnosticPowerModeCodes getPowerModeCode() const;
 
        void setPowerModeCode(DoIpDiagnosticPowerModeCodes code);
 
        std::string getSummary() const;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::DIAGNOSTIC_POWER_MODE_RESPONSE;
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen == FIXED_LEN);
        }
 
    private:
#pragma pack(push, 1)
        struct diagnostic_power_mode_response : doiphdr
        {
            uint8_t powerModeCode;
        };
#pragma pack(pop)
        diagnostic_power_mode_response* getDiagnosticPowerModeResponse() const
        {
            return reinterpret_cast<diagnostic_power_mode_response*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(diagnostic_power_mode_response);
    };
 
    //~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticBase|
    //~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticBase : public DoIpLayer
    {
    public:
        uint16_t getSourceAddress() const;
 
        void setSourceAddress(uint16_t sourceAddress);
 
        uint16_t getTargetAddress() const;
 
        void setTargetAddress(uint16_t targetAddress);
 
        virtual std::string getSummary() const = 0;
 
    protected:
        DoIpDiagnosticBase(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpDiagnosticBase(size_t length) : DoIpLayer(length) {};
 
#pragma pack(push, 1)
        struct common_diagnostic_header : doiphdr
        {
            uint16_t sourceAddress;
 
            uint16_t targetAddress;
        };
#pragma pack(pop)
        common_diagnostic_header* getCommonDiagnosticHeader() const
        {
            return reinterpret_cast<common_diagnostic_header*>(m_Data);
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticMessage|
    //~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticMessage : public DoIpDiagnosticBase
    {
    public:
        DoIpDiagnosticMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpDiagnosticMessage(uint16_t sourceAddress, uint16_t targetAddress,
                              const std::vector<uint8_t>& diagnosticData);
 
        void setDiagnosticData(const std::vector<uint8_t>& data);
 
        std::vector<uint8_t> getDiagnosticData() const;
 
        std::string getSummary() const override;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::DIAGNOSTIC_MESSAGE;
        }
 
        // override getHeaderLen()
        size_t getHeaderLen() const override
        {
            return sizeof(doiphdr) + 2 * sizeof(uint16_t);
        }
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen >= MIN_LEN);
        }
 
    private:
        static constexpr size_t DIAGNOSTIC_DATA_OFFSET = sizeof(common_diagnostic_header);
        static constexpr size_t MIN_LEN = DIAGNOSTIC_DATA_OFFSET + 1; /*Min diagnostic request Len*/
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticResponseMessageBase|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
    class DoIpDiagnosticResponseMessageBase : public DoIpDiagnosticBase
    {
    public:
        uint8_t getResponseCode() const;
 
        void setResponseCode(uint8_t code);
 
        std::vector<uint8_t> getPreviousMessage() const;
 
        bool hasPreviousMessage() const;
 
        void setPreviousMessage(const std::vector<uint8_t>& msg);
 
        void clearPreviousMessage();
 
        static inline bool isDataLenValid(size_t dataLen)
        {
            return (dataLen >= FIXED_LEN);
        }
 
    protected:
        DoIpDiagnosticResponseMessageBase(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
        DoIpDiagnosticResponseMessageBase(uint16_t sourceAddress, uint16_t targetAddress, DoIpPayloadTypes type);
 
    private:
#pragma pack(push, 1)
        struct diagnostic_response_message_base : common_diagnostic_header
        {
            uint8_t diagnosticCode;
        };
#pragma pack(pop)
        diagnostic_response_message_base* getDiagnosticResponseMessageBase() const
        {
            return reinterpret_cast<diagnostic_response_message_base*>(m_Data);
        }
        static constexpr size_t FIXED_LEN = sizeof(diagnostic_response_message_base);
        static constexpr size_t PREVIOUS_MSG_OFFSET = FIXED_LEN;
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticMessageAck|
    //~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticMessageAck : public DoIpDiagnosticResponseMessageBase
    {
    public:
        DoIpDiagnosticMessageAck(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpDiagnosticMessageAck(uint16_t sourceAddress, uint16_t targetAddress, DoIpDiagnosticAckCodes ackCode);
 
        DoIpDiagnosticAckCodes getAckCode() const;
 
        void setAckCode(DoIpDiagnosticAckCodes code);
 
        std::string getSummary() const override;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::DIAGNOSTIC_MESSAGE_ACK;
        }
    };
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~|
    // DoIpDiagnosticMessageNack|
    //~~~~~~~~~~~~~~~~~~~~~~~~~~|
 
    class DoIpDiagnosticMessageNack : public DoIpDiagnosticResponseMessageBase
    {
    public:
        DoIpDiagnosticMessageNack(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DoIpDiagnosticMessageNack(uint16_t sourceAddress, uint16_t targetAddress,
                                  DoIpDiagnosticMessageNackCodes nackCode);
 
        DoIpDiagnosticMessageNackCodes getNackCode() const;
 
        void setNackCode(DoIpDiagnosticMessageNackCodes code);
 
        std::string getSummary() const override;
 
        DoIpPayloadTypes getPayloadType() const override
        {
            return DoIpPayloadTypes::DIAGNOSTIC_MESSAGE_NACK;
        }
    };
 
}  // namespace pcpp