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_UNSPEC: i32 = 0;
pub const AF_UNIX: i32 = 1;
pub const AF_INET: i32 = 2;
pub const AF_INET6: i32 = 10;
pub const AF_VSOCK: i32 = 40;
pub const IPPROTO_IP: i32 = 0;
pub const IPPROTO_ICMP: i32 = 1;
pub const IPPROTO_TCP: i32 = 6;
pub const IPPROTO_UDP: i32 = 17;
pub const IPPROTO_IPV6: i32 = 41;
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 TCP_NODELAY: i32 = 1;
pub const TCP_KEEPIDLE: i32 = 4;
pub const TCP_KEEPINTVL: i32 = 5;
pub const TCP_KEEPCNT: i32 = 6;
pub const SOL_SOCKET: i32 = 1;
pub const SO_REUSEADDR: i32 = 2;
pub const SO_ERROR: i32 = 4;
pub const SO_SNDBUF: i32 = 7;
pub const SO_RCVBUF: i32 = 8;
pub const SO_KEEPALIVE: i32 = 9;
pub const SO_REUSEPORT: i32 = 15;
pub const SO_RCVTIMEO: i32 = 20;
pub const SO_SNDTIMEO: i32 = 21;
pub const IPV6_V6ONLY: i32 = 26;
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],
}
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct InAddr {
pub s_addr: u32,
}
impl InAddr {
#[must_use]
pub const fn from_octets(octets: [u8; 4]) -> Self {
Self {
s_addr: u32::from_ne_bytes(octets),
}
}
#[must_use]
pub const fn octets(self) -> [u8; 4] {
self.s_addr.to_ne_bytes()
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SockAddrIn {
pub sin_family: u16,
pub sin_port: u16,
pub sin_addr: InAddr,
pub sin_zero: [u8; 8],
}
impl SockAddrIn {
#[must_use]
pub const fn new(ip: [u8; 4], port: u16) -> Self {
Self {
sin_family: AF_INET as u16,
sin_port: port.to_be(),
sin_addr: InAddr {
s_addr: u32::from_ne_bytes(ip),
},
sin_zero: [0; 8],
}
}
#[must_use]
pub const fn ip(&self) -> [u8; 4] {
self.sin_addr.s_addr.to_ne_bytes()
}
#[must_use]
pub const fn port(&self) -> u16 {
u16::from_be(self.sin_port)
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct In6Addr {
pub s6_addr: [u8; 16],
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SockAddrIn6 {
pub sin6_family: u16,
pub sin6_port: u16,
pub sin6_flowinfo: u32,
pub sin6_addr: In6Addr,
pub sin6_scope_id: u32,
}
impl SockAddrIn6 {
#[must_use]
pub const fn new(ip: [u8; 16], port: u16, flowinfo: u32, scope_id: u32) -> Self {
Self {
sin6_family: AF_INET6 as u16,
sin6_port: port.to_be(),
sin6_flowinfo: flowinfo,
sin6_addr: In6Addr { s6_addr: ip },
sin6_scope_id: scope_id,
}
}
#[must_use]
pub const fn ip(&self) -> [u8; 16] {
self.sin6_addr.s6_addr
}
#[must_use]
pub const fn port(&self) -> u16 {
u16::from_be(self.sin6_port)
}
}
#[repr(C, align(8))]
#[derive(Clone, Copy, Debug)]
pub struct SockAddrStorage {
pub ss_family: u16,
pub ss_data: [u8; 126],
}
impl Default for SockAddrStorage {
fn default() -> Self {
Self {
ss_family: 0,
ss_data: [0u8; 126],
}
}
}
const _: () = {
assert!(size_of::<SockAddrVm>() == 16);
assert!(size_of::<InAddr>() == 4);
assert!(size_of::<SockAddrIn>() == 16);
assert!(size_of::<In6Addr>() == 16);
assert!(size_of::<SockAddrIn6>() == 28);
assert!(size_of::<SockAddrStorage>() == 128);
};
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 fn bind_in(fd: RawFd, addr: &SockAddrIn) -> SysResult<()> {
unsafe {
bind_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrIn>() as u32,
)
}
}
pub fn bind_in6(fd: RawFd, addr: &SockAddrIn6) -> SysResult<()> {
unsafe {
bind_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrIn6>() 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 connect_in(fd: RawFd, addr: &SockAddrIn) -> SysResult<()> {
unsafe {
connect_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrIn>() as u32,
)
}
}
pub fn connect_in6(fd: RawFd, addr: &SockAddrIn6) -> SysResult<()> {
unsafe {
connect_raw(
fd,
core::ptr::from_ref(addr).cast::<u8>(),
size_of::<SockAddrIn6>() 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 fn accept_in(fd: RawFd, flags: i32) -> SysResult<(RawFd, SockAddrIn)> {
let mut addr = SockAddrIn::default();
let mut len = size_of::<SockAddrIn>() as u32;
let client = unsafe {
accept4_raw(
fd,
core::ptr::from_mut(&mut addr).cast::<u8>(),
core::ptr::from_mut(&mut len),
flags,
)?
};
Ok((client, addr))
}
pub fn accept_in6(fd: RawFd, flags: i32) -> SysResult<(RawFd, SockAddrIn6)> {
let mut addr = SockAddrIn6::default();
let mut len = size_of::<SockAddrIn6>() as u32;
let client = unsafe {
accept4_raw(
fd,
core::ptr::from_mut(&mut addr).cast::<u8>(),
core::ptr::from_mut(&mut len),
flags,
)?
};
Ok((client, addr))
}
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 fn sendto_in(fd: RawFd, buf: &[u8], flags: i32, addr: &SockAddrIn) -> SysResult<usize> {
unsafe {
syscall6(
nr::SENDTO,
fd as usize,
buf.as_ptr() as usize,
buf.len(),
flags as usize,
core::ptr::from_ref(addr) as usize,
size_of::<SockAddrIn>(),
)
}
}
pub fn sendto_in6(fd: RawFd, buf: &[u8], flags: i32, addr: &SockAddrIn6) -> SysResult<usize> {
unsafe {
syscall6(
nr::SENDTO,
fd as usize,
buf.as_ptr() as usize,
buf.len(),
flags as usize,
core::ptr::from_ref(addr) as usize,
size_of::<SockAddrIn6>(),
)
}
}
pub fn recvfrom_in(fd: RawFd, buf: &mut [u8], flags: i32) -> SysResult<(usize, SockAddrIn)> {
let mut addr = SockAddrIn::default();
let mut addrlen = size_of::<SockAddrIn>() as u32;
let n = unsafe {
syscall6(
nr::RECVFROM,
fd as usize,
buf.as_mut_ptr() as usize,
buf.len(),
flags as usize,
core::ptr::from_mut(&mut addr) as usize,
core::ptr::from_mut(&mut addrlen) as usize,
)?
};
Ok((n, addr))
}
pub fn recvfrom_in6(fd: RawFd, buf: &mut [u8], flags: i32) -> SysResult<(usize, SockAddrIn6)> {
let mut addr = SockAddrIn6::default();
let mut addrlen = size_of::<SockAddrIn6>() as u32;
let n = unsafe {
syscall6(
nr::RECVFROM,
fd as usize,
buf.as_mut_ptr() as usize,
buf.len(),
flags as usize,
core::ptr::from_mut(&mut addr) as usize,
core::ptr::from_mut(&mut addrlen) as usize,
)?
};
Ok((n, addr))
}
pub unsafe fn getsockname_raw(fd: RawFd, addr: *mut u8, addrlen: *mut u32) -> SysResult<()> {
unsafe {
syscall3(
nr::GETSOCKNAME,
fd as usize,
addr as usize,
addrlen as usize,
)?;
}
Ok(())
}
pub unsafe fn getpeername_raw(fd: RawFd, addr: *mut u8, addrlen: *mut u32) -> SysResult<()> {
unsafe {
syscall3(
nr::GETPEERNAME,
fd as usize,
addr as usize,
addrlen as usize,
)?;
}
Ok(())
}
pub fn getsockname_in(fd: RawFd) -> SysResult<SockAddrIn> {
let mut addr = SockAddrIn::default();
let mut len = size_of::<SockAddrIn>() as u32;
unsafe {
getsockname_raw(
fd,
core::ptr::from_mut(&mut addr).cast::<u8>(),
core::ptr::from_mut(&mut len),
)?;
}
Ok(addr)
}
pub fn getsockname_in6(fd: RawFd) -> SysResult<SockAddrIn6> {
let mut addr = SockAddrIn6::default();
let mut len = size_of::<SockAddrIn6>() as u32;
unsafe {
getsockname_raw(
fd,
core::ptr::from_mut(&mut addr).cast::<u8>(),
core::ptr::from_mut(&mut len),
)?;
}
Ok(addr)
}
pub fn set_tcp_nodelay(fd: RawFd, nodelay: bool) -> SysResult<()> {
let val: i32 = i32::from(nodelay);
unsafe {
setsockopt_raw(
fd,
IPPROTO_TCP,
TCP_NODELAY,
core::ptr::from_ref(&val).cast::<u8>(),
size_of::<i32>() as u32,
)
}
}
pub fn get_so_error(fd: RawFd) -> SysResult<i32> {
let mut err: i32 = 0;
let mut len = size_of::<i32>() as u32;
unsafe {
getsockopt_raw(
fd,
SOL_SOCKET,
SO_ERROR,
core::ptr::from_mut(&mut err).cast::<u8>(),
core::ptr::from_mut(&mut len),
)?;
}
Ok(err)
}
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);
}
#[test]
fn ipv4_and_ipv6_sockaddr_layouts_and_byte_order() {
let v4 = SockAddrIn::new([127, 0, 0, 1], 8080);
assert_eq!(v4.sin_family, AF_INET as u16);
assert_eq!(v4.sin_port, 8080u16.to_be());
assert_eq!(v4.sin_addr.s_addr, u32::from_ne_bytes([127, 0, 0, 1]));
assert_eq!(v4.ip(), [127, 0, 0, 1]);
assert_eq!(v4.port(), 8080);
let ip6 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
let v6 = SockAddrIn6::new(ip6, 443, 0x1234, 2);
assert_eq!(v6.sin6_family, AF_INET6 as u16);
assert_eq!(v6.sin6_port, 443u16.to_be());
assert_eq!(v6.sin6_flowinfo, 0x1234);
assert_eq!(v6.sin6_addr.s6_addr, ip6);
assert_eq!(v6.sin6_scope_id, 2);
assert_eq!(v6.ip(), ip6);
assert_eq!(v6.port(), 443);
}
}