SomeIpSdLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_SOMEIPSD_LAYER
#define PACKETPP_SOMEIPSD_LAYER

#include "EndianPortable.h"
#include "IpAddress.h"
#include "Layer.h"
#include "SomeIpLayer.h"
#include <cstring>
#include <iterator>
#include <map>
#include <memory>
#include <stdexcept>
#include <vector>


namespace pcpp
{
enum SomeIpSdProtocolType : uint8_t
{
    SD_TCP = 0x06,
    SD_UDP = 0x11
};

class SomeIpSdLayer;

class SomeIpSdOption
{
public:
    friend class SomeIpSdLayer;

    enum class OptionType : uint8_t
    {
        Unknown = 0x00,
        ConfigurationString = 0x01,
        LoadBalancing = 0x02,
        IPv4Endpoint = 0x04,
        IPv6Endpoint = 0x06,
        IPv4Multicast = 0x14,
        IPv6Multicast = 0x16,
        IPv4SdEndpoint = 0x24,
        IPv6SdEndpoint = 0x26
    };

#pragma pack(push, 1)
    struct someipsdhdroptionsbase
    {
        uint16_t length;
        uint8_t type;
        uint8_t reserved;
    };
#pragma pack(pop)

    virtual ~SomeIpSdOption();

    OptionType getType() const;

    size_t getLength() const { return m_DataLen; }

    uint8_t *getDataPtr() const;

    someipsdhdroptionsbase *getSomeIpSdOptionHeader() const;

protected:
    const IDataContainer *m_DataContainer;
    size_t m_Offset;
    uint8_t *m_ShadowData;
    size_t m_DataLen;

    SomeIpSdOption() : m_DataContainer(nullptr), m_Offset(0), m_ShadowData(nullptr), m_DataLen(0) {}

    SomeIpSdOption(const IDataContainer *dataContainer, size_t offset)
        : m_DataContainer(dataContainer), m_Offset(offset), m_ShadowData(nullptr), m_DataLen(0) {}

    void initStdFields(OptionType type);

    SomeIpSdOption(const SomeIpSdOption &) = delete;
    SomeIpSdOption &operator=(const SomeIpSdOption &) = delete;
};

class SomeIpSdIPv4Option : public SomeIpSdOption
{
public:
    friend class SomeIpSdLayer;

    enum IPv4OptionType
    {
        IPv4Endpoint,
        IPv4Multicast,
        IPv4SdEndpoint,
    };

    SomeIpSdIPv4Option(IPv4OptionType type, IPv4Address ipAddress, uint16_t port, SomeIpSdProtocolType l4Protocol);

    SomeIpSdIPv4Option(const IDataContainer *dataContainer, size_t offset);

    IPv4Address getIpAddress() const;

    uint16_t getPort() const;

    SomeIpSdProtocolType getProtocol() const;

private:
#pragma pack(push, 1)
    struct someipsdhdroptionsipv4 : someipsdhdroptionsbase
    {
        /* IPv4-Address field */
        uint32_t ipv4Address;
        /* Reserved */
        uint8_t reserved;
        /* Layer 4 Protocol field (L4-Proto) - Either UDP or TCP */
        SomeIpSdProtocolType l4Protocol;
        /* Port number of UDP or TCP */
        uint16_t portNumber;
    };
#pragma pack(pop)
};

class SomeIpSdIPv6Option : public SomeIpSdOption
{
public:
    friend class SomeIpSdLayer;

    enum IPv6OptionType
    {
        IPv6Endpoint,
        IPv6Multicast,
        IPv6SdEndpoint,
    };

    SomeIpSdIPv6Option(IPv6OptionType type, IPv6Address ipAddress, uint16_t port, SomeIpSdProtocolType l4Protocol);

    SomeIpSdIPv6Option(const IDataContainer *dataContainer, size_t offset);

    IPv6Address getIpAddress() const;

    uint16_t getPort() const;

    SomeIpSdProtocolType getProtocol() const;

private:
#pragma pack(push, 1)
    struct someipsdhdroptionsipv6 : someipsdhdroptionsbase
    {
        /* IPv6-Address field */
        uint8_t ipv6Address[16];
        /* Reserved */
        uint8_t reserved;
        /* Layer 4 Protocol field (L4-Proto) - Either UDP or TCP */
        SomeIpSdProtocolType l4Protocol;
        /* Port number of UDP or TCP */
        uint16_t portNumber;
    };
#pragma pack(pop)
};

class SomeIpSdConfigurationOption : public SomeIpSdOption
{
public:
    friend class SomeIpSdLayer;

    SomeIpSdConfigurationOption(const std::string &configurationString);

    SomeIpSdConfigurationOption(const IDataContainer *dataContainer, size_t offset);

    std::string getConfigurationString() const;
};

class SomeIpSdLoadBalancingOption : public SomeIpSdOption
{
public:
    friend class SomeIpSdLayer;

    SomeIpSdLoadBalancingOption(uint16_t priority, uint16_t weight);

    SomeIpSdLoadBalancingOption(const IDataContainer *dataContainer, size_t offset);

    uint16_t getPriority() const;

    uint16_t getWeight() const;

private:
#pragma pack(push, 1)
    struct someipsdhdroptionsload : someipsdhdroptionsbase
    {
        /* Priority field */
        uint16_t priority;
        /* Weight field */
        uint16_t weight;
    };
#pragma pack(pop)
};

class SomeIpSdEntry
{
public:
    friend class SomeIpSdLayer;

    enum class EntryType : uint8_t
    {
        FindService,
        OfferService,
        StopOfferService,
        SubscribeEventgroup,
        StopSubscribeEventgroup,
        SubscribeEventgroupAck,
        SubscribeEventgroupNack,
        UnknownEntryType
    };

#pragma pack(push, 1)
    struct someipsdhdrentry
    {
        uint8_t type;
        uint8_t indexFirstOption;
        uint8_t indexSecondOption;
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t
            nrOpt2 : 4,
            nrOpt1 : 4;
#else
        uint8_t
            nrOpt1 : 4,
            nrOpt2 : 4;
#endif

        uint16_t serviceID;
        uint16_t instanceID;
        uint32_t majorVersion_ttl;
        uint32_t data;
    };
#pragma pack(pop)

    SomeIpSdEntry(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL,
                  uint32_t minorVersion);

    SomeIpSdEntry(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL,
                  uint8_t counter, uint16_t eventGroupID);

    SomeIpSdEntry(const SomeIpSdLayer *pSomeIpSdLayer, size_t offset);

    ~SomeIpSdEntry();

    uint8_t *getDataPtr() const;

    someipsdhdrentry *getSomeIpSdEntryHeader() const;

    EntryType getType() const { return m_EntryType; }

    size_t getLength() const { return sizeof(someipsdhdrentry); }

    uint32_t getNumOptions() const;

    uint16_t getServiceId() const;

    void setServiceId(uint16_t serviceId);

    uint16_t getInstanceId() const;

    void setInstanceId(uint16_t instanceId);

    uint8_t getMajorVersion() const;

    void setMajorVersion(uint8_t majorVersion);

    uint32_t getTtl() const;

    void setTtl(uint32_t ttl);

    uint32_t getMinorVersion() const;

    void setMinorVersion(uint32_t minorVersion);

    uint8_t getCounter() const;

    void setCounter(uint8_t counter);

    uint16_t getEventgroupId() const;

    void setEventgroupId(uint16_t eventgroupID);

private:
    enum class TypeInternal : uint8_t
    {
        FindService_Internal = 0x00,
        OfferService_Internal = 0x01,
        SubscribeEventgroup_Internal = 0x06,
        SubscribeEventgroupAck_Internal = 0x07,
    };

    EntryType m_EntryType;
    const SomeIpSdLayer *m_Layer;
    size_t m_Offset;
    uint8_t *m_ShadowData;

    void initStdFields(EntryType type, uint16_t serviceID, uint16_t instanceID, uint8_t majorVersion, uint32_t TTL);

    SomeIpSdEntry(const SomeIpSdEntry &) = delete;
    SomeIpSdEntry &operator=(const SomeIpSdEntry &) = delete;

    static const uint32_t SOMEIPSD_HDR_ENTRY_MASK_TTL = 0x00FFFFFF;
};

class SomeIpSdLayer : public SomeIpLayer
{
public:
    friend class SomeIpSdEntry;

    typedef SomeIpSdEntry* EntryPtr;
    typedef std::vector<EntryPtr> EntriesVec;
    typedef SomeIpSdOption* OptionPtr;
    typedef std::vector<OptionPtr> OptionsVec;

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

    SomeIpSdLayer(uint16_t serviceID, uint16_t methodID, uint16_t clientID, uint16_t sessionID,
                  uint8_t interfaceVersion, MsgType type, uint8_t returnCode, uint8_t flags);

    ~SomeIpSdLayer() {}

    static bool isSomeIpSdPort(uint16_t port) { return port == 30490; }

    uint8_t getFlags() const;

    void setFlags(uint8_t flags);

    uint32_t getNumEntries() const;

    uint32_t getNumOptions() const;

    const EntriesVec getEntries() const;

    const OptionsVec getOptions() const;

    const OptionsVec getOptionsFromEntry(uint32_t index) const;

    uint32_t addEntry(const SomeIpSdEntry &entry);

    bool addOptionTo(uint32_t indexEntry, const SomeIpSdOption &option);

    void computeCalculateFields() {};

    std::string toString() const;

private:
#pragma pack(push, 1)
    struct someipsdhdr : someiphdr
    {
        uint8_t flags;
        uint8_t reserved1;
        uint8_t reserved2;
        uint8_t reserved3;
    };
#pragma pack(pop)

    uint32_t m_NumOptions;

    uint32_t countOptions();
    uint32_t findOption(const SomeIpSdOption &option);
    void addOption(const SomeIpSdOption &option);
    bool addOptionIndex(uint32_t indexEntry, uint32_t indexOffset);
    OptionPtr parseOption(SomeIpSdOption::OptionType type, size_t offset) const;

    size_t getLenEntries() const;
    size_t getLenOptions() const;
    void setLenEntries(uint32_t length);
    void setLenOptions(uint32_t length);
};

} // namespace pcpp
#endif /* PACKETPP_SOMEIPSD_LAYER */