Struct tokio_core::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, handle: &Handle) -> Result<TcpListener>[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 accept(&mut self) -> Result<(TcpStream, SocketAddr)>[src]
Attempt to accept a connection and create a new connected TcpStream if
successful.
This function will attempt an accept operation, but will not block waiting for it to complete. If the operation would block then a "would block" error is returned. Additionally, if this method would block, it registers the current task to receive a notification when it would otherwise not block.
Note that typically for simple usage it's easier to treat incoming
connections as a Stream of TcpStreams with the incoming method
below.
Panics
This function will panic if it is called outside the context of a
future's task. It's recommended to only call this from the
implementation of a Future::poll, if necessary.
pub fn accept_std(&mut self) -> Result<(TcpStream, SocketAddr)>[src]
Like accept, except that it returns a raw std::net::TcpStream.
The stream is in blocking mode, and is not associated with the Tokio event loop.
pub fn from_listener(
listener: TcpListener,
addr: &SocketAddr,
handle: &Handle
) -> Result<TcpListener>[src]
listener: TcpListener,
addr: &SocketAddr,
handle: &Handle
) -> Result<TcpListener>
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.
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
addrspecified. That is, ifaddris an IPv4 address then all sockets accepted will be IPv4 as well (same for IPv6).
pub fn poll_read(&self) -> Async<()>[src]
Test whether this socket is ready to be read or not.
pub fn local_addr(&self) -> Result<SocketAddr>[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.
pub fn set_ttl(&self, ttl: u32) -> Result<()>[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.
pub fn ttl(&self) -> Result<u32>[src]
Gets the value of the IP_TTL option for this socket.
For more information about this option, see set_ttl.
pub fn set_only_v6(&self, only_v6: bool) -> Result<()>[src]
Sets the value for the IPV6_V6ONLY option on this socket.
If this is set to true then the socket is restricted to sending and
receiving IPv6 packets only. In this case two IPv4 and IPv6 applications
can bind the same port at the same time.
If this is set to false then the socket can be used to send and
receive packets from an IPv4-mapped IPv6 address.
pub fn only_v6(&self) -> Result<bool>[src]
Gets the value of the IPV6_V6ONLY option for this socket.
For more information about this option, see set_only_v6.