#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"

/// @file

/// @namespace pcpp

/// @brief The main namespace for the PcapPlusPlus lib

namespace pcpp

{

  /// An enum describing all known link layer type. Taken from: http://www.tcpdump.org/linktypes.html .

  enum LinkLayerType

  {

    /// BSD loopback encapsulation

    LINKTYPE_NULL = 0,

    /// IEEE 802.3 Ethernet

    LINKTYPE_ETHERNET = 1,

    /// AX.25 packet

    LINKTYPE_AX25 = 3,

    /// IEEE 802.5 Token Ring

    LINKTYPE_IEEE802_5 = 6,

    /// ARCNET Data Packets

    LINKTYPE_ARCNET_BSD = 7,

    /// SLIP, encapsulated with a LINKTYPE_SLIP header

    LINKTYPE_SLIP = 8,

    /// PPP, as per RFC 1661 and RFC 1662

    LINKTYPE_PPP = 9,

    /// FDDI, as specified by ANSI INCITS 239-1994

    LINKTYPE_FDDI = 10,

    /// Raw IP

    LINKTYPE_DLT_RAW1 = 12,

    /// Raw IP (OpenBSD)

    LINKTYPE_DLT_RAW2 = 14,

    /// PPP in HDLC-like framing, as per RFC 1662, or Cisco PPP with HDLC framing, as per section 4.3.1 of RFC 1547

    LINKTYPE_PPP_HDLC = 50,

    /// PPPoE

    LINKTYPE_PPP_ETHER = 51,

    /// RFC 1483 LLC/SNAP-encapsulated ATM

    LINKTYPE_ATM_RFC1483 = 100,

    /// Raw IP

    LINKTYPE_RAW = 101,

    /// Cisco PPP with HDLC framing

    LINKTYPE_C_HDLC = 104,

    /// IEEE 802.11 wireless LAN

    LINKTYPE_IEEE802_11 = 105,

    /// Frame Relay

    LINKTYPE_FRELAY = 107,

    /// OpenBSD loopback encapsulation

    LINKTYPE_LOOP = 108,

    /// Linux "cooked" capture encapsulation

    LINKTYPE_LINUX_SLL = 113,

    /// Apple LocalTalk

    LINKTYPE_LTALK = 114,

    /// OpenBSD pflog

    LINKTYPE_PFLOG = 117,

    /// Prism monitor mode information followed by an 802.11 header

    LINKTYPE_IEEE802_11_PRISM = 119,

    /// RFC 2625 IP-over-Fibre Channel

    LINKTYPE_IP_OVER_FC = 122,

    /// ATM traffic, encapsulated as per the scheme used by SunATM devices

    LINKTYPE_SUNATM = 123,

    /// Radiotap link-layer information followed by an 802.11 header

    LINKTYPE_IEEE802_11_RADIOTAP = 127,

    /// ARCNET Data Packets, as described by the ARCNET Trade Association standard ATA 878.1-1999

    LINKTYPE_ARCNET_LINUX = 129,

    /// Apple IP-over-IEEE 1394 cooked header

    LINKTYPE_APPLE_IP_OVER_IEEE1394 = 138,

    /// Signaling System 7 Message Transfer Part Level 2

    LINKTYPE_MTP2_WITH_PHDR = 139,

    /// Signaling System 7 Message Transfer Part Level 2

    LINKTYPE_MTP2 = 140,

    /// Signaling System 7 Message Transfer Part Level 3

    LINKTYPE_MTP3 = 141,

    /// Signaling System 7 Signalling Connection Control Part

    LINKTYPE_SCCP = 142,

    /// Signaling System 7 Signalling Connection Control Part

    LINKTYPE_DOCSIS = 143,

    /// Linux-IrDA packets

    LINKTYPE_LINUX_IRDA = 144,

    /// Reserved for private use

    LINKTYPE_USER0 = 147,

    /// Reserved for private use

    LINKTYPE_USER1 = 148,

    /// Reserved for private use

    LINKTYPE_USER2 = 149,

    /// Reserved for private use

    LINKTYPE_USER3 = 150,

    /// Reserved for private use

    LINKTYPE_USER4 = 151,

    /// Reserved for private use

    LINKTYPE_USER5 = 152,

    /// Reserved for private use

    LINKTYPE_USER6 = 153,

    /// Reserved for private use

    LINKTYPE_USER7 = 154,

    /// Reserved for private use

    LINKTYPE_USER8 = 155,

    /// Reserved for private use

    LINKTYPE_USER9 = 156,

    /// Reserved for private use

    LINKTYPE_USER10 = 157,

    /// Reserved for private use

    LINKTYPE_USER11 = 158,

    /// Reserved for private use

    LINKTYPE_USER12 = 159,

    /// Reserved for private use

    LINKTYPE_USER13 = 160,

    /// Reserved for private use

    LINKTYPE_USER14 = 161,

    /// Reserved for private use

    LINKTYPE_USER15 = 162,

    /// AVS monitor mode information followed by an 802.11 header

    LINKTYPE_IEEE802_11_AVS = 163,

    /// BACnet MS/TP frames

    LINKTYPE_BACNET_MS_TP = 165,

    /// PPP in HDLC-like encapsulation, like LINKTYPE_PPP_HDLC, but with the 0xff address byte replaced by a

    /// direction indication - 0x00 for incoming and 0x01 for outgoing

    LINKTYPE_PPP_PPPD = 166,

    /// General Packet Radio Service Logical Link Control

    LINKTYPE_GPRS_LLC = 169,

    /// Transparent-mapped generic framing procedure

    LINKTYPE_GPF_T = 170,

    /// Frame-mapped generic framing procedure

    LINKTYPE_GPF_F = 171,

    /// Link Access Procedures on the D Channel (LAPD) frames

    LINKTYPE_LINUX_LAPD = 177,

    /// Bluetooth HCI UART transport layer

    LINKTYPE_BLUETOOTH_HCI_H4 = 187,

    /// USB packets, beginning with a Linux USB header

    LINKTYPE_USB_LINUX = 189,

    /// Per-Packet Information information

    LINKTYPE_PPI = 192,

    /// IEEE 802.15.4 wireless Personal Area Network

    LINKTYPE_IEEE802_15_4 = 195,

    /// Various link-layer types, with a pseudo-header, for SITA

    LINKTYPE_SITA = 196,

    /// Various link-layer types, with a pseudo-header, for Endace DAG cards; encapsulates Endace ERF record

    LINKTYPE_ERF = 197,

    /// Bluetooth HCI UART transport layer

    LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR = 201,

    /// AX.25 packet, with a 1-byte KISS header containing a type indicator

    LINKTYPE_AX25_KISS = 202,

    /// Link Access Procedures on the D Channel (LAPD) frames

    LINKTYPE_LAPD = 203,

    /// PPP, as per RFC 1661 and RFC 1662, preceded with a one-byte pseudo-header with a zero value meaning

    /// "received by this host" and a non-zero value meaning  "sent by this host"

    LINKTYPE_PPP_WITH_DIR = 204,

    /// Cisco PPP with HDLC framing

    LINKTYPE_C_HDLC_WITH_DIR = 205,

    /// Frame Relay

    LINKTYPE_FRELAY_WITH_DIR = 206,

    /// IPMB over an I2C circuit

    LINKTYPE_IPMB_LINUX = 209,

    /// IEEE 802.15.4 wireless Personal Area Network

    LINKTYPE_IEEE802_15_4_NONASK_PHY = 215,

    /// USB packets, beginning with a Linux USB header

    LINKTYPE_USB_LINUX_MMAPPED = 220,

    /// Fibre Channel FC-2 frames, beginning with a Frame_Header

    LINKTYPE_FC_2 = 224,

    /// Fibre Channel FC-2 frames

    LINKTYPE_FC_2_WITH_FRAME_DELIMS = 225,

    /// Solaris ipnet pseudo-header

    LINKTYPE_IPNET = 226,

    /// CAN (Controller Area Network) frames, with a pseudo-header as supplied by Linux SocketCAN

    LINKTYPE_CAN_SOCKETCAN = 227,

    /// Raw IPv4; the packet begins with an IPv4 header

    LINKTYPE_IPV4 = 228,

    /// Raw IPv6; the packet begins with an IPv6 header

    LINKTYPE_IPV6 = 229,

    /// IEEE 802.15.4 wireless Personal Area Network, without the FCS at the end of the frame

    LINKTYPE_IEEE802_15_4_NOFCS = 230,

    /// Raw D-Bus messages, starting with the endianness flag, followed by the message type, etc., but without the

    /// authentication handshake before the message sequence

    LINKTYPE_DBUS = 231,

    /// DVB-CI (DVB Common Interface for communication between a PC Card module and a DVB receiver), with the

    /// message format specified by the PCAP format for DVB-CI specification

    LINKTYPE_DVB_CI = 235,

    /// Variant of 3GPP TS 27.010 multiplexing protocol (similar to, but not the same as, 27.010)

    LINKTYPE_MUX27010 = 236,

    /// D_PDUs as described by NATO standard STANAG 5066, starting with the synchronization sequence, and including

    /// both header and data CRCs

    LINKTYPE_STANAG_5066_D_PDU = 237,

    /// Linux netlink NETLINK NFLOG socket log messages

    LINKTYPE_NFLOG = 239,

    /// Pseudo-header for Hilscher Gesellschaft für Systemautomation mbH netANALYZER devices, followed by an

    /// Ethernet frame, beginning with the MAC header and ending with the FCS

    LINKTYPE_NETANALYZER = 240,

    /// Pseudo-header for Hilscher Gesellschaft für Systemautomation mbH netANALYZER devices, followed by an

    /// Ethernet frame, beginning with the preamble, SFD, and MAC header, and ending with the FCS

    LINKTYPE_NETANALYZER_TRANSPARENT = 241,

    /// IP-over-InfiniBand, as specified by RFC 4391 section 6

    LINKTYPE_IPOIB = 242,

    /// MPEG-2 Transport Stream transport packets, as specified by ISO 13818-1/ITU-T Recommendation H.222.0

    LINKTYPE_MPEG_2_TS = 243,

    /// Pseudo-header for ng4T GmbH's UMTS Iub/Iur-over-ATM and Iub/Iur-over-IP format as used by their ng40

    /// protocol tester

    LINKTYPE_NG40 = 244,

    /// Pseudo-header for NFC LLCP packet captures, followed by frame data for the LLCP Protocol as specified by

    /// NFCForum-TS-LLCP_1.1

    LINKTYPE_NFC_LLCP = 245,

    /// Raw InfiniBand frames, starting with the Local Routing Header

    LINKTYPE_INFINIBAND = 247,

    /// SCTP packets, as defined by RFC 4960, with no lower-level protocols such as IPv4 or IPv6

    LINKTYPE_SCTP = 248,

    /// USB packets, beginning with a USBPcap header

    LINKTYPE_USBPCAP = 249,

    /// Serial-line packet header for the Schweitzer Engineering Laboratories "RTAC" product

    LINKTYPE_RTAC_SERIAL = 250,

    /// Bluetooth Low Energy air interface Link Layer packets

    LINKTYPE_BLUETOOTH_LE_LL = 251,

    /// Linux Netlink capture encapsulation

    LINKTYPE_NETLINK = 253,

    /// Bluetooth Linux Monitor encapsulation of traffic for the BlueZ stack

    LINKTYPE_BLUETOOTH_LINUX_MONITOR = 254,

    /// Bluetooth Basic Rate and Enhanced Data Rate baseband packets

    LINKTYPE_BLUETOOTH_BREDR_BB = 255,

    /// Bluetooth Low Energy link-layer packets

    LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR = 256,

    /// PROFIBUS data link layer packets, as specified by IEC standard 61158-6-3

    LINKTYPE_PROFIBUS_DL = 257,

    /// Apple PKTAP capture encapsulation

    LINKTYPE_PKTAP = 258,

    /// Ethernet-over-passive-optical-network packets

    LINKTYPE_EPON = 259,

    /// IPMI trace packets, as specified by Table 3-20 "Trace Data Block Format" in the PICMG HPM.2 specification

    LINKTYPE_IPMI_HPM_2 = 260,

    /// Per Joshua Wright <jwright@hasborg.com>, formats for Z-Wave RF profiles R1 and R2 captures

    LINKTYPE_ZWAVE_R1_R2 = 261,

    /// Per Joshua Wright <jwright@hasborg.com>, formats for Z-Wave RF profile R3 captures

    LINKTYPE_ZWAVE_R3 = 262,

    /// Formats for WattStopper Digital Lighting Management (DLM) and Legrand Nitoo Open protocol common packet

    /// structure captures

    LINKTYPE_WATTSTOPPER_DLM = 263,

    /// Messages between ISO 14443 contactless smartcards (Proximity Integrated Circuit Card, PICC) and card readers

    /// (Proximity Coupling Device, PCD), with the message format specified by the PCAP format for ISO14443

    /// specification

    LINKTYPE_ISO_14443 = 264,

    /// Linux "cooked" capture encapsulation v2

    LINKTYPE_LINUX_SLL2 = 276,

    /// Set if interface ID for a packet of a pcapng file is too high

    LINKTYPE_INVALID = 0xFFFF

  };

  /// Convert a link layer type to its string representation.

  /// @param[in] linkLayer The link layer type to convert.

  /// @return The string representation of the link layer type.

  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");

    }

  }

  /// Max packet size supported

#define PCPP_MAX_PACKET_SIZE 65536

  class RawPacket;

  namespace internal

  {

    /// @brief Type of RawPacket implementation

    ///

    /// This is mainly used internally to distinguish between different implementations without using RTTI.

    ///

    /// Only the standard RawPacket implementation is defined in Packet++ library.

    /// Other device specific implementations are defined in their respective parts of Pcap++.

    enum class RawPacketImplType : uint8_t

    {

      /// @brief Unknown type

      Unknown = 0,

      /// @brief Standard RawPacket

      Standard = 1,

      /// @brief DPDK MBuf based RawPacket

      DpdkMBuf = 2,

      /// @brief WinDivert based RawPacket

      WinDivert = 3

    };

    /// @brief Get the concrete implementation type of a RawPacket instance

    /// @param rawPacket The RawPacket instance

    /// @return A value of RawPacketImplType enum representing the concrete implementation type of the given

    /// RawPacket instance.

    RawPacketImplType getRawPacketImplementationType(RawPacket const& rawPacket);

  }  // namespace internal

  /// @class RawPacket

  /// This class holds the packet as raw (not parsed) data. The data is held as byte array. In addition to the data

  /// itself every instance also holds a timestamp representing the time the packet was received by the NIC. RawPacket

  /// instance isn't read only. The user can change the packet data, add or remove data, etc.

  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:

    /// A default constructor that initializes class'es attributes to default value:

    /// - data pointer is set to nullptr

    /// - data length is set to 0

    /// - frame length is set to 0

    /// - takeOwnership is set to 'false'

    /// - timestamp is set to 0

    /// - layer type is set to Ethernet

    RawPacket() = default;

    /// A constructor that receives a pointer to the raw data (allocated elsewhere). This constructor is usually

    /// used when packet is captured using a packet capturing engine (like libPcap. WinPcap, Npcap, PF_RING, etc.).

    /// The capturing engine allocates the raw data memory and give the user a pointer to it + a timestamp it has

    /// arrived to the device

    /// @param[in] pRawData A pointer to the raw data

    /// @param[in] rawDataLen The raw data length in bytes

    /// @param[in] timestamp The timestamp packet was received by the NIC (in usec precision)

    /// @param[in] takeOwnership If 'true' the RawPacket will take ownership of the pRawData pointer and will

    /// free it when the RawPacket instance is destroyed or the buffer is replaced.

    /// @param[in] layerType The link layer type of this raw packet. The default is Ethernet

    RawPacket(const uint8_t* pRawData, int rawDataLen, timeval timestamp, bool takeOwnership,

              LinkLayerType layerType = LINKTYPE_ETHERNET);

    /// A constructor that receives a pointer to the raw data (allocated elsewhere). This constructor is usually

    /// used when packet is captured using a packet capturing engine (like libPcap. WinPcap, Npcap, PF_RING, etc.).

    /// The capturing engine allocates the raw data memory and give the user a pointer to it + a timestamp it has

    /// arrived to the device

    /// @param[in] pRawData A pointer to the raw data

    /// @param[in] rawDataLen The raw data length in bytes

    /// @param[in] timestamp The timestamp packet was received by the NIC (in nsec precision)

    /// @param[in] takeOwnership If 'true' the RawPacket will take ownership of the pRawData pointer and will

    /// free it when the RawPacket instance is destroyed or the buffer is replaced.

    /// @param[in] layerType The link layer type of this raw packet. The default is Ethernet

    RawPacket(const uint8_t* pRawData, int rawDataLen, timespec timestamp, bool takeOwnership,

              LinkLayerType layerType = LINKTYPE_ETHERNET);

    /// A destructor for this class. Frees the raw data if takeOwnership was set to 'true'

    virtual ~RawPacket();

    /// A copy constructor that copies all data from another instance. Notice all raw data is copied (using memcpy),

    /// so when the original or the other instance are freed, the other won't be affected

    /// @param[in] other The instance to copy from

    RawPacket(const RawPacket& other);

    /// Assignment operator overload for this class. When using this operator on an already initialized RawPacket

    /// instance, the original raw data is freed first if takeOwnership was set to 'true'.

    /// Then the other instance is copied to this instance, the same way the copy constructor works

    /// @param[in] other The instance to copy from

    RawPacket& operator=(const RawPacket& other);

    /// @brief Clones the current packet. Caller is responsible for deallocation of the memory.

    /// @return A pointer to the new RawPacket object which is a clone of this object

    virtual RawPacket* clone() const;

    /// @return RawPacket object type. Each derived class should return a different value

    /// @deprecated Deprecated due to unclear semantics and type safety.

    /// The functionality has been moved to the unstable internal API in as

    /// internal::getRawPacketImplementationType(RawPacket const& rawPacket).

    PCPP_DEPRECATED("Deprecated due to unclear semantics.")

    virtual uint8_t getObjectType() const

    {

      return 0;

    }

    /// Set a raw data. If data was already set and takeOwnership was set to 'true' the old data will be

    /// freed first

    /// @param[in] pRawData A pointer to the new raw data

    /// @param[in] rawDataLen The new raw data length in bytes

    /// @param[in] timestamp The timestamp packet was received by the NIC (in usec precision)

    /// @param[in] layerType The link layer type for this raw data

    /// @param[in] frameLength When reading from pcap files, sometimes the captured length is different from the

    /// actual packet length. This parameter represents the packet length. This parameter is optional, if not set or

    /// set to -1 it is assumed both lengths are equal

    /// @return True if raw data was set successfully, false otherwise

    /// @deprecated This method does not update ownership of the pRawData pointer, inheriting the previous buffer's

    /// ownership. Use the overload that takes bool takeOwnership parameter for explicit control.

    /// @remarks Derived classes may not support using the raw data buffer directly.

    /// Users should not rely on the RawPacket always writing to the provided pointer location,

    /// and instead get the raw data pointer using getRawData().

    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);

    /// @brief Assign a buffer to use as raw data.

    ///

    /// If the RawPacket already had raw data, it will be disposed of accordingly.

    ///

    /// @param pRawData A pointer to the new raw data buffer.

    /// @param rawDataLen The length of the new raw data buffer in bytes.

    /// @param takeOwnership If true, the RawPacket will take ownership of the buffer and will be responsible for

    /// freeing it.

    /// @param timestamp The timestamp packet was received by the NIC (in usec precision).

    /// @param layerType The link layer type for this raw data.

    /// @param frameLength When reading from pcap files, sometimes the captured length is different from the

    /// actual packet length. This parameter represents the packet length. This parameter is optional, if not set or

    /// set to -1 it is assumed both lengths are equal

    /// @return True if raw data was set successfully, false otherwise.

    /// @remarks Derived classes may not support using the raw data buffer directly.

    /// Users should not rely on the RawPacket always writing to the provided pointer location,

    /// and instead get the raw data pointer using getRawData().

    bool setRawData(const uint8_t* pRawData, int rawDataLen, bool takeOwnership, timeval timestamp,

                    LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);

    /// Set a raw data. If data was already set and takeOwnership was set to 'true' the old data will be

    /// freed first

    /// @param[in] pRawData A pointer to the new raw data

    /// @param[in] rawDataLen The new raw data length in bytes

    /// @param[in] timestamp The timestamp packet was received by the NIC (in nsec precision)

    /// @param[in] layerType The link layer type for this raw data

    /// @param[in] frameLength When reading from pcap files, sometimes the captured length is different from the

    /// actual packet length. This parameter represents the packet length. This parameter is optional, if not set or

    /// set to -1 it is assumed both lengths are equal

    /// @return True if raw data was set successfully, false otherwise

    /// @deprecated This method does not update ownership of the pRawData pointer, inheriting the previous buffer's

    /// ownership. Use the overload that takes bool takeOwnership parameter for explicit control.

    /// @remarks Derived classes may not support using the raw data buffer directly.

    /// Users should not rely on the RawPacket always writing to the provided pointer location,

    /// and instead get the raw data pointer using getRawData().

    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);

    /// @brief Assign a buffer to use as raw data.

    ///

    /// If the RawPacket already had raw data, it will be disposed of accordingly.

    ///

    /// @param pRawData A pointer to the new raw data buffer.

    /// @param rawDataLen The length of the new raw data buffer in bytes.

    /// @param takeOwnership If true, the RawPacket will take ownership of the buffer and will be responsible for

    /// freeing it.

    /// @param timestamp The timestamp packet was received by the NIC (in nsec precision).

    /// @param layerType The link layer type for this raw data.

    /// @param frameLength When reading from pcap files, sometimes the captured length is different from the

    /// actual packet length. This parameter represents the packet length. This parameter is optional, if not set or

    /// set to -1 it is assumed both lengths are equal

    /// @return True if raw data was set successfully, false otherwise.

    /// @remarks Derived classes may not support using the raw data buffer directly.

    /// Users should not rely on the RawPacket always writing to the provided pointer location,

    /// and instead get the raw data pointer using getRawData().

    bool setRawData(const uint8_t* pRawData, int rawDataLen, bool takeOwnership, timespec timestamp,

                    LinkLayerType layerType = LINKTYPE_ETHERNET, int frameLength = -1);

    /// Initialize a raw packet with data. The main difference between this method and setRawData() is that

    /// setRawData() is meant for replacing the data in an existing raw packet, whereas this method is meant to be

    /// used right after constructing a raw packet using the default c'tor, before setting any data

    /// @param pRawData A pointer to the new raw data

    /// @param rawDataLen The new raw data length in bytes

    /// @param timestamp The timestamp packet was received by the NIC (in nsec precision)

    /// @param layerType The link layer type for this raw data

    /// @return True if raw data was set successfully, false otherwise

    /// @deprecated Prefer using setRawData() with takeOwnership `false`.

    PCPP_DEPRECATED("Prefer using setRawData() with takeOwnership `false`.")

    bool initWithRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp,

                         LinkLayerType layerType = LINKTYPE_ETHERNET);

    /// Get raw data pointer

    /// @return A read-only pointer to the raw data

    const uint8_t* getRawData() const

    {

      return m_RawData;

    }

    /// Get the link layer type

    /// @return the type of the link layer

    LinkLayerType getLinkLayerType() const

    {

      return m_LinkLayerType;

    }

    /// This static method validates whether a link type integer value is valid

    /// @param[in] linkTypeValue Link type integer value

    /// @return True if the link type value is valid and can be casted into LinkLayerType enum, false otherwise

    static bool isLinkTypeValid(int linkTypeValue);

    /// Get raw data length in bytes

    /// @return Raw data length in bytes

    int getRawDataLen() const

    {

      return m_RawDataLen;

    }

    /// Get frame length in bytes

    /// @return frame length in bytes

    int getFrameLength() const

    {

      return m_FrameLength;

    }

    /// Get raw data timestamp

    /// @return Raw data timestamp

    timespec getPacketTimeStamp() const

    {

      return m_TimeStamp;

    }

    /// Set raw packet timestamp with usec precision

    /// @param[in] timestamp The timestamp to set (with usec precision)

    /// @return True if timestamp was set successfully, false otherwise

    virtual bool setPacketTimeStamp(timeval timestamp);

    /// Set raw packet timestamp with nsec precision

    /// @param[in] timestamp The timestamp to set (with nsec precision)

    /// @return True if timestamp was set successfully, false otherwise

    virtual bool setPacketTimeStamp(timespec timestamp);

    /// Get an indication whether raw data was already set for this instance.

    /// @return True if raw data was set for this instance. Raw data can be set using the non-default constructor,

    /// using setRawData(), using the copy constructor or using the assignment operator. Returns false otherwise,

    /// for example: if the instance was created using the default constructor or clear() was called

    bool isPacketSet() const

    {

      return m_RawPacketSet;

    }

    /// Clears all members of this instance, meaning setting raw data to nullptr, raw data length to 0, etc.

    /// Frees the raw data if takeOwnership was set to 'true'

    /// @todo set timestamp to a default value as well

    virtual void clear();

    /// Append data to the end of current data. This method works without allocating more memory, it just uses

    /// memcpy() to copy dataToAppend at the end of the current data. This means that the method assumes this memory

    /// was already allocated by the user. If it isn't the case then this method will cause memory corruption

    /// @param[in] dataToAppend A pointer to the data to append to current raw data

    /// @param[in] dataToAppendLen Length in bytes of dataToAppend

    virtual void appendData(const uint8_t* dataToAppend, size_t dataToAppendLen);

    /// Insert new data at some index of the current data and shift the remaining old data to the end. This method

    /// works without allocating more memory, it just copies dataToAppend at the relevant index and shifts the

    /// remaining data to the end. This means that the method assumes this memory was already allocated by the user.

    /// If it isn't the case then this method will cause memory corruption

    /// @param[in] atIndex The index to insert the new data to

    /// @param[in] dataToInsert A pointer to the new data to insert

    /// @param[in] dataToInsertLen Length in bytes of dataToInsert

    virtual void insertData(int atIndex, const uint8_t* dataToInsert, size_t dataToInsertLen);

    /// Remove certain number of bytes from current raw data buffer. All data after the removed bytes will be

    /// shifted back

    /// @param[in] atIndex The index to start removing bytes from

    /// @param[in] numOfBytesToRemove Number of bytes to remove

    /// @return True if all bytes were removed successfully, or false if atIndex+numOfBytesToRemove is out-of-bounds

    /// of the raw data buffer

    virtual bool removeData(int atIndex, size_t numOfBytesToRemove);

    /// Re-allocate raw packet buffer meaning add size to it without losing the current packet data. This method

    /// allocates the required buffer size as instructed by the use and then copies the raw data from the current

    /// allocated buffer to the new one. This method can become useful if the user wants to insert or append data to

    /// the raw data, and the previous allocated buffer is too small, so the user wants to allocate a larger buffer

    /// and get RawPacket instance to point to it

    /// @param[in] newBufferLength The new buffer length as required by the user. The method is responsible to

    /// allocate the memory

    /// @return True if data was reallocated successfully, false otherwise

    virtual bool reallocateData(size_t newBufferLength);

  protected:

    /// @brief Get the type of RawPacket implementation.

    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