Struct actix_rt::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

A TCP stream between a local and a remote socket.

A TCP stream can either be created by connecting to an endpoint, via the connect method, or by accepting a connection from a listener.

Reading and writing to a TcpStream is usually done using the convenience methods found on the AsyncReadExt and AsyncWriteExt traits. Examples import these traits through the prelude.

Examples

use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;

    // Write some data.
    stream.write_all(b"hello world!").await?;

    Ok(())
}

The write_all method is defined on the AsyncWriteExt trait.

Methods

impl TcpStream

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

Opens a TCP connection to a remote host.

addr is an address of the remote host. Anything which implements ToSocketAddrs trait can be supplied for the address.

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

Examples

use tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;

    // Write some data.
    stream.write_all(b"hello world!").await?;

    Ok(())
}

The write_all method is defined on the AsyncWriteExt trait.

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

Creates new TcpStream from a std::net::TcpStream.

This function will convert a TCP stream created by the standard library to a TCP stream ready to be used with the provided event loop handle.

Examples

use std::error::Error;
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let std_stream = std::net::TcpStream::connect("127.0.0.1:34254")?;
    let stream = TcpStream::from_std(std_stream)?;
    Ok(())
}

Panics

This function panics if thread-local runtime is not set.

The runtime is usually set implicitly when this function is called from a future driven by a tokio runtime, otherwise runtime can be set explicitly with Handle::enter function.

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

Returns the local address that this stream is bound to.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.local_addr()?);

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

Returns the remote address that this stream is connected to.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.peer_addr()?);

pub fn poll_peek(
    &mut self,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize, Error>>

Attempts to receive data on the socket, without removing that data from the queue, registering the current task for wakeup if data is not yet available.

Return value

The function returns:

• Poll::Pending if data is not yet available.
• Poll::Ready(Ok(n)) if data is available. n is the number of bytes peeked.
• Poll::Ready(Err(e)) if an error is encountered.

Errors

This function may encounter any standard I/O error except WouldBlock.

Examples

use tokio::io;
use tokio::net::TcpStream;

use futures::future::poll_fn;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8000").await?;
    let mut buf = [0; 10];

    poll_fn(|cx| {
        stream.poll_peek(cx, &mut buf)
    }).await?;

    Ok(())
}

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

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 tokio::net::TcpStream;
use tokio::prelude::*;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;

    let mut b1 = [0; 10];
    let mut b2 = [0; 10];

    // Peek at the data
    let n = stream.peek(&mut b1).await?;

    // Read the data
    assert_eq!(n, stream.read(&mut b2[..n]).await?);
    assert_eq!(&b1[..n], &b2[..n]);

    Ok(())
}

The read method is defined on the AsyncReadExt trait.

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

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

This function 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 tokio::net::TcpStream;
use std::error::Error;
use std::net::Shutdown;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    let stream = TcpStream::connect("127.0.0.1:8080").await?;

    // Shutdown the stream
    stream.shutdown(Shutdown::Write)?;

    Ok(())
}

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

Gets the value of the TCP_NODELAY option on this socket.

For more information about this option, see set_nodelay.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.nodelay()?);

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

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

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

stream.set_nodelay(true)?;

pub fn recv_buffer_size(&self) -> Result<usize, Error>

Gets the value of the SO_RCVBUF option on this socket.

For more information about this option, see set_recv_buffer_size.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.recv_buffer_size()?);

pub fn set_recv_buffer_size(&self, size: usize) -> Result<(), Error>

Sets the value of the SO_RCVBUF option on this socket.

Changes the size of the operating system's receive buffer associated with the socket.

Examples

use tokio::net::TcpStream;

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

stream.set_recv_buffer_size(100)?;

pub fn send_buffer_size(&self) -> Result<usize, Error>

Gets the value of the SO_SNDBUF option on this socket.

For more information about this option, see set_send_buffer_size.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.send_buffer_size()?);

pub fn set_send_buffer_size(&self, size: usize) -> Result<(), Error>

Sets the value of the SO_SNDBUF option on this socket.

Changes the size of the operating system's send buffer associated with the socket.

Examples

use tokio::net::TcpStream;

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

stream.set_send_buffer_size(100)?;

pub fn keepalive(&self) -> Result<Option<Duration>, Error>

Returns whether keepalive messages are enabled on this socket, and if so the duration of time between them.

For more information about this option, see set_keepalive.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.keepalive()?);

pub fn set_keepalive(&self, keepalive: Option<Duration>) -> Result<(), Error>

Sets whether keepalive messages are enabled to be sent on this socket.

On Unix, this option will set the SO_KEEPALIVE as well as the TCP_KEEPALIVE or TCP_KEEPIDLE option (depending on your platform). On Windows, this will set the SIO_KEEPALIVE_VALS option.

If None is specified then keepalive messages are disabled, otherwise the duration specified will be the time to remain idle before sending a TCP keepalive probe.

Some platforms specify this value in seconds, so sub-second specifications may be omitted.

Examples

use tokio::net::TcpStream;

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

stream.set_keepalive(None)?;

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

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.ttl()?);

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

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

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

stream.set_ttl(123)?;

pub fn linger(&self) -> Result<Option<Duration>, Error>

Reads the linger duration for this socket by getting the SO_LINGER option.

For more information about this option, see set_linger.

Examples

use tokio::net::TcpStream;

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

println!("{:?}", stream.linger()?);

pub fn set_linger(&self, dur: Option<Duration>) -> Result<(), Error>

Sets the linger duration of this socket by setting the SO_LINGER option.

This option controls the action taken when a stream has unsent messages and the stream is closed. If SO_LINGER is set, the system shall block the process until it can transmit the data or until the time expires.

If SO_LINGER is not specified, and the stream is closed, the system handles the call in a way that allows the process to continue as quickly as possible.

Examples

use tokio::net::TcpStream;

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

stream.set_linger(None)?;

pub fn split(&mut self) -> (ReadHalf, WriteHalf)

Splits a TcpStream into a read half and a write half, which can be used to read and write the stream concurrently.

This method is more efficient than into_split, but the halves cannot be moved into independently spawned tasks.

pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf)

Splits a TcpStream into a read half and a write half, which can be used to read and write the stream concurrently.

Unlike split, the owned halves can be moved to separate tasks, however this comes at the cost of a heap allocation.

Trait Implementations

impl AsRawFd for TcpStream

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl AsyncRead for TcpStream

unsafe fn prepare_uninitialized_buffer(&self, &mut [MaybeUninit<u8>]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

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

Attempts to read from the AsyncRead into buf.

fn poll_read_buf<B>(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut B
) -> Poll<Result<usize, Error>> where
    B: BufMut, 

Pulls some bytes from this source into the specified BufMut, returning how many bytes were read.

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_write_buf<B>(
    self: Pin<&mut TcpStream>,
    cx: &mut Context,
    buf: &mut B
) -> Poll<Result<usize, Error>> where
    B: Buf, 

Writes a Buf into this value, returning how many bytes were written.

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

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

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

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

impl Debug for TcpStream

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

Formats the value using the given formatter.

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, <TcpStream as TryFrom<TcpStream>>::Error>

Consumes stream, returning the tokio I/O object.

This is equivalent to TcpStream::from_std(stream).