SOME/IP Message Format & Serialization

import struct

# SOME/IP header: 16 bytes, all big-endian
# ┌──────────┬──────────┬──────────────────────┬──────────┬──────────┐
# │ Svc ID   │ Meth ID  │ Length               │ Clnt ID  │ Sess ID  │
# │ 2 bytes  │ 2 bytes  │ 4 bytes              │ 2 bytes  │ 2 bytes  │
# ├──────────┴──────────┴──────────────────────┴──────────┴──────────┤
# │ Proto Ver│ Iface Ver│ Msg Type             │ Ret Code │ Payload  │
# │ 1 byte   │ 1 byte   │ 1 byte               │ 1 byte   │ variable │
# └──────────┴──────────┴──────────────────────┴──────────┴──────────┘

MSG_TYPE = {0x00:"Request", 0x01:"RequestNoReturn", 0x02:"Notification",
            0x40:"RequestACK", 0x41:"RequestNoReturnACK",
            0x80:"Response", 0x81:"Error"}

RET_CODE = {0x00:"E_OK", 0x01:"E_NOT_OK", 0x02:"E_UNKNOWN_SERVICE",
            0x03:"E_UNKNOWN_METHOD", 0x04:"E_NOT_READY",
            0x05:"E_NOT_REACHABLE", 0x08:"E_MALFORMED_MESSAGE",
            0x09:"E_WRONG_PROTOCOL_VERSION", 0x0A:"E_WRONG_INTERFACE_VERSION"}

def parse_someip(data: bytes) -> dict:
    if len(data) < 16:
        raise ValueError(f"Too short: {len(data)} bytes")
    svc, meth, length, client, session = struct.unpack(">HHIHH", data[:14])
    proto_ver, iface_ver, msg_type, ret_code = struct.unpack("BBBB", data[12:16])
    payload_len = length - 8  # length field includes 8 bytes after it
    return {
        "service_id":  f"0x{svc:04X}",
        "method_id":   f"0x{meth:04X}",
        "payload_len": payload_len,
        "client_id":   f"0x{client:04X}",
        "session_id":  f"0x{session:04X}",
        "proto_ver":   proto_ver,
        "iface_ver":   iface_ver,
        "msg_type":    MSG_TYPE.get(msg_type, f"0x{msg_type:02X}"),
        "ret_code":    RET_CODE.get(ret_code, f"0x{ret_code:02X}"),
        "payload":     data[16:16+payload_len]
    }

def build_someip_request(svc_id, meth_id, client_id, session_id, payload=b""):
    length = 8 + len(payload)   # 8 = 4 (client+session) + 4 (metadata)
    hdr = struct.pack(">HHIHH", svc_id, meth_id, length, client_id, session_id)
    hdr += struct.pack("BBBB", 1, 1, 0x00, 0x00)  # proto=1, iface=1, REQ, E_OK
    return hdr + payload

// SOME/IP payload serialisation: AUTOSAR SOME/IP Transformer (SomeIpXf)
// All integers big-endian; strings length-prefixed; structs packed

#include 
#include 
#include 
#include 

class SomeIpSerializer {
public:
    // Append uint8
    void push_u8(uint8_t v)  { buf_.push_back(v); }

    // Append uint16 big-endian
    void push_u16(uint16_t v) {
        buf_.push_back(static_cast(v >> 8));
        buf_.push_back(static_cast(v & 0xFF));
    }

    // Append uint32 big-endian
    void push_u32(uint32_t v) {
        for (int i = 3; i >= 0; --i)
            buf_.push_back(static_cast((v >> (i*8)) & 0xFF));
    }

    // Append float32 (IEEE 754, big-endian byte order)
    void push_f32(float v) {
        uint32_t bits;
        std::memcpy(&bits, &v, 4);
        push_u32(bits);
    }

    // Append length-delimited string (4-byte length prefix, UTF-8, no null)
    void push_string(const std::string &s) {
        push_u32(static_cast(s.size()));
        buf_.insert(buf_.end(), s.begin(), s.end());
    }

    std::vector finish() { return std::move(buf_); }

private:
    std::vector buf_;
};

// Example: serialise VehicleStatus struct
struct VehicleStatus {
    uint16_t speed_kmh;       // 2 bytes
    float    fuel_level_pct;  // 4 bytes (float32)
    uint8_t  gear;            // 1 byte
};

std::vector serialise_vehicle_status(const VehicleStatus &s) {
    SomeIpSerializer ser;
    ser.push_u16(s.speed_kmh);
    ser.push_f32(s.fuel_level_pct);
    ser.push_u8(s.gear);
    return ser.finish();  // 7 bytes
}