/src/PcapPlusPlus/Packet++/src/RawPacket.cpp

Source (jump to first uncovered line)
#define LOG_MODULE PacketLogModuleRawPacket

#include "RawPacket.h"
#include "Logger.h"
#include "TimespecTimeval.h"
#include <cstring>

namespace pcpp
{
  RawPacket::RawPacket(const uint8_t* pRawData, int rawDataLen, timeval timestamp, bool deleteRawDataAtDestructor,
                       LinkLayerType layerType)
      : RawPacket(pRawData, rawDataLen, internal::toTimespec(timestamp), deleteRawDataAtDestructor, layerType)
  {}

  RawPacket::RawPacket(const uint8_t* pRawData, int rawDataLen, timespec timestamp, bool deleteRawDataAtDestructor,
                       LinkLayerType layerType)
      : m_RawData(const_cast<uint8_t*>(pRawData)), m_RawDataLen(rawDataLen), m_FrameLength(rawDataLen),
        m_TimeStamp(timestamp), m_DeleteRawDataAtDestructor(deleteRawDataAtDestructor), m_RawPacketSet(true),
        m_LinkLayerType(layerType)
  {}

  RawPacket::~RawPacket()
  {
    clear();
  }

  RawPacket::RawPacket(const RawPacket& other)
  {
    m_RawData = nullptr;
    copyDataFrom(other, true);
  }

  RawPacket& RawPacket::operator=(const RawPacket& other)
  {
    if (this != &other)
    {
      clear();

      copyDataFrom(other, true);
    }

    return *this;
  }

  RawPacket* RawPacket::clone() const
  {
    return new RawPacket(*this);
  }

  void RawPacket::copyDataFrom(const RawPacket& other, bool allocateData)
  {
    if (!other.m_RawPacketSet)
      return;

    m_TimeStamp = other.m_TimeStamp;

    if (allocateData)
    {
      m_DeleteRawDataAtDestructor = true;
      m_RawData = new uint8_t[other.m_RawDataLen];
      m_RawDataLen = other.m_RawDataLen;
    }

    memcpy(m_RawData, other.m_RawData, other.m_RawDataLen);
    m_LinkLayerType = other.m_LinkLayerType;
    m_FrameLength = other.m_FrameLength;
    m_RawPacketSet = true;
  }

  bool RawPacket::setRawData(const uint8_t* pRawData, int rawDataLen, timeval timestamp, LinkLayerType layerType,
                             int frameLength)
  {
    return setRawData(pRawData, rawDataLen, internal::toTimespec(timestamp), layerType, frameLength);
  }

  bool RawPacket::setRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp, LinkLayerType layerType,
                             int frameLength)
  {
    clear();

    m_FrameLength = (frameLength == -1) ? rawDataLen : frameLength;
    m_RawData = (uint8_t*)pRawData;
    m_RawDataLen = rawDataLen;
    m_TimeStamp = timestamp;
    m_RawPacketSet = true;
    m_LinkLayerType = layerType;
    return true;
  }

  bool RawPacket::initWithRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp,
                                  LinkLayerType layerType)
  {
    m_DeleteRawDataAtDestructor = false;
    return setRawData(pRawData, rawDataLen, timestamp, layerType);
  }

  void RawPacket::clear()
  {
    if (m_RawData != nullptr && m_DeleteRawDataAtDestructor)
      delete[] m_RawData;

    m_RawData = nullptr;
    m_RawDataLen = 0;
    m_FrameLength = 0;
    m_RawPacketSet = false;
  }

  void RawPacket::appendData(const uint8_t* dataToAppend, size_t dataToAppendLen)
  {
    memcpy((uint8_t*)m_RawData + m_RawDataLen, dataToAppend, dataToAppendLen);
    m_RawDataLen += dataToAppendLen;
    m_FrameLength = m_RawDataLen;
  }

  void RawPacket::insertData(int atIndex, const uint8_t* dataToInsert, size_t dataToInsertLen)
  {
    // memmove copies data as if there was an intermediate buffer in between - so it allows for copying processes on
    // overlapping src/dest ptrs if insertData is called with atIndex == m_RawDataLen, then no data is being moved.
    // The data of the raw packet is still extended by dataToInsertLen
    memmove((uint8_t*)m_RawData + atIndex + dataToInsertLen, (uint8_t*)m_RawData + atIndex, m_RawDataLen - atIndex);

    if (dataToInsert != nullptr)
    {
      // insert data
      memcpy((uint8_t*)m_RawData + atIndex, dataToInsert, dataToInsertLen);
    }

    m_RawDataLen += dataToInsertLen;
    m_FrameLength = m_RawDataLen;
  }

  bool RawPacket::reallocateData(size_t newBufferLength)
  {
    if ((int)newBufferLength == m_RawDataLen)
      return true;

    if ((int)newBufferLength < m_RawDataLen)
    {
      PCPP_LOG_ERROR("Cannot reallocate raw packet to a smaller size. Current data length: "
                     << m_RawDataLen << "; requested length: " << newBufferLength);
      return false;
    }

    uint8_t* newBuffer = new uint8_t[newBufferLength];
    memset(newBuffer, 0, newBufferLength);
    memcpy(newBuffer, m_RawData, m_RawDataLen);
    if (m_DeleteRawDataAtDestructor)
      delete[] m_RawData;

    m_DeleteRawDataAtDestructor = true;
    m_RawData = newBuffer;

    return true;
  }

  bool RawPacket::removeData(int atIndex, size_t numOfBytesToRemove)
  {
    if ((atIndex + (int)numOfBytesToRemove) > m_RawDataLen)
    {
      PCPP_LOG_ERROR("Remove section is out of raw packet bound");
      return false;
    }

    // only move data if we are removing data somewhere in the layer, not at the end of the last layer
    // this is so that resizing of the last layer can occur fast by just reducing the fictional length of the packet
    // (m_RawDataLen) by the given amount
    if ((atIndex + (int)numOfBytesToRemove) != m_RawDataLen)
      // memmove copies data as if there was an intermediate buffer in between - so it allows for copying
      // processes on overlapping src/dest ptrs
      memmove((uint8_t*)m_RawData + atIndex, (uint8_t*)m_RawData + atIndex + numOfBytesToRemove,
              m_RawDataLen - (atIndex + numOfBytesToRemove));

    m_RawDataLen -= numOfBytesToRemove;
    m_FrameLength = m_RawDataLen;
    return true;
  }

  bool RawPacket::setPacketTimeStamp(timeval timestamp)
  {
    return setPacketTimeStamp(internal::toTimespec(timestamp));
  }

  bool RawPacket::setPacketTimeStamp(timespec timestamp)
  {
    m_TimeStamp = timestamp;
    return true;
  }

  bool RawPacket::isLinkTypeValid(int linkTypeValue)
  {
    if ((linkTypeValue < 0 || linkTypeValue > 264) && linkTypeValue != 276)
      return false;

    switch (static_cast<LinkLayerType>(linkTypeValue))
    {
    case LINKTYPE_ETHERNET:
    case LINKTYPE_LINUX_SLL:
    case LINKTYPE_RAW:
    case LINKTYPE_DLT_RAW1:
    case LINKTYPE_DLT_RAW2:
    case LINKTYPE_NULL:
    case LINKTYPE_AX25:
    case LINKTYPE_IEEE802_5:
    case LINKTYPE_ARCNET_BSD:
    case LINKTYPE_SLIP:
    case LINKTYPE_PPP:
    case LINKTYPE_FDDI:
    case LINKTYPE_PPP_HDLC:
    case LINKTYPE_PPP_ETHER:
    case LINKTYPE_ATM_RFC1483:
    case LINKTYPE_C_HDLC:
    case LINKTYPE_IEEE802_11:
    case LINKTYPE_FRELAY:
    case LINKTYPE_LOOP:
    case LINKTYPE_LTALK:
    case LINKTYPE_PFLOG:
    case LINKTYPE_IEEE802_11_PRISM:
    case LINKTYPE_IP_OVER_FC:
    case LINKTYPE_SUNATM:
    case LINKTYPE_IEEE802_11_RADIOTAP:
    case LINKTYPE_ARCNET_LINUX:
    case LINKTYPE_APPLE_IP_OVER_IEEE1394:
    case LINKTYPE_MTP2_WITH_PHDR:
    case LINKTYPE_MTP2:
    case LINKTYPE_MTP3:
    case LINKTYPE_SCCP:
    case LINKTYPE_DOCSIS:
    case LINKTYPE_LINUX_IRDA:
    case LINKTYPE_IEEE802_11_AVS:
    case LINKTYPE_BACNET_MS_TP:
    case LINKTYPE_PPP_PPPD:
    case LINKTYPE_GPRS_LLC:
    case LINKTYPE_GPF_T:
    case LINKTYPE_GPF_F:
    case LINKTYPE_LINUX_LAPD:
    case LINKTYPE_BLUETOOTH_HCI_H4:
    case LINKTYPE_USB_LINUX:
    case LINKTYPE_PPI:
    case LINKTYPE_IEEE802_15_4:
    case LINKTYPE_SITA:
    case LINKTYPE_ERF:
    case LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR:
    case LINKTYPE_AX25_KISS:
    case LINKTYPE_LAPD:
    case LINKTYPE_PPP_WITH_DIR:
    case LINKTYPE_C_HDLC_WITH_DIR:
    case LINKTYPE_FRELAY_WITH_DIR:
    case LINKTYPE_IPMB_LINUX:
    case LINKTYPE_IEEE802_15_4_NONASK_PHY:
    case LINKTYPE_USB_LINUX_MMAPPED:
    case LINKTYPE_FC_2:
    case LINKTYPE_FC_2_WITH_FRAME_DELIMS:
    case LINKTYPE_IPNET:
    case LINKTYPE_CAN_SOCKETCAN:
    case LINKTYPE_IPV4:
    case LINKTYPE_IPV6:
    case LINKTYPE_IEEE802_15_4_NOFCS:
    case LINKTYPE_DBUS:
    case LINKTYPE_DVB_CI:
    case LINKTYPE_MUX27010:
    case LINKTYPE_STANAG_5066_D_PDU:
    case LINKTYPE_NFLOG:
    case LINKTYPE_NETANALYZER:
    case LINKTYPE_NETANALYZER_TRANSPARENT:
    case LINKTYPE_IPOIB:
    case LINKTYPE_MPEG_2_TS:
    case LINKTYPE_NG40:
    case LINKTYPE_NFC_LLCP:
    case LINKTYPE_INFINIBAND:
    case LINKTYPE_SCTP:
    case LINKTYPE_USBPCAP:
    case LINKTYPE_RTAC_SERIAL:
    case LINKTYPE_BLUETOOTH_LE_LL:
    case LINKTYPE_NETLINK:
    case LINKTYPE_BLUETOOTH_LINUX_MONITOR:
    case LINKTYPE_BLUETOOTH_BREDR_BB:
    case LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR:
    case LINKTYPE_PROFIBUS_DL:
    case LINKTYPE_PKTAP:
    case LINKTYPE_EPON:
    case LINKTYPE_IPMI_HPM_2:
    case LINKTYPE_ZWAVE_R1_R2:
    case LINKTYPE_ZWAVE_R3:
    case LINKTYPE_WATTSTOPPER_DLM:
    case LINKTYPE_ISO_14443:
    case LINKTYPE_LINUX_SLL2:
      return true;
    default:
      return false;
    }
  }

}  // namespace pcpp

Coverage Report

Created: 2025-07-12 06:37

Line	Count	Source (jump to first uncovered line)
1	0	#define LOG_MODULE PacketLogModuleRawPacket
2
3		#include "RawPacket.h"
4		#include "Logger.h"
5		#include "TimespecTimeval.h"
6		#include <cstring>
7
8		namespace pcpp
9		{
10		RawPacket::RawPacket(const uint8_t* pRawData, int rawDataLen, timeval timestamp, bool deleteRawDataAtDestructor,
11		LinkLayerType layerType)
12	0	: RawPacket(pRawData, rawDataLen, internal::toTimespec(timestamp), deleteRawDataAtDestructor, layerType)
13	0	{}
14
15		RawPacket::RawPacket(const uint8_t* pRawData, int rawDataLen, timespec timestamp, bool deleteRawDataAtDestructor,
16		LinkLayerType layerType)
17	0	: m_RawData(const_cast<uint8_t*>(pRawData)), m_RawDataLen(rawDataLen), m_FrameLength(rawDataLen),
18	0	m_TimeStamp(timestamp), m_DeleteRawDataAtDestructor(deleteRawDataAtDestructor), m_RawPacketSet(true),
19	0	m_LinkLayerType(layerType)
20	0	{}
21
22		RawPacket::~RawPacket()
23	3.94k	{
24	3.94k	clear();
25	3.94k	}
26
27		RawPacket::RawPacket(const RawPacket& other)
28	0	{
29	0	m_RawData = nullptr;
30	0	copyDataFrom(other, true);
31	0	}
32
33		RawPacket& RawPacket::operator=(const RawPacket& other)
34	0	{
35	0	if (this != &other)
36	0	{
37	0	clear();
38
39	0	copyDataFrom(other, true);
40	0	}
41
42	0	return *this;
43	0	}
44
45		RawPacket* RawPacket::clone() const
46	0	{
47	0	return new RawPacket(*this);
48	0	}
49
50		void RawPacket::copyDataFrom(const RawPacket& other, bool allocateData)
51	0	{
52	0	if (!other.m_RawPacketSet)
53	0	return;
54
55	0	m_TimeStamp = other.m_TimeStamp;
56
57	0	if (allocateData)
58	0	{
59	0	m_DeleteRawDataAtDestructor = true;
60	0	m_RawData = new uint8_t[other.m_RawDataLen];
61	0	m_RawDataLen = other.m_RawDataLen;
62	0	}
63
64	0	memcpy(m_RawData, other.m_RawData, other.m_RawDataLen);
65	0	m_LinkLayerType = other.m_LinkLayerType;
66	0	m_FrameLength = other.m_FrameLength;
67	0	m_RawPacketSet = true;
68	0	}
69
70		bool RawPacket::setRawData(const uint8_t* pRawData, int rawDataLen, timeval timestamp, LinkLayerType layerType,
71		int frameLength)
72	0	{
73	0	return setRawData(pRawData, rawDataLen, internal::toTimespec(timestamp), layerType, frameLength);
74	0	}
75
76		bool RawPacket::setRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp, LinkLayerType layerType,
77		int frameLength)
78	26.1k	{
79	26.1k	clear();
80
81	26.1k	m_FrameLength = (frameLength == -1) ? rawDataLen : frameLength;
82	26.1k	m_RawData = (uint8_t*)pRawData;
83	26.1k	m_RawDataLen = rawDataLen;
84	26.1k	m_TimeStamp = timestamp;
85	26.1k	m_RawPacketSet = true;
86	26.1k	m_LinkLayerType = layerType;
87	26.1k	return true;
88	26.1k	}
89
90		bool RawPacket::initWithRawData(const uint8_t* pRawData, int rawDataLen, timespec timestamp,
91		LinkLayerType layerType)
92	0	{
93	0	m_DeleteRawDataAtDestructor = false;
94	0	return setRawData(pRawData, rawDataLen, timestamp, layerType);
95	0	}
96
97		void RawPacket::clear()
98	60.2k	{
99	60.2k	if (m_RawData != nullptr && m_DeleteRawDataAtDestructor)
100	26.1k	delete[] m_RawData;
101
102	60.2k	m_RawData = nullptr;
103	60.2k	m_RawDataLen = 0;
104	60.2k	m_FrameLength = 0;
105	60.2k	m_RawPacketSet = false;
106	60.2k	}
107
108		void RawPacket::appendData(const uint8_t* dataToAppend, size_t dataToAppendLen)
109	0	{
110	0	memcpy((uint8_t*)m_RawData + m_RawDataLen, dataToAppend, dataToAppendLen);
111	0	m_RawDataLen += dataToAppendLen;
112	0	m_FrameLength = m_RawDataLen;
113	0	}
114
115		void RawPacket::insertData(int atIndex, const uint8_t* dataToInsert, size_t dataToInsertLen)
116	0	{
117		// memmove copies data as if there was an intermediate buffer in between - so it allows for copying processes on
118		// overlapping src/dest ptrs if insertData is called with atIndex == m_RawDataLen, then no data is being moved.
119		// The data of the raw packet is still extended by dataToInsertLen
120	0	memmove((uint8_t)m_RawData + atIndex + dataToInsertLen, (uint8_t)m_RawData + atIndex, m_RawDataLen - atIndex);
121
122	0	if (dataToInsert != nullptr)
123	0	{
124		// insert data
125	0	memcpy((uint8_t*)m_RawData + atIndex, dataToInsert, dataToInsertLen);
126	0	}
127
128	0	m_RawDataLen += dataToInsertLen;
129	0	m_FrameLength = m_RawDataLen;
130	0	}
131
132		bool RawPacket::reallocateData(size_t newBufferLength)
133	0	{
134	0	if ((int)newBufferLength == m_RawDataLen)
135	0	return true;
136
137	0	if ((int)newBufferLength < m_RawDataLen)
138	0	{
139	0	PCPP_LOG_ERROR("Cannot reallocate raw packet to a smaller size. Current data length: "
140	0	<< m_RawDataLen << "; requested length: " << newBufferLength);
141	0	return false;
142	0	}
143
144	0	uint8_t* newBuffer = new uint8_t[newBufferLength];
145	0	memset(newBuffer, 0, newBufferLength);
146	0	memcpy(newBuffer, m_RawData, m_RawDataLen);
147	0	if (m_DeleteRawDataAtDestructor)
148	0	delete[] m_RawData;
149
150	0	m_DeleteRawDataAtDestructor = true;
151	0	m_RawData = newBuffer;
152
153	0	return true;
154	0	}
155
156		bool RawPacket::removeData(int atIndex, size_t numOfBytesToRemove)
157	0	{
158	0	if ((atIndex + (int)numOfBytesToRemove) > m_RawDataLen)
159	0	{
160	0	PCPP_LOG_ERROR("Remove section is out of raw packet bound");
161	0	return false;
162	0	}
163
164		// only move data if we are removing data somewhere in the layer, not at the end of the last layer
165		// this is so that resizing of the last layer can occur fast by just reducing the fictional length of the packet
166		// (m_RawDataLen) by the given amount
167	0	if ((atIndex + (int)numOfBytesToRemove) != m_RawDataLen)
168		// memmove copies data as if there was an intermediate buffer in between - so it allows for copying
169		// processes on overlapping src/dest ptrs
170	0	memmove((uint8_t)m_RawData + atIndex, (uint8_t)m_RawData + atIndex + numOfBytesToRemove,
171	0	m_RawDataLen - (atIndex + numOfBytesToRemove));
172
173	0	m_RawDataLen -= numOfBytesToRemove;
174	0	m_FrameLength = m_RawDataLen;
175	0	return true;
176	0	}
177
178		bool RawPacket::setPacketTimeStamp(timeval timestamp)
179	0	{
180	0	return setPacketTimeStamp(internal::toTimespec(timestamp));
181	0	}
182
183		bool RawPacket::setPacketTimeStamp(timespec timestamp)
184	0	{
185	0	m_TimeStamp = timestamp;
186	0	return true;
187	0	}
188
189		bool RawPacket::isLinkTypeValid(int linkTypeValue)
190	4.00k	{
191	4.00k	if ((linkTypeValue < 0 \|\| linkTypeValue > 264) && linkTypeValue != 276)
192	46	return false;
193
194	3.95k	switch (static_cast<LinkLayerType>(linkTypeValue))
195	3.95k	{
196	115	case LINKTYPE_ETHERNET:
197	545	case LINKTYPE_LINUX_SLL:
198	545	case LINKTYPE_RAW:
199	547	case LINKTYPE_DLT_RAW1:
200	586	case LINKTYPE_DLT_RAW2:
201	1.21k	case LINKTYPE_NULL:
202	1.21k	case LINKTYPE_AX25:
203	1.22k	case LINKTYPE_IEEE802_5:
204	1.22k	case LINKTYPE_ARCNET_BSD:
205	1.22k	case LINKTYPE_SLIP:
206	1.23k	case LINKTYPE_PPP:
207	1.23k	case LINKTYPE_FDDI:
208	1.23k	case LINKTYPE_PPP_HDLC:
209	1.23k	case LINKTYPE_PPP_ETHER:
210	1.23k	case LINKTYPE_ATM_RFC1483:
211	1.34k	case LINKTYPE_C_HDLC:
212	1.35k	case LINKTYPE_IEEE802_11:
213	1.35k	case LINKTYPE_FRELAY:
214	1.36k	case LINKTYPE_LOOP:
215	1.36k	case LINKTYPE_LTALK:
216	1.72k	case LINKTYPE_PFLOG:
217	1.72k	case LINKTYPE_IEEE802_11_PRISM:
218	1.72k	case LINKTYPE_IP_OVER_FC:
219	1.73k	case LINKTYPE_SUNATM:
220	1.76k	case LINKTYPE_IEEE802_11_RADIOTAP:
221	1.76k	case LINKTYPE_ARCNET_LINUX:
222	1.77k	case LINKTYPE_APPLE_IP_OVER_IEEE1394:
223	1.77k	case LINKTYPE_MTP2_WITH_PHDR:
224	1.77k	case LINKTYPE_MTP2:
225	1.77k	case LINKTYPE_MTP3:
226	1.77k	case LINKTYPE_SCCP:
227	1.77k	case LINKTYPE_DOCSIS:
228	1.78k	case LINKTYPE_LINUX_IRDA:
229	1.78k	case LINKTYPE_IEEE802_11_AVS:
230	1.78k	case LINKTYPE_BACNET_MS_TP:
231	1.78k	case LINKTYPE_PPP_PPPD:
232	1.78k	case LINKTYPE_GPRS_LLC:
233	1.78k	case LINKTYPE_GPF_T:
234	1.79k	case LINKTYPE_GPF_F:
235	1.79k	case LINKTYPE_LINUX_LAPD:
236	1.79k	case LINKTYPE_BLUETOOTH_HCI_H4:
237	1.98k	case LINKTYPE_USB_LINUX:
238	1.98k	case LINKTYPE_PPI:
239	1.99k	case LINKTYPE_IEEE802_15_4:
240	1.99k	case LINKTYPE_SITA:
241	1.99k	case LINKTYPE_ERF:
242	1.99k	case LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR:
243	1.99k	case LINKTYPE_AX25_KISS:
244	2.00k	case LINKTYPE_LAPD:
245	2.00k	case LINKTYPE_PPP_WITH_DIR:
246	2.00k	case LINKTYPE_C_HDLC_WITH_DIR:
247	2.01k	case LINKTYPE_FRELAY_WITH_DIR:
248	2.01k	case LINKTYPE_IPMB_LINUX:
249	2.01k	case LINKTYPE_IEEE802_15_4_NONASK_PHY:
250	2.76k	case LINKTYPE_USB_LINUX_MMAPPED:
251	2.77k	case LINKTYPE_FC_2:
252	2.77k	case LINKTYPE_FC_2_WITH_FRAME_DELIMS:
253	2.78k	case LINKTYPE_IPNET:
254	2.79k	case LINKTYPE_CAN_SOCKETCAN:
255	2.79k	case LINKTYPE_IPV4:
256	2.79k	case LINKTYPE_IPV6:
257	2.79k	case LINKTYPE_IEEE802_15_4_NOFCS:
258	2.96k	case LINKTYPE_DBUS:
259	2.96k	case LINKTYPE_DVB_CI:
260	2.96k	case LINKTYPE_MUX27010:
261	2.97k	case LINKTYPE_STANAG_5066_D_PDU:
262	3.18k	case LINKTYPE_NFLOG:
263	3.18k	case LINKTYPE_NETANALYZER:
264	3.18k	case LINKTYPE_NETANALYZER_TRANSPARENT:
265	3.18k	case LINKTYPE_IPOIB:
266	3.19k	case LINKTYPE_MPEG_2_TS:
267	3.19k	case LINKTYPE_NG40:
268	3.19k	case LINKTYPE_NFC_LLCP:
269	3.26k	case LINKTYPE_INFINIBAND:
270	3.26k	case LINKTYPE_SCTP:
271	3.29k	case LINKTYPE_USBPCAP:
272	3.30k	case LINKTYPE_RTAC_SERIAL:
273	3.32k	case LINKTYPE_BLUETOOTH_LE_LL:
274	3.33k	case LINKTYPE_NETLINK:
275	3.33k	case LINKTYPE_BLUETOOTH_LINUX_MONITOR:
276	3.37k	case LINKTYPE_BLUETOOTH_BREDR_BB:
277	3.48k	case LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR:
278	3.48k	case LINKTYPE_PROFIBUS_DL:
279	3.49k	case LINKTYPE_PKTAP:
280	3.49k	case LINKTYPE_EPON:
281	3.50k	case LINKTYPE_IPMI_HPM_2:
282	3.50k	case LINKTYPE_ZWAVE_R1_R2:
283	3.51k	case LINKTYPE_ZWAVE_R3:
284	3.51k	case LINKTYPE_WATTSTOPPER_DLM:
285	3.51k	case LINKTYPE_ISO_14443:
286	3.94k	case LINKTYPE_LINUX_SLL2:
287	3.94k	return true;
288	10	default:
289	10	return false;
290	3.95k	}
291	3.95k	}
292
293		} // namespace pcpp