cap_std/net/
tcp_listener.rs

1use crate::net::{Incoming, SocketAddr, TcpStream};
2#[cfg(not(windows))]
3use io_extras::os::rustix::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
4#[cfg(not(windows))]
5use io_lifetimes::{AsFd, BorrowedFd, OwnedFd};
6#[cfg(windows)]
7use io_lifetimes::{AsSocket, BorrowedSocket, OwnedSocket};
8use std::{fmt, io, net};
9#[cfg(windows)]
10use {
11    io_extras::os::windows::{
12        AsHandleOrSocket, AsRawHandleOrSocket, BorrowedHandleOrSocket, IntoRawHandleOrSocket,
13        OwnedHandleOrSocket, RawHandleOrSocket,
14    },
15    std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket},
16};
17
18/// A TCP socket server, listening for connections.
19///
20/// This corresponds to [`std::net::TcpListener`].
21///
22/// This `TcpListener` has no `bind` method. To bind it to a socket address,
23/// first obtain a [`Pool`] permitting the address, and then call
24/// [`Pool::bind_tcp_listener`].
25///
26/// [`Pool`]: struct.Pool.html
27/// [`Pool::bind_tcp_listener`]: struct.Pool.html#method.bind_tcp_listener
28pub struct TcpListener {
29    std: net::TcpListener,
30}
31
32impl TcpListener {
33    /// Constructs a new instance of `Self` from the given
34    /// `std::net::TcpListener`.
35    ///
36    /// This grants access the resources the `std::net::TcpListener` instance
37    /// already has access to.
38    #[inline]
39    pub fn from_std(std: net::TcpListener) -> Self {
40        Self { std }
41    }
42
43    /// Returns the local socket address of this listener.
44    ///
45    /// This corresponds to [`std::net::TcpListener::local_addr`].
46    #[inline]
47    pub fn local_addr(&self) -> io::Result<SocketAddr> {
48        self.std.local_addr()
49    }
50
51    /// Creates a new independently owned handle to the underlying socket.
52    ///
53    /// This corresponds to [`std::net::TcpListener::try_clone`].
54    #[inline]
55    pub fn try_clone(&self) -> io::Result<Self> {
56        let tcp_listener = self.std.try_clone()?;
57        Ok(Self::from_std(tcp_listener))
58    }
59
60    /// Accept a new incoming connection from this listener.
61    ///
62    /// This corresponds to [`std::net::TcpListener::accept`].
63    #[inline]
64    pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
65        self.std
66            .accept()
67            .map(|(tcp_stream, addr)| (TcpStream::from_std(tcp_stream), addr))
68    }
69
70    /// Returns an iterator over the connections being received on this
71    /// listener.
72    ///
73    /// This corresponds to [`std::net::TcpListener::incoming`].
74    #[inline]
75    pub fn incoming(&self) -> Incoming {
76        let incoming = self.std.incoming();
77        Incoming::from_std(incoming)
78    }
79
80    /// Sets the value for the `IP_TTL` option on this socket.
81    ///
82    /// This corresponds to [`std::net::TcpListener::set_ttl`].
83    #[inline]
84    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
85        self.std.set_ttl(ttl)
86    }
87
88    /// Gets the value of the `IP_TTL` option for this socket.
89    ///
90    /// This corresponds to [`std::net::TcpListener::ttl`].
91    #[inline]
92    pub fn ttl(&self) -> io::Result<u32> {
93        self.std.ttl()
94    }
95
96    /// Gets the value of the `SO_ERROR` option on this socket.
97    ///
98    /// This corresponds to [`std::net::TcpListener::take_error`].
99    #[inline]
100    pub fn take_error(&self) -> io::Result<Option<io::Error>> {
101        self.std.take_error()
102    }
103
104    /// Moves this TCP stream into or out of nonblocking mode.
105    ///
106    /// This corresponds to [`std::net::TcpListener::set_nonblocking`].
107    #[inline]
108    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
109        self.std.set_nonblocking(nonblocking)
110    }
111}
112
113// Safety: `SocketlikeViewType` is implemented for `std`'s socket types.
114unsafe impl io_lifetimes::views::SocketlikeViewType for TcpListener {}
115
116#[cfg(not(windows))]
117impl FromRawFd for TcpListener {
118    #[inline]
119    unsafe fn from_raw_fd(fd: RawFd) -> Self {
120        Self::from_std(net::TcpListener::from_raw_fd(fd))
121    }
122}
123
124#[cfg(not(windows))]
125impl From<OwnedFd> for TcpListener {
126    #[inline]
127    fn from(fd: OwnedFd) -> Self {
128        Self::from_std(net::TcpListener::from(fd))
129    }
130}
131
132#[cfg(windows)]
133impl FromRawSocket for TcpListener {
134    #[inline]
135    unsafe fn from_raw_socket(socket: RawSocket) -> Self {
136        Self::from_std(net::TcpListener::from_raw_socket(socket))
137    }
138}
139
140#[cfg(windows)]
141impl From<OwnedSocket> for TcpListener {
142    #[inline]
143    fn from(socket: OwnedSocket) -> Self {
144        Self::from_std(net::TcpListener::from(socket))
145    }
146}
147
148#[cfg(not(windows))]
149impl AsRawFd for TcpListener {
150    #[inline]
151    fn as_raw_fd(&self) -> RawFd {
152        self.std.as_raw_fd()
153    }
154}
155
156#[cfg(not(windows))]
157impl AsFd for TcpListener {
158    #[inline]
159    fn as_fd(&self) -> BorrowedFd<'_> {
160        self.std.as_fd()
161    }
162}
163
164#[cfg(windows)]
165impl AsRawSocket for TcpListener {
166    #[inline]
167    fn as_raw_socket(&self) -> RawSocket {
168        self.std.as_raw_socket()
169    }
170}
171
172#[cfg(windows)]
173impl AsSocket for TcpListener {
174    #[inline]
175    fn as_socket(&self) -> BorrowedSocket<'_> {
176        self.std.as_socket()
177    }
178}
179
180#[cfg(windows)]
181impl AsRawHandleOrSocket for TcpListener {
182    #[inline]
183    fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
184        self.std.as_raw_handle_or_socket()
185    }
186}
187
188#[cfg(windows)]
189impl AsHandleOrSocket for TcpListener {
190    #[inline]
191    fn as_handle_or_socket(&self) -> BorrowedHandleOrSocket<'_> {
192        self.std.as_handle_or_socket()
193    }
194}
195
196#[cfg(not(windows))]
197impl IntoRawFd for TcpListener {
198    #[inline]
199    fn into_raw_fd(self) -> RawFd {
200        self.std.into_raw_fd()
201    }
202}
203
204#[cfg(not(windows))]
205impl From<TcpListener> for OwnedFd {
206    #[inline]
207    fn from(listener: TcpListener) -> OwnedFd {
208        listener.std.into()
209    }
210}
211
212#[cfg(windows)]
213impl IntoRawSocket for TcpListener {
214    #[inline]
215    fn into_raw_socket(self) -> RawSocket {
216        self.std.into_raw_socket()
217    }
218}
219
220#[cfg(windows)]
221impl From<TcpListener> for OwnedSocket {
222    #[inline]
223    fn from(listener: TcpListener) -> OwnedSocket {
224        listener.std.into()
225    }
226}
227
228#[cfg(windows)]
229impl IntoRawHandleOrSocket for TcpListener {
230    #[inline]
231    fn into_raw_handle_or_socket(self) -> RawHandleOrSocket {
232        self.std.into_raw_handle_or_socket()
233    }
234}
235
236#[cfg(windows)]
237impl From<TcpListener> for OwnedHandleOrSocket {
238    #[inline]
239    fn from(listener: TcpListener) -> Self {
240        listener.std.into()
241    }
242}
243
244impl fmt::Debug for TcpListener {
245    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
246        self.std.fmt(f)
247    }
248}
cap_std/net/tcp_listener.rs

cap_std/net/
tcp_listener.rs
