1use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
2use std::os::unix::net::{self, SocketAddr};
3use std::path::Path;
4use std::{fmt, io};
5
6use crate::io_source::IoSource;
7use crate::net::UnixStream;
8use crate::{event, sys, Interest, Registry, Token};
9
10/// A non-blocking Unix domain socket server.
11pub struct UnixListener {
12 inner: IoSource<net::UnixListener>,
13}
14
15impl UnixListener {
16 /// Creates a new `UnixListener` bound to the specified socket `path`.
17 pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
18 let addr = SocketAddr::from_pathname(path)?;
19 UnixListener::bind_addr(&addr)
20 }
21
22 /// Creates a new `UnixListener` bound to the specified socket `address`.
23 pub fn bind_addr(address: &SocketAddr) -> io::Result<UnixListener> {
24 sys::uds::listener::bind_addr(address).map(UnixListener::from_std)
25 }
26
27 /// Creates a new `UnixListener` from a standard `net::UnixListener`.
28 ///
29 /// This function is intended to be used to wrap a Unix listener from the
30 /// standard library in the Mio equivalent. The conversion assumes nothing
31 /// about the underlying listener; it is left up to the user to set it in
32 /// non-blocking mode.
33 pub fn from_std(listener: net::UnixListener) -> UnixListener {
34 UnixListener {
35 inner: IoSource::new(listener),
36 }
37 }
38
39 /// Accepts a new incoming connection to this listener.
40 ///
41 /// The call is responsible for ensuring that the listening socket is in
42 /// non-blocking mode.
43 pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
44 sys::uds::listener::accept(&self.inner)
45 }
46
47 /// Returns the local socket address of this listener.
48 pub fn local_addr(&self) -> io::Result<SocketAddr> {
49 self.inner.local_addr()
50 }
51
52 /// Returns the value of the `SO_ERROR` option.
53 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
54 self.inner.take_error()
55 }
56}
57
58impl event::Source for UnixListener {
59 fn register(
60 &mut self,
61 registry: &Registry,
62 token: Token,
63 interests: Interest,
64 ) -> io::Result<()> {
65 self.inner.register(registry, token, interests)
66 }
67
68 fn reregister(
69 &mut self,
70 registry: &Registry,
71 token: Token,
72 interests: Interest,
73 ) -> io::Result<()> {
74 self.inner.reregister(registry, token, interests)
75 }
76
77 fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
78 self.inner.deregister(registry)
79 }
80}
81
82impl fmt::Debug for UnixListener {
83 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
84 self.inner.fmt(f)
85 }
86}
87
88impl IntoRawFd for UnixListener {
89 fn into_raw_fd(self) -> RawFd {
90 self.inner.into_inner().into_raw_fd()
91 }
92}
93
94impl AsRawFd for UnixListener {
95 fn as_raw_fd(&self) -> RawFd {
96 self.inner.as_raw_fd()
97 }
98}
99
100impl FromRawFd for UnixListener {
101 /// Converts a `RawFd` to a `UnixListener`.
102 ///
103 /// # Notes
104 ///
105 /// The caller is responsible for ensuring that the socket is in
106 /// non-blocking mode.
107 unsafe fn from_raw_fd(fd: RawFd) -> UnixListener {
108 UnixListener::from_std(listener:FromRawFd::from_raw_fd(fd))
109 }
110}
111
112impl From<UnixListener> for net::UnixListener {
113 fn from(listener: UnixListener) -> Self {
114 // Safety: This is safe since we are extracting the raw fd from a well-constructed
115 // mio::net::uds::UnixListener which ensures that we actually pass in a valid file
116 // descriptor/socket
117 unsafe { net::UnixListener::from_raw_fd(listener.into_raw_fd()) }
118 }
119}
120
121impl From<UnixListener> for OwnedFd {
122 fn from(unix_listener: UnixListener) -> Self {
123 unix_listener.inner.into_inner().into()
124 }
125}
126
127impl AsFd for UnixListener {
128 fn as_fd(&self) -> BorrowedFd<'_> {
129 self.inner.as_fd()
130 }
131}
132
133impl From<OwnedFd> for UnixListener {
134 fn from(fd: OwnedFd) -> Self {
135 UnixListener::from_std(listener:From::from(fd))
136 }
137}
138