FEATURE-ci-v3-runtime-green: poll QUIC fixtures through the host helper on Windows

Author: etr

ChangeLog

@@ -1,4 +1,6 @@
 Version 3.0.0 - 2026-10-10
+	Poll the QUIC interop endpoint and UDP fixture through the shared
+		cross-platform host helper on Windows.
 	Open the QUIC interop test keylog with Windows-compatible flags
 		instead of O_NOFOLLOW/O_CLOEXEC/fchmod.
 	Complete the first FreeBSD native make-check exposure: portable

specs/tasks/FEATURE-ci-v3-runtime-green.md

@@ -179,3 +179,10 @@ Full local `make check -j1` (TLS=no, g++ 15.2, WSL2): 232/235 pass, 2 platform s
 - [x] Evidence (mingw64 job 124232738670, Windows acceptance job 124233097485, both at b080f744): with stage 10 in place the mingw64 package lane printed `PASS installed consumer native TLS=no` — the entire installed tls-no matrix including public-tls and public-http2 passed on Windows for the first time. The tls-yes lane then failed building `libquic_interop_provider_a`: `src/detail/tls_session.cpp:127/129` use `O_NOFOLLOW`, `O_CLOEXEC` and `fchmod`, none of which exist on Windows.
 - [x] Repair: `open_keylog()` gains a `_WIN32` branch using `_O_NOINHERIT` (the close-on-exec analog) and dropping `fchmod` (the creating open already owns the file); the POSIX branch is unchanged. This is the only site in `src/` using those identifiers (`quic_tls_session.cpp` is clean). POSIX-branch syntax check with the interop define passes locally; cpplint clean.
 - [ ] Full Windows tls-yes CI evidence past the interop provider build (SNI/rotation scenarios and the tls-yes public audits remain first-exposure).
+
+## Stage 13: Windows QUIC fixture polls (2026-10-30)
+
+- [x] Evidence (mingw64 job at db7cefec, 41112829610): with the stage-12 keylog fix the tls-yes `make -j2` advanced past `libquic_interop_provider_a` and failed at the next noinst program: `test/integ/quic_interop_endpoint.cpp:3: 'poll.h' file not found`.
+- [x] Repair: the interop endpoint's hand-rolled poll loop now goes through the shared `examples/host_poll.hpp` helper (WSAPoll on Windows, the same contract every external-loop consumer uses), preserving the connection-deadline folding and the one-second park bound; `chmod` of the log directory is POSIX-only. `test/integ/http3_udp_fixture.cpp` — the next `poll.h` includer in the same build set — takes a `_WIN32` branch on the same helper while its POSIX stdin-poll path stays byte-identical (the stdin command channel is driven only by the POSIX parity lanes).
+- [x] Local gates: both files pass cpplint and `g++ -std=c++20 -fsyntax-only` with the full build flags; `integ/http3_full_gate_runner_test.py` 27/27 (it drives the gate runner that builds and runs these fixtures).
+- [ ] Full Windows tls-yes CI evidence past the QUIC fixtures.

test/integ/http3_udp_fixture.cpp

@@ -1,5 +1,9 @@
 /* Copyright (C) 2026 Sebastiano Merlino; SPDX-License-Identifier: LGPL-2.1-or-later */
+#if defined(_WIN32)
+#include "../../examples/host_poll.hpp"
+#else
 #include <poll.h>
+#endif
 #include <unistd.h>
 
 #include <algorithm>
@@ -376,14 +380,22 @@ struct fixture {
         // its successful completion is committed in the next owner turn.
         if (executor.pending() || (send && send->state()->applied()) || receive->state()->applied()) return true;
         auto snapshot = backend.interests();
-        if (snapshot.wake) snapshot.sockets.push_back(*snapshot.wake);
-        std::vector<pollfd> descriptors{{STDIN_FILENO, POLLIN, 0}};
-        for (auto& interest : snapshot.sockets)
-            descriptors.push_back({static_cast<int>(interest.handle.value), static_cast<std::int16_t>((interest.readable ? POLLIN : 0) | (interest.writable ? POLLOUT : 0)), 0});
         auto due = lifetime;
         for (auto& [id, connection] : connections)
             if (auto deadline = connection->deadline()) due = std::min(due, *deadline);
         if (snapshot.next_deadline) due = std::min(due, *snapshot.next_deadline);
+#if defined(_WIN32)
+        // The stdin command channel is driven only by the POSIX parity
+        // lanes; on Windows the fixture builds but never serves commands.
+        const auto park = std::min(due, clock_type::now() + std::chrono::milliseconds(1000));
+        if (!backend.dispatch(v3_host::wait(snapshot, park), clock_type::now()).ok())
+            throw std::runtime_error("backend dispatch failed");
+        return true;
+#else
+        if (snapshot.wake) snapshot.sockets.push_back(*snapshot.wake);
+        std::vector<pollfd> descriptors{{STDIN_FILENO, POLLIN, 0}};
+        for (auto& interest : snapshot.sockets)
+            descriptors.push_back({static_cast<int>(interest.handle.value), static_cast<std::int16_t>((interest.readable ? POLLIN : 0) | (interest.writable ? POLLOUT : 0)), 0});
         int timeout = std::max<std::int64_t>(std::int64_t{0}, std::chrono::ceil<std::chrono::milliseconds>(due - clock_type::now()).count());
         if (poll(descriptors.data(), descriptors.size(), timeout) < 0) throw std::runtime_error("poll failed");
         if (descriptors[0].revents & (POLLIN | POLLHUP)) {
@@ -401,6 +413,7 @@ struct fixture {
             }
         if (!backend.dispatch(events, clock_type::now()).ok()) throw std::runtime_error("backend dispatch failed");
         return true;
+#endif
     }
 };
 }  // namespace

test/integ/quic_interop_endpoint.cpp

@@ -1,6 +1,5 @@
 /* Copyright (C) 2026 Sebastiano Merlino; SPDX-License-Identifier: LGPL-2.1-or-later */
 #include <openssl/pem.h>
-#include <poll.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <csignal>
@@ -20,6 +19,7 @@
 #include <httpserver/concurrency/resume_signal.hpp>
 #include <httpserver/detail/io_poll_backend.hpp>
 #include "../support/http3_network_owner.hpp"
+#include "../../examples/host_poll.hpp"
 #include "../unit/io_udp_backend_contract.hpp"
 namespace {
 volatile std::sig_atomic_t stopping = 0;
@@ -294,30 +294,16 @@ struct fixture {
         if (executor.pending() || (send && send->state()->applied()) || receive->state()->applied())
             return true;
         auto snapshot = backend.interests();
-        if (snapshot.wake)
-            snapshot.sockets.push_back(*snapshot.wake);
-        std::vector<pollfd> descriptors;
-        for (auto& interest : snapshot.sockets)
-            descriptors.push_back(
-                {static_cast<int>(interest.handle.value), static_cast<std::int16_t>((interest.readable ? POLLIN : 0) | (interest.writable ? POLLOUT : 0)), 0});
         auto due = lifetime;
         for (auto& [id, connection] : connections)
             if (auto deadline = connection->deadline())
                 due = std::min(due, *deadline);
         if (snapshot.next_deadline)
             due = std::min(due, *snapshot.next_deadline);
-        int timeout = std::min<std::int64_t>(1000, std::max<std::int64_t>(std::int64_t{0}, std::chrono::ceil<std::chrono::milliseconds>(due - clock_type::now()).count()));
-        if (poll(descriptors.data(), descriptors.size(), timeout) < 0 && !stopping)
-            throw std::runtime_error("poll failed");
-        std::vector<h::server::readiness_event> events;
-        for (unsigned i = 0; i < snapshot.sockets.size(); ++i)
-            if (descriptors[i].revents) {
-                auto& interest = snapshot.sockets[i];
-                auto revents = descriptors[i].revents;
-                events.push_back({interest.key, interest.generation, static_cast<bool>(revents & POLLIN), static_cast<bool>(revents & POLLOUT),
-                                  static_cast<bool>(revents & POLLHUP), static_cast<bool>(revents & (POLLERR | POLLNVAL))});
-            }
-        if (!backend.dispatch(events, clock_type::now()).ok())
+        // Park at most one second past the earliest due work; the shared
+        // host helper owns the platform poll (WSAPoll on Windows).
+        const auto park = std::min(due, clock_type::now() + std::chrono::milliseconds(1000));
+        if (!backend.dispatch(v3_host::wait(snapshot, park), clock_type::now()).ok())
             throw std::runtime_error("backend dispatch failed");
         return true;
     }
@@ -333,7 +319,9 @@ int main() {
         hqnet::files root_check(env("LIBHTTPSERVER_INTEROP_WWW", "/www"));
         const auto logs = env("LIBHTTPSERVER_INTEROP_LOGS", "/logs");
         std::filesystem::create_directories(logs);
+#if !defined(_WIN32)
         if (chmod(logs.c_str(), 0700) != 0) throw std::runtime_error("log permissions failed");
+#endif
         const auto pcap = logs + "/packets.pcap";
         std::signal(SIGTERM, stop);
         std::signal(SIGINT, stop);