RawPacket.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdexcept>
#ifdef _MSC_VER
#   include <winsock2.h>
#   include <time.h>
#else
#   include <sys/time.h>
#endif
#include <stddef.h>
 
#include "DeprecationUtils.h"
 
 
namespace pcpp
{
    enum LinkLayerType
    {
        LINKTYPE_NULL = 0,
        LINKTYPE_ETHERNET = 1,
        LINKTYPE_AX25 = 3,
        LINKTYPE_IEEE802_5 = 6,
        LINKTYPE_ARCNET_BSD = 7,
        LINKTYPE_SLIP = 8,
        LINKTYPE_PPP = 9,
        LINKTYPE_FDDI = 10,
        LINKTYPE_DLT_RAW1 = 12,
        LINKTYPE_DLT_RAW2 = 14,
        LINKTYPE_PPP_HDLC = 50,
        LINKTYPE_PPP_ETHER = 51,
        LINKTYPE_ATM_RFC1483 = 100,
        LINKTYPE_RAW = 101,
        LINKTYPE_C_HDLC = 104,
        LINKTYPE_IEEE802_11 = 105,
        LINKTYPE_FRELAY = 107,
        LINKTYPE_LOOP = 108,
        LINKTYPE_LINUX_SLL = 113,
        LINKTYPE_LTALK = 114,
        LINKTYPE_PFLOG = 117,
        LINKTYPE_IEEE802_11_PRISM = 119,
        LINKTYPE_IP_OVER_FC = 122,
        LINKTYPE_SUNATM = 123,
        LINKTYPE_IEEE802_11_RADIOTAP = 127,
        LINKTYPE_ARCNET_LINUX = 129,
        LINKTYPE_APPLE_IP_OVER_IEEE1394 = 138,
        LINKTYPE_MTP2_WITH_PHDR = 139,
        LINKTYPE_MTP2 = 140,
        LINKTYPE_MTP3 = 141,
        LINKTYPE_SCCP = 142,
        LINKTYPE_DOCSIS = 143,
        LINKTYPE_LINUX_IRDA = 144,
        LINKTYPE_USER0 = 147,
        LINKTYPE_USER1 = 148,
        LINKTYPE_USER2 = 149,
        LINKTYPE_USER3 = 150,
        LINKTYPE_USER4 = 151,
        LINKTYPE_USER5 = 152,
        LINKTYPE_USER6 = 153,
        LINKTYPE_USER7 = 154,
        LINKTYPE_USER8 = 155,
        LINKTYPE_USER9 = 156,
        LINKTYPE_USER10 = 157,
        LINKTYPE_USER11 = 158,
        LINKTYPE_USER12 = 159,
        LINKTYPE_USER13 = 160,
        LINKTYPE_USER14 = 161,
        LINKTYPE_USER15 = 162,
        LINKTYPE_IEEE802_11_AVS = 163,
        LINKTYPE_BACNET_MS_TP = 165,
        LINKTYPE_PPP_PPPD = 166,
        LINKTYPE_GPRS_LLC = 169,
        LINKTYPE_GPF_T = 170,
        LINKTYPE_GPF_F = 171,
        LINKTYPE_LINUX_LAPD = 177,
        LINKTYPE_BLUETOOTH_HCI_H4 = 187,
        LINKTYPE_USB_LINUX = 189,
        LINKTYPE_PPI = 192,
        LINKTYPE_IEEE802_15_4 = 195,
        LINKTYPE_SITA = 196,
        LINKTYPE_ERF = 197,
        LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR = 201,
        LINKTYPE_AX25_KISS = 202,
        LINKTYPE_LAPD = 203,
        LINKTYPE_PPP_WITH_DIR = 204,
        LINKTYPE_C_HDLC_WITH_DIR = 205,
        LINKTYPE_FRELAY_WITH_DIR = 206,
        LINKTYPE_IPMB_LINUX = 209,
        LINKTYPE_IEEE802_15_4_NONASK_PHY = 215,
        LINKTYPE_USB_LINUX_MMAPPED = 220,
        LINKTYPE_FC_2 = 224,
        LINKTYPE_FC_2_WITH_FRAME_DELIMS = 225,
        LINKTYPE_IPNET = 226,
        LINKTYPE_CAN_SOCKETCAN = 227,
        LINKTYPE_IPV4 = 228,
        LINKTYPE_IPV6 = 229,
        LINKTYPE_IEEE802_15_4_NOFCS = 230,
        LINKTYPE_DBUS = 231,
        LINKTYPE_DVB_CI = 235,
        LINKTYPE_MUX27010 = 236,
        LINKTYPE_STANAG_5066_D_PDU = 237,
        LINKTYPE_NFLOG = 239,
        LINKTYPE_NETANALYZER = 240,
        LINKTYPE_NETANALYZER_TRANSPARENT = 241,
        LINKTYPE_IPOIB = 242,
        LINKTYPE_MPEG_2_TS = 243,
        LINKTYPE_NG40 = 244,
        LINKTYPE_NFC_LLCP = 245,
        LINKTYPE_INFINIBAND = 247,
        LINKTYPE_SCTP = 248,
        LINKTYPE_USBPCAP = 249,
        LINKTYPE_RTAC_SERIAL = 250,
        LINKTYPE_BLUETOOTH_LE_LL = 251,
        LINKTYPE_NETLINK = 253,
        LINKTYPE_BLUETOOTH_LINUX_MONITOR = 254,
        LINKTYPE_BLUETOOTH_BREDR_BB = 255,
        LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR = 256,
        LINKTYPE_PROFIBUS_DL = 257,
        LINKTYPE_PKTAP = 258,
        LINKTYPE_EPON = 259,
        LINKTYPE_IPMI_HPM_2 = 260,
        LINKTYPE_ZWAVE_R1_R2 = 261,
        LINKTYPE_ZWAVE_R3 = 262,
        LINKTYPE_WATTSTOPPER_DLM = 263,
        LINKTYPE_ISO_14443 = 264,
        LINKTYPE_LINUX_SLL2 = 276,
        LINKTYPE_INVALID = 0xFFFF
    };
 
    constexpr const char* linkLayerToString(LinkLayerType linkLayer)
    {
        switch (linkLayer)
        {
        case LINKTYPE_NULL:
            return "NULL";
        case LINKTYPE_ETHERNET:
            return "Ethernet";
        case LINKTYPE_AX25:
            return "AX.25";
        case LINKTYPE_IEEE802_5:
            return "IEEE 802.5";
        case LINKTYPE_ARCNET_BSD:
            return "ARCNET BSD";
        case LINKTYPE_SLIP:
            return "SLIP";
        case LINKTYPE_PPP:
            return "PPP";
        case LINKTYPE_FDDI:
            return "FDDI";
        case LINKTYPE_DLT_RAW1:
            return "DLT_RAW1";
        case LINKTYPE_DLT_RAW2:
            return "DLT_RAW2";
        case LINKTYPE_PPP_HDLC:
            return "PPP HDLC";
        case LINKTYPE_PPP_ETHER:
            return "PPPoE";
        case LINKTYPE_ATM_RFC1483:
            return "ATM RFC1483";
        case LINKTYPE_RAW:
            return "Raw";
        case LINKTYPE_C_HDLC:
            return "Cisco HDLC";
        case LINKTYPE_IEEE802_11:
            return "IEEE 802.11";
        case LINKTYPE_FRELAY:
            return "Frame Relay";
        case LINKTYPE_LOOP:
            return "OpenBSD Loopback";
        case LINKTYPE_LINUX_SLL:
            return "Linux SLL";
        case LINKTYPE_LTALK:
            return "LocalTalk";
        case LINKTYPE_PFLOG:
            return "PFLOG";
        case LINKTYPE_IEEE802_11_PRISM:
            return "IEEE 802.11 Prism";
        case LINKTYPE_IP_OVER_FC:
            return "IP over Fibre Channel";
        case LINKTYPE_SUNATM:
            return "SunATM";
        case LINKTYPE_IEEE802_11_RADIOTAP:
            return "IEEE 802.11 Radiotap";
        case LINKTYPE_ARCNET_LINUX:
            return "ARCNET Linux";
        case LINKTYPE_APPLE_IP_OVER_IEEE1394:
            return "Apple IP over IEEE 1394";
        case LINKTYPE_MTP2_WITH_PHDR:
            return "MTP2 with PHDR";
        case LINKTYPE_MTP2:
            return "MTP2";
        case LINKTYPE_MTP3:
            return "MTP3";
        case LINKTYPE_SCCP:
            return "SCCP";
        case LINKTYPE_DOCSIS:
            return "DOCSIS";
        case LINKTYPE_LINUX_IRDA:
            return "Linux IrDA";
 
        case LINKTYPE_USER0:
            return "USER0";
        case LINKTYPE_USER1:
            return "USER1";
        case LINKTYPE_USER2:
            return "USER2";
        case LINKTYPE_USER3:
            return "USER3";
        case LINKTYPE_USER4:
            return "USER4";
        case LINKTYPE_USER5:
            return "USER5";
        case LINKTYPE_USER6:
            return "USER6";
        case LINKTYPE_USER7:
            return "USER7";
        case LINKTYPE_USER8:
            return "USER8";
        case LINKTYPE_USER9:
            return "USER9";
        case LINKTYPE_USER10:
            return "USER10";
        case LINKTYPE_USER11:
            return "USER11";
        case LINKTYPE_USER12:
            return "USER12";
        case LINKTYPE_USER13:
            return "USER13";
        case LINKTYPE_USER14:
            return "USER14";
        case LINKTYPE_USER15:
            return "USER15";
 
        case LINKTYPE_IEEE802_11_AVS:
            return "IEEE 802.11 AVS";
        case LINKTYPE_BACNET_MS_TP:
            return "BACnet MS/TP";
        case LINKTYPE_PPP_PPPD:
            return "PPP PPPD";
        case LINKTYPE_GPRS_LLC:
            return "GPRS LLC";
        case LINKTYPE_GPF_T:
            return "GPF-T";
        case LINKTYPE_GPF_F:
            return "GPF-F";
        case LINKTYPE_LINUX_LAPD:
            return "Linux LAPD";
        case LINKTYPE_BLUETOOTH_HCI_H4:
            return "Bluetooth HCI H4";
        case LINKTYPE_USB_LINUX:
            return "USB Linux";
        case LINKTYPE_PPI:
            return "PPI";
        case LINKTYPE_IEEE802_15_4:
            return "IEEE 802.15.4";
        case LINKTYPE_SITA:
            return "SITA";
        case LINKTYPE_ERF:
            return "ERF";
        case LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR:
            return "Bluetooth HCI H4 with PHDR";
        case LINKTYPE_AX25_KISS:
            return "AX.25 KISS";
        case LINKTYPE_LAPD:
            return "LAPD";
        case LINKTYPE_PPP_WITH_DIR:
            return "PPP with Direction";
        case LINKTYPE_C_HDLC_WITH_DIR:
            return "Cisco HDLC with Direction";
        case LINKTYPE_FRELAY_WITH_DIR:
            return "Frame Relay with Direction";
        case LINKTYPE_IPMB_LINUX:
            return "IPMB Linux";
        case LINKTYPE_IEEE802_15_4_NONASK_PHY:
            return "IEEE 802.15.4 NONASK PHY";
        case LINKTYPE_USB_LINUX_MMAPPED:
            return "USB Linux MMAPPED";
        case LINKTYPE_FC_2:
            return "Fibre Channel FC-2";
        case LINKTYPE_FC_2_WITH_FRAME_DELIMS:
            return "Fibre Channel FC-2 with Frame Delimiters";
        case LINKTYPE_IPNET:
            return "Solaris IPNET";
        case LINKTYPE_CAN_SOCKETCAN:
            return "CAN SocketCAN";
        case LINKTYPE_IPV4:
            return "IPv4";
        case LINKTYPE_IPV6:
            return "IPv6";
        case LINKTYPE_IEEE802_15_4_NOFCS:
            return "IEEE 802.15.4 without FCS";
        case LINKTYPE_DBUS:
            return "D-Bus";
        case LINKTYPE_DVB_CI:
            return "DVB-CI";
        case LINKTYPE_MUX27010:
            return "MUX27010";
        case LINKTYPE_STANAG_5066_D_PDU:
            return "STANAG 5066 D-PDU";
        case LINKTYPE_NFLOG:
            return "NFLOG";
        case LINKTYPE_NETANALYZER:
            return "netANALYZER";
        case LINKTYPE_NETANALYZER_TRANSPARENT:
            return "netANALYZER Transparent";
        case LINKTYPE_IPOIB:
            return "IP over InfiniBand";
        case LINKTYPE_MPEG_2_TS:
            return "MPEG-2 Transport Stream";
        case LINKTYPE_NG40:
            return "NG40";
        case LINKTYPE_NFC_LLCP:
            return "NFC LLCP";
        case LINKTYPE_INFINIBAND:
            return "InfiniBand";
        case LINKTYPE_SCTP:
            return "SCTP";
        case LINKTYPE_USBPCAP:
            return "USBPcap";
        case LINKTYPE_RTAC_SERIAL:
            return "RTAC Serial";
        case LINKTYPE_BLUETOOTH_LE_LL:
            return "Bluetooth LE LL";
        case LINKTYPE_NETLINK:
            return "Netlink";
        case LINKTYPE_BLUETOOTH_LINUX_MONITOR:
            return "Bluetooth Linux Monitor";
        case LINKTYPE_BLUETOOTH_BREDR_BB:
            return "Bluetooth BR/EDR Baseband";
        case LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR:
            return "Bluetooth LE LL with PHDR";
        case LINKTYPE_PROFIBUS_DL:
            return "PROFIBUS DL";
        case LINKTYPE_PKTAP:
            return "PKTAP";
        case LINKTYPE_EPON:
            return "EPON";
        case LINKTYPE_IPMI_HPM_2:
            return "IPMI HPM.2";
        case LINKTYPE_ZWAVE_R1_R2:
            return "Z-Wave R1/R2";
        case LINKTYPE_ZWAVE_R3:
            return "Z-Wave R3";
        case LINKTYPE_WATTSTOPPER_DLM:
            return "WattStopper DLM";
        case LINKTYPE_ISO_14443:
            return "ISO 14443";
        case LINKTYPE_LINUX_SLL2:
            return "Linux SLL2";
        case LINKTYPE_INVALID:
            return "Invalid";
 
        default:
            throw std::invalid_argument("Unknown link type");
        }
    }
 
#define PCPP_MAX_PACKET_SIZE 65536
 
    class RawPacket;
 
    namespace internal
    {
        enum class RawPacketImplType : uint8_t
        {
            Unknown = 0,
            Standard = 1,
            DpdkMBuf = 2,
            WinDivert = 3
        };
 
        RawPacketImplType getRawPacketImplementationType(RawPacket const& rawPacket);
    }  // namespace internal
 
    class RawPacket
    {
        friend internal::RawPacketImplType internal::getRawPacketImplementationType(RawPacket const& rawPacket);
 
    protected:
        uint8_t* m_RawData = nullptr;
        int m_RawDataLen = 0;
        int m_FrameLength = 0;
        timespec m_TimeStamp{};  // Zero initialized
        bool m_OwnsRawData = false;
        bool m_RawPacketSet = false;
        LinkLayerType m_LinkLayerType = LinkLayerType::LINKTYPE_ETHERNET;
 
        void copyDataFrom(const RawPacket& other, bool allocateData = true);
 
    public:
        RawPacket() = default;
 
        RawPacket(const uint8_t* pRawData, int rawDataLen, timeval timestamp, bool takeOwnership,
                  LinkLayerType layerType = LINKTYPE_ETHERNET);
 
        RawPacket(const uint8_t* pRawData, int rawDataLen, timespec timestamp, bool takeOwnership,
                  LinkLayerType layerType = LINKTYPE_ETHERNET);
 
        virtual ~RawPacket();
 
        RawPacket(const RawPacket& other);
 
        RawPacket& operator=(const RawPacket& other);
 
        virtual RawPacket* clone() const;
 
        PCPP_DEPRECATED("Deprecated due to unclear semantics.")
        virtual uint8_t getObjectType() const
        {
            return 0;
        }
 
        PCPP_DEPRECATED("Use the overload that takes bool takeOwnership parameter for explicit control.")
        bool setRawData(const uint8_t* pRawData, int rawDataLen, timeval timestamp,
                        LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);
 
        bool setRawData(const uint8_t* pRawData, int rawDataLen, bool takeOwnership, timeval timestamp,
                        LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);
 
        PCPP_DEPRECATED("Use the overload that takes bool takeOwnership parameter for explicit control.")
        bool setRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp,
                        LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);
 
        bool setRawData(const uint8_t* pRawData, int rawDataLen, bool takeOwnership, timespec timestamp,
                        LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);
 
        PCPP_DEPRECATED("Prefer using setRawData() with takeOwnership `false`.")
        bool initWithRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp,
                             LinkLayerType layerType = LINKTYPE_ETHERNET);
 
        const uint8_t* getRawData() const
        {
            return m_RawData;
        }
 
        LinkLayerType getLinkLayerType() const
        {
            return m_LinkLayerType;
        }
 
        static bool isLinkTypeValid(int linkTypeValue);
 
        int getRawDataLen() const
        {
            return m_RawDataLen;
        }
 
        int getFrameLength() const
        {
            return m_FrameLength;
        }
        timespec getPacketTimeStamp() const
        {
            return m_TimeStamp;
        }
 
        virtual bool setPacketTimeStamp(timeval timestamp);
 
        virtual bool setPacketTimeStamp(timespec timestamp);
 
        bool isPacketSet() const
        {
            return m_RawPacketSet;
        }
 
        virtual void clear();
 
        virtual void appendData(const uint8_t* dataToAppend, size_t dataToAppendLen);
 
        virtual void insertData(int atIndex, const uint8_t* dataToInsert, size_t dataToInsertLen);
 
        virtual bool removeData(int atIndex, size_t numOfBytesToRemove);
 
        virtual bool reallocateData(size_t newBufferLength);
 
    protected:
        virtual internal::RawPacketImplType getImplType() const
        {
            return internal::RawPacketImplType::Standard;
        }
 
        // Updates the raw data buffer and related members. Used by setRawData() methods.
        virtual bool doSetRawData(const uint8_t* pRawData, int rawDataLen, bool takeOwnership, timespec timestamp,
                                  LinkLayerType layerType, int frameLength);
    };
 
    namespace internal
    {
        inline RawPacketImplType getRawPacketImplementationType(RawPacket const& rawPacket)
        {
            return rawPacket.getImplType();
        }
    }  // namespace internal
}  // namespace pcpp