someip_types.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#include <stddef.h>
#include <array>
 
namespace adtf
{
namespace devicetb
{
namespace sdk
{
namespace someip
{
namespace brake
{
 
enum class tMessageType : uint8_t
{
    // Basic request, expect response with MT_RESPONSE
    MT_REQUEST = 0x00,
    // Fire&forget flag if MT_RESPONSE is not set, error flag if MT_RESPONSE is set
    MT_REQUEST_NO_RETURN = 0x01,
    // Notification flag, no response expected
    MT_NOTIFICATION = 0x02,
    // Response flag
    MT_RESPONSE = 0x80,
    // Error, indicated by combination of MT_RESPONSE and MT_REQUEST_NO_RETURN
    MT_ERROR = 0x81,
 
    // Ack flag, found on empty messages, may be combined with all other types
    MT_REQUEST_ACK = 0x40,
    MT_REQUEST_NO_RETURN_ACK = 0x41,
    MT_NOTIFICATION_ACK = 0x42,
    MT_RESPONSE_ACK = 0xC0,
    MT_ERROR_ACK = 0xC1,
 
    // Flag indicating message segmentation - may be combined with all other types
    MT_TP_REQUEST = 0x20,
    MT_TP_REQUEST_NO_RETURN = 0x21,
    MT_TP_NOTIFICATION = 0x22,
    MT_TP_RESPONSE0 = 0xA0,
    MT_TP_ERROR = 0xA1,
};
 
enum class tReturnCode : uint8_t
{
    E_OK = 0x00,
    E_NOT_OK = 0x01,
    E_UNKNOWN_SERVICE = 0x02,
    E_UNKNOWN_METHOD = 0x03,
    E_NOT_READY = 0x04,
    E_NOT_REACHABLE = 0x05,
    E_TIMEOUT = 0x06,
    E_WRONG_PROTOCOL_VERSION = 0x07,
    E_WRONG_INTERFACE_VERSION = 0x08, 
    E_MALFORMED_MESSAGE = 0x09,
    E_WRONG_MESSAGE_TYPE = 0x0a,
    E_RESERVED_MIN = 0x0b,
    E_RESERVED_MAX = 0x3f
};
 
#ifdef WIN32
#pragma warning(disable:4200)
#endif
#pragma pack(push, 1)
struct tSomeIpSampleHeader
{
    static_assert (sizeof(bool) == 1, "Unsupported Compiler: sizeof(bool) is greater than 1");
    uint16_t nVLANId = 0;
    bool bIsTCP = false;
    bool bIsIPv6 = false;
    uint16_t nMessageCount = 0;
    std::array<uint8_t, 16> aSrcIP = { };
    std::array<uint8_t, 16> aDstIP = { };
    uint16_t nSrcPort = 0;
    uint16_t nDstPort = 0;
    uint32_t nMessageDataSize = 0;
    uint8_t aMessageData[0] = { };
};
#pragma pack(pop)
#ifdef WIN32
#pragma warning(default:4200)
#endif
 
 
inline bool operator!=(const tSomeIpSampleHeader& lhs, const tSomeIpSampleHeader& rhs)
{
    return
            lhs.nVLANId != rhs.nVLANId ||
            lhs.bIsTCP != rhs.bIsTCP ||
            lhs.bIsIPv6 != rhs.bIsIPv6 ||
            lhs.nMessageCount != rhs.nMessageCount ||
            lhs.aSrcIP != rhs.aSrcIP ||
            lhs.aDstIP != rhs.aDstIP ||
            lhs.nSrcPort != rhs.nSrcPort ||
            lhs.nDstPort != rhs.nDstPort ||
            lhs.nMessageDataSize != rhs.nMessageDataSize;
}
 
inline bool operator==(const tSomeIpSampleHeader& lhs, const tSomeIpSampleHeader& rhs)
{
    return !(lhs != rhs);
}
 
}
using tMessageType = brake::tMessageType;
using tReturnCode = brake::tReturnCode;
 
namespace hood
{
#ifdef WIN32
#pragma warning(disable:4200)
#endif
#pragma pack(push, 1)
 
struct tSomeIpMessageHeader
{
    uint16_t nServiceId = 0;
    // MSB is Flag for Event Id instead of Method Id
    uint16_t nMethodId = 0;
    // Number of payload bytes after this header, not including this header itself
    uint32_t nLength = 0;
 
    // Returns 32bit header ID in host-byte-order
    uint32_t GetHeaderId() const {
        const auto d = reinterpret_cast<const uint8_t*>(&nServiceId);
        return (static_cast<uint32_t>(d[0]) << 24) + (static_cast<uint32_t>(d[1]) << 16) + (static_cast<uint32_t>(d[2]) << 8) + static_cast<uint32_t>(d[3]);
    }
 
    // Returns 32bit length in host-byte-order
    uint32_t GetLength() const {
        const auto d = reinterpret_cast<const uint8_t*>(&nLength);
        return (static_cast<uint32_t>(d[0]) << 24) + (static_cast<uint32_t>(d[1]) << 16) + (static_cast<uint32_t>(d[2]) << 8) + static_cast<uint32_t>(d[3]);
    }
};
 
struct tSomeIpSampleHeader
{
    static_assert (sizeof(bool) == 1, "Unsupported Compiler: sizeof(bool) is greater than 1");
    uint16_t nVLANId = 0;
    bool bIsTCP = false;
    bool bIsIPv6 = false;
    uint16_t nMessageCount = 0;
    uint8_t aSrcIP[16] = { 0 };
    uint8_t aDstIP[16] = { 0 };
    uint16_t nSrcPort = 0;
    uint16_t nDstPort = 0;
    uint32_t nMessageDataSize = 0;
};
static_assert(sizeof(hood::tSomeIpSampleHeader) == sizeof(brake::tSomeIpSampleHeader), "Incompatible header layout");
 
struct tSomeIpSessionHeader {
    uint16_t nClientId = 0;
    uint16_t nSessionId = 0;
    uint8_t nProtocolVersion = 0;
    uint8_t nInterfaceVersion = 0;
    tMessageType eMessageType = tMessageType::MT_REQUEST;
    tReturnCode eReturnCode = tReturnCode::E_OK;
 
    bool IsSegmented() const {
        return (static_cast<uint8_t>(eMessageType) & static_cast<uint8_t>(tMessageType::MT_TP_REQUEST)) != 0;
    }
};
 
struct tSomeIpTpHeader {
    // Only MSB 28bit are valid, lower 4 bit are reseved for flags and must be treated as 0
    uint32_t nOffset = 0;
    // Returns 32bit offset in host-byte-order
    uint32_t GetOffset() const {
        const auto d = reinterpret_cast<const uint8_t*>(&nOffset);
        return (static_cast<uint32_t>(d[0]) << 24) + (static_cast<uint32_t>(d[1]) << 16) + (static_cast<uint32_t>(d[2]) << 8) + static_cast<uint32_t>(d[3] & 0xf0);
    }
    bool HasMoreSegments() const {
        const auto d = reinterpret_cast<const uint8_t*>(&nOffset);
        return (d[3] & 0x01) != 0;
    }
};
 
union uLimitType
{
    // For all eBasicSignalType::BST_NONE and eBasicSignalType::BST_UNSIGNED
    uint64_t u;
    // For all eBasicSignalType::BST_SIGNED
    int64_t s;
    // For eBasicSignalType::BST_FLOAT, length 4
    float f;
    // For eBasicSignalType::BST_FLOAT, length 8
    double d;
};
 
struct tDataConstraint
{
    // Default value if not present in serialized form
    uLimitType nDefaultRawValue;
    // Plausible value range
    uLimitType nLowerRawLimit;
    uLimitType nUpperRawLimit;
};
 
struct tCompuScale
{
    // Rule applies if ((raw & nMask) >= nLowerLimit && (raw & nMask) <= nUpperLimit)
    // Multiple rules can overlap for text-table.
    // At most a single numeric conversion rule must match at a time - if no numeric rule matches, physical value is invalid.
    uLimitType nLowerLimit;
    uLimitType nUpperLimit;
 
    // Only applicable for eBasicSignalType::BST_NONE and eBasicSignalType::BST_UNSIGNED
    uint64_t nMask;
 
    union uCompuType
    {
        struct tLinear
        {
            // Use for formula physical = nFactor * raw + nOffset
            // nFactor may be 0, representing a constant
            double nFactor;
            double nOffset;
        } oLinear;
 
        struct tTextConstant
        {
            // Use for all text-tables (enums, bitfields, error codes etc.)
            const char* pText;
        } oTextConstant;
 
    } oCompuType;
 
    enum eCompuScaleType : uint8_t
    {
        LINEAR = 0,
        TEXTCONSTANT,
    } oCompuScaleType;
};
 
struct tSomeIpSerializationInfo
{
    // Name of deserialized element
    const char* pStrElementName;
    // Named type of deserialized element
    const char* pStrTypeName;
 
    // Alignment in serialized form, possibly enforces trailing padding bytes
    uint8_t nAlignment = 1;
 
    // Number of bytes used to encode the length field
    // May be overriden by wrapping TLV!
    // Length on wire is in bytes - length on on deserialized side has to be emitted as basic type field
    uint8_t nLengthBytes;
 
    // Number of direct children to this node, including deserialized-only fields
    uint32_t nChildren;
    // Offset to next sibling, 0 if no sibling exists
    uint32_t nNextSiblingOffset;
 
    // Adaptive extensions used by Autosar
    struct tTLVProperties
    {
        // Element is prepended with tag in serialized form
        // 16 bit TLV tag
        // Wire type is in bit [1:3], data id in bit [4:15], bit [0] is reserved
        // Wire type fragment of TLV may override child type (length of type, but not encoding!)
        // TLV tagged element may only have other TLV tagged siblings!
        // TLV tagged siblings may be reordered!
        // TLV tags have no representation in deserialized form
        bool bTlvCoded;
 
        // True: If data ID is never matched, element may be assumed missing and is default-deserialized
        // False: Data ID not being matched represents an invalid encoding
        // Element can't be optional if not TLV coded!
        // Optional coding is only legal within struct which allow optionals
        bool bOptional;
 
        // Data ID fragment of TLV tag
        uint16_t nDataId;
 
        enum eTLVWireType : uint8_t
        {
            WT_1_BYTE = 0,
            WT_2_BYTE = 1,
            WT_4_BYTE = 2,
            WT_8_BYTE = 3,
            WT_COMPLEX_DEFAULT_LENGTH = 4,
            WT_COMPLEX_1_BYTE_LENGTH = 5,
            WT_COMPLEX_2_BYTE_LENGTH = 6,
            WT_COMPLEX_4_BYTE_LENGTH = 7
        };
    } oTLVProperties;
 
    enum eSerializationType : uint8_t
    {
        ST_BASIC = 0,
        ST_ARRAY,
        ST_STRUCT,
        ST_UNION,
        ST_CLASSIC
    };
    eSerializationType oType = ST_BASIC;
 
    union uDetails
    {
        struct tBasicType
        {
            enum eBasicSignalType : uint8_t
            {
                BST_NONE = 0,
                BST_SIGNED,
                BST_UNSIGNED,
                BST_FLOAT,
                BST_BOOLEAN
            };
 
            // Contained data type
            eBasicSignalType nType;
 
            // Length in bytes
            // May be overriden if wrapped by TLV!
            uint8_t nLength;
 
            bool bByteOrderMotorola;
 
            tDataConstraint oDataConstraint;
 
            const tCompuScale* pCompuScales;
            size_t nCountCompuScales;
 
            const char* strUnit;
        } oBasicType;
 
        // Array type, wraps 1-3 children
        // First defining deserialization-only basic type for length field, last defining array payload type
        // Represented in serialized form by length in bytes followed by raw data
        // Represented in derserialized form by struct containing size and payload[] members
        struct tArrayType
        {
            enum eSomeIpArrayType : uint8_t
            {
                // Static size - no length field in deserialized form
                AT_FIXED = 0,
                // First child is length field in deserialized form
                AT_LINEAR,
                AT_SQUARED,
                // First two children are length fields in deserialized form
                AT_RECT,
                // VSA_FULLY_FLEXIBLE is represented by nested AT_LINEAR
            };
 
            // Serialized data layout
            eSomeIpArrayType nType;
 
            // Max size in primary dimension
            uint32_t nMaxSizeX;
            // Max size in secondary dimension, always 1 for AT_FIXED / AT_LINEAR
            // Equal to primary dimension for AT_SQUARED
            uint32_t nMaxSizeY;
        } oArrayType;
 
        // Structure type, may contain an arbitrary number of children
        struct tStructType
        {
            // See SWS_SomeIpXf_00289, if set, first child exists in deserialized form only and is "availability bitfield"
            // Only counting optional fields, presence is encoded in: (availabilityBitfield[(pos/8)] & (1<<(pos mod 8))) != 0
            bool bContainsOptionals;
        } oStructType;
 
        // Union type, contains one type selector followed by nChildren possible variants
        // First child is deserialiaztion only and contains type tag
        // Remember that type tag is 1-based, and 0 indicates null-type
        // Represented in serialized form by type tag followed by true union
        // Represented in deserialized form by struct containing selector and serialized types
        //
        // See SWS_SomeIpXf_00285 / SWS_SomeIpXf_00226, semantic of length field differs based on whether TLV tag is also present
        // With TLV tag present, length includes bytes of type selector
        // Without TLV tag, length excludes bytes of type selector
        struct tUnionType
        {
        } oUnionType;
 
        // Classic Autosar bit-packed signal
        // Only child is basic type aligned within this memory region
        // Not legal if Some/IP transformer is part of transfomer chain
        // Pure serialization detail, no deserialized equivalent
        struct tClassicType
        {
            uint64_t nStartBit;
            uint64_t nLengthInBit;
 
            // -1 if not applicable
            uint64_t nUpdateBitPosition;
        } oClassicType;
 
        // Place holder to ensure layout compatbility with future extensions
        uint8_t _reserved[64];
    } oDetail;
    static_assert(sizeof(oDetail) == sizeof(uDetails::_reserved), "tSomeIpSerializationInfo is incompatible with original hood::tSomeIpSerializationInfo");
    static_assert(alignof(uDetails) == 1, "tSomeIpSerializationInfo is incompatible with original hood::tSomeIpSerializationInfo");
};
 
struct tSomeIpTransformation
{
    enum eTransformationType : uint8_t
    {
        // Plain alias
        TT_NONE = 0,
        // Additional header containing authentification and freshness bits
        TT_E2E,
        // Reassembly of multiple messages required to reconstruct the playload
        // Both input and output payloads follow standard SOME/IP header layout
        // If referenced by tSomeIpMessageInfo, it must be last element of transformation chain
        // @warning The referenced child PDU may be ambigous as all message types and interface revisions are wrapped in the same TP PDU.
        // @warning After reassembly, re-resolve with the tMessageType::MT_TP_REQUEST bit cleared!
        TT_SOME_IP_SEGMENT,
        // Standard SOME/IP request header and signal layout
        TT_SOME_IP_TRANSFORMER,
        // Variable size service announcement list
        TT_SOME_IP_SERVICE_DISCOVERY
    };
    eTransformationType nTransformationType = TT_NONE;
 
    // Number of leading bits added by e.g. SOME/IP session header
    // Should be divisible by 8 in all normal scenarios
    uint16_t nHeaderBits = 0;
    // Number of trailing bits added by e.g. E2E authentification header
    // Should be divisible by 8 in all normal scenarios
    uint16_t nTrailingBits = 0;
 
    // If not zero, the transformed message at this step also corresponds to a different message
    uint32_t nAliasedMessageId;
 
    union uDetails
    {
        // Place holder to ensure layout compatbility with future extensions
        uint8_t _reserved[64];
    } oDetail;
    static_assert(sizeof(oDetail) == sizeof(uDetails::_reserved), "tSomeIpTransformation is incompatible with original hood::tSomeIpSerializationInfo");
    static_assert(alignof(uDetails) == 1, "tSomeIpTransformation is incompatible with original hood::tSomeIpSerializationInfo");
};
 
 
struct tSomeIpMessageInfo
{
    // Internal message ID
    // See tSomeIpSocketMessageInfo instead for the identification of this PDU on a specific socket
    uint32_t nMessageId = 0;
 
    const char* pstrName = nullptr;
    const char* pstrPath = nullptr;
 
    // Optional fixed message size - if -1 then size is fully dynamic
    // Actual message size should never exceed this size
    uint64_t nMessageSizeInBit = 0;
 
    // Default length bytes for unknown TLV tagged nodes
    // Explicit specification in TLV wire type and tSomeIpSerializationInfo:::nLengthBytes have precendence
    uint8_t nDefaultLengthBytes = 0;
 
    // Transformation directives required to locate payload
    const tSomeIpTransformation* pTransformationChain = nullptr;
    size_t nTransformationChainLength = 0;
 
    // Deserialization directives for the entire payload *after* transformation headers
    const tSomeIpSerializationInfo* pMembers = nullptr;
    size_t nMemberCount = 0;
};
struct tECUInfo
{
    // Internal ECU ID
    uint32_t nEcuId = 0;
 
    const char* pstrName = nullptr;
    const char* pstrPath = nullptr;
};
 
struct tSomeIpSocketMessageInfo
{
    // Reference to tSomeIpMessageInfo
    uint32_t nMessageId;
    // Header Id from ARXML -> SOME/IP Message Header
    uint32_t nHeaderId;
};
 
struct tSomeIpSocket
{
    uint8_t  aIP[16] = { 0 };
    uint16_t nPort = 0;
};
 
struct tSomeIpConnectionInfo
{
    // Internal connection ID
    uint32_t nConnectionId = 0;
 
    // Source and desitnation - IP and/or port may be empty if dynamic
    tSomeIpSocket oSource;
    tSomeIpSocket oDestination;
 
    bool bIsUdp = false;
 
    const tSomeIpSocketMessageInfo* aSocketMessageInfos = nullptr;
    size_t nSocketMessageInfoCount = 0;
};
 
struct tChannelInfo
{
    // Internal channel ID
    uint32_t nChannelId = 0;
 
    const char* pstrName = nullptr;
    const char* pstrPath = nullptr;
    uint16_t nVLANId = 0;
};
 
struct tClusterInfo
{
    // Internal cluster ID
    uint32_t nClusterId = 0;
 
    const char* pstrName = nullptr;
    const char* pstrPath = nullptr;
};
#pragma pack(pop)
#ifdef WIN32
#pragma warning(default:4200)
#endif
 
 
inline bool operator!=(const tSomeIpSampleHeader& lhs, const tSomeIpSampleHeader& rhs)
{
    return
            lhs.nVLANId != rhs.nVLANId ||
            lhs.bIsTCP != rhs.bIsTCP ||
            lhs.bIsIPv6 != rhs.bIsIPv6 ||
            lhs.nMessageCount != rhs.nMessageCount ||
            lhs.aSrcIP != rhs.aSrcIP ||
            lhs.aDstIP != rhs.aDstIP ||
            lhs.nSrcPort != rhs.nSrcPort ||
            lhs.nDstPort != rhs.nDstPort ||
            lhs.nMessageDataSize != rhs.nMessageDataSize;
}
 
inline bool operator==(const tSomeIpSampleHeader& lhs, const tSomeIpSampleHeader& rhs)
{
    return !(lhs != rhs);
}
 
inline bool operator!=(const tSomeIpSessionHeader& lhs, const tSomeIpSessionHeader& rhs)
{
    return
        lhs.nClientId != rhs.nClientId ||
        lhs.nSessionId != rhs.nSessionId ||
        lhs.nProtocolVersion != rhs.nProtocolVersion ||
        lhs.nInterfaceVersion != rhs.nInterfaceVersion ||
        lhs.eMessageType != rhs.eMessageType ||
        lhs.eReturnCode != rhs.eReturnCode;
}
 
inline bool operator==(const tSomeIpSessionHeader& lhs, const tSomeIpSessionHeader& rhs)
{
    return !(lhs != rhs);
}
 
}
using tSomeIpSampleHeader = hood::tSomeIpSampleHeader;
using tSomeIpMessageHeader = hood::tSomeIpMessageHeader;
using tSomeIpTpHeader = hood::tSomeIpTpHeader;
using tSomeIpSerializationInfo = hood::tSomeIpSerializationInfo;
using tSomeIpTransformation = hood::tSomeIpTransformation;
using tSomeIpSessionHeader = hood::tSomeIpSessionHeader;
using tCompuScale = hood::tCompuScale;
using tDataConstraint = hood::tDataConstraint;
using tSomeIpMessageInfo = hood::tSomeIpMessageInfo;
using tClusterInfo = hood::tClusterInfo;
using hood::operator!=;
using hood::operator==;
}
}
}
}