channel.h

Go to the documentation of this file.

#ifndef SNIFF_CHANNEL
#define SNIFF_CHANNEL
 
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <queue>
#include <tins/packet.h>
 
namespace yarilo {
 
class PacketChannel {
public:
  PacketChannel() : closed(false) {}
 
  void send(std::unique_ptr<Tins::Packet> pkt) {
    std::unique_lock<std::mutex> send_lock(send_mtx);
    {
      std::unique_lock<std::mutex> lock(mtx);
      decrypted_packets.push(std::move(pkt));
    }
    cv.notify_one();
  }
 
  std::optional<std::unique_ptr<Tins::Packet>> receive() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [this] { return !decrypted_packets.empty() || closed; });
    if (closed)
      return std::nullopt;
 
    std::unique_ptr<Tins::Packet> value = std::move(decrypted_packets.front());
    decrypted_packets.pop();
    return value;
  }
 
  void close() {
    closed = true;
    cv.notify_one();
  }
 
  bool is_closed() { return closed; }
 
  bool is_empty() { return decrypted_packets.empty(); }
 
  size_t len() { return decrypted_packets.size(); }
 
  std::unique_lock<std::mutex> lock_send() {
    return std::unique_lock(send_mtx);
  }
 
  void unlock_send() { send_mtx.unlock(); }
 
private:
  std::queue<std::unique_ptr<Tins::Packet>> decrypted_packets;
  std::mutex mtx;
  std::mutex send_mtx;
  std::condition_variable cv;
  std::atomic<bool> closed;
};
 
} // namespace yarilo
 
#endif // SNIFF_CHANNEL