Struct async_net::TcpListener

pub struct TcpListener { /* private fields */ }

A TCP server, listening for connections.

After creating a TcpListener by binding it to an address, it listens for incoming TCP connections. These can be accepted by calling accept() or by awaiting items from the stream of incoming connections.

Cloning a TcpListener creates another handle to the same socket. The socket will be closed when all handles to it are dropped.

The Transmission Control Protocol is specified in IETF RFC 793.

Examples

use async_net::TcpListener;
use futures_lite::prelude::*;

let listener = TcpListener::bind("127.0.0.1:8080").await?;
let mut incoming = listener.incoming();

while let Some(stream) = incoming.next().await {
    let mut stream = stream?;
    stream.write_all(b"hello").await?;
}

Implementations

impl TcpListener

pub async fn bind<A: AsyncToSocketAddrs>(addr: A) -> Result<TcpListener>

Creates a new TcpListener bound to the given address.

Binding with a port number of 0 will request that the operating system assigns an available port to this listener. The assigned port can be queried via the local_addr() method.

If addr yields multiple addresses, binding will be attempted with each of the addresses until one succeeds and returns the listener. If none of the addresses succeed in creating a listener, the error from the last attempt is returned.

Examples

Create a TCP listener bound to 127.0.0.1:80:

use async_net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:80").await?;

Create a TCP listener bound to 127.0.0.1:80. If that address is unavailable, then try binding to 127.0.0.1:443:

use async_net::{SocketAddr, TcpListener};

let addrs = [
    SocketAddr::from(([127, 0, 0, 1], 80)),
    SocketAddr::from(([127, 0, 0, 1], 443)),
];
let listener = TcpListener::bind(&addrs[..]).await.unwrap();

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

Returns the local address this listener is bound to.

Examples

Bind to port 0 and then see which port was assigned by the operating system:

use async_net::{SocketAddr, TcpListener};

let listener = TcpListener::bind("127.0.0.1:0").await?;
println!("Listening on {}", listener.local_addr()?);

pub async fn accept(&self) -> Result<(TcpStream, SocketAddr)>

Accepts a new incoming connection.

Returns a TCP stream and the address it is connected to.

Examples

use async_net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:8080").await?;
let (stream, addr) = listener.accept().await?;

pub fn incoming(&self) -> Incoming<'_>

Returns a stream of incoming connections.

Iterating over this stream is equivalent to calling accept() in a loop. The stream of connections is infinite, i.e awaiting the next connection will never result in None.

Examples

use async_net::TcpListener;
use futures_lite::prelude::*;

let listener = TcpListener::bind("127.0.0.1:0").await?;
let mut incoming = listener.incoming();

while let Some(stream) = incoming.next().await {
    let mut stream = stream?;
    stream.write_all(b"hello").await?;
}

pub fn ttl(&self) -> Result<u32>

Gets the value of the IP_TTL option for this socket.

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

Examples

use async_net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:80").await?;
listener.set_ttl(100)?;
assert_eq!(listener.ttl()?, 100);

pub fn set_ttl(&self, ttl: u32) -> Result<()>

Sets the value of the IP_TTL option for this socket.

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

Examples

use async_net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:80").await?;
listener.set_ttl(100)?;

Trait Implementations

impl AsRawFd for TcpListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Clone for TcpListener

fn clone(&self) -> TcpListener

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TcpListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Async<TcpListener>> for TcpListener

fn from(listener: Async<TcpListener>) -> TcpListener

Performs the conversion.

impl From<TcpListener> for Arc<Async<TcpListener>>

fn from(val: TcpListener) -> Self

Performs the conversion.

impl TryFrom<TcpListener> for TcpListener

type Error = Error

The type returned in the event of a conversion error.

fn try_from(listener: TcpListener) -> Result<TcpListener>

Performs the conversion.