hermit/syscalls/socket/
mod.rs

1#![allow(dead_code)]
2#![allow(nonstandard_style)]
3
4mod addrinfo;
5
6use alloc::boxed::Box;
7use alloc::sync::Arc;
8use core::ffi::{c_char, c_void};
9use core::mem::{self, size_of};
10use core::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
11#[allow(unused_imports)]
12use core::ops::DerefMut;
13
14use cfg_if::cfg_if;
15use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
16#[cfg(feature = "net")]
17use smoltcp::wire::{IpAddress, IpEndpoint, IpListenEndpoint};
18
19use crate::errno::Errno;
20#[cfg(feature = "net")]
21use crate::executor::network::{NIC, NetworkState};
22#[cfg(feature = "tcp")]
23use crate::fd::socket::tcp;
24#[cfg(feature = "udp")]
25use crate::fd::socket::udp;
26#[cfg(feature = "vsock")]
27use crate::fd::socket::vsock::{self, VsockEndpoint, VsockListenEndpoint};
28use crate::fd::{
29	self, Endpoint, ListenEndpoint, ObjectInterface, SocketOption, get_object, insert_object,
30};
31use crate::syscalls::block_on;
32
33#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
34#[repr(u8)]
35pub enum Af {
36	Unspec = 0,
37	Inet = 3,
38	Inet6 = 1,
39	Unix = 4,
40	#[cfg(feature = "vsock")]
41	Vsock = 2,
42}
43
44impl From<IpAddr> for Af {
45	fn from(value: IpAddr) -> Self {
46		match value {
47			IpAddr::V4(_) => Self::Inet,
48			IpAddr::V6(_) => Self::Inet6,
49		}
50	}
51}
52
53#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
54#[repr(u8)]
55pub enum Ipproto {
56	Ip = 0,
57	Ipv6 = 41,
58	Tcp = 6,
59	Udp = 17,
60}
61
62pub const IPV6_ADD_MEMBERSHIP: i32 = 12;
63pub const IPV6_DROP_MEMBERSHIP: i32 = 13;
64pub const IPV6_MULTICAST_LOOP: i32 = 19;
65pub const IPV6_V6ONLY: i32 = 27;
66pub const IP_TOS: i32 = 1;
67pub const IP_TTL: i32 = 2;
68pub const IP_MULTICAST_TTL: i32 = 5;
69pub const IP_MULTICAST_LOOP: i32 = 7;
70pub const IP_ADD_MEMBERSHIP: i32 = 3;
71pub const IP_DROP_MEMBERSHIP: i32 = 4;
72pub const SOL_SOCKET: i32 = 4095;
73pub const SO_REUSEADDR: i32 = 0x0004;
74pub const SO_KEEPALIVE: i32 = 0x0008;
75pub const SO_BROADCAST: i32 = 0x0020;
76pub const SO_LINGER: i32 = 0x0080;
77pub const SO_SNDBUF: i32 = 0x1001;
78pub const SO_RCVBUF: i32 = 0x1002;
79pub const SO_SNDTIMEO: i32 = 0x1005;
80pub const SO_RCVTIMEO: i32 = 0x1006;
81pub const SO_ERROR: i32 = 0x1007;
82pub const TCP_NODELAY: i32 = 1;
83pub const MSG_PEEK: i32 = 1;
84pub type sa_family_t = u8;
85pub type socklen_t = u32;
86pub type in_addr_t = u32;
87pub type in_port_t = u16;
88
89#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
90#[repr(u8)]
91pub enum Sock {
92	Stream = 1,
93	Dgram = 2,
94	Raw = 3,
95	Seqpacket = 5,
96}
97
98bitflags! {
99	#[derive(Debug, Copy, Clone)]
100	#[repr(C)]
101	pub struct SockFlags: i32 {
102		const SOCK_NONBLOCK = 0o4000;
103		const SOCK_CLOEXEC = 0o40000;
104		const _ = !0;
105	}
106}
107
108impl Sock {
109	pub fn from_bits(bits: i32) -> Option<(Self, SockFlags)> {
110		let sock = Sock::try_from(bits as u8).ok()?;
111		let flags = SockFlags::from_bits_retain(bits & !0xff);
112		Some((sock, flags))
113	}
114}
115
116#[repr(C)]
117#[derive(Debug, Default, Copy, Clone)]
118pub struct in_addr {
119	pub s_addr: in_addr_t,
120}
121
122impl From<Ipv4Addr> for in_addr {
123	fn from(value: Ipv4Addr) -> Self {
124		Self {
125			s_addr: u32::from_ne_bytes(value.octets()),
126		}
127	}
128}
129
130#[repr(C, align(4))]
131#[derive(Debug, Default, Copy, Clone)]
132pub struct in6_addr {
133	pub s6_addr: [u8; 16],
134}
135
136impl From<Ipv6Addr> for in6_addr {
137	fn from(value: Ipv6Addr) -> Self {
138		Self {
139			s6_addr: value.octets(),
140		}
141	}
142}
143
144#[repr(C)]
145#[derive(Debug, Default, Copy, Clone)]
146pub struct sockaddr {
147	pub sa_len: u8,
148	pub sa_family: sa_family_t,
149	pub sa_data: [c_char; 14],
150}
151
152#[derive(Clone, Debug)]
153pub enum sockaddrBox {
154	sockaddr(Box<sockaddr>),
155	sockaddr_in(Box<sockaddr_in>),
156	sockaddr_in6(Box<sockaddr_in6>),
157	sockaddr_un(Box<sockaddr_un>),
158	#[cfg(feature = "vsock")]
159	sockaddr_vm(Box<sockaddr_vm>),
160}
161
162#[derive(Clone, Copy, Debug)]
163pub enum sockaddrRef<'a> {
164	sockaddr(&'a sockaddr),
165	sockaddr_in(&'a sockaddr_in),
166	sockaddr_in6(&'a sockaddr_in6),
167	sockaddr_un(&'a sockaddr_un),
168	#[cfg(feature = "vsock")]
169	sockaddr_vm(&'a sockaddr_vm),
170}
171
172impl sockaddr {
173	pub unsafe fn sa_family(ptr: *const Self) -> Result<Af, TryFromPrimitiveError<Af>> {
174		let sa_family = unsafe { (*ptr).sa_family };
175		Af::try_from(sa_family)
176	}
177
178	pub unsafe fn as_ref(ptr: &*const Self) -> Result<sockaddrRef<'_>, TryFromPrimitiveError<Af>> {
179		let ptr = *ptr;
180		let sa_family = unsafe { Self::sa_family(ptr)? };
181		let ret = match sa_family {
182			Af::Unspec => sockaddrRef::sockaddr(unsafe { &*ptr }),
183			Af::Inet => sockaddrRef::sockaddr_in(unsafe { &*ptr.cast() }),
184			Af::Inet6 => sockaddrRef::sockaddr_in6(unsafe { &*ptr.cast() }),
185			Af::Unix => sockaddrRef::sockaddr_un(unsafe { &*ptr.cast() }),
186			#[cfg(feature = "vsock")]
187			Af::Vsock => sockaddrRef::sockaddr_vm(unsafe { &*ptr.cast() }),
188		};
189		Ok(ret)
190	}
191
192	pub unsafe fn as_box(ptr: *mut Self) -> Result<sockaddrBox, TryFromPrimitiveError<Af>> {
193		let sa_family = unsafe { Self::sa_family(ptr)? };
194		let ret = match sa_family {
195			Af::Unspec => sockaddrBox::sockaddr(unsafe { Box::from_raw(ptr) }),
196			Af::Inet => sockaddrBox::sockaddr_in(unsafe { Box::from_raw(ptr.cast()) }),
197			Af::Inet6 => sockaddrBox::sockaddr_in6(unsafe { Box::from_raw(ptr.cast()) }),
198			Af::Unix => sockaddrBox::sockaddr_un(unsafe { Box::from_raw(ptr.cast()) }),
199			#[cfg(feature = "vsock")]
200			Af::Vsock => sockaddrBox::sockaddr_vm(unsafe { Box::from_raw(ptr.cast()) }),
201		};
202		Ok(ret)
203	}
204}
205
206impl sockaddrBox {
207	pub fn into_raw(self) -> *mut sockaddr {
208		match self {
209			sockaddrBox::sockaddr(sockaddr) => Box::into_raw(sockaddr),
210			sockaddrBox::sockaddr_in(sockaddr_in) => Box::into_raw(sockaddr_in).cast(),
211			sockaddrBox::sockaddr_in6(sockaddr_in6) => Box::into_raw(sockaddr_in6).cast(),
212			sockaddrBox::sockaddr_un(sockaddr_un) => Box::into_raw(sockaddr_un).cast(),
213			#[cfg(feature = "vsock")]
214			sockaddrBox::sockaddr_vm(sockaddr_vm) => Box::into_raw(sockaddr_vm).cast(),
215		}
216	}
217
218	pub fn as_ref(&self) -> sockaddrRef<'_> {
219		match self {
220			Self::sockaddr(sockaddr) => sockaddrRef::sockaddr(sockaddr.as_ref()),
221			Self::sockaddr_in(sockaddr_in) => sockaddrRef::sockaddr_in(sockaddr_in.as_ref()),
222			Self::sockaddr_in6(sockaddr_in6) => sockaddrRef::sockaddr_in6(sockaddr_in6.as_ref()),
223			Self::sockaddr_un(sockaddr_un) => sockaddrRef::sockaddr_un(sockaddr_un.as_ref()),
224			#[cfg(feature = "vsock")]
225			Self::sockaddr_vm(sockaddr_vm) => sockaddrRef::sockaddr_vm(sockaddr_vm.as_ref()),
226		}
227	}
228}
229
230impl From<SocketAddr> for sockaddrBox {
231	fn from(value: SocketAddr) -> Self {
232		match value {
233			SocketAddr::V4(socket_addr_v4) => Self::sockaddr_in(Box::new(socket_addr_v4.into())),
234			SocketAddr::V6(socket_addr_v6) => Self::sockaddr_in6(Box::new(socket_addr_v6.into())),
235		}
236	}
237}
238
239impl sockaddrRef<'_> {
240	pub fn addrlen(self) -> u8 {
241		match self {
242			sockaddrRef::sockaddr(sockaddr) => sockaddr.sa_len,
243			sockaddrRef::sockaddr_in(sockaddr_in) => sockaddr_in.sin_len,
244			sockaddrRef::sockaddr_in6(sockaddr_in6) => sockaddr_in6.sin6_len,
245			sockaddrRef::sockaddr_un(sockaddr_un) => sockaddr_un.sun_len,
246			#[cfg(feature = "vsock")]
247			sockaddrRef::sockaddr_vm(sockaddr_vm) => sockaddr_vm.svm_len,
248		}
249	}
250}
251
252#[cfg(feature = "vsock")]
253#[repr(C)]
254#[derive(Debug, Copy, Clone, Default)]
255pub struct sockaddr_vm {
256	pub svm_len: u8,
257	pub svm_family: sa_family_t,
258	pub svm_reserved1: u16,
259	pub svm_port: u32,
260	pub svm_cid: u32,
261	pub svm_zero: [u8; 4],
262}
263
264#[cfg(feature = "vsock")]
265impl From<sockaddr_vm> for VsockListenEndpoint {
266	fn from(addr: sockaddr_vm) -> VsockListenEndpoint {
267		let port = addr.svm_port;
268		let cid = if addr.svm_cid < u32::MAX {
269			Some(addr.svm_cid)
270		} else {
271			None
272		};
273
274		VsockListenEndpoint::new(port, cid)
275	}
276}
277
278#[cfg(feature = "vsock")]
279impl From<sockaddr_vm> for VsockEndpoint {
280	fn from(addr: sockaddr_vm) -> VsockEndpoint {
281		let port = addr.svm_port;
282		let cid = addr.svm_cid;
283
284		VsockEndpoint::new(port, cid)
285	}
286}
287
288#[cfg(feature = "vsock")]
289impl From<VsockEndpoint> for sockaddr_vm {
290	fn from(endpoint: VsockEndpoint) -> Self {
291		Self {
292			svm_len: core::mem::size_of::<sockaddr_vm>().try_into().unwrap(),
293			svm_family: Af::Vsock.into(),
294			svm_port: endpoint.port,
295			svm_cid: endpoint.cid,
296			..Default::default()
297		}
298	}
299}
300
301#[repr(C)]
302#[derive(Debug, Default, Copy, Clone)]
303pub struct sockaddr_in {
304	pub sin_len: u8,
305	pub sin_family: sa_family_t,
306	pub sin_port: in_port_t,
307	pub sin_addr: in_addr,
308	pub sin_zero: [c_char; 8],
309}
310
311#[cfg(feature = "net")]
312impl From<sockaddr_in> for IpListenEndpoint {
313	fn from(addr: sockaddr_in) -> IpListenEndpoint {
314		let port = u16::from_be(addr.sin_port);
315		if addr.sin_addr.s_addr == 0 {
316			IpListenEndpoint { addr: None, port }
317		} else {
318			let s_addr = addr.sin_addr.s_addr.to_ne_bytes();
319
320			let address = IpAddress::v4(s_addr[0], s_addr[1], s_addr[2], s_addr[3]);
321
322			IpListenEndpoint::from((address, port))
323		}
324	}
325}
326
327#[cfg(feature = "net")]
328impl From<sockaddr_in> for IpEndpoint {
329	fn from(addr: sockaddr_in) -> IpEndpoint {
330		let port = u16::from_be(addr.sin_port);
331		let s_addr = addr.sin_addr.s_addr.to_ne_bytes();
332		let address = IpAddress::v4(s_addr[0], s_addr[1], s_addr[2], s_addr[3]);
333
334		IpEndpoint::from((address, port))
335	}
336}
337
338#[cfg(feature = "net")]
339impl From<IpEndpoint> for sockaddr_in {
340	fn from(endpoint: IpEndpoint) -> Self {
341		match endpoint.addr {
342			IpAddress::Ipv4(ip) => {
343				let sin_addr = in_addr {
344					s_addr: u32::from_ne_bytes(ip.octets()),
345				};
346
347				Self {
348					sin_len: core::mem::size_of::<sockaddr_in>().try_into().unwrap(),
349					sin_port: endpoint.port.to_be(),
350					sin_family: Af::Inet.into(),
351					sin_addr,
352					..Default::default()
353				}
354			}
355			IpAddress::Ipv6(_) => panic!("Unable to convert IPv6 address to sockadd_in"),
356		}
357	}
358}
359
360impl From<SocketAddrV4> for sockaddr_in {
361	fn from(value: SocketAddrV4) -> Self {
362		Self {
363			sin_len: mem::size_of::<Self>().try_into().unwrap(),
364			sin_family: Af::Inet.into(),
365			sin_port: value.port().to_be(),
366			sin_addr: (*value.ip()).into(),
367			sin_zero: Default::default(),
368		}
369	}
370}
371
372#[repr(C)]
373#[derive(Debug, Default, Copy, Clone)]
374pub struct sockaddr_in6 {
375	pub sin6_len: u8,
376	pub sin6_family: sa_family_t,
377	pub sin6_port: in_port_t,
378	pub sin6_flowinfo: u32,
379	pub sin6_addr: in6_addr,
380	pub sin6_scope_id: u32,
381}
382
383#[cfg(feature = "net")]
384impl From<sockaddr_in6> for IpListenEndpoint {
385	fn from(addr: sockaddr_in6) -> IpListenEndpoint {
386		let port = u16::from_be(addr.sin6_port);
387		if addr.sin6_addr.s6_addr.into_iter().all(|b| b == 0) {
388			IpListenEndpoint { addr: None, port }
389		} else {
390			let s6_addr = addr.sin6_addr.s6_addr;
391			let a0 = (u16::from(s6_addr[0]) << 8) | u16::from(s6_addr[1]);
392			let a1 = (u16::from(s6_addr[2]) << 8) | u16::from(s6_addr[3]);
393			let a2 = (u16::from(s6_addr[4]) << 8) | u16::from(s6_addr[5]);
394			let a3 = (u16::from(s6_addr[6]) << 8) | u16::from(s6_addr[7]);
395			let a4 = (u16::from(s6_addr[8]) << 8) | u16::from(s6_addr[9]);
396			let a5 = (u16::from(s6_addr[10]) << 8) | u16::from(s6_addr[11]);
397			let a6 = (u16::from(s6_addr[12]) << 8) | u16::from(s6_addr[13]);
398			let a7 = (u16::from(s6_addr[14]) << 8) | u16::from(s6_addr[15]);
399			let address = IpAddress::v6(a0, a1, a2, a3, a4, a5, a6, a7);
400
401			IpListenEndpoint::from((address, port))
402		}
403	}
404}
405
406#[cfg(feature = "net")]
407impl From<sockaddr_in6> for IpEndpoint {
408	fn from(addr: sockaddr_in6) -> IpEndpoint {
409		let port = u16::from_be(addr.sin6_port);
410		let s6_addr = addr.sin6_addr.s6_addr;
411		let a0 = (u16::from(s6_addr[0]) << 8) | u16::from(s6_addr[1]);
412		let a1 = (u16::from(s6_addr[2]) << 8) | u16::from(s6_addr[3]);
413		let a2 = (u16::from(s6_addr[4]) << 8) | u16::from(s6_addr[5]);
414		let a3 = (u16::from(s6_addr[6]) << 8) | u16::from(s6_addr[7]);
415		let a4 = (u16::from(s6_addr[8]) << 8) | u16::from(s6_addr[9]);
416		let a5 = (u16::from(s6_addr[10]) << 8) | u16::from(s6_addr[11]);
417		let a6 = (u16::from(s6_addr[12]) << 8) | u16::from(s6_addr[13]);
418		let a7 = (u16::from(s6_addr[14]) << 8) | u16::from(s6_addr[15]);
419		let address = IpAddress::v6(a0, a1, a2, a3, a4, a5, a6, a7);
420
421		IpEndpoint::from((address, port))
422	}
423}
424
425#[cfg(feature = "net")]
426impl From<IpEndpoint> for sockaddr_in6 {
427	fn from(endpoint: IpEndpoint) -> Self {
428		match endpoint.addr {
429			IpAddress::Ipv6(ip) => {
430				let mut in6_addr = in6_addr::default();
431				in6_addr.s6_addr.copy_from_slice(&ip.octets());
432
433				Self {
434					sin6_len: core::mem::size_of::<sockaddr_in6>().try_into().unwrap(),
435					sin6_port: endpoint.port.to_be(),
436					sin6_family: Af::Inet6.into(),
437					sin6_addr: in6_addr,
438					..Default::default()
439				}
440			}
441			IpAddress::Ipv4(_) => panic!("Unable to convert IPv4 address to sockadd_in6"),
442		}
443	}
444}
445
446impl From<SocketAddrV6> for sockaddr_in6 {
447	fn from(value: SocketAddrV6) -> Self {
448		Self {
449			sin6_len: mem::size_of::<Self>().try_into().unwrap(),
450			sin6_family: Af::Inet6.into(),
451			sin6_port: value.port().to_be(),
452			sin6_flowinfo: Default::default(),
453			sin6_addr: (*value.ip()).into(),
454			sin6_scope_id: Default::default(),
455		}
456	}
457}
458
459#[repr(C)]
460#[derive(Debug, Copy, Clone)]
461pub struct sockaddr_un {
462	pub sun_len: u8,
463	pub sun_family: sa_family_t,
464	pub sun_path: [c_char; 104],
465}
466
467#[repr(C)]
468#[derive(Debug, Copy, Clone)]
469pub struct ip_mreq {
470	pub imr_multiaddr: in_addr,
471	pub imr_interface: in_addr,
472}
473
474#[repr(C)]
475#[derive(Debug, Copy, Clone)]
476pub struct ipv6_mreq {
477	pub ipv6mr_multiaddr: in6_addr,
478	pub ipv6mr_interface: u32,
479}
480#[repr(C)]
481#[derive(Debug, Copy, Clone)]
482pub struct linger {
483	pub l_onoff: i32,
484	pub l_linger: i32,
485}
486
487#[cfg(not(feature = "dns"))]
488#[hermit_macro::system(errno)]
489#[unsafe(no_mangle)]
490pub unsafe extern "C" fn sys_getaddrbyname(
491	_name: *const c_char,
492	_inaddr: *mut u8,
493	_len: usize,
494) -> i32 {
495	error!("Please enable the feature 'dns' to determine the network ip by name.");
496	-i32::from(Errno::Nosys)
497}
498
499/// The system call `sys_getaddrbyname` determine the network host entry.
500/// It expects an array of u8 with a size of in_addr or of in6_addr.
501/// The result of the DNS request will be stored in this array.
502///
503/// # Example
504///
505/// ```
506/// use hermit_abi::in_addr;
507/// let c_string = std::ffi::CString::new("rust-lang.org").expect("CString::new failed");
508/// let name = c_string.into_raw();
509/// let mut inaddr: in_addr = Default::default();
510/// let _ = unsafe {
511///         hermit_abi::getaddrbyname(
512///                 name,
513///                 &mut inaddr as *mut _ as *mut u8,
514///                 std::mem::size_of::<in_addr>(),
515///         )
516/// };
517///
518/// // retake pointer to free memory
519/// let _ = CString::from_raw(name);
520/// ```
521#[cfg(feature = "dns")]
522#[hermit_macro::system(errno)]
523#[unsafe(no_mangle)]
524pub unsafe extern "C" fn sys_getaddrbyname(
525	name: *const c_char,
526	inaddr: *mut u8,
527	len: usize,
528) -> i32 {
529	use alloc::borrow::ToOwned;
530
531	use smoltcp::wire::DnsQueryType;
532
533	use crate::executor::block_on;
534	use crate::executor::network::get_query_result;
535
536	if len != size_of::<in_addr>() && len != size_of::<in6_addr>() {
537		return -i32::from(Errno::Inval);
538	}
539
540	if inaddr.is_null() {
541		return -i32::from(Errno::Inval);
542	}
543
544	let query_type = if len == size_of::<in6_addr>() {
545		DnsQueryType::Aaaa
546	} else {
547		DnsQueryType::A
548	};
549
550	let name = unsafe { core::ffi::CStr::from_ptr(name) };
551	let name = if let Ok(name) = name.to_str() {
552		name.to_owned()
553	} else {
554		return -i32::from(Errno::Inval);
555	};
556
557	let query = {
558		let mut guard = NIC.lock();
559		let nic = guard.as_nic_mut().unwrap();
560		let query = nic.start_query(&name, query_type).unwrap();
561		nic.poll_common(crate::executor::network::now());
562
563		query
564	};
565
566	match block_on(get_query_result(query), None) {
567		Ok(addr_vec) => {
568			let slice = unsafe { core::slice::from_raw_parts_mut(inaddr, len) };
569
570			match addr_vec[0] {
571				IpAddress::Ipv4(ipv4_addr) => slice.copy_from_slice(&ipv4_addr.octets()),
572				IpAddress::Ipv6(ipv6_addr) => slice.copy_from_slice(&ipv6_addr.octets()),
573			}
574
575			0
576		}
577		Err(e) => -i32::from(e),
578	}
579}
580
581#[hermit_macro::system(errno)]
582#[unsafe(no_mangle)]
583pub extern "C" fn sys_socket(domain: i32, type_: i32, protocol: i32) -> i32 {
584	debug!("sys_socket: domain {domain}, type {type_:?}, protocol {protocol}");
585
586	let Ok(Ok(domain)) = u8::try_from(domain).map(Af::try_from) else {
587		return -i32::from(Errno::Inval);
588	};
589
590	let Some((sock, sock_flags)) = Sock::from_bits(type_) else {
591		return -i32::from(Errno::Inval);
592	};
593
594	let Ok(Ok(proto)) = u8::try_from(protocol).map(Ipproto::try_from) else {
595		return -i32::from(Errno::Inval);
596	};
597
598	match (sock, proto) {
599		(_, Ipproto::Ip | Ipproto::Ipv6)
600		| (Sock::Stream, Ipproto::Tcp)
601		| (Sock::Dgram, Ipproto::Udp) => {}
602		(_, _) => return -i32::from(Errno::Inval),
603	}
604
605	#[cfg(feature = "vsock")]
606	if domain == Af::Vsock && sock == Sock::Stream {
607		let mut socket = vsock::Socket::new();
608
609		if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
610			block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
611		}
612
613		let socket = Arc::new(async_lock::RwLock::new(socket));
614		let fd = insert_object(socket).expect("FD is already used");
615
616		return fd;
617	}
618
619	#[cfg(feature = "net")]
620	if (domain == Af::Inet || domain == Af::Inet6) && (sock == Sock::Stream || sock == Sock::Dgram)
621	{
622		let mut guard = NIC.lock();
623
624		if let NetworkState::Initialized(nic) = &mut *guard {
625			#[cfg(feature = "udp")]
626			if sock == Sock::Dgram {
627				let handle = nic.create_udp_handle().unwrap();
628				drop(guard);
629				let mut socket = udp::Socket::new(handle, domain);
630
631				if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
632					block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
633				}
634
635				let socket = Arc::new(async_lock::RwLock::new(socket));
636				let fd = insert_object(socket).expect("FD is already used");
637
638				return fd;
639			}
640
641			#[cfg(feature = "tcp")]
642			if sock == Sock::Stream {
643				let handle = nic.create_tcp_handle().unwrap();
644				drop(guard);
645				let mut socket = tcp::Socket::new(handle, domain);
646
647				if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
648					block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
649				}
650
651				let socket = Arc::new(async_lock::RwLock::new(socket));
652				let fd = insert_object(socket).expect("FD is already used");
653
654				return fd;
655			}
656		}
657	}
658
659	-i32::from(Errno::Inval)
660}
661
662#[hermit_macro::system(errno)]
663#[unsafe(no_mangle)]
664pub unsafe extern "C" fn sys_accept(fd: i32, addr: *mut sockaddr, addrlen: *mut socklen_t) -> i32 {
665	let obj = get_object(fd);
666	obj.map_or_else(
667		|e| -i32::from(e),
668		|v| {
669			block_on(async { v.write().await.accept().await }, None).map_or_else(
670				|e| -i32::from(e),
671				#[cfg_attr(not(feature = "net"), expect(unused_variables))]
672				|(obj, endpoint)| match endpoint {
673					#[cfg(feature = "net")]
674					Endpoint::Ip(endpoint) => {
675						let new_fd = insert_object(obj).unwrap();
676
677						if !addr.is_null() && !addrlen.is_null() {
678							let addrlen = unsafe { &mut *addrlen };
679
680							match endpoint.addr {
681								IpAddress::Ipv4(_) => {
682									if *addrlen >= u32::try_from(size_of::<sockaddr_in>()).unwrap()
683									{
684										let addr = unsafe { &mut *addr.cast() };
685										*addr = sockaddr_in::from(endpoint);
686										*addrlen = size_of::<sockaddr_in>().try_into().unwrap();
687									}
688								}
689								IpAddress::Ipv6(_) => {
690									if *addrlen >= u32::try_from(size_of::<sockaddr_in6>()).unwrap()
691									{
692										let addr = unsafe { &mut *addr.cast() };
693										*addr = sockaddr_in6::from(endpoint);
694										*addrlen = size_of::<sockaddr_in6>().try_into().unwrap();
695									}
696								}
697							}
698						}
699
700						new_fd
701					}
702					#[cfg(feature = "vsock")]
703					Endpoint::Vsock(endpoint) => {
704						let new_fd = insert_object(v.clone()).unwrap();
705
706						if !addr.is_null() && !addrlen.is_null() {
707							let addrlen = unsafe { &mut *addrlen };
708
709							if *addrlen >= u32::try_from(size_of::<sockaddr_vm>()).unwrap() {
710								let addr = unsafe { &mut *addr.cast() };
711								*addr = sockaddr_vm::from(endpoint);
712								*addrlen = size_of::<sockaddr_vm>().try_into().unwrap();
713							}
714						}
715
716						new_fd
717					}
718				},
719			)
720		},
721	)
722}
723
724#[hermit_macro::system(errno)]
725#[unsafe(no_mangle)]
726pub extern "C" fn sys_listen(fd: i32, backlog: i32) -> i32 {
727	let obj = get_object(fd);
728	obj.map_or_else(
729		|e| -i32::from(e),
730		|v| {
731			block_on(async { v.write().await.listen(backlog).await }, None)
732				.map_or_else(|e| -i32::from(e), |()| 0)
733		},
734	)
735}
736
737#[hermit_macro::system(errno)]
738#[unsafe(no_mangle)]
739pub unsafe extern "C" fn sys_bind(fd: i32, name: *const sockaddr, namelen: socklen_t) -> i32 {
740	if name.is_null() {
741		return -i32::from(Errno::Destaddrreq);
742	}
743
744	let Ok(family) = (unsafe { Af::try_from((*name).sa_family) }) else {
745		return -i32::from(Errno::Inval);
746	};
747
748	let obj = get_object(fd);
749	obj.map_or_else(
750		|e| -i32::from(e),
751		|v| match family {
752			#[cfg(feature = "net")]
753			Af::Inet => {
754				if namelen < u32::try_from(size_of::<sockaddr_in>()).unwrap() {
755					return -i32::from(Errno::Inval);
756				}
757				let endpoint = IpListenEndpoint::from(unsafe { *name.cast::<sockaddr_in>() });
758				block_on(
759					async { v.write().await.bind(ListenEndpoint::Ip(endpoint)).await },
760					None,
761				)
762				.map_or_else(|e| -i32::from(e), |()| 0)
763			}
764			#[cfg(feature = "net")]
765			Af::Inet6 => {
766				if namelen < u32::try_from(size_of::<sockaddr_in6>()).unwrap() {
767					return -i32::from(Errno::Inval);
768				}
769				let endpoint = IpListenEndpoint::from(unsafe { *name.cast::<sockaddr_in6>() });
770				block_on(
771					async { v.write().await.bind(ListenEndpoint::Ip(endpoint)).await },
772					None,
773				)
774				.map_or_else(|e| -i32::from(e), |()| 0)
775			}
776			#[cfg(feature = "vsock")]
777			Af::Vsock => {
778				if namelen < u32::try_from(size_of::<sockaddr_vm>()).unwrap() {
779					return -i32::from(Errno::Inval);
780				}
781				let endpoint = VsockListenEndpoint::from(unsafe { *name.cast::<sockaddr_vm>() });
782				block_on(
783					async { v.write().await.bind(ListenEndpoint::Vsock(endpoint)).await },
784					None,
785				)
786				.map_or_else(|e| -i32::from(e), |()| 0)
787			}
788			_ => -i32::from(Errno::Inval),
789		},
790	)
791}
792
793#[hermit_macro::system(errno)]
794#[unsafe(no_mangle)]
795pub unsafe extern "C" fn sys_connect(fd: i32, name: *const sockaddr, namelen: socklen_t) -> i32 {
796	if name.is_null() {
797		return -i32::from(Errno::Inval);
798	}
799
800	let Ok(sa_family) = (unsafe { Af::try_from((*name).sa_family) }) else {
801		return -i32::from(Errno::Inval);
802	};
803
804	let endpoint = match sa_family {
805		#[cfg(feature = "net")]
806		Af::Inet => {
807			if namelen < u32::try_from(size_of::<sockaddr_in>()).unwrap() {
808				return -i32::from(Errno::Inval);
809			}
810			Endpoint::Ip(IpEndpoint::from(unsafe { *name.cast::<sockaddr_in>() }))
811		}
812		#[cfg(feature = "net")]
813		Af::Inet6 => {
814			if namelen < u32::try_from(size_of::<sockaddr_in6>()).unwrap() {
815				return -i32::from(Errno::Inval);
816			}
817			Endpoint::Ip(IpEndpoint::from(unsafe { *name.cast::<sockaddr_in6>() }))
818		}
819		#[cfg(feature = "vsock")]
820		Af::Vsock => {
821			if namelen < u32::try_from(size_of::<sockaddr_vm>()).unwrap() {
822				return -i32::from(Errno::Inval);
823			}
824			Endpoint::Vsock(VsockEndpoint::from(unsafe { *name.cast::<sockaddr_vm>() }))
825		}
826		_ => {
827			return -i32::from(Errno::Inval);
828		}
829	};
830
831	let obj = get_object(fd);
832	obj.map_or_else(
833		|e| -i32::from(e),
834		|v| {
835			block_on(async { v.write().await.connect(endpoint).await }, None)
836				.map_or_else(|e| -i32::from(e), |()| 0)
837		},
838	)
839}
840
841#[hermit_macro::system(errno)]
842#[unsafe(no_mangle)]
843pub unsafe extern "C" fn sys_getsockname(
844	fd: i32,
845	addr: *mut sockaddr,
846	addrlen: *mut socklen_t,
847) -> i32 {
848	let obj = get_object(fd);
849	obj.map_or_else(
850		|e| -i32::from(e),
851		|v| {
852			if let Ok(Some(endpoint)) = block_on(async { v.read().await.getsockname().await }, None)
853			{
854				if !addr.is_null() && !addrlen.is_null() {
855					let addrlen = unsafe { &mut *addrlen };
856
857					match endpoint {
858						#[cfg(feature = "net")]
859						Endpoint::Ip(endpoint) => match endpoint.addr {
860							IpAddress::Ipv4(_) => {
861								if *addrlen >= u32::try_from(size_of::<sockaddr_in>()).unwrap() {
862									let addr = unsafe { &mut *addr.cast() };
863									*addr = sockaddr_in::from(endpoint);
864									*addrlen = size_of::<sockaddr_in>().try_into().unwrap();
865
866									0
867								} else {
868									-i32::from(Errno::Inval)
869								}
870							}
871							#[cfg(feature = "net")]
872							IpAddress::Ipv6(_) => {
873								if *addrlen >= u32::try_from(size_of::<sockaddr_in6>()).unwrap() {
874									let addr = unsafe { &mut *addr.cast() };
875									*addr = sockaddr_in6::from(endpoint);
876									*addrlen = size_of::<sockaddr_in6>().try_into().unwrap();
877
878									0
879								} else {
880									-i32::from(Errno::Inval)
881								}
882							}
883						},
884						#[cfg(feature = "vsock")]
885						Endpoint::Vsock(_) => {
886							if *addrlen >= u32::try_from(size_of::<sockaddr_vm>()).unwrap() {
887								warn!("unsupported device");
888								0
889							} else {
890								-i32::from(Errno::Inval)
891							}
892						}
893					}
894				} else {
895					-i32::from(Errno::Inval)
896				}
897			} else {
898				-i32::from(Errno::Inval)
899			}
900		},
901	)
902}
903
904#[hermit_macro::system(errno)]
905#[unsafe(no_mangle)]
906pub unsafe extern "C" fn sys_setsockopt(
907	fd: i32,
908	level: i32,
909	optname: i32,
910	optval: *const c_void,
911	optlen: socklen_t,
912) -> i32 {
913	if level == SOL_SOCKET && optname == SO_REUSEADDR {
914		return 0;
915	}
916
917	let Ok(Ok(level)) = u8::try_from(level).map(Ipproto::try_from) else {
918		return -i32::from(Errno::Inval);
919	};
920
921	debug!("sys_setsockopt: {fd}, level {level:?}, optname {optname}");
922
923	if level == Ipproto::Tcp
924		&& optname == TCP_NODELAY
925		&& optlen == u32::try_from(size_of::<i32>()).unwrap()
926	{
927		if optval.is_null() {
928			return -i32::from(Errno::Inval);
929		}
930
931		let value = unsafe { *optval.cast::<i32>() };
932		let obj = get_object(fd);
933		obj.map_or_else(
934			|e| -i32::from(e),
935			|v| {
936				block_on(
937					async {
938						v.read()
939							.await
940							.setsockopt(SocketOption::TcpNoDelay, value != 0)
941							.await
942					},
943					None,
944				)
945				.map_or_else(|e| -i32::from(e), |()| 0)
946			},
947		)
948	} else {
949		-i32::from(Errno::Inval)
950	}
951}
952
953#[hermit_macro::system(errno)]
954#[unsafe(no_mangle)]
955pub unsafe extern "C" fn sys_getsockopt(
956	fd: i32,
957	level: i32,
958	optname: i32,
959	optval: *mut c_void,
960	optlen: *mut socklen_t,
961) -> i32 {
962	let Ok(Ok(level)) = u8::try_from(level).map(Ipproto::try_from) else {
963		return -i32::from(Errno::Inval);
964	};
965
966	debug!("sys_getsockopt: {fd}, level {level:?}, optname {optname}");
967
968	if level == Ipproto::Tcp && optname == TCP_NODELAY {
969		if optval.is_null() || optlen.is_null() {
970			return -i32::from(Errno::Inval);
971		}
972
973		let optval = unsafe { &mut *optval.cast::<i32>() };
974		let optlen = unsafe { &mut *optlen };
975		let obj = get_object(fd);
976		obj.map_or_else(
977			|e| -i32::from(e),
978			|v| {
979				block_on(
980					async { v.read().await.getsockopt(SocketOption::TcpNoDelay).await },
981					None,
982				)
983				.map_or_else(
984					|e| -i32::from(e),
985					|value| {
986						if value {
987							*optval = 1;
988						} else {
989							*optval = 0;
990						}
991						*optlen = core::mem::size_of::<i32>().try_into().unwrap();
992
993						0
994					},
995				)
996			},
997		)
998	} else {
999		-i32::from(Errno::Inval)
1000	}
1001}
1002
1003#[hermit_macro::system(errno)]
1004#[unsafe(no_mangle)]
1005pub unsafe extern "C" fn sys_getpeername(
1006	fd: i32,
1007	addr: *mut sockaddr,
1008	addrlen: *mut socklen_t,
1009) -> i32 {
1010	let obj = get_object(fd);
1011	obj.map_or_else(
1012		|e| -i32::from(e),
1013		|v| {
1014			if let Ok(Some(endpoint)) = block_on(async { v.read().await.getpeername().await }, None)
1015			{
1016				if !addr.is_null() && !addrlen.is_null() {
1017					let addrlen = unsafe { &mut *addrlen };
1018
1019					match endpoint {
1020						#[cfg(feature = "net")]
1021						Endpoint::Ip(endpoint) => match endpoint.addr {
1022							IpAddress::Ipv4(_) => {
1023								if *addrlen >= u32::try_from(size_of::<sockaddr_in>()).unwrap() {
1024									let addr = unsafe { &mut *addr.cast() };
1025									*addr = sockaddr_in::from(endpoint);
1026									*addrlen = size_of::<sockaddr_in>().try_into().unwrap();
1027								} else {
1028									return -i32::from(Errno::Inval);
1029								}
1030							}
1031							IpAddress::Ipv6(_) => {
1032								if *addrlen >= u32::try_from(size_of::<sockaddr_in6>()).unwrap() {
1033									let addr = unsafe { &mut *addr.cast() };
1034									*addr = sockaddr_in6::from(endpoint);
1035									*addrlen = size_of::<sockaddr_in6>().try_into().unwrap();
1036								} else {
1037									return -i32::from(Errno::Inval);
1038								}
1039							}
1040						},
1041						#[cfg(feature = "vsock")]
1042						Endpoint::Vsock(_) => {
1043							if *addrlen >= u32::try_from(size_of::<sockaddr_vm>()).unwrap() {
1044								warn!("unsupported device");
1045							} else {
1046								return -i32::from(Errno::Inval);
1047							}
1048						}
1049					}
1050				} else {
1051					return -i32::from(Errno::Inval);
1052				}
1053			}
1054
1055			0
1056		},
1057	)
1058}
1059
1060#[hermit_macro::system(errno)]
1061#[unsafe(no_mangle)]
1062pub unsafe extern "C" fn sys_send(s: i32, mem: *const c_void, len: usize, _flags: i32) -> isize {
1063	unsafe { super::write(s, mem.cast(), len) }
1064}
1065
1066fn shutdown(sockfd: i32, how: i32) -> i32 {
1067	let obj = get_object(sockfd);
1068	obj.map_or_else(
1069		|e| -i32::from(e),
1070		|v| {
1071			block_on(async { v.read().await.shutdown(how).await }, None)
1072				.map_or_else(|e| -i32::from(e), |()| 0)
1073		},
1074	)
1075}
1076
1077#[hermit_macro::system(errno)]
1078#[unsafe(no_mangle)]
1079pub extern "C" fn sys_shutdown(sockfd: i32, how: i32) -> i32 {
1080	shutdown(sockfd, how)
1081}
1082
1083#[hermit_macro::system(errno)]
1084#[unsafe(no_mangle)]
1085pub extern "C" fn sys_shutdown_socket(fd: i32, how: i32) -> i32 {
1086	shutdown(fd, how)
1087}
1088
1089#[hermit_macro::system(errno)]
1090#[unsafe(no_mangle)]
1091pub unsafe extern "C" fn sys_recv(fd: i32, buf: *mut u8, len: usize, flags: i32) -> isize {
1092	if flags == 0 {
1093		let slice = unsafe { core::slice::from_raw_parts_mut(buf.cast(), len) };
1094		fd::read(fd, slice).map_or_else(
1095			|e| isize::try_from(-i32::from(e)).unwrap(),
1096			|v| v.try_into().unwrap(),
1097		)
1098	} else {
1099		(-i32::from(Errno::Inval)).try_into().unwrap()
1100	}
1101}
1102
1103#[hermit_macro::system(errno)]
1104#[unsafe(no_mangle)]
1105pub unsafe extern "C" fn sys_sendto(
1106	fd: i32,
1107	buf: *const u8,
1108	len: usize,
1109	_flags: i32,
1110	addr: *const sockaddr,
1111	addr_len: socklen_t,
1112) -> isize {
1113	let endpoint;
1114
1115	if addr.is_null() || addr_len == 0 {
1116		return (-i32::from(Errno::Inval)).try_into().unwrap();
1117	}
1118
1119	cfg_if! {
1120		if #[cfg(feature = "net")] {
1121			let Ok(sa_family) = (unsafe { Af::try_from((*addr).sa_family) }) else {
1122				return (-i32::from(Errno::Inval)).try_into().unwrap();
1123			};
1124
1125			if sa_family == Af::Inet {
1126				if addr_len < u32::try_from(size_of::<sockaddr_in>()).unwrap() {
1127					return (-i32::from(Errno::Inval)).try_into().unwrap();
1128				}
1129
1130				endpoint = Some(Endpoint::Ip(IpEndpoint::from(unsafe {*(addr.cast::<sockaddr_in>())})));
1131			} else if sa_family == Af::Inet6 {
1132				if addr_len < u32::try_from(size_of::<sockaddr_in6>()).unwrap() {
1133					return (-i32::from(Errno::Inval)).try_into().unwrap();
1134				}
1135
1136				endpoint = Some(Endpoint::Ip(IpEndpoint::from(unsafe { *(addr.cast::<sockaddr_in6>()) })));
1137			} else {
1138				endpoint = None;
1139			}
1140		} else {
1141			endpoint = None;
1142		}
1143	}
1144
1145	if let Some(endpoint) = endpoint {
1146		let slice = unsafe { core::slice::from_raw_parts(buf, len) };
1147		let obj = get_object(fd);
1148
1149		obj.map_or_else(
1150			|e| isize::try_from(-i32::from(e)).unwrap(),
1151			|v| {
1152				block_on(async { v.read().await.sendto(slice, endpoint).await }, None).map_or_else(
1153					|e| isize::try_from(-i32::from(e)).unwrap(),
1154					|v| v.try_into().unwrap(),
1155				)
1156			},
1157		)
1158	} else {
1159		(-i32::from(Errno::Inval)).try_into().unwrap()
1160	}
1161}
1162
1163#[hermit_macro::system(errno)]
1164#[unsafe(no_mangle)]
1165pub unsafe extern "C" fn sys_recvfrom(
1166	fd: i32,
1167	buf: *mut u8,
1168	len: usize,
1169	_flags: i32,
1170	addr: *mut sockaddr,
1171	addrlen: *mut socklen_t,
1172) -> isize {
1173	let slice = unsafe { core::slice::from_raw_parts_mut(buf.cast(), len) };
1174	let obj = get_object(fd);
1175	obj.map_or_else(
1176		|e| isize::try_from(-i32::from(e)).unwrap(),
1177		|v| {
1178			block_on(async { v.read().await.recvfrom(slice).await }, None).map_or_else(
1179				|e| isize::try_from(-i32::from(e)).unwrap(),
1180				|(len, endpoint)| {
1181					if !addr.is_null() && !addrlen.is_null() {
1182						#[allow(unused_variables)]
1183						let addrlen = unsafe { &mut *addrlen };
1184
1185						match endpoint {
1186							#[cfg(feature = "net")]
1187							Endpoint::Ip(endpoint) => match endpoint.addr {
1188								IpAddress::Ipv4(_) => {
1189									if *addrlen >= u32::try_from(size_of::<sockaddr_in>()).unwrap()
1190									{
1191										let addr = unsafe { &mut *addr.cast() };
1192										*addr = sockaddr_in::from(endpoint);
1193										*addrlen = size_of::<sockaddr_in>().try_into().unwrap();
1194									} else {
1195										return (-i32::from(Errno::Inval)).try_into().unwrap();
1196									}
1197								}
1198								IpAddress::Ipv6(_) => {
1199									if *addrlen >= u32::try_from(size_of::<sockaddr_in6>()).unwrap()
1200									{
1201										let addr = unsafe { &mut *addr.cast() };
1202										*addr = sockaddr_in6::from(endpoint);
1203										*addrlen = size_of::<sockaddr_in6>().try_into().unwrap();
1204									} else {
1205										return (-i32::from(Errno::Inval)).try_into().unwrap();
1206									}
1207								}
1208							},
1209							#[cfg(feature = "vsock")]
1210							_ => {
1211								return (-i32::from(Errno::Inval)).try_into().unwrap();
1212							}
1213						}
1214					}
1215
1216					len.try_into().unwrap()
1217				},
1218			)
1219		},
1220	)
1221}
hermit/syscalls/socket/mod.rs

hermit/syscalls/socket/
mod.rs
