@desklink/host 0.5.8 → 0.5.10

package/engine/src/mac.rs

@@ -39,6 +39,8 @@ unsafe extern "C" {
     pub(crate) fn CGPreflightScreenCaptureAccess() -> bool;
     pub(crate) fn CGPreflightPostEventAccess() -> bool;
     pub(crate) fn CGRequestPostEventAccess() -> bool;
+    pub(crate) fn CGPreflightListenEventAccess() -> bool;
+    pub(crate) fn CGRequestListenEventAccess() -> bool;
     fn CGGetActiveDisplayList(max: u32, displays: *mut DisplayId, count: *mut u32) -> i32;
     fn CGMainDisplayID() -> DisplayId;
     fn CGDisplayPixelsWide(display: DisplayId) -> usize;
@@ -713,6 +715,12 @@ pub fn run() -> i32 {
                 let _ = crate::input::request_access();
                 println!("If the Accessibility alert did not open, allow {} in System Settings › Privacy & Security › Accessibility.", tcc_responsible_app_name());
             }
+            if crate::input::observe_probe().is_ok() {
+                println!("Input Monitoring permission is already granted to {}.", tcc_responsible_app_name());
+            } else {
+                let _ = crate::input::request_observe_access();
+                println!("If the Input Monitoring alert did not open, allow {} in System Settings › Privacy & Security › Input Monitoring.", tcc_responsible_app_name());
+            }
         }
         _ => println!("desklink-host {}\nUSAGE: desklink-host [serve|capabilities|capture-probe|encode-probe|setup-input|version]", env!("CARGO_PKG_VERSION")),
     }

package/engine/src/main.rs

@@ -26,7 +26,7 @@ mod clipboard;
 mod clipboard;
 #[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
 mod convert;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 mod cursor;
 #[cfg(target_os = "linux")]
 mod encoder;
@@ -72,6 +72,8 @@ mod keymap;
 mod keymap;
 #[cfg(target_os = "macos")]
 mod mac;
+#[cfg(any(target_os = "linux", all(any(target_os = "macos", target_os = "windows"), desklink_vpx)))]
+mod observe;
 #[cfg(any(
     target_os = "linux",
     all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
@@ -136,7 +138,14 @@ use tokio::sync::mpsc as tokio_mpsc;
 unsafe extern "C" {
     fn desklink_point_overlay_main(display: *const std::ffi::c_char) -> i32;
     fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
-    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32, desktop: i32) -> i32;
+    fn desklink_agent_overlay_wayland(
+        source_w: i32,
+        source_h: i32,
+        desktop: i32,
+        origin_known: i32,
+        origin_x: i32,
+        origin_y: i32,
+    ) -> i32;
     fn desklink_wayland_layer_shell_available() -> i32;
     fn desklink_point_overlay_wayland(
         w: i32,
@@ -212,7 +221,21 @@ fn main() {
                 2
             } else {
                 let desktop = i32::from(args.get(3).map(String::as_str) == Some("desktop"));
-                unsafe { desklink_agent_overlay_wayland(width, height, desktop) }
+                // A desktop cue respawned after a press names the layout
+                // point that chose its output: `w h desktop ox oy`.
+                let (known, ox, oy) = match (args.get(4), args.get(5)) {
+                    (Some(x), Some(y)) => match (x.parse(), y.parse()) {
+                        (Ok(x), Ok(y)) => (1, x, y),
+                        _ => (0, 0, 0),
+                    },
+                    _ => (0, 0, 0),
+                };
+                let (known, ox, oy) = if desktop == 1 {
+                    (known, ox, oy)
+                } else {
+                    (0, 0, 0)
+                };
+                unsafe { desklink_agent_overlay_wayland(width, height, desktop, known, ox, oy) }
             }
         }
         "capabilities" => {
@@ -542,6 +565,47 @@ async fn serve() -> Result<()> {
     Ok(())
 }
 
+/// Splits the requested ICE servers into the configuration the peer gets and
+/// the URLs this engine leaves out. Every URL the WebRTC stack can dial goes
+/// through with its entry's username and credential — all of an entry's URLs,
+/// so a fallback behind an unreachable primary still gathers candidates. A
+/// TURN URL whose transport is not UDP is one the stack cannot dial, so it is
+/// skipped here and reported once by the caller, never dropped silently. A
+/// URL the parser cannot read is forwarded unchanged: the peer connection
+/// owns that verdict and refuses the open in its own words.
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
+fn usable_ice_servers(
+    servers: Vec<protocol::IceServerParam>,
+) -> (
+    Vec<(Vec<String>, Option<String>, Option<String>)>,
+    Vec<String>,
+) {
+    use rtc_ice::url::{ProtoType, SchemeType, Url};
+    let mut usable = Vec::new();
+    let mut skipped = Vec::new();
+    for server in servers {
+        let mut urls = Vec::with_capacity(server.urls.len());
+        for url in server.urls {
+            let undialable = Url::parse_url(&url).is_ok_and(|parsed| {
+                matches!(parsed.scheme, SchemeType::Turn | SchemeType::Turns)
+                    && parsed.proto != ProtoType::Udp
+            });
+            if undialable {
+                skipped.push(url);
+            } else {
+                urls.push(url);
+            }
+        }
+        if !urls.is_empty() {
+            usable.push((urls, server.username, server.credential));
+        }
+    }
+    (usable, skipped)
+}
+
 #[cfg(any(
     target_os = "linux",
     all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
@@ -604,6 +668,13 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.input",
             serde_json::json!({ "sessionId": session_id, "input": input }),
         ),
+        session::SessionEvent::Observed {
+            timestamp_us,
+            input,
+        } => (
+            "session.input.observed",
+            serde_json::json!({ "sessionId": session_id, "timestamp_us": timestamp_us, "input": input }),
+        ),
         session::SessionEvent::KeyframeRequest { generation } => (
             "session.keyframeRequest",
             serde_json::json!({ "sessionId": session_id, "generation": generation }),
@@ -616,6 +687,10 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.capture.stopped",
             serde_json::json!({ "sessionId": session_id, "reason": reason }),
         ),
+        session::SessionEvent::IceServerSkipped { url } => (
+            "session.iceServerSkipped",
+            serde_json::json!({ "sessionId": session_id, "url": url }),
+        ),
         session::SessionEvent::Revoked { reason, code } => (
             "session.revoked",
             serde_json::json!({ "sessionId": session_id, "reason": reason, "code": code }),
@@ -672,6 +747,7 @@ async fn dispatch(
             }
             let params: protocol::OpenParams = serde_json::from_value(request.params.clone())
                 .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            let usable = usable_ice_servers(params.ice_servers);
             let open = session::OpenRequest {
                 source: params.source,
                 cursor: params.cursor,
@@ -685,16 +761,8 @@ async fn dispatch(
                 agent_indicator: params.agent_indicator,
                 local_frames: params.local_frames,
                 audio: params.audio,
-                ice_servers: params
-                    .ice_servers
-                    .into_iter()
-                    .filter_map(|server| {
-                        server
-                            .urls
-                            .first()
-                            .map(|url| (url.clone(), server.username, server.credential))
-                    })
-                    .collect(),
+                observe_input: params.observe_input,
+                ice_servers: usable.0,
             };
             let session = session::Session::open(open, events.clone())
                 .await
@@ -712,7 +780,17 @@ async fn dispatch(
                 "cursor": session.cursor_info(),
                 "agentIndicator": session.agent_indicator(),
                 "audio": session.audio_info(),
+                "inputObservation": session.observation_info(),
             });
+            // URLs the WebRTC stack cannot dial were left out of the peer's
+            // configuration; each skipped one is named once instead of
+            // vanishing from a multi-URL entry without a trace.
+            for url in usable.1 {
+                let _ = events.send(session::Notice {
+                    session_id: session.id().to_owned(),
+                    event: session::SessionEvent::IceServerSkipped { url },
+                });
+            }
             *current = Some(session);
             Ok(result)
         }
@@ -947,6 +1025,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn the_skipped_ice_server_warning_names_the_url_once() {
+        let line = render_event(session::Notice {
+            session_id: String::from("session-1"),
+            event: session::SessionEvent::IceServerSkipped {
+                url: String::from("turn:turn.example.com:3478?transport=tcp"),
+            },
+        })
+        .expect("a skipped-URL warning is renderable");
+        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(parsed["event"], "session.iceServerSkipped");
+        assert_eq!(
+            parsed["params"],
+            serde_json::json!({
+                "sessionId": "session-1",
+                "url": "turn:turn.example.com:3478?transport=tcp"
+            })
+        );
+    }
+
     #[tokio::test]
     async fn the_state_notification_carries_exactly_what_the_document_promises() {
         let line = render_event(session::Notice {

package/engine/src/observe.rs

@@ -0,0 +1,94 @@
+//! Passive observation of the desktop's own pointer buttons, cursor and keys.
+//!
+//! The engine only listens; events are the ones `docs/PROTOCOL.md` describes. A
+//! platform that cannot observe says why with a typed reason and delivers nothing.
+
+use crate::protocol::{CursorPosition, ObservedInput};
+use std::sync::Arc;
+
+#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
+pub enum Observation {
+    Input {
+        timestamp_us: u64,
+        input: ObservedInput,
+    },
+    Cursor(CursorPosition),
+}
+
+pub type Sink = Arc<dyn Fn(Observation) + Send + Sync + 'static>;
+
+/// Keeps an observer running; dropping it stops it.
+#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
+pub struct Tap {
+    pub mechanism: &'static str,
+    pub guard: Box<dyn Send>,
+}
+
+/// Why the desktop's input cannot be observed, and what the owner can do.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Unavailable {
+    pub code: &'static str,
+    pub reason: String,
+    pub remedy: String,
+}
+
+#[cfg(target_os = "macos")]
+pub fn start(display_id: u32, pixels: (usize, usize), sink: Sink) -> Result<Tap, Unavailable> {
+    crate::input::observe(display_id, pixels, sink)
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn start(_: u32, _: (usize, usize), _: Sink) -> Result<Tap, Unavailable> {
+    Err(Unavailable {
+        code: "unsupported-platform",
+        reason: String::from("observing the desktop's own input is only implemented on macOS"),
+        remedy: String::from("none: this platform delivers no input events"),
+    })
+}
+
+/// The `inputObservation` member of the `session.open` reply.
+pub fn status(result: Option<&Result<Tap, Unavailable>>) -> serde_json::Value {
+    match result {
+        None => serde_json::json!({"observing": false}),
+        Some(Ok(tap)) => serde_json::json!({"observing": true, "mechanism": tap.mechanism}),
+        Some(Err(error)) => serde_json::json!({
+            "observing": false,
+            "code": error.code,
+            "reason": error.reason,
+            "remedy": error.remedy,
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[cfg(not(target_os = "macos"))]
+    fn a_platform_that_cannot_observe_says_so_and_delivers_nothing() {
+        let delivered = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let counted = delivered.clone();
+        let sink: Sink = Arc::new(move |_| {
+            counted.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        });
+        let refused = start(0, (1920, 1080), sink);
+        let status = status(Some(&refused));
+        assert_eq!(status["observing"], false);
+        assert_eq!(status["code"], "unsupported-platform");
+        assert_eq!(delivered.load(std::sync::atomic::Ordering::SeqCst), 0);
+    }
+
+    #[test]
+    fn a_refusal_carries_its_code_reason_and_remedy() {
+        let refused: Result<Tap, Unavailable> = Err(Unavailable {
+            code: "missing-input-monitoring",
+            reason: String::from("reason"),
+            remedy: String::from("remedy"),
+        });
+        assert_eq!(
+            status(Some(&refused)),
+            serde_json::json!({"observing": false, "code": "missing-input-monitoring", "reason": "reason", "remedy": "remedy"})
+        );
+    }
+}

package/engine/src/peer.rs

@@ -23,7 +23,7 @@ use rtc::peer_connection::configuration::media_engine::{
 use rtc::peer_connection::configuration::RTCConfigurationBuilder;
 use rtc::peer_connection::event::RTCPeerConnectionIceEvent;
 use rtc::peer_connection::sdp::RTCSessionDescription;
-use rtc::peer_connection::transport::{RTCIceCandidateInit, RTCIceServer};
+use rtc::peer_connection::transport::{RTCIceCandidateInit, RTCIceProtocol, RTCIceServer};
 use rtc::rtcp::payload_feedbacks::full_intra_request::FullIntraRequest;
 use rtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
 use rtc::rtcp::receiver_report::ReceiverReport;
@@ -47,7 +47,7 @@ use webrtc::peer_connection::{
 };
 use webrtc::runtime::default_runtime;
 
-// desklink scout trace (dl-roam-postnom-attr): engine-side restart timeline.
+// desklink scout trace: engine-side restart timeline.
 // Enabled with `DESKLINK_ICE_TRACE=1`; stamps microseconds since the Unix epoch
 // so these lines interleave with the vendored ICE agent's `[ice ...]` lines in
 // one order. Droppable: grep `desklink scout trace`.
@@ -258,7 +258,10 @@ pub enum PeerEvent {
 /// Transport settings the consumer chose for this session.
 #[derive(Debug, Clone)]
 pub struct TransportOptions {
-    pub ice_servers: Vec<(String, Option<String>, Option<String>)>,
+    /// One entry per ICE server the consumer asked for, carrying every URL
+    /// that entry listed; the engine has already left out the ones the
+    /// WebRTC stack cannot dial and reported those to the consumer.
+    pub ice_servers: Vec<(Vec<String>, Option<String>, Option<String>)>,
     /// Listen for ICE over TCP on the loopback too. A phone that reaches this
     /// computer only through SSH has no UDP path; it forwards this port over
     /// the SSH connection it already has, and the picture rides that.
@@ -474,7 +477,7 @@ impl PeerConnectionEventHandler for Handler {
     }
 
     async fn on_connection_state_change(&self, state: RTCPeerConnectionState) {
-        // desklink scout trace (dl-roam-postnom-attr): the engine's rtc-level
+        // desklink scout trace: the engine's rtc-level
         // transport state event, on the same microsecond clock as the vendored
         // agent's `[ice ...]` lines, so the rtc Connected gate is separable.
         if dl_trace_on() {
@@ -898,8 +901,8 @@ impl VideoPeer {
                 options
                     .ice_servers
                     .iter()
-                    .map(|(url, username, credential)| RTCIceServer {
-                        urls: vec![url.clone()],
+                    .map(|(urls, username, credential)| RTCIceServer {
+                        urls: urls.clone(),
                         username: username.clone().unwrap_or_default(),
                         credential: credential.clone().unwrap_or_default(),
                     })
@@ -1130,6 +1133,21 @@ impl VideoPeer {
         self.connected.load(Ordering::SeqCst)
     }
 
+    /// Whether ICE selected a TCP candidate pair (the relay's ICE-TCP path).
+    /// False until a pair is selected.
+    pub async fn selected_pair_is_tcp(&self) -> bool {
+        let Some(sender) = self.peer.get_senders().await.into_iter().next() else {
+            return false;
+        };
+        let Ok(Some(dtls)) = sender.transport().await else {
+            return false;
+        };
+        matches!(
+            dtls.ice_transport().get_selected_candidate_pair().await,
+            Ok(Some(pair)) if pair.local().protocol == RTCIceProtocol::Tcp
+        )
+    }
+
     /// Stand in for a connected transport, for a pipeline under test.
     #[cfg(test)]
     pub fn assume_connected(&self) {
@@ -1172,6 +1190,12 @@ impl VideoPeer {
         lock(&self.path).take()
     }
 
+    /// Stand in for transport-wide feedback that reports a path, for a pipeline under test.
+    #[cfg(test)]
+    pub fn report_path(&self, report: PathReport) {
+        *lock(&self.path) = Some(report);
+    }
+
     /// Take the pending "the far end needs a reference frame" request, if any.
     pub fn take_keyframe_request(&self) -> bool {
         self.wants_keyframe.swap(false, Ordering::SeqCst)
@@ -1697,6 +1721,7 @@ pub(crate) mod tests {
     async fn media_receiver(
         receiver: Arc<MediaReceiver>,
         udp: Vec<std::net::SocketAddr>,
+        tcp: Vec<std::net::SocketAddr>,
     ) -> Arc<dyn PeerConnection> {
         let mut media_engine = MediaEngine::default();
         media_engine
@@ -1710,6 +1735,7 @@ pub(crate) mod tests {
             .with_runtime(default_runtime().expect("a runtime"))
             .with_handler(receiver)
             .with_udp_addrs(udp)
+            .with_tcp_addrs(tcp)
             .build()
             .await
             .expect("a receiving peer");
@@ -1719,17 +1745,27 @@ pub(crate) mod tests {
     /// An engine and a client receiving on `client_udp`, offered, answered and
     /// connected over ICE, with the client's RTP arrival times and the
     /// candidates the engine offered.
-    struct Connected {
-        engine: Arc<VideoPeer>,
+    pub(crate) struct Connected {
+        pub(crate) engine: Arc<VideoPeer>,
         offer: String,
-        client: Arc<dyn PeerConnection>,
+        pub(crate) client: Arc<dyn PeerConnection>,
         arrivals: Arc<Mutex<Vec<Instant>>>,
         offered: Arc<Mutex<Vec<String>>>,
     }
 
-    async fn connected(client_udp: Vec<std::net::SocketAddr>) -> Connected {
+    /// `client_tcp` and `loopback_tcp` give a pair that runs over ICE-TCP: a
+    /// client with no UDP candidates can only reach the engine over TCP.
+    pub(crate) async fn connected(
+        client_udp: Vec<std::net::SocketAddr>,
+        client_tcp: Vec<std::net::SocketAddr>,
+        loopback_tcp: bool,
+    ) -> Connected {
         let (events, mut events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (engine, offer) = VideoPeer::offer(transport(), events, VideoCodec::Vp9)
+        let options = TransportOptions {
+            loopback_tcp,
+            ..transport()
+        };
+        let (engine, offer) = VideoPeer::offer(options, events, VideoCodec::Vp9)
             .await
             .expect("an offering peer");
         let engine = Arc::new(engine);
@@ -1743,7 +1779,7 @@ pub(crate) mod tests {
             arrivals: Arc::clone(&arrivals),
             connected: Arc::clone(&connected),
         });
-        let client = media_receiver(Arc::clone(&receiver), client_udp).await;
+        let client = media_receiver(Arc::clone(&receiver), client_udp, client_tcp).await;
 
         client
             .set_remote_description(RTCSessionDescription::offer(offer.clone()).expect("an offer"))
@@ -1824,7 +1860,12 @@ pub(crate) mod tests {
             client,
             arrivals,
             offered,
-        } = connected(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))]).await;
+        } = connected(
+            vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))],
+            Vec::new(),
+            false,
+        )
+        .await;
         eprintln!("restart: the engine offered {:?}", offered.lock().unwrap());
 
         // Any bytes the VP9 packetizer turns into one access unit.
@@ -1968,10 +2009,14 @@ pub(crate) mod tests {
             arrivals,
             offered,
             ..
-        } = connected(vec![std::net::SocketAddr::from((
-            std::net::Ipv6Addr::LOCALHOST,
-            0,
-        ))])
+        } = connected(
+            vec![std::net::SocketAddr::from((
+                std::net::Ipv6Addr::LOCALHOST,
+                0,
+            ))],
+            Vec::new(),
+            false,
+        )
         .await;
         let offered = offered.lock().unwrap().clone();
         eprintln!("ipv6: the engine offered {offered:?}");
@@ -2047,4 +2092,110 @@ pub(crate) mod tests {
             "no one else is offered a port on the loopback"
         );
     }
+
+    /// A STUN responder bound on the wildcard that answers every Binding
+    /// request with the requester's own address, the way a real STUN server
+    /// would. Reach it at the address `primary_ip` names, not at its bind
+    /// address: the wildcard receives for every interface.
+    async fn stun_responder() -> std::net::SocketAddr {
+        use rtc::stun::message::Setter;
+        let socket = tokio::net::UdpSocket::bind("0.0.0.0:0")
+            .await
+            .expect("a socket");
+        let addr = socket.local_addr().expect("a bound port");
+        tokio::spawn(async move {
+            let mut buffer = vec![0u8; 1500];
+            while let Ok((size, peer)) = socket.recv_from(&mut buffer).await {
+                let mut request = rtc::stun::message::Message::new();
+                request.raw = buffer[..size].to_vec();
+                if request.decode().is_err() {
+                    continue;
+                }
+                let mut response = rtc::stun::message::Message::new();
+                response.set_type(rtc::stun::message::BINDING_SUCCESS);
+                response.transaction_id = request.transaction_id;
+                let mapped = rtc::stun::xoraddr::XorMappedAddress {
+                    ip: peer.ip(),
+                    port: peer.port(),
+                };
+                if mapped.add_to(&mut response).is_err() {
+                    continue;
+                }
+                response.write_header();
+                let _ = socket.send_to(&response.raw, peer).await;
+            }
+        });
+        addr
+    }
+
+    /// The interface address this machine sources its own traffic from — the
+    /// address a socket bound to this machine's interfaces can reach. The
+    /// peer binds one socket per non-loopback interface (loopback is skipped
+    /// when host candidates are gathered), and Windows' strong-host model
+    /// refuses to send an interface-bound datagram to 127.0.0.1, where the
+    /// Linux weak-host model allows it — so a loopback STUN fixture gathers
+    /// nothing on Windows. A real STUN server sits on the subnet, and the
+    /// fixture does the same. The probe is a connected UDP socket: the OS
+    /// resolves the route and its source address without sending a packet.
+    fn primary_ip() -> std::net::IpAddr {
+        let probe = std::net::UdpSocket::bind("0.0.0.0:0").and_then(|probe| {
+            probe.connect("192.0.2.1:9")?; // TEST-NET-1: connected UDP sends nothing
+            probe.local_addr()
+        });
+        match probe {
+            Ok(addr) if !addr.ip().is_unspecified() && !addr.ip().is_loopback() => addr.ip(),
+            _ => std::net::IpAddr::from([127, 0, 0, 1]),
+        }
+    }
+
+    /// One ice_servers entry listing two URLs must put both in front of the
+    /// peer connection: the first responder here never answers, so any
+    /// reflexive candidate can only have come from the second URL. The engine
+    /// used to forward only the first URL of each entry, which lost the rest.
+    #[tokio::test]
+    async fn the_second_url_of_an_ice_server_entry_gathers_a_reflexive_candidate() {
+        let ip = primary_ip();
+        // A server that never answers: bound, so its port cannot be reused,
+        // and silent, so it is as good as unreachable.
+        let silent = tokio::net::UdpSocket::bind("0.0.0.0:0")
+            .await
+            .expect("a socket");
+        let unreachable = silent.local_addr().expect("a port");
+        let answering = stun_responder().await;
+
+        let (events, mut events_rx) = tokio::sync::mpsc::unbounded_channel();
+        let (_peer, _offer) = VideoPeer::offer(
+            TransportOptions {
+                ice_servers: vec![(
+                    vec![
+                        format!("stun:{ip}:{}", unreachable.port()),
+                        format!("stun:{ip}:{}", answering.port()),
+                    ],
+                    None,
+                    None,
+                )],
+                loopback_tcp: false,
+                pace_bps: 20_000_000.0,
+            },
+            events,
+            VideoCodec::Vp9,
+        )
+        .await
+        .expect("a peer connection");
+
+        // Host candidates arrive without the network; the reflexive one needs
+        // the binding round trip through the second URL of the entry.
+        let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
+        loop {
+            let event = tokio::time::timeout_at(deadline, events_rx.recv())
+                .await
+                .expect("no reflexive candidate was ever gathered")
+                .expect("the peer event stream ended");
+            if let PeerEvent::Candidate { candidate, .. } = event {
+                if candidate.contains(" typ srflx ") {
+                    break;
+                }
+            }
+        }
+    }
 }