Struct kvarn::prelude::networking::TcpListener
source · 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§
source§impl TcpListener
impl TcpListener
sourcepub 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.
sourcepub 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());
})
sourcepub 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)));
Trait Implementations§
source§impl AsRawFd for TcpListener
impl AsRawFd for TcpListener
source§impl FromRawFd for TcpListener
impl FromRawFd for TcpListener
source§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