SomeIpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_SOMEIP_LAYER
#define PACKETPP_SOMEIP_LAYER

#include "Layer.h"
#include <unordered_set>


namespace pcpp
{

class SomeIpLayer : public Layer
{
public:
    enum class MsgType : uint8_t
    {
        REQUEST = 0x00,
        REQUEST_ACK = 0x40,
        REQUEST_NO_RETURN = 0x01,
        REQUEST_NO_RETURN_ACK = 0x41,
        NOTIFICATION = 0x02,
        NOTIFICATION_ACK = 0x42,
        RESPONSE = 0x80,
        RESPONSE_ACK = 0xC0,
        ERRORS = 0x81,
        ERROR_ACK = 0xC1,
        TP_REQUEST = 0x20,
        TP_REQUEST_NO_RETURN = 0x21,
        TP_NOTIFICATION = 0x22,
        TP_RESPONSE = 0xa0,
        TP_ERROR = 0xa1,
    };

#pragma pack(push, 1)
    struct someiphdr
    {
        uint16_t serviceID;
        uint16_t methodID;
        uint32_t length;
        uint16_t clientID;
        uint16_t sessionID;
        uint8_t protocolVersion;
        uint8_t interfaceVersion;
        uint8_t msgType;
        uint8_t returnCode;
    };
#pragma pack(pop)

    SomeIpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
        : Layer(data, dataLen, prevLayer, packet)
    {
        m_Protocol = SomeIP;
    }

    SomeIpLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID, uint8_t interfaceVersion,
                MsgType type, uint8_t returnCode, const uint8_t *const data = nullptr, size_t dataLen = 0);

    ~SomeIpLayer() {}

    static Layer* parseSomeIpLayer(uint8_t *data, size_t dataLen, Layer* prevLayer, Packet* packet);

    someiphdr *getSomeIpHeader() const { return (someiphdr *)m_Data; }

    static bool isSomeIpPort(uint16_t port);

    static void addSomeIpPort(uint16_t port);

    static void removeSomeIpPort(uint16_t port);

    static void removeAllSomeIpPorts();

    uint32_t getMessageID() const;

    void setMessageID(uint32_t messageID);

    uint16_t getServiceID() const;

    void setServiceID(uint16_t serviceID);

    uint16_t getMethodID() const;

    void setMethodID(uint16_t methodID);

    uint32_t getLengthField() const;

    uint32_t getRequestID() const;

    void setRequestID(uint32_t requestID);

    uint16_t getSessionID() const;

    void setSessionID(uint16_t sessionID);

    uint16_t getClientID() const;

    void setClientID(uint16_t clientID);

    uint8_t getProtocolVersion() const;

    void setProtocolVersion(uint8_t version);

    uint8_t getInterfaceVersion() const;

    void setInterfaceVersion(uint8_t version);

    uint8_t getMessageTypeAsInt() const;

    SomeIpLayer::MsgType getMessageType() const;

    void setMessageType(MsgType type);

    void setMessageType(uint8_t type);

    uint8_t getReturnCode() const;

    void setReturnCode(uint8_t returnCode);

    void setPayloadLength(uint32_t payloadLength);

    uint8_t *getPduPayload() const { return m_Data + getSomeIpHeaderLen(); }

    size_t getPduPayloadSize() const { return getHeaderLen() - getSomeIpHeaderLen(); }

    size_t getHeaderLen() const { return sizeof(uint32_t) * 2 + getLengthField(); }

    virtual void computeCalculateFields() {}

    void parseNextLayer();

    virtual std::string toString() const;

    OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }

protected:
    SomeIpLayer() {}

private:
    static const uint8_t SOMEIP_PROTOCOL_VERSION = 1;
    virtual size_t getSomeIpHeaderLen() const { return sizeof(someiphdr); }

    /* Using unordered_set since insertion and search should be almost constant time */
    static std::unordered_set<uint16_t> m_SomeIpPorts;
};

class SomeIpTpLayer : public SomeIpLayer
{
public:
#pragma pack(push, 1)
    struct someiptphdr : someiphdr
    {
        uint32_t offsetAndFlag;
    };
#pragma pack(pop)

    SomeIpTpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
        : SomeIpLayer(data, dataLen, prevLayer, packet) {}

    SomeIpTpLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID,
                  uint8_t interfaceVersion, MsgType type, uint8_t returnCode, uint32_t offset, bool moreSegmentsFlag,
                  const uint8_t *const data = nullptr, size_t dataLen = 0);

    ~SomeIpTpLayer() {}

    someiptphdr *getSomeIpTpHeader() const { return (someiptphdr *)m_Data; }

    uint32_t getOffset() const;

    void setOffset(uint32_t offset);

    bool getMoreSegmentsFlag() const;

    void setMoreSegmentsFlag(bool flag);

    void computeCalculateFields();

    std::string toString() const;

private:
    static const uint32_t SOMEIP_TP_MORE_FLAG_MASK = 0x01;
    static const uint32_t SOMEIP_TP_OFFSET_MASK = 0xFFFFFFF0;

    size_t getSomeIpHeaderLen() const { return sizeof(someiptphdr); }

    static uint8_t setTpFlag(uint8_t messageType);
};

} // namespace pcpp
#endif /* PACKETPP_SOMEIP_LAYER */