1use super::super::super::{GONE, OPENING, Pipe, Shared, State};
2use super::*;
3use std::{
4 io::{Read, Write},
5 net::{Shutdown, TcpListener, TcpStream},
6 sync::atomic::AtomicUsize,
7};
8
9struct Barrier {
10 reached: mpsc::Sender<()>,
11 resume: mpsc::Receiver<()>,
12}
13
14impl Barrier {
15 fn wait(self) -> io::Result<()> {
16 self.reached.send(()).map_err(io::Error::other)?;
17 self.resume.recv_timeout(GONE).map_err(io::Error::other)
18 }
19}
20
21fn barrier() -> (Barrier, mpsc::Receiver<()>, mpsc::Sender<()>) {
22 let (reached, waiting) = mpsc::channel();
23 let (resume, continued) = mpsc::channel();
24 (
25 Barrier {
26 reached,
27 resume: continued,
28 },
29 waiting,
30 resume,
31 )
32}
33
34struct HandoverPipe {
35 stream: TcpStream,
36 direct: bool,
37 body: Mutex<Option<Barrier>>,
38 retired: mpsc::Sender<()>,
39}
40
41impl Pipe for HandoverPipe {
42 fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {
43 let gate = if buffer.len() > 4 {
44 self.body.lock().unwrap().take()
45 } else {
46 None
47 };
48 if let Some(gate) = gate {
49 // Preserve a complete copied ciphertext block across the old pipe's shutdown.
50 Read::read_exact(&mut &self.stream, buffer)?;
51 gate.wait()?;
52 Ok(buffer.len())
53 } else {
54 Read::read(&mut &self.stream, buffer)
55 }
56 }
57
58 fn write(&self, bytes: &[u8]) -> io::Result<usize> {
59 Write::write(&mut &self.stream, bytes)
60 }
61
62 fn set_read_timeout(&self, timeout: Duration) -> io::Result<()> {
63 self.stream.set_read_timeout(Some(timeout))
64 }
65
66 fn shutdown(&self) {
67 let _ = self.stream.shutdown(Shutdown::Both);
68 }
69
70 fn direct(&self) -> bool {
71 self.direct
72 }
73}
74
75impl Drop for HandoverPipe {
76 fn drop(&mut self) {
77 let _ = self.retired.send(());
78 }
79}
80
81struct Handover {
82 shared: Arc<Shared>,
83 guest: Arc<Inner>,
84 pipes: Vec<Arc<HandoverPipe>>,
85 readers: Vec<(mpsc::Receiver<()>, thread::JoinHandle<()>)>,
86 retired: (mpsc::Sender<()>, mpsc::Receiver<()>),
87 observed: mpsc::Receiver<()>,
88 releases: Vec<mpsc::Sender<()>>,
89}
90
91impl Handover {
92 fn new(met: Option<Barrier>) -> Self {
93 let me = Hello::new("Guest".into(), None).unwrap();
94 let guest = Arc::new(Inner {
95 share: [41; 16],
96 me: me.clone(),
97 reach: None,
98 relay: None,
99 events: Arc::new(|| {}),
100 presence: Mutex::default(),
101 here: Mutex::default(),
102 host: Mutex::default(),
103 pending: Mutex::default(),
104 next: AtomicU64::new(1),
105 watch: Mutex::default(),
106 ended: Mutex::default(),
107 asked: Default::default(),
108 images: Mutex::default(),
109 current: Mutex::default(),
110 });
111 let heard = Arc::clone(&guest);
112 let met = Mutex::new(met);
113 let (events, observed) = mpsc::channel();
114 let room = Room::Notebook([42; 16]);
115 let shared = Arc::new(Shared {
116 me,
117 secret: room.secret(),
118 room,
119 reach: None,
120 state: Mutex::new(State::default()),
121 events: Box::new(move |source, event| {
122 let meeting = matches!(&event, Event::Met(..));
123 if meeting {
124 let gate = met.lock().unwrap().take();
125 if let Some(gate) = gate {
126 gate.wait().unwrap();
127 }
128 }
129 heard.heard(source, event);
130 if meeting {
131 let _ = events.send(());
132 }
133 }),
134 stopped: AtomicBool::new(false),
135 connections: AtomicU64::new(0),
136 });
137 Self {
138 shared,
139 guest,
140 pipes: Vec::new(),
141 readers: Vec::new(),
142 retired: mpsc::channel(),
143 observed,
144 releases: Vec::new(),
145 }
146 }
147
148 fn open(&mut self, host: &Hello, direct: bool) -> (TcpStream, wire::Sealer, wire::Sealer) {
149 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
150 let mut remote =
151 TcpStream::connect_timeout(&listener.local_addr().unwrap(), OPENING).unwrap();
152 remote.set_read_timeout(Some(OPENING)).unwrap();
153 remote.set_write_timeout(Some(OPENING)).unwrap();
154 let (local, _) = listener.accept().unwrap();
155 local.set_write_timeout(Some(OPENING)).unwrap();
156 let pipe = Arc::new(HandoverPipe {
157 stream: local,
158 direct,
159 body: Mutex::default(),
160 retired: self.retired.0.clone(),
161 });
162 self.pipes.push(Arc::clone(&pipe));
163 let shared = Arc::clone(&self.shared);
164 let tag = shared.room.tag().unwrap();
165 let reader_tag = tag.clone();
166 let (finished, done) = mpsc::channel();
167 let reader = thread::spawn(move || {
168 shared.run(pipe, wire::Side::Responder, &reader_tag);
169 let _ = finished.send(());
170 });
171 self.readers.push((done, reader));
172 let (mut send, mut receive) = wire::open(
173 &mut remote,
174 wire::Side::Initiator,
175 &tag,
176 &self.shared.secret,
177 )
178 .unwrap();
179 send.send(&mut remote, kind::HELLO, host).unwrap();
180 let (message, body) = receive.receive(&mut remote).unwrap();
181 assert_eq!(message, kind::HELLO);
182 assert_eq!(minicbor::decode::<Hello>(&body).unwrap(), self.shared.me);
183 (remote, send, receive)
184 }
185
186 fn heard(&self) {
187 self.observed.recv_timeout(OPENING).unwrap();
188 }
189}
190
191impl Drop for Handover {
192 fn drop(&mut self) {
193 self.shared.stopped.store(true, Ordering::Release);
194 for release in self.releases.drain(..) {
195 let _ = release.send(());
196 }
197 for pipe in &self.pipes {
198 pipe.shutdown();
199 }
200 self.shared.state.lock().unwrap().peers.clear();
201 let readers_done = self
202 .readers
203 .iter()
204 .all(|(done, _)| done.recv_timeout(OPENING) != Err(mpsc::RecvTimeoutError::Timeout));
205 self.guest.host.lock().unwrap().take();
206 let count = self.pipes.len();
207 self.pipes.clear();
208 let joined = readers_done
209 && (0..count).all(|_| self.retired.1.recv_timeout(OPENING).is_ok())
210 && (self.readers.drain(..)).all(|(_, reader)| reader.join().is_ok());
211 if !thread::panicking() {
212 assert!(
213 joined,
214 "handover reader/writer owners did not retire and join"
215 );
216 }
217 }
218}
219
220#[test]
221fn handover_stale_frame_cannot_end_promoted_guest() {
222 let mut fixture = Handover::new(None);
223 let mut host = Hello::new("Old host route".into(), None).unwrap();
224 host.serves = Some(fixture.guest.share);
225 let (mut old, mut send, _) = fixture.open(&host, false);
226 fixture.heard();
227 let (gate, copied, resume) = barrier();
228 fixture.releases.push(resume.clone());
229 *fixture.pipes[0].body.lock().unwrap() = Some(gate);
230 send.send(
231 &mut old,
232 kind::BYE,
233 &wire::Bye {
234 reason: STOPPED.into(),
235 },
236 )
237 .unwrap();
238 copied.recv_timeout(OPENING).unwrap();
239 host.name = "Promoted host route".into();
240 let (_new, _, _) = fixture.open(&host, true);
241 fixture.heard();
242 assert!(
243 fixture.shared.state.lock().unwrap().peers[&host.peer]
244 .pipe
245 .direct()
246 );
247 assert!(fixture.guest.ended.lock().unwrap().is_none());
248 resume.send(()).unwrap();
249 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
250 let ended = *fixture.guest.ended.lock().unwrap();
251 drop(fixture);
252 assert_eq!(ended, None, "stale frame ended the promoted guest");
253}
254
255#[test]
256fn handover_reply_from_retired_route_reaches_its_waiter() {
257 let mut fixture = Handover::new(None);
258 let mut host = Hello::new("Old host route".into(), None).unwrap();
259 host.serves = Some(fixture.guest.share);
260 let (mut old, mut send, _) = fixture.open(&host, false);
261 fixture.heard();
262 let (answer, waiting) = crate::task::response::<Reply>();
263 fixture.guest.pending.lock().unwrap().insert(75, answer);
264 let (gate, copied, resume) = barrier();
265 fixture.releases.push(resume.clone());
266 *fixture.pipes[0].body.lock().unwrap() = Some(gate);
267 let reply = Reply {
268 id: 75,
269 length: Some(12),
270 ..Reply::default()
271 };
272 send.send(&mut old, kind::REPLY, &reply).unwrap();
273 copied.recv_timeout(OPENING).unwrap();
274 host.name = "Promoted host route".into();
275 let (_new, _, _) = fixture.open(&host, true);
276 fixture.heard();
277 resume.send(()).unwrap();
278 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
279 let answered = waiting.try_recv().ok();
280 drop(fixture);
281 assert_eq!(
282 answered,
283 Some(reply),
284 "a reply read off a retired route missed its waiter"
285 );
286}
287
288#[test]
289fn handover_stale_met_cannot_replace_promoted_guest_line() {
290 let (gate, delayed, resume) = barrier();
291 let mut fixture = Handover::new(Some(gate));
292 fixture.releases.push(resume.clone());
293 let mut host = Hello::new("Old host route".into(), None).unwrap();
294 host.serves = Some(fixture.guest.share);
295 let (_old, _, _) = fixture.open(&host, false);
296 delayed.recv_timeout(OPENING).unwrap();
297 host.name = "Promoted host route".into();
298 let (_new, _, _) = fixture.open(&host, true);
299 fixture.heard();
300 assert_eq!(
301 fixture.guest.host.lock().unwrap().as_ref().unwrap().0.name,
302 host.name
303 );
304 resume.send(()).unwrap();
305 fixture.heard();
306 assert_eq!(
307 fixture.shared.state.lock().unwrap().peers[&host.peer]
308 .peer
309 .hello
310 .name,
311 host.name
312 );
313 let selected = fixture
314 .guest
315 .host
316 .lock()
317 .unwrap()
318 .as_ref()
319 .unwrap()
320 .0
321 .name
322 .clone();
323 drop(fixture);
324 assert_eq!(
325 selected, host.name,
326 "stale Met replaced the promoted guest Line"
327 );
328}
329
330impl Handover {
331 fn intercept(
332 &mut self,
333 before: impl Fn(&Arc<Shared>, &Event<'_>) + Send + Sync + 'static,
334 ) -> mpsc::Receiver<u16> {
335 let guest = Arc::clone(&self.guest);
336 let (observed, waiting) = mpsc::channel();
337 Arc::get_mut(&mut self.shared).unwrap().events = Box::new(move |source, event| {
338 let kind = match &event {
339 Event::Met(..) => kind::HELLO,
340 Event::Left(..) => kind::BYE,
341 Event::Frame { kind, .. } => *kind,
342 Event::Changed => 0,
343 };
344 before(source, &event);
345 guest.heard(source, event);
346 let _ = observed.send(kind);
347 });
348 waiting
349 }
350}
351
352fn observed(events: &mpsc::Receiver<u16>, wanted: u16) {
353 let end = std::time::Instant::now() + OPENING;
354 loop {
355 let kind = events
356 .recv_timeout(end.saturating_duration_since(std::time::Instant::now()))
357 .unwrap();
358 if kind == wanted {
359 return;
360 }
361 }
362}
363
364#[test]
365fn handover_old_left_preserves_promoted_host_and_pending_reply() {
366 let mut fixture = Handover::new(None);
367 let (gate, removed, resume) = barrier();
368 fixture.releases.push(resume.clone());
369 let gate = Mutex::new(Some(gate));
370 let events = fixture.intercept(move |_, event| {
371 if matches!(event, Event::Left(_))
372 && let Some(gate) = gate.lock().unwrap().take()
373 {
374 gate.wait().unwrap();
375 }
376 });
377 let mut host = Hello::new("Old host route".into(), None).unwrap();
378 host.serves = Some(fixture.guest.share);
379 let (old, _, _) = fixture.open(&host, false);
380 observed(&events, kind::HELLO);
381 old.shutdown(Shutdown::Both).unwrap();
382 removed.recv_timeout(OPENING).unwrap();
383 host.name = "Promoted host route".into();
384 let (_new, _, _) = fixture.open(&host, true);
385 observed(&events, kind::HELLO);
386 let (answer, waiting) = crate::task::response::<Reply>();
387 fixture.guest.pending.lock().unwrap().insert(73, answer);
388 resume.send(()).unwrap();
389 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
390 let host_kept = fixture
391 .guest
392 .host
393 .lock()
394 .unwrap()
395 .as_ref()
396 .is_some_and(|(hello, _)| hello.name == host.name);
397 let pending_kept = fixture.guest.pending.lock().unwrap().contains_key(&73);
398 let answer_kept = matches!(waiting.try_recv(), Err(mpsc::TryRecvError::Empty));
399 drop(fixture);
400 assert!(
401 host_kept && pending_kept && answer_kept,
402 "retired Left cleared the promoted host or pending reply"
403 );
404}
405
406#[test]
407fn handover_selected_loss_clears_host_and_disconnects_pending_reply() {
408 let mut fixture = Handover::new(None);
409 let mut host = Hello::new("Selected host".into(), None).unwrap();
410 host.serves = Some(fixture.guest.share);
411 let (remote, _, _) = fixture.open(&host, true);
412 fixture.heard();
413 let (answer, waiting) = crate::task::response::<Reply>();
414 fixture.guest.pending.lock().unwrap().insert(74, answer);
415 remote.shutdown(Shutdown::Both).unwrap();
416 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
417 let host_cleared = fixture.guest.host.lock().unwrap().is_none();
418 let pending_cleared = fixture.guest.pending.lock().unwrap().is_empty();
419 let answer_lost = matches!(waiting.try_recv(), Err(mpsc::TryRecvError::Disconnected));
420 drop(fixture);
421 assert!(
422 host_cleared && pending_cleared && answer_lost,
423 "selected route loss retained the host or pending reply"
424 );
425}
426
427fn served() -> (tempfile::TempDir, Arc<Served>) {
428 let directory = tempfile::tempdir().unwrap();
429 let folder = directory.path().join("notebook");
430 std::fs::create_dir(&folder).unwrap();
431 let served = Arc::new(Served {
432 storage: crate::session::Notebook::open(&folder, directory.path().join("cache"))
433 .unwrap()
434 .into_storage(),
435 images: Mutex::default(),
436 snapshots: Mutex::default(),
437 puts: Mutex::default(),
438 guests: Mutex::default(),
439 writers: Mutex::default(),
440 members: Weak::new(),
441 host: Mutex::default(),
442 room: Mutex::default(),
443 });
444 (directory, served)
445}
446
447#[test]
448fn handover_copied_host_request_cannot_enter_promoted_queue() {
449 let (_directory, served) = served();
450 let mut fixture = Handover::new(None);
451 let serving = Arc::clone(&served);
452 let events = fixture.intercept(move |source, event| match event {
453 Event::Met(hello, line) => assert!(serving.admit(source, hello, [0; 16], line)),
454 Event::Frame { from, kind, body } => serving.queue(source, from, *kind, body),
455 Event::Left(hello) => serving.forget(&hello.peer, Some((source, hello))),
456 _ => {}
457 });
458 let mut host = Hello::new("Old route".into(), None).unwrap();
459 host.serves = Some(fixture.guest.share);
460 let (mut old, mut send, _) = fixture.open(&host, false);
461 observed(&events, kind::HELLO);
462 let (gate, copied, resume) = barrier();
463 fixture.releases.push(resume.clone());
464 *fixture.pipes[0].body.lock().unwrap() = Some(gate);
465 send.send(
466 &mut old,
467 kind::PUT,
468 &Request {
469 id: 80,
470 handle: Some(1),
471 offset: Some(0),
472 bytes: Some(vec![1, 2, 3]),
473 ..Request::default()
474 },
475 )
476 .unwrap();
477 copied.recv_timeout(OPENING).unwrap();
478 host.name = "Promoted route".into();
479 let (mut new, mut send, mut receive) = fixture.open(&host, true);
480 observed(&events, kind::HELLO);
481 resume.send(()).unwrap();
482 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
483 send.send(
484 &mut new,
485 kind::PUT,
486 &Request {
487 id: 81,
488 handle: Some(2),
489 offset: Some(0),
490 bytes: Some(vec![4, 5, 6]),
491 ..Request::default()
492 },
493 )
494 .unwrap();
495 let reply = loop {
496 let (kind, body) = receive.receive(&mut new).unwrap();
497 if kind == kind::REPLY {
498 break minicbor::decode::<Reply>(&body).unwrap();
499 }
500 };
501 let puts = served
502 .puts
503 .lock()
504 .unwrap()
505 .keys()
506 .copied()
507 .collect::<Vec<_>>();
508 served.guests.lock().unwrap().clear();
509 drop(fixture);
510 assert_eq!(
511 (reply.id, reply.failure, puts),
512 (81, None, vec![(host.peer, 2)]),
513 "retired request reached the promoted guest or current request was lost"
514 );
515}
516
517#[test]
518fn handover_old_left_preserves_promoted_host_uploads_and_snapshots() {
519 let (_directory, served) = served();
520 let mut fixture = Handover::new(None);
521 let (gate, removed, resume) = barrier();
522 fixture.releases.push(resume.clone());
523 let gate = Mutex::new(Some(gate));
524 let serving = Arc::clone(&served);
525 let events = fixture.intercept(move |source, event| match event {
526 Event::Met(hello, line) => assert!(serving.admit(source, hello, [0; 16], line)),
527 Event::Left(hello) => {
528 if let Some(gate) = gate.lock().unwrap().take() {
529 gate.wait().unwrap();
530 }
531 serving.forget(&hello.peer, Some((source, hello)));
532 }
533 _ => {}
534 });
535 let mut host = Hello::new("Old route".into(), None).unwrap();
536 host.serves = Some(fixture.guest.share);
537 let (old, _, _) = fixture.open(&host, false);
538 observed(&events, kind::HELLO);
539 old.shutdown(Shutdown::Both).unwrap();
540 removed.recv_timeout(OPENING).unwrap();
541 host.name = "Promoted route".into();
542 let (_new, _, _) = fixture.open(&host, true);
543 observed(&events, kind::HELLO);
544 served
545 .puts
546 .lock()
547 .unwrap()
548 .insert((host.peer, 90), vec![7, 8, 9]);
549 served
550 .snapshots
551 .lock()
552 .unwrap()
553 .insert((host.peer, 91), (Arc::new(vec![10, 11]), Instant::now()));
554 resume.send(()).unwrap();
555 fixture.readers[0].0.recv_timeout(OPENING).unwrap();
556 let guest_kept = served
557 .guests
558 .lock()
559 .unwrap()
560 .get(&host.peer)
561 .is_some_and(|guest| guest.hello.name == host.name);
562 let upload_kept = served.puts.lock().unwrap().get(&(host.peer, 90)) == Some(&vec![7, 8, 9]);
563 let snapshot_kept = served
564 .snapshots
565 .lock()
566 .unwrap()
567 .get(&(host.peer, 91))
568 .is_some_and(|(bytes, _)| **bytes == vec![10, 11]);
569 served.guests.lock().unwrap().clear();
570 drop(fixture);
571 assert!(
572 guest_kept && upload_kept && snapshot_kept,
573 "retired Left removed promoted host resources"
574 );
575}
576
577#[test]
578fn handover_deferred_presence_cannot_replace_promoted_host_room() {
579 let mut fixture = Handover::new(None);
580 let mut host = Hello::new("Old host route".into(), None).unwrap();
581 host.serves = Some(fixture.guest.share);
582 let (_old, _, _) = fixture.open(&host, false);
583 fixture.heard();
584 let from = Arc::clone(&fixture.guest.host.lock().unwrap().as_ref().unwrap().0);
585 let secret = [61; 16];
586 let guest = Arc::clone(&fixture.guest);
587 let source = Arc::clone(&fixture.shared);
588 let here_owner = Arc::clone(&fixture.guest);
589 let here = here_owner.here.lock().unwrap();
590 let (entered, started) = mpsc::channel();
591 let (finished, done) = mpsc::channel();
592 let installer = thread::spawn(move || {
593 entered.send(()).unwrap();
594 guest.join_presence(&source, &from, secret);
595 let _ = finished.send(());
596 });
597 fixture.readers.push((done, installer));
598 started.recv_timeout(OPENING).unwrap();
599 host.name = "Promoted host route".into();
600 let (_new, _, _) = fixture.open(&host, true);
601 fixture.heard();
602 drop(here);
603 fixture.readers[1].0.recv_timeout(OPENING).unwrap();
604 let refused = fixture.guest.presence.lock().unwrap().is_none();
605 let promoted = fixture
606 .guest
607 .host
608 .lock()
609 .unwrap()
610 .as_ref()
611 .is_some_and(|(hello, _)| hello.name == host.name);
612 drop(fixture);
613 assert!(
614 refused && promoted,
615 "deferred old WELCOME installed its presence room"
616 );
617}
618
619#[test]
620fn handover_presence_install_seeds_latest_here() {
621 let mut fixture = Handover::new(None);
622 let mut host = Hello::new("Current host".into(), None).unwrap();
623 host.serves = Some(fixture.guest.share);
624 let (_remote, _, _) = fixture.open(&host, true);
625 fixture.heard();
626 let from = Arc::clone(&fixture.guest.host.lock().unwrap().as_ref().unwrap().0);
627 let secret = [62; 16];
628 let guest = Arc::clone(&fixture.guest);
629 let source = Arc::clone(&fixture.shared);
630 let mut here = fixture.guest.here.lock().unwrap();
631 let latest = Presence {
632 section: Some([63; 16]),
633 ..Presence::default()
634 };
635 let (entered, started) = mpsc::channel();
636 let (finished, done) = mpsc::channel();
637 let installer = thread::spawn(move || {
638 entered.send(()).unwrap();
639 guest.join_presence(&source, &from, secret);
640 let _ = finished.send(());
641 });
642 fixture.readers.push((done, installer));
643 started.recv_timeout(OPENING).unwrap();
644 *here = latest.clone();
645 drop(here);
646 fixture.readers[1].0.recv_timeout(OPENING).unwrap();
647 let seeded = fixture
648 .guest
649 .presence
650 .lock()
651 .unwrap()
652 .as_ref()
653 .is_some_and(|(held, live)| {
654 *held == secret && live.shared.state.lock().unwrap().presence == latest
655 });
656 let installed = fixture.guest.presence.lock().unwrap().take();
657 drop(installed);
658 drop(fixture);
659 assert!(
660 seeded,
661 "presence installation overwrote current here with a stale seed"
662 );
663}
664
665pub(super) fn promoted_routes<T>(
666 room: Room,
667 before: impl FnOnce(&Arc<Shared>, &Arc<Hello>, &Line),
668 check: impl FnOnce(&Arc<Shared>, &Arc<Hello>, &Line, &Arc<Hello>, &Line) -> T,
669) -> T {
670 let mut fixture = Handover::new(None);
671 let shared = Arc::get_mut(&mut fixture.shared).unwrap();
672 shared.secret = room.secret();
673 shared.room = room;
674 let host = Hello::new("Pairing device".into(), None).unwrap();
675 let (_old, _, _) = fixture.open(&host, false);
676 fixture.heard();
677 let (old, old_line) = {
678 let state = fixture.shared.state.lock().unwrap();
679 let link = &state.peers[&host.peer];
680 (Arc::clone(&link.peer.hello), link.line.clone())
681 };
682 before(&fixture.shared, &old, &old_line);
683 let (_new, _, _) = fixture.open(&host, true);
684 fixture.heard();
685 let (new, new_line) = {
686 let state = fixture.shared.state.lock().unwrap();
687 let link = &state.peers[&host.peer];
688 (Arc::clone(&link.peer.hello), link.line.clone())
689 };
690 let result = check(&fixture.shared, &old, &old_line, &new, &new_line);
691 drop((old_line, new_line));
692 drop(fixture);
693 result
694}
695
696#[test]
697fn handover_pair_pending_keeps_promoted_identity_and_rejects_retired_allow() {
698 let directory = tempfile::tempdir().unwrap();
699 let folder = directory.path().join("notebook");
700 std::fs::create_dir(&folder).unwrap();
701 let sharing = Sharing {
702 approve: true,
703 code: super::super::super::code::format(701, "ABCDEF").unwrap(),
704 ..Sharing::new("").unwrap()
705 };
706 let room = Room::share(&sharing.code, &sharing.password);
707 let host = Host::start(
708 crate::session::Notebook::open(&folder, directory.path().join("cache"))
709 .unwrap()
710 .into_storage(),
711 Hello::new("Notebook owner".into(), None).unwrap(),
712 sharing,
713 "Fixture",
714 None,
715 None,
716 || {},
717 |_| Ok(()),
718 )
719 .unwrap();
720 let callback = Arc::clone(&host.pairing.lock().unwrap().as_ref().unwrap().shared);
721 let valid = promoted_routes(
722 room,
723 |source, old, old_line| {
724 (callback.events)(source, Event::Met(old, old_line));
725 },
726 |source, old, old_line, new, new_line| {
727 host.allow(&old.peer).unwrap();
728 let no_grant = host.sharing().members.is_empty();
729 (callback.events)(source, Event::Met(new, new_line));
730 (callback.events)(source, Event::Met(old, old_line));
731 (callback.events)(source, Event::Left(old));
732 let kept = host
733 .requests()
734 .first()
735 .is_some_and(|request| Arc::ptr_eq(request, new));
736 host.stop();
737 kept && no_grant
738 },
739 );
740 assert!(
741 valid,
742 "pairing admitted a retired route or retired Left removed the promoted request"
743 );
744}
745
746#[test]
747fn handover_pair_retired_met_cannot_persist_another_credential() {
748 let directory = tempfile::tempdir().unwrap();
749 let folder = directory.path().join("notebook");
750 std::fs::create_dir(&folder).unwrap();
751 let sharing = Sharing {
752 approve: false,
753 code: super::super::super::code::format(702, "ABCDEF").unwrap(),
754 ..Sharing::new("").unwrap()
755 };
756 let room = Room::share(&sharing.code, &sharing.password);
757 let kept = Arc::new(AtomicUsize::new(0));
758 let count = Arc::clone(&kept);
759 let host = Host::start(
760 crate::session::Notebook::open(&folder, directory.path().join("cache"))
761 .unwrap()
762 .into_storage(),
763 Hello::new("Notebook owner".into(), None).unwrap(),
764 sharing,
765 "Fixture",
766 None,
767 None,
768 || {},
769 move |_| {
770 count.fetch_add(1, Ordering::SeqCst);
771 Ok(())
772 },
773 )
774 .unwrap();
775 let callback = Arc::clone(&host.pairing.lock().unwrap().as_ref().unwrap().shared);
776 let valid = promoted_routes(
777 room,
778 |_, _, _| {},
779 |source, old, old_line, new, new_line| {
780 (callback.events)(source, Event::Met(new, new_line));
781 let after_current = kept.load(Ordering::SeqCst);
782 (callback.events)(source, Event::Met(old, old_line));
783 let refused = kept.load(Ordering::SeqCst) == after_current
784 && after_current == 2
785 && host.sharing().members.len() == 1;
786 host.stop();
787 refused
788 },
789 );
790 assert!(valid, "retired pairing Met persisted another credential");
791}
792
793#[test]
794fn handover_retired_membership_rejects_deferred_access_met() {
795 let directory = tempfile::tempdir().unwrap();
796 let folder = directory.path().join("notebook");
797 std::fs::create_dir(&folder).unwrap();
798 let secret = [71; 16];
799 let sharing = Sharing {
800 code: super::super::super::code::format(703, "ABCDEF").unwrap(),
801 members: vec![Device {
802 secret,
803 name: "Retired device".into(),
804 device: None,
805 landed: BTreeMap::new(),
806 }],
807 ..Sharing::new("").unwrap()
808 };
809 let host = Host::start(
810 crate::session::Notebook::open(&folder, directory.path().join("cache"))
811 .unwrap()
812 .into_storage(),
813 Hello::new("Notebook owner".into(), None).unwrap(),
814 sharing,
815 "Fixture",
816 None,
817 None,
818 || {},
819 |_| Ok(()),
820 )
821 .unwrap();
822 let callback = Arc::clone(&host.members.access.lock().unwrap()[&secret].shared);
823 let refused = promoted_routes(
824 Room::Notebook(secret),
825 |_, _, _| {},
826 |source, _, _, current, line| {
827 host.remove(&secret).unwrap();
828 (callback.events)(source, Event::Met(current, line));
829 let refused = host.members.served.guests.lock().unwrap().is_empty()
830 && host.sharing().members.is_empty();
831 host.stop();
832 refused
833 },
834 );
835 assert!(
836 refused,
837 "deferred access callback readmitted a removed device"
838 );
839}