Struct kvarn::prelude::networking::TcpListener
pub struct TcpListener { /* private fields */ }
async-networking
only.Expand description
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
impl TcpListener
pub fn bind(addr: SocketAddr) -> Result<TcpListener, Error>
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
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>
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>>
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 FromRawFd for TcpListener
impl FromRawFd for TcpListener
§unsafe fn from_raw_fd(fd: i32) -> TcpListener
unsafe fn from_raw_fd(fd: i32) -> TcpListener
Self
from the given raw file
descriptor. Read more