vmsocket/
af_vsock.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! AF_VSOCK support.

// UNSAFETY: Calling libc functions on a raw socket fd.
#![expect(unsafe_code)]

use crate::VmListener;
use crate::VmSocket;
use crate::VmStream;
use mesh::payload::os_resource;
use socket2::Domain;
use socket2::SockAddr;
use socket2::Socket;
use socket2::Type;
use std::io;
use std::os::unix::prelude::*;
use std::time::Duration;

#[derive(Debug)]
pub struct Address {
    pub(crate) cid: u32,
    pub(crate) port: u32,
}

impl Address {
    pub fn new(cid: u32, port: u32) -> Self {
        Self { cid, port }
    }

    pub fn vsock_any(port: u32) -> Self {
        Self::new(!0, port)
    }

    pub fn vsock_host(port: u32) -> Self {
        Self::new(2, port)
    }

    pub fn into_sock_addr(self) -> SockAddr {
        SockAddr::vsock(self.cid, self.port)
    }

    pub fn try_from_sock_addr(addr: &SockAddr) -> Option<Self> {
        let (cid, port) = addr.as_vsock_address()?;
        Some(Self::new(cid, port))
    }
}

impl VmSocket {
    pub(crate) fn new_inner() -> io::Result<Self> {
        Ok(Self(Socket::new(Domain::VSOCK, Type::STREAM, None)?))
    }

    /// Sets the connection timeout for this socket.
    pub fn set_connect_timeout(&self, duration: Duration) -> io::Result<()> {
        let timeout = libc::timeval {
            tv_sec: duration
                .as_secs()
                .try_into()
                .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?,
            tv_usec: duration.subsec_micros().into(),
        };

        // SAFETY: Calling a VSOCK-specific option on a VSOCK socket,
        // and passing a valid pointer to a timeval struct.
        unsafe {
            if libc::setsockopt(
                self.as_fd().as_raw_fd(),
                libc::AF_VSOCK,
                6, // SO_VM_SOCKETS_CONNECT_TIMEOUT
                std::ptr::from_ref(&timeout).cast(),
                size_of_val(&timeout) as u32,
            ) != 0
            {
                return Err(io::Error::last_os_error());
            }
        }
        Ok(())
    }
}

impl AsFd for VmSocket {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.0.as_fd()
    }
}

impl From<VmSocket> for OwnedFd {
    fn from(fd: VmSocket) -> Self {
        fd.0.into()
    }
}

impl From<OwnedFd> for VmSocket {
    fn from(fd: OwnedFd) -> Self {
        Self(fd.into())
    }
}

impl AsFd for VmListener {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.0.as_fd()
    }
}

impl From<VmListener> for OwnedFd {
    fn from(fd: VmListener) -> Self {
        fd.0.into()
    }
}

impl From<OwnedFd> for VmListener {
    fn from(fd: OwnedFd) -> Self {
        Self(fd.into())
    }
}

impl AsFd for VmStream {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.0.as_fd()
    }
}

impl From<VmStream> for OwnedFd {
    fn from(fd: VmStream) -> Self {
        fd.0.into()
    }
}

impl From<OwnedFd> for VmStream {
    fn from(fd: OwnedFd) -> Self {
        Self(fd.into())
    }
}

os_resource!(VmSocket, OwnedFd);
os_resource!(VmStream, OwnedFd);
os_resource!(VmListener, OwnedFd);