pcap packet capture

src/DataAccess/Pcap.cpp

@@ -2,8 +2,92 @@
 // Created by robin on 5/10/16.
 //
 
+#include <pcap.h>
 #include "Pcap.h"
 
+struct CustomPcapData {
+    Pcap* pcap;
+    void* data;
+    PcapCallback callback;
+};
+
 Pcap::Pcap(const std::string &device)
+    : _device(device)
+    , _pcap(0)
+    , _isInLoop(false)
+{
+}
+
+Pcap::~Pcap()
+{
+    close();
+}
+
+ResultBool Pcap::init(int snaplen, bool promisc, int timeout)
+{
+    char errbuf[PCAP_ERRBUF_SIZE];
+    _pcap = pcap_open_live(_device.c_str(), snaplen, promisc, timeout, errbuf);
+    if (!_pcap) {
+        return ResultBool::error(errbuf);
+    }
+    return ResultBool::ok(true);
+}
+
+ResultString Pcap::getDefaultDevice()
+{
+    char errbuf[PCAP_ERRBUF_SIZE];
+    char* dev = pcap_lookupdev(errbuf);
+    if (!dev) {
+        return ResultString::error(errbuf);
+    }
+    return ResultString::ok(dev);
+}
+
+ResultBool Pcap::run(PcapCallback callback, void* data, int count)
+{
+    if (!_pcap) {
+        return ResultBool::error("Pcap has not been initialized");
+    }
+    CustomPcapData customData;
+    customData.pcap = this;
+    customData.data = data;
+    customData.callback = callback;
+    _isInLoop = true;
+    int res = pcap_loop(_pcap, count, [](u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
+        CustomPcapData* customData = (CustomPcapData*)args;
+        customData->pcap->onPacket(args, header, packet);
+    }, (u_char*)&customData);
+    _isInLoop = false;
+    if (res == -1) {
+        return ResultBool::error(getPcapLastError());
+    }
+    return ResultBool::ok(true);
+}
+
+void Pcap::onPacket(u_char* args, const struct pcap_pkthdr* header, const u_char* packet)
+{
+    CustomPcapData* customData = (CustomPcapData*)args;
+    if (!customData->callback(customData->data, header->caplen, (const char*)packet)) {
+        stop();
+    }
+}
+
+std::string Pcap::getPcapLastError() const
+{
+    return pcap_geterr(_pcap);
+}
+
+void Pcap::stop()
+{
+    if (_pcap && _isInLoop) {
+        pcap_breakloop(_pcap);
+    }
+}
+
+void Pcap::close()
 {
+    if (_pcap) {
+        pcap_close(_pcap);
+        _pcap = 0;
+    }
 }

src/DataAccess/Pcap.h

@@ -6,12 +6,38 @@
 #define ROZITM_PCAP_H
 
 #include <string>
+#include <functional>
+#include <pcap.h>
 #include "DBO/Result.h"
 
+typedef std::function<bool(void* userData, unsigned int len, const char* data)> PcapCallback;
+
 class Pcap
 {
 public:
     Pcap(const std::string& device);
+    ~Pcap();
+
+    ResultBool init(int snaplen = BUFSIZ, bool promisc = true, int timeout = 1000);
+
+    ResultBool run(PcapCallback callback, void* data = 0, int count = -1);
+
+    void stop();
+
+    void close();
+
+    std::string getPcapLastError() const;
+
+    static ResultString getDefaultDevice();
+
+protected:
+    const std::string _device;
+
+    pcap_t* _pcap;
+
+    bool _isInLoop;
+
+    void onPacket(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);
 };