LibCore: Implement TCPServer on Windows

Author: https://github.com/ayeteadoe
Commit: cc3cabc768
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/5435
Reviewed-by: https://github.com/ADKaster ✅
Reviewed-by: https://github.com/R-Goc

Libraries/LibCore/CMakeLists.txt

@@ -58,11 +58,12 @@ set(SOURCES
 )
 
 if (WIN32)
-    # FIXME: Support UDPServer and TCPServer on Windows
+    # FIXME: Support UDPServer on Windows
     list(APPEND SOURCES
         SocketWindows.cpp
         AnonymousBufferWindows.cpp
-        EventLoopImplementationWindows.cpp)
+        EventLoopImplementationWindows.cpp
+        TCPServerWindows.cpp)
 else()
     list(APPEND SOURCES
         Command.cpp

Libraries/LibCore/EventLoopImplementationWindows.cpp

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2023, Andreas Kling <andreas@ladybird.org>
  * Copyright (c) 2024-2025, stasoid <stasoid@yahoo.com>
+ * Copyright (c) 2025, ayeteadoe <ayeteadoe@gmail.com>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -166,7 +167,7 @@ static int notifier_type_to_network_event(NotificationType type)
 {
     switch (type) {
     case NotificationType::Read:
-        return FD_READ | FD_CLOSE;
+        return FD_READ | FD_CLOSE | FD_ACCEPT;
     case NotificationType::Write:
         return FD_WRITE;
     default:

Libraries/LibCore/SocketWindows.cpp

@@ -2,6 +2,7 @@
  * Copyright (c) 2018-2021, Andreas Kling <andreas@ladybird.org>
  * Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
  * Copyright (c) 2025, stasoid <stasoid@yahoo.com>
+ * Copyright (c) 2025, ayeteadoe <ayeteadoe@gmail.com>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -279,4 +280,15 @@ ErrorOr<NonnullOwnPtr<TCPSocket>> TCPSocket::connect(SocketAddress const& addres
     return socket;
 }
 
+ErrorOr<NonnullOwnPtr<TCPSocket>> TCPSocket::adopt_fd(int fd)
+{
+    if (static_cast<SOCKET>(fd) == INVALID_SOCKET)
+        return Error::from_windows_error();
+
+    auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) TCPSocket()));
+    socket->m_helper.set_fd(fd);
+    socket->setup_notifier();
+    return socket;
+}
+
 }

Libraries/LibCore/SystemWindows.cpp

@@ -5,6 +5,7 @@
  * Copyright (c) 2022, Matthias Zimmerman <matthias291999@gmail.com>
  * Copyright (c) 2023, Cameron Youell <cameronyouell@gmail.com>
  * Copyright (c) 2024-2025, stasoid <stasoid@yahoo.com>
+ * Copyright (c) 2025, ayeteadoe <ayeteadoe@gmail.com>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -109,10 +110,15 @@ ErrorOr<struct stat> fstat(int handle)
     return st;
 }
 
-ErrorOr<void> ioctl(int, unsigned, ...)
+ErrorOr<void> ioctl(int fd, unsigned request, ...)
 {
-    dbgln("Core::System::ioctl() is not implemented");
-    VERIFY_NOT_REACHED();
+    va_list ap;
+    va_start(ap, request);
+    u_long arg = va_arg(ap, FlatPtr);
+    va_end(ap);
+    if (::ioctlsocket(fd, request, &arg) == SOCKET_ERROR)
+        return Error::from_windows_error();
+    return {};
 }
 
 ErrorOr<ByteString> getcwd()
@@ -242,6 +248,42 @@ bool is_socket(int handle)
     return GetFileType(to_handle(handle)) == FILE_TYPE_PIPE;
 }
 
+ErrorOr<void> bind(int sockfd, struct sockaddr const* name, socklen_t name_size)
+{
+    if (::bind(sockfd, name, name_size) == SOCKET_ERROR)
+        return Error::from_windows_error();
+    return {};
+}
+
+ErrorOr<void> listen(int sockfd, int backlog)
+{
+    if (::listen(sockfd, backlog) == SOCKET_ERROR)
+        return Error::from_windows_error();
+    return {};
+}
+
+ErrorOr<int> accept(int sockfd, struct sockaddr* addr, socklen_t* addr_size)
+{
+    auto fd = ::accept(sockfd, addr, addr_size);
+    if (fd == INVALID_SOCKET)
+        return Error::from_windows_error();
+    return fd;
+}
+
+ErrorOr<void> getsockname(int sockfd, struct sockaddr* name, socklen_t* name_size)
+{
+    if (::getsockname(sockfd, name, name_size) == SOCKET_ERROR)
+        return Error::from_windows_error();
+    return {};
+}
+
+ErrorOr<void> setsockopt(int sockfd, int level, int option, void const* value, socklen_t value_size)
+{
+    if (::setsockopt(sockfd, level, option, static_cast<char const*>(value), value_size) == SOCKET_ERROR)
+        return Error::from_windows_error();
+    return {};
+}
+
 ErrorOr<void> socketpair(int domain, int type, int protocol, int sv[2])
 {
     if (domain != AF_LOCAL || type != SOCK_STREAM || protocol != 0)

Libraries/LibCore/TCPServerWindows.cpp

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2025, ayeteadoe <ayeteadoe@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/IPv4Address.h>
+#include <AK/Types.h>
+#include <LibCore/Notifier.h>
+#include <LibCore/Socket.h>
+#include <LibCore/System.h>
+#include <LibCore/TCPServer.h>
+
+#include <AK/Windows.h>
+
+namespace Core {
+
+ErrorOr<NonnullRefPtr<TCPServer>> TCPServer::try_create(EventReceiver* parent)
+{
+    int fd = TRY(Core::System::socket(AF_INET, SOCK_STREAM, 0));
+    ArmedScopeGuard close_fd { [fd]() {
+        MUST(Core::System::close(fd));
+    } };
+
+    int option = 1;
+    TRY(Core::System::ioctl(fd, FIONBIO, option));
+    TRY(Core::System::setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &option, sizeof(option)));
+    if (SetHandleInformation(to_handle(fd), HANDLE_FLAG_INHERIT, 0) == 0)
+        return Error::from_windows_error();
+    close_fd.disarm();
+    return adopt_nonnull_ref_or_enomem(new (nothrow) TCPServer(fd, parent));
+}
+
+TCPServer::TCPServer(int fd, EventReceiver* parent)
+    : EventReceiver(parent)
+    , m_fd(fd)
+{
+    VERIFY(m_fd >= 0);
+}
+
+TCPServer::~TCPServer()
+{
+    MUST(Core::System::close(m_fd));
+}
+
+ErrorOr<void> TCPServer::listen(IPv4Address const& address, u16 port, AllowAddressReuse allow_address_reuse)
+{
+    if (m_listening)
+        return Error::from_errno(EADDRINUSE);
+
+    auto socket_address = SocketAddress(address, port);
+    auto in = socket_address.to_sockaddr_in();
+
+    if (allow_address_reuse == AllowAddressReuse::Yes) {
+        int option = 1;
+        TRY(Core::System::setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)));
+    }
+
+    TRY(Core::System::bind(m_fd, (sockaddr const*)&in, sizeof(in)));
+    TRY(Core::System::listen(m_fd, 5));
+    m_listening = true;
+
+    m_notifier = Notifier::construct(m_fd, Notifier::Type::Read, this);
+    m_notifier->on_activation = [this] {
+        if (on_ready_to_accept)
+            on_ready_to_accept();
+    };
+    return {};
+}
+
+ErrorOr<void> TCPServer::set_blocking(bool blocking)
+{
+    TRY(Core::System::ioctl(m_fd, FIONBIO, blocking ? 0 : 1));
+    return {};
+}
+
+ErrorOr<NonnullOwnPtr<TCPSocket>> TCPServer::accept()
+{
+    VERIFY(m_listening);
+    sockaddr_in in;
+    socklen_t in_size = sizeof(in);
+    int accepted_fd = TRY(Core::System::accept(m_fd, (sockaddr*)&in, &in_size));
+    return TRY(TCPSocket::adopt_fd(accepted_fd));
+}
+
+Optional<IPv4Address> TCPServer::local_address() const
+{
+    if (m_fd == -1)
+        return {};
+
+    sockaddr_in address;
+    socklen_t len = sizeof(address);
+    if (Core::System::getsockname(m_fd, (sockaddr*)&address, &len).is_error())
+        return {};
+
+    return IPv4Address(address.sin_addr.s_addr);
+}
+
+Optional<u16> TCPServer::local_port() const
+{
+    if (m_fd == -1)
+        return {};
+
+    sockaddr_in address;
+    socklen_t len = sizeof(address);
+    if (Core::System::getsockname(m_fd, (sockaddr*)&address, &len).is_error())
+        return {};
+
+    return ntohs(address.sin_port);
+}
+
+}