/*
 * Copyright (c) 2025 Lexi Winter
 *
 * SPDX-License-Identifier: ISC
 */

/*
 * Tests for link_addr() and link_ntoa().
 *
 * link_addr converts a string representing an (optionally null) interface name
 * followed by an Ethernet address into a sockaddr_dl.  The expected format is
 * "[ifname]:lladdr".  This means if ifname is not specified, the leading colon
 * is still required.
 *
 * link_ntoa does the inverse of link_addr, returning a string representation
 * of the address.
 *
 * Note that the output format of link_ntoa is not valid input for link_addr
 * since the leading colon may be omitted.  This is by design.
 */

#include <sys/types.h>
#include <sys/socket.h>

#include <net/ethernet.h>
#include <net/if_dl.h>

#include <format>
#include <iostream>
#include <ranges>
#include <span>
#include <utility>
#include <vector>

#include <cstddef>
#include <cstdint>

#include <atf-c++.hpp>

using namespace std::literals;

/*
 * Define operator== and operator<< for ether_addr so we can use them in
 * ATF_EXPECT_EQ expressions.
 */

bool
operator==(ether_addr a, ether_addr b)
{
	return (std::ranges::equal(a.octet, b.octet));
}

std::ostream &
operator<<(std::ostream &s, ether_addr a)
{
	for (unsigned i = 0; i < ETHER_ADDR_LEN; ++i) {
		if (i > 0)
			s << ":";

		s << std::format("{:02x}", static_cast<int>(a.octet[i]));
	}

	return (s);
}

/*
 * Create a sockaddr_dl from a string using link_addr(), and ensure the
 * returned struct looks valid.
 */
sockaddr_dl
make_linkaddr(const std::string &addr)
{
	auto sdl = sockaddr_dl{};
	int ret;

	sdl.sdl_len = sizeof(sdl);
	ret = ::link_addr(addr.c_str(), &sdl);

	ATF_REQUIRE_EQ(0, ret);
	ATF_REQUIRE_EQ(AF_LINK, static_cast<int>(sdl.sdl_family));
	ATF_REQUIRE_EQ(true, sdl.sdl_len > 0);
	ATF_REQUIRE_EQ(true, sdl.sdl_nlen >= 0);

	return (sdl);
}

/*
 * Return the data stored in a sockaddr_dl as a span.
 */
std::span<const char>
data(const sockaddr_dl &sdl)
{
	// sdl_len is the entire structure, but we only want the length of the
	// data area.
	auto dlen = sdl.sdl_len - offsetof(sockaddr_dl, sdl_data);
	return {&sdl.sdl_data[0], dlen};
}

/*
 * Return the interface name stored in a sockaddr_dl as a string.
 */
std::string_view
ifname(const sockaddr_dl &sdl)
{
	auto name = data(sdl).subspan(0, sdl.sdl_nlen);
	return {name.begin(), name.end()};
}

/*
 * Return the Ethernet address stored in a sockaddr_dl as an ether_addr.
 */
ether_addr
addr(const sockaddr_dl &sdl)
{
	ether_addr ret{};
	ATF_REQUIRE_EQ(ETHER_ADDR_LEN, sdl.sdl_alen);
	std::ranges::copy(data(sdl).subspan(sdl.sdl_nlen, ETHER_ADDR_LEN),
			  &ret.octet[0]);
	return (ret);
}

/*
 * Return the link address stored in a sockaddr_dl as a span of octets.
 */
std::span<const std::uint8_t>
lladdr(const sockaddr_dl &sdl)
{
	auto data = reinterpret_cast<const uint8_t *>(LLADDR(&sdl));
	return {data, data + sdl.sdl_alen};
}


/*
 * Some sample addresses we use for testing.  Include at least one address for
 * each format we want to support.
 */

struct test_address {
	std::string input;	/* value passed to link_addr */
	std::string ntoa;	/* expected return from link_ntoa */
	ether_addr addr{};	/* expected return from link_addr */
};

std::vector<test_address> test_addresses{
	// No delimiter
	{"001122334455"s, "0.11.22.33.44.55",
	 ether_addr{0x00, 0x11, 0x22, 0x33, 0x44, 0x55}},

	// Colon delimiter
	{"00:11:22:33:44:55"s, "0.11.22.33.44.55",
	 ether_addr{0x00, 0x11, 0x22, 0x33, 0x44, 0x55}},

	// Dash delimiter
	{"00-11-22-33-44-55"s, "0.11.22.33.44.55",
	 ether_addr{0x00, 0x11, 0x22, 0x33, 0x44, 0x55}},

	// Period delimiter (link_ntoa format)
	{"00.11.22.33.44.55"s, "0.11.22.33.44.55",
	 ether_addr{0x00, 0x11, 0x22, 0x33, 0x44, 0x55}},

	// Period delimiter (Cisco format)
	{"0011.2233.4455"s, "0.11.22.33.44.55",
	 ether_addr{0x00, 0x11, 0x22, 0x33, 0x44, 0x55}},

	// An addresses without leading zeroes.
	{"0:1:02:30:4:55"s, "0.1.2.30.4.55",
	 ether_addr{0x00, 0x01, 0x02, 0x30, 0x04, 0x55}},

	// An address with some uppercase letters.
	{"AA:B:cC:Dd:e0:1f"s, "aa.b.cc.dd.e0.1f",
	 ether_addr{0xaa, 0x0b, 0xcc, 0xdd, 0xe0, 0x1f}},

	// Addresses composed only of letters, to make sure they're not
	// confused with an interface name.

	{"aabbccddeeff"s, "aa.bb.cc.dd.ee.ff",
	 ether_addr{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}},

	{"aa:bb:cc:dd:ee:ff"s, "aa.bb.cc.dd.ee.ff",
	 ether_addr{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}},

	// Address with a blank octet; this is an old form of Ethernet address.
	{"00:11::33:44:55"s, "0.11.0.33.44.55",
	 ether_addr{0x00, 0x11, 0x00, 0x33, 0x44, 0x55}},
};

/*
 * Test without an interface name.
 */
ATF_TEST_CASE_WITHOUT_HEAD(basic)
ATF_TEST_CASE_BODY(basic)
{
	for (const auto &ta : test_addresses) {
		// This does basic tests on the returned value.
		auto sdl = make_linkaddr(":" + ta.input);

		// Check the ifname and address.
		ATF_REQUIRE_EQ(""s, ifname(sdl));
		ATF_REQUIRE_EQ(ETHER_ADDR_LEN, static_cast<int>(sdl.sdl_alen));
		ATF_REQUIRE_EQ(ta.addr, addr(sdl));

		// Check link_ntoa returns the expected value.
		auto ntoa = std::string(::link_ntoa(&sdl));
		ATF_REQUIRE_EQ(ta.ntoa, ntoa);
	}

}

/*
 * Test with an interface name.
 */
ATF_TEST_CASE_WITHOUT_HEAD(ifname)
ATF_TEST_CASE_BODY(ifname)
{
	for (const auto &ta : test_addresses) {
		auto sdl = make_linkaddr("ix0:" + ta.input);

		ATF_REQUIRE_EQ("ix0", ifname(sdl));
		ATF_REQUIRE_EQ(ETHER_ADDR_LEN, static_cast<int>(sdl.sdl_alen));
		ATF_REQUIRE_EQ(ta.addr, addr(sdl));

		auto ntoa = std::string(::link_ntoa(&sdl));
		ATF_REQUIRE_EQ("ix0:" + ta.ntoa, ntoa);
	}

}

/*
 * Test with some invalid addresses.
 */
ATF_TEST_CASE_WITHOUT_HEAD(invalid)
ATF_TEST_CASE_BODY(invalid)
{
	auto const invalid_addresses = std::vector{
		// Invalid separator
		":1/2/3"s,
		"ix0:1/2/3"s,

		// Multiple different separators
		":1.2-3"s,
		"ix0:1.2-3"s,

		// An IP address
		":10.1.2.200/28"s,
		"ix0:10.1.2.200/28"s,

		// Valid address followed by garbage
		":1.2.3xxx"s,
		":1.2.3.xxx"s,
		"ix0:1.2.3xxx"s,
		"ix0:1.2.3.xxx"s,
	};

	for (auto const &addr : invalid_addresses) {
		int ret;

		auto sdl = sockaddr_dl{};
		sdl.sdl_len = sizeof(sdl);

		ret = link_addr(addr.c_str(), &sdl);
		ATF_REQUIRE_EQ(-1, ret);
	}
}

/*
 * Test some non-Ethernet addresses.
 */
ATF_TEST_CASE_WITHOUT_HEAD(nonether)
ATF_TEST_CASE_BODY(nonether)
{
	sockaddr_dl sdl;

	/* A short address */
	sdl = make_linkaddr(":1:23:cc");
	ATF_REQUIRE_EQ("", ifname(sdl));
	ATF_REQUIRE_EQ("1.23.cc"s, ::link_ntoa(&sdl));
	ATF_REQUIRE_EQ(3, sdl.sdl_alen);
	ATF_REQUIRE_EQ(true,
	    std::ranges::equal(std::vector{0x01u, 0x23u, 0xccu}, lladdr(sdl)));

	/* A long address */
	sdl = make_linkaddr(":1:23:cc:a:b:c:d:e:f");
	ATF_REQUIRE_EQ("", ifname(sdl));
	ATF_REQUIRE_EQ("1.23.cc.a.b.c.d.e.f"s, ::link_ntoa(&sdl));
	ATF_REQUIRE_EQ(9, sdl.sdl_alen);
	ATF_REQUIRE_EQ(true, std::ranges::equal(
	    std::vector{0x01u, 0x23u, 0xccu, 0xau, 0xbu, 0xcu, 0xdu, 0xeu, 0xfu},
	    lladdr(sdl)));
}

/*
 * Test link_addr behaviour with undersized buffers.
 */
ATF_TEST_CASE_WITHOUT_HEAD(smallbuf)
ATF_TEST_CASE_BODY(smallbuf)
{
	static constexpr auto garbage = std::byte{0xcc};
	auto buf = std::vector<std::byte>();
	sockaddr_dl *sdl;
	int ret;

	/*
	 * Make an sdl with an sdl_data member of the appropriate size, and
	 * place it in buf.  Ensure it's followed by a trailing byte of garbage
	 * so we can test that link_addr doesn't write past the end.
	 */
	auto mksdl = [&buf](std::size_t datalen) -> sockaddr_dl * {
		auto actual_size = datalen + offsetof(sockaddr_dl, sdl_data);

		buf.resize(actual_size + 1);
		std::ranges::fill(buf, garbage);

		auto *sdl = new(reinterpret_cast<sockaddr_dl *>(&buf[0]))
		    sockaddr_dl;
		sdl->sdl_len = actual_size;
		return (sdl);
	};

	/* An sdl large enough to store the interface name */
	sdl = mksdl(3);
	ret = link_addr("ix0:1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(ENOSPC, errno);
	ATF_REQUIRE_EQ(3, sdl->sdl_nlen);
	ATF_REQUIRE_EQ("ix0", ifname(*sdl));
	ATF_REQUIRE_EQ(0, static_cast<int>(sdl->sdl_alen));

	/*
	 * For these tests, test both with and without an interface name, since
	 * that will overflow the buffer in different places.
	 */

	/* An empty sdl.  Nothing may grow on this cursed ground. */

	sdl = mksdl(0);
	ret = link_addr("ix0:1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(ENOSPC, errno);
	ATF_REQUIRE_EQ(0, sdl->sdl_nlen);
	ATF_REQUIRE_EQ(0, static_cast<int>(sdl->sdl_alen));

	sdl = mksdl(0);
	ret = link_addr(":1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(ENOSPC, errno);
	ATF_REQUIRE_EQ(0, sdl->sdl_nlen);
	ATF_REQUIRE_EQ(0, static_cast<int>(sdl->sdl_alen));

	/*
	 * An sdl large enough to store the interface name and two octets of the
	 * address.
	 */

	sdl = mksdl(5);
	ret = link_addr("ix0:1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(ENOSPC, errno);
	ATF_REQUIRE_EQ("ix0", ifname(*sdl));
	ATF_REQUIRE(std::ranges::equal(
	    std::vector{ 0x01, 0x02 }, lladdr(*sdl)));

	sdl = mksdl(2);
	ret = link_addr(":1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(ENOSPC, errno);
	ATF_REQUIRE_EQ("", ifname(*sdl));
	ATF_REQUIRE(std::ranges::equal(
	    std::vector{ 0x01, 0x02 }, lladdr(*sdl)));

	/*
	 * An sdl large enough to store the entire address.
	 */

	sdl = mksdl(6);
	ret = link_addr("ix0:1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(0, ret);
	ATF_REQUIRE_EQ("ix0", ifname(*sdl));
	ATF_REQUIRE(std::ranges::equal(
	    std::vector{ 0x01, 0x02, 0x03 }, lladdr(*sdl)));

	sdl = mksdl(3);
	ret = link_addr(":1.2.3", sdl);
	ATF_REQUIRE(*rbegin(buf) == garbage);
	ATF_REQUIRE_EQ(0, ret);
	ATF_REQUIRE_EQ("", ifname(*sdl));
	ATF_REQUIRE(std::ranges::equal(
	    std::vector{ 0x01, 0x02, 0x03 }, lladdr(*sdl)));
}

/*
 * Test an extremely long address which would overflow link_ntoa's internal
 * buffer.  It should handle this by truncating the output.
 * (Test for SA-16:37.libc / CVE-2016-6559.)
 */
ATF_TEST_CASE_WITHOUT_HEAD(overlong)
ATF_TEST_CASE_BODY(overlong)
{
	auto sdl = make_linkaddr(
	    ":01.02.03.04.05.06.07.08.09.0a.0b.0c.0d.0e.0f."
	    "11.12.13.14.15.16.17.18.19.1a.1b.1c.1d.1e.1f."
	    "22.22.23.24.25.26.27.28.29.2a.2b.2c.2d.2e.2f");

	ATF_REQUIRE_EQ(
	    "1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.11.12.13.14.15.16.17.18.19.1a.1b."s,
	    ::link_ntoa(&sdl));
}

/*
 * Test link_ntoa_r, the re-entrant version of link_ntoa().
 */
ATF_TEST_CASE_WITHOUT_HEAD(link_ntoa_r)
ATF_TEST_CASE_BODY(link_ntoa_r)
{
	static constexpr char garbage = 0x41;
	std::vector<char> buf;
	sockaddr_dl sdl;
	size_t len;
	int ret;

	// Return the contents of buf as a string, using the NUL terminator to
	// determine length.  This is to ensure we're using the return value in
	// the same way C code would, but we do a bit more verification to
	// elicit a test failure rather than a SEGV if it's broken.
	auto bufstr = [&buf]() -> std::string_view {
		// Find the NUL.
		auto end = std::ranges::find(buf, '\0');
		ATF_REQUIRE(end != buf.end());

		// Intentionally chopping the NUL off.
		return {begin(buf), end};
	};

	// Resize the buffer and set the contents to a known garbage value, so
	// we don't accidentally have a NUL in the right place when link_ntoa_r
	// didn't put it there.
	auto resetbuf = [&buf, &len](std::size_t size) {
		len = size;
		buf.resize(len);
		std::ranges::fill(buf, garbage);
	};

	// Test a short address with a large buffer.
	sdl = make_linkaddr("ix0:1.2.3");
	resetbuf(64);
	ret = ::link_ntoa_r(&sdl, &buf[0], &len);
	ATF_REQUIRE_EQ(0, ret);
	ATF_REQUIRE_EQ(10, len);
	ATF_REQUIRE_EQ("ix0:1.2.3"s, bufstr());

	// Test a buffer which is exactly the right size.
	sdl = make_linkaddr("ix0:1.2.3");
	resetbuf(10);
	ret = ::link_ntoa_r(&sdl, &buf[0], &len);
	ATF_REQUIRE_EQ(0, ret);
	ATF_REQUIRE_EQ(10, len);
	ATF_REQUIRE_EQ("ix0:1.2.3"sv, bufstr());

	// Test various short buffers, using a table of buffer length and the
	// output we expect.  All of these should produce valid but truncated
	// strings, with a trailing NUL and with buflen set correctly.

	auto buftests = std::vector<std::pair<std::size_t, std::string_view>>{
		{1u, ""sv},
		{2u, ""sv},
		{3u, ""sv},
		{4u, "ix0"sv},
		{5u, "ix0:"sv},
		{6u, "ix0:1"sv},
		{7u, "ix0:1."sv},
		{8u, "ix0:1.2"sv},
		{9u, "ix0:1.2."sv},
	};

	for (auto const &[buflen, expected] : buftests) {
		sdl = make_linkaddr("ix0:1.2.3");
		resetbuf(buflen);
		ret = ::link_ntoa_r(&sdl, &buf[0], &len);
		ATF_REQUIRE_EQ(-1, ret);
		ATF_REQUIRE_EQ(10, len);
		ATF_REQUIRE_EQ(expected, bufstr());
	}

	// Test a NULL buffer, which should just set buflen.
	sdl = make_linkaddr("ix0:1.2.3");
	len = 0;
	ret = ::link_ntoa_r(&sdl, NULL, &len);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(10, len);

	// A NULL buffer with a non-zero length should also be accepted.
	sdl = make_linkaddr("ix0:1.2.3");
	len = 64;
	ret = ::link_ntoa_r(&sdl, NULL, &len);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(10, len);

	// Test a non-NULL buffer, but with a length of zero.
	sdl = make_linkaddr("ix0:1.2.3");
	resetbuf(1);
	len = 0;
	ret = ::link_ntoa_r(&sdl, &buf[0], &len);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(10, len);
	// Check we really didn't write anything.
	ATF_REQUIRE_EQ(garbage, buf[0]);

	// Test a buffer which would be truncated in the middle of a two-digit
	// hex octet, which should not write the truncated octet at all.
	sdl = make_linkaddr("ix0:1.22.3");
	resetbuf(8);
	ret = ::link_ntoa_r(&sdl, &buf[0], &len);
	ATF_REQUIRE_EQ(-1, ret);
	ATF_REQUIRE_EQ(11, len);
	ATF_REQUIRE_EQ("ix0:1."sv, bufstr());
}

ATF_INIT_TEST_CASES(tcs)
{
	ATF_ADD_TEST_CASE(tcs, basic);
	ATF_ADD_TEST_CASE(tcs, ifname);
	ATF_ADD_TEST_CASE(tcs, smallbuf);
	ATF_ADD_TEST_CASE(tcs, invalid);
	ATF_ADD_TEST_CASE(tcs, nonether);
	ATF_ADD_TEST_CASE(tcs, overlong);
	ATF_ADD_TEST_CASE(tcs, link_ntoa_r);
}