{

constexpr auto winhttpModuleName = L"Winhttp.dll";

const wil::shared_hmodule winhttpModule{LoadLibraryEx(winhttpModuleName, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32)};

if (!winhttpModule)

{

return false;

}

try

{

// attempt to find the functions for the Winhttp proxy APIs.

static LxssDynamicFunction<decltype(WinHttpRegisterProxyChangeNotification)> WinHttpRegisterProxyChangeNotification{

winhttpModule, "WinHttpRegisterProxyChangeNotification"};

static LxssDynamicFunction<decltype(WinHttpUnregisterProxyChangeNotification)> WinHttpUnregisterProxyChangeNotification{

winhttpModule, "WinHttpUnregisterProxyChangeNotification"};

static LxssDynamicFunction<decltype(WinHttpGetProxySettingsEx)> WinHttpGetProxySettingsEx{

winhttpModule, "WinHttpGetProxySettingsEx"};

static LxssDynamicFunction<decltype(WinHttpGetProxySettingsResultEx)> WinHttpGetProxySettingsResultEx{

winhttpModule, "WinHttpGetProxySettingsResultEx"};

static LxssDynamicFunction<decltype(WinHttpFreeProxySettingsEx)> WinHttpFreeProxySettingsEx{

winhttpModule, "WinHttpFreeProxySettingsEx"};

}

catch (...)

{

return false;

}

return true;

{

auto [out, _] = LxsstuLaunchWslAndCaptureOutput(L"cat /sys/class/net/" + adapter + L"/address", 0);

out.pop_back(); // remove LF

return out;

{

LARGE_INTEGER m_startQpc;

LARGE_INTEGER m_frequencyQpc;

T m_timeoutInterval;

Stopwatch(_In_opt_ T TimeoutInterval = T::max()) : m_timeoutInterval(TimeoutInterval)

{

QueryPerformanceFrequency(&m_frequencyQpc);

QueryPerformanceCounter(&m_startQpc);

}

T Elapsed()

{

LARGE_INTEGER End;

UINT64 ElapsedQpc;

QueryPerformanceCounter(&End);

ElapsedQpc = End.QuadPart - m_startQpc.QuadPart;

return T((ElapsedQpc * T::period::den) / T::period::num / m_frequencyQpc.QuadPart);

}

bool IsExpired()

{

return Elapsed() >= m_timeoutInterval;

}

{

WSL_TEST_CLASS(NetworkTests)

static std::wstring SockaddrToString(const SOCKADDR_INET* sockAddr)

{

constexpr auto ipv4AddressStringLength = 16;

constexpr auto ipv6AddressStringLength = 48;

std::wstring address(std::max(ipv4AddressStringLength, ipv6AddressStringLength), L'\0');

switch (sockAddr->si_family)

{

case AF_INET:

{

RtlIpv4AddressToStringW(&sockAddr->Ipv4.sin_addr, address.data());

break;

}

case AF_INET6:

{

RtlIpv6AddressToStringW(&sockAddr->Ipv6.sin6_addr, address.data());

break;

}

default:

break;

}

address.resize(std::wcslen(address.data()));

return address;

}

struct IpAddress

{

std::wstring Address;

uint8_t PrefixLength;

bool Preferred = false;

bool operator==(const IpAddress& other) const

{

return Address == other.Address && PrefixLength == other.PrefixLength;

}

std::wstring GetPrefix() const

{

DWORD status = ERROR_INVALID_FUNCTION;

SOCKADDR_INET* address = nullptr;

unsigned char* addressPointer{};

NET_ADDRESS_INFO netAddrInfo{};

status = ParseNetworkString(Address.c_str(), NET_STRING_IP_ADDRESS, &netAddrInfo, nullptr, nullptr);

if (status != NO_ERROR)

{

return std::wstring(L"");

}

address = reinterpret_cast<SOCKADDR_INET*>(&netAddrInfo.IpAddress);

addressPointer = (address->si_family == AF_INET) ? reinterpret_cast<unsigned char*>(&address->Ipv4.sin_addr)

: address->Ipv6.sin6_addr.u.Byte;

constexpr int c_numBitsPerByte = 8;

for (int i = 0, currPrefixLength = PrefixLength; i < INET_ADDR_LENGTH(address->si_family); i++, currPrefixLength -= c_numBitsPerByte)

{

if (currPrefixLength < c_numBitsPerByte)

{

const int bitShiftAmt = (c_numBitsPerByte - std::max(currPrefixLength, 0));

addressPointer[i] &= (0xFF >> bitShiftAmt) << bitShiftAmt;

}

}

return SockaddrToString(address) + L"/" + std::to_wstring(PrefixLength);

}

};

struct InterfaceState

{

std::wstring Name;

std::vector<IpAddress> V4Addresses;

std::optional<std::wstring> Gateway;

std::vector<IpAddress> V6Addresses;

std::optional<std::wstring> V6Gateway;

bool Up = false;

int Mtu = 0;

bool Rename = false;

};

struct Route

{

std::wstring Via;

std::wstring Device;

std::optional<std::wstring> Prefix;

int Metric = 0;

bool operator==(const Route& other) const

{

return Via == other.Via && Device == other.Device && Prefix == other.Prefix;

}

};

struct RoutingTableState

{

std::optional<Route> DefaultRoute;

std::vector<Route> Routes;

};

enum class FirewallType

{

Host,

HyperV

};

struct FirewallRule

{

FirewallType Type;

std::wstring Name;

std::wstring RemotePorts;

std::wstring Action;

std::wstring VmCreatorId;

};

GUID AdapterId;

TEST_CLASS_SETUP(TestClassSetup)

{

VERIFY_ARE_EQUAL(LxsstuInitialize(false), TRUE);

return true;

}

TEST_CLASS_CLEANUP(TestClassCleanup)

{

if (LxsstuVmMode())

{

WslShutdown();

}

VERIFY_NO_THROW(LxsstuUninitialize(false));

return true;

}

TEST_METHOD_SETUP(MethodSetup)

{

if (!LxsstuVmMode())

{

return true;

}

auto [out, _] = LxsstuLaunchWslAndCaptureOutput(

L"readlink /sys/class/net/eth0 | grep -o -E '[[:xdigit:]]{8}(-[[:xdigit:]]{4}){3}-[[:xdigit:]]{12}'", 0);

out.pop_back();

const auto guid = wsl::shared::string::ToGuid(out);

VERIFY_IS_TRUE(guid.has_value());

AdapterId = guid.value();

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"ln -f -s /init /gns"), (DWORD)0);

return true;

}

TEST_METHOD(RemoveAndAddDefaultRoute)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

// Verify that the default routes are set

auto state = GetIpv4RoutingTableState();

VERIFY_IS_TRUE(state.DefaultRoute.has_value());

VERIFY_ARE_EQUAL(state.DefaultRoute->Via, L"192.168.0.1");

auto v6State = GetIpv6RoutingTableState();

VERIFY_IS_TRUE(v6State.DefaultRoute.has_value());

VERIFY_ARE_EQUAL(v6State.DefaultRoute->Via, L"fc00::1");

// Now remove them

wsl::shared::hns::Route route;

route.NextHop = L"192.168.0.1";

route.DestinationPrefix = LX_INIT_DEFAULT_ROUTE_PREFIX;

route.Family = AF_INET;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

wsl::shared::hns::Route v6Route;

v6Route.NextHop = L"fc00::1";

v6Route.DestinationPrefix = LX_INIT_DEFAULT_ROUTE_V6_PREFIX;

v6Route.Family = AF_INET6;

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

// Verify that the routes are removed

state = GetIpv4RoutingTableState();

VERIFY_IS_FALSE(state.DefaultRoute.has_value());

v6State = GetIpv6RoutingTableState();

VERIFY_IS_FALSE(v6State.DefaultRoute.has_value());

// Add them again

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Add, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Add, GuestEndpointResourceType::Route);

// Verify that the routes are restored

state = GetIpv4RoutingTableState();

VERIFY_IS_TRUE(state.DefaultRoute.has_value());

VERIFY_ARE_EQUAL(state.DefaultRoute->Via, L"192.168.0.1");

VERIFY_ARE_EQUAL(state.DefaultRoute->Device, L"eth0");

v6State = GetIpv6RoutingTableState();

VERIFY_IS_TRUE(v6State.DefaultRoute.has_value());

VERIFY_ARE_EQUAL(v6State.DefaultRoute->Via, L"fc00::1");

VERIFY_ARE_EQUAL(v6State.DefaultRoute->Device, L"eth0");

}

TEST_METHOD(SetInterfaceDownAndUp)

{

WSL2_TEST_ONLY();

// Disconnect interface

wsl::shared::hns::NetworkInterface link;

link.Connected = false;

RunGns(link, ModifyRequestType::Update, GuestEndpointResourceType::Interface);

VERIFY_IS_FALSE(GetInterfaceState(L"eth0").Up);

// Connect it again

link.Connected = true;

RunGns(link, ModifyRequestType::Update, GuestEndpointResourceType::Interface);

VERIFY_IS_TRUE(GetInterfaceState(L"eth0").Up);

}

TEST_METHOD(SetMtu)

{

WSL2_TEST_ONLY();

// Set MTU - must be 1280 bytes or above to meet IPv6 minimum MTU requirement

wsl::shared::hns::NetworkInterface link;

link.Connected = true;

link.NlMtu = 1280;

RunGns(link, ModifyRequestType::Update, GuestEndpointResourceType::Interface);

VERIFY_ARE_EQUAL(GetInterfaceState(L"eth0").Mtu, 1280);

}

TEST_METHOD(AddAndRemoveCustomRoute)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

// Add custom routes, one per address family

wsl::shared::hns::Route route;

route.NextHop = L"192.168.0.12";

route.DestinationPrefix = L"192.168.2.0/24";

route.Family = AF_INET;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

wsl::shared::hns::Route v6Route;

v6Route.NextHop = L"fc00::12";

v6Route.DestinationPrefix = L"fc00:abcd::/80";

v6Route.Family = AF_INET6;

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

// Check that the routes are there

const bool v4CustomRouteExists = RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24"});

const bool v6CustomRouteExists = RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/80"});

// Now remove them

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

// Check that the routes are gone

const bool v4CustomRouteGone = !RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24"});

const bool v6CustomRouteGone = !RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/80"});

VERIFY_IS_TRUE(v4CustomRouteExists);

VERIFY_IS_TRUE(v6CustomRouteExists);

VERIFY_IS_TRUE(v4CustomRouteGone);

VERIFY_IS_TRUE(v6CustomRouteGone);

}

TEST_METHOD(AddRouteWithMetrics)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

// Add a custom route per address family

wsl::shared::hns::Route route;

route.NextHop = L"192.168.0.12";

route.DestinationPrefix = L"192.168.2.0/24";

route.Family = AF_INET;

route.Metric = 12;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

wsl::shared::hns::Route v6Route;

v6Route.NextHop = L"fc00::12";

v6Route.DestinationPrefix = L"fc00:abcd::/64";

v6Route.Family = AF_INET6;

v6Route.Metric = 12;

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

// Check that the routes are there

const bool v4CustomRouteExists = RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24", 12});

const bool v6CustomRouteExists = RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/64", 12});

// Now remove them

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Remove, GuestEndpointResourceType::Route);

// Check that the routes are gone

const bool v4CustomRouteGone = !RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24", 12});

const bool v6CustomRouteGone = !RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/64", 12});

VERIFY_IS_TRUE(v4CustomRouteExists);

VERIFY_IS_TRUE(v6CustomRouteExists);

VERIFY_IS_TRUE(v4CustomRouteGone);

VERIFY_IS_TRUE(v6CustomRouteGone);

}

TEST_METHOD(ResetRoutes)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

// Add a custom route per address family

wsl::shared::hns::Route route;

route.NextHop = L"192.168.0.12";

route.DestinationPrefix = L"192.168.2.0/24";

route.Family = AF_INET;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

wsl::shared::hns::Route v6Route;

v6Route.NextHop = L"fc00::12";

v6Route.DestinationPrefix = L"fc00:abcd::/80";

v6Route.Family = AF_INET6;

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

// Check that the custom routes are there

bool v4RouteExists = RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24"});

bool v6RouteExists = RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/80"});

// Reset the routing table

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

// Check that both routes are gone, per address family

bool v4RouteGoneAfterReset = !RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24"});

auto state = GetIpv4RoutingTableState();

bool v4GwGoneAfterReset = !state.DefaultRoute.has_value();

bool v6RouteGoneAfterReset = !RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/80"});

auto v6State = GetIpv6RoutingTableState();

bool v6GwGoneAfterReset = !v6State.DefaultRoute.has_value();

// Add the custom and default routes back

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

route.DestinationPrefix = LX_INIT_DEFAULT_ROUTE_PREFIX;

route.NextHop = L"192.168.0.1";

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

v6Route.DestinationPrefix = LX_INIT_DEFAULT_ROUTE_V6_PREFIX;

v6Route.NextHop = L"fc00::1";

SendDeviceSettingsRequest(L"eth0", v6Route, ModifyRequestType::Update, GuestEndpointResourceType::Route);

// Verify that all the routes are there

bool v4RouteRestored = RouteExists({L"192.168.0.12", L"eth0", L"192.168.2.0/24"});

state = GetIpv4RoutingTableState();

bool v4GwRestored = state.DefaultRoute.has_value();

bool v4GwRestoredCorrectly = state.DefaultRoute->Via == L"192.168.0.1";

bool v6RouteRestored = RouteExists({L"fc00::12", L"eth0", L"fc00:abcd::/80"});

v6State = GetIpv6RoutingTableState();

bool v6GwRestored = v6State.DefaultRoute.has_value();

bool v6GwRestoredCorrectly = v6State.DefaultRoute->Via == L"fc00::1";

VERIFY_IS_TRUE(v4RouteExists);

VERIFY_IS_TRUE(v6RouteExists);

VERIFY_IS_TRUE(v4RouteGoneAfterReset);

VERIFY_IS_TRUE(v4GwGoneAfterReset);

VERIFY_IS_TRUE(v6RouteGoneAfterReset);

VERIFY_IS_TRUE(v6GwGoneAfterReset);

VERIFY_IS_TRUE(v4RouteRestored);

VERIFY_IS_TRUE(v4GwRestored);

VERIFY_IS_TRUE(v4GwRestoredCorrectly);

VERIFY_IS_TRUE(v6RouteRestored);

VERIFY_IS_TRUE(v6GwRestored);

VERIFY_IS_TRUE(v6GwRestoredCorrectly);

}

TEST_METHOD(ResetRoutesTwice)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

auto state = GetIpv4RoutingTableState();

VERIFY_IS_TRUE(state.DefaultRoute.has_value());

auto v6State = GetIpv6RoutingTableState();

VERIFY_IS_TRUE(v6State.DefaultRoute.has_value());

// Reset the IPv4 table twice

wsl::shared::hns::Route route;

route.Family = AF_INET;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

state = GetIpv4RoutingTableState();

VERIFY_IS_FALSE(state.DefaultRoute.has_value());

VERIFY_IS_TRUE(state.Routes.empty());

// Then reset the IPv6 table twice

route.Family = AF_INET6;

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

SendDeviceSettingsRequest(L"eth0", route, ModifyRequestType::Reset, GuestEndpointResourceType::Route);

state = GetIpv6RoutingTableState();

VERIFY_IS_FALSE(state.DefaultRoute.has_value());

VERIFY_IS_TRUE(state.Routes.empty());

}

TEST_METHOD(UpdateIpAddress)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

// Verify that the IPs are in the preferred state

auto interfaceState = GetInterfaceState(L"eth0");

VERIFY_ARE_EQUAL(1, interfaceState.V4Addresses.size());

VERIFY_ARE_EQUAL(L"192.168.0.2", interfaceState.V4Addresses[0].Address);

VERIFY_IS_TRUE(interfaceState.V4Addresses[0].Preferred);

VERIFY_ARE_EQUAL(1, interfaceState.V6Addresses.size());

VERIFY_ARE_EQUAL(L"fc00::2", interfaceState.V6Addresses[0].Address);

VERIFY_IS_TRUE(interfaceState.V6Addresses[0].Preferred);

// Change current ip addresses to be deprecated

wsl::shared::hns::IPAddress address;

address.Address = L"192.168.0.2";

address.OnLinkPrefixLength = 24;

address.Family = AF_INET;

address.PreferredLifetime = 0;

SendDeviceSettingsRequest(L"eth0", address, ModifyRequestType::Update, GuestEndpointResourceType::IPAddress);

wsl::shared::hns::IPAddress v6Address;

v6Address.Address = L"fc00::2";

v6Address.OnLinkPrefixLength = 64;

v6Address.Family = AF_INET6;

address.PreferredLifetime = 0;

SendDeviceSettingsRequest(L"eth0", v6Address, ModifyRequestType::Update, GuestEndpointResourceType::IPAddress);

// Validate that the IPs are no longer preferred

interfaceState = GetInterfaceState(L"eth0");

VERIFY_ARE_EQUAL(1, interfaceState.V4Addresses.size());

VERIFY_ARE_EQUAL(L"192.168.0.2", interfaceState.V4Addresses[0].Address);

VERIFY_IS_FALSE(interfaceState.V4Addresses[0].Preferred);

VERIFY_ARE_EQUAL(1, interfaceState.V6Addresses.size());

VERIFY_ARE_EQUAL(L"fc00::2", interfaceState.V6Addresses[0].Address);

VERIFY_IS_FALSE(interfaceState.V6Addresses[0].Preferred);

}

enum IpPrefixOrigin

{

IpPrefixOriginOther = 0,

IpPrefixOriginManual,

IpPrefixOriginWellKnown,

IpPrefixOriginDhcp,

IpPrefixOriginRouterAdvertisement,

};

enum IpSuffixOrigin

{

IpSuffixOriginOther = 0,

IpSuffixOriginManual,

IpSuffixOriginWellKnown,

IpSuffixOriginDhcp,

IpSuffixOriginLinkLayerAddress,

IpSuffixOriginRandom,

};

TEST_METHOD(TemporaryAddress)

{

WSL2_TEST_ONLY();

TestCase({{L"eth0", {}, {}, {{L"fc00::2", 64}}, L"fc00::1"}});

// Make the address public

wsl::shared::hns::IPAddress v6Address;

v6Address.Address = L"fc00::2";

v6Address.OnLinkPrefixLength = 64;

v6Address.Family = AF_INET6;

v6Address.PrefixOrigin = IpPrefixOriginRouterAdvertisement;

v6Address.SuffixOrigin = IpSuffixOriginLinkLayerAddress;

v6Address.PreferredLifetime = 0xFFFFFFFF;

SendDeviceSettingsRequest(L"eth0", v6Address, ModifyRequestType::Update, GuestEndpointResourceType::IPAddress);

// Add a temporary address

v6Address.Address = L"fc00::abcd:1234:5678:9999";

v6Address.OnLinkPrefixLength = 64;

v6Address.Family = AF_INET6;

v6Address.PrefixOrigin = IpPrefixOriginRouterAdvertisement;

v6Address.SuffixOrigin = IpSuffixOriginRandom;

v6Address.PreferredLifetime = 0xFFFFFFFF;

SendDeviceSettingsRequest(L"eth0", v6Address, ModifyRequestType::Add, GuestEndpointResourceType::IPAddress);

// Wait for DAD to finish to avoid it being a factor in source address selection

std::this_thread::sleep_for(std::chrono::milliseconds(2000));

VERIFY_ARE_EQUAL(2, GetInterfaceState(L"eth0").V6Addresses.size());

// Ensure that the temporary address is preferred during source address selection

auto [out, _] = LxsstuLaunchWslAndCaptureOutput(L"ip route get 2001::5");

LogInfo("'ip route get 2001::5' - '%ls'", out.c_str());

auto [out5, _5] = LxsstuLaunchWslAndCaptureOutput(L"ip addr show eth0");

LogInfo("[TemporaryAddress] ip addr show output: '%ls'", out5.c_str());

std::wsmatch match;

std::wregex pattern(L"2001::5 from :: via fc00::1 dev eth0 proto kernel src ([a-f,A-F,0-9,:]+)");

VERIFY_IS_TRUE(std::regex_search(out, match, pattern));

VERIFY_ARE_EQUAL(2, match.size());

VERIFY_ARE_EQUAL(L"fc00::abcd:1234:5678:9999", match.str(1));

// Make another public address

v6Address.Address = L"fc00::3";

v6Address.OnLinkPrefixLength = 64;

v6Address.Family = AF_INET6;

v6Address.PrefixOrigin = IpPrefixOriginRouterAdvertisement;

v6Address.SuffixOrigin = IpSuffixOriginLinkLayerAddress;

v6Address.PreferredLifetime = 0xFFFFFFFF;

SendDeviceSettingsRequest(L"eth0", v6Address, ModifyRequestType::Add, GuestEndpointResourceType::IPAddress);

// Test source address selection again

auto [out2, _2] = LxsstuLaunchWslAndCaptureOutput(L"ip route get 2001::6");

LogInfo("'ip route get 2001::6' - '%ls'", out2.c_str());

std::wregex pattern2(L"2001::6 from :: via fc00::1 dev eth0 proto kernel src ([a-f,A-F,0-9,:]+)");

VERIFY_IS_TRUE(std::regex_search(out2, match, pattern2));

VERIFY_ARE_EQUAL(2, match.size());

VERIFY_ARE_EQUAL(L"fc00::abcd:1234:5678:9999", match.str(1));

}

TEST_METHOD(SimpleCase)

{

TestCase({{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

}

TEST_METHOD(AddressChange)

{

TestCase(

{{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"},

{L"eth0", {{L"192.168.0.3", 24}}, L"192.168.0.1", {{L"fc00::3", 64}}, L"fc00::1"}});

}

TEST_METHOD(GatewayChange)

{

TestCase(

{{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"},

{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.3", {{L"fc00::2", 64}}, L"fc00::3"}});

}

TEST_METHOD(NetworkChange)

{

TestCase(

{{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"},

{L"eth0", {{L"10.0.0.2", 16}}, L"10.0.0.1", {{L"fc00:abcd::5", 80}}, L"fc00:abcd::1"}});

}

TEST_METHOD(NetworkChangeAndBack)

{

TestCase(

{{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"},

{L"eth0", {{L"10.0.0.2", 16}}, L"10.0.0.1", {{L"fc00:abcd::5", 80}}, L"fc00:abcd::1"},

{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

}

TEST_METHOD(NoChange)

{

TestCase(

{{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"},

{L"eth0", {{L"192.168.0.2", 24}}, L"192.168.0.1", {{L"fc00::2", 64}}, L"fc00::1"}});

}

TEST_METHOD(MultipleIps)

{

TestCase(

{{L"eth0",

{{L"192.168.0.2", 24}, {L"192.168.0.3", 24}},

L"192.168.0.1",

{{L"fc00::2", 64}, {L"fc00::3", 64}},

L"fc00::1"}});

}

TEST_METHOD(MacAddressChangeAndBack)

{

WSL2_TEST_ONLY();

const auto originalMac = GetMacAddress();

wsl::shared::hns::MacAddress macAddress;

macAddress.PhysicalAddress = "AA-AA-FF-FF-FF-FF";

SendDeviceSettingsRequest(L"eth0", macAddress, ModifyRequestType::Update, GuestEndpointResourceType::MacAddress);

VERIFY_ARE_EQUAL(GetMacAddress(), L"aa:aa:ff:ff:ff:ff");

macAddress.PhysicalAddress = wsl::shared::string::WideToMultiByte(originalMac);

std::replace(macAddress.PhysicalAddress.begin(), macAddress.PhysicalAddress.end(), ':', '-');

SendDeviceSettingsRequest(L"eth0", macAddress, ModifyRequestType::Update, GuestEndpointResourceType::MacAddress);

VERIFY_ARE_EQUAL(GetMacAddress(), originalMac);

}

static void VerifyDigDnsResolution(const std::wstring& digCommandLine)

{

// dig has exit code 0 when it receives a DNS response

auto [out, _] = LxsstuLaunchWslAndCaptureOutput(digCommandLine.data(), 0);

// Verify dig returned a non-empty output

VERIFY_IS_TRUE(!out.empty());

}

static void VerifyDnsQueries()

{

// query for A/IPv4 records

VerifyDigDnsResolution(L"dig +short +time=5 A bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 A bing.com");

// query for AAAA/IPv6 records

VerifyDigDnsResolution(L"dig +short +time=5 AAAA bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 AAAA bing.com");

// query for MX records

VerifyDigDnsResolution(L"dig +short +time=5 MX bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 MX bing.com");

// query for NS records

VerifyDigDnsResolution(L"dig +short +time=5 NS bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 NS bing.com");

// reverse DNS lookup

VerifyDigDnsResolution(L"dig +short +time=5 -x 8.8.8.8");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 -x 8.8.8.8");

// query for SOA records

VerifyDigDnsResolution(L"dig +short +time=5 SOA bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 SOA bing.com");

// query for TXT records

VerifyDigDnsResolution(L"dig +short +time=5 TXT bing.com");

VerifyDigDnsResolution(L"dig +tcp +short +time=5 TXT bing.com");

// query for CNAME records

VerifyDigDnsResolution(L"dig +time=5 CNAME bing.com");

VerifyDigDnsResolution(L"dig +tcp +time=5 CNAME bing.com");

// query for SRV records

VerifyDigDnsResolution(L"dig +time=5 SRV bing.com");

VerifyDigDnsResolution(L"dig +tcp +time=5 SRV bing.com");

// query for ANY - for this option dig expects a large response so it will query directly over TCP,

// instead of trying UDP first and falling back to TCP.

VerifyDigDnsResolution(L"dig +short ANY bing.com");

}

static void VerifyDnsSuffixes()

{

bool foundSuffix = false;

// Verify global DNS suffixes are reflected in Linux

auto [outGlobal, errGlobal] = LxsstuLaunchPowershellAndCaptureOutput(

L"Get-DnsClientGlobalSetting | Select-Object -Property SuffixSearchList | ForEach-Object {$_.SuffixSearchList}");

const std::wstring separators = L" \n\t\r";

for (const auto& suffix : wsl::shared::string::SplitByMultipleSeparators(outGlobal, separators))

{

if (!suffix.empty())

{

foundSuffix = true;

// use grep -F as suffixes can contain '.'

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"cat /etc/resolv.conf | grep search | grep -F " + suffix), static_cast<DWORD>(0));

}

}

// Verify per-interface DNS suffixes are reflected in Linux

auto [outPerInterface, errPerInterface] =

LxsstuLaunchPowershellAndCaptureOutput(L"Get-DnsClient | ForEach-Object {$_.ConnectionSpecificSuffix}");

for (const auto& suffix : wsl::shared::string::SplitByMultipleSeparators(outPerInterface, separators))

{

if (!suffix.empty())

{

foundSuffix = true;

// use grep -F as suffixes can contain '.'

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"cat /etc/resolv.conf | grep search | grep -F " + suffix), static_cast<DWORD>(0));

}

}

// No suffix was found - configure a dummy global suffix, verify it's reflected in Linux, then delete it

if (!foundSuffix)

{

LxsstuLaunchPowershellAndCaptureOutput(L"Set-DnsClientGlobalSetting -SuffixSearchList @('test.com')");

auto restoreGlobalSuffixes = wil::scope_exit(

[&] { LxsstuLaunchPowershellAndCaptureOutput(L"Set-DnsClientGlobalSetting -SuffixSearchList @()"); });

std::this_thread::sleep_for(std::chrono::seconds(1));

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"cat /etc/resolv.conf | grep search | grep -F test.com"), static_cast<DWORD>(0));

LxsstuLaunchPowershellAndCaptureOutput(L"Set-DnsClientGlobalSetting -SuffixSearchList @()");

std::this_thread::sleep_for(std::chrono::seconds(1));

VERIFY_ARE_NOT_EQUAL(LxsstuLaunchWsl(L"cat /etc/resolv.conf | grep search | grep -F test.com"), static_cast<DWORD>(0));

}

}

static void VerifyEtcHosts()

{

const auto windowsHostsPath = "C:\\Windows\\System32\\drivers\\etc\\hosts";

// Save existing Windows /etc/hosts

std::wifstream windowsHostsRead(windowsHostsPath);

const auto oldWindowsHosts = std::wstring{std::istreambuf_iterator<wchar_t>(windowsHostsRead), {}};

windowsHostsRead.close();

auto restoreWindowsHosts = wil::scope_exit([&] {

std::wofstream windowsHostsWrite(windowsHostsPath);

windowsHostsWrite << oldWindowsHosts;

});

// Add dummy entry matching bing.com to IP 1.2.3.4

std::wofstream windowsHostsWrite(windowsHostsPath, std::ios_base::app);

windowsHostsWrite << "\n1.2.3.4 bing.com";

windowsHostsWrite.close();

// Verify Linux /etc/hosts does *not* contain 1.2.3.4

VERIFY_ARE_NOT_EQUAL(LxsstuLaunchWsl(L"cat /etc/hosts | grep -F 1.2.3.4"), static_cast<DWORD>(0));

// Verify bing.com gets resolved to 1.2.3.4 by dig

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"dig bing.com | grep -F 1.2.3.4"), static_cast<DWORD>(0));

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"dig +tcp bing.com | grep -F 1.2.3.4"), static_cast<DWORD>(0));

}

static void VerifyDnsTunneling(const std::wstring& dnsTunnelingIpAddress)

{

// Verify /etc/resolv.conf is configured with the expected nameserver

VERIFY_ARE_EQUAL(LxsstuLaunchWsl(L"cat /etc/resolv.conf | grep nameserver | grep -F " + dnsTunnelingIpAddress), static_cast<DWORD>(0));

// Verify that we have a working connection.

GuestClient(L"tcp-connect:bing.com:80");

// Verify multiple types of DNS queries

VerifyDnsQueries();

// Verify resolution via Windows /etc/hosts

VerifyEtcHosts();

// Verify DNS tunneling works with systemd enabled

auto revert = EnableSystemd();

GuestClient(L"tcp-connect:bing.com:80");

VerifyDnsQueries();

}

TEST_METHOD(NatDnsTunneling)

{

DNS_TUNNELING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.dnsTunneling = true}));

VerifyDnsTunneling(c_dnsTunnelingDefaultIp);

}

TEST_METHOD(NatDnsTunnelingWithSpecificIp)

{

DNS_TUNNELING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.dnsTunneling = true, .dnsTunnelingIpAddress = L"10.255.255.1"}));

VerifyDnsTunneling(L"10.255.255.1");

}

TEST_METHOD(NatDnsTunnelingVerifySuffixes)

{

DNS_TUNNELING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.dnsTunneling = true}));

VerifyDnsSuffixes();

}

TEST_METHOD(MirroredDnsTunneling)

{

DNS_TUNNELING_TEST_ONLY();

MIRRORED_NETWORKING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.networkingMode = wsl::core::NetworkingMode::Mirrored, .dnsTunneling = true}));

WaitForMirroredStateInLinux();

VerifyDnsTunneling(c_dnsTunnelingDefaultIp);

}

TEST_METHOD(MirroredDnsTunnelingWithSpecificIp)

{

DNS_TUNNELING_TEST_ONLY();

MIRRORED_NETWORKING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig(

{.networkingMode = wsl::core::NetworkingMode::Mirrored, .dnsTunneling = true, .dnsTunnelingIpAddress = L"10.255.255.1"}));

WaitForMirroredStateInLinux();

VerifyDnsTunneling(L"10.255.255.1");

}

TEST_METHOD(MirroredDnsTunnelingVerifySuffixes)

{

DNS_TUNNELING_TEST_ONLY();

MIRRORED_NETWORKING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.networkingMode = wsl::core::NetworkingMode::Mirrored, .dnsTunneling = true}));

WaitForMirroredStateInLinux();

VerifyDnsSuffixes();

}

TEST_METHOD(MirroredWithoutTunnelingVerifySuffixes)

{

MIRRORED_NETWORKING_TEST_ONLY();

WslConfigChange config(LxssGenerateTestConfig({.networkingMode = wsl::core::NetworkingMode::Mirrored, .dnsTunneling = false}));

WaitForMirroredStateInLinux();

VerifyDnsSuffixes();

}