Struct TcpStream

pub struct TcpStream {
    inner: Arc<Async<TcpStream>>,
    readable: Option<ReadableOwned<TcpStream>>,
    writable: Option<WritableOwned<TcpStream>>,
}

A TCP connection.

A TcpStream can be created by connecting to an endpoint or by accepting an incoming connection.

TcpStream is a bidirectional stream that implements traits AsyncRead and AsyncWrite.

Cloning a TcpStream creates another handle to the same socket. The socket will be closed when all handles to it are dropped. The reading and writing portions of the connection can also be shut down individually with the shutdown() method.

The Transmission Control Protocol is specified in IETF RFC 793.

Examples

use async_net::TcpStream;
use futures_lite::prelude::*;

let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.write_all(b"hello").await?;

let mut buf = vec![0u8; 1024];
let n = stream.read(&mut buf).await?;

Fields

inner: Arc<Async<TcpStream>>

readable: Option<ReadableOwned<TcpStream>>

writable: Option<WritableOwned<TcpStream>>

Implementations

impl TcpStream

pub async fn connect<A>(addr: A) -> Result<TcpStream, Error>

where A: AsyncToSocketAddrs,

Creates a TCP connection to the specified address.

This method will create a new TCP socket and attempt to connect it to the provided addr,

If addr yields multiple addresses, connecting will be attempted with each of the addresses until connecting to one succeeds. If none of the addresses result in a successful connection, the error from the last connect attempt is returned.

Examples

Connect to example.com:80:

use async_net::TcpStream;

let stream = TcpStream::connect("example.com:80").await?;

Connect to 127.0.0.1:8080. If that fails, then try connecting to 127.0.0.1:8081:

use async_net::{SocketAddr, TcpStream};

let addrs = [
    SocketAddr::from(([127, 0, 0, 1], 8080)),
    SocketAddr::from(([127, 0, 0, 1], 8081)),
];
let stream = TcpStream::connect(&addrs[..]).await?;

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

Returns the local address this stream is bound to.

Examples

use async_net::TcpStream;

let stream = TcpStream::connect("example.com:80").await?;
println!("Local address is {}", stream.local_addr()?);

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

Returns the remote address this stream is connected to.

Examples

use async_net::TcpStream;

let stream = TcpStream::connect("example.com:80").await?;
println!("Connected to {}", stream.peer_addr()?);

pub fn shutdown(&self, how: Shutdown) -> Result<(), Error>

Shuts down the read half, write half, or both halves of this connection.

This method will cause all pending and future I/O in the given directions to return immediately with an appropriate value (see the documentation of Shutdown).

Examples

use async_net::{Shutdown, TcpStream};

let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.shutdown(Shutdown::Both)?;

pub async fn peek(&self, buf: &mut [u8]) -> Result<usize, Error>

Receives data without removing it from the queue.

On success, returns the number of bytes peeked.

Successive calls return the same data. This is accomplished by passing MSG_PEEK as a flag to the underlying recv system call.

Examples

use async_net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

let mut buf = vec![0; 1024];
let n = stream.peek(&mut buf).await?;

pub fn nodelay(&self) -> Result<bool, Error>

Gets the value of the TCP_NODELAY option for this socket.

If set to true, this option disables the Nagle algorithm. This means that written data is always sent as soon as possible, even if there is only a small amount of it.

When set to false, written data is buffered until there is a certain amount to send out, thereby avoiding the frequent sending of small packets.

Examples

use async_net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("TCP_NODELAY is set to {}", stream.nodelay()?);

pub fn set_nodelay(&self, nodelay: bool) -> Result<(), Error>

Sets the value of the TCP_NODELAY option for this socket.

If set to true, this option disables the Nagle algorithm. This means that written data is always sent as soon as possible, even if there is only a small amount of it.

When set to false, written data is buffered until there is a certain amount to send out, thereby avoiding the frequent sending of small packets.

Examples

use async_net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_nodelay(false)?;

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

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::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("IP_TTL is set to {}", stream.ttl()?);

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

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::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_ttl(100)?;

Trait Implementations

impl AsFd for TcpStream

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl AsRawFd for TcpStream

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl AsyncRead for TcpStream

fn poll_read( self: Pin<&mut TcpStream>, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl AsyncWrite for TcpStream

fn poll_write( self: Pin<&mut TcpStream>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_flush( self: Pin<&mut TcpStream>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close( self: Pin<&mut TcpStream>, _: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut TcpStream>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl Clone for TcpStream

fn clone(&self) -> TcpStream

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TcpStream

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

Formats the value using the given formatter.

impl From<Async<TcpStream>> for TcpStream

fn from(stream: Async<TcpStream>) -> TcpStream

Converts to this type from the input type.

impl TryFrom<OwnedFd> for TcpStream

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: OwnedFd, ) -> Result<TcpStream, <TcpStream as TryFrom<OwnedFd>>::Error>

Performs the conversion.

impl TryFrom<TcpStream> for TcpStream

type Error = Error

The type returned in the event of a conversion error.

fn try_from(stream: TcpStream) -> Result<TcpStream, Error>

Performs the conversion.

impl RefUnwindSafe for TcpStream

impl UnwindSafe for TcpStream