Struct tokio::net::TcpListener
[−]
[src]
pub struct TcpListener { /* fields omitted */ }
An I/O object representing a TCP socket listening for incoming connections.
This object can be converted into a stream of incoming connections for various forms of processing.
Methods
impl TcpListener
[src]
pub fn bind(addr: &SocketAddr) -> Result<TcpListener, Error>
[src]
Create a new TCP listener associated with this event loop.
The TCP listener will bind to the provided addr
address, if available.
If the result is Ok
, the socket has successfully bound.
pub fn poll_accept(&mut self) -> Result<Async<(TcpStream, SocketAddr)>, Error>
[src]
Attempt to accept a connection and create a new connected TcpStream
if
successful.
Note that typically for simple usage it's easier to treat incoming
connections as a Stream
of TcpStream
s with the incoming
method
below.
Return
On success, returns Ok(Async::Ready((socket, addr)))
.
If the listener is not ready to accept, the method returns
Ok(Async::NotReady)
and arranges for the current task to receive a
notification when the listener becomes ready to accept.
Panics
This function will panic if called from outside of a task context.
pub fn poll_accept_std(
&mut self
) -> Result<Async<(TcpStream, SocketAddr)>, Error>
[src]
&mut self
) -> Result<Async<(TcpStream, SocketAddr)>, Error>
Attempt to accept a connection and create a new connected TcpStream
if
successful.
This function is the same as accept
above except that it returns a
std::net::TcpStream
instead of a tokio::net::TcpStream
. This in turn
can then allow for the TCP stream to be associated with a different
reactor than the one this TcpListener
is associated with.
Return
On success, returns Ok(Async::Ready((socket, addr)))
.
If the listener is not ready to accept, the method returns
Ok(Async::NotReady)
and arranges for the current task to receive a
notification when the listener becomes ready to accept.
Panics
This function will panic if called from outside of a task context.
pub fn from_std(
listener: TcpListener,
handle: &Handle
) -> Result<TcpListener, Error>
[src]
listener: TcpListener,
handle: &Handle
) -> Result<TcpListener, Error>
Create a new TCP listener from the standard library's TCP listener.
This method can be used when the Handle::tcp_listen
method isn't
sufficient because perhaps some more configuration is needed in terms of
before the calls to bind
and listen
.
This API is typically paired with the net2
crate and the TcpBuilder
type to build up and customize a listener before it's shipped off to the
backing event loop. This allows configuration of options like
SO_REUSEPORT
, binding to multiple addresses, etc.
The addr
argument here is one of the addresses that listener
is
bound to and the listener will only be guaranteed to accept connections
of the same address type currently.
Finally, the handle
argument is the event loop that this listener will
be bound to.
Use Handle::default()
to lazily bind to an event loop, just like bind
does.
The platform specific behavior of this function looks like:
-
On Unix, the socket is placed into nonblocking mode and connections can be accepted as normal
-
On Windows, the address is stored internally and all future accepts will only be for the same IP version as
addr
specified. That is, ifaddr
is an IPv4 address then all sockets accepted will be IPv4 as well (same for IPv6).
pub fn local_addr(&self) -> Result<SocketAddr, Error>
[src]
Returns the local address that this listener is bound to.
This can be useful, for example, when binding to port 0 to figure out which port was actually bound.
pub fn incoming(self) -> Incoming
[src]
Consumes this listener, returning a stream of the sockets this listener accepts.
This method returns an implementation of the Stream
trait which
resolves to the sockets the are accepted on this listener.
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.
If aiming for production, decision what to do about them must be made. The
tk-listen
crate might be of some help.
pub fn ttl(&self) -> Result<u32, Error>
[src]
Gets the value of the IP_TTL
option for this socket.
For more information about this option, see set_ttl
.
pub fn set_ttl(&self, ttl: u32) -> Result<(), Error>
[src]
Sets the value for the IP_TTL
option on this socket.
This value sets the time-to-live field that is used in every packet sent from this socket.