launcher: wait for network-online on resume before nudging (Phase 6)

Adds netprobe.{hpp,cpp}: dependency-free TCP reachability with backoff
(tcp_reachable / wait_online). PlayerController::on_resume now waits until the
configured host:port is reachable (default www.youtube.com:443, 8s budget)
before the play nudge, so we don't drive the player into an error state before
the network is back after wake. Bounded and skippable (timeout 0).

Config: resume_probe_host / resume_probe_port / resume_online_timeout_ms in
app.json. player_test gains netprobe coverage (reachable, dead-port timeout is
bounded, timeout-0 skip) and a resume-with-live-probe case. Green under gcc and
ASan+UBSan.

Author: Properrr

config/app.json

@@ -21,7 +21,10 @@
   "power": {
     "$comment": "Phase 6 (doc §2 P6). Play-state is polled over DevTools (needs remote_debugging_port) to hold the logind idle inhibitor while a video plays. Synthetic fallback is off by default.",
     "devtools_poll_ms": 1000,
-    "idle_inhibit_synthetic_fallback": false
+    "idle_inhibit_synthetic_fallback": false,
+    "resume_probe_host": "www.youtube.com",
+    "resume_probe_port": 443,
+    "resume_online_timeout_ms": 8000
   },
   "log": {
     "$comment": "Size-rotating file sink owned by launcher/ (doc §2 P2). Empty log_directory derives from DECKBACK_LOG_DIR / XDG_STATE_HOME at runtime. Lines also mirror to stderr for journald/Steam.",

launcher/CMakeLists.txt

@@ -26,6 +26,7 @@ add_executable(deckback-launcher
   src/cdm_fetcher.cpp
   src/devtools.cpp
   src/player.cpp
+  src/netprobe.cpp
 )
 target_include_directories(deckback-launcher PRIVATE src)
 
@@ -61,7 +62,8 @@ if(BUILD_TESTING)
   target_link_libraries(devtools_test PRIVATE Threads::Threads)
   add_test(NAME devtools_test COMMAND devtools_test)
 
-  add_executable(player_test tests/player_test.cpp src/player.cpp src/devtools.cpp src/log.cpp)
+  add_executable(player_test tests/player_test.cpp src/player.cpp src/devtools.cpp
+                             src/netprobe.cpp src/log.cpp)
   target_include_directories(player_test PRIVATE src tests)
   target_link_libraries(player_test PRIVATE Threads::Threads)
   add_test(NAME player_test COMMAND player_test)

launcher/src/config.cpp

@@ -114,6 +114,10 @@ std::optional<Config> Config::load(const std::string& path) {
   if (auto v = read_int(s, "devtools_poll_ms")) c.devtools_poll_ms = static_cast<int>(*v);
   if (auto v = read_bool(s, "idle_inhibit_synthetic_fallback"))
     c.idle_inhibit_synthetic_fallback = *v;
+  if (auto v = read_string(s, "resume_probe_host")) c.resume_probe_host = *v;
+  if (auto v = read_int(s, "resume_probe_port")) c.resume_probe_port = static_cast<int>(*v);
+  if (auto v = read_int(s, "resume_online_timeout_ms"))
+    c.resume_online_timeout_ms = static_cast<int>(*v);
   return c;
 }
 

launcher/src/config.hpp

@@ -25,6 +25,10 @@ struct Config {
   // to fall back to synthetic activity when no logind idle inhibitor is available.
   int devtools_poll_ms = 1000;
   bool idle_inhibit_synthetic_fallback = false;
+  // On resume, wait until this host:port is reachable before nudging the player (0 ms = skip).
+  std::string resume_probe_host = "www.youtube.com";
+  int resume_probe_port = 443;
+  int resume_online_timeout_ms = 8000;
 
   // Loads and parses the JSON at `path`. Returns nullopt on read/parse failure.
   // NOTE: this is a minimal top-level-key extractor sufficient for app.json's shape; replace with a

launcher/src/main.cpp

@@ -130,8 +130,10 @@ int main(int argc, char** argv) {
   // Cobalt's remote-debugging port; without it we fall back to logging-only hooks.
   std::optional<PlayerController> player;
   if (cfg->remote_debugging_port > 0) {
-    player.emplace(*platform, "127.0.0.1", cfg->remote_debugging_port, cfg->devtools_poll_ms,
-                   cfg->idle_inhibit_synthetic_fallback);
+    player.emplace(
+        *platform, "127.0.0.1", cfg->remote_debugging_port, cfg->devtools_poll_ms,
+        cfg->idle_inhibit_synthetic_fallback,
+        ResumeProbe{cfg->resume_probe_host, cfg->resume_probe_port, cfg->resume_online_timeout_ms});
     platform->on_suspend([&] { player->on_suspend(); });
     platform->on_resume([&] { player->on_resume(); });
     player->start();

launcher/src/netprobe.cpp

@@ -0,0 +1,72 @@
+#include "netprobe.hpp"
+
+#include <fcntl.h>
+#include <netdb.h>
+#include <poll.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <cerrno>
+
+namespace deckback {
+namespace {
+
+long mono_ms() {
+  timespec ts{};
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return ts.tv_sec * 1000L + ts.tv_nsec / 1'000'000L;
+}
+
+}  // namespace
+
+bool tcp_reachable(const std::string& host, int port, int timeout_ms) {
+  addrinfo hints{};
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  addrinfo* res = nullptr;
+  const std::string port_s = std::to_string(port);
+  if (getaddrinfo(host.c_str(), port_s.c_str(), &hints, &res) != 0 || !res) return false;
+
+  bool ok = false;
+  for (addrinfo* ai = res; ai && !ok; ai = ai->ai_next) {
+    int fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+    if (fd < 0) continue;
+    int flags = fcntl(fd, F_GETFL, 0);
+    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+    int rc = connect(fd, ai->ai_addr, ai->ai_addrlen);
+    if (rc == 0) {
+      ok = true;
+    } else if (errno == EINPROGRESS) {
+      pollfd pfd{fd, POLLOUT, 0};
+      if (poll(&pfd, 1, timeout_ms) > 0 && (pfd.revents & POLLOUT)) {
+        int err = 0;
+        socklen_t l = sizeof err;
+        getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &l);
+        ok = (err == 0);
+      }
+    }
+    close(fd);
+  }
+  freeaddrinfo(res);
+  return ok;
+}
+
+bool wait_online(const std::string& host, int port, int max_ms) {
+  if (max_ms <= 0) return true;
+  const long deadline = mono_ms() + max_ms;
+  int backoff = 200;
+  for (;;) {
+    int remaining = static_cast<int>(deadline - mono_ms());
+    if (remaining <= 0) return false;
+    if (tcp_reachable(host, port, remaining < 1000 ? remaining : 1000)) return true;
+    int nap = backoff < remaining ? backoff : remaining;
+    if (nap > 0) {
+      timespec ts{nap / 1000, (nap % 1000) * 1'000'000L};
+      nanosleep(&ts, nullptr);
+    }
+    backoff = backoff < 1600 ? backoff * 2 : 1600;
+  }
+}
+
+}  // namespace deckback

launcher/src/netprobe.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <string>
+
+namespace deckback {
+
+// Dependency-free network-reachability probes for the Phase 6 resume path (doc §2 P6): after wake
+// we want the network back before nudging the player, so we don't drive it into an error state.
+
+// One non-blocking TCP connect attempt to host:port, bounded by timeout_ms. True if it connects.
+bool tcp_reachable(const std::string& host, int port, int timeout_ms);
+
+// Poll tcp_reachable with backoff until it succeeds or max_ms elapses. max_ms <= 0 disables the
+// wait (returns true immediately). Returns whether the host became reachable within the budget.
+bool wait_online(const std::string& host, int port, int max_ms);
+
+}  // namespace deckback

launcher/src/player.cpp

@@ -4,6 +4,7 @@
 #include <format>
 
 #include "log.hpp"
+#include "netprobe.hpp"
 #include "platform.hpp"
 
 namespace deckback {
@@ -27,11 +28,12 @@ constexpr const char* kPlayExpr =
 }  // namespace
 
 PlayerController::PlayerController(Platform& platform, std::string host, int port, int poll_ms,
-                                   bool synthetic_fallback)
+                                   bool synthetic_fallback, ResumeProbe resume_probe)
     : platform_(platform),
       client_(std::move(host), port),
       poll_ms_(poll_ms < 100 ? 100 : poll_ms),
-      synthetic_fallback_(synthetic_fallback) {}
+      synthetic_fallback_(synthetic_fallback),
+      resume_probe_(std::move(resume_probe)) {}
 
 PlayerController::~PlayerController() { stop(); }
 
@@ -91,6 +93,14 @@ std::optional<double> PlayerController::on_suspend() {
 }
 
 bool PlayerController::on_resume() {
+  if (resume_probe_.timeout_ms > 0) {
+    if (wait_online(resume_probe_.host, resume_probe_.port, resume_probe_.timeout_ms))
+      info(std::format("player: network reachable ({}:{}) — nudging playback", resume_probe_.host,
+                       resume_probe_.port));
+    else
+      warn(std::format("player: network still down after {} ms — nudging anyway",
+                       resume_probe_.timeout_ms));
+  }
   const bool ok = client_.eval_void(kPlayExpr);
   info(ok ? "player: resume nudge sent" : "player: resume nudge failed (engine unreachable?)");
   return ok;

launcher/src/player.hpp

@@ -12,6 +12,13 @@ namespace deckback {
 
 class Platform;
 
+// On resume, wait until host:port is reachable before nudging the player (timeout_ms 0 = skip).
+struct ResumeProbe {
+  std::string host;
+  int port = 443;
+  int timeout_ms = 0;
+};
+
 // Drives the Phase 6 power contract through the DevTools bridge (doc §2 P6):
 //   * a background thread polls the player's play-state and holds/releases the logind idle
 //     inhibitor via Platform so the screen never dims mid-video;
@@ -23,7 +30,7 @@ class Platform;
 class PlayerController {
  public:
   PlayerController(Platform& platform, std::string host, int port, int poll_ms,
-                   bool synthetic_fallback);
+                   bool synthetic_fallback, ResumeProbe resume_probe = ResumeProbe{});
   ~PlayerController();
 
   PlayerController(const PlayerController&) = delete;
@@ -48,6 +55,7 @@ class PlayerController {
   DevToolsClient client_;
   int poll_ms_;
   bool synthetic_fallback_;
+  ResumeProbe resume_probe_;
   bool warned_synthetic_ = false;
 
   std::thread thread_;

launcher/tests/player_test.cpp

@@ -7,6 +7,7 @@
 #include <thread>
 
 #include "fake_cdp_server.hpp"
+#include "netprobe.hpp"
 #include "platform.hpp"
 
 using namespace deckback;
@@ -87,13 +88,41 @@ void test_thread_lifecycle() {
   pc.stop();  // idempotent
 }
 
+// The network probe: a listening port is reachable; a dead port times out within its budget.
+void test_netprobe() {
+  testing::FakeServer server;  // a live loopback listener
+  assert(tcp_reachable("127.0.0.1", server.port(), 500));
+  assert(wait_online("127.0.0.1", server.port(), 2000));
+
+  // Dead port: wait_online must return false and respect its budget (not hang).
+  auto t0 = std::chrono::steady_clock::now();
+  assert(!wait_online("127.0.0.1", 8, 600));
+  auto elapsed =
+      std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - t0)
+          .count();
+  assert(elapsed < 3000);  // bounded by the 600ms budget (+ backoff slack), nowhere near hanging
+
+  assert(wait_online("127.0.0.1", 8, 0));  // timeout 0 disables the wait -> immediate true
+}
+
+// Resume with a network probe pointed at a live port still nudges playback.
+void test_resume_with_probe() {
+  testing::FakeServer server;
+  FakePlatform plat;
+  PlayerController pc(plat, "127.0.0.1", server.port(), 1000, false,
+                      ResumeProbe{"127.0.0.1", server.port(), 2000});
+  assert(pc.on_resume() == true);
+}
+
 }  // namespace
 
 int main() {
   test_poll_tracks_playstate();
   test_suspend_resume_hooks();
   test_engine_unreachable();
   test_thread_lifecycle();
+  test_netprobe();
+  test_resume_with_probe();
   std::puts("player_test: ok");
   return 0;
 }