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/shared/inc/stringshared.h

@@ -13,14 +13,19 @@ Module Name:
 --*/
 
 #pragma once
+#include <algorithm>
+#include <cctype>
+#include <cwctype>
 #include <set>
 #include <vector>
 #include <string>
+#include <string_view>
 #include <sstream>
 #include <fstream>
 #include <gsl/gsl>
 #include <format>
 #include <source_location>
+#include <type_traits>
 
 #ifndef WIN32
 #include <string.h>
@@ -98,6 +103,27 @@ inline std::vector<std::basic_string<T>> Split(const std::basic_string<T>& Strin
     return Output;
 }
 
+template <class T>
+inline std::vector<std::basic_string_view<T>> SplitPreserveEmpty(const std::basic_string_view<T> String, T Separator)
+{
+    std::vector<std::basic_string_view<T>> Output;
+    size_t Start = 0;
+    while (Start <= String.size())
+    {
+        const auto End = String.find(Separator, Start);
+        if (End == std::basic_string_view<T>::npos)
+        {
+            Output.emplace_back(String.substr(Start));
+            break;
+        }
+
+        Output.emplace_back(String.substr(Start, End - Start));
+        Start = End + 1;
+    }
+
+    return Output;
+}
+
 template <class T>
 inline std::vector<std::basic_string<T>> SplitByMultipleSeparators(const std::basic_string<T>& String, const std::basic_string<T>& Separators)
 {
@@ -311,6 +337,21 @@ inline bool IsEqual(const std::wstring_view String1, const std::wstring_view Str
     return (Compare(String1, String2, CaseInsensitive) == String1.size());
 }
 
+template <class T>
+inline bool IsEmptyOrWhitespace(const std::basic_string_view<T> String)
+{
+    return String.empty() || std::all_of(String.begin(), String.end(), [](T Ch) {
+               if constexpr (std::is_same_v<T, wchar_t>)
+               {
+                   return std::iswspace(static_cast<wint_t>(Ch));
+               }
+               else
+               {
+                   return std::isspace(static_cast<unsigned char>(Ch));
+               }
+           });
+}
+
 template <typename T>
 inline std::optional<bool> ParseBool(const T* String)
 {

src/windows/common/WSLCContainerLauncher.cpp

@@ -252,7 +252,12 @@ 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,24 +384,37 @@ 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();
     options.ContainerNetwork.NetworksCount = static_cast<ULONG>(connections.size());
 
     // Aliases for the primary endpoint.
-    std::vector<KeyValuePair> aliasKvps;
-    aliasKvps.reserve(m_primaryNetworkAliases.size());
+    std::vector<KeyValuePair> primarySettings;
+    primarySettings.reserve(m_primaryNetworkAliases.size());
     for (const auto& alias : m_primaryNetworkAliases)
     {
-        aliasKvps.push_back({.Key = "Aliases", .Value = alias.c_str()});
+        primarySettings.push_back({.Key = "Aliases", .Value = alias.c_str()});
     }
 
-    options.ContainerNetwork.Settings = aliasKvps.empty() ? nullptr : aliasKvps.data();
-    options.ContainerNetwork.SettingsCount = static_cast<ULONG>(aliasKvps.size());
+    options.ContainerNetwork.Settings = primarySettings.empty() ? nullptr : primarySettings.data();
+    options.ContainerNetwork.SettingsCount = static_cast<ULONG>(primarySettings.size());
 
     options.MemoryBytes = m_memoryBytes;
     options.NanoCpus = m_nanoCpus;

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;
     }
 
@@ -192,6 +180,18 @@ 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, argName);
+        if (IsEqual(parsed.Name, "host", true))
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkHostModeNotSupportedError());
+        }
+    }
+}
+
 // 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)
 {
@@ -494,6 +494,80 @@ std::tuple<std::string, int64_t, int64_t> ParseUlimit(const std::wstring& input,
     return {WideToMultiByte(input.substr(0, equalsPos)), soft, hard};
 }
 
+ParsedNetworkArgument ParseNetworkArgument(std::wstring_view value, const std::wstring& argName)
+{
+    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 || separator == 0)
+            {
+                throw ArgumentException(Localization::WSLCCLI_NetworkUnsupportedOptionError(argName, std::wstring{part}));
+            }
+
+            const auto key = part.substr(0, separator);
+            const auto optionValue = part.substr(separator + 1);
+            if (key == L"name")
+            {
+                if (IsEmptyOrWhitespace(optionValue))
+                {
+                    throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(argName));
+                }
+
+                if (parsedName)
+                {
+                    throw ArgumentException(Localization::WSLCCLI_NetworkDuplicateNameError(argName));
+                }
+
+                parsedName = true;
+                result.Name = WideToMultiByte(std::wstring{optionValue});
+            }
+            else if (key == L"alias")
+            {
+                if (IsEmptyOrWhitespace(optionValue))
+                {
+                    throw ArgumentException(Localization::WSLCCLI_NetworkAliasEmptyError(argName));
+                }
+
+                result.Aliases.emplace_back(WideToMultiByte(std::wstring{optionValue}));
+            }
+            else
+            {
+                throw ArgumentException(Localization::WSLCCLI_NetworkUnsupportedOptionError(argName, std::wstring{key}));
+            }
+        }
+
+        if (requireName && !parsedName)
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(argName));
+        }
+    };
+
+    if (value.find(L'=') != std::wstring_view::npos)
+    {
+        parseOptions(value, true);
+    }
+    else
+    {
+        if (IsEmptyOrWhitespace(value))
+        {
+            throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(argName));
+        }
+
+        result.Name = WideToMultiByte(std::wstring{value});
+    }
+
+    if (result.Name.empty())
+    {
+        throw ArgumentException(Localization::WSLCCLI_NetworkEmptyError(argName));
+    }
+
+    return result;
+}
+
 std::pair<std::string, std::string> ParseLabel(const std::wstring& value)
 {
     std::pair<std::string, std::string> result{};

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,18 @@ 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);
 
+struct ParsedNetworkArgument
+{
+    std::string Name;
+    std::vector<std::string> Aliases;
+};
+
+ParsedNetworkArgument ParseNetworkArgument(std::wstring_view value, const std::wstring& argName = {});
+
 } // 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;