Struct kvarn::prelude::networking::TcpListener

pub struct TcpListener { /* private fields */ }

Available on crate feature async-networking only.

A TCP socket server, listening for connections.

You can accept a new connection by using the accept method.

Examples

use tokio_uring::net::TcpListener;
use tokio_uring::net::TcpStream;

let listener = TcpListener::bind("127.0.0.1:2345".parse().unwrap()).unwrap();

tokio_uring::start(async move {
    let (tx_ch, rx_ch) = tokio::sync::oneshot::channel();

    tokio_uring::spawn(async move {
        let (rx, _) = listener.accept().await.unwrap();
        if let Err(_) = tx_ch.send(rx) {
            panic!("The receiver dropped");
        }
    });
    tokio::task::yield_now().await; // Ensure the listener.accept().await has been kicked off.

    let tx = TcpStream::connect("127.0.0.1:2345".parse().unwrap()).await.unwrap();
    let rx = rx_ch.await.expect("The spawned task expected to send a TcpStream");

    tx.write(b"test" as &'static [u8]).submit().await.0.unwrap();

    let (_, buf) = rx.read(vec![0; 4]).await;

    assert_eq!(buf, b"test");
});

Implementations

impl TcpListener

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

Creates a new TcpListener, which will be bound to the specified address.

The returned listener is ready for accepting connections.

Binding with a port number of 0 will request that the OS assigns a port to this listener.

pub fn from_std(socket: TcpListener) -> TcpListener

Creates new TcpListener from a previously bound std::net::TcpListener.

This function is intended to be used to wrap a TCP listener from the standard library in the tokio-uring equivalent. The conversion assumes nothing about the underlying socket; it is left up to the user to decide what socket options are appropriate for their use case.

This can be used in conjunction with socket2’s Socket interface to configure a socket before it’s handed off, such as setting options like reuse_address or binding to multiple addresses.

Example

tokio_uring::start(async {
    let address: std::net::SocketAddr = "[::0]:8443".parse().unwrap();
    let socket = tokio::net::TcpSocket::new_v6().unwrap();
    socket.set_reuseaddr(true).unwrap();
    socket.set_reuseport(true).unwrap();
    socket.bind(address).unwrap();

    let listener = socket.listen(1024).unwrap();

    let listener = tokio_uring::net::TcpListener::from_std(listener.into_std().unwrap());
})

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 std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use tokio_uring::net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:8080".parse().unwrap()).unwrap();

let addr = listener.local_addr().expect("Couldn't get local address");
assert_eq!(addr, SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));

pub async fn accept( &self ) -> impl Future<Output = Result<(TcpStream, SocketAddr), Error>>

Accepts a new incoming connection from this listener.

This function will yield once a new TCP connection is established. When established, the corresponding TcpStream and the remote peer’s address will be returned.

Trait Implementations

impl AsRawFd for TcpListener

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl FromRawFd for TcpListener

unsafe fn from_raw_fd(fd: i32) -> TcpListener

Constructs a new instance of Self from the given raw file descriptor.