make tun dependency optional (#142)

* remove log crates
* remove udp/raw of smoltcp
* make tun as optional dependancy, compile for freebsd works

easytier/src/gateway/tokio_smoltcp/socket.rs

@@ -1,8 +1,8 @@
 use super::{reactor::Reactor, socket_allocator::SocketHandle};
 use futures::future::{self, poll_fn};
 use futures::{ready, Stream};
-pub use smoltcp::socket::{raw, tcp, udp};
-use smoltcp::wire::{IpAddress, IpEndpoint, IpProtocol, IpVersion};
+pub use smoltcp::socket::tcp;
+use smoltcp::wire::{IpAddress, IpEndpoint};
 use std::mem::replace;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::{
@@ -231,147 +231,3 @@ impl AsyncWrite for TcpStream {
         Poll::Pending
     }
 }
-
-/// A UDP socket.
-pub struct UdpSocket {
-    handle: SocketHandle,
-    reactor: Arc<Reactor>,
-    local_addr: SocketAddr,
-}
-
-impl UdpSocket {
-    pub(super) async fn new(
-        reactor: Arc<Reactor>,
-        local_endpoint: IpEndpoint,
-    ) -> io::Result<UdpSocket> {
-        let handle = reactor.socket_allocator().new_udp_socket();
-        {
-            let mut socket = reactor.get_socket::<udp::Socket>(*handle);
-            socket.bind(local_endpoint).map_err(map_err)?;
-        }
-
-        let local_addr = ep2sa(&local_endpoint);
-
-        Ok(UdpSocket {
-            handle,
-            reactor,
-            local_addr,
-        })
-    }
-    /// Note that on multiple calls to a poll_* method in the send direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.
-    pub fn poll_send_to(
-        &self,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-        target: SocketAddr,
-    ) -> Poll<io::Result<usize>> {
-        let mut socket = self.reactor.get_socket::<udp::Socket>(*self.handle);
-        let target_ip: IpEndpoint = target.into();
-
-        match socket.send_slice(buf, target_ip) {
-            // the buffer is full
-            Err(udp::SendError::BufferFull) => {}
-            r => {
-                r.map_err(map_err)?;
-                self.reactor.notify();
-                return Poll::Ready(Ok(buf.len()));
-            }
-        }
-
-        socket.register_send_waker(cx.waker());
-        Poll::Pending
-    }
-    /// See note on `poll_send_to`
-    pub async fn send_to(&self, buf: &[u8], target: SocketAddr) -> io::Result<usize> {
-        poll_fn(|cx| self.poll_send_to(cx, buf, target)).await
-    }
-    /// Note that on multiple calls to a poll_* method in the recv direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.
-    pub fn poll_recv_from(
-        &self,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<(usize, SocketAddr)>> {
-        let mut socket = self.reactor.get_socket::<udp::Socket>(*self.handle);
-
-        match socket.recv_slice(buf) {
-            // the buffer is empty
-            Err(udp::RecvError::Exhausted) => {}
-            r => {
-                let (size, metadata) = r.map_err(map_err)?;
-                self.reactor.notify();
-                return Poll::Ready(Ok((size, ep2sa(&metadata.endpoint))));
-            }
-        }
-
-        socket.register_recv_waker(cx.waker());
-        Poll::Pending
-    }
-    /// See note on `poll_recv_from`
-    pub async fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
-        poll_fn(|cx| self.poll_recv_from(cx, buf)).await
-    }
-    pub fn local_addr(&self) -> io::Result<SocketAddr> {
-        Ok(self.local_addr)
-    }
-}
-
-/// A raw socket.
-pub struct RawSocket {
-    handle: SocketHandle,
-    reactor: Arc<Reactor>,
-}
-
-impl RawSocket {
-    pub(super) async fn new(
-        reactor: Arc<Reactor>,
-        ip_version: IpVersion,
-        ip_protocol: IpProtocol,
-    ) -> io::Result<RawSocket> {
-        let handle = reactor
-            .socket_allocator()
-            .new_raw_socket(ip_version, ip_protocol);
-
-        Ok(RawSocket { handle, reactor })
-    }
-    /// Note that on multiple calls to a poll_* method in the send direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.
-    pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
-        let mut socket = self.reactor.get_socket::<raw::Socket>(*self.handle);
-
-        match socket.send_slice(buf) {
-            // the buffer is full
-            Err(raw::SendError::BufferFull) => {}
-            r => {
-                r.map_err(map_err)?;
-                self.reactor.notify();
-                return Poll::Ready(Ok(buf.len()));
-            }
-        }
-
-        socket.register_send_waker(cx.waker());
-        Poll::Pending
-    }
-    /// See note on `poll_send`
-    pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
-        poll_fn(|cx| self.poll_send(cx, buf)).await
-    }
-    /// Note that on multiple calls to a poll_* method in the recv direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.
-    pub fn poll_recv(&self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
-        let mut socket = self.reactor.get_socket::<raw::Socket>(*self.handle);
-
-        match socket.recv_slice(buf) {
-            // the buffer is empty
-            Err(raw::RecvError::Exhausted) => {}
-            r => {
-                let size = r.map_err(map_err)?;
-                return Poll::Ready(Ok(size));
-            }
-        }
-
-        socket.register_recv_waker(cx.waker());
-        Poll::Pending
-    }
-    /// See note on `poll_recv`
-    pub async fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
-        poll_fn(|cx| self.poll_recv(cx, buf)).await
-    }
-}