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]
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.
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.
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).
fn poll_read(&self) -> Async<()>[src]
Test whether this socket is ready to be read or not.
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.
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.
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.
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.
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.
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.