WS-I: review fixes (connection cap, header timeout, SIGHUP on plain path, HTTP/1.1 only)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ariandClaude Sonnet 5.5 committed 2026-10-16 07:19:14 -04:00
1 parent c5972b762f
commit 9f2bbc7d14
6 files changed
+252 -18

No files matched your search

+166
View File
@@ -497,3 +497,169 @@ async fn sigterm_with_open_tls_connections_exits_promptly() {
tokio::time::sleep(Duration::from_millis(50)).await;
}
}
/// In-process TLS listener with explicit limits.
async fn inproc(
pair: &Pair,
limits: skyg_linux_tracker::tls::Limits,
) -> (u16, tokio_util::sync::CancellationToken, tempdir::Dir) {
use skyg_linux_tracker::{config::Config, server, sources::fake::fake_state, tls};
let dir = tempdir::Dir::new("inproc");
let (c, k) = write_pair(&dir.0, pair);
let mut cfg = Config::default();
cfg.auth.enabled = false;
cfg.server.tls.enabled = true;
cfg.server.tls.cert_file = c;
cfg.server.tls.key_file = k;
let cert = tls::ReloadableCert::load(&cfg.server.tls).unwrap();
let acceptor = tls::acceptor(cert).unwrap();
let state = fake_state(cfg);
let shutdown = state.shutdown.clone();
let app = server::build_router(state);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(tls::serve_tls(
listener,
acceptor,
app,
shutdown.clone(),
limits,
));
(port, shutdown, dir)
}
async fn handshake(
port: u16,
pair: &Pair,
) -> std::io::Result<tokio_rustls::client::TlsStream<TcpStream>> {
let tcp = TcpStream::connect(("127.0.0.1", port)).await?;
connector(pair)
.connect(ServerName::try_from("localhost").unwrap(), tcp)
.await
}
#[tokio::test]
async fn silent_connection_closed_after_header_timeout() {
let pair = gen_pair();
let (port, shutdown, _d) = inproc(
&pair,
skyg_linux_tracker::tls::Limits {
max_conns: 16,
header_timeout: Duration::from_millis(500),
},
)
.await;
let mut c = handshake(port, &pair).await.unwrap();
let start = Instant::now();
let mut buf = [0u8; 256];
let r = tokio::time::timeout(Duration::from_secs(5), async {
loop {
match c.read(&mut buf).await {
Ok(0) | Err(_) => break,
Ok(_) => {}
}
}
})
.await;
assert!(r.is_ok(), "silent post-handshake connection was not closed");
assert!(start.elapsed() < Duration::from_secs(4));
shutdown.cancel();
}
#[tokio::test]
async fn connection_cap_is_enforced() {
let pair = gen_pair();
let (port, shutdown, _d) = inproc(
&pair,
skyg_linux_tracker::tls::Limits {
max_conns: 2,
header_timeout: Duration::from_secs(30),
},
)
.await;
let c1 = handshake(port, &pair).await.unwrap();
let c2 = handshake(port, &pair).await.unwrap();
let third = tokio::time::timeout(Duration::from_millis(800), handshake(port, &pair)).await;
assert!(third.is_err(), "third connection was served beyond the cap");
drop(c1);
let c3 = tokio::time::timeout(Duration::from_secs(5), handshake(port, &pair)).await;
assert!(c3.is_ok(), "slot was not released after a close");
drop(c2);
shutdown.cancel();
}
#[test]
fn sighup_with_tls_disabled_keeps_serving() {
use std::io::{Read, Write};
let dir = tempdir::Dir::new("plainhup");
let port = free_port();
let f = dir.0.join("c.toml");
std::fs::write(
&f,
format!(
"[server]\nport = {port}\n[auth]\ndb_path = {:?}\n",
dir.0.join("db.sqlite").display().to_string()
),
)
.unwrap();
let mut child = Command::new(BIN)
.args(["serve", "--config"])
.arg(&f)
.env_clear()
.stderr(Stdio::null())
.spawn()
.unwrap();
let get = || -> Option<String> {
let mut c = std::net::TcpStream::connect(("127.0.0.1", port)).ok()?;
c.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
.ok()?;
let mut s = String::new();
let _ = c.read_to_string(&mut s);
Some(s)
};
for _ in 0..100 {
if get().is_some_and(|s| s.contains("200 OK")) {
break;
}
std::thread::sleep(Duration::from_millis(100));
}
signal(&child, "-HUP");
std::thread::sleep(Duration::from_millis(500));
assert!(
child.try_wait().unwrap().is_none(),
"SIGHUP killed the process"
);
assert!(get().is_some_and(|s| s.contains("200 OK")));
let _ = child.kill();
let _ = child.wait();
}
#[tokio::test]
async fn mismatched_pair_on_sighup_keeps_old_cert() {
let a = gen_pair();
let b = gen_pair();
let s = start(&a);
let fp_a = https(s.port, &a, "GET", "/healthz", &[], None)
.await
.peer_fp;
// New cert B with old key A: mismatch, old pair kept.
std::fs::write(s.dir.0.join("cert.pem"), &b.cert_pem).unwrap();
signal(&s.child, "-HUP");
tokio::time::sleep(Duration::from_millis(500)).await;
let r = https(s.port, &a, "GET", "/healthz", &[], None).await;
assert_eq!(r.peer_fp, fp_a);
// Completing the rotation (key B) and sending HUP again works.
std::fs::write(s.dir.0.join("key.pem"), &b.key_pem).unwrap();
signal(&s.child, "-HUP");
let mut fp = String::new();
for _ in 0..30 {
tokio::time::sleep(Duration::from_millis(200)).await;
fp = https(s.port, &b, "GET", "/healthz", &[], None)
.await
.peer_fp;
if fp != fp_a {
break;
}
}
assert_ne!(fp, fp_a);
}