Adding upstream version 1.0.18.upstream/1.0.18upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 641 insertions, 0 deletions

diff --git a/src/daemon/interfaces-bsd.c b/src/daemon/interfaces-bsd.c
new file mode 100644
index 0000000..a8248fe
--- /dev/null
+++ b/src/daemon/interfaces-bsd.c
@@ -0,0 +1,641 @@
+/* -*- mode: c; c-file-style: "openbsd" -*- */
+/*
+ * Copyright (c) 2012 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 <unistd.h>
+#include <ifaddrs.h>
+#include <errno.h>
+#include <ctype.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <net/bpf.h>
+#include <net/if_types.h>
+#include <net/if_media.h>
+#include <net/if_dl.h>
+#if defined HOST_OS_FREEBSD
+#  include <net/if_vlan_var.h>
+#  include <net/if_bridgevar.h>
+#  include <net/if_lagg.h>
+#elif defined HOST_OS_DRAGONFLY
+#  include <net/vlan/if_vlan_var.h>
+#  include <net/bridge/if_bridgevar.h>
+#elif defined HOST_OS_OPENBSD
+#  include <net/if_vlan_var.h>
+#  include <net/if_bridge.h>
+#  include <net/if_trunk.h>
+#elif defined HOST_OS_NETBSD
+#  include <net/if_vlanvar.h>
+#  include <net/if_bridgevar.h>
+#  include <net/agr/if_agrioctl.h>
+#elif defined HOST_OS_OSX
+#  include <osx/if_vlan_var.h>
+#  include <osx/if_bridgevar.h>
+#  include <osx/if_bond_var.h>
+#endif
+
+#ifndef IFDESCRSIZE
+#  define IFDESCRSIZE 64
+#endif
+
+static int
+ifbsd_check_wireless(struct lldpd *cfg, struct ifaddrs *ifaddr,
+    struct interfaces_device *iface)
+{
+	struct ifmediareq ifmr = {};
+	strlcpy(ifmr.ifm_name, iface->name, sizeof(ifmr.ifm_name));
+	if (ioctl(cfg->g_sock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0 ||
+	    IFM_TYPE(ifmr.ifm_current) != IFM_IEEE80211)
+		return 0; /* Not wireless either */
+	iface->type |= IFACE_WIRELESS_T | IFACE_PHYSICAL_T;
+	return 0;
+}
+
+static void
+ifbsd_check_bridge(struct lldpd *cfg, struct interfaces_device_list *interfaces,
+    struct interfaces_device *master)
+{
+	static size_t ifbic_len = 64;
+	struct ifbreq *req = NULL;
+	struct ifbifconf bifc = {};
+
+retry_alloc:
+	if ((req = realloc(req, ifbic_len)) == NULL) {
+		log_warn("interfaces", "unable to allocate memory to query bridge %s",
+		    master->name);
+		free(bifc.ifbic_req);
+		return;
+	}
+	bifc.ifbic_len = ifbic_len;
+	bifc.ifbic_req = req;
+
+#if defined HOST_OS_FREEBSD || defined HOST_OS_NETBSD || defined HOST_OS_OSX || \
+    defined HOST_OS_DRAGONFLY
+	struct ifdrv ifd = { .ifd_cmd = BRDGGIFS,
+		.ifd_len = sizeof(bifc),
+		.ifd_data = &bifc };
+
+	strlcpy(ifd.ifd_name, master->name, sizeof(ifd.ifd_name));
+	if (ioctl(cfg->g_sock, SIOCGDRVSPEC, (caddr_t)&ifd) < 0) {
+		log_debug("interfaces", "%s is not a bridge", master->name);
+		return;
+	}
+#elif defined HOST_OS_OPENBSD
+	strlcpy(bifc.ifbic_name, master->name, sizeof(bifc.ifbic_name));
+	if (ioctl(cfg->g_sock, SIOCBRDGIFS, (caddr_t)&bifc) < 0) {
+		log_debug("interfaces", "%s is not a bridge", master->name);
+		return;
+	}
+#else
+#  error Unsupported OS
+#endif
+	if (bifc.ifbic_len >= ifbic_len) {
+		ifbic_len = bifc.ifbic_len + 1;
+		goto retry_alloc;
+	}
+	for (int i = 0; i < bifc.ifbic_len / sizeof(*req); i++) {
+		struct interfaces_device *slave =
+		    interfaces_nametointerface(interfaces, req[i].ifbr_ifsname);
+		if (slave == NULL) {
+			log_warnx("interfaces",
+			    "%s should be bridged to %s but we don't know %s",
+			    req[i].ifbr_ifsname, master->name, req[i].ifbr_ifsname);
+			continue;
+		}
+		log_debug("interfaces", "%s is bridged to %s", slave->name,
+		    master->name);
+		slave->upper = master;
+	}
+	master->type |= IFACE_BRIDGE_T;
+}
+
+static void
+ifbsd_check_bond(struct lldpd *cfg, struct interfaces_device_list *interfaces,
+    struct interfaces_device *master)
+{
+#if defined HOST_OS_OPENBSD
+/* OpenBSD is the same as FreeBSD, just lagg->trunk */
+#  define lagg_reqport trunk_reqport
+#  define lagg_reqall trunk_reqall
+#  define SIOCGLAGG SIOCGTRUNK
+#  define LAGG_MAX_PORTS TRUNK_MAX_PORTS
+#endif
+#if defined HOST_OS_OPENBSD || defined HOST_OS_FREEBSD
+	struct lagg_reqport rpbuf[LAGG_MAX_PORTS];
+	struct lagg_reqall ra = { .ra_size = sizeof(rpbuf), .ra_port = rpbuf };
+	strlcpy(ra.ra_ifname, master->name, IFNAMSIZ);
+	if (ioctl(cfg->g_sock, SIOCGLAGG, (caddr_t)&ra) < 0) {
+		log_debug("interfaces", "%s is not a bond", master->name);
+		return;
+	}
+
+	for (int i = 0; i < ra.ra_ports; i++) {
+		struct interfaces_device *slave;
+		slave = interfaces_nametointerface(interfaces, rpbuf[i].rp_portname);
+		if (slave == NULL) {
+			log_warnx("interfaces",
+			    "%s should be enslaved to %s but we don't know %s",
+			    rpbuf[i].rp_portname, master->name, rpbuf[i].rp_portname);
+			continue;
+		}
+		log_debug("interfaces", "%s is enslaved to bond %s", slave->name,
+		    master->name);
+		slave->upper = master;
+	}
+	master->type |= IFACE_BOND_T;
+#elif defined HOST_OS_NETBSD
+	/* No max, we consider a maximum of 24 ports */
+	char buf[sizeof(struct agrportinfo) * 24] = {};
+	size_t buflen = sizeof(buf);
+	struct agrreq ar = { .ar_version = AGRREQ_VERSION,
+		.ar_cmd = AGRCMD_PORTLIST,
+		.ar_buf = buf,
+		.ar_buflen = buflen };
+	struct ifreq ifr = { .ifr_data = &ar };
+	struct agrportlist *apl = (void *)buf;
+	struct agrportinfo *api = (void *)(apl + 1);
+	strlcpy(ifr.ifr_name, master->name, sizeof(ifr.ifr_name));
+	if (ioctl(cfg->g_sock, SIOCGETAGR, &ifr) == -1) {
+		if (errno == E2BIG) {
+			log_warnx("interfaces",
+			    "%s is a too big aggregate. Please, report the problem",
+			    master->name);
+		} else {
+			log_debug("interfaces", "%s is not an aggregate", master->name);
+		}
+		return;
+	}
+	for (int i = 0; i < apl->apl_nports; i++, api++) {
+		struct interfaces_device *slave;
+		slave = interfaces_nametointerface(interfaces, api->api_ifname);
+		if (slave == NULL) {
+			log_warnx("interfaces",
+			    "%s should be enslaved to %s but we don't know %s",
+			    api->api_ifname, master->name, api->api_ifname);
+			continue;
+		}
+		log_debug("interfaces", "%s is enslaved to bond %s", slave->name,
+		    master->name);
+		slave->upper = master;
+	}
+	master->type |= IFACE_BOND_T;
+#elif defined HOST_OS_OSX
+	struct if_bond_req ibr = { .ibr_op = IF_BOND_OP_GET_STATUS,
+		.ibr_ibru = {
+		    .ibru_status = { .ibsr_version = IF_BOND_STATUS_REQ_VERSION } } };
+	struct ifreq ifr = { .ifr_data = (caddr_t)&ibr };
+	strlcpy(ifr.ifr_name, master->name, sizeof(ifr.ifr_name));
+	if (ioctl(cfg->g_sock, SIOCGIFBOND, (caddr_t)&ifr) < 0) {
+		log_debug("interfaces", "%s is not an aggregate", master->name);
+		return;
+	}
+	master->type |= IFACE_BOND_T;
+	if (ibr.ibr_ibru.ibru_status.ibsr_total == 0) {
+		log_debug("interfaces", "no members for bond %s", master->name);
+		return;
+	}
+
+	struct if_bond_status_req *ibsr_p = &ibr.ibr_ibru.ibru_status;
+	ibsr_p->ibsr_buffer =
+	    malloc(sizeof(struct if_bond_status) * ibsr_p->ibsr_total);
+	if (ibsr_p->ibsr_buffer == NULL) {
+		log_warnx("interfaces", "not enough memory to check bond members");
+		return;
+	}
+	ibsr_p->ibsr_count = ibsr_p->ibsr_total;
+	if (ioctl(cfg->g_sock, SIOCGIFBOND, (caddr_t)&ifr) < 0) {
+		log_warn("interfaces", "unable to get members for bond %s",
+		    master->name);
+		goto end;
+	}
+
+	struct if_bond_status *ibs_p = (struct if_bond_status *)ibsr_p->ibsr_buffer;
+	for (int i = 0; i < ibsr_p->ibsr_total; i++, ibs_p++) {
+		struct interfaces_device *slave;
+		slave = interfaces_nametointerface(interfaces, ibs_p->ibs_if_name);
+		if (slave == NULL) {
+			log_warnx("interfaces",
+			    "%s should be enslaved to %s but we don't know %s",
+			    ibs_p->ibs_if_name, master->name, ibs_p->ibs_if_name);
+			continue;
+		}
+		log_debug("interfaces", "%s is enslaved to bond %s", slave->name,
+		    master->name);
+		slave->upper = master;
+	}
+end:
+	free(ibsr_p->ibsr_buffer);
+#elif defined HOST_OS_DRAGONFLY
+	log_debug("interfaces", "DragonFly BSD does not support link aggregation");
+#else
+#  error Unsupported OS
+#endif
+}
+
+static void
+ifbsd_check_vlan(struct lldpd *cfg, struct interfaces_device_list *interfaces,
+    struct interfaces_device *vlan)
+{
+	struct interfaces_device *lower;
+	struct vlanreq vreq = {};
+	struct ifreq ifr = { .ifr_data = (caddr_t)&vreq };
+	strlcpy(ifr.ifr_name, vlan->name, sizeof(ifr.ifr_name));
+	if (ioctl(cfg->g_sock, SIOCGETVLAN, (caddr_t)&ifr) < 0) {
+		log_debug("interfaces", "%s is not a VLAN", vlan->name);
+		return;
+	}
+	if (strlen(vreq.vlr_parent) == 0) {
+		log_debug("interfaces", "%s is a VLAN but has no lower interface",
+		    vlan->name);
+		vlan->lower = NULL;
+		vlan->type |= IFACE_VLAN_T;
+		return;
+	}
+	lower = interfaces_nametointerface(interfaces, vreq.vlr_parent);
+	if (lower == NULL) {
+		log_warnx("interfaces",
+		    "%s should be a VLAN of %s but %s does not exist", vlan->name,
+		    vreq.vlr_parent, vreq.vlr_parent);
+		return;
+	}
+	log_debug("interfaces", "%s is VLAN %d of %s", vlan->name, vreq.vlr_tag,
+	    lower->name);
+	vlan->lower = lower;
+	bitmap_set(vlan->vlan_bmap, vreq.vlr_tag);
+	vlan->type |= IFACE_VLAN_T;
+}
+
+static void
+ifbsd_check_physical(struct lldpd *cfg, struct interfaces_device_list *interfaces,
+    struct interfaces_device *iface)
+{
+	if (iface->type &
+	    (IFACE_VLAN_T | IFACE_BOND_T | IFACE_BRIDGE_T | IFACE_PHYSICAL_T))
+		return;
+
+	if (!(iface->flags & (IFF_MULTICAST | IFF_BROADCAST))) {
+		log_debug("interfaces",
+		    "skip %s: not able to do multicast nor broadcast", iface->name);
+		return;
+	}
+	log_debug("interfaces", "%s is a physical interface", iface->name);
+	iface->type |= IFACE_PHYSICAL_T;
+}
+
+/* Remove any dangerous interface. Currently, only p2p0 is removed as it
+ * triggers some AirDrop functionality when we send something on it.
+ *  See: https://github.com/lldpd/lldpd/issues/61
+ */
+static void
+ifbsd_denylist(struct lldpd *cfg, struct interfaces_device_list *interfaces)
+{
+#ifdef HOST_OS_OSX
+	struct interfaces_device *iface = NULL;
+	TAILQ_FOREACH (iface, interfaces, next) {
+		int i;
+		if (strncmp(iface->name, "p2p", 3)) continue;
+		if (strlen(iface->name) < 4) continue;
+		for (i = 3;
+		     iface->name[i] != '\0' && isdigit((unsigned char)(iface->name[i]));
+		     i++)
+			;
+		if (iface->name[i] == '\0') {
+			log_debug("interfaces", "skip %s: AirDrop interface",
+			    iface->name);
+			iface->ignore = 1;
+		}
+	}
+#endif
+}
+
+static struct interfaces_device *
+ifbsd_extract_device(struct lldpd *cfg, struct ifaddrs *ifaddr)
+{
+	struct interfaces_device *iface = NULL;
+	struct sockaddr_dl *saddrdl =
+	    ALIGNED_CAST(struct sockaddr_dl *, ifaddr->ifa_addr);
+	if ((saddrdl->sdl_type != IFT_BRIDGE) && (saddrdl->sdl_type != IFT_L2VLAN) &&
+	    (saddrdl->sdl_type != IFT_ETHER)) {
+		log_debug("interfaces", "skip %s: not an ethernet device (%d)",
+		    ifaddr->ifa_name, saddrdl->sdl_type);
+		return NULL;
+	}
+	if ((iface = calloc(1, sizeof(struct interfaces_device))) == NULL) {
+		log_warn("interfaces", "unable to allocate memory for %s",
+		    ifaddr->ifa_name);
+		return NULL;
+	}
+
+	iface->index = saddrdl->sdl_index;
+	iface->name = strdup(ifaddr->ifa_name);
+	iface->flags = ifaddr->ifa_flags;
+
+	/* MAC address */
+	iface->address = malloc(ETHER_ADDR_LEN);
+	if (iface->address) memcpy(iface->address, LLADDR(saddrdl), ETHER_ADDR_LEN);
+
+		/* Grab description */
+#ifdef SIOCGIFDESCR
+#  if defined HOST_OS_FREEBSD || defined HOST_OS_OPENBSD
+	iface->alias = malloc(IFDESCRSIZE);
+	if (iface->alias) {
+#    if defined HOST_OS_FREEBSD
+		struct ifreq ifr = { .ifr_buffer = { .buffer = iface->alias,
+					 .length = IFDESCRSIZE } };
+#    else
+		struct ifreq ifr = { .ifr_data = (caddr_t)iface->alias };
+#    endif
+		strlcpy(ifr.ifr_name, ifaddr->ifa_name, sizeof(ifr.ifr_name));
+		if (ioctl(cfg->g_sock, SIOCGIFDESCR, (caddr_t)&ifr) < 0) {
+			free(iface->alias);
+			iface->alias = NULL;
+		}
+	}
+#  endif
+#endif /* SIOCGIFDESCR */
+
+	if (ifbsd_check_wireless(cfg, ifaddr, iface) == -1) {
+		interfaces_free_device(iface);
+		return NULL;
+	}
+
+	return iface;
+}
+
+static void
+ifbsd_extract(struct lldpd *cfg, struct interfaces_device_list *interfaces,
+    struct interfaces_address_list *addresses, struct ifaddrs *ifaddr)
+{
+	struct interfaces_address *address = NULL;
+	struct interfaces_device *device = NULL;
+	if (!ifaddr->ifa_name) return;
+	if (!ifaddr->ifa_addr) return;
+	switch (ifaddr->ifa_addr->sa_family) {
+	case AF_LINK:
+		log_debug("interfaces", "grabbing information on interface %s",
+		    ifaddr->ifa_name);
+		device = ifbsd_extract_device(cfg, ifaddr);
+		if (device) {
+#if defined HOST_OS_OPENBSD
+			/* On OpenBSD, the interface can have IFF_RUNNING but be down.
+			 */
+			struct if_data *ifdata;
+			ifdata = ifaddr->ifa_data;
+			if (!LINK_STATE_IS_UP(ifdata->ifi_link_state))
+				device->flags &= ~IFF_RUNNING;
+#endif
+			TAILQ_INSERT_TAIL(interfaces, device, next);
+		}
+		break;
+	case AF_INET:
+	case AF_INET6:
+		log_debug("interfaces", "got an IP address on %s", ifaddr->ifa_name);
+		address = malloc(sizeof(struct interfaces_address));
+		if (address == NULL) {
+			log_warn("interfaces",
+			    "not enough memory for a new IP address on %s",
+			    ifaddr->ifa_name);
+			return;
+		}
+		address->flags = ifaddr->ifa_flags;
+		address->index = if_nametoindex(ifaddr->ifa_name);
+		memcpy(&address->address, ifaddr->ifa_addr,
+		    (ifaddr->ifa_addr->sa_family == AF_INET) ?
+			sizeof(struct sockaddr_in) :
+			sizeof(struct sockaddr_in6));
+		TAILQ_INSERT_TAIL(addresses, address, next);
+		break;
+	default:
+		log_debug("interfaces", "unhandled family %d for interface %s",
+		    ifaddr->ifa_addr->sa_family, ifaddr->ifa_name);
+	}
+}
+
+static void
+ifbsd_macphy(struct lldpd *cfg, struct lldpd_hardware *hardware)
+{
+#ifdef ENABLE_DOT3
+	struct ifmediareq ifmr = {};
+#  ifdef HAVE_TYPEOF
+	typeof(ifmr.ifm_ulist[0]) media_list[32] = {};
+#  else
+	int media_list[32] = {};
+#  endif
+	ifmr.ifm_ulist = media_list;
+	ifmr.ifm_count = 32;
+	struct lldpd_port *port = &hardware->h_lport;
+	unsigned int duplex;
+	unsigned int media;
+	int advertised_ifmedia_to_rfc3636[][3] = {
+		{ IFM_10_T, LLDP_DOT3_LINK_AUTONEG_10BASE_T,
+		    LLDP_DOT3_LINK_AUTONEG_10BASET_FD },
+		{ IFM_10_STP, LLDP_DOT3_LINK_AUTONEG_10BASE_T,
+		    LLDP_DOT3_LINK_AUTONEG_10BASET_FD },
+		{ IFM_100_TX, LLDP_DOT3_LINK_AUTONEG_100BASE_TX,
+		    LLDP_DOT3_LINK_AUTONEG_100BASE_TXFD },
+		{ IFM_100_T4, LLDP_DOT3_LINK_AUTONEG_100BASE_T4,
+		    LLDP_DOT3_LINK_AUTONEG_100BASE_T4 },
+		{ IFM_100_T2, LLDP_DOT3_LINK_AUTONEG_100BASE_T2,
+		    LLDP_DOT3_LINK_AUTONEG_100BASE_T2FD },
+		{ IFM_1000_SX, LLDP_DOT3_LINK_AUTONEG_1000BASE_X,
+		    LLDP_DOT3_LINK_AUTONEG_1000BASE_XFD },
+		{ IFM_1000_LX, LLDP_DOT3_LINK_AUTONEG_1000BASE_X,
+		    LLDP_DOT3_LINK_AUTONEG_1000BASE_XFD },
+		{ IFM_1000_CX, LLDP_DOT3_LINK_AUTONEG_1000BASE_X,
+		    LLDP_DOT3_LINK_AUTONEG_1000BASE_XFD },
+		{ IFM_1000_T, LLDP_DOT3_LINK_AUTONEG_1000BASE_T,
+		    LLDP_DOT3_LINK_AUTONEG_1000BASE_TFD },
+		{ 0, 0, 0 }
+	};
+	int current_ifmedia_to_rfc3636[][3] = { { IFM_10_T, LLDP_DOT3_MAU_10BASETHD,
+						    LLDP_DOT3_MAU_10BASETFD },
+		{ IFM_10_STP, LLDP_DOT3_MAU_10BASETHD, LLDP_DOT3_MAU_10BASETFD },
+		{ IFM_10_2, LLDP_DOT3_MAU_10BASE2, LLDP_DOT3_MAU_10BASE2 },
+		{ IFM_10_5, LLDP_DOT3_MAU_10BASE5, LLDP_DOT3_MAU_10BASE5 },
+		{ IFM_100_TX, LLDP_DOT3_MAU_100BASETXHD, LLDP_DOT3_MAU_100BASETXFD },
+		{ IFM_100_FX, LLDP_DOT3_MAU_100BASEFXHD, LLDP_DOT3_MAU_100BASEFXFD },
+		{ IFM_100_T2, LLDP_DOT3_MAU_100BASET2HD, LLDP_DOT3_MAU_100BASET2FD },
+		{ IFM_1000_SX, LLDP_DOT3_MAU_1000BASESXHD, LLDP_DOT3_MAU_1000BASESXFD },
+		{ IFM_10_FL, LLDP_DOT3_MAU_10BASEFLHD, LLDP_DOT3_MAU_10BASEFLFD },
+		{ IFM_1000_LX, LLDP_DOT3_MAU_1000BASELXHD, LLDP_DOT3_MAU_1000BASELXFD },
+		{ IFM_1000_CX, LLDP_DOT3_MAU_1000BASECXHD, LLDP_DOT3_MAU_1000BASECXFD },
+		{ IFM_1000_T, LLDP_DOT3_MAU_1000BASETHD, LLDP_DOT3_MAU_1000BASETFD },
+		{ IFM_10G_LR, LLDP_DOT3_MAU_10GIGBASELR, LLDP_DOT3_MAU_10GIGBASELR },
+		{ IFM_10G_SR, LLDP_DOT3_MAU_10GIGBASESR, LLDP_DOT3_MAU_10GIGBASESR },
+		{ IFM_10G_CX4, LLDP_DOT3_MAU_10GIGBASELX4, LLDP_DOT3_MAU_10GIGBASELX4 },
+#  ifdef IFM_10G_T
+		{ IFM_10G_T, LLDP_DOT3_MAU_10GIGBASECX4, LLDP_DOT3_MAU_10GIGBASECX4 },
+#  endif
+#  ifdef IFM_10G_TWINAX
+		{ IFM_10G_TWINAX, LLDP_DOT3_MAU_10GIGBASECX4,
+		    LLDP_DOT3_MAU_10GIGBASECX4 },
+#  endif
+#  ifdef IFM_10G_TWINAX_LONG
+		{ IFM_10G_TWINAX_LONG, LLDP_DOT3_MAU_10GIGBASECX4,
+		    LLDP_DOT3_MAU_10GIGBASECX4 },
+#  endif
+#  ifdef IFM_10G_LRM
+		{ IFM_10G_LRM, LLDP_DOT3_MAU_10GIGBASELR, LLDP_DOT3_MAU_10GIGBASELR },
+#  endif
+#  ifdef IFM_10G_SFP_CU
+		{ IFM_10G_SFP_CU, LLDP_DOT3_MAU_10GIGBASECX4,
+		    LLDP_DOT3_MAU_10GIGBASECX4 },
+#  endif
+		{ 0, 0, 0 } };
+
+	log_debug("interfaces", "get MAC/phy for %s", hardware->h_ifname);
+	strlcpy(ifmr.ifm_name, hardware->h_ifname, sizeof(ifmr.ifm_name));
+	if (ioctl(cfg->g_sock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
+		log_debug("interfaces", "unable to get media information from %s",
+		    hardware->h_ifname);
+		return;
+	}
+	if (IFM_TYPE(ifmr.ifm_current) != IFM_ETHER) {
+		log_warnx("interfaces",
+		    "cannot get media information from %s: not an ethernet device",
+		    hardware->h_ifname);
+		return;
+	}
+	if ((ifmr.ifm_status & IFM_ACTIVE) == 0) {
+		log_debug("interfaces", "interface %s is now down, skip",
+		    hardware->h_ifname);
+		return;
+	}
+	if (ifmr.ifm_count == 0) {
+		log_warnx("interfaces", "no media information available on %s",
+		    hardware->h_ifname);
+		return;
+	}
+	port->p_macphy.autoneg_support = port->p_macphy.autoneg_enabled = 0;
+	for (int m = 0; m < ifmr.ifm_count; m++) {
+		media = IFM_SUBTYPE(ifmr.ifm_ulist[m]);
+		duplex = !!(IFM_OPTIONS(ifmr.ifm_ulist[m]) & IFM_FDX);
+		if (media == IFM_AUTO) {
+			port->p_macphy.autoneg_support = 1;
+			port->p_macphy.autoneg_enabled =
+			    (IFM_SUBTYPE(ifmr.ifm_current) == IFM_AUTO);
+			continue;
+		}
+
+		int found = 0;
+		for (int j = 0; advertised_ifmedia_to_rfc3636[j][0]; j++) {
+			if (advertised_ifmedia_to_rfc3636[j][0] == media) {
+				port->p_macphy.autoneg_advertised |=
+				    advertised_ifmedia_to_rfc3636[j][1 + duplex];
+				found = 1;
+				break;
+			}
+		}
+		if (!found)
+			port->p_macphy.autoneg_advertised |=
+			    LLDP_DOT3_LINK_AUTONEG_OTHER;
+	}
+
+	port->p_macphy.mau_type = 0;
+	media = IFM_SUBTYPE(ifmr.ifm_active);
+	duplex = !!(IFM_OPTIONS(ifmr.ifm_active) & IFM_FDX);
+	for (int j = 0; current_ifmedia_to_rfc3636[j][0]; j++) {
+		if (current_ifmedia_to_rfc3636[j][0] == media) {
+			port->p_macphy.mau_type =
+			    current_ifmedia_to_rfc3636[j][1 + duplex];
+			break;
+		}
+	}
+#endif
+}
+
+extern struct lldpd_ops bpf_ops;
+void
+interfaces_update(struct lldpd *cfg)
+{
+	struct lldpd_hardware *hardware;
+	struct interfaces_device *iface;
+	struct interfaces_device_list *interfaces;
+	struct interfaces_address_list *addresses;
+	struct ifaddrs *ifaddrs = NULL, *ifaddr;
+
+	interfaces = malloc(sizeof(struct interfaces_device_list));
+	addresses = malloc(sizeof(struct interfaces_address_list));
+	if (interfaces == NULL || addresses == NULL) {
+		log_warnx("interfaces", "unable to allocate memory");
+		goto end;
+	}
+	TAILQ_INIT(interfaces);
+	TAILQ_INIT(addresses);
+	if (getifaddrs(&ifaddrs) < 0) {
+		log_warnx("interfaces", "unable to get list of interfaces");
+		goto end;
+	}
+
+	for (ifaddr = ifaddrs; ifaddr != NULL; ifaddr = ifaddr->ifa_next) {
+		ifbsd_extract(cfg, interfaces, addresses, ifaddr);
+	}
+	/* Link interfaces together if needed */
+	TAILQ_FOREACH (iface, interfaces, next) {
+		ifbsd_check_bridge(cfg, interfaces, iface);
+		ifbsd_check_bond(cfg, interfaces, iface);
+		ifbsd_check_vlan(cfg, interfaces, iface);
+		ifbsd_check_physical(cfg, interfaces, iface);
+	}
+
+	ifbsd_denylist(cfg, interfaces);
+	interfaces_helper_allowlist(cfg, interfaces);
+	interfaces_helper_physical(cfg, interfaces, &bpf_ops, ifbpf_phys_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) continue;
+		ifbsd_macphy(cfg, hardware);
+		interfaces_helper_promisc(cfg, hardware);
+	}
+
+	if (cfg->g_iface_event == NULL) {
+		int s;
+		log_debug("interfaces", "subscribe to route socket notifications");
+		if ((s = socket(PF_ROUTE, SOCK_RAW, 0)) < 0) {
+			log_warn("interfaces", "unable to open route socket");
+			goto end;
+		}
+
+#ifdef ROUTE_MSGFILTER
+		unsigned int rtfilter;
+		rtfilter = ROUTE_FILTER(RTM_IFINFO);
+		if (setsockopt(s, PF_ROUTE, ROUTE_MSGFILTER, &rtfilter,
+			sizeof(rtfilter)) == -1)
+			log_warn("interfaces",
+			    "unable to set filter for interface updates");
+#endif
+
+		if (levent_iface_subscribe(cfg, s) == -1) close(s);
+	}
+
+end:
+	interfaces_free_devices(interfaces);
+	interfaces_free_addresses(addresses);
+	if (ifaddrs) freeifaddrs(ifaddrs);
+}
+
+void
+interfaces_cleanup(struct lldpd *cfg)
+{
+}