release capture only if no active capture at pos

Author: feschber

src/capture.rs

@@ -228,6 +228,19 @@ async fn handle_capture_event(
         enter_tx.send(handle).expect("channel closed");
     }
 
+    // incoming connection
+    if handle >= Service::ENTER_HANDLE_BEGIN {
+        // if there is no active outgoing connection at the current capture,
+        // we release the capture
+        if let Some(pos) = server.get_incoming_pos(handle) {
+            if server.client_manager.client_at(pos).is_none() {
+                capture.release().await?;
+            }
+        }
+        // we dont care about events from incoming handles except for releasing the capture
+        return Ok(());
+    }
+
     // activated a new client
     if event == CaptureEvent::Begin && Some(handle) != server.get_active() {
         *state = State::WaitingForAck;

src/service.rs

@@ -70,7 +70,7 @@ pub struct Service {
     capture_status: Rc<Cell<Status>>,
     pub(crate) emulation_status: Rc<Cell<Status>>,
     pub(crate) should_release: Rc<RefCell<Option<ReleaseToken>>>,
-    incoming_conns: Rc<RefCell<HashMap<ClientHandle, (String, SocketAddr)>>>,
+    incoming_conns: Rc<RefCell<HashMap<ClientHandle, (String, SocketAddr, Position)>>>,
     cert: Certificate,
     next_trigger_handle: u64,
 }
@@ -225,34 +225,42 @@ impl Service {
         Ok(())
     }
 
+    pub(crate) const ENTER_HANDLE_BEGIN: u64 = u64::MAX / 2 + 1;
+
     fn add_incoming(
         &mut self,
         addr: SocketAddr,
         pos: Position,
         fingerprint: String,
         capture: &Capture,
     ) {
-        const ENTER_HANDLE_BEGIN: u64 = u64::MAX / 2 + 1;
-        let handle = ENTER_HANDLE_BEGIN + self.next_trigger_handle;
+        let handle = Self::ENTER_HANDLE_BEGIN + self.next_trigger_handle;
         self.next_trigger_handle += 1;
         capture.create(handle, pos);
         self.incoming_conns
             .borrow_mut()
-            .insert(handle, (fingerprint, addr));
+            .insert(handle, (fingerprint, addr, pos));
     }
 
     fn remove_incoming(&mut self, addr: SocketAddr, capture: &Capture) -> Option<String> {
         let handle = self
             .incoming_conns
             .borrow()
             .iter()
-            .find(|(_, (_, a))| *a == addr)
+            .find(|(_, (_, a, _))| *a == addr)
             .map(|(k, _)| *k)?;
         capture.destroy(handle);
         self.incoming_conns
             .borrow_mut()
             .remove(&handle)
-            .map(|(f, _)| f)
+            .map(|(f, _, _)| f)
+    }
+
+    pub(crate) fn get_incoming_pos(&self, handle: ClientHandle) -> Option<Position> {
+        self.incoming_conns
+            .borrow()
+            .get(&handle)
+            .map(|&(_, _, p)| p)
     }
 
     fn notify_frontend(&self, event: FrontendEvent) {