Skip to main content

libc_rs/
net.rs

1//! Socket, UNIX domain, and Virtio-Vsock syscall wrappers.
2
3use core::mem::size_of;
4
5use crate::errno::{EINVAL, ENAMETOOLONG, Errno, SysResult};
6use crate::fd::RawFd;
7use crate::raw::{nr, syscall2, syscall3, syscall4, syscall5, syscall6};
8
9/// Unix domain sockets address family.
10pub const AF_UNIX: i32 = 1;
11/// Virtio vsock address family.
12pub const AF_VSOCK: i32 = 40;
13
14/// Sequenced, reliable, two-way connection-based byte streams.
15pub const SOCK_STREAM: i32 = 1;
16/// Connectionless, unreliable datagrams.
17pub const SOCK_DGRAM: i32 = 2;
18/// Set `O_NONBLOCK` on the new open file description.
19pub const SOCK_NONBLOCK: i32 = 0x800;
20/// Set close-on-exec (`FD_CLOEXEC`) on the new descriptor.
21pub const SOCK_CLOEXEC: i32 = 0x80000;
22
23/// Socket level for `getsockopt` / `setsockopt`.
24pub const SOL_SOCKET: i32 = 1;
25/// Allow reuse of local addresses.
26pub const SO_REUSEADDR: i32 = 2;
27/// Get and clear pending socket error.
28pub const SO_ERROR: i32 = 4;
29/// Enable keep-alive messages on connection-oriented sockets.
30pub const SO_KEEPALIVE: i32 = 9;
31/// Receive timeout option.
32pub const SO_RCVTIMEO: i32 = 20;
33/// Send timeout option.
34pub const SO_SNDTIMEO: i32 = 21;
35
36/// Nonblocking I/O for a single send/recv call.
37pub const MSG_DONTWAIT: i32 = 0x40;
38/// Wait for full request or error.
39pub const MSG_WAITALL: i32 = 0x100;
40/// Do not generate `SIGPIPE` on peer close.
41pub const MSG_NOSIGNAL: i32 = 0x4000;
42
43/// Shut down the reading side of a socket.
44pub const SHUT_RD: i32 = 0;
45/// Shut down the writing side of a socket.
46pub const SHUT_WR: i32 = 1;
47/// Shut down both reading and writing sides of a socket.
48pub const SHUT_RDWR: i32 = 2;
49
50/// Wildcard vsock context ID.
51pub const VMADDR_CID_ANY: u32 = u32::MAX;
52/// Local loopback vsock context ID.
53pub const VMADDR_CID_LOCAL: u32 = 1;
54/// Host hypervisor vsock context ID.
55pub const VMADDR_CID_HOST: u32 = 2;
56
57/// Kernel `sockaddr_un` structure for UNIX domain sockets.
58#[repr(C)]
59#[derive(Clone, Copy, Debug)]
60pub struct SockAddrUn {
61    pub sun_family: u16,
62    pub sun_path: [u8; 108],
63}
64
65impl SockAddrUn {
66    /// Builds a NUL-terminated [`SockAddrUn`] and its effective `socklen_t` from `path`.
67    ///
68    /// Reserves 1 trailing NUL byte so `path.len() >= 108` fails with `ENAMETOOLONG`,
69    /// and rejects interior NUL bytes or empty paths with `EINVAL`.
70    pub fn from_path(path: &[u8]) -> SysResult<(Self, u32)> {
71        if path.is_empty() || path.contains(&0) {
72            return Err(Errno(EINVAL));
73        }
74        if path.len() >= 108 {
75            return Err(Errno(ENAMETOOLONG));
76        }
77        let mut addr = Self {
78            sun_family: AF_UNIX as u16,
79            sun_path: [0u8; 108],
80        };
81        addr.sun_path[..path.len()].copy_from_slice(path);
82        let addrlen = (size_of::<u16>() + path.len() + 1) as u32;
83        Ok((addr, addrlen))
84    }
85}
86
87/// Kernel `sockaddr_vm` structure for `AF_VSOCK` sockets.
88#[repr(C)]
89#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
90pub struct SockAddrVm {
91    pub svm_family: u16,
92    pub svm_reserved1: u16,
93    pub svm_port: u32,
94    pub svm_cid: u32,
95    pub svm_flags: u8,
96    pub svm_zero: [u8; 3],
97}
98
99impl SockAddrVm {
100    /// Constructs an `AF_VSOCK` socket address for `(cid, port)`.
101    #[must_use]
102    pub const fn new(cid: u32, port: u32) -> Self {
103        Self {
104            svm_family: AF_VSOCK as u16,
105            svm_reserved1: 0,
106            svm_port: port,
107            svm_cid: cid,
108            svm_flags: 0,
109            svm_zero: [0; 3],
110        }
111    }
112}
113
114const _: () = {
115    assert!(size_of::<SockAddrVm>() == 16);
116};
117
118/// Creates an endpoint for communication and returns its file descriptor.
119pub fn socket(domain: i32, ty: i32, protocol: i32) -> SysResult<RawFd> {
120    // SAFETY: `SOCKET` takes three scalar integer arguments.
121    unsafe {
122        syscall3(nr::SOCKET, domain as usize, ty as usize, protocol as usize).map(|fd| fd as RawFd)
123    }
124}
125
126/// Creates an unnamed pair of connected sockets.
127pub fn socketpair(domain: i32, ty: i32, protocol: i32) -> SysResult<[RawFd; 2]> {
128    let mut sv = [0i32; 2];
129    // SAFETY: `sv` is a valid 2-element `i32` array on the stack.
130    unsafe {
131        syscall4(
132            nr::SOCKETPAIR,
133            domain as usize,
134            ty as usize,
135            protocol as usize,
136            sv.as_mut_ptr() as usize,
137        )?;
138    }
139    Ok(sv)
140}
141
142/// Binds `fd` to the raw socket address `[addr..addr + addrlen]`.
143///
144/// # Safety
145///
146/// `addr` must point to at least `addrlen` readable bytes containing a valid kernel `sockaddr`.
147pub unsafe fn bind_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
148    // SAFETY: Caller guarantees `addr` and `addrlen` describe a valid readable buffer.
149    unsafe {
150        syscall3(nr::BIND, fd as usize, addr as usize, addrlen as usize)?;
151    }
152    Ok(())
153}
154
155/// Binds an `AF_UNIX` socket `fd` to `path`.
156pub fn bind_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
157    let (addr, len) = SockAddrUn::from_path(path)?;
158    // SAFETY: `addr` is a stack `SockAddrUn` and `len <= size_of::<SockAddrUn>()`.
159    unsafe { bind_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
160}
161
162/// Binds an `AF_VSOCK` socket `fd` to `addr`.
163pub fn bind_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
164    // SAFETY: `addr` is a valid `SockAddrVm` of size 16 bytes.
165    unsafe {
166        bind_raw(
167            fd,
168            core::ptr::from_ref(addr).cast::<u8>(),
169            size_of::<SockAddrVm>() as u32,
170        )
171    }
172}
173
174/// Connects `fd` to the raw socket address `[addr..addr + addrlen]`.
175///
176/// # Safety
177///
178/// `addr` must point to at least `addrlen` readable bytes containing a valid kernel `sockaddr`.
179pub unsafe fn connect_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
180    // SAFETY: Caller guarantees `addr` and `addrlen` describe a valid readable buffer.
181    unsafe {
182        syscall3(nr::CONNECT, fd as usize, addr as usize, addrlen as usize)?;
183    }
184    Ok(())
185}
186
187/// Connects an `AF_UNIX` socket `fd` to `path`.
188pub fn connect_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
189    let (addr, len) = SockAddrUn::from_path(path)?;
190    // SAFETY: `addr` is a stack `SockAddrUn` and `len <= size_of::<SockAddrUn>()`.
191    unsafe { connect_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
192}
193
194/// Connects an `AF_VSOCK` socket `fd` to `addr`.
195pub fn connect_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
196    // SAFETY: `addr` is a valid `SockAddrVm` of size 16 bytes.
197    unsafe {
198        connect_raw(
199            fd,
200            core::ptr::from_ref(addr).cast::<u8>(),
201            size_of::<SockAddrVm>() as u32,
202        )
203    }
204}
205
206/// Marks `fd` as a passive socket with maximum pending connection queue `backlog`.
207pub fn listen(fd: RawFd, backlog: i32) -> SysResult<()> {
208    // SAFETY: `LISTEN` takes scalar descriptor and backlog arguments.
209    unsafe {
210        syscall2(nr::LISTEN, fd as usize, backlog as usize)?;
211    }
212    Ok(())
213}
214
215/// Accepts a connection on `fd` with `flags`, optionally writing the peer address into `addr`.
216///
217/// # Safety
218///
219/// Either `addr` and `addrlen` must both be null, or `addrlen` must point to a valid `u32`
220/// initialized to the byte capacity of `addr` and `addr` must be writable for that many bytes.
221pub unsafe fn accept4_raw(
222    fd: RawFd,
223    addr: *mut u8,
224    addrlen: *mut u32,
225    flags: i32,
226) -> SysResult<RawFd> {
227    // SAFETY: Caller upholds the pointer validity contract for `addr` and `addrlen`.
228    unsafe {
229        syscall4(
230            nr::ACCEPT4,
231            fd as usize,
232            addr as usize,
233            addrlen as usize,
234            flags as usize,
235        )
236        .map(|v| v as RawFd)
237    }
238}
239
240/// Accepts a connection on `fd` without peer address capture.
241pub fn accept(fd: RawFd) -> SysResult<RawFd> {
242    accept4(fd, 0)
243}
244
245/// Accepts a connection on `fd` with `flags` (`SOCK_NONBLOCK`, `SOCK_CLOEXEC`) without peer address capture.
246pub fn accept4(fd: RawFd, flags: i32) -> SysResult<RawFd> {
247    // SAFETY: Null address and length pointers are explicitly allowed by `accept4`.
248    unsafe { accept4_raw(fd, core::ptr::null_mut(), core::ptr::null_mut(), flags) }
249}
250
251/// Sends `len` bytes from `buf` on connected socket `fd` with `flags`.
252///
253/// # Safety
254///
255/// `buf` must be valid for reads of `len` bytes (or `len == 0`).
256pub unsafe fn send_raw(fd: RawFd, buf: *const u8, len: usize, flags: i32) -> SysResult<usize> {
257    // SAFETY: Caller guarantees `buf` is readable for `len` bytes; `dest_addr = 0, addrlen = 0`
258    // is the standard AArch64 `sendto` encoding for `send`.
259    unsafe {
260        syscall6(
261            nr::SENDTO,
262            fd as usize,
263            buf as usize,
264            len,
265            flags as usize,
266            0,
267            0,
268        )
269    }
270}
271
272/// Sends `buf` on connected socket `fd` with `flags`.
273pub fn send(fd: RawFd, buf: &[u8], flags: i32) -> SysResult<usize> {
274    // SAFETY: `buf.as_ptr()` is valid for `buf.len()` bytes.
275    unsafe { send_raw(fd, buf.as_ptr(), buf.len(), flags) }
276}
277
278/// Receives up to `len` bytes into `buf` from socket `fd` with `flags`.
279///
280/// # Safety
281///
282/// `buf` must be valid for writes of `len` bytes (or `len == 0`).
283pub unsafe fn recv_raw(fd: RawFd, buf: *mut u8, len: usize, flags: i32) -> SysResult<usize> {
284    // SAFETY: Caller guarantees `buf` is writable for `len` bytes; `src_addr = 0, addrlen = 0`
285    // is the standard AArch64 `recvfrom` encoding for `recv`.
286    unsafe {
287        syscall6(
288            nr::RECVFROM,
289            fd as usize,
290            buf as usize,
291            len,
292            flags as usize,
293            0,
294            0,
295        )
296    }
297}
298
299/// Receives bytes into `buf` from socket `fd` with `flags`.
300pub fn recv(fd: RawFd, buf: &mut [u8], flags: i32) -> SysResult<usize> {
301    // SAFETY: `buf.as_mut_ptr()` is valid for `buf.len()` writable bytes.
302    unsafe { recv_raw(fd, buf.as_mut_ptr(), buf.len(), flags) }
303}
304
305/// Sets a raw socket option on `fd`.
306///
307/// # Safety
308///
309/// `optval` must be readable for `optlen` bytes (or null if `optlen == 0`).
310pub unsafe fn setsockopt_raw(
311    fd: RawFd,
312    level: i32,
313    optname: i32,
314    optval: *const u8,
315    optlen: u32,
316) -> SysResult<()> {
317    // SAFETY: Caller guarantees `optval` points to `optlen` readable bytes.
318    unsafe {
319        syscall5(
320            nr::SETSOCKOPT,
321            fd as usize,
322            level as usize,
323            optname as usize,
324            optval as usize,
325            optlen as usize,
326        )?;
327    }
328    Ok(())
329}
330
331/// Gets a raw socket option from `fd`.
332///
333/// # Safety
334///
335/// `optlen` must point to a valid `u32` initialized to the byte capacity of `optval`,
336/// and `optval` must be writable for that many bytes.
337pub unsafe fn getsockopt_raw(
338    fd: RawFd,
339    level: i32,
340    optname: i32,
341    optval: *mut u8,
342    optlen: *mut u32,
343) -> SysResult<()> {
344    // SAFETY: Caller guarantees `optval` and `optlen` are valid writable pointers.
345    unsafe {
346        syscall5(
347            nr::GETSOCKOPT,
348            fd as usize,
349            level as usize,
350            optname as usize,
351            optval as usize,
352            optlen as usize,
353        )?;
354    }
355    Ok(())
356}
357
358/// Shuts down part or all of a full-duplex connection on `fd`.
359pub fn shutdown(fd: RawFd, how: i32) -> SysResult<()> {
360    // SAFETY: `SHUTDOWN` takes scalar `fd` and `how` arguments.
361    unsafe {
362        syscall2(nr::SHUTDOWN, fd as usize, how as usize)?;
363    }
364    Ok(())
365}
366
367#[cfg(test)]
368mod tests {
369    use super::*;
370
371    #[test]
372    fn sockaddr_un_from_path_validates_bounds_and_interior_nul() {
373        let (addr, len) = SockAddrUn::from_path(b"/run/test.sock").unwrap();
374        assert_eq!(addr.sun_family, AF_UNIX as u16);
375        assert_eq!(len, (2 + b"/run/test.sock".len() + 1) as u32);
376        assert_eq!(&addr.sun_path[..14], b"/run/test.sock");
377        assert_eq!(addr.sun_path[14], 0);
378
379        let max_ok = [b'a'; 107];
380        let (_, max_len) = SockAddrUn::from_path(&max_ok).unwrap();
381        assert_eq!(max_len, 110);
382
383        let too_long = [b'a'; 108];
384        assert_eq!(
385            SockAddrUn::from_path(&too_long).unwrap_err(),
386            Errno(ENAMETOOLONG)
387        );
388
389        assert_eq!(SockAddrUn::from_path(b"").unwrap_err(), Errno(EINVAL));
390        assert_eq!(
391            SockAddrUn::from_path(b"/tmp/bad\0path").unwrap_err(),
392            Errno(EINVAL)
393        );
394    }
395
396    #[test]
397    fn vsock_addr_constructor_sets_family_cid_and_port() {
398        let vm = SockAddrVm::new(VMADDR_CID_HOST, 5000);
399        assert_eq!(vm.svm_family, AF_VSOCK as u16);
400        assert_eq!(vm.svm_cid, VMADDR_CID_HOST);
401        assert_eq!(vm.svm_port, 5000);
402    }
403}