Struct tokio::net::tcp::TcpListener

source · [−]

pub struct TcpListener { /* private fields */ }

Expand description

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.

Examples

extern crate tokio;
extern crate futures;

use futures::stream::Stream;
use std::net::SocketAddr;
use tokio::net::{TcpListener, TcpStream};

fn process_socket(socket: TcpStream) {
    // ...
}

fn main() -> Result<(), Box<std::error::Error>> {
    let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
    let listener = TcpListener::bind(&addr)?;

    // accept connections and process them
    tokio::run(listener.incoming()
        .map_err(|e| eprintln!("failed to accept socket; error = {:?}", e))
        .for_each(|socket| {
            process_socket(socket);
            Ok(())
        })
    );
    Ok(())
}

Implementations

source

impl TcpListener

source

pub fn bind(addr: &SocketAddr) -> Result<TcpListener, Error>

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>

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 TcpStreams 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>

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.

Examples

use std::net::SocketAddr;
use tokio::net::TcpListener;
use futures::Async;

let addr = "127.0.0.1:0".parse::<SocketAddr>()?;
let mut listener = TcpListener::bind(&addr)?;
match listener.poll_accept_std() {
    Ok(Async::Ready((_socket, addr))) => println!("listener ready to accept: {:?}", addr),
    Ok(Async::NotReady) => println!("listener not ready to accept!"),
    Err(e) => eprintln!("got an error: {}", e),
}

source

pub fn from_std(
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, if addr is an IPv4 address then all sockets accepted will be IPv4 as well (same for IPv6).

Examples

use tokio::net::TcpListener;
use std::net::TcpListener as StdTcpListener;
use tokio::reactor::Handle;

let std_listener = StdTcpListener::bind("127.0.0.1:0")?;
let listener = TcpListener::from_std(std_listener, &Handle::default())?;

source

pub fn local_addr(&self) -> Result<SocketAddr, Error>

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.

Examples

use tokio::net::TcpListener;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let listener = TcpListener::bind(&addr)?;
assert_eq!(listener.local_addr()?,
           SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));

This value sets the time-to-live field that is used in every packet sent from this socket.

Examples

use tokio::net::TcpListener;
use std::net::SocketAddr;

let addr = "127.0.0.1:0".parse::<SocketAddr>()?;
let listener = TcpListener::bind(&addr)?;
listener.set_ttl(100).expect("could not set TTL");