Implement IPv4 address configuration on Linux

This involved refactoring the crate structure to share code between
macOS and Linux. The new methods have not yet been implemented on
macOS, but they have todo!() placeholders.

tun/src/unix/apple/kern_control.rs

@@ -0,0 +1,43 @@
+use fehler::throws;
+use std::io::Error;
+use std::mem::size_of;
+use std::os::unix::io::AsRawFd;
+
+use super::sys;
+
+/// Trait to connect to kernel extensions on Apple platforms
+///
+/// Pulled from XNU source: https://github.com/apple/darwin-xnu/blob/main/bsd/sys/kern_control.h
+pub trait SysControlSocket {
+    #[throws]
+    fn resolve(&self, name: &str, index: u32) -> socket2::SockAddr;
+}
+
+impl SysControlSocket for socket2::Socket {
+    #[throws]
+    fn resolve(&self, name: &str, index: u32) -> socket2::SockAddr {
+        let mut info = sys::ctl_info {
+            ctl_id: 0,
+            ctl_name: [0; 96],
+        };
+        info.ctl_name[..name.len()].copy_from_slice(name.as_bytes());
+
+        unsafe { sys::resolve_ctl_info(self.as_raw_fd(), &mut info as *mut sys::ctl_info)? };
+
+        let (_, addr) = unsafe {
+            socket2::SockAddr::init(|addr_storage, len| {
+                *len = size_of::<sys::sockaddr_ctl>() as u32;
+
+                let mut addr: &mut sys::sockaddr_ctl = &mut *addr_storage.cast();
+                addr.sc_len = *len as u8;
+                addr.sc_family = sys::AF_SYSTEM as u8;
+                addr.ss_sysaddr = sys::AF_SYS_CONTROL as u16;
+                addr.sc_id = info.ctl_id;
+                addr.sc_unit = index;
+                Ok(())
+            })
+        }?;
+
+        addr
+    }
+}

tun/src/unix/apple/mod.rs

@@ -0,0 +1,76 @@
+use fehler::throws;
+use libc::c_char;
+use std::net::Ipv4Addr;
+use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+use std::io::Error;
+
+mod sys;
+mod kern_control;
+
+pub use super::queue::TunQueue;
+
+use super::ifname_to_string;
+use kern_control::SysControlSocket;
+
+#[derive(Debug)]
+pub struct TunInterface {
+    pub(crate) socket: socket2::Socket,
+}
+
+impl TunInterface {
+    #[throws]
+    pub fn new() -> TunInterface {
+        TunInterface::connect(0)?
+    }
+
+    #[throws]
+    fn connect(index: u32) -> TunInterface {
+        use socket2::{Domain, Protocol, Socket, Type};
+
+        let socket = Socket::new(
+            Domain::from(sys::AF_SYSTEM),
+            Type::DGRAM,
+            Some(Protocol::from(sys::SYSPROTO_CONTROL)),
+        )?;
+        let addr = socket.resolve(sys::UTUN_CONTROL_NAME, index)?;
+        socket.connect(&addr)?;
+
+        TunInterface { socket }
+    }
+
+    #[throws]
+    pub fn name(&self) -> String {
+        let mut buf = [0 as c_char; sys::IFNAMSIZ];
+        let mut len = buf.len() as sys::socklen_t;
+        sys::syscall!(getsockopt(
+            self.as_raw_fd(),
+            sys::SYSPROTO_CONTROL,
+            sys::UTUN_OPT_IFNAME,
+            buf.as_mut_ptr() as *mut sys::c_void,
+            &mut len,
+        ))?;
+        ifname_to_string(buf)
+    }
+
+    #[throws]
+    pub fn set_ipv4_addr(&self, _addr: Ipv4Addr) {
+        todo!()
+    }
+
+    #[throws]
+    pub fn ipv4_addr(&self) -> Ipv4Addr {
+        todo!()
+    }
+}
+
+impl AsRawFd for TunInterface {
+    fn as_raw_fd(&self) -> RawFd {
+        self.socket.as_raw_fd()
+    }
+}
+
+impl IntoRawFd for TunInterface {
+    fn into_raw_fd(self) -> RawFd {
+        self.socket.into_raw_fd()
+    }
+}

tun/src/unix/apple/sys.rs

@@ -0,0 +1,35 @@
+pub use libc::{c_void, socklen_t, SYSPROTO_CONTROL, IFNAMSIZ, sockaddr_ctl, AF_SYSTEM, AF_SYS_CONTROL};
+use nix::ioctl_readwrite;
+
+pub const UTUN_CONTROL_NAME: &str = "com.apple.net.utun_control";
+pub const UTUN_OPT_IFNAME: libc::c_int = 2;
+
+pub const MAX_KCTL_NAME: usize = 96;
+
+    #[repr(C)]
+pub struct ctl_info {
+    pub ctl_id: u32,
+    pub ctl_name: [u8; MAX_KCTL_NAME],
+}
+
+#[repr(C)]
+pub struct ifreq {}
+
+ioctl_readwrite!(resolve_ctl_info, b'N', 3, ctl_info);
+
+/// Copied from https://github.com/rust-lang/socket2/blob/61314a231f73964b3db969ef72c0e9479df320f3/src/sys/unix.rs#L168-L178
+/// getsockopt is not exposed by socket2
+#[macro_export]
+macro_rules! syscall {
+    ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{
+        #[allow(unused_unsafe)]
+        let res = unsafe { libc::$fn($($arg, )*) };
+        if res == -1 {
+            Err(std::io::Error::last_os_error())
+        } else {
+            Ok(res)
+        }
+    }};
+}
+
+pub use syscall;