GvcpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "IpAddress.h"
#include "Layer.h"
#include "MacAddress.h"
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <ostream>
#include <string>
 
 
namespace pcpp
{
    using GvcpFlag = uint8_t;
 
    class GvcpLayer : public Layer
    {
    public:
        enum class GvcpCommand : uint16_t
        {
            DiscoveredCmd = 0x0002,
            DiscoveredAck = 0x0003,
            ForceIpCmd = 0x0004,
            ForceIpAck = 0x0005,
 
            PacketResendCmd = 0x0040,
            PacketResendAck = 0x0041,
 
            ReadRegCmd = 0x0080,
            ReadRegAck = 0x0081,
            WriteRegCmd = 0x0082,
            WriteRegAck = 0x0083,
            ReadMemCmd = 0x0084,
            ReadMemAck = 0x0085,
            WriteMemCmd = 0x0086,
            WriteMemAck = 0x0087,
            PendingAck = 0x0089,
 
            EventCmd = 0x00C0,
            EventAck = 0x00C1,
            EventDataCmd = 0x00C2,
            EventDataAck = 0x00C3,
 
            ActionCmd = 0x0100,
            ActionAck = 0x0101,
 
            Unknown = 0xFFFF
        };
 
        static bool isGvcpPort(uint16_t port)
        {
            return port == 3956;
        }
 
        static GvcpLayer* parseGvcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        virtual GvcpCommand getCommand() const = 0;
 
        virtual uint16_t getDataSize() const = 0;
 
        // Overridden methods
 
        void parseNextLayer() override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Command, CommandName };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Command;
 
            static const FieldDescriptor CommandName;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 2;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
        GvcpLayer() = default;
 
        GvcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, GVCP)
        {}
 
        void initLayer(size_t dataLen);
 
    private:
        static uint16_t getRawCommand(const uint8_t* data);
    };
 
    std::ostream& operator<<(std::ostream& os, GvcpLayer::GvcpCommand command);
 
    class GvcpRequestLayer : public GvcpLayer
    {
    public:
        GvcpRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpLayer(data, dataLen, prevLayer, packet)
        {}
 
        explicit GvcpRequestLayer(GvcpCommand command, GvcpFlag flag = 0, uint16_t requestId = 1)
            : GvcpRequestLayer(command, flag, requestId, 0)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        GvcpFlag getFlag() const;
 
        void setFlag(GvcpFlag flag);
 
        bool hasAcknowledgeFlag() const;
 
        uint16_t getRequestId() const;
 
        void setRequestId(uint16_t requestId);
 
        // Overridden methods
 
        GvcpCommand getCommand() const override;
 
        uint16_t getDataSize() const override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(gvcp_request_header);
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        struct SerializedFields : GvcpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GvcpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Flag, AcknowledgeRequired, RequestId };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Flag;
 
            static const FieldDescriptor AcknowledgeRequired;
 
            static const FieldDescriptor RequestId;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GvcpLayer::SerializedFields::MaxID + 3;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
#pragma pack(push, 1)
        struct gvcp_request_header
        {
            uint8_t magicNumber;
            uint8_t flag;
            uint16_t command;
            uint16_t dataSize;
            uint16_t requestId;
        };
#pragma pack(pop)
        static_assert(sizeof(gvcp_request_header) == 8, "gvcp_request_header size is not 8 bytes");
 
        GvcpRequestLayer(GvcpCommand command, GvcpFlag flag, uint16_t requestId, size_t bodyLen);
 
    private:
        // GvcpLayer::parseGvcpLayer() reads the command from the header
        friend class GvcpLayer;
 
        gvcp_request_header* getGvcpHeader() const
        {
            return reinterpret_cast<gvcp_request_header*>(m_Data);
        }
    };
 
    class GvcpAcknowledgeLayer : public GvcpLayer
    {
    public:
        enum class GvcpResponseStatus : uint16_t
        {
            Success = 0x0000,
            PacketResend = 0x0100,
            NotImplemented = 0x8001,
            InvalidParameter = 0x8002,
            InvalidAddress = 0x8003,
            WriteProtect = 0x8004,
            BadAlignment = 0x8005,
            AccessDenied = 0x8006,
            Busy = 0x8007,
            LocalProblem = 0x8008,
            MsgMismatch = 0x8009,
            InvalidProtocol = 0x800A,
            NoMsg = 0x800B,
            PacketUnavailable = 0x800C,
            DataOverrun = 0x800D,
            InvalidHeader = 0x800E,
            WrongConfig = 0x800F,
            PacketNotYetAvailable = 0x8010,
            PacketAndPrevRemovedFromMemory = 0x8011,
            PacketRemovedFromMemory = 0x8012,
            NoRefTime = 0x8013,
            PacketTemporarilyUnavailable = 0x8014,
            Overflow = 0x8015,
            ActionLate = 0x8016,
            LeaderTrailerOverflow = 0x8017,
            Error = 0x8FFF,
            Unknown = 0xFFFF
        };
 
        GvcpAcknowledgeLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpLayer(data, dataLen, prevLayer, packet)
        {}
 
        GvcpAcknowledgeLayer(GvcpResponseStatus status, GvcpCommand command, uint16_t ackId = 0)
            : GvcpAcknowledgeLayer(status, command, ackId, 0)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        GvcpResponseStatus getStatus() const;
 
        void setStatus(GvcpResponseStatus status);
 
        uint16_t getAckId() const;
 
        void setAckId(uint16_t ackId);
 
        // Overridden methods
 
        GvcpCommand getCommand() const override;
 
        uint16_t getDataSize() const override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(gvcp_ack_header);
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        struct SerializedFields : GvcpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GvcpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Status, StatusName, AckId };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Status;
 
            static const FieldDescriptor StatusName;
 
            static const FieldDescriptor AckId;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GvcpLayer::SerializedFields::MaxID + 3;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
#pragma pack(push, 1)
        struct gvcp_ack_header
        {
            uint16_t status;
            uint16_t command;
            uint16_t dataSize;
            uint16_t ackId;
        };
#pragma pack(pop)
        static_assert(sizeof(gvcp_ack_header) == 8, "gvcp_ack_header size is not 8 bytes");
 
        GvcpAcknowledgeLayer(GvcpResponseStatus status, GvcpCommand command, uint16_t ackId, size_t bodyLen);
 
    private:
        // GvcpLayer::parseGvcpLayer() reads the command from the header
        friend class GvcpLayer;
 
        gvcp_ack_header* getGvcpHeader() const
        {
            return reinterpret_cast<gvcp_ack_header*>(m_Data);
        }
    };
 
    std::ostream& operator<<(std::ostream& os, GvcpAcknowledgeLayer::GvcpResponseStatus status);
 
    class GvcpDiscoveryRequestLayer : public GvcpRequestLayer
    {
    public:
        GvcpDiscoveryRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpRequestLayer(data, dataLen, prevLayer, packet)
        {}
 
        explicit GvcpDiscoveryRequestLayer(bool allowBroadcastAck = false, bool acknowledgeRequired = true,
                                           uint16_t requestId = 1);
 
        bool hasAllowBroadcastAckFlag() const;
 
        void setAllowBroadcastAckFlag(bool allowBroadcastAck);
        struct SerializedFields : GvcpRequestLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GvcpRequestLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ AllowBroadcastAck };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor AllowBroadcastAck;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GvcpRequestLayer::SerializedFields::MaxID + 1;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class GvcpDiscoveryAcknowledgeLayer : public GvcpAcknowledgeLayer
    {
    public:
        struct GvcpVersion
        {
            uint16_t major;
            uint16_t minor;
        };
 
        GvcpDiscoveryAcknowledgeLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpAcknowledgeLayer(data, dataLen, prevLayer, packet)
        {}
 
        explicit GvcpDiscoveryAcknowledgeLayer(GvcpResponseStatus status = GvcpResponseStatus::Success,
                                               uint16_t ackId = 0);
 
        // cppcheck-suppress duplInheritedMember
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        GvcpVersion getVersion() const;
 
        void setVersion(const GvcpVersion& version);
 
        MacAddress getMacAddress() const;
 
        void setMacAddress(const MacAddress& macAddress);
 
        IPv4Address getIpAddress() const;
 
        void setIpAddress(const IPv4Address& ipAddress);
 
        IPv4Address getSubnetMask() const;
 
        void setSubnetMask(const IPv4Address& subnetMask);
 
        IPv4Address getGatewayIpAddress() const;
 
        void setGatewayIpAddress(const IPv4Address& gatewayIpAddress);
 
        std::string getManufacturerName() const;
 
        void setManufacturerName(const std::string& manufacturerName);
 
        std::string getModelName() const;
 
        void setModelName(const std::string& modelName);
 
        std::string getDeviceVersion() const;
 
        void setDeviceVersion(const std::string& deviceVersion);
 
        std::string getManufacturerSpecificInformation() const;
 
        void setManufacturerSpecificInformation(const std::string& info);
 
        std::string getSerialNumber() const;
 
        void setSerialNumber(const std::string& serialNumber);
 
        std::string getUserDefinedName() const;
 
        void setUserDefinedName(const std::string& userDefinedName);
 
        // Overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(gvcp_ack_header) + sizeof(gvcp_discovery_body);
        }
 
        struct SerializedFields : GvcpAcknowledgeLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GvcpAcknowledgeLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{
                    VersionMajor,     VersionMinor,     MacAddress, IpAddress,     SubnetMask,
                    GatewayIpAddress, ManufacturerName, ModelName,  DeviceVersion, ManufacturerSpecificInformation,
                    SerialNumber,     UserDefinedName
                };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor VersionMajor;
 
            static const FieldDescriptor VersionMinor;
 
            static const FieldDescriptor MacAddress;
 
            static const FieldDescriptor IpAddress;
 
            static const FieldDescriptor SubnetMask;
 
            static const FieldDescriptor GatewayIpAddress;
 
            static const FieldDescriptor ManufacturerName;
 
            static const FieldDescriptor ModelName;
 
            static const FieldDescriptor DeviceVersion;
 
            static const FieldDescriptor ManufacturerSpecificInformation;
 
            static const FieldDescriptor SerialNumber;
 
            static const FieldDescriptor UserDefinedName;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GvcpAcknowledgeLayer::SerializedFields::MaxID + 12;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
#pragma pack(push, 1)
        struct gvcp_discovery_body
        {
            uint16_t versionMajor;
            uint16_t versionMinor;
            uint32_t deviceMode;
            uint16_t reserved;
            uint8_t macAddress[6];
            uint32_t supportedIpConfigOptions;
            uint32_t ipConfigCurrent;
            uint8_t reserved2[12];
            uint32_t ipAddress;
            uint8_t reserved3[12];
            uint32_t subnetMask;
            uint8_t reserved4[12];
            uint32_t defaultGateway;
            char manufacturerName[32];
            char modelName[32];
            char deviceVersion[32];
            char manufacturerSpecificInformation[48];
            char serialNumber[16];
            char userDefinedName[16];
        };
#pragma pack(pop)
        static_assert(sizeof(gvcp_discovery_body) == 248, "gvcp_discovery_body size is not 248 bytes");
 
        gvcp_discovery_body* getGvcpDiscoveryBody() const
        {
            return reinterpret_cast<gvcp_discovery_body*>(m_Data + sizeof(gvcp_ack_header));
        }
    };
 
    class GvcpForceIpRequestLayer : public GvcpRequestLayer
    {
    public:
        GvcpForceIpRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpRequestLayer(data, dataLen, prevLayer, packet)
        {}
 
        GvcpForceIpRequestLayer(const MacAddress& macAddress, const IPv4Address& ipAddress,
                                const IPv4Address& subnetMask, const IPv4Address& gatewayIpAddress, GvcpFlag flag = 0,
                                uint16_t requestId = 1);
 
        // cppcheck-suppress duplInheritedMember
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        MacAddress getMacAddress() const;
 
        void setMacAddress(const MacAddress& macAddress);
 
        IPv4Address getIpAddress() const;
 
        void setIpAddress(const IPv4Address& ipAddress);
 
        IPv4Address getSubnetMask() const;
 
        void setSubnetMask(const IPv4Address& subnetMask);
 
        IPv4Address getGatewayIpAddress() const;
 
        void setGatewayIpAddress(const IPv4Address& gatewayIpAddress);
 
        // Overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(gvcp_request_header) + sizeof(gvcp_forceip_body);
        }
 
        struct SerializedFields : GvcpRequestLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GvcpRequestLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ MacAddress, IpAddress, SubnetMask, GatewayIpAddress };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor MacAddress;
 
            static const FieldDescriptor IpAddress;
 
            static const FieldDescriptor SubnetMask;
 
            static const FieldDescriptor GatewayIpAddress;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GvcpRequestLayer::SerializedFields::MaxID + 4;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
#pragma pack(push, 1)
        struct gvcp_forceip_body
        {
            uint8_t reserved[2];
            uint8_t macAddress[6];
            uint8_t reserved2[12];
            uint32_t ipAddress;
            uint8_t reserved3[12];
            uint32_t subnetMask;
            uint8_t reserved4[12];
            uint32_t gateway;
        };
#pragma pack(pop)
        static_assert(sizeof(gvcp_forceip_body) == 56, "gvcp_forceip_body size is not 56 bytes");
 
        gvcp_forceip_body* getGvcpForceIpBody() const
        {
            return reinterpret_cast<gvcp_forceip_body*>(m_Data + sizeof(gvcp_request_header));
        }
    };
 
    class GvcpForceIpAcknowledgeLayer : public GvcpAcknowledgeLayer
    {
    public:
        GvcpForceIpAcknowledgeLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GvcpAcknowledgeLayer(data, dataLen, prevLayer, packet)
        {}
 
        explicit GvcpForceIpAcknowledgeLayer(GvcpResponseStatus status = GvcpResponseStatus::Success,
                                             uint16_t ackId = 0)
            : GvcpAcknowledgeLayer(status, GvcpCommand::ForceIpAck, ackId)
        {}
    };
}  // namespace pcpp