修复linux无法运行的问题

2023-01-04 23:22:37 +08:00
parent d4f941d4e7
commit 0d83dcce9b
31 changed files with 3347 additions and 13 deletions
@@ -0,0 +1,149 @@
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//                    Version 2, December 2004
+//
+// Copyleft (ↄ) meh. <[email protected]> | http://meh.schizofreni.co
+//
+// Everyone is permitted to copy and distribute verbatim or modified
+// copies of this license document, and changing it is allowed as long
+// as the name is changed.
+//
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+//
+//  0. You just DO WHAT THE FUCK YOU WANT TO.
+
+use std::io;
+
+use byteorder::{NativeEndian, NetworkEndian, WriteBytesExt};
+use bytes::{BufMut, Bytes, BytesMut};
+use tokio_util::codec::{Decoder, Encoder};
+
+/// A packet protocol IP version
+#[derive(Debug)]
+enum PacketProtocol {
+    IPv4,
+    IPv6,
+    Other(u8),
+}
+
+// Note: the protocol in the packet information header is platform dependent.
+impl PacketProtocol {
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    fn into_pi_field(&self) -> Result<u16, io::Error> {
+        match self {
+            PacketProtocol::IPv4 => Ok(libc::ETH_P_IP as u16),
+            PacketProtocol::IPv6 => Ok(libc::ETH_P_IPV6 as u16),
+            PacketProtocol::Other(_) => Err(io::Error::new(
+                io::ErrorKind::Other,
+                "neither an IPv4 or IPv6 packet",
+            )),
+        }
+    }
+
+    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    fn into_pi_field(&self) -> Result<u16, io::Error> {
+        match self {
+            PacketProtocol::IPv4 => Ok(libc::PF_INET as u16),
+            PacketProtocol::IPv6 => Ok(libc::PF_INET6 as u16),
+            PacketProtocol::Other(_) => Err(io::Error::new(
+                io::ErrorKind::Other,
+                "neither an IPv4 or IPv6 packet",
+            )),
+        }
+    }
+}
+
+/// A Tun Packet to be sent or received on the TUN interface.
+#[derive(Debug)]
+pub struct TunPacket(PacketProtocol, Bytes);
+
+/// Infer the protocol based on the first nibble in the packet buffer.
+fn infer_proto(buf: &[u8]) -> PacketProtocol {
+    match buf[0] >> 4 {
+        4 => PacketProtocol::IPv4,
+        6 => PacketProtocol::IPv6,
+        p => PacketProtocol::Other(p),
+    }
+}
+
+impl TunPacket {
+    /// Create a new `TunPacket` based on a byte slice.
+    pub fn new(bytes: Vec<u8>) -> TunPacket {
+        let proto = infer_proto(&bytes);
+        TunPacket(proto, Bytes::from(bytes))
+    }
+
+    /// Return this packet's bytes.
+    pub fn get_bytes(&self) -> &[u8] {
+        &self.1
+    }
+
+    pub fn into_bytes(self) -> Bytes {
+        self.1
+    }
+}
+
+/// A TunPacket Encoder/Decoder.
+pub struct TunPacketCodec(bool, i32);
+
+impl TunPacketCodec {
+    /// Create a new `TunPacketCodec` specifying whether the underlying
+    ///  tunnel Device has enabled the packet information header.
+    pub fn new(pi: bool, mtu: i32) -> TunPacketCodec {
+        TunPacketCodec(pi, mtu)
+    }
+}
+
+impl Decoder for TunPacketCodec {
+    type Item = TunPacket;
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if buf.is_empty() {
+            return Ok(None);
+        }
+
+        let mut pkt = buf.split_to(buf.len());
+
+        // reserve enough space for the next packet
+        if self.0 {
+            buf.reserve(self.1 as usize + 4);
+        } else {
+            buf.reserve(self.1 as usize);
+        }
+
+        // if the packet information is enabled we have to ignore the first 4 bytes
+        if self.0 {
+            let _ = pkt.split_to(4);
+        }
+
+        let proto = infer_proto(pkt.as_ref());
+        Ok(Some(TunPacket(proto, pkt.freeze())))
+    }
+}
+
+impl Encoder<TunPacket> for TunPacketCodec {
+    type Error = io::Error;
+
+    fn encode(&mut self, item: TunPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        dst.reserve(item.get_bytes().len() + 4);
+        match item {
+            TunPacket(proto, bytes) if self.0 => {
+                // build the packet information header comprising of 2 u16
+                // fields: flags and protocol.
+                let mut buf = Vec::<u8>::with_capacity(4);
+
+                // flags is always 0
+                buf.write_u16::<NativeEndian>(0).unwrap();
+                // write the protocol as network byte order
+                buf.write_u16::<NetworkEndian>(proto.into_pi_field()?)
+                    .unwrap();
+
+                dst.put_slice(&buf);
+                dst.put(bytes);
+            }
+            TunPacket(_, bytes) => dst.put(bytes),
+        }
+        Ok(())
+    }
+}
@@ -0,0 +1,201 @@
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//                    Version 2, December 2004
+//
+// Copyleft (ↄ) meh. <[email protected]> | http://meh.schizofreni.co
+//
+// Everyone is permitted to copy and distribute verbatim or modified
+// copies of this license document, and changing it is allowed as long
+// as the name is changed.
+//
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+//
+//  0. You just DO WHAT THE FUCK YOU WANT TO.
+
+use std::io;
+use std::io::{IoSlice, Read, Write};
+
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use futures_core::ready;
+use tokio::io::unix::AsyncFd;
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_util::codec::Framed;
+
+use crate::device::Device as D;
+use crate::platform::{Device, Queue};
+use crate::r#async::codec::*;
+
+/// An async TUN device wrapper around a TUN device.
+pub struct AsyncDevice {
+    inner: AsyncFd<Device>,
+}
+
+impl AsyncDevice {
+    /// Create a new `AsyncDevice` wrapping around a `Device`.
+    pub fn new(device: Device) -> io::Result<AsyncDevice> {
+        device.set_nonblock()?;
+        Ok(AsyncDevice {
+            inner: AsyncFd::new(device)?,
+        })
+    }
+    /// Returns a shared reference to the underlying Device object
+    pub fn get_ref(&self) -> &Device {
+        self.inner.get_ref()
+    }
+
+    /// Returns a mutable reference to the underlying Device object
+    pub fn get_mut(&mut self) -> &mut Device {
+        self.inner.get_mut()
+    }
+
+    /// Consumes this AsyncDevice and return a Framed object (unified Stream and Sink interface)
+    pub fn into_framed(mut self) -> Framed<Self, TunPacketCodec> {
+        let pi = self.get_mut().has_packet_information();
+        let codec = TunPacketCodec::new(pi, self.inner.get_ref().mtu().unwrap_or(1504));
+        Framed::new(self, codec)
+    }
+}
+
+impl AsyncRead for AsyncDevice {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf,
+    ) -> Poll<io::Result<()>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_read_ready_mut(cx))?;
+            let rbuf = buf.initialize_unfilled();
+            match guard.try_io(|inner| inner.get_mut().read(rbuf)) {
+                Ok(res) => return Poll::Ready(res.map(|n| buf.advance(n))),
+                Err(_wb) => continue,
+            }
+        }
+    }
+}
+
+impl AsyncWrite for AsyncDevice {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?;
+            match guard.try_io(|inner| inner.get_mut().write(buf)) {
+                Ok(res) => return Poll::Ready(res),
+                Err(_wb) => continue,
+            }
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?;
+            match guard.try_io(|inner| inner.get_mut().flush()) {
+                Ok(res) => return Poll::Ready(res),
+                Err(_wb) => continue,
+            }
+        }
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?;
+            match guard.try_io(|inner| inner.get_mut().write_vectored(bufs)) {
+                Ok(res) => return Poll::Ready(res),
+                Err(_wb) => continue,
+            }
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+}
+
+/// An async TUN device queue wrapper around a TUN device queue.
+pub struct AsyncQueue {
+    inner: AsyncFd<Queue>,
+}
+
+impl AsyncQueue {
+    /// Create a new `AsyncQueue` wrapping around a `Queue`.
+    pub fn new(queue: Queue) -> io::Result<AsyncQueue> {
+        queue.set_nonblock()?;
+        Ok(AsyncQueue {
+            inner: AsyncFd::new(queue)?,
+        })
+    }
+    /// Returns a shared reference to the underlying Queue object
+    pub fn get_ref(&self) -> &Queue {
+        self.inner.get_ref()
+    }
+
+    /// Returns a mutable reference to the underlying Queue object
+    pub fn get_mut(&mut self) -> &mut Queue {
+        self.inner.get_mut()
+    }
+
+    /// Consumes this AsyncQueue and return a Framed object (unified Stream and Sink interface)
+    pub fn into_framed(mut self) -> Framed<Self, TunPacketCodec> {
+        let pi = self.get_mut().has_packet_information();
+        let codec = TunPacketCodec::new(pi, 1504);
+        Framed::new(self, codec)
+    }
+}
+
+impl AsyncRead for AsyncQueue {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf,
+    ) -> Poll<io::Result<()>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_read_ready_mut(cx))?;
+            let rbuf = buf.initialize_unfilled();
+            match guard.try_io(|inner| inner.get_mut().read(rbuf)) {
+                Ok(res) => return Poll::Ready(res.map(|n| buf.advance(n))),
+                Err(_wb) => continue,
+            }
+        }
+    }
+}
+
+impl AsyncWrite for AsyncQueue {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?;
+            match guard.try_io(|inner| inner.get_mut().write(buf)) {
+                Ok(res) => return Poll::Ready(res),
+                Err(_wb) => continue,
+            }
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        loop {
+            let mut guard = ready!(self.inner.poll_write_ready_mut(cx))?;
+            match guard.try_io(|inner| inner.get_mut().flush()) {
+                Ok(res) => return Poll::Ready(res),
+                Err(_wb) => continue,
+            }
+        }
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
@@ -0,0 +1,32 @@
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//                    Version 2, December 2004
+//
+// Copyleft (ↄ) meh. <[email protected]> | http://meh.schizofreni.co
+//
+// Everyone is permitted to copy and distribute verbatim or modified
+// copies of this license document, and changing it is allowed as long
+// as the name is changed.
+//
+//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+//
+//  0. You just DO WHAT THE FUCK YOU WANT TO.
+
+//! Async specific modules.
+
+use crate::error;
+
+use crate::configuration::Configuration;
+use crate::platform::create;
+
+mod device;
+pub use self::device::{AsyncDevice, AsyncQueue};
+
+mod codec;
+pub use self::codec::{TunPacket, TunPacketCodec};
+
+/// Create a TUN device with the given name.
+pub fn create_as_async(configuration: &Configuration) -> Result<AsyncDevice, error::Error> {
+    let device = create(&configuration)?;
+    AsyncDevice::new(device).map_err(|err| err.into())
+}