xref: /illumos-gate/usr/src/test/os-tests/tests/libsocket/getifaddrs_dl.c (revision b5c46058df272e09a79597fb15cd84399922d666)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2026 Oxide Computer Company
 */

/*
 * This is a basic set of sanity checks for getifaddrs(3SOCKET) and its behavior
 * with AF_LINK addresses. This is generally designed around being a regression
 * test for #16383 and #16384 which were missing data entries in both the
 * sockaddr_dl and the struct if_data.  Rather than change the system and see
 * what's there, we instead walk the links in the system assuming there is
 * usually at least one interface present.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <stdlib.h>
#include <err.h>
#include <libdladm.h>
#include <libdllink.h>
#include <string.h>
#include <stdbool.h>
#include <libdlpi.h>

typedef struct {
	const struct ifaddrs *ic_ifa;
	int ic_ret;
	uint32_t ic_nmatch;
} ifaddr_cb_t;

typedef struct {
	bool mc_found;
	bool *mc_pass;
	const char *mc_name;
	const struct ifaddrs *mc_ifa;
} mac_cb_t;

static boolean_t
dladm_walk_mac_cb(void *arg, dladm_macaddr_attr_t *attr)
{
	mac_cb_t *cb = arg;
	const struct ifaddrs *ifa = cb->mc_ifa;
	const struct sockaddr_dl *dl = (struct sockaddr_dl *)ifa->ifa_addr;
	const struct if_data *if_data = ifa->ifa_data;

	if (attr->ma_addrlen != dl->sdl_alen)
		return (B_TRUE);

	if (memcmp(LLADDR(dl), attr->ma_addr, attr->ma_addrlen) != 0) {
		return (B_TRUE);
	}

	cb->mc_found = true;
	if (if_data != NULL && if_data->ifi_addrlen != attr->ma_addrlen) {
		warnx("TEST FAILED: link %s: found if_data address length "
		    "0x%x, but expected 0x%x", cb->mc_name,
		    if_data->ifi_addrlen, attr->ma_addrlen);
		*cb->mc_pass = false;
	}

	return (B_TRUE);
}

static int
dladm_walk_cb(dladm_handle_t hdl, datalink_id_t id, void *arg)
{
	dladm_status_t dlret;
	ifaddr_cb_t *cb = arg;
	char name[MAXLINKNAMELEN];
	char dlerr[DLADM_STRSIZE];
	uint32_t media;
	char buf[DLADM_PROP_VAL_MAX];
	char *valptr[1];
	uint_t valcnt;

	dlret = dladm_datalink_id2info(hdl, id, NULL, NULL, &media, name,
	    sizeof (name));
	if (dlret != DLADM_STATUS_OK) {
		cb->ic_ret = EXIT_FAILURE;
		warnx("INTERNAL TEST FAILURE: failed to get datalink "
		    "information for link 0x%x: %s", id, dladm_status2str(dlret,
		    dlerr));

		return (DLADM_WALK_CONTINUE);
	}

	/*
	 * Before we scan the list looking for this, see if the link is up. In
	 * particular, dladm will see all datalinks; however, if it isn't really
	 * in use by some client, then it's likely that it's not actually in our
	 * getifaddrs() list. If filtering to links that are not in an unknown
	 * state gives us false positives then we can revisit this.
	 */
	valptr[0] = buf;
	valcnt = 1;
	if (dladm_get_linkprop(hdl, id, DLADM_PROP_VAL_CURRENT, "state", valptr,
	    &valcnt) != DLADM_STATUS_OK) {
		warnx("skipping datalink %s as we could not get \"state\" link "
		    "link property", name);
		return (DLADM_WALK_CONTINUE);
	}

	if (strcmp(buf, "up") != 0 && strcmp(buf, "down") != 0) {
		return (DLADM_WALK_CONTINUE);
	}

	for (const struct ifaddrs *i = cb->ic_ifa; i != NULL; i = i->ifa_next) {
		bool pass = true;

		if (strcmp(name, i->ifa_name) != 0)
			continue;
		if (i->ifa_addr->sa_family != AF_LINK)
			continue;

		struct sockaddr_dl *dl = (struct sockaddr_dl *)i->ifa_addr;
		uint_t ift_type = dlpi_iftype(media);

		if (ift_type != dl->sdl_type) {
			pass = false;
			warnx("TEST FAILED: link %s: found type 0x%x, but "
			    "expected type 0x%x (dlpi 0x%x)", name,
			    dl->sdl_type, ift_type, media);
		}

		size_t nlen = strlen(name);
		if (nlen != dl->sdl_nlen) {
			pass = false;
			warnx("TEST FAILED: link %s: name length mismatch: "
			    "found %u, expected %zu", name, dl->sdl_nlen, nlen);
		}

		if (dl->sdl_nlen > 0) {
			if (strncmp(name, &dl->sdl_data[0], dl->sdl_nlen) !=
			    0) {
				pass = false;
				warnx("TEST FAILED: link %s: sockaddr_dl does "
				    "not match name", name);
			}
		}

		/*
		 * Walk device MAC addresses to ensure that this looks right.
		 */
		mac_cb_t mcb = { false, &pass, name, i };
		(void) dladm_walk_macaddr(hdl, id, &mcb, dladm_walk_mac_cb);
		if (!mcb.mc_found) {
			pass = false;
			warnx("TEST FAILED: link %s: failed to find matching "
			    "mac address", name);
		}

		/*
		 * Check a few last aspects of the ifi_data. The ifi_addrlen has
		 * already been filled in. We need to verify the MTU and type.
		 */
		if (i->ifa_data != NULL) {
			struct if_data *data = i->ifa_data;

			if (data->ifi_type != ift_type) {
				pass = false;
				warnx("TEST FAILED: link %s: found if_data "
				    "ifi_type 0x%x, but expected type 0x%x "
				    "(dlpi 0x%x)", name, data->ifi_type,
				    ift_type, media);
			}

			valptr[0] = buf;
			valcnt = 1;
			if (dladm_get_linkprop(hdl, id, DLADM_PROP_VAL_CURRENT,
			    "mtu", valptr, &valcnt) == DLADM_STATUS_OK) {
				/*
				 * Assume libdladm gives us something
				 * reasonable.
				 */
				ulong_t val = strtoul(buf, NULL, 10);
				if (val != data->ifi_mtu) {
					pass = false;
					warnx("TEST FAILED: link %s: found "
					    "MTU %u, expected %lu", name,
					    data->ifi_mtu, val);
				}
			}
		} else {
			pass = false;
			warnx("TEST FAILED: link %s: found NULL ifa_data "
			    "pointer", name);
		}

		if (pass) {
			(void) printf("TEST PASSED: %s AF_LINK entry looks "
			    "right\n", name);
		} else {
			cb->ic_ret = EXIT_FAILURE;
		}

		cb->ic_nmatch++;
		return (DLADM_WALK_CONTINUE);
	}

	warnx("TEST FAILED: failed to find matching ifaddrs entry for datalink "
	    "%s (0x%x)", name, id);
	cb->ic_ret = EXIT_FAILURE;
	return (DLADM_WALK_CONTINUE);
}

int
main(void)
{
	struct ifaddrs *ifa;
	dladm_status_t dlret;
	dladm_handle_t dladm;
	char dlerr[DLADM_STRSIZE];
	ifaddr_cb_t cb;

	if (getifaddrs(&ifa) != 0) {
		err(EXIT_FAILURE, "INTERNAL TEST FAILURE: getifaddrs() failed: "
		    "test cannot proceed");
	}

	dlret = dladm_open(&dladm);
	if (dlret != DLADM_STATUS_OK) {
		errx(EXIT_FAILURE, "INTERNAL TEST FAILURE: failed to "
		    "initialize libdladm handle: %s", dladm_status2str(dlret,
		    dlerr));
	}

	cb.ic_ifa = ifa;
	cb.ic_ret = EXIT_SUCCESS;
	cb.ic_nmatch = 0;
	(void) dladm_walk_datalink_id(dladm_walk_cb, dladm, &cb,
	    DATALINK_CLASS_PHYS | DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE,
	    DLADM_OPT_ACTIVE);
	dladm_close(dladm);
	freeifaddrs(ifa);

	if (cb.ic_nmatch == 0) {
		cb.ic_ret = EXIT_FAILURE;
		warnx("no AF_LINK entries found");
	}

	if (cb.ic_ret == EXIT_SUCCESS) {
		(void) printf("All tests passed successfully\n");
	}
	return (cb.ic_ret);
}