net_card_manager.h

Go to the documentation of this file.

#ifndef SNIFF_NET_CARD_MANAGER
#define SNIFF_NET_CARD_MANAGER
 
#include "netlink/attr.h"
#include "netlink/handlers.h"
#include "netlink/netlink.h"
#include <linux/nl80211.h>
#include <memory>
#include <optional>
#include <set>
#include <spdlog/logger.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
#include <string>
 
namespace yarilo {
 
class NetlinkCallback {
public:
  NetlinkCallback(nl_sock *sock) { this->sock = sock; };
 
  void attach(nl_recvmsg_msg_cb_t func, void *arg);
 
  int wait();
 
private:
  static int finish(nl_msg *msg, void *arg);
  static int error(sockaddr_nl *nla, nlmsgerr *err, void *arg);
  static int ack(nl_msg *msg, void *arg);
 
  nl_sock *sock = nullptr;
  nl_cb *callback = nullptr;
  int result = 1;
};
 
class NetCardManager {
public:
  enum ChannelModes {
    NO_HT,     // Channel does not support High Throughput (HT) mode.
    HT20,      // Channel does support HT mode with a channel width of 20 MHz.
    HT40MINUS, // Channel does support HT mode with a channel width of 40 MHz,
               // where the secondary channel is below the primary channel.
    HT40PLUS,  // Channel does support HT mode with a channel width of 40 MHz,
               // where the secondary channel is above the primary channel.
    VHT80,     // Channel does support Very High Throughput (VHT) mode with a
               // channel width of 80 MHz
    VHT80P80,  // Channel does support Very High Throughput (VHT) mode with a
               // channel width of 80 MHz and also supports an additional 80 MHz
               // channel (80+80 MHz)
    VHT160     // Channel does support VHT mode with a channel width of 160 MHz
  };
 
  enum FcsState { FCS_ALL, FCS_VALID, FCS_INVALID };
 
  struct phy_info {
    std::string ifname;             // Interface name
    std::set<uint32_t> frequencies; // Supported frequencies
    bool can_check_fcs;             // Can it check the Frame Check Sequence
    int channel_opts; // All available channel options, see ChannelModes
    int can_monitor;  // Supports monitor mode
 
    bool operator<(const phy_info &other) const {
      return ifname < other.ifname;
    }
  };
 
  struct iface_state {
    int type;               // (virtual) interface type, see nl80211_iftype
    int phy_idx;            // Physical index
    int logic_idx;          // Logical index
    int freq;               // Current working frequency
    ChannelModes chan_type; // Current channel type
    int center_freq1;       // Primary center frequency
    int center_freq2; // Secondary center frequency in cases of bonded channels.
    FcsState fcs_state; // Validation state of the Frame Check Sequence
  };
 
  NetCardManager();
 
  bool connect();
 
  void disconnect();
 
  static std::set<std::string> net_interfaces();
 
  std::set<std::string> phy_interfaces() const;
 
  std::optional<phy_info> phy_details(int phy_idx) const;
 
  std::optional<iface_state> net_iface_details(const std::string &ifname) const;
 
  bool set_phy_channel(int phy_idx, int chan) const;
 
  static int freq_to_chan(int freq);
 
  static int chan_to_freq(int chan);
 
  ~NetCardManager() {
    if (sock)
      nl_socket_free(this->sock);
  }
 
private:
  static int phy_interfaces_callback(nl_msg *msg, void *arg);
  static int phy_details_callback(nl_msg *msg, void *arg);
  static int net_iface_details_callback(nl_msg *msg, void *arg);
 
  std::shared_ptr<spdlog::logger> logger;
  nl_sock *sock = nullptr;
  int sock_id = -1;
};
 
} // namespace yarilo
 
#endif // SNIFF_NET_CARD_MANAGER