Skip to main content

vmbus_server/
hvsock.rs

1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4//! This module implements an hvsocket-to-Unix socket relay.
5//!
6//! This supports the [hybrid vsock connection model][1] established by
7//! Firecracker, extended to support Hyper-V sockets as well.
8//!
9//! [1]: <https://github.com/firecracker-microvm/firecracker/blob/7b2e87dc65fc45162303e5708b83c379cf1b0426/docs/vsock.md>
10
11use 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    /// Creates and starts a relay thread, waiting for hvsocket connect requests
63    /// on `recv`.
64    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    /// Relays each connection accepted by `listener` to the guest hvsocket
116    /// service `service_id`.
117    ///
118    /// Unlike the hybrid vsock listener, clients do not send a `CONNECT`
119    /// request or receive an `OK` response, so the stream carries only relayed
120    /// data. This supports clients that cannot perform the hybrid vsock
121    /// handshake.
122    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    /// Stops accepting connections for a listener added by
147    /// [`Self::add_service_listener`]. Established connections are not
148    /// affected.
149    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    /// Connects to an hvsocket in the guest and returns a Unix socket that is
160    /// relayed to the hvsocket.
161    ///
162    /// Blocks until complete or cancelled.
163    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        // Ensure the task gets dropped if the future is dropped.
173        let (mut ctx, cancel) = ctx.with_cancel();
174
175        // Spawn a task to initiate the connect to avoid keeping a reference on `RelayInner`.
176        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    /// The guest service for every accepted connection. If `None`, each
200    /// connection selects its service with a hybrid vsock `CONNECT` request.
201    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                // Keep the offer alive until the relay completes.
277                let _offer = offer;
278
279                if let Some(request) = request {
280                    // Notify the client that connection was successful, using a format that matches
281                    // the request.
282                    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        // Wrap the connect request so that we are assured to send a response.
401        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        // Find the appropriate path to connect to. Don't connect until the
453        // channel with the guest has been established, since that's a
454        // failure-prone operation and we don't want the host to see a broken
455        // connection.
456        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        // Now that the channel is offered, report that the connection operation is
481        // done.
482        pending.done(true);
483
484        // Give the guest a few seconds to open the channel.
485        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        // Connect to the host Unix socket.
494        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        // Accept the channel now that the host connection is established.
507        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        // N.B. offer needs to stay alive until here to avoid revoking the channel
521        // before the relay is done.
522        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                // Keep the offer alive until the relay completes.
564                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        // The guest's outgoing ring is the host's incoming ring.
736        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    /// A bus that reports each offer and then rejects it.
753    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 to s
791        c.write_all(d).await.unwrap();
792        s.read_exact(&mut v).await.unwrap();
793        assert_eq!(&v, d);
794
795        // s to c
796        s.write_all(d).await.unwrap();
797        c.read_exact(&mut v).await.unwrap();
798        assert_eq!(&v, d);
799
800        // s to c
801        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 to s
807        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)] // Windows does not deliver POLLHUP on Unix socket close.
816    #[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        // The relay offers the service without waiting for a connect request.
890        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}