Support Docker-style network aliases in wslc

localization/strings/en-US/Resources.resw

@@ -2884,6 +2884,14 @@ On first run, creates the file with all settings commented out at their defaults
     <value>Invalid {} value: network name cannot be empty or whitespace</value>
     <comment>{FixedPlaceholder="{}"}Command line arguments, file names and string inserts should not be translated</comment>
   </data>
+  <data name="WSLCCLI_NetworkDuplicateNameError" xml:space="preserve">
+    <value>Invalid {} value: network name can only be specified once</value>
+    <comment>{FixedPlaceholder="{}"}Command line arguments, file names and string inserts should not be translated</comment>
+  </data>
+  <data name="WSLCCLI_NetworkUnsupportedOptionError" xml:space="preserve">
+    <value>Invalid {} value: unsupported network option '{}'</value>
+    <comment>{FixedPlaceholder="{}"}{FixedPlaceholder="{}"}Command line arguments, file names and string inserts should not be translated</comment>
+  </data>
   <data name="WSLCCLI_NetworkHostModeNotSupportedError" xml:space="preserve">
     <value>host mode networking is not supported</value>
   </data>

src/windows/common/WSLCContainerLauncher.cpp

@@ -252,7 +252,13 @@ void wsl::windows::common::WSLCContainerLauncher::AddTmpfs(const std::string& Co
 
 void wsl::windows::common::WSLCContainerLauncher::AddAdditionalNetwork(const std::string& Name)
 {
-    m_additionalNetworks.push_back(Name);
+    AddAdditionalNetwork(Name, {});
+}
+
+void wsl::windows::common::WSLCContainerLauncher::AddAdditionalNetwork(
+    const std::string& Name, const std::vector<std::string>& Aliases)
+{
+    m_additionalNetworks.push_back({.Name = Name, .Aliases = Aliases});
 }
 
 void wsl::windows::common::WSLCContainerLauncher::AddPrimaryNetworkAlias(const std::string& Alias)
@@ -379,9 +385,22 @@ std::pair<HRESULT, std::optional<RunningWSLCContainer>> WSLCContainerLauncher::C
     // Each additional network becomes an entry in NetworkingConfig.EndpointsConfig.
     std::vector<WSLCNetworkConnection> connections;
     connections.reserve(m_additionalNetworks.size());
+    std::vector<std::vector<KeyValuePair>> connectionSettings;
+    connectionSettings.reserve(m_additionalNetworks.size());
     for (const auto& e : m_additionalNetworks)
     {
-        connections.push_back({.NetworkName = e.c_str()});
+        auto& settings = connectionSettings.emplace_back();
+        settings.reserve(e.Aliases.size());
+        for (const auto& alias : e.Aliases)
+        {
+            settings.push_back({.Key = "Aliases", .Value = alias.c_str()});
+        }
+
+        connections.push_back({
+            .NetworkName = e.Name.c_str(),
+            .Settings = settings.empty() ? nullptr : settings.data(),
+            .SettingsCount = static_cast<ULONG>(settings.size()),
+        });
     }
 
     options.ContainerNetwork.Networks = connections.empty() ? nullptr : connections.data();

src/windows/common/WSLCContainerLauncher.h

@@ -63,6 +63,7 @@ class WSLCContainerLauncher : private WSLCProcessLauncher
     void AddLabel(const std::string& Key, const std::string& Value);
     void AddTmpfs(const std::string& ContainerPath, const std::string& Options);
     void AddAdditionalNetwork(const std::string& Name);
+    void AddAdditionalNetwork(const std::string& Name, const std::vector<std::string>& Aliases);
     void AddPrimaryNetworkAlias(const std::string& Alias);
 
     std::pair<HRESULT, std::optional<RunningWSLCContainer>> CreateNoThrow(IWSLCSession& Session, IWarningCallback* WarningCallback = nullptr);
@@ -93,6 +94,12 @@ class WSLCContainerLauncher : private WSLCProcessLauncher
     using WSLCProcessLauncher::SetWorkingDirectory;
 
 private:
+    struct NetworkConnection
+    {
+        std::string Name;
+        std::vector<std::string> Aliases;
+    };
+
     std::string m_image;
     std::string m_name;
     std::vector<WSLCPortMapping> m_ports;
@@ -112,7 +119,7 @@ class WSLCContainerLauncher : private WSLCProcessLauncher
     std::vector<std::string> m_dnsServers;
     std::vector<std::string> m_dnsSearchDomains;
     std::vector<std::string> m_dnsOptions;
-    std::vector<std::string> m_additionalNetworks;
+    std::vector<NetworkConnection> m_additionalNetworks;
     std::vector<std::string> m_primaryNetworkAliases;
     std::vector<WSLCLabel> m_labels;
     std::deque<std::string> m_labelKeys;

src/windows/service/inc/wslc.idl

@@ -207,6 +207,9 @@ typedef struct _WSLCUlimit
 typedef struct _WSLCNetworkConnection
 {
     [string] LPCSTR NetworkName;
+
+    // Settings for this endpoint.
+    // KVP-encoded; duplicate keys are allowed (e.g., multiple "Aliases" entries).
     [unique, size_is(SettingsCount)] const KeyValuePair* Settings;
     ULONG SettingsCount;
 } WSLCNetworkConnection;

src/windows/wslc/arguments/ArgumentValidation.cpp

@@ -114,19 +114,7 @@ void Argument::Validate(const ArgMap& execArgs) const
 
     case ArgType::Network:
     {
-        for (const auto& value : execArgs.GetAll<ArgType::Network>())
-        {
-            if (value.empty() ||
-                std::all_of(value.begin(), value.end(), [](wchar_t c) { return std::iswspace(static_cast<wint_t>(c)); }))
-            {
-                throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(m_name));
-            }
-
-            if (IsEqual(value, L"host", true))
-            {
-                throw ArgumentException(Localization::WSLCCLI_NetworkHostModeNotSupportedError());
-            }
-        }
+        validation::ValidateNetwork(execArgs.GetAll<ArgType::Network>(), m_name);
         break;
     }
 
@@ -166,6 +154,39 @@ static const std::unordered_map<std::wstring, WSLCSignal> SignalMap = {
     {L"SIGPOLL", WSLCSignalSIGPOLL}, {L"SIGPWR", WSLCSignalSIGPWR},     {L"SIGSYS", WSLCSignalSIGSYS},
 };
 
+namespace {
+    std::wstring ToWideString(std::wstring_view value)
+    {
+        return {value.data(), value.size()};
+    }
+
+    std::vector<std::wstring_view> SplitPreserveEmpty(std::wstring_view value, wchar_t delimiter)
+    {
+        std::vector<std::wstring_view> parts;
+        size_t start = 0;
+        while (start <= value.size())
+        {
+            const auto end = value.find(delimiter, start);
+            if (end == std::wstring_view::npos)
+            {
+                parts.emplace_back(value.substr(start));
+                break;
+            }
+
+            parts.emplace_back(value.substr(start, end - start));
+            start = end + 1;
+        }
+
+        return parts;
+    }
+
+    bool IsEmptyOrWhitespace(std::wstring_view value)
+    {
+        return value.empty() ||
+               std::all_of(value.begin(), value.end(), [](wchar_t c) { return std::iswspace(static_cast<wint_t>(c)); });
+    }
+} // namespace
+
 void ValidateWSLCSignalFromString(const std::vector<std::wstring>& values, const std::wstring& argName)
 {
     for (const auto& value : values)
@@ -192,6 +213,113 @@ void ValidateFilter(const std::vector<std::wstring>& values)
     }
 }
 
+void ValidateNetwork(const std::vector<std::wstring>& values, const std::wstring& argName)
+{
+    for (const auto& value : values)
+    {
+        const auto parsed = ParseNetworkArgument(value);
+        if (parsed.Error == NetworkArgumentParseError::EmptyNetworkName)
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(argName));
+        }
+        else if (parsed.Error == NetworkArgumentParseError::EmptyAlias)
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkAliasEmptyError(argName));
+        }
+        else if (parsed.Error == NetworkArgumentParseError::DuplicateNetworkName)
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkDuplicateNameError(argName));
+        }
+        else if (parsed.Error == NetworkArgumentParseError::UnsupportedOption)
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkUnsupportedOptionError(argName, parsed.ErrorValue));
+        }
+
+        if (IsEqual(parsed.Name, L"host", true))
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkHostModeNotSupportedError());
+        }
+    }
+}
+
+ParsedNetworkArgument ParseNetworkArgument(std::wstring_view value)
+{
+    ParsedNetworkArgument result;
+
+    auto parseOptions = [&](std::wstring_view options, bool requireName) {
+        bool parsedName = false;
+        for (const auto part : SplitPreserveEmpty(options, L','))
+        {
+            const auto separator = part.find(L'=');
+            if (separator == std::wstring_view::npos)
+            {
+                result.Error = NetworkArgumentParseError::UnsupportedOption;
+                result.ErrorValue = ToWideString(part);
+                return;
+            }
+
+            const auto key = part.substr(0, separator);
+            const auto optionValue = part.substr(separator + 1);
+            if (key == L"name")
+            {
+                if (parsedName)
+                {
+                    result.Error = NetworkArgumentParseError::DuplicateNetworkName;
+                    result.ErrorValue = ToWideString(key);
+                    return;
+                }
+
+                parsedName = true;
+                result.Name = ToWideString(optionValue);
+            }
+            else if (key == L"alias")
+            {
+                result.Aliases.emplace_back(ToWideString(optionValue));
+            }
+            else
+            {
+                result.Error = NetworkArgumentParseError::UnsupportedOption;
+                result.ErrorValue = ToWideString(key);
+                return;
+            }
+        }
+
+        if (requireName && !parsedName)
+        {
+            result.Error = NetworkArgumentParseError::EmptyNetworkName;
+        }
+    };
+
+    if (value.find(L'=') != std::wstring_view::npos)
+    {
+        parseOptions(value, true);
+    }
+    else
+    {
+        result.Name = ToWideString(value);
+    }
+
+    if (result.Error == NetworkArgumentParseError::None)
+    {
+        if (IsEmptyOrWhitespace(result.Name))
+        {
+            result.Error = NetworkArgumentParseError::EmptyNetworkName;
+            return result;
+        }
+
+        for (const auto& alias : result.Aliases)
+        {
+            if (IsEmptyOrWhitespace(alias))
+            {
+                result.Error = NetworkArgumentParseError::EmptyAlias;
+                return result;
+            }
+        }
+    }
+
+    return result;
+}
+
 // Convert string to WSLCSignal enum - accepts either signal name (e.g., "SIGKILL") or number (e.g., "9")
 WSLCSignal GetWSLCSignalFromString(const std::wstring& input, const std::wstring& argName)
 {
@@ -357,8 +485,8 @@ FormatType GetFormatTypeFromString(const std::wstring& input, const std::wstring
     }
     else
     {
-        throw ArgumentException(std::format(
-            L"Invalid {} value: {} is not a recognized format type. Supported format types are: json, table.", argName, input));
+        throw ArgumentException(
+            std::format(L"Invalid {} value: {} is not a recognized format type. Supported format types are: json, table.", argName, input));
     }
 }
 

src/windows/wslc/arguments/ArgumentValidation.h

@@ -17,6 +17,7 @@ Module Name:
 #include "ContainerModel.h"
 #include "InspectModel.h"
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <vector>
 #include <charconv>
@@ -82,9 +83,29 @@ InspectType GetInspectTypeFromString(const std::wstring& input, const std::wstri
 void ValidateGpus(const std::vector<std::wstring>& values, const std::wstring& argName);
 void ValidateVolumeMount(const std::vector<std::wstring>& values);
 void ValidateFilter(const std::vector<std::wstring>& values);
+void ValidateNetwork(const std::vector<std::wstring>& values, const std::wstring& argName);
 
 std::pair<std::string, std::string> ParseLabel(const std::wstring& value);
 std::pair<std::string, std::string> ParseDriverOption(const std::wstring& value);
 std::pair<std::string, std::string> ParseFilter(const std::wstring& value);
 
+enum class NetworkArgumentParseError
+{
+    None,
+    EmptyNetworkName,
+    EmptyAlias,
+    DuplicateNetworkName,
+    UnsupportedOption,
+};
+
+struct ParsedNetworkArgument
+{
+    std::wstring Name;
+    std::vector<std::wstring> Aliases;
+    NetworkArgumentParseError Error = NetworkArgumentParseError::None;
+    std::wstring ErrorValue;
+};
+
+ParsedNetworkArgument ParseNetworkArgument(std::wstring_view value);
+
 } // namespace wsl::windows::wslc::validation

src/windows/wslc/services/ContainerModel.h

@@ -16,7 +16,9 @@ Module Name:
 
 #include <wslservice.h>
 #include <wslc.h>
+#include <optional>
 #include <string>
+#include <vector>
 
 namespace wsl::windows::wslc::models {
 
@@ -27,6 +29,12 @@ enum class FormatType
     Json,
 };
 
+struct ContainerNetwork
+{
+    std::string Name;
+    std::vector<std::string> Aliases;
+};
+
 struct ContainerOptions
 {
     std::vector<std::string> Arguments;
@@ -51,7 +59,7 @@ struct ContainerOptions
     std::vector<std::string> DnsServers;
     std::vector<std::string> DnsSearchDomains;
     std::vector<std::string> DnsOptions;
-    std::vector<std::string> Networks;
+    std::vector<ContainerNetwork> Networks;
     std::vector<std::string> NetworkAliases;
     std::vector<std::string> Tmpfs;
     std::vector<std::pair<std::string, std::string>> Labels;