      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146

    use crate::io::{Interest, PollEvented};
    use crate::net::unix::{SocketAddr, UnixStream};

    use std::convert::TryFrom;
    use std::fmt;
    use std::io;
    use std::os::unix::io::{AsRawFd, RawFd};
    use std::os::unix::net;
    use std::path::Path;
    use std::task::{Context, Poll};

    cfg_net_unix! {
        /// A Unix socket which can accept connections from other Unix sockets.
        ///
        /// You can accept a new connection by using the [`accept`](`UnixListener::accept`) method.
        ///
        /// # Errors
        ///
        /// Note that accepting a connection can lead to various errors and not all
        /// of them are necessarily fatal ‒ for example having too many open file
        /// descriptors or the other side closing the connection while it waits in
        /// an accept queue. These would terminate the stream if not handled in any
        /// way.
        ///
        /// # Examples
        ///
        /// ```no_run
        /// use tokio::net::UnixListener;
        ///
        /// #[tokio::main]
        /// async fn main() {
        ///     let listener = UnixListener::bind("/path/to/the/socket").unwrap();
        ///     loop {
        ///         match listener.accept().await {
        ///             Ok((stream, _addr)) => {
        ///                 println!("new client!");
        ///             }
        ///             Err(e) => { /* connection failed */ }
        ///         }
        ///     }
        /// }
        /// ```
        pub struct UnixListener {
            io: PollEvented<mio::net::UnixListener>,
        }
    }

    impl UnixListener {
        /// Creates a new `UnixListener` bound to the specified path.
        ///
        /// # Panics
        ///
        /// This function panics if thread-local runtime is not set.
        ///
        /// The runtime is usually set implicitly when this function is called
        /// from a future driven by a tokio runtime, otherwise runtime can be set
        /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function.
        pub fn bind<P>(path: P) -> io::Result<UnixListener>
        where
            P: AsRef<Path>,
        {
            let listener = mio::net::UnixListener::bind(path)?;
            let io = PollEvented::new(listener)?;
            Ok(UnixListener { io })
        }

        /// Creates new `UnixListener` from a `std::os::unix::net::UnixListener `.
        ///
        /// This function is intended to be used to wrap a UnixListener from the
        /// standard library in the Tokio equivalent. The conversion assumes
        /// nothing about the underlying listener; it is left up to the user to set
        /// it in non-blocking mode.
        ///
        /// # Panics
        ///
        /// This function panics if thread-local runtime is not set.
        ///
        /// The runtime is usually set implicitly when this function is called
        /// from a future driven by a tokio runtime, otherwise runtime can be set
        /// explicitly with [`Runtime::enter`](crate::runtime::Runtime::enter) function.
        pub fn from_std(listener: net::UnixListener) -> io::Result<UnixListener> {
            let listener = mio::net::UnixListener::from_std(listener);
            let io = PollEvented::new(listener)?;
            Ok(UnixListener { io })
        }

        /// Returns the local socket address of this listener.
        pub fn local_addr(&self) -> io::Result<SocketAddr> {
            self.io.local_addr().map(SocketAddr)
        }

        /// Returns the value of the `SO_ERROR` option.
        pub fn take_error(&self) -> io::Result<Option<io::Error>> {
            self.io.take_error()
        }

        /// Accepts a new incoming connection to this listener.
        pub async fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
            let (mio, addr) = self
                .io
                .registration()
                .async_io(Interest::READABLE, || self.io.accept())
                .await?;

            let addr = SocketAddr(addr);
            let stream = UnixStream::new(mio)?;
            Ok((stream, addr))
        }

        /// Polls to accept a new incoming connection to this listener.
        ///
        /// If there is no connection to accept, `Poll::Pending` is returned and the
        /// current task will be notified by a waker.  Note that on multiple calls
        /// to `poll_accept`, only the `Waker` from the `Context` passed to the most
        /// recent call is scheduled to receive a wakeup.
        pub fn poll_accept(&self, cx: &mut Context<'_>) -> Poll<io::Result<(UnixStream, SocketAddr)>> {
            let (sock, addr) = ready!(self.io.registration().poll_read_io(cx, || self.io.accept()))?;
            let addr = SocketAddr(addr);
            let sock = UnixStream::new(sock)?;
            Poll::Ready(Ok((sock, addr)))
        }
    }

    impl TryFrom<std::os::unix::net::UnixListener> for UnixListener {
        type Error = io::Error;

        /// Consumes stream, returning the tokio I/O object.
        ///
        /// This is equivalent to
        /// [`UnixListener::from_std(stream)`](UnixListener::from_std).
        fn try_from(stream: std::os::unix::net::UnixListener) -> io::Result<Self> {
            Self::from_std(stream)
        }
    }

    impl fmt::Debug for UnixListener {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            self.io.fmt(f)
        }
    }

    impl AsRawFd for UnixListener {
        fn as_raw_fd(&self) -> RawFd {
            self.io.as_raw_fd()
        }
    }