      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
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165

    use crate::io_source::IoSource;
    use crate::{event, sys, Interest, Registry, Token};

    use std::net::Shutdown;
    use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
    use std::os::unix::net;
    use std::path::Path;
    use std::{fmt, io};

    /// A Unix datagram socket.
    pub struct UnixDatagram {
        inner: IoSource<net::UnixDatagram>,
    }

    impl UnixDatagram {
        /// Creates a Unix datagram socket bound to the given path.
        pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> {
            sys::uds::datagram::bind(path.as_ref()).map(UnixDatagram::from_std)
        }

        /// Creates a new `UnixDatagram` from a standard `net::UnixDatagram`.
        ///
        /// This function is intended to be used to wrap a Unix datagram from the
        /// standard library in the Mio equivalent. The conversion assumes nothing
        /// about the underlying datagram; ; it is left up to the user to set it
        /// in non-blocking mode.
        pub fn from_std(socket: net::UnixDatagram) -> UnixDatagram {
            UnixDatagram {
                inner: IoSource::new(socket),
            }
        }

        /// Connects the socket to the specified address.
        pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
            self.inner.connect(path)
        }

        /// Creates a Unix Datagram socket which is not bound to any address.
        pub fn unbound() -> io::Result<UnixDatagram> {
            sys::uds::datagram::unbound().map(UnixDatagram::from_std)
        }

        /// Create an unnamed pair of connected sockets.
        pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> {
            sys::uds::datagram::pair().map(|(socket1, socket2)| {
                (
                    UnixDatagram::from_std(socket1),
                    UnixDatagram::from_std(socket2),
                )
            })
        }

        /// Returns the address of this socket.
        pub fn local_addr(&self) -> io::Result<sys::SocketAddr> {
            sys::uds::datagram::local_addr(&self.inner)
        }

        /// Returns the address of this socket's peer.
        ///
        /// The `connect` method will connect the socket to a peer.
        pub fn peer_addr(&self) -> io::Result<sys::SocketAddr> {
            sys::uds::datagram::peer_addr(&self.inner)
        }

        /// Receives data from the socket.
        ///
        /// On success, returns the number of bytes read and the address from
        /// whence the data came.
        pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, sys::SocketAddr)> {
            self.inner
                .do_io(|inner| sys::uds::datagram::recv_from(inner, buf))
        }

        /// Receives data from the socket.
        ///
        /// On success, returns the number of bytes read.
        pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
            self.inner.do_io(|inner| inner.recv(buf))
        }

        /// Sends data on the socket to the specified address.
        ///
        /// On success, returns the number of bytes written.
        pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> io::Result<usize> {
            self.inner.do_io(|inner| inner.send_to(buf, path))
        }

        /// Sends data on the socket to the socket's peer.
        ///
        /// The peer address may be set by the `connect` method, and this method
        /// will return an error if the socket has not already been connected.
        ///
        /// On success, returns the number of bytes written.
        pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
            self.inner.do_io(|inner| inner.send(buf))
        }

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

        /// Shut down the read, write, or both halves of this connection.
        ///
        /// This function will cause all pending and future I/O calls on the
        /// specified portions to immediately return with an appropriate value
        /// (see the documentation of `Shutdown`).
        pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
            self.inner.shutdown(how)
        }
    }

    impl event::Source for UnixDatagram {
        fn register(
            &mut self,
            registry: &Registry,
            token: Token,
            interests: Interest,
        ) -> io::Result<()> {
            self.inner.register(registry, token, interests)
        }

        fn reregister(
            &mut self,
            registry: &Registry,
            token: Token,
            interests: Interest,
        ) -> io::Result<()> {
            self.inner.reregister(registry, token, interests)
        }

        fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
            self.inner.deregister(registry)
        }
    }

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

    impl IntoRawFd for UnixDatagram {
        fn into_raw_fd(self) -> RawFd {
            self.inner.into_inner().into_raw_fd()
        }
    }

    impl AsRawFd for UnixDatagram {
        fn as_raw_fd(&self) -> RawFd {
            self.inner.as_raw_fd()
        }
    }

    impl FromRawFd for UnixDatagram {
        /// Converts a `RawFd` to a `UnixDatagram`.
        ///
        /// # Notes
        ///
        /// The caller is responsible for ensuring that the socket is in
        /// non-blocking mode.
        unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram {
            UnixDatagram::from_std(FromRawFd::from_raw_fd(fd))
        }
    }