Struct async_std::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

A TCP stream between a local and a remote socket.

A TcpStream can either be created by connecting to an endpoint, via the connect method, or by accepting a connection from a listener. It can be read or written to using the AsyncRead, AsyncWrite, and related extension traits in futures::io.

The connection will be closed when the value is dropped. The reading and writing portions of the connection can also be shut down individually with the shutdown method.

This type is an async version of std::net::TcpStream.

Examples

use async_std::net::TcpStream;
use async_std::prelude::*;

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

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

Methods

impl TcpStream

pub async fn connect<A: ToSocketAddrs>(addrs: A) -> Result<TcpStream>

Creates a new TCP stream connected to the specified address.

This method will create a new TCP socket and attempt to connect it to the addr provided. The returned future will be resolved once the stream has successfully connected, or it will return an error if one occurs.

Examples

use async_std::net::TcpStream;

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

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

Returns the local address that this stream is connected to.

Examples

use async_std::net::TcpStream;

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

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

Returns the remote address that this stream is connected to.

Examples

use async_std::net::TcpStream;

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

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

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

Examples

use async_std::net::TcpStream;

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

stream.set_ttl(100)?;
assert_eq!(stream.ttl()?, 100);

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

Sets the value for the IP_TTL option on this socket.

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

Examples

use async_std::net::TcpStream;

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

stream.set_ttl(100)?;
assert_eq!(stream.ttl()?, 100);

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

Receives data on the socket from the remote address to which it is connected, without removing that data 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_std::net::TcpStream;

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

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

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

Gets the value of the TCP_NODELAY option on this socket.

For more information about this option, see set_nodelay.

Examples

use async_std::net::TcpStream;

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

stream.set_nodelay(true)?;
assert_eq!(stream.nodelay()?, true);

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

Sets the value of the TCP_NODELAY option on this socket.

If set, this option disables the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets.

Examples

use async_std::net::TcpStream;

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

stream.set_nodelay(true)?;
assert_eq!(stream.nodelay()?, true);

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

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

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

Examples

use std::net::Shutdown;

use async_std::net::TcpStream;

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

Trait Implementations

impl Read for TcpStream

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

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>>

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

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads some bytes from the byte stream.

fn read_vectored<'a>(
    &'a mut self,
    bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Like [read], except that it reads into a slice of buffers.

fn read_to_end<'a>(
    &'a mut self,
    buf: &'a mut Vec<u8>
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads all bytes from the byte stream.

fn read_to_string<'a>(
    &'a mut self,
    buf: &'a mut String
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads all bytes from the byte stream and appends them into a string.

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Reads the exact number of bytes required to fill buf.

fn take(self, limit: u64) -> Take<Self> where
    Self: Sized, 

Creates an adaptor which will read at most limit bytes from it.

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self> where
    Self: Sized, 

Transforms this Read instance to a Stream over its bytes.

fn chain<R: Read>(self, next: R) -> Chain<Self, R> where
    Self: Sized, 

Creates an adaptor which will chain this stream with another.

impl<'_> Read for &'_ TcpStream

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

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>>

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

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads some bytes from the byte stream.

fn read_vectored<'a>(
    &'a mut self,
    bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Like [read], except that it reads into a slice of buffers.

fn read_to_end<'a>(
    &'a mut self,
    buf: &'a mut Vec<u8>
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads all bytes from the byte stream.

fn read_to_string<'a>(
    &'a mut self,
    buf: &'a mut String
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Reads all bytes from the byte stream and appends them into a string.

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Reads the exact number of bytes required to fill buf.

fn take(self, limit: u64) -> Take<Self> where
    Self: Sized, 

Creates an adaptor which will read at most limit bytes from it.

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self> where
    Self: Sized, 

Transforms this Read instance to a Stream over its bytes.

fn chain<R: Read>(self, next: R) -> Chain<Self, R> where
    Self: Sized, 

Creates an adaptor which will chain this stream with another.

impl Write for TcpStream

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

Attempt to write bytes from buf into the object.

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

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

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

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

fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to close the object.

fn write<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Writes some bytes into the byte stream.

fn flush(&mut self) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Flushes the stream to ensure that all buffered contents reach their destination.

fn write_vectored<'a>(
    &'a mut self,
    bufs: &'a [IoSlice<'a>]
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Like [write], except that it writes from a slice of buffers.

fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Writes an entire buffer into the byte stream.

fn write_fmt<'a>(&'a mut self, fmt: Arguments) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Writes a formatted string into this writer, returning any error encountered.

impl<'_> Write for &'_ TcpStream

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

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

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

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

Attempt to close the object.

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

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

fn write<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Writes some bytes into the byte stream.

fn flush(&mut self) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Flushes the stream to ensure that all buffered contents reach their destination.

fn write_vectored<'a>(
    &'a mut self,
    bufs: &'a [IoSlice<'a>]
) -> ImplFuture<Result<usize>> where
    Self: Unpin, 

Like [write], except that it writes from a slice of buffers.

fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Writes an entire buffer into the byte stream.

fn write_fmt<'a>(&'a mut self, fmt: Arguments) -> ImplFuture<Result<()>> where
    Self: Unpin, 

Writes a formatted string into this writer, returning any error encountered.

impl AsRawFd for TcpStream

fn as_raw_fd(&self) -> RawFd

This is supported on Unix only.

Extracts the raw file descriptor.

impl FromRawFd for TcpStream

unsafe fn from_raw_fd(fd: RawFd) -> TcpStream

This is supported on Unix only.

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

impl IntoRawFd for TcpStream

fn into_raw_fd(self) -> RawFd

This is supported on Unix only.

Consumes this object, returning the raw underlying file descriptor.

impl From<TcpStream> for TcpStream

fn from(stream: TcpStream) -> TcpStream

Converts a std::net::TcpStream into its asynchronous equivalent.

impl Debug for TcpStream

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

Formats the value using the given formatter.