Add port mappings to container list output

src/windows/service/inc/wslaservice.idl

@@ -284,6 +284,8 @@ typedef struct _WSLAContainerEntry
     ULONGLONG StateChangedAt;
     ULONGLONG CreatedAt;
     WSLAContainerState State;
+    [unique, size_is(PortsCount)] WSLAPortMapping* Ports;
+    ULONG PortsCount;
 } WSLAContainerEntry;
 
 typedef enum _WSLAProcessState

src/windows/wslasession/WSLAContainer.cpp

@@ -373,6 +373,11 @@ const std::string& WSLAContainerImpl::Name() const noexcept
     return m_name;
 }
 
+const std::vector<ContainerPortMapping>& WSLAContainerImpl::GetPorts() const noexcept
+{
+    return m_mappedPorts;
+}
+
 void WSLAContainerImpl::GetStateChangedAt(ULONGLONG* Result)
 {
     auto lock = m_lock.lock_shared();

src/windows/wslasession/WSLAContainer.h

@@ -90,6 +90,7 @@ class WSLAContainerImpl
     const std::string& Image() const noexcept;
     const std::string& Name() const noexcept;
     WSLAContainerState State() const noexcept;
+    const std::vector<ContainerPortMapping>& GetPorts() const noexcept;
 
     __requires_lock_held(m_lock) void Transition(WSLAContainerState State) noexcept;
 

src/windows/wslasession/WSLASession.cpp

@@ -1164,6 +1164,17 @@ try
     auto output = wil::make_unique_cotaskmem<WSLAContainerEntry[]>(m_containers.size());
 
     size_t index = 0;
+    auto errorCleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&]() {
+        for (size_t i = 0; i < index; ++i)
+        {
+            for (ULONG j = 0; j < output[i].PortsCount; ++j)
+            {
+                CoTaskMemFree(const_cast<LPSTR>(output[i].Ports[j].BindingAddress));
+            }
+            CoTaskMemFree(output[i].Ports);
+        }
+    });
+
     for (const auto& e : m_containers)
     {
         THROW_HR_IF(E_UNEXPECTED, strcpy_s(output[index].Image, e->Image().c_str()) != 0);
@@ -1172,9 +1183,45 @@ try
         e->GetState(&output[index].State);
         e->GetStateChangedAt(&output[index].StateChangedAt);
         e->GetCreatedAt(&output[index].CreatedAt);
+
+        const auto& ports = e->GetPorts();
+        if (!ports.empty())
+        {
+            auto portsArray = wil::make_unique_cotaskmem<::WSLAPortMapping[]>(ports.size());
+            size_t portsBuilt = 0;
+            auto portsCleanup = wil::scope_exit([&]() {
+                for (size_t j = 0; j < portsBuilt; ++j)
+                {
+                    CoTaskMemFree(const_cast<LPSTR>(portsArray[j].BindingAddress));
+                }
+            });
+
+            for (size_t i = 0; i < ports.size(); ++i)
+            {
+                portsArray[i].HostPort = ports[i].VmMapping.HostPort();
+                portsArray[i].ContainerPort = ports[i].ContainerPort;
+                portsArray[i].Family = ports[i].VmMapping.BindAddress.si_family;
+                portsArray[i].Protocol = ports[i].VmMapping.Protocol;
+                portsArray[i].BindingAddress =
+                    wil::make_unique_ansistring<wil::unique_cotaskmem_ansistring>(ports[i].VmMapping.BindingAddressString().c_str())
+                        .release();
+                portsBuilt++;
+            }
+
+            output[index].Ports = portsArray.release();
+            output[index].PortsCount = static_cast<ULONG>(ports.size());
+            portsCleanup.release();
+        }
+        else
+        {
+            output[index].Ports = nullptr;
+            output[index].PortsCount = 0;
+        }
+
         index++;
     }
 
+    errorCleanup.release();
     *Count = static_cast<ULONG>(m_containers.size());
     *Containers = output.release();
     return S_OK;

src/windows/wslc/services/ContainerModel.h

@@ -57,6 +57,16 @@ struct KillContainerOptions
     int Signal = WSLASignalSIGKILL;
 };
 
+struct PortInformation
+{
+    uint16_t HostPort{};
+    uint16_t ContainerPort{};
+    int Family{};   // AF_INET or AF_INET6
+    int Protocol{}; // IP protocol number (e.g., IPPROTO_TCP or IPPROTO_UDP)
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(PortInformation, HostPort, ContainerPort, Family, Protocol);
+};
+
 struct ContainerInformation
 {
     std::string Id;
@@ -65,8 +75,9 @@ struct ContainerInformation
     WSLAContainerState State;
     ULONGLONG StateChangedAt{};
     ULONGLONG CreatedAt{};
+    std::vector<PortInformation> Ports;
 
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(ContainerInformation, Id, Name, Image, State, StateChangedAt, CreatedAt);
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(ContainerInformation, Id, Name, Image, State, StateChangedAt, CreatedAt, Ports);
 };
 
 struct PublishPort

src/windows/wslc/services/ContainerService.cpp

@@ -246,6 +246,33 @@ std::wstring ContainerService::ContainerStateToString(WSLAContainerState state,
     return std::format(L"{} {}", stateString, FormatRelativeTime(stateChangedAt));
 }
 
+std::wstring ContainerService::FormatPorts(const std::vector<PortInformation>& ports)
+{
+    if (ports.empty())
+    {
+        return L"";
+    }
+
+    std::wstring result;
+    for (size_t i = 0; i < ports.size(); ++i)
+    {
+        const auto& port = ports[i];
+
+        // AF_INET = 2, AF_INET6 = 23
+        std::wstring hostIp = (port.Family == AF_INET6) ? L"[::]" : L"0.0.0.0";
+        std::wstring protocol = (port.Protocol == IPPROTO_UDP) ? L"udp" : L"tcp";
+
+        if (i > 0)
+        {
+            result += L", ";
+        }
+
+        result += std::format(L"{}:{}->{}/{}", hostIp, port.HostPort, port.ContainerPort, protocol);
+    }
+
+    return result;
+}
+
 int ContainerService::Run(Session& session, const std::string& image, ContainerOptions runOptions, IProgressCallback* callback)
 {
     // Create the container
@@ -323,6 +350,25 @@ std::vector<ContainerInformation> ContainerService::List(Session& session)
         entry.Id = current.Id;
         entry.StateChangedAt = current.StateChangedAt;
         entry.CreatedAt = current.CreatedAt;
+
+        // Extract ports
+        for (ULONG i = 0; i < current.PortsCount; ++i)
+        {
+            PortInformation port;
+            port.HostPort = current.Ports[i].HostPort;
+            port.ContainerPort = current.Ports[i].ContainerPort;
+            port.Family = current.Ports[i].Family;
+            port.Protocol = static_cast<int>(current.Ports[i].Protocol);
+            entry.Ports.push_back(port);
+        }
+
+        // Free nested ports array
+        for (ULONG i = 0; i < current.PortsCount; ++i)
+        {
+            CoTaskMemFree(const_cast<LPSTR>(current.Ports[i].BindingAddress));
+        }
+        CoTaskMemFree(current.Ports);
+
         result.emplace_back(std::move(entry));
     }
 

src/windows/wslc/services/ContainerService.h

@@ -21,6 +21,7 @@ struct ContainerService
 {
     static std::wstring ContainerStateToString(WSLAContainerState state, ULONGLONG stateChangedAt = 0);
     static std::wstring FormatRelativeTime(ULONGLONG timestamp);
+    static std::wstring FormatPorts(const std::vector<models::PortInformation>& ports);
     static int Attach(models::Session& session, const std::string& id);
     static int Run(models::Session& session, const std::string& image, models::ContainerOptions options, IProgressCallback* callback);
     static models::CreateContainerResult Create(models::Session& session, const std::string& image, models::ContainerOptions options, IProgressCallback* callback);

src/windows/wslc/tasks/ContainerTasks.cpp

@@ -139,7 +139,7 @@ void ListContainers(CLIExecutionContext& context)
     }
     case FormatType::Table:
     {
-        utils::TablePrinter tablePrinter({L"ID", L"NAME", L"IMAGE", L"CREATED", L"STATUS"});
+        utils::TablePrinter tablePrinter({L"ID", L"NAME", L"IMAGE", L"CREATED", L"STATUS", L"PORTS"});
         for (const auto& container : containers)
         {
             tablePrinter.AddRow({
@@ -148,6 +148,7 @@ void ListContainers(CLIExecutionContext& context)
                 MultiByteToWide(container.Image),
                 ContainerService::FormatRelativeTime(container.CreatedAt),
                 ContainerService::ContainerStateToString(container.State, container.StateChangedAt),
+                ContainerService::FormatPorts(container.Ports),
             });
         }
 

test/windows/WSLATests.cpp

@@ -3143,6 +3143,7 @@ class WSLATests
                 VERIFY_ARE_EQUAL(strlen(containers[i].Id), WSLA_CONTAINER_ID_LENGTH);
                 VERIFY_IS_TRUE(containers[i].StateChangedAt > 0);
                 VERIFY_IS_TRUE(containers[i].CreatedAt > 0);
+                VERIFY_ARE_EQUAL(0, containers[i].PortsCount);
             }
         };
 
@@ -3410,6 +3411,7 @@ class WSLATests
                 VERIFY_ARE_EQUAL(strlen(containers[i].Id), WSLA_CONTAINER_ID_LENGTH);
                 VERIFY_IS_TRUE(containers[i].StateChangedAt > 0);
                 VERIFY_IS_TRUE(containers[i].CreatedAt > 0);
+                VERIFY_ARE_EQUAL(0, containers[i].PortsCount);
             }
         };
 
@@ -3853,6 +3855,45 @@ class WSLATests
 
             ExpectHttpResponse(L"http://[::1]:1234", 200);
 
+            // Verify that ListContainers returns the port data.
+            {
+                wil::unique_cotaskmem_array_ptr<WSLAContainerEntry> containers;
+                VERIFY_SUCCEEDED(session.ListContainers(&containers, containers.size_address<ULONG>()));
+
+                auto freeNestedPorts = wil::scope_exit([&]() noexcept {
+                    for (const auto& entry : containers)
+                    {
+                        for (ULONG j = 0; j < entry.PortsCount; ++j)
+                        {
+                            CoTaskMemFree(const_cast<LPSTR>(entry.Ports[j].BindingAddress));
+                        }
+                        CoTaskMemFree(entry.Ports);
+                    }
+                });
+
+                bool found = false;
+                for (const auto& entry : containers)
+                {
+                    if (std::string(entry.Name) == "test-ports")
+                    {
+                        found = true;
+                        VERIFY_IS_NOT_NULL(entry.Ports);
+                        VERIFY_ARE_EQUAL(2, entry.PortsCount);
+                        VERIFY_ARE_EQUAL(1234, entry.Ports[0].HostPort);
+                        VERIFY_ARE_EQUAL(8000, entry.Ports[0].ContainerPort);
+                        VERIFY_ARE_EQUAL(AF_INET, entry.Ports[0].Family);
+                        VERIFY_ARE_EQUAL(1234, entry.Ports[1].HostPort);
+                        VERIFY_ARE_EQUAL(8000, entry.Ports[1].ContainerPort);
+                        VERIFY_ARE_EQUAL(AF_INET6, entry.Ports[1].Family);
+                        VERIFY_ARE_EQUAL(IPPROTO_TCP, entry.Ports[0].Protocol);
+                        VERIFY_ARE_EQUAL(IPPROTO_TCP, entry.Ports[1].Protocol);
+                        break;
+                    }
+                }
+
+                VERIFY_IS_TRUE(found);
+            }
+
             // Validate that the port cannot be reused while the container is running.
             WSLAContainerLauncher subLauncher(
                 "python:3.12-alpine", "test-ports-2", {"python3", "-m", "http.server"}, {"PYTHONUNBUFFERED=1"}, containerNetworkType);