1use super::Guid;
12use crate::HvsockRelayChannelHalf;
13use crate::ring::RingMem;
14use anyhow::Context;
15use futures::AsyncReadExt;
16use futures::AsyncWriteExt;
17use futures::StreamExt;
18use futures_concurrency::stream::Merge;
19use hybrid_vsock::HYBRID_CONNECT_REQUEST_LEN;
20use hybrid_vsock::VsockPortOrId;
21use mesh::CancelContext;
22use pal_async::driver::SpawnDriver;
23use pal_async::socket::PolledSocket;
24use pal_async::task::Spawn;
25use pal_async::task::Task;
26use std::collections::HashMap;
27use std::collections::hash_map;
28use std::io::ErrorKind;
29use std::path::Path;
30use std::path::PathBuf;
31use std::sync::Arc;
32use std::time::Duration;
33use unicycle::FuturesUnordered;
34use unix_socket::UnixListener;
35use unix_socket::UnixStream;
36use vmbus_async::pipe::BytePipe;
37use vmbus_channel::bus::ChannelType;
38use vmbus_channel::bus::OfferParams;
39use vmbus_channel::bus::ParentBus;
40use vmbus_channel::offer::Offer;
41use vmbus_core::HvsockConnectRequest;
42use vmbus_core::HvsockConnectResult;
43
44pub struct HvsockRelay {
45 inner: Arc<RelayInner>,
46 host_send: mesh::Sender<RelayRequest>,
47 _relay_task: Task<()>,
48 _listener_task: Option<Task<()>>,
49 service_listener_tasks: HashMap<Guid, Task<()>>,
50}
51
52enum RelayRequest {
53 AddTask(Task<()>),
54}
55
56struct RelayInner {
57 vmbus: Arc<dyn ParentBus>,
58 driver: Box<dyn SpawnDriver>,
59}
60
61impl HvsockRelay {
62 pub fn new(
65 driver: impl SpawnDriver,
66 vmbus: Arc<dyn ParentBus>,
67 guest: HvsockRelayChannelHalf,
68 hybrid_vsock_path: Option<PathBuf>,
69 hybrid_vsock_listener: Option<UnixListener>,
70 ) -> anyhow::Result<Self> {
71 let inner = Arc::new(RelayInner {
72 vmbus,
73 driver: Box::new(driver),
74 });
75
76 let worker = HvsockRelayWorker {
77 guest_send: guest.response_send,
78 inner: inner.clone(),
79 tasks: Default::default(),
80 hybrid_vsock_path,
81 };
82
83 let (host_send, host_recv) = mesh::channel();
84
85 let _listener_task = if let Some(listener) = hybrid_vsock_listener {
86 let listener = PolledSocket::new(inner.driver.as_ref(), listener)?;
87 Some(
88 inner.driver.spawn(
89 "hvsock-listener",
90 ListenerWorker {
91 inner: inner.clone(),
92 host_send: host_send.clone(),
93 service_id: None,
94 }
95 .run(listener),
96 ),
97 )
98 } else {
99 None
100 };
101
102 let task = inner
103 .driver
104 .spawn("hvsock relay", worker.run(guest.request_receive, host_recv));
105
106 Ok(Self {
107 host_send,
108 inner,
109 _relay_task: task,
110 _listener_task,
111 service_listener_tasks: HashMap::new(),
112 })
113 }
114
115 pub fn add_service_listener(
123 &mut self,
124 service_id: Guid,
125 listener: UnixListener,
126 ) -> anyhow::Result<()> {
127 let hash_map::Entry::Vacant(entry) = self.service_listener_tasks.entry(service_id) else {
128 anyhow::bail!("a listener for hvsocket service {service_id} already exists");
129 };
130
131 let listener = PolledSocket::new(self.inner.driver.as_ref(), listener)?;
132 let task = self.inner.driver.spawn(
133 format!("hvsock-listener {service_id}"),
134 ListenerWorker {
135 inner: self.inner.clone(),
136 host_send: self.host_send.clone(),
137 service_id: Some(service_id),
138 }
139 .run(listener),
140 );
141
142 entry.insert(task);
143 Ok(())
144 }
145
146 pub async fn remove_service_listener(&mut self, service_id: Guid) -> anyhow::Result<()> {
150 let task = self
151 .service_listener_tasks
152 .remove(&service_id)
153 .with_context(|| format!("no listener for hvsocket service {service_id}"))?;
154
155 task.cancel().await;
156 Ok(())
157 }
158
159 pub fn connect(
164 &self,
165 ctx: &mut CancelContext,
166 service_id: Guid,
167 ) -> impl Future<Output = anyhow::Result<UnixStream>> + Send + use<> {
168 let inner = self.inner.clone();
169 let host_send = self.host_send.clone();
170 let (send, recv) = mesh::oneshot();
171
172 let (mut ctx, cancel) = ctx.with_cancel();
174
175 let task = self.inner.driver.spawn("hvsock-connect", async move {
177 let r = async {
178 let (stream, task) = ctx
179 .until_cancelled(inner.connect_to_guest(service_id))
180 .await??;
181 host_send.send(RelayRequest::AddTask(task));
182 Ok(stream)
183 }
184 .await;
185
186 send.send(r);
187 });
188 self.host_send.send(RelayRequest::AddTask(task));
189 async move {
190 let _cancel = cancel;
191 recv.await?
192 }
193 }
194}
195
196struct ListenerWorker {
197 inner: Arc<RelayInner>,
198 host_send: mesh::Sender<RelayRequest>,
199 service_id: Option<Guid>,
202}
203
204impl ListenerWorker {
205 async fn run(self, mut listener: PolledSocket<UnixListener>) {
206 loop {
207 let connection = match listener.accept().await {
208 Ok((connection, _address)) => connection,
209 Err(err) => {
210 tracing::error!(
211 error = &err as &dyn std::error::Error,
212 "failed to accept hybrid vsock connection, shutting down listener"
213 );
214 break;
215 }
216 };
217 match self.spawn_relay(connection).await {
218 Ok(task) => {
219 self.host_send.send(RelayRequest::AddTask(task));
220 }
221 Err(err) => {
222 tracing::warn!(
223 error = err.as_ref() as &dyn std::error::Error,
224 "relayed connection failed"
225 );
226 }
227 }
228 }
229 }
230
231 async fn spawn_relay(&self, connection: UnixStream) -> anyhow::Result<Task<()>> {
232 let mut socket = PolledSocket::new(self.inner.driver.as_ref(), connection)?;
233 let (service_id, request) = match self.service_id {
234 Some(service_id) => (service_id, None),
235 None => {
236 let request = read_hybrid_vsock_connect(&mut socket).await?;
237 (request.id(), Some(request))
238 }
239 };
240
241 let instance_id = Guid::new_random();
242 let mut offer = Offer::new(
243 self.inner.driver.as_ref(),
244 self.inner.vmbus.as_ref(),
245 OfferParams {
246 interface_name: "hvsocket_connect".into(),
247 interface_id: service_id,
248 instance_id,
249 channel_type: ChannelType::HvSocket {
250 is_connect: true,
251 is_for_container: false,
252 silo_id: Guid::ZERO,
253 },
254 ..Default::default()
255 },
256 )
257 .await
258 .context("failed to offer channel")?;
259
260 let channel = CancelContext::new()
261 .with_timeout(Duration::from_secs(2))
262 .until_cancelled(offer.wait_for_open(self.inner.driver.as_ref()))
263 .await?
264 .context("failed to accept channel")?
265 .accept()
266 .channel;
267
268 let pipe = BytePipe::new(channel).context("failed to create vmbus pipe")?;
269
270 tracing::debug!(%service_id, endpoint_id = %instance_id, "connected host to guest");
271
272 let task = self
273 .inner
274 .driver
275 .spawn("hvsock connection relay", async move {
276 let _offer = offer;
278
279 if let Some(request) = request {
280 let response = match request {
283 VsockPortOrId::Port(_) => VsockPortOrId::Port(instance_id.data1),
284 VsockPortOrId::Id(_) => VsockPortOrId::Id(instance_id),
285 };
286 let s = response.get_ok_response();
287 if let Err(err) = socket.write_all(s.as_bytes()).await {
288 tracing::error!(
289 %service_id,
290 error = &err as &dyn std::error::Error,
291 "failed to write OK response"
292 );
293 }
294 }
295
296 if let Err(err) = relay_connected(pipe, socket).await {
297 tracing::error!(
298 %service_id,
299 error = &err as &dyn std::error::Error,
300 "connection relay failed"
301 );
302 } else {
303 tracing::debug!(%service_id, "connection relay finished");
304 }
305 });
306
307 Ok(task)
308 }
309}
310
311async fn read_hybrid_vsock_connect(
312 socket: &mut PolledSocket<UnixStream>,
313) -> anyhow::Result<VsockPortOrId> {
314 let mut buf = [0; HYBRID_CONNECT_REQUEST_LEN];
315 let mut i = 0;
316 while i == 0 || buf[i - 1] != b'\n' {
317 if i == buf.len() {
318 anyhow::bail!("connect request did not fit");
319 }
320 let n = socket
321 .read(&mut buf[i..])
322 .await
323 .context("failed to read connect request")?;
324 if n == 0 {
325 anyhow::bail!("no connect request");
326 }
327 i += n;
328 }
329
330 let request = VsockPortOrId::parse_connect_request(&buf[..i - 1])?;
331 tracing::debug!(?request, "got hybrid connect request");
332 Ok(request)
333}
334
335struct PendingConnection {
336 send: mesh::Sender<HvsockConnectResult>,
337 request: HvsockConnectRequest,
338}
339
340impl PendingConnection {
341 fn done(self, success: bool) {
342 self.send
343 .send(HvsockConnectResult::from_request(&self.request, success));
344 std::mem::forget(self);
345 }
346}
347
348impl Drop for PendingConnection {
349 fn drop(&mut self) {
350 self.send
351 .send(HvsockConnectResult::from_request(&self.request, false));
352 }
353}
354
355struct HvsockRelayWorker {
356 guest_send: mesh::Sender<HvsockConnectResult>,
357 tasks: FuturesUnordered<Task<()>>,
358 inner: Arc<RelayInner>,
359 hybrid_vsock_path: Option<PathBuf>,
360}
361
362impl HvsockRelayWorker {
363 async fn run(
364 mut self,
365 guest_recv: mesh::Receiver<HvsockConnectRequest>,
366 host_recv: mesh::Receiver<RelayRequest>,
367 ) {
368 enum Event {
369 Guest(HvsockConnectRequest),
370 Host(RelayRequest),
371 TaskDone(()),
372 }
373
374 let mut recv = (guest_recv.map(Event::Guest), host_recv.map(Event::Host)).merge();
375
376 while let Some(event) = (&mut recv, (&mut self.tasks).map(Event::TaskDone))
377 .merge()
378 .next()
379 .await
380 {
381 match event {
382 Event::Guest(request) => {
383 self.handle_connect_from_guest(request);
384 }
385 Event::Host(request) => match request {
386 RelayRequest::AddTask(task) => {
387 self.tasks.push(task);
388 }
389 },
390 Event::TaskDone(()) => {}
391 }
392 }
393 }
394
395 fn handle_connect_from_guest(&mut self, request: HvsockConnectRequest) {
396 if request.silo_id != Guid::ZERO {
397 tracelimit::warn_ratelimited!(?request, "Non-zero silo ID is currently ignored.")
398 }
399
400 let pending = PendingConnection {
402 send: self.guest_send.clone(),
403 request,
404 };
405 let path = {
406 if let Some(hybrid_vsock_path) = &self.hybrid_vsock_path {
407 hybrid_vsock_path.to_owned()
408 } else {
409 tracing::debug!(request = ?&request, "ignoring hvsock connect request");
410 return;
411 }
412 };
413
414 let task = self.inner.driver.spawn(
415 format!(
416 "hvsock accept {}:{}",
417 request.service_id, request.endpoint_id
418 ),
419 {
420 let inner = self.inner.clone();
421 async move {
422 match inner
423 .relay_guest_connect_to_host(pending, path.as_ref())
424 .await
425 {
426 Ok(()) => {
427 tracing::debug!(request = ?&request, "relay done");
428 }
429 Err(err) => {
430 tracelimit::error_ratelimited!(
431 request = ?&request,
432 err = err.as_ref() as &dyn std::error::Error,
433 "relay error"
434 );
435 }
436 }
437 }
438 },
439 );
440 self.tasks.push(task);
441 }
442}
443
444impl RelayInner {
445 async fn relay_guest_connect_to_host(
446 &self,
447 pending: PendingConnection,
448 base_path: &Path,
449 ) -> anyhow::Result<()> {
450 let request = &pending.request;
451
452 let vsock_request = VsockPortOrId::Id(request.service_id);
457 let path = vsock_request.host_uds_path(base_path)?;
458
459 let mut offer = Offer::new(
460 self.driver.as_ref(),
461 self.vmbus.as_ref(),
462 OfferParams {
463 interface_name: "hvsocket".to_owned(),
464 instance_id: request.endpoint_id,
465 interface_id: request.service_id,
466 channel_type: ChannelType::HvSocket {
467 is_connect: false,
468 is_for_container: false,
469 silo_id: Guid::ZERO,
470 },
471 ..Default::default()
472 },
473 )
474 .await
475 .context("failed to offer channel")?;
476
477 tracing::debug!(?request, "offered hvsocket channel to guest");
478 let service_id = request.service_id;
479
480 pending.done(true);
483
484 let channel = CancelContext::new()
486 .with_timeout(Duration::from_secs(5))
487 .until_cancelled(offer.wait_for_open(self.driver.as_ref()))
488 .await
489 .context("guest did not open hvsocket channel")??;
490
491 tracing::debug!(%service_id, "guest opened hvsocket channel");
492
493 let socket = PolledSocket::connect_unix(self.driver.as_ref(), &path)
495 .await
496 .with_context(|| {
497 format!(
498 "failed to connect to registered listener {} for {}",
499 path.display(),
500 service_id
501 )
502 })?;
503
504 tracing::debug!(%service_id, path = %path.display(), "connected to host uds socket");
505
506 let channel = channel.accept().channel;
508
509 let channel = BytePipe::new(channel)?;
510 if let Err(err) = relay_connected(channel, socket).await {
511 tracelimit::error_ratelimited!(
512 %service_id,
513 error = &err as &dyn std::error::Error,
514 "guest to host connection relay failed"
515 );
516 } else {
517 tracing::debug!(%service_id, "guest to host connection relay finished");
518 }
519
520 drop(offer);
523 Ok(())
524 }
525
526 async fn connect_to_guest(&self, service_id: Guid) -> anyhow::Result<(UnixStream, Task<()>)> {
527 let instance_id = Guid::new_random();
528 let mut offer = Offer::new(
529 &self.driver,
530 self.vmbus.as_ref(),
531 OfferParams {
532 interface_name: "hvsocket_connect".into(),
533 interface_id: service_id,
534 instance_id,
535 channel_type: ChannelType::HvSocket {
536 is_connect: true,
537 is_for_container: false,
538 silo_id: Guid::ZERO,
539 },
540 ..Default::default()
541 },
542 )
543 .await
544 .context("failed to offer channel")?;
545
546 let channel = offer
547 .wait_for_open(self.driver.as_ref())
548 .await
549 .context("failed to accept channel")?
550 .accept()
551 .channel;
552 let pipe = BytePipe::new(channel).context("failed to create vmbus pipe")?;
553
554 tracing::debug!(%service_id, endpoint_id = %instance_id, "connected host to guest");
555
556 let (left, right) = UnixStream::pair().context("failed to create socket pair")?;
557 let right = PolledSocket::new(self.driver.as_ref(), right)
558 .context("failed to create polled socket")?;
559
560 let task = self.driver.spawn(
561 format!("hvsock {}:{}", service_id, instance_id),
562 async move {
563 let _offer = offer;
565 if let Err(err) = relay_connected(pipe, right).await {
566 tracing::error!(
567 %service_id,
568 error = &err as &dyn std::error::Error,
569 "connection relay failed"
570 );
571 }
572 },
573 );
574
575 Ok((left, task))
576 }
577}
578
579async fn relay_connected<T: RingMem + Unpin>(
580 channel: BytePipe<T>,
581 socket: PolledSocket<UnixStream>,
582) -> std::io::Result<()> {
583 let (channel_read, mut channel_write) = channel.split();
584 let (socket_read, mut socket_write) = socket.split();
585
586 let channel_to_socket = async {
587 futures::io::copy(channel_read, &mut socket_write).await?;
588 socket_write.close().await
589 };
590
591 let socket_to_channel = async {
592 futures::io::copy(socket_read, &mut channel_write).await?;
593 channel_write.close().await
594 };
595
596 match futures::future::try_join(channel_to_socket, socket_to_channel).await {
597 Ok(((), ())) => {}
598 Err(err) if err.kind() == ErrorKind::ConnectionReset => {}
599 Err(err) => return Err(err),
600 }
601 Ok(())
602}
603
604#[cfg(test)]
605mod tests {
606 use super::HvsockRelay;
607 use super::relay_connected;
608 use crate::HvsockRelayChannel;
609 use crate::ring::FlatRingMem;
610 use async_trait::async_trait;
611 use futures::AsyncReadExt;
612 use futures::AsyncWriteExt;
613 use futures::StreamExt;
614 use guid::Guid;
615 use pal_async::DefaultDriver;
616 use pal_async::async_test;
617 use pal_async::driver::Driver;
618 use pal_async::socket::PolledSocket;
619 use pal_async::task::Spawn;
620 use pal_async::task::Task;
621 use std::sync::Arc;
622 use unix_socket::UnixListener;
623 use unix_socket::UnixStream;
624 use vmbus_async::pipe::BytePipe;
625 use vmbus_async::pipe::connected_byte_pipes;
626 use vmbus_channel::bus::OfferInput;
627 use vmbus_channel::bus::OfferParams;
628 use vmbus_channel::bus::OfferResources;
629 use vmbus_channel::bus::ParentBus;
630
631 use guestmem::GuestMemory;
632 use mesh::rpc::RpcSend;
633 use pal_event::Event;
634 use vmbus_channel::ChannelClosed;
635 use vmbus_channel::RawAsyncChannel;
636 use vmbus_channel::SignalVmbusChannel;
637 use vmbus_channel::bus::ChannelRequest;
638 use vmbus_channel::bus::GpadlRequest;
639 use vmbus_channel::bus::OpenData;
640 use vmbus_channel::bus::OpenRequest;
641 use vmbus_channel::gpadl::GpadlMap;
642 use vmbus_channel::gpadl_ring::AlignedGpadlView;
643 use vmbus_channel::gpadl_ring::GpadlRingMem;
644 use vmbus_core::protocol::GpadlId;
645 use vmbus_ring::IncomingRing;
646 use vmbus_ring::OutgoingRing;
647 use vmbus_ring::gparange::MultiPagedRangeBuf;
648 use vmcore::interrupt::Interrupt;
649 use vmcore::notify::Notify;
650 use vmcore::notify::PolledNotify;
651
652 struct TestBus {
653 memory: GuestMemory,
654 offers: mesh::Sender<OfferInput>,
655 }
656
657 #[async_trait]
658 impl ParentBus for TestBus {
659 async fn add_child(&self, request: OfferInput) -> anyhow::Result<OfferResources> {
660 self.offers.send(request);
661 Ok(OfferResources::new(self.memory.clone(), None))
662 }
663
664 fn clone_bus(&self) -> Box<dyn ParentBus> {
665 Box::new(Self {
666 memory: self.memory.clone(),
667 offers: self.offers.clone(),
668 })
669 }
670 }
671
672 struct TestSignal {
673 event: PolledNotify,
674 interrupt: Interrupt,
675 }
676
677 impl SignalVmbusChannel for TestSignal {
678 fn signal_remote(&self) {
679 self.interrupt.deliver();
680 }
681
682 fn poll_for_signal(
683 &self,
684 cx: &mut std::task::Context<'_>,
685 ) -> std::task::Poll<Result<(), ChannelClosed>> {
686 self.event.poll_wait(cx).map(Ok)
687 }
688 }
689
690 async fn open_guest_pipe(
691 driver: &DefaultDriver,
692 memory: &GuestMemory,
693 offer: &OfferInput,
694 ) -> BytePipe<GpadlRingMem> {
695 let buf = vec![4 * 4096, 0, 1, 2, 3];
696 assert!(
697 offer
698 .request_send
699 .call(
700 ChannelRequest::Gpadl,
701 GpadlRequest {
702 id: GpadlId(1),
703 count: 1,
704 buf: buf.clone()
705 }
706 )
707 .await
708 .unwrap()
709 );
710 let event = Event::new();
711 let open = offer.request_send.call(
712 ChannelRequest::Open,
713 OpenRequest {
714 open_data: OpenData {
715 target_vp: None,
716 ring_offset: 2,
717 ring_gpadl_id: GpadlId(1),
718 event_flag: 0,
719 connection_id: 0,
720 user_data: Default::default(),
721 },
722 interrupt: Interrupt::from_event(event.clone()),
723 use_confidential_ring: false,
724 use_confidential_external_memory: false,
725 is_external_memory_pinned: false,
726 },
727 );
728 assert!(open.await.unwrap());
729
730 let gpadls = GpadlMap::new();
731 gpadls.add(
732 GpadlId(1),
733 MultiPagedRangeBuf::from_range_buffer(1, buf).unwrap(),
734 );
735 let (out_mem, in_mem) = AlignedGpadlView::new(gpadls.view().map(GpadlId(1)).unwrap())
737 .unwrap()
738 .split(2)
739 .ok()
740 .unwrap();
741 BytePipe::new(RawAsyncChannel {
742 in_ring: IncomingRing::new(GpadlRingMem::new(in_mem, memory).unwrap()).unwrap(),
743 out_ring: OutgoingRing::new(GpadlRingMem::new(out_mem, memory).unwrap()).unwrap(),
744 signal: Box::new(TestSignal {
745 event: Notify::from_event(event).pollable(driver).unwrap(),
746 interrupt: offer.event.clone(),
747 }),
748 })
749 .unwrap()
750 }
751
752 struct OfferRecorder(mesh::Sender<OfferParams>);
754
755 #[async_trait]
756 impl ParentBus for OfferRecorder {
757 async fn add_child(&self, request: OfferInput) -> anyhow::Result<OfferResources> {
758 self.0.send(request.params);
759 anyhow::bail!("offers are not supported")
760 }
761
762 fn clone_bus(&self) -> Box<dyn ParentBus> {
763 Box::new(Self(self.0.clone()))
764 }
765 }
766
767 fn setup_relay<T: Driver + Spawn>(
768 driver: &T,
769 ) -> (
770 BytePipe<FlatRingMem>,
771 PolledSocket<UnixStream>,
772 Task<std::io::Result<()>>,
773 ) {
774 let (hc, c) = connected_byte_pipes(4096);
775 let (s, s2) = UnixStream::pair().unwrap();
776 let s = PolledSocket::new(driver, s).unwrap();
777 let s2 = PolledSocket::new(driver, s2).unwrap();
778 let task = driver.spawn("test", async move { relay_connected(hc, s2).await });
779
780 (c, s, task)
781 }
782
783 #[async_test]
784 async fn test_relay(driver: DefaultDriver) {
785 let (mut c, mut s, task) = setup_relay(&driver);
786
787 let d = b"abcd";
788 let mut v = [0; 4];
789
790 c.write_all(d).await.unwrap();
792 s.read_exact(&mut v).await.unwrap();
793 assert_eq!(&v, d);
794
795 s.write_all(d).await.unwrap();
797 c.read_exact(&mut v).await.unwrap();
798 assert_eq!(&v, d);
799
800 s.write_all(d).await.unwrap();
802 s.close().await.unwrap();
803 c.read_exact(&mut v).await.unwrap();
804 assert_eq!(&v, d);
805
806 c.write_all(d).await.unwrap();
808 s.read_exact(&mut v).await.unwrap();
809 assert_eq!(&v, d);
810
811 c.close().await.unwrap();
812 task.await.unwrap();
813 }
814
815 #[cfg(unix)] #[async_test]
817 async fn test_relay_host_close(driver: DefaultDriver) {
818 let (mut c, _, task) = setup_relay(&driver);
819
820 let mut b = [0];
821 assert_eq!(c.read(&mut b).await.unwrap(), 0);
822 drop(c);
823 task.await.unwrap();
824 }
825
826 #[async_test]
827 async fn test_relay_guest_close(driver: DefaultDriver) {
828 let (_, mut s, task) = setup_relay(&driver);
829
830 let mut b = [0];
831 assert_eq!(s.read(&mut b).await.unwrap(), 0);
832 drop(s);
833 task.await.unwrap();
834 }
835
836 #[async_test]
837 async fn test_relay_forward_socket_shutdown(driver: DefaultDriver) {
838 let (mut c, mut s, task) = setup_relay(&driver);
839 s.close().await.unwrap();
840 let mut v = [0; 1];
841 assert_eq!(c.read(&mut v).await.unwrap(), 0);
842 drop(c);
843 task.await.unwrap();
844 }
845
846 #[async_test]
847 async fn test_relay_forward_channel_shutdown(driver: DefaultDriver) {
848 let (mut c, mut s, task) = setup_relay(&driver);
849
850 c.close().await.unwrap();
851 let mut v = [0; 1];
852 assert_eq!(s.read(&mut v).await.unwrap(), 0);
853 drop(s);
854 task.await.unwrap();
855 }
856
857 #[async_test]
858 async fn test_service_listener(driver: DefaultDriver) {
859 let dir = tempfile::tempdir().unwrap();
860 let path = dir.path().join("service");
861 let (offer_send, mut offer_recv) = mesh::channel();
862 let channel = HvsockRelayChannel::new();
863 let _server_half = channel.server_half;
864 let mut relay = HvsockRelay::new(
865 driver.clone(),
866 Arc::new(OfferRecorder(offer_send)),
867 channel.relay_half,
868 None,
869 None,
870 )
871 .unwrap();
872
873 let service_id = Guid::new_random();
874 let other_service_id = Guid::new_random();
875 let other_path = dir.path().join("other");
876 relay
877 .add_service_listener(service_id, UnixListener::bind(&path).unwrap())
878 .unwrap();
879 relay
880 .add_service_listener(other_service_id, UnixListener::bind(&other_path).unwrap())
881 .unwrap();
882 relay
883 .add_service_listener(
884 service_id,
885 UnixListener::bind(dir.path().join("duplicate")).unwrap(),
886 )
887 .unwrap_err();
888
889 let _client = UnixStream::connect(&path).unwrap();
891 let params = offer_recv.next().await.unwrap();
892 assert_eq!(params.interface_id, service_id);
893
894 relay.remove_service_listener(service_id).await.unwrap();
895 assert!(UnixStream::connect(&path).is_err());
896 let _other_client = UnixStream::connect(&other_path).unwrap();
897 assert_eq!(
898 offer_recv.next().await.unwrap().interface_id,
899 other_service_id
900 );
901 relay
902 .remove_service_listener(other_service_id)
903 .await
904 .unwrap();
905 relay.remove_service_listener(service_id).await.unwrap_err();
906 relay
907 .add_service_listener(
908 service_id,
909 UnixListener::bind(dir.path().join("readded")).unwrap(),
910 )
911 .unwrap();
912 }
913
914 #[async_test]
915 async fn test_service_listener_preserves_stream_and_established_connections(
916 driver: DefaultDriver,
917 ) {
918 let dir = tempfile::tempdir().unwrap();
919 let path = dir.path().join("service");
920 let memory = GuestMemory::allocate(4 * 4096);
921 let (offers, mut offer_recv) = mesh::channel();
922 let channel = HvsockRelayChannel::new();
923 let _server_half = channel.server_half;
924 let mut relay = HvsockRelay::new(
925 driver.clone(),
926 Arc::new(TestBus {
927 memory: memory.clone(),
928 offers,
929 }),
930 channel.relay_half,
931 None,
932 None,
933 )
934 .unwrap();
935 let service_id = Guid::new_random();
936 relay
937 .add_service_listener(service_id, UnixListener::bind(&path).unwrap())
938 .unwrap();
939 let mut client = PolledSocket::connect_unix(&driver, &path).await.unwrap();
940 let payload = b"application data\n";
941 client.write_all(payload).await.unwrap();
942 let offer = offer_recv.next().await.unwrap();
943 assert_eq!(offer.params.interface_id, service_id);
944 let mut guest = open_guest_pipe(&driver, &memory, &offer).await;
945 let mut received = [0; 17];
946 guest.read_exact(&mut received).await.unwrap();
947 assert_eq!(&received, payload);
948 guest.write_all(payload).await.unwrap();
949 client.read_exact(&mut received).await.unwrap();
950 assert_eq!(&received, payload);
951
952 relay.remove_service_listener(service_id).await.unwrap();
953 assert!(UnixStream::connect(&path).is_err());
954 assert!(path.exists());
955 assert!(UnixListener::bind(&path).is_err());
956 client.write_all(payload).await.unwrap();
957 guest.read_exact(&mut received).await.unwrap();
958 assert_eq!(&received, payload);
959 guest.write_all(payload).await.unwrap();
960 client.read_exact(&mut received).await.unwrap();
961 assert_eq!(&received, payload);
962
963 client.close().await.unwrap();
964 assert_eq!(guest.read(&mut received).await.unwrap(), 0);
965 guest.close().await.unwrap();
966 assert_eq!(client.read(&mut received).await.unwrap(), 0);
967 std::fs::remove_file(&path).unwrap();
968 relay
969 .add_service_listener(service_id, UnixListener::bind(&path).unwrap())
970 .unwrap();
971 relay.remove_service_listener(service_id).await.unwrap();
972 }
973
974 #[async_test]
975 async fn test_hybrid_listener_handshake(driver: DefaultDriver) {
976 let dir = tempfile::tempdir().unwrap();
977 let path = dir.path().join("hybrid");
978 let memory = GuestMemory::allocate(4 * 4096);
979 let (offers, mut offer_recv) = mesh::channel();
980 let channel = HvsockRelayChannel::new();
981 let _server_half = channel.server_half;
982 let _relay = HvsockRelay::new(
983 driver.clone(),
984 Arc::new(TestBus {
985 memory: memory.clone(),
986 offers,
987 }),
988 channel.relay_half,
989 None,
990 Some(UnixListener::bind(&path).unwrap()),
991 )
992 .unwrap();
993 let mut client = PolledSocket::connect_unix(&driver, &path).await.unwrap();
994 client.write_all(b"CONNECT 50001\n").await.unwrap();
995 let offer = offer_recv.next().await.unwrap();
996 assert_eq!(
997 offer.params.interface_id,
998 guid::guid!("0000c351-facb-11e6-bd58-64006a7986d3")
999 );
1000 let mut guest = open_guest_pipe(&driver, &memory, &offer).await;
1001 let expected = format!("OK {}\n", offer.params.instance_id.data1);
1002 let mut response = vec![0; expected.len()];
1003 client.read_exact(&mut response).await.unwrap();
1004 assert_eq!(response, expected.as_bytes());
1005
1006 client.write_all(b"ping").await.unwrap();
1007 let mut payload = [0; 4];
1008 guest.read_exact(&mut payload).await.unwrap();
1009 assert_eq!(&payload, b"ping");
1010 guest.write_all(b"pong").await.unwrap();
1011 client.read_exact(&mut payload).await.unwrap();
1012 assert_eq!(&payload, b"pong");
1013 client.close().await.unwrap();
1014 assert_eq!(guest.read(&mut payload).await.unwrap(), 0);
1015 guest.close().await.unwrap();
1016 assert_eq!(client.read(&mut payload).await.unwrap(), 0);
1017 }
1018}