Skip to content

Application close code is often lost over the WebSocket (qmux) transport: the client sees Transport("connection closed") #4249

Closed

Description

@fperex

Summary

A moq-tokio server closes a session with an application code, either Session::abort(Error::App(4011)) after accepting or Request::reject(Reject::App(4011)). A moq-tokio client over WebTransport always gets Error::Session(SessionError::App(4011)). The same client over the WebSocket fallback (ws://, qmux) usually gets Error::Transport("connection closed") with no code. Sometimes it gets Error::Session(SessionError::Internal), which is the client's own close code. An application that uses close codes to tell a client why it was disconnected (for example "kicked" or "room full") cannot rely on them over the fallback.

Versions

  • moq-tokio 0.19.17 (default features), moq-net 0.3.5, qmux 0.5.1, rustls 0.23 with aws-lc-rs
  • rustc / cargo 1.96.0, Linux x86_64, server and client in one process on 127.0.0.1

Repro

[dependencies]
moq-tokio = "=0.19.17"
rustls = { version = "0.23", default-features = false, features = ["aws-lc-rs"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }
url = "2"
src/main.rs (about 110 lines)
use std::net::SocketAddr;
use std::time::Duration;

use moq_tokio::moq_net;

type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;

const APP_CODE: u16 = 4011;

#[derive(Clone, Copy, Debug)]
enum Case {
	CloseAfterAccept,
	CloseAfterAcceptThenDrop,
	RejectDuringHandshake,
}

struct Addrs {
	quic: SocketAddr,
	websocket: SocketAddr,
}

async fn start_server(case: Case) -> Result<Addrs> {
	let mut config = moq_tokio::server::Config::default();
	config.listen.bind = Some(moq_tokio::listen::Bind::Addr("127.0.0.1:0".parse()?));
	config.listen.tls.generate = vec!["localhost".to_string()];
	config.websocket = Some(moq_tokio::websocket::Listener::bind("127.0.0.1:0".parse()?).await?);
	let mut listener = config.init()?.listen().await?;
	let addrs = Addrs {
		quic: listener.local_addr()?,
		websocket: listener.websocket_local_addr().expect("websocket listener"),
	};

	tokio::spawn(async move {
		while let Some(request) = listener.accept().await {
			tokio::spawn(async move {
				match case {
					Case::RejectDuringHandshake => {
						request
							.reject(moq_tokio::server::Reject::App(APP_CODE))
							.await
							.expect("reject");
					}
					Case::CloseAfterAcceptThenDrop => {
						let session = request.ok().await.expect("accept");
						tokio::time::sleep(Duration::from_millis(300)).await;
						session.abort(moq_net::Error::App(APP_CODE));
						drop(session);
					}
					Case::CloseAfterAccept => {
						let session = request.ok().await.expect("accept");
						tokio::time::sleep(Duration::from_millis(300)).await;
						session.abort(moq_net::Error::App(APP_CODE));
						tokio::time::sleep(Duration::from_secs(2)).await;
						drop(session);
					}
				}
			});
		}
	});

	Ok(addrs)
}

async fn run_client(url: url::Url, websocket: bool) -> Result<String> {
	let mut config = moq_tokio::connect::Config::default();
	config.tls.insecure = Some(true);
	config.websocket.enabled = Some(websocket);
	let client = config.init(moq_tokio::quic::Config::default())?.with_reconnect(false);

	let connection = client.connect(url);
	let outcome = match tokio::time::timeout(Duration::from_secs(5), connection.established()).await {
		Err(_) => "not established within 5 s".to_string(),
		Ok(Err(err)) => format!("connect failed: {err:?}"),
		Ok(Ok(connection)) => match tokio::time::timeout(Duration::from_secs(5), connection.closed()).await {
			Err(_) => "not closed within 5 s".to_string(),
			Ok(Ok(())) => "closed without an error".to_string(),
			Ok(Err(err)) => format!("{err:?}"),
		},
	};
	Ok(outcome)
}

#[tokio::main]
async fn main() -> Result<()> {
	let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
	let runs: usize = std::env::args().nth(1).map(|n| n.parse().expect("runs")).unwrap_or(20);
	println!("moq-tokio 0.19.17 / moq-net 0.3.5 / qmux 0.5.1, server and client in one process on 127.0.0.1");
	println!("application code {APP_CODE} goes on the wire as {} (App codes are offset by 64)", APP_CODE as u32 + 64);
	println!("{runs} fresh client connections per case and transport; the client's terminal error is tallied");
	for case in [Case::CloseAfterAccept, Case::CloseAfterAcceptThenDrop, Case::RejectDuringHandshake] {
		println!();
		println!("case {case:?}");
		let addrs = start_server(case).await?;
		let quic = addrs.quic.port();
		let ws = addrs.websocket.port();
		let transports = [
			("WebTransport (https://)", format!("https://localhost:{quic}/"), false),
			("raw QUIC (moqt://)", format!("moqt://localhost:{quic}/"), false),
			("WebSocket/qmux (ws://)", format!("ws://127.0.0.1:{ws}/"), true),
		];
		for (label, url, websocket) in transports {
			let mut tally: std::collections::BTreeMap<String, usize> = Default::default();
			for _ in 0..runs {
				let outcome = run_client(url.parse()?, websocket).await?;
				*tally.entry(outcome).or_default() += 1;
			}
			println!("  {label}:");
			for (outcome, count) in tally {
				println!("    {count:>3}/{runs}  {outcome}");
			}
		}
	}
	Ok(())
}

Run with cargo run --release -- 20. It opens 20 one-shot client connections per case and transport and tallies the client's terminal error (Connection::closed()).

Observed

Two runs of the repro above, 20 connections per cell. The loss rate varies between runs because the loss is a race.

server action client transport run 1 run 2
abort(App(4011)), handle kept 2 s WebTransport (https://) 20/20 Session(App(4011)) 20/20 Session(App(4011))
WebSocket (ws://) 13/20 Session(App(4011)), 6/20 Transport("connection closed"), 1/20 Session(Internal) 1/20 Session(App(4011)), 15/20 Transport("connection closed"), 4/20 Session(Internal)
abort(App(4011)), then drop the handle at once WebTransport 20/20 Session(App(4011)) 20/20 Session(App(4011))
WebSocket 3/20 Session(App(4011)), 14/20 Transport("connection closed"), 3/20 Session(Internal) 4/20 Session(App(4011)), 16/20 Transport("connection closed")
Request::reject(Reject::App(4011)) WebTransport 20/20 Session(App(4011)) 20/20 Session(App(4011))
WebSocket 20/20 Transport("connection closed") 3/20 Session(App(4011)), 17/20 Transport("connection closed")

(Run 2 happened while another CPU-heavy process was running on the machine. Full outputs are in output-earlier-run.txt (run 1) and output.txt (run 2).)

Expected

The same result as WebTransport: MoqNet(Session(App(4011))) in every case.

What I checked

  • The server does send the close. With eprintln! added to a local copy of qmux 0.5.1 (diagnostics/qmux-diagnostic-prints.diff), every WebSocket connection shows the server's Session::close(code=4075). The writer then sends APPLICATION_CLOSE code=4075, and the client's qmux reader receives APPLICATION_CLOSE code=4075 while its closed slot is still empty. 4075 is 4011 + 64. Even so, the client reported Transport("connection closed") in 2 of the 3 instrumented reject runs (diagnostics/output-diagnostic-prints.txt).
  • After receiving the peer's APPLICATION_CLOSE, the client calls its own Session::close(code=1). The diagnostics show the client's closed slot ending as connection closed: 1:. Session::close (qmux src/session.rs line 2044) and the reader's Frame::ApplicationClose arm (line 1339) both use watch::Sender::send, which overwrites. The terminal-error helper note_closed keeps the first value instead. This matches the Session(Internal) results, since session code 1 decodes to Internal. Making both of these first-writer-wins (diagnostics/qmux-first-close-wins.diff) removed the Session(Internal) results. It did not remove Transport("connection closed") (diagnostics/output-first-close-wins.txt), so there is at least one more path.
  • Transport("connection closed") is qmux Error::Closed passed through moq-net Error::from_transport (moq-net src/error.rs line 487), which maps any error without a session code to Transport(err.to_string()). In qmux, Error::Closed comes from SessionGuard::drop (src/session.rs line 70, when the last Session handle drops), from Session::closed() when the watch has no value (line 2061), and from accept_uni / accept_bi (lines 1899 and 1903, ok_or(Error::Closed), which ignore the recorded close reason). moq-net publishes the first error that poll_closed yields (Supervisor::poll, moq-net src/session.rs line 301). The moq-tokio adapter implements poll_closed with qmux Session::closed() (moq-tokio src/transport.rs line 193).

Suspected cause

The suspected area is the client-side close path in qmux and how moq-net reads it. In the instrumented runs the peer's APPLICATION_CLOSE reaches the client's qmux reader first. Even so, moq-net on the client ends with either Error::Closed or the client's own code 1, not the peer's 4075.

The overwrite described above explains the Session(Internal) outcome. I have not found which path produces Error::Closed. The places that construct it without consulting the recorded close reason are listed above.

Possible direction:

  • Keep the first terminal reason in qmux's closed slot, so that a received APPLICATION_CLOSE wins over a later local close.
  • Make every path that reports Error::Closed return the recorded reason when there is one.

Related observation (raw QUIC)

Over raw QUIC (moqt://) the client never got Session(App(4011)) in the 120 connections of the two runs. 114 carried the code only as text inside Transport, for example MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)")); 10 of these failed during connect. The other 6 were MoqNet(Transport("connection error: closed")), with no code at all. It looks like the raw QUIC backend's error does not report session_error(). I can file this separately if preferred.

Attached

src/main.rs is inlined above. The remaining project files, run output and diagnostics:

Cargo.toml
[package]
name = "ws-close-repro"
version = "0.1.0"
edition = "2024"
publish = false

[dependencies]
moq-tokio = "=0.19.17"
rustls = { version = "0.23", default-features = false, features = ["aws-lc-rs"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }
url = "2"
run.sh
#!/usr/bin/env bash
# Application close code as seen by a moq-tokio client over WebTransport, raw QUIC and WebSocket.
# Server and client run in one process on 127.0.0.1; the argument is the number of client connections per cell.
set -euo pipefail
cd "$(dirname "$0")"
cargo --version
cargo run --release --locked --quiet -- "${1:-20}" | tee output.txt
output.txt (run 2)
moq-tokio 0.19.17 / moq-net 0.3.5 / qmux 0.5.1, server and client in one process on 127.0.0.1
application code 4011 goes on the wire as 4075 (App codes are offset by 64)
20 fresh client connections per case and transport; the client's terminal error is tallied

case CloseAfterAccept
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     20/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
      1/20  MoqNet(Session(App(4011)))
      4/20  MoqNet(Session(Internal))
     15/20  MoqNet(Transport("connection closed"))

case CloseAfterAcceptThenDrop
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     19/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
      1/20  MoqNet(Transport("connection error: closed"))
  WebSocket/qmux (ws://):
      4/20  MoqNet(Session(App(4011)))
     16/20  MoqNet(Transport("connection closed"))

case RejectDuringHandshake
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     16/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
      4/20  MoqNet(Transport("connection error: closed"))
  WebSocket/qmux (ws://):
      3/20  MoqNet(Session(App(4011)))
     17/20  MoqNet(Transport("connection closed"))
output-earlier-run.txt (run 1)
moq-tokio 0.19.17 / moq-net 0.3.5 / qmux 0.5.1, server and client in one process on 127.0.0.1
application code 4011 goes on the wire as 4075 (App codes are offset by 64)
20 fresh client connections per case and transport; the client's terminal error is tallied

case CloseAfterAccept
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     20/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
     13/20  MoqNet(Session(App(4011)))
      1/20  MoqNet(Session(Internal))
      6/20  MoqNet(Transport("connection closed"))

case CloseAfterAcceptThenDrop
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     20/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
      3/20  MoqNet(Session(App(4011)))
      3/20  MoqNet(Session(Internal))
     14/20  MoqNet(Transport("connection closed"))

case RejectDuringHandshake
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
      9/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
      1/20  MoqNet(Transport("connection error: closed"))
     10/20  connect failed: MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
     20/20  MoqNet(Transport("connection closed"))
diagnostics/run-instrumented.sh
#!/usr/bin/env bash
# Optional: rerun the repro against a local copy of qmux 0.5.1 with the eprintln! lines from
# qmux-diagnostic-prints.diff (or the experiment in qmux-first-close-wins.diff) applied.
set -euo pipefail
cd "$(dirname "$0")"
patch_file="${1:-qmux-diagnostic-prints.diff}"
work=$(mktemp -d)
cp -r ../src ../Cargo.toml ../Cargo.lock "$work/"
(cd "$work" && cargo fetch --locked --quiet)
src=$(ls -d "${CARGO_HOME:-$HOME/.cargo}"/registry/src/*/qmux-0.5.1 | head -n 1)
cp -r "$src" "$work/qmux"
patch -d "$work/qmux" -p1 < "$patch_file"
printf '\n[patch.crates-io]\nqmux = { path = "qmux" }\n' >> "$work/Cargo.toml"
(cd "$work" && cargo run --release --quiet -- "${2:-3}")
rm -rf "$work"
diagnostics/qmux-diagnostic-prints.diff
--- a/src/session.rs	2006-07-23 21:21:28.000000000 -0400
+++ b/src/session.rs	2026-09-26 10:18:45.761298664 -0400
@@ -67,6 +67,7 @@
 
 impl Drop for SessionGuard {
     fn drop(&mut self) {
+        eprintln!("    [qmux diag] last Session handle dropped (closed slot before: {:?})", self.closed.borrow().as_ref().map(|e| e.to_string()));
         note_closed(&self.closed, Error::Closed);
     }
 }
@@ -418,14 +419,17 @@
             tokio::select! {
                 biased;
                 frame = next_outbound(&mut self.control, &mut self.datagrams, &self.outbound) => {
+                    if let Some(Frame::ApplicationClose(close)) = &frame { eprintln!("    [qmux diag] writer: sending APPLICATION_CLOSE code={}", close.code); }
                     match frame {
                         Some(frame) => match self.transmit_or_teardown(frame, &mut closed_rx).await {
                             Transmitted::Ok => {}
                             Transmitted::Failed(err) => {
+                                eprintln!("    [qmux diag] writer: frame write failed: {err}");
                                 self.note_closed(err);
                                 break;
                             }
                             Transmitted::Interrupted => {
+                                eprintln!("    [qmux diag] writer: frame write interrupted by teardown");
                                 interrupted = true;
                                 break;
                             }
@@ -1337,6 +1341,7 @@
             // APPLICATION_CLOSE (0x1d): a graceful, deliberate peer close — surfaces
             // as a clean session close carrying the peer's code/reason.
             Frame::ApplicationClose(close) => {
+                eprintln!("    [qmux diag] {} reader: received APPLICATION_CLOSE code={} (closed slot before: {:?})", if self.is_server { "server" } else { "client" }, close.code, self.closed.borrow().as_ref().map(|e| e.to_string()));
                 self.closed
                     .send(Some(Error::ConnectionClosed {
                         code: close.code,
@@ -2042,6 +2047,7 @@
     }
 
     fn close(&self, code: u32, reason: &str) {
+        eprintln!("    [qmux diag] {} Session::close(code={code})", if self.is_server { "server" } else { "client" });
         // App-initiated: an APPLICATION_CLOSE (0x1d) the peer surfaces as a clean
         // session close carrying our code/reason.
         let frame = ApplicationClose {
diagnostics/output-diagnostic-prints.txt
moq-tokio 0.19.17 / moq-net 0.3.5 / qmux 0.5.1, server and client in one process on 127.0.0.1
application code 4011 goes on the wire as 4075 (App codes are offset by 64)
3 fresh client connections per case and transport; the client's terminal error is tallied

case CloseAfterAccept
  WebTransport (https://):
      3/3  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
      3/3  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] writer: sending APPLICATION_CLOSE code=1
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] writer: sending APPLICATION_CLOSE code=1
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] writer: sending APPLICATION_CLOSE code=1
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
  WebSocket/qmux (ws://):
      3/3  MoqNet(Session(App(4011)))

case CloseAfterAcceptThenDrop
  WebTransport (https://):
      3/3  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
      3/3  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 4075: app code=4011"))
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed"))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 4075: app code=4011"))
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] server Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] writer: sending APPLICATION_CLOSE code=1
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
  WebSocket/qmux (ws://):
      2/3  MoqNet(Session(App(4011)))
      1/3  MoqNet(Transport("connection closed"))

case RejectDuringHandshake
  WebTransport (https://):
      2/3  MoqNet(Session(App(4011)))
      1/3  connect failed: MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
      3/3  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 4075: app code=4011"))
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 4075: app code=4011"))
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
    [qmux diag] server Session::close(code=4075)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 4075: app code=4011"))
    [qmux diag] writer: sending APPLICATION_CLOSE code=4075
    [qmux diag] client reader: received APPLICATION_CLOSE code=4075 (closed slot before: None)
    [qmux diag] client Session::close(code=1)
    [qmux diag] last Session handle dropped (closed slot before: Some("connection closed: 1: "))
  WebSocket/qmux (ws://):
      1/3  MoqNet(Session(App(4011)))
      2/3  MoqNet(Transport("connection closed"))
diagnostics/qmux-first-close-wins.diff
--- a/src/session.rs	2006-07-23 21:21:28.000000000 -0400
+++ b/src/session.rs	2026-09-26 10:15:53.550010946 -0400
@@ -1337,12 +1337,13 @@
             // APPLICATION_CLOSE (0x1d): a graceful, deliberate peer close — surfaces
             // as a clean session close carrying the peer's code/reason.
             Frame::ApplicationClose(close) => {
-                self.closed
-                    .send(Some(Error::ConnectionClosed {
+                note_closed(
+                    &self.closed,
+                    Error::ConnectionClosed {
                         code: close.code,
                         reason: close.reason,
-                    }))
-                    .ok();
+                    },
+                );
             }
             // CONNECTION_CLOSE (0x1c): the peer hit a protocol/transport error —
             // surfaces as an abnormal close, not a clean one.
@@ -2050,12 +2051,13 @@
         };
         let _ = self.outbound_priority.send(frame.into());
 
-        self.closed
-            .send(Some(Error::ConnectionClosed {
+        note_closed(
+            &self.closed,
+            Error::ConnectionClosed {
                 code: VarInt::from(code),
                 reason: reason.to_string(),
-            }))
-            .ok();
+            },
+        );
     }
 
     async fn closed(&self) -> Self::Error {
diagnostics/output-first-close-wins.txt
moq-tokio 0.19.17 / moq-net 0.3.5 / qmux 0.5.1, server and client in one process on 127.0.0.1
application code 4011 goes on the wire as 4075 (App codes are offset by 64)
20 fresh client connections per case and transport; the client's terminal error is tallied

case CloseAfterAccept
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     20/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
      7/20  MoqNet(Session(App(4011)))
     13/20  MoqNet(Transport("connection closed"))

case CloseAfterAcceptThenDrop
  WebTransport (https://):
     20/20  MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
     20/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
      5/20  MoqNet(Session(App(4011)))
     15/20  MoqNet(Transport("connection closed"))

case RejectDuringHandshake
  WebTransport (https://):
      2/20  MoqNet(Session(App(4011)))
     18/20  connect failed: MoqNet(Session(App(4011)))
  raw QUIC (moqt://):
      4/20  MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
      1/20  MoqNet(Transport("connection error: closed"))
     15/20  connect failed: MoqNet(Transport("connection error: closed by peer: app code=4011 (code 4075)"))
  WebSocket/qmux (ws://):
      1/20  MoqNet(Transport("IO error: Connection reset by peer (os error 104)"))
     19/20  MoqNet(Transport("connection closed"))

Cargo.lock is omitted here as a large, mechanically generated pin file; exact dependency versions are in the Versions section above and Cargo.toml, and the lockfile is available on request.

Metadata

Metadata

Assignees

No one assigned

    Labels

    questBeing tracked/planned in a quest. See `quest/`

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions