Add Rust bindings (WIP)

pkg/crate/libzt/src/lib.rs

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+/****/
+
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+include!(concat!("./libzt.rs"));
+
+pub mod node;
+pub mod socket;
+pub mod tcp;
+pub mod udp;
+pub mod utils;

pkg/crate/libzt/src/node.rs

@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+/****/
+
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+include!(concat!("./libzt.rs"));
+
+use std::ffi::{c_void, CStr, CString};
+
+extern "C" fn native_event_handler(msg: *mut c_void) {
+    let event: &mut zts_event_msg_t = unsafe { &mut *(msg as *mut zts_event_msg_t) };
+    println!("event: {}", event.event_code);
+    //user_event_handler(event.event_code);
+}
+
+pub struct ZeroTierNode {
+    // TODO
+}
+
+impl ZeroTierNode {
+    pub fn init_set_event_handler(&self, user_event_handler: impl Fn(i16) -> ()) -> i32 {
+        unsafe {
+            return zts_init_set_event_handler(Some(native_event_handler));
+        }
+    }
+
+    pub fn init_set_port(&self, port: u16) -> i32 {
+        unsafe {
+            return zts_init_set_port(port);
+        }
+    }
+
+    pub fn init_from_storage(&self, storage_path: &str) -> i32 {
+        unsafe {
+            // This is a false-positive by the linter
+            // See: https://github.com/rust-lang/rust/issues/78691
+            #[allow(temporary_cstring_as_ptr)]
+            return zts_init_from_storage(CString::new(storage_path).unwrap().as_ptr());
+        }
+    }
+
+    pub fn start(&self) -> i32 {
+        unsafe {
+            return zts_node_start();
+        }
+    }
+
+    pub fn stop(&self) -> i32 {
+        unsafe {
+            return zts_node_stop();
+        }
+    }
+
+    pub fn free(&self) -> i32 {
+        unsafe {
+            return zts_node_free();
+        }
+    }
+
+    pub fn net_join(&self, net_id: u64) -> i32 {
+        unsafe {
+            return zts_net_join(net_id);
+        }
+    }
+
+    pub fn net_leave(&self, net_id: u64) -> i32 {
+        unsafe {
+            return zts_net_leave(net_id);
+        }
+    }
+
+    pub fn net_transport_is_ready(&self, net_id: u64) -> bool {
+        unsafe {
+            return zts_net_transport_is_ready(net_id) == 1;
+        }
+    }
+
+    pub fn is_online(&self) -> bool {
+        unsafe {
+            return zts_node_is_online() == 1;
+        }
+    }
+
+    pub fn id(&self) -> u64 {
+        unsafe {
+            return zts_node_get_id();
+        }
+    }
+
+    pub fn delay(&self, interval_ms: u64) -> () {
+        unsafe { zts_util_delay(interval_ms) }
+    }
+
+    pub fn addr_get(&self, net_id: u64) -> String {
+        unsafe {
+            let mut v = vec![0; (ZTS_INET6_ADDRSTRLEN as usize) + 1];
+            let ptr = v.as_mut_ptr() as *mut i8;
+            zts_addr_get_str(net_id, ZTS_AF_INET, ptr, ZTS_INET6_ADDRSTRLEN);
+            let c_str = CStr::from_ptr(ptr);
+            return c_str.to_string_lossy().into_owned();
+        }
+    }
+}

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))
+            }
+        }
+    }
+}

pkg/crate/libzt/src/tcp.rs

@@ -0,0 +1,518 @@
+/*
+ * 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::ffi::{c_void, CString};
+use std::io;
+use std::io::{Read, Write};
+use std::net::{Shutdown, SocketAddr, ToSocketAddrs};
+use std::os::raw::c_int;
+use std::time::Duration;
+use std::{cmp, mem};
+
+use crate::socket::Socket;
+use crate::utils::*;
+
+//----------------------------------------------------------------------------//
+// TcpStream                                                                  //
+//----------------------------------------------------------------------------//
+
+pub struct TcpStreamImpl {
+    inner: Socket,
+}
+
+impl TcpStreamImpl {
+    pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStreamImpl> {
+        let addr = addr?;
+        let socket = Socket::new(addr, ZTS_SOCK_STREAM as i32)?;
+        //let (addrp, len) = addr.into_inner();
+        unsafe {
+            // TODO: Find a better way to split this address string
+            let full_str = addr.to_string();
+            let full_vec = full_str.split(":");
+            let lvec: Vec<&str> = full_vec.collect();
+            let addr_str = lvec[0];
+            let port = addr.port();
+            let timeout_ms = 0;
+            // TODO: Handle native error code, consider cvt?
+            // This is a false-positive by the linter
+            // See: https://github.com/rust-lang/rust/issues/78691
+            #[allow(temporary_cstring_as_ptr)]
+            zts_connect(
+                *socket.as_inner(),
+                CString::new(addr_str).unwrap().as_ptr(),
+                port,
+                timeout_ms,
+            );
+        }
+        Ok(TcpStreamImpl { inner: socket })
+    }
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        let len = cmp::min(buf.len(), <size_t>::MAX as usize) as size_t;
+        // TODO: Handle native error code, consider cvt?
+        let ret =
+            unsafe { zts_bsd_write(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len) };
+        Ok(ret as usize)
+    }
+    /*
+        pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
+            init();
+
+            let sock = Socket::new(addr, c::SOCK_STREAM)?;
+            sock.connect_timeout(addr, timeout)?;
+            Ok(TcpStream { inner: sock })
+        }
+    */
+    pub fn socket(&self) -> &Socket {
+        &self.inner
+    }
+
+    pub fn into_socket(self) -> Socket {
+        self.inner
+    }
+
+    pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.inner.set_timeout(dur, ZTS_SO_RCVTIMEO as i32)
+    }
+
+    pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.inner.set_timeout(dur, ZTS_SO_SNDTIMEO as i32)
+    }
+
+    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+        self.inner.timeout(ZTS_SO_RCVTIMEO as i32)
+    }
+
+    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+        self.inner.timeout(ZTS_SO_SNDTIMEO as i32)
+    }
+
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.peek(buf)
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
+    /*
+        pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+            self.inner.read_vectored(bufs)
+        }
+
+        #[inline]
+        pub fn is_read_vectored(&self) -> bool {
+            self.inner.is_read_vectored()
+        }
+
+        pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+            let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
+            let ret = cvt(unsafe {
+                zts_bsd_send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, ZTS_MSG_NOSIGNAL)
+            })?;
+            Ok(ret as usize)
+        }
+
+        pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+            self.inner.write_vectored(bufs)
+        }
+
+        #[inline]
+        pub fn is_write_vectored(&self) -> bool {
+            self.inner.is_write_vectored()
+        }
+    */
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        sockname(|buf, len| unsafe { zts_bsd_getpeername(*self.inner.as_inner(), buf, len) })
+    }
+
+    pub fn socket_addr(&self) -> io::Result<SocketAddr> {
+        sockname(|buf, len| unsafe { zts_bsd_getsockname(*self.inner.as_inner(), buf, len) })
+    }
+
+    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+        self.inner.shutdown(how)
+    }
+
+    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
+        self.inner.set_nodelay(nodelay)
+    }
+
+    pub fn nodelay(&self) -> io::Result<bool> {
+        self.inner.nodelay()
+    }
+
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        setsockopt(
+            &self.inner,
+            ZTS_IPPROTO_IP as i32,
+            ZTS_IP_TTL as i32,
+            ttl as c_int,
+        )
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, ZTS_IPPROTO_IP as i32, ZTS_IP_TTL as i32)?;
+        Ok(raw as u32)
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.inner.take_error()
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.inner.set_nonblocking(nonblocking)
+    }
+}
+
+pub struct TcpStream(TcpStreamImpl);
+
+impl TcpStream {
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
+        each_addr(addr, TcpStreamImpl::connect).map(TcpStream)
+    }
+    /*
+        pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
+            TcpStreamImpl::connect_timeout(addr, timeout).map(TcpStream)
+        }
+    */
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.0.peer_addr()
+    }
+
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.0.socket_addr()
+    }
+
+    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+        self.0.shutdown(how)
+    }
+
+    pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.0.set_read_timeout(dur)
+    }
+
+    pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.0.set_write_timeout(dur)
+    }
+
+    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+        self.0.read_timeout()
+    }
+
+    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+        self.0.write_timeout()
+    }
+
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.peek(buf)
+    }
+
+    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
+        self.0.set_nodelay(nodelay)
+    }
+
+    pub fn nodelay(&self) -> io::Result<bool> {
+        self.0.nodelay()
+    }
+
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        self.0.set_ttl(ttl)
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        self.0.ttl()
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.0.take_error()
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.0.set_nonblocking(nonblocking)
+    }
+}
+
+impl Read for TcpStream {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+    /*
+        fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+            self.0.read_vectored(bufs)
+        }
+
+        #[inline]
+        fn is_read_vectored(&self) -> bool {
+            self.0.is_read_vectored()
+        }
+
+        #[inline]
+        unsafe fn initializer(&self) -> Initializer {
+            // SAFETY: Read is guaranteed to work on uninitialized memory
+            unsafe { Initializer::nop() }
+        }
+    */
+}
+
+impl Write for TcpStream {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+    /*
+        fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+            self.0.write_vectored(bufs)
+        }
+
+        #[inline]
+        fn is_write_vectored(&self) -> bool {
+            self.0.is_write_vectored()
+        }
+    */
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Read for &TcpStream {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.read(buf)
+    }
+    /*
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        self.0.read_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        self.0.is_read_vectored()
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        // SAFETY: Read is guaranteed to work on uninitialized memory
+        unsafe { Initializer::nop() }
+    }
+    */
+}
+
+impl Write for &TcpStream {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+    /*
+        fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+            self.0.write_vectored(bufs)
+        }
+
+        #[inline]
+        fn is_write_vectored(&self) -> bool {
+            self.0.is_write_vectored()
+        }
+    */
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl AsInner<TcpStreamImpl> for TcpStream {
+    fn as_inner(&self) -> &TcpStreamImpl {
+        &self.0
+    }
+}
+
+impl FromInner<TcpStreamImpl> for TcpStream {
+    fn from_inner(inner: TcpStreamImpl) -> TcpStream {
+        TcpStream(inner)
+    }
+}
+
+impl IntoInner<TcpStreamImpl> for TcpStream {
+    fn into_inner(self) -> TcpStreamImpl {
+        self.0
+    }
+}
+/*
+impl fmt::Debug for TcpStream {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+*/
+
+//----------------------------------------------------------------------------//
+// TcpListener                                                                //
+//----------------------------------------------------------------------------//
+
+pub struct TcpListenerImpl {
+    inner: Socket,
+}
+
+impl TcpListenerImpl {
+    pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<TcpListenerImpl> {
+        let addr = addr?;
+        let socket = Socket::new(addr, ZTS_SOCK_STREAM as i32)?;
+        // TODO: Possibly set SO_REUSEADDR
+        //let (addrp, len) = addr.into_inner();
+        unsafe {
+            //zts_bsd_bind(*socket.as_inner(), addrp, len as _);
+            // TODO: Find a better way to split this address string
+            let full_str = addr.to_string();
+            let full_vec = full_str.split(":");
+            let lvec: Vec<&str> = full_vec.collect();
+            let addr_str = lvec[0];
+            let port = addr.port();
+            // TODO: Handle native error code, consider cvt?
+            // This is a false-positive by the linter
+            // See: https://github.com/rust-lang/rust/issues/78691
+            #[allow(temporary_cstring_as_ptr)]
+            zts_bind(
+                *socket.as_inner(),
+                CString::new(addr_str).unwrap().as_ptr(),
+                port,
+            );
+            // TODO: Handle native error code, consider cvt?
+            zts_bsd_listen(*socket.as_inner(), 128);
+        }
+        Ok(TcpListenerImpl { inner: socket })
+    }
+
+    pub fn accept(&self) -> io::Result<(TcpStreamImpl, SocketAddr)> {
+        let mut storage: zts_sockaddr_storage = unsafe { mem::zeroed() };
+        let mut len = mem::size_of_val(&storage) as zts_socklen_t;
+        // TODO: Handle native error code, consider cvt?
+        let socket = self
+            .inner
+            .accept(&mut storage as *mut _ as *mut _, &mut len)?;
+        let addr = sockaddr_to_addr(&storage, len as usize)?;
+        Ok((TcpStreamImpl { inner: socket }, addr))
+    }
+
+    pub fn socket(&self) -> &Socket {
+        &self.inner
+    }
+
+    pub fn into_socket(self) -> Socket {
+        self.inner
+    }
+
+    pub fn socket_addr(&self) -> io::Result<SocketAddr> {
+        sockname(|buf, len| unsafe { zts_bsd_getsockname(*self.inner.as_inner(), buf, len) })
+    }
+
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        setsockopt(
+            &self.inner,
+            ZTS_IPPROTO_IP as i32,
+            ZTS_IP_TTL as i32,
+            ttl as c_int,
+        )
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, ZTS_IPPROTO_IP as i32, ZTS_IP_TTL as i32)?;
+        Ok(raw as u32)
+    }
+
+    pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
+        setsockopt(
+            &self.inner,
+            ZTS_IPPROTO_IPV6 as i32,
+            ZTS_IPV6_V6ONLY as i32,
+            only_v6 as c_int,
+        )
+    }
+
+    pub fn only_v6(&self) -> io::Result<bool> {
+        let raw: c_int = getsockopt(&self.inner, ZTS_IPPROTO_IPV6 as i32, ZTS_IPV6_V6ONLY as i32)?;
+        Ok(raw != 0)
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.inner.take_error()
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.inner.set_nonblocking(nonblocking)
+    }
+}
+
+pub struct TcpListener(TcpListenerImpl);
+
+pub struct Incoming<'a> {
+    listener: &'a TcpListener,
+}
+
+impl<'a> Iterator for Incoming<'a> {
+    type Item = io::Result<TcpStream>;
+    fn next(&mut self) -> Option<io::Result<TcpStream>> {
+        Some(self.listener.accept().map(|p| p.0))
+    }
+}
+
+impl TcpListener {
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
+        each_addr(addr, TcpListenerImpl::bind).map(TcpListener)
+    }
+
+    pub fn incoming(&self) -> Incoming<'_> {
+        Incoming { listener: self }
+    }
+
+    pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
+        self.0.accept().map(|(a, b)| (TcpStream(a), b))
+    }
+
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.0.socket_addr()
+    }
+
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        self.0.set_ttl(ttl)
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        self.0.ttl()
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.0.take_error()
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.0.set_nonblocking(nonblocking)
+    }
+}
+
+impl AsInner<TcpListenerImpl> for TcpListener {
+    fn as_inner(&self) -> &TcpListenerImpl {
+        &self.0
+    }
+}
+
+impl FromInner<TcpListenerImpl> for TcpListener {
+    fn from_inner(inner: TcpListenerImpl) -> TcpListener {
+        TcpListener(inner)
+    }
+}
+
+impl IntoInner<TcpListenerImpl> for TcpListener {
+    fn into_inner(self) -> TcpListenerImpl {
+        self.0
+    }
+}
+/*
+impl fmt::Debug for TcpListener {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+*/

pkg/crate/libzt/src/udp.rs

@@ -0,0 +1,459 @@
+/*
+ * 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, CString};
+use std::io::{self, Error, ErrorKind};
+use std::net::{/*Ipv4Addr, Ipv6Addr,*/ SocketAddr, ToSocketAddrs};
+use std::os::raw::c_int;
+use std::time::Duration;
+//use std::cmp;
+
+use crate::socket::Socket;
+use crate::utils::*;
+
+//----------------------------------------------------------------------------//
+// UdpSocketImpl                                                              //
+//----------------------------------------------------------------------------//
+
+pub struct UdpSocketImpl {
+    inner: Socket,
+}
+
+impl UdpSocketImpl {
+    pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<UdpSocketImpl> {
+        let addr = addr?;
+        let socket = Socket::new(addr, ZTS_SOCK_DGRAM as i32)?;
+        // TODO: Possibly set SO_REUSEADDR
+        //let (addrp, len) = addr.into_inner();
+        unsafe {
+            //zts_bsd_bind(*socket.as_inner(), addrp, len as _);
+            // TODO: Find a better way to split this address string
+            let full_str = addr.to_string();
+            let full_vec = full_str.split(":");
+            let lvec: Vec<&str> = full_vec.collect();
+            let addr_str = lvec[0];
+            let port = addr.port();
+            // TODO: Handle native error code, consider cvt?
+            // This is a false-positive by the linter
+            // See: https://github.com/rust-lang/rust/issues/78691
+            #[allow(temporary_cstring_as_ptr)]
+            zts_bind(
+                *socket.as_inner(),
+                CString::new(addr_str).unwrap().as_ptr(),
+                port,
+            );
+        }
+        Ok(UdpSocketImpl { inner: socket })
+    }
+
+    pub fn socket(&self) -> &Socket {
+        &self.inner
+    }
+
+    pub fn into_socket(self) -> Socket {
+        self.inner
+    }
+
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        sockname(|buf, len| unsafe { zts_bsd_getpeername(*self.inner.as_inner(), buf, len) })
+    }
+
+    pub fn socket_addr(&self) -> io::Result<SocketAddr> {
+        sockname(|buf, len| unsafe { zts_bsd_getsockname(*self.inner.as_inner(), buf, len) })
+    }
+
+    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.inner.recv_from(buf)
+    }
+
+    pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.inner.peek_from(buf)
+    }
+
+    pub fn send_to(&self, buf: &[u8], dst: &SocketAddr) -> io::Result<usize> {
+        /*
+                let len = cmp::min(buf.len(), <size_t>::MAX as usize) as size_t;
+                let (dstp, dstlen) = dst.into_inner();
+                let ret = cvt(unsafe {
+                    zts_bsd_sendto(
+                        *self.inner.as_inner(),
+                        buf.as_ptr() as *const c_void,
+                        len,
+                        ZTS_MSG_NOSIGNAL,
+                        dstp,
+                        dstlen,
+                    )
+                })?;
+                Ok(ret as usize)
+        */
+        Ok(0)
+    }
+
+    pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.inner.set_timeout(dur, ZTS_SO_RCVTIMEO as i32)
+    }
+
+    pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.inner.set_timeout(dur, ZTS_SO_SNDTIMEO as i32)
+    }
+
+    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+        self.inner.timeout(ZTS_SO_RCVTIMEO as i32)
+    }
+
+    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+        self.inner.timeout(ZTS_SO_SNDTIMEO as i32)
+    }
+
+    pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
+        setsockopt(
+            &self.inner,
+            ZTS_SOL_SOCKET as i32,
+            ZTS_SO_BROADCAST as i32,
+            broadcast as c_int,
+        )
+    }
+
+    pub fn broadcast(&self) -> io::Result<bool> {
+        let raw: c_int = getsockopt(&self.inner, ZTS_SOL_SOCKET as i32, ZTS_SO_BROADCAST as i32)?;
+        Ok(raw != 0)
+    }
+    /*
+        pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
+            setsockopt(
+                &self.inner,
+                ZTS_IPPROTO_IP,
+                ZTS_IP_MULTICAST_LOOP,
+                multicast_loop_v4 as IpV4MultiCastType,
+            )
+        }
+
+        pub fn multicast_loop_v4(&self) -> io::Result<bool> {
+            let raw: IpV4MultiCastType = getsockopt(&self.inner, ZTS_IPPROTO_IP, ZTS_IP_MULTICAST_LOOP)?;
+            Ok(raw != 0)
+        }
+
+        pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
+            setsockopt(
+                &self.inner,
+                ZTS_IPPROTO_IP,
+                ZTS_IP_MULTICAST_TTL,
+                multicast_ttl_v4 as IpV4MultiCastType,
+            )
+        }
+
+        pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
+            let raw: IpV4MultiCastType = getsockopt(&self.inner, ZTS_IPPROTO_IP, ZTS_IP_MULTICAST_TTL)?;
+            Ok(raw as u32)
+        }
+
+        pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
+            setsockopt(&self.inner, ZTS_IPPROTO_IPV6, ZTS_IPV6_MULTICAST_LOOP, multicast_loop_v6 as c_int)
+        }
+
+        pub fn multicast_loop_v6(&self) -> io::Result<bool> {
+            let raw: c_int = getsockopt(&self.inner, ZTS_IPPROTO_IPV6, ZTS_IPV6_MULTICAST_LOOP)?;
+            Ok(raw != 0)
+        }
+
+        pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
+            let mreq = zts_ip_mreq {
+                imr_multiaddr: multiaddr.into_inner(),
+                imr_interface: interface.into_inner(),
+            };
+            setsockopt(&self.inner, ZTS_IPPROTO_IP, ZTS_IP_ADD_MEMBERSHIP, mreq)
+        }
+
+        pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
+            let mreq = zts_ipv6_mreq {
+                ipv6mr_multiaddr: *multiaddr.as_inner(),
+                ipv6mr_interface: to_ipv6mr_interface(interface),
+            };
+            setsockopt(&self.inner, ZTS_IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq)
+        }
+
+        pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
+            let mreq = zts_ip_mreq {
+                imr_multiaddr: multiaddr.into_inner(),
+                imr_interface: interface.into_inner(),
+            };
+            setsockopt(&self.inner, ZTS_IPPROTO_IP, ZTS_IP_DROP_MEMBERSHIP, mreq)
+        }
+
+        pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
+            let mreq = zts_ipv6_mreq {
+                ipv6mr_multiaddr: *multiaddr.as_inner(),
+                ipv6mr_interface: to_ipv6mr_interface(interface),
+            };
+            setsockopt(&self.inner, ZTS_IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq)
+        }
+    */
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        setsockopt(
+            &self.inner,
+            ZTS_IPPROTO_IP as i32,
+            ZTS_IP_TTL as i32,
+            ttl as c_int,
+        )
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        let raw: c_int = getsockopt(&self.inner, ZTS_IPPROTO_IP as i32, ZTS_IP_TTL as i32)?;
+        Ok(raw as u32)
+    }
+
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.inner.take_error()
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.inner.set_nonblocking(nonblocking)
+    }
+
+    pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
+
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.peek(buf)
+    }
+
+    pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
+        /*
+        let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
+        let ret = cvt(unsafe {
+            zts_bsd_send(*self.inner.as_inner(), buf.as_ptr() as *const c_void, len, ZTS_MSG_NOSIGNAL)
+        })?;
+        Ok(ret as usize)
+        */
+        unsafe {
+            let raw = zts_bsd_write(
+                *self.inner.as_inner(),
+                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 connect(&self, addr: io::Result<&SocketAddr>) -> io::Result<()> {
+        let addr = addr?;
+        //let (addrp, len) = addr?.into_inner();
+        unsafe {
+            let full_str = addr.to_string();
+            let full_vec = full_str.split(":");
+            let lvec: Vec<&str> = full_vec.collect();
+            let addr_str = lvec[0];
+            let port = addr.port();
+            let timeout_ms = 0;
+            // TODO: Handle native error code, consider cvt?
+            // This is a false-positive by the linter
+            // See: https://github.com/rust-lang/rust/issues/78691
+            #[allow(temporary_cstring_as_ptr)]
+            cvt(zts_connect(
+                *self.inner.as_inner(),
+                CString::new(addr_str).unwrap().as_ptr(),
+                port,
+                timeout_ms,
+            ))?;
+        }
+
+        Ok(())
+    }
+}
+
+impl FromInner<Socket> for UdpSocketImpl {
+    fn from_inner(socket: Socket) -> UdpSocketImpl {
+        UdpSocketImpl { inner: socket }
+    }
+}
+
+/*
+impl fmt::Debug for UdpSocketImpl {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut res = f.debug_struct("UdpSocketImpl");
+
+        if let Ok(addr) = self.socket_addr() {
+            res.field("addr", &addr);
+        }
+
+        let name = if cfg!(windows) { "socket" } else { "fd" };
+        res.field(name, &self.inner.as_inner()).finish()
+    }
+}
+*/
+
+//----------------------------------------------------------------------------//
+// UdpSocket                                                                  //
+//----------------------------------------------------------------------------//
+
+pub struct UdpSocket(UdpSocketImpl);
+
+impl UdpSocket {
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
+        each_addr(addr, UdpSocketImpl::bind).map(UdpSocket)
+    }
+
+    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.0.recv_from(buf)
+    }
+
+    pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.0.peek_from(buf)
+    }
+
+    pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> io::Result<usize> {
+        match addr.to_socket_addrs()?.next() {
+            Some(addr) => self.0.send_to(buf, &addr),
+            None => Err(Error::new(
+                ErrorKind::InvalidInput,
+                "No address to send data to",
+            )),
+        }
+    }
+
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.0.peer_addr()
+    }
+
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.0.socket_addr()
+    }
+
+    pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.0.set_read_timeout(dur)
+    }
+
+    pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
+        self.0.set_write_timeout(dur)
+    }
+
+    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+        self.0.read_timeout()
+    }
+
+    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+        self.0.write_timeout()
+    }
+
+    pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
+        self.0.set_broadcast(broadcast)
+    }
+
+    pub fn broadcast(&self) -> io::Result<bool> {
+        self.0.broadcast()
+    }
+    /*
+        pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
+            self.0.set_multicast_loop_v4(multicast_loop_v4)
+        }
+
+        pub fn multicast_loop_v4(&self) -> io::Result<bool> {
+            self.0.multicast_loop_v4()
+        }
+
+        pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
+            self.0.set_multicast_ttl_v4(multicast_ttl_v4)
+        }
+
+        pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
+            self.0.multicast_ttl_v4()
+        }
+
+        pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
+            self.0.set_multicast_loop_v6(multicast_loop_v6)
+        }
+
+        pub fn multicast_loop_v6(&self) -> io::Result<bool> {
+            self.0.multicast_loop_v6()
+        }
+    */
+    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
+        self.0.set_ttl(ttl)
+    }
+
+    pub fn ttl(&self) -> io::Result<u32> {
+        self.0.ttl()
+    }
+    /*
+        pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
+            self.0.join_multicast_v4(multiaddr, interface)
+        }
+
+        pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
+            self.0.join_multicast_v6(multiaddr, interface)
+        }
+
+        pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
+            self.0.leave_multicast_v4(multiaddr, interface)
+        }
+
+        pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
+            self.0.leave_multicast_v6(multiaddr, interface)
+        }
+    */
+    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+        self.0.take_error()
+    }
+
+    pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
+        each_addr(addr, |addr| self.0.connect(addr))
+    }
+
+    pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
+        self.0.send(buf)
+    }
+
+    pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.recv(buf)
+    }
+
+    pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+        self.0.peek(buf)
+    }
+
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        self.0.set_nonblocking(nonblocking)
+    }
+}
+
+impl AsInner<UdpSocketImpl> for UdpSocket {
+    fn as_inner(&self) -> &UdpSocketImpl {
+        &self.0
+    }
+}
+
+impl FromInner<UdpSocketImpl> for UdpSocket {
+    fn from_inner(inner: UdpSocketImpl) -> UdpSocket {
+        UdpSocket(inner)
+    }
+}
+
+impl IntoInner<UdpSocketImpl> for UdpSocket {
+    fn into_inner(self) -> UdpSocketImpl {
+        self.0
+    }
+}
+
+/*
+impl fmt::Debug for UdpSocket {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+*/

pkg/crate/libzt/src/utils.rs

@@ -0,0 +1,213 @@
+/*
+ * 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.
+ */
+/****/
+
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+include!(concat!("./libzt.rs"));
+
+use std::ffi::c_void;
+use std::io::{Error, ErrorKind};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
+use std::os::raw::c_int;
+use std::{io, mem};
+
+use crate::socket::Socket;
+
+//----------------------------------------------------------------------------//
+// Utilities                                                                  //
+//----------------------------------------------------------------------------//
+
+/*
+
+The following utility functions were lifted directly from the Rust standard
+library and tweaked to accommodate ZeroTier sockets. See their original
+implementations here:
+
+    - https://doc.rust-lang.org/src/std/net/tcp.rs.html#95-97
+    - https://github.com/rust-lang/rust/blob/master/library/std/src/sys_common/net.rs
+    - https://github.com/rust-lang/rust/blob/db492ecd5ba6bd82205612cebb9034710653f0c2/library/std/src/net/mod.rs
+*/
+
+pub trait IsMinusOne {
+    fn is_minus_one(&self) -> bool;
+}
+
+macro_rules! impl_is_minus_one {
+    ($($t:ident)*) => ($(impl IsMinusOne for $t {
+        fn is_minus_one(&self) -> bool {
+            *self == -1
+        }
+    })*)
+}
+
+impl_is_minus_one! { i8 i16 i32 i64 isize }
+
+pub fn cvt<T: IsMinusOne>(t: T) -> std::io::Result<T> {
+    if t.is_minus_one() {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(t)
+    }
+}
+
+pub fn cvt_r<T, F>(mut f: F) -> std::io::Result<T>
+where
+    T: IsMinusOne,
+    F: FnMut() -> T,
+{
+    loop {
+        match cvt(f()) {
+            Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+            other => return other,
+        }
+    }
+}
+
+pub fn setsockopt<T>(sock: &Socket, opt: c_int, val: c_int, payload: T) -> io::Result<()> {
+    unsafe {
+        let payload = &payload as *const T as *const c_void;
+        cvt(zts_bsd_setsockopt(
+            *sock.as_inner(),
+            opt,
+            val,
+            payload,
+            mem::size_of::<T>() as zts_socklen_t,
+        ))?;
+        Ok(())
+    }
+}
+
+pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int, val: c_int) -> io::Result<T> {
+    unsafe {
+        let mut slot: T = mem::zeroed();
+        let mut len = mem::size_of::<T>() as zts_socklen_t;
+        cvt(zts_bsd_getsockopt(
+            *sock.as_inner(),
+            opt,
+            val,
+            &mut slot as *mut _ as *mut _,
+            &mut len,
+        ))?;
+        Ok(slot)
+    }
+}
+
+pub trait AsInner<Inner: ?Sized> {
+    fn as_inner(&self) -> &Inner;
+}
+
+pub trait AsInnerMut<Inner: ?Sized> {
+    fn as_inner_mut(&mut self) -> &mut Inner;
+}
+
+pub trait IntoInner<Inner> {
+    fn into_inner(self) -> Inner;
+}
+
+pub trait FromInner<Inner> {
+    fn from_inner(inner: Inner) -> Self;
+}
+
+pub fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T>
+where
+    F: FnMut(io::Result<&SocketAddr>) -> io::Result<T>,
+{
+    let addrs = match addr.to_socket_addrs() {
+        Ok(addrs) => addrs,
+        Err(e) => return f(Err(e)),
+    };
+    let mut last_err = None;
+    for addr in addrs {
+        match f(Ok(&addr)) {
+            Ok(l) => return Ok(l),
+            Err(e) => last_err = Some(e),
+        }
+    }
+    // TODO: Should ideally use new_const as is used in std::net to avoid allocations
+    Err(last_err.unwrap_or_else(|| {
+        Error::new(
+            ErrorKind::InvalidInput,
+            "Could not resolve to any addresses",
+        )
+    }))
+}
+
+pub const fn ntohs(i: u16) -> u16 {
+    u16::from_be(i)
+}
+
+pub const fn htons(i: u16) -> u16 {
+    i.to_be()
+}
+
+pub fn ipv4_addr(addr: zts_in_addr) -> u32 {
+    (addr.s_addr as u32).to_be()
+}
+
+// Copied from: https://docs.rs/pnet_sys/0.28.0/src/pnet_sys/unix.rs.html#162-201
+pub fn sockaddr_to_addr(storage: &zts_sockaddr_storage, len: usize) -> io::Result<SocketAddr> {
+    // See: https://github.com/rust-lang/rust/issues/76191
+    match storage.ss_family as c_int {
+        // ZTS_AF_INET
+        0x2 => {
+            assert!(len as usize >= mem::size_of::<zts_sockaddr_in>());
+            let storage: &zts_sockaddr_in = unsafe { mem::transmute(storage) };
+            let ip = ipv4_addr(storage.sin_addr);
+            let a = (ip >> 24) as u8;
+            let b = (ip >> 16) as u8;
+            let c = (ip >> 8) as u8;
+            let d = ip as u8;
+            let sockaddrv4 = SocketAddrV4::new(Ipv4Addr::new(a, b, c, d), ntohs(storage.sin_port));
+            Ok(SocketAddr::V4(sockaddrv4))
+        }
+        // ZTS_AF_INET6
+        0xA => {
+            assert!(len as usize >= mem::size_of::<zts_sockaddr_in6>());
+            let storage: &zts_sockaddr_in6 = unsafe { mem::transmute(storage) };
+            let arr: [u16; 8] = unsafe { mem::transmute(storage.sin6_addr.un.u8_addr) };
+            let a = ntohs(arr[0]);
+            let b = ntohs(arr[1]);
+            let c = ntohs(arr[2]);
+            let d = ntohs(arr[3]);
+            let e = ntohs(arr[4]);
+            let f = ntohs(arr[5]);
+            let g = ntohs(arr[6]);
+            let h = ntohs(arr[7]);
+            let ip = Ipv6Addr::new(a, b, c, d, e, f, g, h);
+            Ok(SocketAddr::V6(SocketAddrV6::new(
+                ip,
+                ntohs(storage.sin6_port),
+                u32::from_be(storage.sin6_flowinfo),
+                storage.sin6_scope_id,
+            )))
+        }
+        _ => Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "expected IPv4 or IPv6 socket",
+        )),
+    }
+}
+
+pub fn sockname<F>(f: F) -> io::Result<SocketAddr>
+where
+    F: FnOnce(*mut zts_sockaddr, *mut zts_socklen_t) -> c_int,
+{
+    unsafe {
+        let mut storage: zts_sockaddr_storage = mem::zeroed();
+        let mut len = mem::size_of_val(&storage) as zts_socklen_t;
+        f(&mut storage as *mut _ as *mut _, &mut len);
+        sockaddr_to_addr(&storage, len as usize)
+    }
+}