1use 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
9pub const AF_UNIX: i32 = 1;
11pub const AF_VSOCK: i32 = 40;
13
14pub const SOCK_STREAM: i32 = 1;
16pub const SOCK_DGRAM: i32 = 2;
18pub const SOCK_NONBLOCK: i32 = 0x800;
20pub const SOCK_CLOEXEC: i32 = 0x80000;
22
23pub const SOL_SOCKET: i32 = 1;
25pub const SO_REUSEADDR: i32 = 2;
27pub const SO_ERROR: i32 = 4;
29pub const SO_KEEPALIVE: i32 = 9;
31pub const SO_RCVTIMEO: i32 = 20;
33pub const SO_SNDTIMEO: i32 = 21;
35
36pub const MSG_DONTWAIT: i32 = 0x40;
38pub const MSG_WAITALL: i32 = 0x100;
40pub const MSG_NOSIGNAL: i32 = 0x4000;
42
43pub const SHUT_RD: i32 = 0;
45pub const SHUT_WR: i32 = 1;
47pub const SHUT_RDWR: i32 = 2;
49
50pub const VMADDR_CID_ANY: u32 = u32::MAX;
52pub const VMADDR_CID_LOCAL: u32 = 1;
54pub const VMADDR_CID_HOST: u32 = 2;
56
57#[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 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#[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 #[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
118pub fn socket(domain: i32, ty: i32, protocol: i32) -> SysResult<RawFd> {
120 unsafe {
122 syscall3(nr::SOCKET, domain as usize, ty as usize, protocol as usize).map(|fd| fd as RawFd)
123 }
124}
125
126pub fn socketpair(domain: i32, ty: i32, protocol: i32) -> SysResult<[RawFd; 2]> {
128 let mut sv = [0i32; 2];
129 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
142pub unsafe fn bind_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
148 unsafe {
150 syscall3(nr::BIND, fd as usize, addr as usize, addrlen as usize)?;
151 }
152 Ok(())
153}
154
155pub fn bind_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
157 let (addr, len) = SockAddrUn::from_path(path)?;
158 unsafe { bind_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
160}
161
162pub fn bind_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
164 unsafe {
166 bind_raw(
167 fd,
168 core::ptr::from_ref(addr).cast::<u8>(),
169 size_of::<SockAddrVm>() as u32,
170 )
171 }
172}
173
174pub unsafe fn connect_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
180 unsafe {
182 syscall3(nr::CONNECT, fd as usize, addr as usize, addrlen as usize)?;
183 }
184 Ok(())
185}
186
187pub fn connect_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
189 let (addr, len) = SockAddrUn::from_path(path)?;
190 unsafe { connect_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
192}
193
194pub fn connect_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
196 unsafe {
198 connect_raw(
199 fd,
200 core::ptr::from_ref(addr).cast::<u8>(),
201 size_of::<SockAddrVm>() as u32,
202 )
203 }
204}
205
206pub fn listen(fd: RawFd, backlog: i32) -> SysResult<()> {
208 unsafe {
210 syscall2(nr::LISTEN, fd as usize, backlog as usize)?;
211 }
212 Ok(())
213}
214
215pub unsafe fn accept4_raw(
222 fd: RawFd,
223 addr: *mut u8,
224 addrlen: *mut u32,
225 flags: i32,
226) -> SysResult<RawFd> {
227 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
240pub fn accept(fd: RawFd) -> SysResult<RawFd> {
242 accept4(fd, 0)
243}
244
245pub fn accept4(fd: RawFd, flags: i32) -> SysResult<RawFd> {
247 unsafe { accept4_raw(fd, core::ptr::null_mut(), core::ptr::null_mut(), flags) }
249}
250
251pub unsafe fn send_raw(fd: RawFd, buf: *const u8, len: usize, flags: i32) -> SysResult<usize> {
257 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
272pub fn send(fd: RawFd, buf: &[u8], flags: i32) -> SysResult<usize> {
274 unsafe { send_raw(fd, buf.as_ptr(), buf.len(), flags) }
276}
277
278pub unsafe fn recv_raw(fd: RawFd, buf: *mut u8, len: usize, flags: i32) -> SysResult<usize> {
284 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
299pub fn recv(fd: RawFd, buf: &mut [u8], flags: i32) -> SysResult<usize> {
301 unsafe { recv_raw(fd, buf.as_mut_ptr(), buf.len(), flags) }
303}
304
305pub unsafe fn setsockopt_raw(
311 fd: RawFd,
312 level: i32,
313 optname: i32,
314 optval: *const u8,
315 optlen: u32,
316) -> SysResult<()> {
317 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
331pub unsafe fn getsockopt_raw(
338 fd: RawFd,
339 level: i32,
340 optname: i32,
341 optval: *mut u8,
342 optlen: *mut u32,
343) -> SysResult<()> {
344 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
358pub fn shutdown(fd: RawFd, how: i32) -> SysResult<()> {
360 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}