1use super::*;
2
3pub struct Host {
4 members: Arc<Members>,
5 pairing: Mutex<Option<Live>>,
6}
7
8#[allow(clippy::type_complexity)]
9pub(super) struct Members {
10 me: Hello,
11 notebook: String,
12 reach: Option<Reach>,
13 relay: Option<String>,
14 sharing: Mutex<Sharing>,
15 changes: Mutex<()>,
16 pending: Mutex<BTreeMap<[u8; 16], (Arc<Hello>, Line, Weak<super::super::Shared>)>>,
17 access: Mutex<HashMap<[u8; 16], Live>>,
18 room: Mutex<Option<Live>>,
19 served: Arc<Served>,
20 events: Arc<dyn Fn() + Send + Sync>,
21 keep: Box<dyn Fn(&Sharing) -> io::Result<()> + Send + Sync>,
22 /// Commits noted in `sharing` that it does not keep yet.
23 unkept: AtomicBool,
24}
25
26/// How long a commit noted waits to be kept, so that a burst of them is kept once.
27const KEEP_LANDED: Duration = Duration::from_secs(2);
28
29impl Drop for Members {
30 fn drop(&mut self) {
31 self.keep_landed();
32 }
33}
34
35impl Host {
36 /// Shares a notebook, keeping every credential change before granting or revoking access.
37 #[allow(clippy::too_many_arguments)]
38 pub fn start(
39 storage: Box<dyn Storage>,
40 me: Hello,
41 sharing: Sharing,
42 notebook: &str,
43 reach: Option<Reach>,
44 relay: Option<&str>,
45 events: impl Fn() + Send + Sync + 'static,
46 keep: impl Fn(&Sharing) -> io::Result<()> + Send + Sync + 'static,
47 ) -> io::Result<Self> {
48 keep(&sharing)?;
49 let members = Arc::new_cyclic(|members| Members {
50 me,
51 notebook: notebook.to_owned(),
52 reach,
53 relay: relay.map(str::to_owned),
54 sharing: Mutex::new(sharing),
55 changes: Mutex::default(),
56 pending: Mutex::default(),
57 access: Mutex::default(),
58 room: Mutex::default(),
59 served: Arc::new(Served {
60 storage,
61 images: Mutex::default(),
62 snapshots: Mutex::default(),
63 puts: Mutex::default(),
64 guests: Mutex::default(),
65 writers: Mutex::default(),
66 members: members.clone(),
67 host: Mutex::default(),
68 room: Mutex::default(),
69 }),
70 events: Arc::new(events),
71 keep: Box::new(keep),
72 unkept: AtomicBool::new(false),
73 });
74 let sharing = members.sharing.lock().unwrap().clone();
75 members.presence(sharing.secret)?;
76 for device in &sharing.members {
77 members.open(device.secret)?;
78 }
79 let pairing = Mutex::new(Some(members.pair(&sharing)?));
80 Ok(Self { members, pairing })
81 }
82
83 pub fn code(&self) -> Option<String> {
84 let mut pairing = self.pairing.lock().unwrap();
85 let pairing = pairing.as_mut()?;
86 let mut sharing = self.members.sharing.lock().unwrap();
87 if pairing.burned() {
88 let mut next = sharing.clone();
89 next.code = super::super::code::secret().ok()?;
90 (self.members.keep)(&next).ok()?;
91 *pairing = self.members.pair(&next).ok()?;
92 *sharing = next;
93 }
94 let code = pairing.code();
95 if let Some(code) = &code
96 && *code != sharing.code
97 {
98 let mut next = sharing.clone();
99 next.code = code.clone();
100 (self.members.keep)(&next).ok()?;
101 *sharing = next;
102 }
103 code
104 }
105
106 pub fn sharing(&self) -> Sharing {
107 self.code();
108 self.members.sharing.lock().unwrap().clone()
109 }
110
111 pub fn relayed(&self) -> Relayed {
112 self.pairing
113 .lock()
114 .unwrap()
115 .as_ref()
116 .map_or(Relayed::Unknown, Live::relayed)
117 }
118
119 pub fn guests(&self) -> Vec<Peer> {
120 self.members
121 .room
122 .lock()
123 .unwrap()
124 .as_ref()
125 .map(Live::peers)
126 .unwrap_or_default()
127 }
128
129 pub fn devices(&self) -> Vec<(Device, bool)> {
130 let sharing = self.members.sharing.lock().unwrap();
131 let access = self.members.access.lock().unwrap();
132 sharing
133 .members
134 .iter()
135 .map(|device| {
136 let connected = access
137 .get(&device.secret)
138 .is_some_and(|live| !live.peers().is_empty());
139 (device.clone(), connected)
140 })
141 .collect()
142 }
143
144 pub fn requests(&self) -> Vec<Arc<Hello>> {
145 self.members
146 .pending
147 .lock()
148 .unwrap()
149 .values()
150 .map(|(hello, _, _)| Arc::clone(hello))
151 .collect()
152 }
153
154 pub fn approve(&self, approve: bool) -> io::Result<()> {
155 let mut sharing = self.members.sharing.lock().unwrap();
156 let mut next = sharing.clone();
157 next.approve = approve;
158 (self.members.keep)(&next)?;
159 *sharing = next;
160 drop(sharing);
161 if !approve {
162 for hello in self.requests() {
163 self.allow(&hello.peer)?;
164 }
165 }
166 (self.members.events)();
167 Ok(())
168 }
169
170 /// Admits the device asking as `peer`, or drops its request if it has gone.
171 pub fn allow(&self, peer: &[u8; 16]) -> io::Result<()> {
172 let request = self.members.pending.lock().unwrap().remove(peer);
173 let Some((hello, line, source)) = request else {
174 return Ok(());
175 };
176 let connected = || {
177 source
178 .upgrade()
179 .is_some_and(|source| source.connected(&hello))
180 };
181 if connected()
182 && let Err(error) = self.members.grant(&hello, &line)
183 {
184 let mut pending = self.members.pending.lock().unwrap();
185 if connected() && !pending.contains_key(peer) {
186 pending.insert(*peer, (hello, line, source));
187 }
188 return Err(error);
189 }
190 (self.members.events)();
191 Ok(())
192 }
193
194 pub fn decline(&self, peer: &[u8; 16]) {
195 let request = self.members.pending.lock().unwrap().remove(peer);
196 if let Some((_, line, _)) = request {
197 let _ = line.send(kind::APPROVAL, &wire::Approval::Declined);
198 (self.members.events)();
199 }
200 }
201
202 pub fn remove(&self, secret: &[u8; 16]) -> io::Result<()> {
203 let _change = self.members.changes.lock().unwrap();
204 let mut sharing = self.members.sharing.lock().unwrap();
205 if !sharing
206 .members
207 .iter()
208 .any(|device| device.secret == *secret)
209 {
210 return Ok(());
211 }
212 let mut next = sharing.clone();
213 next.members.retain(|device| device.secret != *secret);
214 getrandom::fill(&mut next.secret)
215 .map_err(|_| io::Error::other("System random source failed"))?;
216 next.code = super::super::code::secret()?;
217 (self.members.keep)(&next)?;
218 *sharing = next.clone();
219 drop(sharing);
220 let removed = self.members.access.lock().unwrap().remove(secret);
221 if let Some(removed) = removed {
222 for peer in removed.peers() {
223 self.members.served.forget(&peer.hello.peer, None);
224 }
225 removed.leave("removed");
226 }
227 self.members.presence(next.secret)?;
228 *self.pairing.lock().unwrap() = Some(self.members.pair(&next)?);
229 let welcomes = {
230 let access = self.members.access.lock().unwrap();
231 next.members
232 .iter()
233 .filter_map(|device| Some((device.secret, access.get(&device.secret)?)))
234 .flat_map(|(secret, live)| {
235 let welcome = self.members.welcome(&next, secret);
236 (live.peers().into_iter())
237 .filter_map(|peer| live.line(&peer.hello.peer))
238 .map(move |line| (welcome.clone(), line))
239 })
240 .collect::<Vec<_>>()
241 };
242 // Browser send failures may reenter a removal that rotates the room again.
243 #[cfg(target_arch = "wasm32")]
244 drop(_change);
245 for (welcome, line) in welcomes {
246 #[cfg(target_arch = "wasm32")]
247 if self.members.sharing.lock().unwrap().secret != next.secret {
248 break;
249 }
250 let _ = line.send(kind::WELCOME, &welcome);
251 }
252 (self.members.events)();
253 Ok(())
254 }
255
256 pub fn set_presence(&self, presence: Presence) {
257 if let Some(room) = &*self.members.room.lock().unwrap() {
258 room.set_presence(presence);
259 }
260 }
261
262 pub fn on_changed(&self, listener: crate::session::Listener) {
263 *self.members.served.host.lock().unwrap() = Some(listener);
264 }
265
266 pub fn touched(&self, paths: &[String]) {
267 for path in paths {
268 self.members.served.changed_here(path);
269 }
270 self.members.served.tell(paths);
271 }
272
273 pub fn stop(&self) {
274 let _change = self.members.changes.lock().unwrap();
275 drop(self.pairing.lock().unwrap().take());
276 self.members.pending.lock().unwrap().clear();
277 let access = std::mem::take(&mut *self.members.access.lock().unwrap());
278 for (_, live) in access {
279 live.leave(STOPPED);
280 }
281 drop(self.members.room.lock().unwrap().take());
282 }
283}
284
285impl Members {
286 /// What device `secret` last landed on the section at `path`.
287 pub(super) fn landed(&self, secret: &[u8; 16], path: &str) -> Option<Landed> {
288 let sharing = self.sharing.lock().unwrap();
289 let device = sharing
290 .members
291 .iter()
292 .find(|device| device.secret == *secret)?;
293 device.landed.get(path).cloned()
294 }
295
296 /// Notes `landed` as what device `secret` last landed on the section at `path`, in place
297 /// of the commit before, which the device has since heard of, and keeps the share soon.
298 pub(super) fn remember(self: &Arc<Self>, secret: &[u8; 16], path: &str, landed: Landed) {
299 let mut sharing = self.sharing.lock().unwrap();
300 let Some(device) = (sharing.members.iter_mut()).find(|device| device.secret == *secret)
301 else {
302 return;
303 };
304 device.landed.insert(path.to_owned(), landed);
305 drop(sharing);
306 if self.unkept.swap(true, Ordering::AcqRel) {
307 return;
308 }
309 let members = Arc::downgrade(self);
310 thread::spawn(move || {
311 thread::sleep(KEEP_LANDED);
312 if let Some(members) = members.upgrade() {
313 members.keep_landed();
314 }
315 });
316 }
317
318 /// Keeps the share where commits it noted since are not kept yet, unless it stopped,
319 /// whose host keeps it no more.
320 fn keep_landed(&self) {
321 let _change = self.changes.lock().unwrap();
322 let sharing = self.sharing.lock().unwrap();
323 if self.unkept.swap(false, Ordering::AcqRel)
324 && self.room.lock().unwrap().is_some()
325 && let Err(error) = (self.keep)(&sharing)
326 {
327 eprintln!("Live Share: could not keep guests' commits: {error}");
328 }
329 }
330
331 fn welcome(&self, sharing: &Sharing, secret: [u8; 16]) -> Welcome {
332 Welcome {
333 share: sharing.share,
334 secret,
335 room: sharing.secret,
336 notebook: self.notebook.clone(),
337 host: self.me.name.clone(),
338 }
339 }
340
341 fn presence(self: &Arc<Self>, secret: [u8; 16]) -> io::Result<()> {
342 let told = Arc::clone(&self.events);
343 let live = Live::start(
344 self.me.clone(),
345 &Room::Notebook(secret),
346 self.reach,
347 self.relay.as_deref(),
348 move |_| told(),
349 )?;
350 *self.served.room.lock().unwrap() = Some(live.sender());
351 *self.room.lock().unwrap() = Some(live);
352 Ok(())
353 }
354
355 fn open(self: &Arc<Self>, secret: [u8; 16]) -> io::Result<()> {
356 let members = Arc::downgrade(self);
357 let live = Live::start_with(
358 Hello {
359 serves: Some(self.sharing.lock().unwrap().share),
360 ..self.me.clone()
361 },
362 &Room::Notebook(secret),
363 self.reach,
364 self.relay.as_deref(),
365 move |source, event| {
366 let Some(members) = members.upgrade() else {
367 return;
368 };
369 match event {
370 Event::Met(hello, line) => {
371 let sharing = members.sharing.lock().unwrap();
372 let admitted =
373 if sharing.members.iter().any(|device| device.secret == secret) {
374 Ok(members
375 .served
376 .admit(source, hello, secret, line)
377 .then(|| members.welcome(&sharing, secret)))
378 } else {
379 Err(())
380 };
381 // Browser send failures may reenter membership callbacks.
382 #[cfg(target_arch = "wasm32")]
383 drop(sharing);
384 match admitted {
385 Ok(Some(welcome)) => {
386 let _ = line.send(kind::WELCOME, &welcome);
387 }
388 Err(()) => line.hang_up("removed"),
389 Ok(None) => {}
390 }
391 }
392 Event::Left(hello) => members.served.forget(&hello.peer, Some((source, hello))),
393 Event::Frame { from, kind, body }
394 if wire::KNOWN.contains(&kind) && kind > 256 && kind != kind::REPLY =>
395 {
396 members.served.queue(source, from, kind, body)
397 }
398 Event::Changed => (members.events)(),
399 _ => {}
400 }
401 },
402 )?;
403 self.access.lock().unwrap().insert(secret, live);
404 Ok(())
405 }
406
407 fn grant(self: &Arc<Self>, hello: &Hello, line: &Line) -> io::Result<()> {
408 let _change = self.changes.lock().unwrap();
409 if self.room.lock().unwrap().is_none() {
410 return Err(io::ErrorKind::NotConnected.into());
411 }
412 let mut secret = [0; 16];
413 getrandom::fill(&mut secret)
414 .map_err(|_| io::Error::other("System random source failed"))?;
415 if self.sharing.lock().unwrap().members.len() >= 64 {
416 return Err(io::ErrorKind::ResourceBusy.into());
417 }
418 self.open(secret)?;
419 let kept = (|| -> io::Result<Welcome> {
420 let mut sharing = self.sharing.lock().unwrap();
421 let mut next = sharing.clone();
422 next.members.push(Device {
423 secret,
424 name: hello.name.clone(),
425 device: hello.device.clone(),
426 landed: BTreeMap::new(),
427 });
428 (self.keep)(&next)?;
429 *sharing = next;
430 Ok(self.welcome(&sharing, secret))
431 })();
432 let welcome = match kept {
433 Ok(welcome) => welcome,
434 Err(error) => {
435 drop(self.access.lock().unwrap().remove(&secret));
436 return Err(error);
437 }
438 };
439 line.send(kind::WELCOME, &welcome)?;
440 (self.events)();
441 Ok(())
442 }
443
444 fn pair(self: &Arc<Self>, sharing: &Sharing) -> io::Result<Live> {
445 let members = Arc::downgrade(self);
446 Live::start_with(
447 Hello {
448 serves: None,
449 ..self.me.clone()
450 },
451 &Room::share(&sharing.code, &sharing.password),
452 self.reach,
453 self.relay.as_deref(),
454 move |source, event| {
455 let Some(members) = members.upgrade() else {
456 return;
457 };
458 match event {
459 Event::Met(hello, line) => {
460 let approve = members.sharing.lock().unwrap().approve;
461 let (approval, retired) = {
462 let mut pending = members.pending.lock().unwrap();
463 if !source.connected(hello) {
464 return;
465 }
466 if approve {
467 if pending.len() < 32 || pending.contains_key(&hello.peer) {
468 (
469 Some(wire::Approval::Pending),
470 pending.insert(
471 hello.peer,
472 (
473 Arc::clone(hello),
474 line.clone(),
475 Arc::downgrade(source),
476 ),
477 ),
478 )
479 } else {
480 (Some(wire::Approval::Failed), None)
481 }
482 } else {
483 (None, None)
484 }
485 };
486 drop(retired);
487 if let Some(approval) = approval {
488 let _ = line.send(kind::APPROVAL, &approval);
489 (members.events)();
490 } else if let Err(error) = members.grant(hello, line) {
491 eprintln!("Live Share: could not admit a device: {error}");
492 let _ = line.send(kind::APPROVAL, &wire::Approval::Failed);
493 }
494 }
495 Event::Left(hello) => {
496 let retired = {
497 let mut pending = members.pending.lock().unwrap();
498 if source.gone(hello)
499 && pending
500 .get(&hello.peer)
501 .is_some_and(|(admitted, _, _)| Arc::ptr_eq(admitted, hello))
502 {
503 pending.remove(&hello.peer)
504 } else {
505 None
506 }
507 };
508 drop(retired);
509 (members.events)();
510 }
511 Event::Changed => (members.events)(),
512 _ => {}
513 }
514 },
515 )
516 }
517}
518
519#[cfg(all(test, not(target_arch = "wasm32")))]
520#[path = "handover_tests.rs"]
521mod handover_tests;