/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "iputils.hh"

#include <fstream>
#include <sys/socket.h>
#include <boost/format.hpp>

#ifdef HAVE_GETIFADDRS
#include <ifaddrs.h>
#endif

/** these functions provide a very lightweight wrapper to the Berkeley sockets API. Errors -> exceptions! */

static void RuntimeError(const std::string& error)
{
  throw runtime_error(error);
}

static void NetworkErr(const std::string& error)
{
  throw NetworkError(error);
}

int SSocket(int family, int type, int flags)
{
  int ret = socket(family, type, flags);
  if (ret < 0) {
    RuntimeError("creating socket of type " + std::to_string(family) + ": " + stringerror());
  }
  return ret;
}

int SConnect(int sockfd, const ComboAddress& remote)
{
  int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
  if (ret < 0) {
    int savederrno = errno;
    RuntimeError("connecting socket to " + remote.toStringWithPort() + ": " + stringerror(savederrno));
  }
  return ret;
}

int SConnectWithTimeout(int sockfd, const ComboAddress& remote, const struct timeval& timeout)
{
  int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
  if (ret < 0) {
    int savederrno = errno;
    if (savederrno == EINPROGRESS) {
      if (timeout <= timeval{0, 0}) {
        return savederrno;
      }

      /* we wait until the connection has been established */
      bool error = false;
      bool disconnected = false;
      int res = waitForRWData(sockfd, false, static_cast<int>(timeout.tv_sec), static_cast<int>(timeout.tv_usec), &error, &disconnected);
      if (res == 1) {
        if (error) {
          savederrno = 0;
          socklen_t errlen = sizeof(savederrno);
          if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&savederrno, &errlen) == 0) {
            NetworkErr("connecting to " + remote.toStringWithPort() + " failed: " + stringerror(savederrno));
          }
          else {
            NetworkErr("connecting to " + remote.toStringWithPort() + " failed");
          }
        }
        if (disconnected) {
          NetworkErr(remote.toStringWithPort() + " closed the connection");
        }
        return 0;
      }
      if (res == 0) {
        NetworkErr("timeout while connecting to " + remote.toStringWithPort());
      }
      else if (res < 0) {
        savederrno = errno;
        NetworkErr("waiting to connect to " + remote.toStringWithPort() + ": " + stringerror(savederrno));
      }
    }
    else {
      NetworkErr("connecting to " + remote.toStringWithPort() + ": " + stringerror(savederrno));
    }
  }

  return 0;
}

int SBind(int sockfd, const ComboAddress& local)
{
  int ret = bind(sockfd, reinterpret_cast<const struct sockaddr*>(&local), local.getSocklen()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
  if (ret < 0) {
    int savederrno = errno;
    RuntimeError("binding socket to " + local.toStringWithPort() + ": " + stringerror(savederrno));
  }
  return ret;
}

int SAccept(int sockfd, ComboAddress& remote)
{
  socklen_t remlen = remote.getSocklen();

  int ret = accept(sockfd, reinterpret_cast<struct sockaddr*>(&remote), &remlen); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
  if (ret < 0) {
    RuntimeError("accepting new connection on socket: " + stringerror());
  }
  return ret;
}

int SListen(int sockfd, int limit)
{
  int ret = listen(sockfd, limit);
  if (ret < 0) {
    RuntimeError("setting socket to listen: " + stringerror());
  }
  return ret;
}

int SSetsockopt(int sockfd, int level, int opname, int value)
{
  int ret = setsockopt(sockfd, level, opname, &value, sizeof(value));
  if (ret < 0) {
    RuntimeError("setsockopt for level " + std::to_string(level) + " and opname " + std::to_string(opname) + " to " + std::to_string(value) + " failed: " + stringerror());
  }
  return ret;
}

void setSocketIgnorePMTU([[maybe_unused]] int sockfd, [[maybe_unused]] int family)
{
  if (family == AF_INET) { // NOLINT(bugprone-branch-clone)
#if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT)
#ifdef IP_PMTUDISC_OMIT
    /* Linux 3.15+ has IP_PMTUDISC_OMIT, which discards PMTU information to prevent
       poisoning, but still allows fragmentation if the packet size exceeds the
       outgoing interface MTU, which is good.
    */
    try {
      SSetsockopt(sockfd, IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_OMIT);
      return;
    }
    catch (const std::exception& e) {
      /* failed, let's try IP_PMTUDISC_DONT instead */
    }
#endif /* IP_PMTUDISC_OMIT */

    /* IP_PMTUDISC_DONT disables Path MTU discovery */
    SSetsockopt(sockfd, IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_DONT);
#endif /* defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT) */
  }
  else {
#if defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DONT)
#ifdef IPV6_PMTUDISC_OMIT
    /* Linux 3.15+ has IPV6_PMTUDISC_OMIT, which discards PMTU information to prevent
       poisoning, but still allows fragmentation if the packet size exceeds the
       outgoing interface MTU, which is good.
    */
    try {
      SSetsockopt(sockfd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, IPV6_PMTUDISC_OMIT);
      return;
    }
    catch (const std::exception& e) {
      /* failed, let's try IP_PMTUDISC_DONT instead */
    }
#endif /* IPV6_PMTUDISC_OMIT */

    /* IPV6_PMTUDISC_DONT disables Path MTU discovery */
    SSetsockopt(sockfd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, IPV6_PMTUDISC_DONT);
#endif /* defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DONT) */
  }
}

void setSocketForcePMTU([[maybe_unused]] int sockfd, [[maybe_unused]] int family)
{
  if (family == AF_INET) {
#if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)
    /* IP_PMTUDISC_DO enables Path MTU discovery and prevents fragmentation */
    SSetsockopt(sockfd, IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_DO);
#elif defined(IP_DONTFRAG)
    /* at least this prevents fragmentation */
    SSetsockopt(sockfd, IPPROTO_IP, IP_DONTFRAG, 1);
#endif /* defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) */
  }
  else {
#if defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
    /* IPV6_PMTUDISC_DO enables Path MTU discovery and prevents fragmentation */
    SSetsockopt(sockfd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, IPV6_PMTUDISC_DO);
#elif defined(IPV6_DONTFRAG)
    /* at least this prevents fragmentation */
    SSetsockopt(sockfd, IPPROTO_IPV6, IPV6_DONTFRAG, 1);
#endif /* defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) */
  }
}

bool setReusePort(int sockfd)
{
#if defined(SO_REUSEPORT_LB)
  try {
    SSetsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT_LB, 1);
    return true;
  }
  catch (const std::exception& e) {
    return false;
  }
#elif defined(SO_REUSEPORT)
  try {
    SSetsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, 1);
    return true;
  }
  catch (const std::exception& e) {
    return false;
  }
#endif
  return false;
}

bool HarvestTimestamp(struct msghdr* msgh, struct timeval* timeval)
{
  // NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast, cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-const-cast, cppcoreguidelines-pro-type-reinterpret-cast)
#ifdef SO_TIMESTAMP
  struct cmsghdr* cmsg{};
  for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != nullptr; cmsg = CMSG_NXTHDR(msgh, cmsg)) {
    if ((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SO_TIMESTAMP || cmsg->cmsg_type == SCM_TIMESTAMP) && CMSG_LEN(sizeof(*timeval)) == cmsg->cmsg_len) {
      memcpy(timeval, CMSG_DATA(cmsg), sizeof(*timeval));
      return true;
    }
  }
#endif
  return false;
}
bool HarvestDestinationAddress(const struct msghdr* msgh, ComboAddress* destination)
{
  destination->reset();
#ifdef __NetBSD__
  struct cmsghdr* cmsg{};
#else
  const struct cmsghdr* cmsg{};
#endif
  for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != nullptr; cmsg = CMSG_NXTHDR(const_cast<struct msghdr*>(msgh), const_cast<struct cmsghdr*>(cmsg))) {
#if defined(IP_PKTINFO)
    if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_PKTINFO)) {
      const auto* ptr = reinterpret_cast<const struct in_pktinfo*>(CMSG_DATA(cmsg));
      destination->sin4.sin_addr = ptr->ipi_addr;
      destination->sin4.sin_family = AF_INET;
      return true;
    }
#elif defined(IP_RECVDSTADDR)
    if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_RECVDSTADDR)) {
      const auto* ptr = reinterpret_cast<const struct in_addr*>(CMSG_DATA(cmsg));
      destination->sin4.sin_addr = *ptr;
      destination->sin4.sin_family = AF_INET;
      return true;
    }
#endif

    if ((cmsg->cmsg_level == IPPROTO_IPV6) && (cmsg->cmsg_type == IPV6_PKTINFO)) {
      const auto* ptr = reinterpret_cast<const struct in6_pktinfo*>(CMSG_DATA(cmsg));
      destination->sin6.sin6_addr = ptr->ipi6_addr;
      destination->sin4.sin_family = AF_INET6;
      return true;
    }
  }
  return false;
  // NOLINTEND(cppcoreguidelines-pro-type-cstyle-cast, cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-const-cast, cppcoreguidelines-pro-type-reinterpret-cast)
}

bool IsAnyAddress(const ComboAddress& addr)
{
  if (addr.sin4.sin_family == AF_INET) {
    return addr.sin4.sin_addr.s_addr == 0;
  }
  if (addr.sin4.sin_family == AF_INET6) {
    return memcmp(&addr.sin6.sin6_addr, &in6addr_any, sizeof(addr.sin6.sin6_addr)) == 0;
  }
  return false;
}

int sendOnNBSocket(int fileDesc, const struct msghdr* msgh)
{
  int sendErr = 0;
#ifdef __OpenBSD__
  // OpenBSD can and does return EAGAIN on non-blocking datagram sockets
  for (int i = 0; i < 10; i++) { // Arbitrary upper bound
    if (sendmsg(fileDesc, msgh, 0) != -1) {
      sendErr = 0;
      break;
    }
    sendErr = errno;
    if (sendErr != EAGAIN) {
      break;
    }
  }
#else
  if (sendmsg(fileDesc, msgh, 0) == -1) {
    sendErr = errno;
  }
#endif
  return sendErr;
}

// be careful: when using this for receive purposes, make sure addr->sin4.sin_family is set appropriately so getSocklen works!
// be careful: when using this function for *send* purposes, be sure to set cbufsize to 0!
// be careful: if you don't call addCMsgSrcAddr after fillMSGHdr, make sure to set msg_control to NULL
void fillMSGHdr(struct msghdr* msgh, struct iovec* iov, cmsgbuf_aligned* cbuf, size_t cbufsize, char* data, size_t datalen, ComboAddress* addr)
{
  iov->iov_base = data;
  iov->iov_len = datalen;

  memset(msgh, 0, sizeof(struct msghdr));

  msgh->msg_control = cbuf;
  msgh->msg_controllen = cbufsize;
  msgh->msg_name = addr;
  msgh->msg_namelen = addr->getSocklen();
  msgh->msg_iov = iov;
  msgh->msg_iovlen = 1;
  msgh->msg_flags = 0;
}

// warning: various parts of PowerDNS assume 'truncate' will never throw
void ComboAddress::truncate(unsigned int bits) noexcept
{
  uint8_t* start{};
  int len = 4;
  if (sin4.sin_family == AF_INET) {
    if (bits >= 32) {
      return;
    }
    start = reinterpret_cast<uint8_t*>(&sin4.sin_addr.s_addr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    len = 4;
  }
  else {
    if (bits >= 128) {
      return;
    }
    start = reinterpret_cast<uint8_t*>(&sin6.sin6_addr.s6_addr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    len = 16;
  }

  auto tozero = len * 8 - bits; // if set to 22, this will clear 1 byte, as it should

  memset(start + len - tozero / 8, 0, tozero / 8); // blot out the whole bytes on the right NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)

  auto bitsleft = tozero % 8; // 2 bits left to clear
  if (bitsleft == 0) {
    // the memset() above cleared whole bytes only, and for 0 bits the byte we
    // would look at is the one before the address
    return;
  }

  // a b c d, to truncate to 22 bits, we just zeroed 'd' and need to zero 2 bits from c
  // so and by '11111100', which is ~((1<<2)-1)  = ~3
  uint8_t* place = start + len - 1 - tozero / 8; // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  *place &= (~((1 << bitsleft) - 1));
}

size_t sendMsgWithOptions(int socketDesc, const void* buffer, size_t len, const ComboAddress* dest, const ComboAddress* local, unsigned int localItf, int flags)
{
  msghdr msgh{};
  iovec iov{};
  cmsgbuf_aligned cbuf;

  /* Set up iov and msgh structures. */
  memset(&msgh, 0, sizeof(msgh));
  msgh.msg_control = nullptr;
  msgh.msg_controllen = 0;
  if (dest != nullptr) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-type-const-cast): it's the API
    msgh.msg_name = reinterpret_cast<void*>(const_cast<ComboAddress*>(dest));
    msgh.msg_namelen = dest->getSocklen();
  }
  else {
    msgh.msg_name = nullptr;
    msgh.msg_namelen = 0;
  }

  msgh.msg_flags = 0;

  if (local != nullptr && local->sin4.sin_family != 0) {
    addCMsgSrcAddr(&msgh, &cbuf, local, static_cast<int>(localItf));
  }

  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast): it's the API
  iov.iov_base = const_cast<void*>(buffer);
  iov.iov_len = len;
  msgh.msg_iov = &iov;
  msgh.msg_iovlen = 1;
  msgh.msg_flags = 0;

  size_t sent = 0;
#ifdef MSG_FASTOPEN
  bool firstTry = true;
#endif

  do {

#ifdef MSG_FASTOPEN
    if ((flags & MSG_FASTOPEN) != 0 && !firstTry) {
      flags &= ~MSG_FASTOPEN;
    }
#endif /* MSG_FASTOPEN */

    ssize_t res = sendmsg(socketDesc, &msgh, flags);

    if (res > 0) {
      auto written = static_cast<size_t>(res);
      sent += written;

      if (sent == len) {
        return sent;
      }

      /* partial write */
#ifdef MSG_FASTOPEN
      firstTry = false;
#endif
      iov.iov_len -= written;
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic): it's the API
      iov.iov_base = reinterpret_cast<void*>(reinterpret_cast<char*>(iov.iov_base) + written);
    }
    else if (res == 0) {
      return res;
    }
    else if (res == -1) {
      int err = errno;
      if (err == EINTR) {
        continue;
      }
      if (err == EAGAIN || err == EWOULDBLOCK || err == EINPROGRESS || err == ENOTCONN) {
        /* EINPROGRESS might happen with non blocking socket,
           especially with TCP Fast Open */
        return sent;
      }
      unixDie("failed in sendMsgWithOptions");
    }
  } while (true);

  return 0;
}

template class NetmaskTree<bool, Netmask>;

/* requires a non-blocking socket.
   On Linux, we could use MSG_DONTWAIT on a blocking socket
   but this is not portable.
*/
bool isTCPSocketUsable(int sock)
{
  int err = 0;
  char buf = '\0';
  size_t buf_size = sizeof(buf);

  do {
    ssize_t got = recv(sock, &buf, buf_size, MSG_PEEK);

    if (got > 0) {
      /* socket is usable, some data is even waiting to be read */
      return true;
    }
    if (got == 0) {
      /* other end has closed the socket */
      return false;
    }
    err = errno;
    if (err == EAGAIN || err == EWOULDBLOCK) {
      /* socket is usable, no data waiting */
      return true;
    }
    if (err != EINTR) {
      /* something is wrong, could be ECONNRESET,
         ENOTCONN, EPIPE, but anyway this socket is
         not usable. */
      return false;
    }
  } while (err == EINTR);

  return false;
}
/* mission in life: parse four cases
   1) [2002::1]:53
   2) 1.2.3.4
   3) 1.2.3.4:5300
   4) 2001::1 no port allowed
*/

ComboAddress parseIPAndPort(const std::string& input, uint16_t port)
{
  if (input[0] == '[') { // case 1
    auto both = splitField(input.substr(1), ']');
    return ComboAddress(both.first, both.second.empty() ? port : pdns::checked_stoi<uint16_t>(both.second.substr(1)));
  }

  string::size_type count = 0;
  for (char chr : input) {
    if (chr == ':') {
      count++;
    }
    if (count > 1) {
      break;
    }
  }
  switch (count) {
  case 0: // case 2
    return ComboAddress(input, port);
  case 1: { // case 3
    string::size_type cpos = input.rfind(':');
    pair<std::string, std::string> both;
    both.first = input.substr(0, cpos);
    both.second = input.substr(cpos + 1);

    auto newport = pdns::checked_stoi<uint16_t>(both.second);
    return ComboAddress(both.first, newport);
  }
  default: // case 4
    return ComboAddress(input, port);
  }
}

void setSocketBuffer(int fileDesc, int optname, uint32_t size)
{
  uint32_t psize = 0;
  socklen_t len = sizeof(psize);

  if (getsockopt(fileDesc, SOL_SOCKET, optname, &psize, &len) != 0) {
    throw std::runtime_error("Unable to retrieve socket buffer size:" + stringerror());
  }
  if (psize >= size) {
    return;
  }
  if (setsockopt(fileDesc, SOL_SOCKET, optname, &size, sizeof(size)) != 0) {
    throw std::runtime_error("Unable to raise socket buffer size to " + std::to_string(size) + ": " + stringerror());
  }
}

void setSocketReceiveBuffer(int fileDesc, uint32_t size)
{
  setSocketBuffer(fileDesc, SO_RCVBUF, size);
}

void setSocketSendBuffer(int fileDesc, uint32_t size)
{
  setSocketBuffer(fileDesc, SO_SNDBUF, size);
}

#ifdef __linux__
static uint32_t raiseSocketBufferToMax(int socket, int optname, const std::string& readMaxFromFile)
{
  std::ifstream ifs(readMaxFromFile);
  if (ifs) {
    std::string line;
    if (getline(ifs, line)) {
      auto max = pdns::checked_stoi<uint32_t>(line);
      setSocketBuffer(socket, optname, max);
      return max;
    }
  }
  return 0;
}
#endif

uint32_t raiseSocketReceiveBufferToMax([[maybe_unused]] int socket)
{
#ifdef __linux__
  return raiseSocketBufferToMax(socket, SO_RCVBUF, "/proc/sys/net/core/rmem_max");
#else
  return 0;
#endif
}

uint32_t raiseSocketSendBufferToMax([[maybe_unused]] int socket)
{
#ifdef __linux__
  return raiseSocketBufferToMax(socket, SO_SNDBUF, "/proc/sys/net/core/wmem_max");
#else
  return 0;
#endif
}

std::set<std::string> getListOfNetworkInterfaces()
{
  std::set<std::string> result;
#ifdef HAVE_GETIFADDRS
  struct ifaddrs* ifaddr{};
  if (getifaddrs(&ifaddr) == -1) {
    return result;
  }

  for (struct ifaddrs* ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
    if (ifa->ifa_name == nullptr) {
      continue;
    }
    result.insert(ifa->ifa_name);
  }

  freeifaddrs(ifaddr);
#endif
  return result;
}

#ifdef HAVE_GETIFADDRS
std::vector<ComboAddress> getListOfAddressesOfNetworkInterface(const std::string& itf)
{
  std::vector<ComboAddress> result;
  struct ifaddrs* ifaddr = nullptr;
  if (getifaddrs(&ifaddr) == -1) {
    return result;
  }

  for (struct ifaddrs* ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
    if (ifa->ifa_name == nullptr || strcmp(ifa->ifa_name, itf.c_str()) != 0) {
      continue;
    }
    if (ifa->ifa_addr == nullptr || (ifa->ifa_addr->sa_family != AF_INET && ifa->ifa_addr->sa_family != AF_INET6)) {
      continue;
    }
    ComboAddress addr;
    try {
      addr.setSockaddr(ifa->ifa_addr, ifa->ifa_addr->sa_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6));
    }
    catch (...) {
      continue;
    }

    result.push_back(addr);
  }

  freeifaddrs(ifaddr);
  return result;
}
#else
std::vector<ComboAddress> getListOfAddressesOfNetworkInterface(const std::string& /* itf */)
{
  std::vector<ComboAddress> result;
  return result;
}
#endif // HAVE_GETIFADDRS

#ifdef HAVE_GETIFADDRS
static uint8_t convertNetmaskToBits(const uint8_t* mask, socklen_t len)
{
  if (mask == nullptr || len > 16) {
    throw std::runtime_error("Invalid parameters passed to convertNetmaskToBits");
  }

  uint8_t result = 0;
  // for all bytes in the address (4 for IPv4, 16 for IPv6)
  for (size_t idx = 0; idx < len; idx++) {
    uint8_t byte = *(mask + idx); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    // count the number of bits set
    while (byte > 0) {
      result += (byte & 1);
      byte >>= 1;
    }
  }
  return result;
}
#endif /* HAVE_GETIFADDRS */

#ifdef HAVE_GETIFADDRS
std::vector<Netmask> getListOfRangesOfNetworkInterface(const std::string& itf)
{
  std::vector<Netmask> result;
  struct ifaddrs* ifaddr = nullptr;
  if (getifaddrs(&ifaddr) == -1) {
    return result;
  }

  for (struct ifaddrs* ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
    if (ifa->ifa_name == nullptr || strcmp(ifa->ifa_name, itf.c_str()) != 0) {
      continue;
    }
    if (ifa->ifa_addr == nullptr || (ifa->ifa_addr->sa_family != AF_INET && ifa->ifa_addr->sa_family != AF_INET6)) {
      continue;
    }
    ComboAddress addr;
    try {
      addr.setSockaddr(ifa->ifa_addr, ifa->ifa_addr->sa_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6));
    }
    catch (...) {
      continue;
    }

    // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
    if (ifa->ifa_addr->sa_family == AF_INET) {
      const auto* netmask = reinterpret_cast<const struct sockaddr_in*>(ifa->ifa_netmask);
      uint8_t maskBits = convertNetmaskToBits(reinterpret_cast<const uint8_t*>(&netmask->sin_addr.s_addr), sizeof(netmask->sin_addr.s_addr));
      result.emplace_back(addr, maskBits);
    }
    else if (ifa->ifa_addr->sa_family == AF_INET6) {
      const auto* netmask = reinterpret_cast<const struct sockaddr_in6*>(ifa->ifa_netmask);
      uint8_t maskBits = convertNetmaskToBits(reinterpret_cast<const uint8_t*>(&netmask->sin6_addr.s6_addr), sizeof(netmask->sin6_addr.s6_addr));
      result.emplace_back(addr, maskBits);
    }
    // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
  }

  freeifaddrs(ifaddr);
  return result;
}
#else
std::vector<Netmask> getListOfRangesOfNetworkInterface(const std::string& /* itf */)
{
  std::vector<Netmask> result;
  return result;
}
#endif // HAVE_GETIFADDRS
