TheLanc3/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2026-09-05 23:51:04 +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 2657143712
commit ed09f3cc76
4 changed files with 20 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libs/hbb_common

Submodule libs/hbb_common updated: 6677318bd2...73007cb38e

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.

4
src/client/io_loop.rs
View File

@@ -198,7 +198,7 @@ impl<T: InvokeUiSession> Remote<T> {
self.handle_disconnected(round);
// Close the WebRTC pc on this decline path too (no-op for TCP/WS); otherwise its
// pc lingers in the global session cache until ICE decays on its own.
peer.close_webrtc().await;
peer.close_webrtc();
return;
}
self.handler.update_direct(Some(direct));
@@ -348,7 +348,7 @@ impl<T: InvokeUiSession> Remote<T> {
// Close the WebRTC peer connection (if this session used it) so its pc is not left
// lingering in the global session cache after the session ends; dropping `peer`
// alone does not release it. No-op for TCP/WebSocket transports.
peer.close_webrtc().await;
peer.close_webrtc();
// Stop client audio server.
if let Some(s) = self.stop_voice_call_sender.take() {
s.send(()).ok();

16
src/port_forward.rs
View File

@@ -158,7 +158,7 @@ async fn connect_and_login(
*close_port_forward = true;
// Close the WebRTC pc on this decline path too (no-op for TCP/WS), matching every
// other exit in this function; a bare drop leaks it in the global session cache.
stream.close_webrtc().await;
stream.close_webrtc();
return Ok(None);
}
}
@@ -173,7 +173,7 @@ async fn connect_and_login(
tokio::select! {
res = timeout(READ_TIMEOUT, stream.next()) => match res {
Err(_) => {
stream.close_webrtc().await;
stream.close_webrtc();
bail!("Timeout");
}
Ok(Some(Ok(bytes))) => {
@@ -184,7 +184,7 @@ async fn connect_and_login(
let msg_in = match Message::parse_from_bytes(&bytes) {
Ok(msg) => msg,
Err(err) => {
stream.close_webrtc().await;
stream.close_webrtc();
return Err(err.into());
}
};
@@ -198,7 +198,7 @@ async fn connect_and_login(
Some(message::Union::LoginResponse(lr)) => match lr.union {
Some(login_response::Union::Error(err)) => {
if !interface.handle_login_error(&err) {
stream.close_webrtc().await;
stream.close_webrtc();
return Ok(None);
}
}
@@ -215,11 +215,11 @@ async fn connect_and_login(
}
}
Ok(Some(Err(err))) => {
stream.close_webrtc().await;
stream.close_webrtc();
bail!("Connection closed: {}", err);
}
_ => {
stream.close_webrtc().await;
stream.close_webrtc();
bail!("Reset by the peer");
}
},
@@ -239,7 +239,7 @@ async fn connect_and_login(
if let Some(Ok(bytes)) = res {
buffer.extend(bytes);
} else {
stream.close_webrtc().await;
stream.close_webrtc();
return Ok(None);
}
},
@@ -344,7 +344,7 @@ async fn run_forward(forward: Framed<TcpStream, BytesCodec>, stream: Stream) ->
},
}
}
stream.close_webrtc().await;
stream.close_webrtc();
Ok(())
}