use core::mem::size_of;
use crate::errno::{EINVAL, ENAMETOOLONG, Errno, SysResult};
use crate::fd::RawFd;
use crate::raw::{nr, syscall2, syscall3, syscall4, syscall5, syscall6};
pub const AF_UNIX: i32 = 1;
pub const AF_VSOCK: i32 = 40;
pub const SOCK_STREAM: i32 = 1;
pub const SOCK_DGRAM: i32 = 2;
pub const SOCK_NONBLOCK: i32 = 0x800;
pub const SOCK_CLOEXEC: i32 = 0x80000;
pub const SOL_SOCKET: i32 = 1;
pub const SO_REUSEADDR: i32 = 2;
pub const SO_ERROR: i32 = 4;
pub const SO_KEEPALIVE: i32 = 9;
pub const SO_RCVTIMEO: i32 = 20;
pub const SO_SNDTIMEO: i32 = 21;
pub const MSG_DONTWAIT: i32 = 0x40;
pub const MSG_WAITALL: i32 = 0x100;
pub const MSG_NOSIGNAL: i32 = 0x4000;
pub const SHUT_RD: i32 = 0;
pub const SHUT_WR: i32 = 1;
pub const SHUT_RDWR: i32 = 2;
pub const VMADDR_CID_ANY: u32 = u32::MAX;
pub const VMADDR_CID_LOCAL: u32 = 1;
pub const VMADDR_CID_HOST: u32 = 2;
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct SockAddrUn {
pub sun_family: u16,
pub sun_path: [u8; 108],
}
impl SockAddrUn {
pub fn from_path(path: &[u8]) -> SysResult<(Self, u32)> {
if path.is_empty() || path.contains(&0) {
return Err(Errno(EINVAL));
}
if path.len() >= 108 {
return Err(Errno(ENAMETOOLONG));
}
let mut addr = Self {
sun_family: AF_UNIX as u16,
sun_path: [0u8; 108],
};
addr.sun_path[..path.len()].copy_from_slice(path);
let addrlen = (size_of::<u16>() + path.len() + 1) as u32;
Ok((addr, addrlen))
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SockAddrVm {
pub svm_family: u16,
pub svm_reserved1: u16,
pub svm_port: u32,
pub svm_cid: u32,
pub svm_flags: u8,
pub svm_zero: [u8; 3],
}
impl SockAddrVm {
#[must_use]
pub const fn new(cid: u32, port: u32) -> Self {
Self {
svm_family: AF_VSOCK as u16,
svm_reserved1: 0,
svm_port: port,
svm_cid: cid,
svm_flags: 0,
svm_zero: [0; 3],
}
}
}
const _: () = {
assert!(size_of::<SockAddrVm>() == 16);
};
pub fn socket(domain: i32, ty: i32, protocol: i32) -> SysResult<RawFd> {
unsafe {
syscall3(nr::SOCKET, domain as usize, ty as usize, protocol as usize).map(|fd| fd as RawFd)
}
}
pub fn socketpair(domain: i32, ty: i32, protocol: i32) -> SysResult<[RawFd; 2]> {
let mut sv = [0i32; 2];
unsafe {
syscall4(
nr::SOCKETPAIR,
domain as usize,
ty as usize,
protocol as usize,
sv.as_mut_ptr() as usize,
)?;
}
Ok(sv)
}
pub unsafe fn bind_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
unsafe {
syscall3(nr::BIND, fd as usize, addr as usize, addrlen as usize)?;
}
Ok(())
}
pub fn bind_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
let (addr, len) = SockAddrUn::from_path(path)?;
unsafe { bind_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
}
pub fn bind_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
unsafe {
bind_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrVm>() as u32,
)
}
}
pub unsafe fn connect_raw(fd: RawFd, addr: *const u8, addrlen: u32) -> SysResult<()> {
unsafe {
syscall3(nr::CONNECT, fd as usize, addr as usize, addrlen as usize)?;
}
Ok(())
}
pub fn connect_unix(fd: RawFd, path: &[u8]) -> SysResult<()> {
let (addr, len) = SockAddrUn::from_path(path)?;
unsafe { connect_raw(fd, core::ptr::from_ref(&addr).cast::<u8>(), len) }
}
pub fn connect_vsock(fd: RawFd, addr: &SockAddrVm) -> SysResult<()> {
unsafe {
connect_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrVm>() as u32,
)
}
}
pub fn listen(fd: RawFd, backlog: i32) -> SysResult<()> {
unsafe {
syscall2(nr::LISTEN, fd as usize, backlog as usize)?;
}
Ok(())
}
pub unsafe fn accept4_raw(
fd: RawFd,
addr: *mut u8,
addrlen: *mut u32,
flags: i32,
) -> SysResult<RawFd> {
unsafe {
syscall4(
nr::ACCEPT4,
fd as usize,
addr as usize,
addrlen as usize,
flags as usize,
)
.map(|v| v as RawFd)
}
}
pub fn accept(fd: RawFd) -> SysResult<RawFd> {
accept4(fd, 0)
}
pub fn accept4(fd: RawFd, flags: i32) -> SysResult<RawFd> {
unsafe { accept4_raw(fd, core::ptr::null_mut(), core::ptr::null_mut(), flags) }
}
pub unsafe fn send_raw(fd: RawFd, buf: *const u8, len: usize, flags: i32) -> SysResult<usize> {
unsafe {
syscall6(
nr::SENDTO,
fd as usize,
buf as usize,
len,
flags as usize,
0,
0,
)
}
}
pub fn send(fd: RawFd, buf: &[u8], flags: i32) -> SysResult<usize> {
unsafe { send_raw(fd, buf.as_ptr(), buf.len(), flags) }
}
pub unsafe fn recv_raw(fd: RawFd, buf: *mut u8, len: usize, flags: i32) -> SysResult<usize> {
unsafe {
syscall6(
nr::RECVFROM,
fd as usize,
buf as usize,
len,
flags as usize,
0,
0,
)
}
}
pub fn recv(fd: RawFd, buf: &mut [u8], flags: i32) -> SysResult<usize> {
unsafe { recv_raw(fd, buf.as_mut_ptr(), buf.len(), flags) }
}
pub unsafe fn setsockopt_raw(
fd: RawFd,
level: i32,
optname: i32,
optval: *const u8,
optlen: u32,
) -> SysResult<()> {
unsafe {
syscall5(
nr::SETSOCKOPT,
fd as usize,
level as usize,
optname as usize,
optval as usize,
optlen as usize,
)?;
}
Ok(())
}
pub unsafe fn getsockopt_raw(
fd: RawFd,
level: i32,
optname: i32,
optval: *mut u8,
optlen: *mut u32,
) -> SysResult<()> {
unsafe {
syscall5(
nr::GETSOCKOPT,
fd as usize,
level as usize,
optname as usize,
optval as usize,
optlen as usize,
)?;
}
Ok(())
}
pub fn shutdown(fd: RawFd, how: i32) -> SysResult<()> {
unsafe {
syscall2(nr::SHUTDOWN, fd as usize, how as usize)?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sockaddr_un_from_path_validates_bounds_and_interior_nul() {
let (addr, len) = SockAddrUn::from_path(b"/run/test.sock").unwrap();
assert_eq!(addr.sun_family, AF_UNIX as u16);
assert_eq!(len, (2 + b"/run/test.sock".len() + 1) as u32);
assert_eq!(&addr.sun_path[..14], b"/run/test.sock");
assert_eq!(addr.sun_path[14], 0);
let max_ok = [b'a'; 107];
let (_, max_len) = SockAddrUn::from_path(&max_ok).unwrap();
assert_eq!(max_len, 110);
let too_long = [b'a'; 108];
assert_eq!(
SockAddrUn::from_path(&too_long).unwrap_err(),
Errno(ENAMETOOLONG)
);
assert_eq!(SockAddrUn::from_path(b"").unwrap_err(), Errno(EINVAL));
assert_eq!(
SockAddrUn::from_path(b"/tmp/bad\0path").unwrap_err(),
Errno(EINVAL)
);
}
#[test]
fn vsock_addr_constructor_sets_family_cid_and_port() {
let vm = SockAddrVm::new(VMADDR_CID_HOST, 5000);
assert_eq!(vm.svm_family, AF_VSOCK as u16);
assert_eq!(vm.svm_cid, VMADDR_CID_HOST);
assert_eq!(vm.svm_port, 5000);
}
}