TheLanc3/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2026-09-19 02:41:10 +03:00
Code Issues Packages Projects Releases Wiki Activity

webrtc: close without an await point; do not report an unknown path as direct

Browse Source 
- close_webrtc is no longer async (hbb_common 88f965f), so the ten call
  sites in port_forward and io_loop - all inside select! arms or futures
  the UI can abandon - can no longer be cancelled mid-teardown, which
  left the pc unclosable and its session entry stranded. Client's own
  spawn_close_webrtc went with it: the runtime-teardown guard it existed
  for now lives in close_detached, so both Drop paths share one
  implementation.

- webrtc_relayed() returns None when no candidate pair is selected or
  the pc closed under a concurrent teardown, and both call sites read
  that as "not relayed", i.e. direct. A TURN-relayed session could
  therefore be shown to the user as peer-to-peer. Claiming a direct path
  needs evidence of one, so an unknown answer now counts as relayed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ExUfAkYbq8UC9pQCiLy8TQ
This commit is contained in:
rustdesk
2026-08-08 13:10:22 +08:00
parent 2639ede4c4
commit c1b50f3910
4 changed files with 20 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/client.rs
View File

@@ -202,7 +202,7 @@ impl OffererGuard {
impl Drop for OffererGuard {
fn drop(&mut self) {
if let Some(stream) = self.0.take() {
Client::spawn_close_webrtc(stream);
stream.close_detached();
}
}
}
@@ -581,34 +581,6 @@ impl Client {
!session_key.is_empty() && ice.session_key == session_key && !ice.candidate.is_empty()
}
/// Tear down an abandoned WebRTC offerer off the connection hot path.
///
/// The pc must be closed explicitly (a dropped handle leaves the `SESSIONS` clone alive),
/// but `close()` awaits internal ICE/DTLS shutdown and the result is pure cleanup with no
/// downstream dependency, so it must not block session establishment.
fn spawn_close_webrtc(webrtc: WebRTCStream) {
// Use the current runtime handle explicitly: this is also called from OffererGuard::drop,
// which can run during runtime teardown where a bare tokio::spawn would panic. If no
// runtime is available the pc cannot be closed here (it is released at process exit).
// Handle::spawn can also panic when the runtime is shutting down; catch that so Drop
// never panics (prefer a brief leak until process exit over aborting the process).
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
let spawn_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
handle.spawn(async move {
webrtc.close().await;
});
}));
if spawn_result.is_err() {
log::warn!("failed to spawn WebRTC close (runtime shutting down)");
}
}
Err(_) => {
log::warn!("no tokio runtime available to close WebRTC peer connection");
}
}
}
/// Whether to build a WebRTC offerer for this connection.
///
/// Off by default against a private rendezvous server, like the UDP/IPv6 punch options:
@@ -1180,7 +1152,10 @@ impl Client {
let direct = match typ {
"IPv6" => true,
// WebRTC through a TURN server is relayed traffic; report it as such.
"WebRTC" => !conn.webrtc_relayed().await.unwrap_or(false),
// An unknown answer (no selected pair yet, or the pc closed under a
// concurrent teardown) must not be read as "direct": claiming a P2P
// path needs evidence of one.
"WebRTC" => !conn.webrtc_relayed().await.unwrap_or(true),
_ => false,
};
// Secured and WebRTC won: disarm so the returned conn keeps the pc alive.
@@ -1276,7 +1251,7 @@ impl Client {
// Bailing before connect(): an offerer already adopted into webrtc_for_connect was
// disarmed out of its guard, so close it (and stop its bridge) explicitly here.
if let Some(webrtc) = webrtc_for_connect.take() {
Self::spawn_close_webrtc(webrtc);
webrtc.close_detached();
}
if let Some(stop) = webrtc_bridge_stop.take() {
let _ = stop.send(());
@@ -1536,8 +1511,9 @@ impl Client {
};
if typ == "WebRTC" {
// WebRTC through a TURN server (force_relay, or a TURN pair winning under All
// policy) is relayed traffic; report the direct flag accordingly.
if conn.webrtc_relayed().await.unwrap_or(false) {
// policy) is relayed traffic; report the direct flag accordingly. An unknown answer
// counts as relayed — claiming a P2P path needs evidence of one.
if conn.webrtc_relayed().await.unwrap_or(true) {
direct = false;
}
// Secured: disarm so the returned conn keeps the pc alive.