/src/lldpd/src/daemon/interfaces-linux.c

Source
/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "lldpd.h"

#include <stdio.h>
#include <unistd.h>
#include <inttypes.h>
#include <errno.h>
#include <sys/ioctl.h>
#if defined(__clang__)
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wdocumentation"
#endif
#include <netinet/in.h>
#include <linux/if_vlan.h>
#include <linux/if_bonding.h>
#include <linux/if_bridge.h>
#include <linux/wireless.h>
#include <linux/sockios.h>
#include <linux/if_packet.h>
#include <linux/ethtool.h>
#if defined(__clang__)
#  pragma clang diagnostic pop
#endif

#define SYSFS_PATH_MAX 256
#define MAX_PORTS 1024
#define MAX_BRIDGES 1024

static int
iflinux_eth_init(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
  int fd;

  log_debug("interfaces", "initialize ethernet device %s", hardware->h_ifname);
  if ((fd = priv_iface_init(hardware->h_ifindex, hardware->h_ifname)) == -1)
    return -1;
  hardware->h_sendfd = fd; /* Send */

  interfaces_setup_multicast(cfg, hardware->h_ifname, 0);

  levent_hardware_add_fd(hardware, fd); /* Receive */
  log_debug("interfaces", "interface %s initialized (fd=%d)", hardware->h_ifname,
      fd);
  return 0;
}

/* Generic ethernet send/receive */
static int
iflinux_eth_send(struct lldpd *cfg, struct lldpd_hardware *hardware, char *buffer,
    size_t size)
{
  log_debug("interfaces", "send PDU to ethernet device %s (fd=%d)",
      hardware->h_ifname, hardware->h_sendfd);
  return write(hardware->h_sendfd, buffer, size);
}

static int
iflinux_generic_recv(struct lldpd_hardware *hardware, int fd, char *buffer, size_t size,
    struct sockaddr_ll *from)
{
  int n, retry = 0;
  socklen_t fromlen;

retry:
  fromlen = sizeof(*from);
  memset(from, 0, fromlen);
  if ((n = recvfrom(fd, buffer, size, 0, (struct sockaddr *)from, &fromlen)) ==
      -1) {
    if (errno == EAGAIN && retry == 0) {
      /* There may be an error queued in the socket. Clear it and
       * retry. */
      levent_recv_error(fd, hardware->h_ifname);
      retry++;
      goto retry;
    }
    if (errno == ENETDOWN) {
      log_debug("interfaces",
          "error while receiving frame on %s (network down)",
          hardware->h_ifname);
    } else {
      log_warn("interfaces",
          "error while receiving frame on %s (retry: %d)",
          hardware->h_ifname, retry);
      hardware->h_rx_discarded_cnt++;
    }
    return -1;
  }
  if (from->sll_pkttype == PACKET_OUTGOING) return -1;
  return n;
}

static int
iflinux_eth_recv(struct lldpd *cfg, struct lldpd_hardware *hardware, int fd,
    char *buffer, size_t size)
{
  int n;
  struct sockaddr_ll from;

  log_debug("interfaces", "receive PDU from ethernet device %s",
      hardware->h_ifname);
  if ((n = iflinux_generic_recv(hardware, fd, buffer, size, &from)) == -1)
    return -1;
  return n;
}

static int
iflinux_eth_close(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
  log_debug("interfaces", "close ethernet device %s", hardware->h_ifname);
  interfaces_setup_multicast(cfg, hardware->h_ifname, 1);
  return 0;
}

static struct lldpd_ops eth_ops = {
  .send = iflinux_eth_send,
  .recv = iflinux_eth_recv,
  .cleanup = iflinux_eth_close,
};

static int
iflinux_is_bridge(struct lldpd *cfg, struct interfaces_device_list *interfaces,
    struct interfaces_device *iface)
{
#ifdef ENABLE_OLDIES
  struct interfaces_device *port;
  char path[SYSFS_PATH_MAX];
  int f;

  if ((snprintf(path, SYSFS_PATH_MAX, SYSFS_CLASS_NET "%s/" SYSFS_BRIDGE_FDB,
    iface->name)) >= SYSFS_PATH_MAX)
    log_warnx("interfaces", "path truncated");
  if ((f = priv_open(path)) < 0) return 0;
  close(f);

  /* Also grab all ports */
  TAILQ_FOREACH (port, interfaces, next) {
    if (port->upper) continue;
    if (snprintf(path, SYSFS_PATH_MAX,
      SYSFS_CLASS_NET "%s/" SYSFS_BRIDGE_PORT_SUBDIR "/%s/port_no",
      iface->name, port->name) >= SYSFS_PATH_MAX)
      log_warnx("interfaces", "path truncated");
    if ((f = priv_open(path)) < 0) continue;
    log_debug("interfaces", "port %s is bridged to %s", port->name,
        iface->name);
    port->upper = iface;
    close(f);
  }

  return 1;
#else
  return 0;
#endif
}

static int
iflinux_is_vlan(struct lldpd *cfg, struct interfaces_device_list *interfaces,
    struct interfaces_device *iface)
{
#ifdef ENABLE_OLDIES
  struct vlan_ioctl_args ifv = {};
  ifv.cmd = GET_VLAN_REALDEV_NAME_CMD;
  strlcpy(ifv.device1, iface->name, sizeof(ifv.device1));
  if (ioctl(cfg->g_sock, SIOCGIFVLAN, &ifv) >= 0) {
    /* This is a VLAN, get the lower interface and the VID */
    struct interfaces_device *lower =
        interfaces_nametointerface(interfaces, ifv.u.device2);
    if (!lower) {
      log_debug("interfaces",
          "unable to find lower interface for VLAN %s", iface->name);
      return 0;
    }

    memset(&ifv, 0, sizeof(ifv));
    ifv.cmd = GET_VLAN_VID_CMD;
    strlcpy(ifv.device1, iface->name, sizeof(ifv.device1));
    if (ioctl(cfg->g_sock, SIOCGIFVLAN, &ifv) < 0) {
      log_debug("interfaces", "unable to find VID for VLAN %s",
          iface->name);
      return 0;
    }

    iface->lower = lower;
    bitmap_set(iface->vlan_bmap, ifv.u.VID);
    return 1;
  }
#endif
  return 0;
}

static int
iflinux_is_bond(struct lldpd *cfg, struct interfaces_device_list *interfaces,
    struct interfaces_device *master)
{
#ifdef ENABLE_OLDIES
  /* Shortcut if we detect the new team driver. Upper and lower links
   * should already be set with netlink in this case.  */
  if (master->driver && !strcmp(master->driver, "team")) {
    return 1;
  }

  struct ifreq ifr = {};
  struct ifbond ifb = {};
  strlcpy(ifr.ifr_name, master->name, sizeof(ifr.ifr_name));
  ifr.ifr_data = (char *)&ifb;
  if (ioctl(cfg->g_sock, SIOCBONDINFOQUERY, &ifr) >= 0) {
    while (ifb.num_slaves--) {
      struct ifslave ifs;
      memset(&ifr, 0, sizeof(ifr));
      memset(&ifs, 0, sizeof(ifs));
      strlcpy(ifr.ifr_name, master->name, sizeof(ifr.ifr_name));
      ifr.ifr_data = (char *)&ifs;
      ifs.slave_id = ifb.num_slaves;
      if (ioctl(cfg->g_sock, SIOCBONDSLAVEINFOQUERY, &ifr) >= 0) {
        struct interfaces_device *slave =
            interfaces_nametointerface(interfaces,
          ifs.slave_name);
        if (slave == NULL) continue;
        if (slave->upper) continue;
        log_debug("interfaces",
            "interface %s is enslaved to %s", slave->name,
            master->name);
        slave->upper = master;
      }
    }
    return 1;
  }
#endif
  return 0;
}

/**
 * Get permanent MAC from ethtool.
 *
 * Return 0 on success, -1 on error.
 */
static int
iflinux_get_permanent_mac_ethtool(struct lldpd *cfg,
    struct interfaces_device_list *interfaces, struct interfaces_device *iface)
{
  int ret = -1;
  struct ifreq ifr = {};
  struct ethtool_perm_addr *epaddr =
      calloc(1, sizeof(struct ethtool_perm_addr) + ETHER_ADDR_LEN);
  if (epaddr == NULL) goto end;

  strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
  epaddr->cmd = ETHTOOL_GPERMADDR;
  epaddr->size = ETHER_ADDR_LEN;
  ifr.ifr_data = (caddr_t)epaddr;
  if (ioctl(cfg->g_sock, SIOCETHTOOL, &ifr) == -1) {
    static int once = 0;
    if (errno == EPERM && !once) {
      log_warnx("interfaces",
          "no permission to get permanent MAC address for %s (requires 2.6.19+)",
          iface->name);
      once = 1;
      goto end;
    }
    if (errno != EPERM)
      log_warn("interfaces",
          "cannot get permanent MAC address for %s", iface->name);
    goto end;
  }
  if (epaddr->data[0] != 0 || epaddr->data[1] != 0 || epaddr->data[2] != 0 ||
      epaddr->data[3] != 0 || epaddr->data[4] != 0 || epaddr->data[5] != 0) {
    memcpy(iface->address, epaddr->data, ETHER_ADDR_LEN);
    ret = 0;
    goto end;
  }
  log_debug("interfaces", "cannot get permanent MAC for %s (all 0)", iface->name);
end:
  free(epaddr);
  return ret;
}

/**
 * Get permanent MAC address for a bond device.
 */
static void
iflinux_get_permanent_mac_bond(struct lldpd *cfg,
    struct interfaces_device_list *interfaces, struct interfaces_device *iface)
{
  struct interfaces_device *master = iface->upper;
  int f, state = 0;
  FILE *netbond;
  const char *slaveif = "Slave Interface: ";
  const char *hwaddr = "Permanent HW addr: ";
  u_int8_t mac[ETHER_ADDR_LEN];
  char path[SYSFS_PATH_MAX];
  char line[100];

  /* We have a bond, we need to query it to get real MAC addresses */
  if (snprintf(path, SYSFS_PATH_MAX, "/proc/net/bonding/%s", master->name) >=
      SYSFS_PATH_MAX) {
    log_warnx("interfaces", "path truncated");
    return;
  }
  if ((f = priv_open(path)) < 0) {
    if (snprintf(path, SYSFS_PATH_MAX, "/proc/self/net/bonding/%s",
      master->name) >= SYSFS_PATH_MAX) {
      log_warnx("interfaces", "path truncated");
      return;
    }
    f = priv_open(path);
  }
  if (f < 0) {
    log_warnx("interfaces", "unable to get permanent MAC address for %s",
        iface->name);
    return;
  }
  if ((netbond = fdopen(f, "r")) == NULL) {
    log_warn("interfaces", "unable to read stream from %s", path);
    close(f);
    return;
  }
  /* State 0:
     We parse the file to search "Slave Interface: ". If found, go to
     state 1.
     State 1:
     We parse the file to search "Permanent HW addr: ". If found, we get
     the mac.
  */
  while (fgets(line, sizeof(line), netbond)) {
    switch (state) {
    case 0:
      if (strncmp(line, slaveif, strlen(slaveif)) == 0) {
        if (line[strlen(line) - 1] == '\n')
          line[strlen(line) - 1] = '\0';
        if (strcmp(iface->name, line + strlen(slaveif)) == 0)
          state++;
      }
      break;
    case 1:
      if (strncmp(line, hwaddr, strlen(hwaddr)) == 0) {
        if (line[strlen(line) - 1] == '\n')
          line[strlen(line) - 1] = '\0';
        if (sscanf(line + strlen(hwaddr),
          "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
          &mac[0], &mac[1], &mac[2], &mac[3], &mac[4],
          &mac[5]) != ETHER_ADDR_LEN) {
          log_warn("interfaces", "unable to parse %s",
              line + strlen(hwaddr));
          fclose(netbond);
          return;
        }
        memcpy(iface->address, mac, ETHER_ADDR_LEN);
        fclose(netbond);
        return;
      }
      break;
    }
  }
  log_warnx("interfaces", "unable to find real MAC address for enslaved %s",
      iface->name);
  fclose(netbond);
}

/**
 * Get permanent MAC.
 */
static void
iflinux_get_permanent_mac(struct lldpd *cfg, struct interfaces_device_list *interfaces,
    struct interfaces_device *iface)
{
  struct interfaces_device *master = iface->upper;

  if (master == NULL || master->type != IFACE_BOND_T) return;
  if (iflinux_get_permanent_mac_ethtool(cfg, interfaces, iface) == -1 &&
      (master->driver == NULL || !strcmp(master->driver, "bonding")))
    /* Fallback to old method for a bond */
    iflinux_get_permanent_mac_bond(cfg, interfaces, iface);
}

#ifdef ENABLE_DOT3
#  define ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32 (SCHAR_MAX)
#  define ETHTOOL_DECLARE_LINK_MODE_MASK(name) \
    uint32_t name[ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32]

struct ethtool_link_usettings {
  struct ethtool_link_settings base;
  struct {
    ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
    ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
    ETHTOOL_DECLARE_LINK_MODE_MASK(lp_advertising);
  } link_modes;
};

static int
iflinux_ethtool_link_mode_test_bit(unsigned int nr, const uint32_t *mask)
{
  if (nr >= 32 * ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32) return 0;
  return !!(mask[nr / 32] & (1 << (nr % 32)));
}
static void
iflinux_ethtool_link_mode_unset_bit(unsigned int nr, uint32_t *mask)
{
  if (nr >= 32 * ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32) return;
  mask[nr / 32] &= ~(1 << (nr % 32));
}
static int
iflinux_ethtool_link_mode_is_empty(const uint32_t *mask)
{
  for (unsigned int i = 0; i < ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32; ++i) {
    if (mask[i] != 0) return 0;
  }

  return 1;
}

static int
iflinux_ethtool_glink(struct lldpd *cfg, const char *ifname,
    struct ethtool_link_usettings *uset)
{
  int rc;

  /* Try with ETHTOOL_GLINKSETTINGS first */
  struct {
    struct ethtool_link_settings req;
    uint32_t link_mode_data[3 * ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32];
  } ecmd;
  static int8_t nwords = 0;
  struct ifreq ifr = {};
  strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

  if (nwords == 0) {
    /* Do a handshake first. We assume that this is device-independant. */
    memset(&ecmd, 0, sizeof(ecmd));
    ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
    ifr.ifr_data = (caddr_t)&ecmd;
    rc = ioctl(cfg->g_sock, SIOCETHTOOL, &ifr);
    if (rc == 0) {
      nwords = -ecmd.req.link_mode_masks_nwords;
      log_debug("interfaces", "glinksettings nwords is %" PRId8,
          nwords);
    } else {
      static int once = 0;
      if (errno == EPERM && !once) {
        log_warnx("interfaces",
            "cannot get ethtool link information "
            "with GLINKSETTINGS (requires 4.9+). "
            "25G+ speeds may be missing in MAC/PHY TLVs");
        once = 1;
      }
      nwords = -1;
    }
  }
  if (nwords > 0) {
    memset(&ecmd, 0, sizeof(ecmd));
    ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
    ecmd.req.link_mode_masks_nwords = nwords;
    ifr.ifr_data = (caddr_t)&ecmd;
    rc = ioctl(cfg->g_sock, SIOCETHTOOL, &ifr);
    if (rc == 0) {
      log_debug("interfaces",
          "got ethtool results for %s with GLINKSETTINGS", ifname);
      memcpy(&uset->base, &ecmd.req, sizeof(uset->base));
      unsigned int u32_offs = 0;
      memcpy(uset->link_modes.supported,
          &ecmd.link_mode_data[u32_offs],
          4 * ecmd.req.link_mode_masks_nwords);
      u32_offs += ecmd.req.link_mode_masks_nwords;
      memcpy(uset->link_modes.advertising,
          &ecmd.link_mode_data[u32_offs],
          4 * ecmd.req.link_mode_masks_nwords);
      u32_offs += ecmd.req.link_mode_masks_nwords;
      memcpy(uset->link_modes.lp_advertising,
          &ecmd.link_mode_data[u32_offs],
          4 * ecmd.req.link_mode_masks_nwords);
      goto end;
    }
  }

  /* Try with ETHTOOL_GSET */
  struct ethtool_cmd ethc;
  memset(&ethc, 0, sizeof(ethc));
  ethc.cmd = ETHTOOL_GSET;
  ifr.ifr_data = (caddr_t)&ethc;
  rc = ioctl(cfg->g_sock, SIOCETHTOOL, &ifr);
  if (rc == 0) {
    /* Do a partial copy (only what we need) */
    log_debug("interfaces", "got ethtool results for %s with GSET", ifname);
    memset(uset, 0, sizeof(*uset));
    uset->base.cmd = ETHTOOL_GSET;
    uset->base.link_mode_masks_nwords = 1;
    uset->link_modes.supported[0] = ethc.supported;
    uset->link_modes.advertising[0] = ethc.advertising;
    uset->link_modes.lp_advertising[0] = ethc.lp_advertising;
    uset->base.speed = (ethc.speed_hi << 16) | ethc.speed;
    uset->base.duplex = ethc.duplex;
    uset->base.port = ethc.port;
    uset->base.autoneg = ethc.autoneg;
  } else {
    static int once = 0;
    if (errno == EPERM && !once) {
      log_warnx("interfaces",
          "cannot get ethtool link information "
          "with GSET (requires 2.6.19+). "
          "MAC/PHY TLV will be unavailable");
      once = 1;
    }
  }
end:
  return rc;
}

struct ethtool_to_mau_type {
  int ethtool_bit;
  int mau_type;
};

static int
iflinux_ethtool_to_mau_type(const struct ethtool_to_mau_type *map,
    const uint32_t *supported)
{
  for (int i = 0; map[i].ethtool_bit >= 0; i++) {
    if (iflinux_ethtool_link_mode_test_bit(
      map[i].ethtool_bit, supported))
      return map[i].mau_type;
  }
  return 0;
}

static const struct ethtool_to_mau_type ethtool_10g_to_mau[] = {
  { ETHTOOL_LINK_MODE_10000baseT_Full_BIT, LLDP_DOT3_MAU_10GBASET },
  { ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, LLDP_DOT3_MAU_10GBASEKX4 },
  { ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, LLDP_DOT3_MAU_10GBASEKR },
  { ETHTOOL_LINK_MODE_10000baseCR_Full_BIT, LLDP_DOT3_MAU_10GIGBASECX4 },
  { ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, LLDP_DOT3_MAU_10GIGBASESR },
  { ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, LLDP_DOT3_MAU_10GIGBASELR },
  { ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT, LLDP_DOT3_MAU_10GBASELRM },
  { ETHTOOL_LINK_MODE_10000baseER_Full_BIT, LLDP_DOT3_MAU_10GIGBASEER },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_25g_to_mau[] = {
  { ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, LLDP_DOT3_MAU_25GBASECR },
  { ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, LLDP_DOT3_MAU_25GBASEKR },
  { ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, LLDP_DOT3_MAU_25GBASESR },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_40g_to_mau[] = {
  { ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, LLDP_DOT3_MAU_40GBASEKR4 },
  { ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, LLDP_DOT3_MAU_40GBASECR4 },
  { ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, LLDP_DOT3_MAU_40GBASESR4 },
  { ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, LLDP_DOT3_MAU_40GBASELR4 },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_50g_to_mau[] = {
  { ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT, LLDP_DOT3_MAU_50GBASECR },
  { ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT, LLDP_DOT3_MAU_50GBASEKR },
  { ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT, LLDP_DOT3_MAU_50GBASESR },
  { ETHTOOL_LINK_MODE_50000baseKR_Full_BIT, LLDP_DOT3_MAU_50GBASEKR },
  { ETHTOOL_LINK_MODE_50000baseSR_Full_BIT, LLDP_DOT3_MAU_50GBASESR },
  { ETHTOOL_LINK_MODE_50000baseCR_Full_BIT, LLDP_DOT3_MAU_50GBASECR },
  { ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT, LLDP_DOT3_MAU_50GBASELR },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_100g_to_mau[] = {
  { ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, LLDP_DOT3_MAU_100GBASEKR4 },
  { ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, LLDP_DOT3_MAU_100GBASESR4 },
  { ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, LLDP_DOT3_MAU_100GBASECR4 },
  { ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT, LLDP_DOT3_MAU_100GBASELR4 },
  { ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT, LLDP_DOT3_MAU_100GBASEKR2 },
  { ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT, LLDP_DOT3_MAU_100GBASESR2 },
  { ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT, LLDP_DOT3_MAU_100GBASECR2 },
  { ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT, LLDP_DOT3_MAU_100GBASER },
  { ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT, LLDP_DOT3_MAU_100GBASEDR },
  { ETHTOOL_LINK_MODE_100000baseKR_Full_BIT, LLDP_DOT3_MAU_100GBASER },
  { ETHTOOL_LINK_MODE_100000baseSR_Full_BIT, LLDP_DOT3_MAU_100GBASER },
  { ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT, LLDP_DOT3_MAU_100GBASER },
  { ETHTOOL_LINK_MODE_100000baseCR_Full_BIT, LLDP_DOT3_MAU_100GBASER },
  { ETHTOOL_LINK_MODE_100000baseDR_Full_BIT, LLDP_DOT3_MAU_100GBASEDR },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_200g_to_mau[] = {
  { ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT, LLDP_DOT3_MAU_200GBASEKR4 },
  { ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT, LLDP_DOT3_MAU_200GBASESR4 },
  { ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT, LLDP_DOT3_MAU_200GBASELR4 },
  { ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT, LLDP_DOT3_MAU_200GBASEDR4 },
  { ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT, LLDP_DOT3_MAU_200GBASECR4 },
  { ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT, LLDP_DOT3_MAU_200GBASER },
  { ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT, LLDP_DOT3_MAU_200GBASER },
  { ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT, LLDP_DOT3_MAU_200GBASER },
  { ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT, LLDP_DOT3_MAU_200GBASER },
  { ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT, LLDP_DOT3_MAU_200GBASER },
  { -1, 0 }
};

static const struct ethtool_to_mau_type ethtool_400g_to_mau[] = {
  { ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT, LLDP_DOT3_MAU_400GBASELR8 },
  { ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT, LLDP_DOT3_MAU_400GBASEDR4 },
  { ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT, LLDP_DOT3_MAU_400GBASER },
  { -1, 0 }
};

/* Fill up MAC/PHY for a given hardware port */
static void
iflinux_macphy(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
  struct ethtool_link_usettings uset = {};
  struct lldpd_port *port = &hardware->h_lport;
  int j, mau;
  int advertised_ethtool_to_rfc3636[][2] = {
    { ETHTOOL_LINK_MODE_10baseT_Half_BIT, LLDP_DOT3_LINK_AUTONEG_10BASE_T },
    { ETHTOOL_LINK_MODE_10baseT_Full_BIT,
        LLDP_DOT3_LINK_AUTONEG_10BASET_FD },
    { ETHTOOL_LINK_MODE_100baseT_Half_BIT,
        LLDP_DOT3_LINK_AUTONEG_100BASE_TX },
    { ETHTOOL_LINK_MODE_100baseT_Full_BIT,
        LLDP_DOT3_LINK_AUTONEG_100BASE_TXFD },
    { ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
        LLDP_DOT3_LINK_AUTONEG_1000BASE_T },
    { ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
        LLDP_DOT3_LINK_AUTONEG_1000BASE_TFD },
    { ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
        LLDP_DOT3_LINK_AUTONEG_1000BASE_XFD },
    { ETHTOOL_LINK_MODE_Pause_BIT, LLDP_DOT3_LINK_AUTONEG_FDX_PAUSE },
    { ETHTOOL_LINK_MODE_Asym_Pause_BIT, LLDP_DOT3_LINK_AUTONEG_FDX_APAUSE },
    { -1, 0 }
  };

  log_debug("interfaces", "ask ethtool for the appropriate MAC/PHY for %s",
      hardware->h_ifname);
  if (iflinux_ethtool_glink(cfg, hardware->h_ifname, &uset) == 0) {
    port->p_macphy.autoneg_support =
        iflinux_ethtool_link_mode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
      uset.link_modes.supported);
    port->p_macphy.autoneg_enabled =
        (uset.base.autoneg == AUTONEG_DISABLE) ? 0 : 1;
    for (j = 0; advertised_ethtool_to_rfc3636[j][0] >= 0; j++) {
      if (iflinux_ethtool_link_mode_test_bit(
        advertised_ethtool_to_rfc3636[j][0],
        uset.link_modes.advertising)) {
        port->p_macphy.autoneg_advertised |=
            advertised_ethtool_to_rfc3636[j][1];
        iflinux_ethtool_link_mode_unset_bit(
            advertised_ethtool_to_rfc3636[j][0],
            uset.link_modes.advertising);
      }
    }
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_TP_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_AUI_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_MII_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_FIBRE_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_BNC_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_Pause_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
        uset.link_modes.advertising);
    iflinux_ethtool_link_mode_unset_bit(ETHTOOL_LINK_MODE_Backplane_BIT,
        uset.link_modes.advertising);
    if (!iflinux_ethtool_link_mode_is_empty(uset.link_modes.advertising)) {
      port->p_macphy.autoneg_advertised |=
          LLDP_DOT3_LINK_AUTONEG_OTHER;
    }
    switch (uset.base.speed) {
    case SPEED_10:
      port->p_macphy.mau_type = (uset.base.duplex == DUPLEX_FULL) ?
          LLDP_DOT3_MAU_10BASETFD :
          LLDP_DOT3_MAU_10BASETHD;
      if (uset.base.port == PORT_BNC)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_10BASE2;
      if (uset.base.port == PORT_FIBRE)
        port->p_macphy.mau_type =
            (uset.base.duplex == DUPLEX_FULL) ?
            LLDP_DOT3_MAU_10BASEFLFD :
            LLDP_DOT3_MAU_10BASEFLHD;
      break;
    case SPEED_100:
      port->p_macphy.mau_type = (uset.base.duplex == DUPLEX_FULL) ?
          LLDP_DOT3_MAU_100BASETXFD :
          LLDP_DOT3_MAU_100BASETXHD;
      if (uset.base.port == PORT_BNC)
        port->p_macphy.mau_type =
            (uset.base.duplex == DUPLEX_FULL) ?
            LLDP_DOT3_MAU_100BASET2FD :
            LLDP_DOT3_MAU_100BASET2HD;
      if (uset.base.port == PORT_FIBRE)
        port->p_macphy.mau_type =
            (uset.base.duplex == DUPLEX_FULL) ?
            LLDP_DOT3_MAU_100BASEFXFD :
            LLDP_DOT3_MAU_100BASEFXHD;
      break;
    case SPEED_1000:
      port->p_macphy.mau_type = (uset.base.duplex == DUPLEX_FULL) ?
          LLDP_DOT3_MAU_1000BASETFD :
          LLDP_DOT3_MAU_1000BASETHD;
      if (uset.base.port == PORT_FIBRE)
        port->p_macphy.mau_type =
            (uset.base.duplex == DUPLEX_FULL) ?
            LLDP_DOT3_MAU_1000BASEXFD :
            LLDP_DOT3_MAU_1000BASEXHD;
      break;
    case SPEED_2500:
      port->p_macphy.mau_type = LLDP_DOT3_MAU_2P5GIGT;
      break;
    case SPEED_5000:
      port->p_macphy.mau_type = LLDP_DOT3_MAU_5GIGT;
      break;
    case SPEED_10000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_10g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else if (uset.base.port == PORT_TP)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_10GBASET;
      else if (uset.base.port == PORT_FIBRE)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_10GIGBASELR;
      else if (uset.base.port == PORT_DA)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_10GIGBASECX4;
      break;
    case SPEED_25000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_25g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else if (uset.base.port == PORT_TP)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_25GBASET;
      else if (uset.base.port == PORT_FIBRE)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_25GBASELR;
      else if (uset.base.port == PORT_DA)
        port->p_macphy.mau_type = LLDP_DOT3_MAU_25GBASECR;
      break;
    case SPEED_40000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_40g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else
        port->p_macphy.mau_type =
            (uset.base.port == PORT_FIBRE) ?
            LLDP_DOT3_MAU_40GBASELR4 :
            LLDP_DOT3_MAU_40GBASECR4;
      break;
    case SPEED_50000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_50g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else
        port->p_macphy.mau_type =
            (uset.base.port == PORT_FIBRE) ?
            LLDP_DOT3_MAU_50GBASELR :
            LLDP_DOT3_MAU_50GBASECR;
      break;
    case SPEED_100000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_100g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else
        port->p_macphy.mau_type =
            (uset.base.port == PORT_FIBRE) ?
            LLDP_DOT3_MAU_100GBASELR4 :
            LLDP_DOT3_MAU_100GBASECR4;
      break;
    case SPEED_200000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_200g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else
        port->p_macphy.mau_type = LLDP_DOT3_MAU_200GBASER;
      break;
    case SPEED_400000:
      if ((mau = iflinux_ethtool_to_mau_type(
         ethtool_400g_to_mau, uset.link_modes.supported)))
        port->p_macphy.mau_type = mau;
      else
        port->p_macphy.mau_type = LLDP_DOT3_MAU_400GBASER;
      break;
    }
    if (uset.base.port == PORT_AUI)
      port->p_macphy.mau_type = LLDP_DOT3_MAU_AUI;
  }
}
#else  /* ENABLE_DOT3 */
static void
iflinux_macphy(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
}
#endif /* ENABLE_DOT3 */

#ifdef ENABLE_OLDIES
struct bond_master {
  char name[IFNAMSIZ];
  int index;
};

static int
iface_bond_init(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
  struct bond_master *master = hardware->h_data;
  int fd;
  int un = 1;

  if (!master) return -1;

  log_debug("interfaces", "initialize enslaved device %s", hardware->h_ifname);

  /* First, we get a socket to the raw physical interface */
  if ((fd = priv_iface_init(hardware->h_ifindex, hardware->h_ifname)) == -1)
    return -1;
  hardware->h_sendfd = fd;
  interfaces_setup_multicast(cfg, hardware->h_ifname, 0);

  /* Then, we open a raw interface for the master */
  log_debug("interfaces", "enslaved device %s has master %s(%d)",
      hardware->h_ifname, master->name, master->index);
  if ((fd = priv_iface_init(master->index, master->name)) == -1) {
    close(hardware->h_sendfd);
    return -1;
  }
  /* With bonding and older kernels (< 2.6.27) we need to listen
   * to bond device. We use setsockopt() PACKET_ORIGDEV to get
   * physical device instead of bond device (works with >=
   * 2.6.24). */
  if (setsockopt(fd, SOL_PACKET, PACKET_ORIGDEV, &un, sizeof(un)) == -1) {
    log_info("interfaces",
        "unable to setsockopt for master bonding device of %s. "
        "You will get inaccurate results",
        hardware->h_ifname);
  }
  interfaces_setup_multicast(cfg, master->name, 0);

  levent_hardware_add_fd(hardware, hardware->h_sendfd);
  levent_hardware_add_fd(hardware, fd);
  log_debug("interfaces", "interface %s initialized (fd=%d,master=%s[%d])",
      hardware->h_ifname, hardware->h_sendfd, master->name, fd);
  return 0;
}

static int
iface_bond_recv(struct lldpd *cfg, struct lldpd_hardware *hardware, int fd,
    char *buffer, size_t size)
{
  int n;
  struct sockaddr_ll from;
  struct bond_master *master = hardware->h_data;

  log_debug("interfaces", "receive PDU from enslaved device %s",
      hardware->h_ifname);
  if ((n = iflinux_generic_recv(hardware, fd, buffer, size, &from)) == -1)
    return -1;
  if (fd == hardware->h_sendfd) /* We received this on the physical interface. */
    return n;
  /* We received this on the bonding interface. Is it really for us? */
  if (from.sll_ifindex == hardware->h_ifindex) /* This is for us */
    return n;
  if (from.sll_ifindex == master->index)
    /* We don't know from which physical interface it comes (kernel
     * < 2.6.24). In doubt, this is for us. */
    return n;
  return -1; /* Not for us */
}

static int
iface_bond_close(struct lldpd *cfg, struct lldpd_hardware *hardware)
{
  struct bond_master *master = hardware->h_data;
  log_debug("interfaces", "closing enslaved device %s", hardware->h_ifname);
  interfaces_setup_multicast(cfg, hardware->h_ifname, 1);
  interfaces_setup_multicast(cfg, master->name, 1);
  free(hardware->h_data);
  hardware->h_data = NULL;
  return 0;
}

struct lldpd_ops bond_ops = {
  .send = iflinux_eth_send,
  .recv = iface_bond_recv,
  .cleanup = iface_bond_close,
};

static void
iflinux_handle_bond(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;
  struct interfaces_device *master;
  struct lldpd_hardware *hardware;
  struct bond_master *bmaster;
  int created;
  TAILQ_FOREACH (iface, interfaces, next) {
    if (!(iface->type & IFACE_PHYSICAL_T)) continue;
    if (iface->ignore) continue;
    if (!iface->upper || !(iface->upper->type & IFACE_BOND_T)) continue;

    master = iface->upper;
    log_debug("interfaces",
        "%s is an acceptable enslaved device (master=%s)", iface->name,
        master->name);
    created = 0;
    if ((hardware = lldpd_get_hardware(cfg, iface->name, iface->index)) ==
        NULL) {
      if ((hardware = lldpd_alloc_hardware(cfg, iface->name,
         iface->index)) == NULL) {
        log_warnx("interfaces",
            "Unable to allocate space for %s", iface->name);
        continue;
      }
      created = 1;
    }
    if (hardware->h_flags) continue;
    if (hardware->h_ops != &bond_ops || hardware->h_ifindex_changed) {
      if (!created) {
        log_debug("interfaces",
            "bond %s is converted from another type of interface",
            hardware->h_ifname);
        if (hardware->h_ops && hardware->h_ops->cleanup)
          hardware->h_ops->cleanup(cfg, hardware);
        levent_hardware_release(hardware);
        levent_hardware_init(hardware);
      }
      bmaster = hardware->h_data =
          calloc(1, sizeof(struct bond_master));
      if (!bmaster) {
        log_warn("interfaces", "not enough memory");
        lldpd_hardware_cleanup(cfg, hardware);
        continue;
      }
    } else
      bmaster = hardware->h_data;
    bmaster->index = master->index;
    strlcpy(bmaster->name, master->name, IFNAMSIZ);
    if (hardware->h_ops != &bond_ops || hardware->h_ifindex_changed) {
      if (iface_bond_init(cfg, hardware) != 0) {
        log_warn("interfaces", "unable to initialize %s",
            hardware->h_ifname);
        lldpd_hardware_cleanup(cfg, hardware);
        continue;
      }
      hardware->h_ops = &bond_ops;
      hardware->h_mangle = 1;
    }
    if (created)
      interfaces_helper_add_hardware(cfg, hardware);
    else
      lldpd_port_cleanup(&hardware->h_lport, 0);

    hardware->h_flags = iface->flags;
    iface->ignore = 1;

    /* Get local address */
    memcpy(&hardware->h_lladdr, iface->address, ETHER_ADDR_LEN);

    /* Fill information about port */
    interfaces_helper_port_name_desc(cfg, hardware, iface);

    /* Fill additional info */
#  ifdef ENABLE_DOT3
    hardware->h_lport.p_aggregid = master->index;
#  endif
    hardware->h_mtu = iface->mtu ? iface->mtu : 1500;
  }
}
#endif

/* Query each interface to get the appropriate driver */
static void
iflinux_add_driver(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;
  TAILQ_FOREACH (iface, interfaces, next) {
    struct ethtool_drvinfo ethc = { .cmd = ETHTOOL_GDRVINFO };
    struct ifreq ifr = { .ifr_data = (caddr_t)&ethc };
    if (iface->driver) continue;

    strlcpy(ifr.ifr_name, iface->name, IFNAMSIZ);
    if (ioctl(cfg->g_sock, SIOCETHTOOL, &ifr) == 0) {
      iface->driver = strdup(ethc.driver);
      log_debug("interfaces", "driver for %s is `%s`", iface->name,
          iface->driver);
    }
  }
}

/* Query each interface to see if it is a wireless one */
static void
iflinux_add_wireless(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;
  TAILQ_FOREACH (iface, interfaces, next) {
    if (iface->type &
        (IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T | IFACE_WIRELESS_T))
      continue;
    char path[IFNAMSIZ + sizeof(SYSFS_CLASS_NET) + sizeof("/wireless")];
    snprintf(path, sizeof(path), SYSFS_CLASS_NET "%s/wireless",
        iface->name);
    if (priv_exist(path) == 0) {
      log_debug("interfaces", "%s is wireless", iface->name);
      iface->type |= IFACE_WIRELESS_T | IFACE_PHYSICAL_T;
    }
  }
}

/* Query each interface to see if it is a bridge */
static void
iflinux_add_bridge(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;

  TAILQ_FOREACH (iface, interfaces, next) {
    if (iface->type &
        (IFACE_PHYSICAL_T | IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T))
      continue;
    if (iflinux_is_bridge(cfg, interfaces, iface)) {
      log_debug("interfaces", "interface %s is a bridge",
          iface->name);
      iface->type |= IFACE_BRIDGE_T;
    }
  }
}

/* Query each interface to see if it is a bond */
static void
iflinux_add_bond(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;

  TAILQ_FOREACH (iface, interfaces, next) {
    if (iface->type &
        (IFACE_PHYSICAL_T | IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T))
      continue;
    if (iflinux_is_bond(cfg, interfaces, iface)) {
      log_debug("interfaces", "interface %s is a bond", iface->name);
      iface->type |= IFACE_BOND_T;
    }
  }
}

/* Query each interface to see if it is a vlan */
static void
iflinux_add_vlan(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;

  TAILQ_FOREACH (iface, interfaces, next) {
    if (iface->type &
        (IFACE_PHYSICAL_T | IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T))
      continue;
    if (iflinux_is_vlan(cfg, interfaces, iface)) {
      log_debug("interfaces", "interface %s is a VLAN", iface->name);
      iface->type |= IFACE_VLAN_T;
    }
  }
}

static void
iflinux_add_physical(struct lldpd *cfg, struct interfaces_device_list *interfaces)
{
  struct interfaces_device *iface;
  /* Deny some drivers */
  const char *const *rif;
  const char *const denied_drivers[] = { "cdc_mbim", "vxlan", NULL };

  TAILQ_FOREACH (iface, interfaces, next) {
    if (iface->type & (IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T))
      continue;

    iface->type &= ~IFACE_PHYSICAL_T;

    /* We request that the interface is able to do either multicast
     * or broadcast to be able to send discovery frames. */
    if (!(iface->flags & (IFF_MULTICAST | IFF_BROADCAST))) {
      log_debug("interfaces",
          "skip %s: not able to do multicast nor broadcast",
          iface->name);
      continue;
    }

    /* Check if the driver is not denied */
    if (iface->driver) {
      int skip = 0;
      for (rif = denied_drivers; *rif; rif++) {
        if (strcmp(iface->driver, *rif) == 0) {
          log_debug("interfaces",
              "skip %s: denied driver", iface->name);
          skip = 1;
          break;
        }
      }
      if (skip) continue;
    }

    /* If the interface is linked to another one, skip it too. */
    if (iface->lower &&
        (!iface->driver ||
      (strcmp(iface->driver, "veth") &&
          strcmp(iface->driver, "dsa")))) {
      log_debug("interfaces",
          "skip %s: there is a lower interface (%s)", iface->name,
          iface->lower->name);
      continue;
    }

    /* Get the real MAC address (for example, if the interface is enslaved)
     */
    iflinux_get_permanent_mac(cfg, interfaces, iface);

    log_debug("interfaces", "%s is a physical interface", iface->name);
    iface->type |= IFACE_PHYSICAL_T;
  }
}

void
interfaces_update(struct lldpd *cfg)
{
  struct lldpd_hardware *hardware;
  struct interfaces_device_list *interfaces;
  struct interfaces_address_list *addresses;
  interfaces = netlink_get_interfaces(cfg);
  addresses = netlink_get_addresses(cfg);
  if (interfaces == NULL || addresses == NULL) {
    log_warnx("interfaces", "cannot update the list of local interfaces");
    return;
  }

  /* Add missing bits to list of interfaces */
  iflinux_add_driver(cfg, interfaces);
  if (LOCAL_CHASSIS(cfg)->c_cap_available & LLDP_CAP_WLAN)
    iflinux_add_wireless(cfg, interfaces);
  if (LOCAL_CHASSIS(cfg)->c_cap_available & LLDP_CAP_BRIDGE)
    iflinux_add_bridge(cfg, interfaces);
  iflinux_add_bond(cfg, interfaces);
  iflinux_add_vlan(cfg, interfaces);
  iflinux_add_physical(cfg, interfaces);

  interfaces_helper_allowlist(cfg, interfaces);
#ifdef ENABLE_OLDIES
  iflinux_handle_bond(cfg, interfaces);
#endif
  interfaces_helper_physical(cfg, interfaces, &eth_ops, iflinux_eth_init);
#ifdef ENABLE_DOT1
  interfaces_helper_vlan(cfg, interfaces);
#endif
  interfaces_helper_mgmt(cfg, addresses, interfaces);
  interfaces_helper_chassis(cfg, interfaces);

  /* Mac/PHY */
  TAILQ_FOREACH (hardware, &cfg->g_hardware, h_entries) {
    if (!(hardware->h_flags & IFF_RUNNING)) continue;
    iflinux_macphy(cfg, hardware);
    interfaces_helper_promisc(cfg, hardware);
  }
}

void
interfaces_cleanup(struct lldpd *cfg)
{
  netlink_cleanup(cfg);
}

Coverage Report

Created: 2026-05-30 06:38