Add Rust bindings (WIP)

pkg/crate/libzt/src/socket.rs

@@ -0,0 +1,329 @@
+/*
+ * Copyright (c)2013-2021 ZeroTier, Inc.
+ *
+ * Use of this software is governed by the Business Source License included
+ * in the LICENSE.TXT file in the project's root directory.
+ *
+ * Change Date: 2026-01-01
+ *
+ * On the date above, in accordance with the Business Source License, use
+ * of this software will be governed by version 2.0 of the Apache License.
+ */
+/****/
+
+use std::convert::TryInto;
+use std::ffi::c_void;
+use std::io::{Error, ErrorKind};
+use std::net::{Shutdown, SocketAddr};
+use std::os::raw::c_int;
+use std::time::Duration;
+use std::{io, mem};
+
+use crate::utils::*;
+
+// Note: FileDesc and c_int in libc are private so we can't use that. Use i32 instead
+pub struct Socket(c_int);
+
+impl Socket {
+    pub fn new(addr: &SocketAddr, sock_type: c_int) -> io::Result<Socket> {
+        let family = match *addr {
+            SocketAddr::V4(..) => ZTS_AF_INET,
+            SocketAddr::V6(..) => ZTS_AF_INET6,
+        };
+        Socket::new_raw(family as i32, sock_type)
+    }
+
+    pub fn new_raw(family: c_int, sock_type: c_int) -> io::Result<Socket> {
+        unsafe {
+            // TODO: Set O_CLOEXEC (this is done in the Rust netc implementation)
+            let fd = zts_bsd_socket(family, sock_type, 0);
+            Ok(Socket(fd))
+        }
+    }
+
+    pub fn accept(
+        &self,
+        storage: *mut zts_sockaddr,
+        len: *mut zts_socklen_t,
+    ) -> io::Result<Socket> {
+        let fd = unsafe { zts_bsd_accept(self.0, storage, len) };
+        Ok(Socket(fd))
+    }
+
+    pub fn as_inner(&self) -> &c_int {
+        &self.0
+        //.as_inner()
+    }
+
+    /*
+        pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
+            self.set_nonblocking(true)?;
+            let r = unsafe {
+                let (addrp, len) = addr.into_inner();
+                cvt(zts_bsd_connect(self.0, addrp, len))
+            };
+            self.set_nonblocking(false)?;
+
+            match r {
+                Ok(_) => return Ok(()),
+                // there's no ErrorKind for EINPROGRESS :(
+                Err(ref e) if e.raw_os_error() == Some(ZTS_EINPROGRESS) => {}
+                Err(e) => return Err(e),
+            }
+
+            let mut pollfd = zts_pollfd { fd: self.0, events: ZTS_POLLOUT, revents: 0 };
+
+            if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
+                return Err(io::Error::new_const(
+                    io::ErrorKind::InvalidInput,
+                    &"cannot set a 0 duration timeout",
+                ));
+            }
+
+            let start = Instant::now();
+
+            loop {
+                let elapsed = start.elapsed();
+                if elapsed >= timeout {
+                    return Err(io::Error::new_const(io::ErrorKind::TimedOut, &"connection timed out"));
+                }
+
+                let timeout = timeout - elapsed;
+                let mut timeout = timeout
+                    .as_secs()
+                    .saturating_mul(1_000)
+                    .saturating_add(timeout.subsec_nanos() as u64 / 1_000_000);
+                if timeout == 0 {
+                    timeout = 1;
+                }
+
+                let timeout = cmp::min(timeout, c_int::MAX as u64) as c_int;
+
+                match unsafe { zts_bsd_poll(&mut pollfd, 1, timeout) } {
+                    -1 => {
+                        let err = io::Error::last_os_error();
+                        if err.kind() != io::ErrorKind::Interrupted {
+                            return Err(err);
+                        }
+                    }
+                    0 => {}
+                    _ => {
+                        // linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look
+                        // for POLLHUP rather than read readiness
+                        if pollfd.revents & ZTS_POLLHUP != 0 {
+                            let e = self.take_error()?.unwrap_or_else(|| {
+                                io::Error::new_const(
+                                    io::ErrorKind::Other,
+                                    &"no error set after POLLHUP",
+                                )
+                            });
+                            return Err(e);
+                        }
+
+                        return Ok(());
+                    }
+                }
+            }
+        }
+    */
+
+    fn recv_with_flags(&self, buf: &mut [u8], flags: c_int) -> io::Result<usize> {
+        unsafe {
+            let raw = zts_bsd_recv(
+                self.0,
+                buf.as_mut_ptr() as *mut c_void,
+                (buf.len() as usize).try_into().unwrap(),
+                flags,
+            );
+            Ok(raw as usize)
+        }
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.recv_with_flags(buf, 0)
+    }
+
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.recv_with_flags(buf, ZTS_MSG_PEEK as i32)
+    }
+    /*
+        pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+            self.0.read_vectored(bufs)
+        }
+    */
+    #[inline]
+    pub fn is_read_vectored(&self) -> bool {
+        // TODO: In principle this is possible but is not hooked up yet
+        return false;
+    }
+
+    fn recv_from_with_flags(
+        &self,
+        buf: &mut [u8],
+        flags: c_int,
+    ) -> io::Result<(usize, SocketAddr)> {
+        let mut storage: zts_sockaddr_storage = unsafe { mem::zeroed() };
+        let mut addrlen = mem::size_of_val(&storage) as zts_socklen_t;
+
+        unsafe {
+            let n = zts_bsd_recvfrom(
+                self.0,
+                buf.as_mut_ptr() as *mut c_void,
+                buf.len().try_into().unwrap(),
+                flags,
+                &mut storage as *mut _ as *mut _,
+                &mut addrlen,
+            );
+            Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize)?))
+        }
+    }
+
+    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.recv_from_with_flags(buf, 0)
+    }
+
+    pub fn recv_msg(&self, msg: &mut zts_msghdr) -> io::Result<usize> {
+        unsafe {
+            let n = zts_bsd_recvmsg(self.0, msg, 0 /*ZTS_MSG_CMSG_CLOEXEC*/);
+            Ok(n as usize)
+        }
+    }
+
+    pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.recv_from_with_flags(buf, ZTS_MSG_PEEK as i32)
+    }
+
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        unsafe {
+            let raw = zts_bsd_write(
+                self.0,
+                buf.as_ptr() as *const c_void,
+                buf.len().try_into().unwrap(),
+            );
+            if raw >= 0 {
+                Ok(raw.try_into().unwrap())
+            } else {
+                Err(io::Error::from_raw_os_error(raw as i32))
+            }
+        }
+    }
+    /*
+        pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+            self.0.write_vectored(bufs)
+        }
+    */
+    #[inline]
+    pub fn is_write_vectored(&self) -> bool {
+        // TODO: In principle this is possible but is not hooked up yet
+        return false;
+    }
+
+    pub fn send_msg(&self, msg: &mut zts_msghdr) -> io::Result<usize> {
+        unsafe {
+            let n = zts_bsd_sendmsg(self.0, msg, 0);
+            Ok(n as usize)
+        }
+    }
+
+    pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()> {
+        let timeout = match dur {
+            Some(dur) => {
+                if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
+                    // TODO: Use new_const to avoid allocations
+                    return Err(Error::new(
+                        ErrorKind::InvalidInput,
+                        "Cannot set a 0 duration timeout",
+                    ));
+                }
+
+                let secs = if dur.as_secs() > time_t::MAX as u64 {
+                    time_t::MAX
+                } else {
+                    dur.as_secs() as time_t
+                };
+                let mut timeout = zts_timeval {
+                    tv_sec: secs,
+                    tv_usec: dur.subsec_micros() as std::os::raw::c_long,
+                };
+                if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
+                    timeout.tv_usec = 1;
+                }
+                timeout
+            }
+            None => zts_timeval {
+                tv_sec: 0,
+                tv_usec: 0,
+            },
+        };
+        setsockopt(self, ZTS_SOL_SOCKET as i32, kind, timeout)
+    }
+
+    pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
+        let raw: zts_timeval = getsockopt(self, ZTS_SOL_SOCKET as i32, kind)?;
+        if raw.tv_sec == 0 && raw.tv_usec == 0 {
+            Ok(None)
+        } else {
+            let sec = raw.tv_sec as u64;
+            let nsec = (raw.tv_usec as u32) * 1000;
+            Ok(Some(Duration::new(sec, nsec)))
+        }
+    }
+
+    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+        let how = match how {
+            Shutdown::Write => ZTS_SHUT_WR as i32,
+            Shutdown::Read => ZTS_SHUT_RD as i32,
+            Shutdown::Both => ZTS_SHUT_RDWR as i32,
+        };
+        unsafe {
+            let raw: c_int = zts_bsd_shutdown(self.0, how);
+            if raw == 0 {
+                Ok(())
+            } else {
+                Err(io::Error::from_raw_os_error(raw as i32))
+            }
+        }
+    }
+
+    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
+        let nodelay = nodelay as c_int;
+        unsafe {
+            let raw: c_int = zts_set_no_delay(self.0, nodelay);
+            if raw == 0 {
+                Ok(())
+            } else {
+                Err(io::Error::from_raw_os_error(raw as i32))
+            }
+        }
+    }
+
+    pub fn nodelay(&self) -> io::Result<bool> {
+        unsafe {
+            let raw: c_int = zts_get_no_delay(self.0);
+            Ok(raw != 0)
+        }
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        let nonblocking = nonblocking as c_int;
+        unsafe {
+            let raw: c_int = zts_set_blocking(self.0, !nonblocking);
+            if raw == 0 {
+                Ok(())
+            } else {
+                Err(io::Error::from_raw_os_error(raw as i32))
+            }
+        }
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        unsafe {
+            let raw: c_int = zts_get_last_socket_error(self.0);
+            if raw == 0 {
+                Ok(None)
+            } else {
+                Err(io::Error::from_raw_os_error(raw as i32))
+            }
+        }
+    }
+}