ArpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IpAddress.h"
#include "MacAddress.h"
#include "DeprecationUtils.h"
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct arphdr
    {
        uint16_t hardwareType;
        uint16_t protocolType;
        uint8_t hardwareSize;
        uint8_t protocolSize;
        uint16_t opcode;
        uint8_t senderMacAddr[6];
        uint32_t senderIpAddr;
        uint8_t targetMacAddr[6];
        uint32_t targetIpAddr;
    };
#pragma pack(pop)
    static_assert(sizeof(arphdr) == 28, "arphdr size is not 28 bytes");
 
    enum ArpOpcode
    {
        ARP_REQUEST = 0x0001,  
        ARP_REPLY = 0x0002     
    };
 
    enum class ArpMessageType
    {
        Unknown,            
        Request,            
        Reply,              
        GratuitousRequest,  
        GratuitousReply,    
    };
 
    struct ArpRequest
    {
        MacAddress senderMacAddr;
        IPv4Address senderIpAddr;
        IPv4Address targetIpAddr;
 
        ArpRequest(MacAddress const& senderMacAddress, IPv4Address const& senderIPAddress,
                   IPv4Address const& targetIPAddress)
            : senderMacAddr(senderMacAddress), senderIpAddr(senderIPAddress), targetIpAddr(targetIPAddress) {};
    };
 
    struct ArpReply
    {
        MacAddress senderMacAddr;
        IPv4Address senderIpAddr;
        MacAddress targetMacAddr;
        IPv4Address targetIpAddr;
 
        ArpReply(MacAddress const& senderMacAddress, IPv4Address const& senderIPAddress,
                 MacAddress const& targetMacAddress, IPv4Address const& targetIPAddress)
            : senderMacAddr(senderMacAddress), senderIpAddr(senderIPAddress), targetMacAddr(targetMacAddress),
              targetIpAddr(targetIPAddress) {};
    };
 
    struct GratuitousArpRequest
    {
        MacAddress senderMacAddr;
        IPv4Address senderIpAddr;
 
        GratuitousArpRequest(MacAddress const& senderMacAddress, IPv4Address const& senderIPAddress)
            : senderMacAddr(senderMacAddress), senderIpAddr(senderIPAddress) {};
    };
 
    struct GratuitousArpReply
    {
        MacAddress senderMacAddr;
        IPv4Address senderIpAddr;
 
        GratuitousArpReply(MacAddress const& senderMacAddress, IPv4Address const& senderIPAddress)
            : senderMacAddr(senderMacAddress), senderIpAddr(senderIPAddress) {};
    };
 
    class ArpLayer : public Layer
    {
    public:
        ArpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, ARP)
        {
            m_DataLen = sizeof(arphdr);
        }
 
        ArpLayer(ArpOpcode opCode, const MacAddress& senderMacAddr, const IPv4Address& senderIpAddr,
                 const MacAddress& targetMacAddr, const IPv4Address& targetIpAddr);
 
        PCPP_DEPRECATED("This constructor has been deprecated. Please use one of the other overloads.")
        ArpLayer(ArpOpcode opCode, const MacAddress& senderMacAddr, const MacAddress& targetMacAddr,
                 const IPv4Address& senderIpAddr, const IPv4Address& targetIpAddr);
 
        explicit ArpLayer(ArpRequest const& arpRequest);
 
        explicit ArpLayer(ArpReply const& arpReply);
 
        explicit ArpLayer(GratuitousArpRequest const& gratuitousArpRequest);
 
        explicit ArpLayer(GratuitousArpReply const& gratuitousArpReply);
 
        ~ArpLayer() override = default;
 
        inline arphdr* getArpHeader() const
        {
            return reinterpret_cast<arphdr*>(m_Data);
        }
 
        ArpOpcode getOpcode() const;
 
        inline MacAddress getSenderMacAddress() const
        {
            return MacAddress(getArpHeader()->senderMacAddr);
        }
 
        inline MacAddress getTargetMacAddress() const
        {
            return MacAddress(getArpHeader()->targetMacAddr);
        }
 
        inline IPv4Address getSenderIpAddr() const
        {
            return getArpHeader()->senderIpAddr;
        }
 
        inline IPv4Address getTargetIpAddr() const
        {
            return getArpHeader()->targetIpAddr;
        }
 
        // implement abstract methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return sizeof(arphdr);
        }
 
        void computeCalculateFields() override;
 
        ArpMessageType getMessageType() const;
 
        bool isRequest() const;
 
        bool isReply() const;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return canReinterpretAs<arphdr>(data, dataLen);
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ OpCode,          SenderMacAddress, TargetMacAddress,
                                                              SenderIpAddress, TargetIpAddress,  MessageType,
                                                              HardwareType,    HardwareSize,     ProtocolType,
                                                              ProtocolSize };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor OpCode;
 
            static const FieldDescriptor SenderMacAddress;
 
            static const FieldDescriptor TargetMacAddress;
 
            static const FieldDescriptor SenderIpAddress;
 
            static const FieldDescriptor TargetIpAddress;
 
            static const FieldDescriptor MessageType;
 
            static const FieldDescriptor HardwareType;
 
            static const FieldDescriptor HardwareSize;
 
            static const FieldDescriptor ProtocolType;
 
            static const FieldDescriptor ProtocolSize;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
}  // namespace pcpp