PcapPlusPlus  20.08
KniDevice.h
Go to the documentation of this file.
1 #ifndef PCAPPP_KNI_DEVICE
2 #define PCAPPP_KNI_DEVICE
3 
4 #include <string>
5 
6 #include "Device.h"
7 #include "MacAddress.h"
8 #include "MBufRawPacket.h"
9 #include "LinuxNicInformationSocket.h"
10 
79 struct rte_kni;
80 
85 namespace pcpp
86 {
87  class KniDevice;
88  class KniDeviceList;
89 
93  typedef bool (*OnKniPacketArriveCallback)(MBufRawPacket* packets, uint32_t numOfPackets, KniDevice* device, void* userCookie);
94 
120  class KniDevice : public IDevice
121  {
122  friend class KniDeviceList;
123  friend class MBufRawPacket;
124  public:
129  {
138  };
143  {
148  };
153  {
158  };
159 
172  {
177  int (*change_mtu)(uint16_t port_id, unsigned int new_mtu);
182  int (*config_network_if)(uint16_t port_id, uint8_t if_up);
190  int (*config_mac_address)(uint16_t port_id, uint8_t mac_addr[]);
198  int (*config_promiscusity)(uint16_t port_id, uint8_t to_on);
199  };
200 
209  {
214  int (*change_mtu)(uint8_t port_id, unsigned int new_mtu);
219  int (*config_network_if)(uint8_t port_id, uint8_t if_up);
220  };
221 
229  {
235  std::string name;
236  union
237  {
238  KniIoctlCallbacks* callbacks;
239  KniOldIoctlCallbacks* oldCallbacks;
240  };
254  uint16_t portId;
256  uint16_t mtu;
266  uint32_t kthreadCoreId;
267  };
268 
269  private:
271  KniDevice(const KniDeviceConfiguration& conf, size_t mempoolSize, int unique);
273  KniDevice(const KniDevice&);
275  KniDevice& operator=(const KniDevice&);
277  ~KniDevice();
278 
279  public:
280  /* Information getters */
281 
285  inline bool isInitialized() const { return !(m_Device == NULL || m_MBufMempool == NULL); }
289  inline std::string getName() const { return std::string(m_DeviceInfo.name); }
293  inline uint16_t getPort() const { return m_DeviceInfo.portId; }
320  uint16_t getMtu(KniInfoState state = INFO_CACHED);
330 
331  /* Information setters */
332 
344  bool setLinkState(KniLinkState state);
354  bool setMacAddress(MacAddress mac);
365  bool setMtu(uint16_t mtu);
390 
391  /* Requests */
392 
408  bool handleRequests();
421  bool startRequestHandlerThread(long sleepSeconds, long sleepNanoSeconds = 0);
431 
432  /* Packet receive */
433 
439  uint16_t receivePackets(MBufRawPacketVector& rawPacketsArr);
452  uint16_t receivePackets(MBufRawPacket** rawPacketsArr, uint16_t rawPacketArrLength);
461  uint16_t receivePackets(Packet** packetsArr, uint16_t packetsArrLength);
462 
463  /* Packet send */
464 
479  uint16_t sendPackets(MBufRawPacket** rawPacketsArr, uint16_t arrLength);
495  uint16_t sendPackets(Packet** packetsArr, uint16_t arrLength);
506  uint16_t sendPackets(MBufRawPacketVector& rawPacketsVec);
521  uint16_t sendPackets(RawPacketVector& rawPacketsVec);
531  bool sendPacket(RawPacket& rawPacket);
538  bool sendPacket(MBufRawPacket& rawPacket);
548  bool sendPacket(Packet& packet);
549 
550  /* Packet capture */
551 
569  bool startCapture(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie);
592  int startCaptureBlockingMode(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie, int timeout);
596  void stopCapture();
597 
598  /* Device control */
599 
605  bool open();
611  void close();
612 
613  private:
614  struct rte_kni* m_Device;
615  struct rte_mempool* m_MBufMempool;
616  struct KniDeviceInfo
617  {
619  KniLinkState link;
620  KniPromiscuousMode promisc;
621  uint16_t portId;
622  uint16_t mtu;
623  MacAddress mac;
624  std::string name;
625 
626  bool init(const KniDeviceConfiguration& conf);
627  } m_DeviceInfo;
628  struct KniThread;
629  struct KniCapturing
630  {
631  OnKniPacketArriveCallback callback;
632  void* userCookie;
633  KniThread* thread;
634 
635  static void* runCapture(void* devicePointer);
636  inline bool isRunning() const { return thread != NULL; }
637  void cleanup();
638  } m_Capturing;
639  struct KniRequests
640  {
641  long sleepS;
642  long sleepNs;
643  KniThread* thread;
644 
645  static void* runRequests(void* devicePointer);
646  void cleanup();
647  } m_Requests;
648  };
649 
650 } // namespace pcpp
651 #endif /* PCAPPP_KNI_DEVICE */
The main namespace for the PcapPlusPlus lib.
Definition: KniDevice.h:155
KniPromiscuousMode getPromiscuous(KniInfoState state=INFO_CACHED)
Obtains information about promiscuous mode of KNI device. If called with INFO_CACHED - returns cached...
int(* change_mtu)(uint16_t port_id, unsigned int new_mtu)
Definition: KniDevice.h:177
Definition: KniDevice.h:120
void close()
Close the KNI device. When device is closed it&#39;s not possible to work with it. Stops asynchronous pac...
Definition: KniDevice.h:135
bool startCapture(OnKniPacketArriveCallback onPacketArrives, void *onPacketArrivesUserCookie)
Start capturing packets asynchronously on this KNI interface. Each time a burst of packets is capture...
bool setPromiscuous(KniPromiscuousMode mode)
Sets promiscuous mode of KNI device. Firstly the promiscuous mode information is updated as by call t...
KniInfoState
Definition: KniDevice.h:142
uint16_t getMtu(KniInfoState state=INFO_CACHED)
Obtains MTU of KNI device. If called with INFO_CACHED - returns cached data about MTU (SUPER FAST may...
Definition: KniDevice.h:147
Definition: Packet.h:26
bool bindKthread
Definition: KniDevice.h:264
bool isInitialized() const
Definition: KniDevice.h:285
Definition: PointerVector.h:24
MacAddress getMacAddress(KniInfoState state=INFO_CACHED)
Obtains MAC address of KNI device. If called with INFO_CACHED - returns cached data about MAC address...
Definition: RawPacket.h:252
Definition: Device.h:24
Definition: LinuxNicInformationSocket.h:26
uint32_t kthreadCoreId
Definition: KniDevice.h:266
Definition: MBufRawPacket.h:43
bool startRequestHandlerThread(long sleepSeconds, long sleepNanoSeconds=0)
Starts new thread (using pthread) to asynchronously handle KNI device requests. See description of ha...
int(* config_promiscusity)(uint16_t port_id, uint8_t to_on)
Definition: KniDevice.h:198
bool(* OnKniPacketArriveCallback)(MBufRawPacket *packets, uint32_t numOfPackets, KniDevice *device, void *userCookie)
Definition: KniDevice.h:93
KniLinkState
Definition: KniDevice.h:128
New callbacks for KNI device events. This structure MUST be used ONLY when KniDeviceList::callbackVer...
Definition: KniDevice.h:171
KniLinkState getLinkState(KniInfoState state=INFO_CACHED)
Obtains link status of KNI device. If called with INFO_CACHED - returns cached data about link state ...
Old callbacks for KNI device events. This structure MUST be used ONLY when KniDeviceList::callbackVer...
Definition: KniDevice.h:208
MacAddress mac
Definition: KniDevice.h:247
int startCaptureBlockingMode(OnKniPacketArriveCallback onPacketArrives, void *onPacketArrivesUserCookie, int timeout)
Start capturing packets synchronously on this KNI interface in blocking mode. Blocking mode means tha...
int(* config_network_if)(uint16_t port_id, uint8_t if_up)
Definition: KniDevice.h:182
Definition: KniDevice.h:133
bool handleRequests()
Handle requests from Linux kernel synchronously in calling thread. When one of events which is needed...
Definition: KniDeviceList.h:22
KniLinkState updateLinkState(KniLinkState state)
Updates link state of KNI device. Unconditionally updates link state of KNI device via call to DPDK l...
bool setMacAddress(MacAddress mac)
Sets MAC address of KNI device. Unconditionally changes MAC of KNI device. If MAC is updated successf...
Definition: KniDevice.h:145
std::string name
Definition: KniDevice.h:235
Definition: KniDevice.h:157
KNI device initialization data. Used to create new KNI device. Usage of callbacks member or oldCallba...
Definition: KniDevice.h:228
bool setLinkState(KniLinkState state)
Sets link state of KNI device. Firstly the link information is updated as by call to getLinkState(INF...
std::string getName() const
Definition: KniDevice.h:289
bool setMtu(uint16_t mtu)
Sets MTU of KNI device. Unconditionally changes MTU of KNI device. If MTU is updated successfully the...
uint16_t portId
Definition: KniDevice.h:254
KniPromiscuousMode
Definition: KniDevice.h:152
uint16_t mtu
Definition: KniDevice.h:256
uint16_t receivePackets(MBufRawPacketVector &rawPacketsArr)
Receive raw packets from kernel.
Definition: KniDevice.h:137
void stopRequestHandlerThread()
Explicitly stops request thread for this device if it was running. See description of handleRequests(...
uint16_t getPort() const
Definition: KniDevice.h:293
Definition: KniDevice.h:131
Definition: MacAddress.h:27
bool sendPacket(RawPacket &rawPacket)
Send a raw packet to kernel. Please notice that if the raw packet isn&#39;t of type MBufRawPacket, a new temp MBufRawPacket will be created and the data will be copied to it. This is necessary to allocate an mbuf which will store the data to be sent. If performance is a critical factor please make sure you send a raw packet of type MBufRawPacket. Please also notice that the mbuf used or allocated in this method isn&#39;t freed by this method, it will be transparently freed by DPDK.
int(* config_mac_address)(uint16_t port_id, uint8_t mac_addr[])
Definition: KniDevice.h:190
uint16_t sendPackets(MBufRawPacket **rawPacketsArr, uint16_t arrLength)
Send an array of MBufRawPacket to kernel. Please notice the following: