interface.cpp

//
//  interface.cpp
//
//  Copyright (c) 2019 2025 Andrea Bondavalli. All rights reserved.
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//  MIT License
//

#include <boost/asio.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <fstream>
#include <utility>
#include <iostream>

#include <ifaddrs.h>
#include "log.hpp"

using namespace boost::asio;
using namespace boost::asio::ip;

bool is_interface_ip(const std::string& interface_name,
                     const std::string& addr) {
  struct ifaddrs *ifap, *ifa;
  struct sockaddr_in* sa;
  char* saddr;
  bool found(false);

  getifaddrs(&ifap);
  for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
    if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) {
      sa = (struct sockaddr_in*)ifa->ifa_addr;
      saddr = inet_ntoa(sa->sin_addr);
      if (interface_name == ifa->ifa_name && addr == saddr)
        found = true;
    }
  }

  freeifaddrs(ifap);
  return found;
}

std::pair<uint32_t, std::string> get_interface_ip(
    const std::string& interface_name) {
  if (interface_name.empty()) {
    return {0, ""};
  }
  int fd = socket(AF_INET, SOCK_DGRAM, 0);
  if (fd < 0) {
    BOOST_LOG_TRIVIAL(warning)
        << "Cannot retrieve IP address for interface " << interface_name;
    return {0, ""};
  }
  struct ifreq ifr;
  ifr.ifr_addr.sa_family = AF_INET;
  strncpy(ifr.ifr_name, interface_name.c_str(), IFNAMSIZ - 1);
  if (ioctl(fd, SIOCGIFADDR, &ifr) < 0) {
    close(fd);
    BOOST_LOG_TRIVIAL(warning)
        << "Cannot retrieve IP address for interface " << interface_name;
    return {0, ""};
  }
  close(fd);

  struct sockaddr_in* sockaddr =
      reinterpret_cast<struct sockaddr_in*>(&ifr.ifr_addr);
  uint32_t addr = ntohl(sockaddr->sin_addr.s_addr);
  std::string str_addr(ip::address_v4(addr).to_string());
  /*BOOST_LOG_TRIVIAL(debug) << "interface " << interface_name
                             << " IP address " << str_addr;*/

  return {addr, str_addr};
}

std::tuple<uint32_t, std::string, bool> get_new_interface_ip(
    const std::string& interface_name,
    const std::string& curr_addr) {
  if (is_interface_ip(interface_name, curr_addr)) {
    uint32_t ip_addr;
    inet_pton(AF_INET, curr_addr.c_str(), &ip_addr);
    return {ntohl(ip_addr), curr_addr, false};
  }

  auto [ip_addr, ip_str] = get_interface_ip(interface_name);
  BOOST_LOG_TRIVIAL(info) << "interface " << interface_name
                          << " new IP address <" << ip_str << ">";
  return {ip_addr, ip_str,
          !ip_str.empty() && !curr_addr.empty() && curr_addr != ip_str};
}

std::pair<std::array<uint8_t, 6>, std::string> get_interface_mac(
    const std::string& interface_name) {
  std::array<uint8_t, 6> mac{0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  int fd = socket(AF_INET, SOCK_DGRAM, 0);
  if (fd < 0) {
    BOOST_LOG_TRIVIAL(error)
        << "Cannot retrieve MAC address for interface " << interface_name;
    return {mac, ""};
  }

  struct ifreq ifr;
  ifr.ifr_addr.sa_family = AF_INET;
  strncpy(ifr.ifr_name, interface_name.c_str(), IFNAMSIZ - 1);
  if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
    close(fd);
    BOOST_LOG_TRIVIAL(error)
        << "Cannot retrieve MAC address for interface " << interface_name;
    return {mac, ""};
  }
  close(fd);

  uint8_t* sa = reinterpret_cast<uint8_t*>(ifr.ifr_hwaddr.sa_data);
  std::copy(sa, sa + 6, std::begin(mac));

  char str_mac[18];
  sprintf(str_mac, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0], mac[1], mac[2],
          mac[3], mac[4], mac[5]);
  /*BOOST_LOG_TRIVIAL(debug) << "interface " << interface_name
                             << " MAC address " << str_mac;*/

  return {mac, str_mac};
}

int get_interface_index(const std::string& interface_name) {
  int fd = socket(AF_INET, SOCK_DGRAM, 0);
  if (fd < 0) {
    BOOST_LOG_TRIVIAL(warning)
        << "Cannot retrieve index for interface " << interface_name;
    return -1;
  }
  struct ifreq ifr;
  ifr.ifr_addr.sa_family = AF_INET;
  strncpy(ifr.ifr_name, interface_name.c_str(), IFNAMSIZ - 1);
  if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
    close(fd);
    BOOST_LOG_TRIVIAL(warning)
        << "Cannot retrieve index for interface " << interface_name;
    return -1;
  }
  close(fd);
  /*BOOST_LOG_TRIVIAL(debug) << "interface " << interface_name
                             << " index " << ifr.ifr_ifindex;*/

  return ifr.ifr_ifindex;
}

std::pair<std::array<uint8_t, 6>, std::string> get_mac_from_arp_cache(
    const std::string& ip) {
  const std::string arpProcPath("/proc/net/arp");
  std::array<uint8_t, 6> mac{0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  std::ifstream stream(arpProcPath);

  while (stream) {
    std::string line;
    std::vector<std::string> tokens;

    std::getline(stream, line);
    if (line.find(ip) == std::string::npos) {
      continue;
    }
    boost::split(tokens, line, boost::is_any_of(" "), boost::token_compress_on);
    /* check that IP is on the correct interface */
    if (tokens.size() >= 6 /*&& tokens[5] == interface_name*/) {
      std::vector<std::string> vec;
      /* parse MAC */
      boost::split(vec, tokens[3], boost::is_any_of(":"));
      int j = 0;
      bool check = false;
      for (auto const& item : vec) {
        mac[j] = strtol(item.c_str(), nullptr, 16);
        check = check | (mac[j] != 0);
        j++;
      }
      if (check) {
        return {mac, tokens[3]};
      }
    }
  }
  BOOST_LOG_TRIVIAL(debug)
      << "get_mac_from_arp_cache:: cannot retrieve MAC for IP " << ip;
  return {mac, ""};
}

bool ping(const std::string& ip) {
  static uint16_t sequence_number(0);
  uint16_t identifier(0xABAB);
  uint8_t buffer[10];

  // Create an ICMP header for an echo request.
  buffer[0] = 0x8;                          // echo request
  buffer[1] = 0x0;                          // code
  memcpy(buffer + 2, &identifier, 2);       // identifier
  memcpy(buffer + 4, &sequence_number, 2);  // sequence number
  memcpy(buffer + 6, "ping", 4);            // body

  // this requires root priv
  try {
    io_context io_service;
    icmp::socket socket{io_service, icmp::v4()};
    ip::icmp::endpoint destination(ip::icmp::v4(),
#if BOOST_VERSION < 108700
                                   ip::address_v4::from_string(ip).to_ulong());
#else
                                   ip::make_address(ip).to_v4().to_uint());
#endif
    socket.send_to(boost::asio::buffer(buffer, sizeof buffer), destination);
  } catch (...) {
    BOOST_LOG_TRIVIAL(error) << "ping:: send_to() failed";
    return false;
  }
  return true;
}

bool echo_try_connect(const std::string& dest_ip) {
  ip::tcp::iostream s;
  BOOST_LOG_TRIVIAL(debug) << "echo_connect:: connecting to " << dest_ip;
#if BOOST_VERSION < 106600
  s.expires_from_now(boost::posix_time::seconds(1));
#else
  s.expires_after(boost::asio::chrono::seconds(1));
#endif
  s.connect(dest_ip, "7");
  if (!s || s.error()) {
    BOOST_LOG_TRIVIAL(debug)
        << "echo_connect:: unable to connect to " << dest_ip;
    return false;
  }
  s.close();
  return true;
}

std::array<uint8_t, 6> get_mcast_mac_addr(uint32_t mcast_ip) {
  // As defined by IANA, the most significant 24 bits of an IPv4 multicast
  // MAC address are 0x01005E.  // Bit 25 is 0, and the other 23 bits are the
  // least significant 23 bits of an IPv4 multicast address.
  return {0x01,
          0x00,
          0x5e,
          static_cast<uint8_t>((mcast_ip >> 16) & 0x7F),
          static_cast<uint8_t>(mcast_ip >> 8),
          static_cast<uint8_t>(mcast_ip)};
}