Struct TcpStream 

pub struct TcpStream { /* private fields */ }

Available on crate feature net only.

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.

Examples

use std::net::SocketAddr;

use compio_io::AsyncWrite;
use compio_net::TcpStream;

// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await.unwrap();

// Write some data.
stream.write("hello world!").await.unwrap();

Implementations

impl TcpStream

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

Opens a TCP connection to a remote host.

To configure the socket before connecting, you can use the TcpSocket type.

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

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

pub fn close(self) -> impl Future<Output = Result<(), Error>>

Close the socket. If the returned future is dropped before polling, the socket won’t be closed.

As the socket is clonable, users can call close on a clone, but the future will never complete until all clones are dropped. Some operations may keep a strong reference to the socket, so the future may never complete if there are pending operations.

It’s OK to drop the socket directly without calling close, but the socket may not be closed immediately.

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

Returns the socket address of the remote peer of this TCP connection.

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

Returns the socket address of the local half of this TCP connection.

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

Returns the value of the SO_ERROR option.

pub fn split(&self) -> (ReadHalf<'_, TcpStream>, WriteHalf<'_, TcpStream>)

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) -> (TcpStream, TcpStream)

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.

pub fn to_poll_fd(&self) -> Result<PollFd<Socket>, Error>

Create PollFd from inner socket.

pub fn into_poll_fd(self) -> Result<PollFd<Socket>, Error>

Create PollFd from inner socket.

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 TcpStream::set_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.

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

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

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

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

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

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl_v4.

pub fn set_ttl_v4(&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.

pub async fn send_out_of_band<T>(&self, buf: T) -> BufResult<usize, T>

where T: IoBuf,

Sends out-of-band data on this socket.

Out-of-band data is sent with the MSG_OOB flag.

Trait Implementations

impl AsFd for TcpStream

Available on Unix only.

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

async fn read<B>(&mut self, buf: B) -> BufResult<usize, B>

where B: IoBufMut,

Read some bytes from this source into the IoBufMut buffer and return a BufResult, consisting of the buffer and a usize indicating how many bytes were read.

async fn read_vectored<V>(&mut self, buf: V) -> BufResult<usize, V>

where V: IoVectoredBufMut,

Like read, except that it reads into a type implements IoVectoredBufMut.

impl AsyncRead for TcpStream

async fn read<B>(&mut self, buf: B) -> BufResult<usize, B>

where B: IoBufMut,

Read some bytes from this source into the IoBufMut buffer and return a BufResult, consisting of the buffer and a usize indicating how many bytes were read.

async fn read_vectored<V>(&mut self, buf: V) -> BufResult<usize, V>

where V: IoVectoredBufMut,

Like read, except that it reads into a type implements IoVectoredBufMut.

impl AsyncReadAncillary for &TcpStream

async fn read_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<(usize, usize), (T, C)>

where T: IoBufMut, C: IoBufMut,

Read data with ancillary data into an owned buffer.

async fn read_vectored_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<(usize, usize), (T, C)>

where T: IoVectoredBufMut, C: IoBufMut,

Read data with ancillary data into a vectored buffer.

impl AsyncReadAncillary for TcpStream

async fn read_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<(usize, usize), (T, C)>

where T: IoBufMut, C: IoBufMut,

Read data with ancillary data into an owned buffer.

async fn read_vectored_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<(usize, usize), (T, C)>

where T: IoVectoredBufMut, C: IoBufMut,

Read data with ancillary data into a vectored buffer.

impl AsyncReadAncillaryManaged for &TcpStream

async fn read_managed_with_ancillary<C>( &mut self, len: usize, control: C, ) -> Result<Option<(<&TcpStream as AsyncReadManaged>::Buffer, C)>, Error>

where C: IoBufMut,

Read data into a managed buffer with ancillary data.

impl AsyncReadAncillaryManaged for TcpStream

async fn read_managed_with_ancillary<C>( &mut self, len: usize, control: C, ) -> Result<Option<(<TcpStream as AsyncReadManaged>::Buffer, C)>, Error>

where C: IoBufMut,

Read data into a managed buffer with ancillary data.

impl AsyncReadAncillaryMulti for &TcpStream

type Return = RecvMsgMultiResult

A wrapped type for the payload data and the ancillary data.

fn read_multi_with_ancillary( &mut self, control_len: usize, ) -> impl Stream<Item = Result<<&TcpStream as AsyncReadAncillaryMulti>::Return, Error>>

Read data and ancillary data into multiple managed buffers.

impl AsyncReadAncillaryMulti for TcpStream

type Return = RecvMsgMultiResult

A wrapped type for the payload data and the ancillary data.

fn read_multi_with_ancillary( &mut self, control_len: usize, ) -> impl Stream<Item = Result<<TcpStream as AsyncReadAncillaryMulti>::Return, Error>>

Read data and ancillary data into multiple managed buffers.

impl AsyncReadManaged for &TcpStream

type Buffer = BufferRef

Filled buffer type

async fn read_managed( &mut self, len: usize, ) -> Result<Option<<&TcpStream as AsyncReadManaged>::Buffer>, Error>

Read some bytes from this source and return a Self::Buffer.

impl AsyncReadManaged for TcpStream

type Buffer = BufferRef

Filled buffer type

async fn read_managed( &mut self, len: usize, ) -> Result<Option<<TcpStream as AsyncReadManaged>::Buffer>, Error>

Read some bytes from this source and return a Self::Buffer.

impl AsyncReadMulti for &TcpStream

fn read_multi( &mut self, len: usize, ) -> impl Stream<Item = Result<<&TcpStream as AsyncReadManaged>::Buffer, Error>>

Read some bytes from this source and return a stream of AsyncReadManaged::Buffer.

impl AsyncReadMulti for TcpStream

fn read_multi( &mut self, len: usize, ) -> impl Stream<Item = Result<<TcpStream as AsyncReadManaged>::Buffer, Error>>

Read some bytes from this source and return a stream of AsyncReadManaged::Buffer.

impl AsyncWrite for &TcpStream

async fn write<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoBuf,

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn write_vectored<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoVectoredBuf,

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

async fn flush(&mut self) -> Result<(), Error>

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

async fn shutdown(&mut self) -> Result<(), Error>

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

impl AsyncWrite for TcpStream

async fn write<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoBuf,

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn write_vectored<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoVectoredBuf,

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

async fn flush(&mut self) -> Result<(), Error>

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

async fn shutdown(&mut self) -> Result<(), Error>

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

impl AsyncWriteAncillary for &TcpStream

async fn write_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<usize, (T, C)>

where T: IoBuf, C: IoBuf,

Write data with ancillary data from an owned buffer.

async fn write_vectored_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<usize, (T, C)>

where T: IoVectoredBuf, C: IoBuf,

Write data with ancillary data from a vectored buffer.

impl AsyncWriteAncillary for TcpStream

async fn write_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<usize, (T, C)>

where T: IoBuf, C: IoBuf,

Write data with ancillary data from an owned buffer.

async fn write_vectored_with_ancillary<T, C>( &mut self, buffer: T, control: C, ) -> BufResult<usize, (T, C)>

where T: IoVectoredBuf, C: IoBuf,

Write data with ancillary data from a vectored buffer.

impl AsyncWriteAncillaryZerocopy for &TcpStream

type BufferReadyFuture<T: IoBuf, C: IoBuf> = Extract<Zerocopy<SendMsg<[T; 1], C, SharedFd<Socket>>>, T, C>

The future that will be resolved when the buffer is safe to be reused.

type VectoredBufferReadyFuture<T: IoVectoredBuf, C: IoBuf> = Zerocopy<SendMsg<T, C, SharedFd<Socket>>>

The future that will be resolved when the vectored buffer is safe to be reused.

async fn write_zerocopy_with_ancillary<T, C>( &mut self, buf: T, control: C, ) -> BufResult<usize, <&TcpStream as AsyncWriteAncillaryZerocopy>::BufferReadyFuture<T, C>>

where T: IoBuf, C: IoBuf,

Write some bytes from buffer into this source using the underlying zero-copy mechanism. It returns a result of the underlying write operation and a future that will be resolved when the buffer is safe to be reused.

async fn write_zerocopy_vectored_with_ancillary<T, C>( &mut self, buf: T, control: C, ) -> BufResult<usize, <&TcpStream as AsyncWriteAncillaryZerocopy>::VectoredBufferReadyFuture<T, C>>

where T: IoVectoredBuf, C: IoBuf,

Like write_zerocopy_with_ancillary, except that it writes from a buffer implements IoVectoredBuf into the source.

impl AsyncWriteAncillaryZerocopy for TcpStream

type BufferReadyFuture<T: IoBuf, C: IoBuf> = Extract<Zerocopy<SendMsg<[T; 1], C, SharedFd<Socket>>>, T, C>

The future that will be resolved when the buffer is safe to be reused.

type VectoredBufferReadyFuture<T: IoVectoredBuf, C: IoBuf> = Zerocopy<SendMsg<T, C, SharedFd<Socket>>>

The future that will be resolved when the vectored buffer is safe to be reused.

async fn write_zerocopy_with_ancillary<T, C>( &mut self, buf: T, control: C, ) -> BufResult<usize, <TcpStream as AsyncWriteAncillaryZerocopy>::BufferReadyFuture<T, C>>

where T: IoBuf, C: IoBuf,

Write some bytes from buffer into this source using the underlying zero-copy mechanism. It returns a result of the underlying write operation and a future that will be resolved when the buffer is safe to be reused.

async fn write_zerocopy_vectored_with_ancillary<T, C>( &mut self, buf: T, control: C, ) -> BufResult<usize, <TcpStream as AsyncWriteAncillaryZerocopy>::VectoredBufferReadyFuture<T, C>>

where T: IoVectoredBuf, C: IoBuf,

Like write_zerocopy_with_ancillary, except that it writes from a buffer implements IoVectoredBuf into the source.

impl AsyncWriteZerocopy for &TcpStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

The future that will be resolved when the buffer is safe to be reused.

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

The future that will be resolved when the vectored buffer is safe to be reused.

async fn write_zerocopy<T>( &mut self, buf: T, ) -> BufResult<usize, <&TcpStream as AsyncWriteZerocopy>::BufferReadyFuture<T>>

where T: IoBuf,

Write some bytes from buffer into this source using the underlying zero-copy mechanism. It returns a result of the underlying write operation and a future that will be resolved when the buffer is safe to be reused.

async fn write_zerocopy_vectored<T>( &mut self, buf: T, ) -> BufResult<usize, <&TcpStream as AsyncWriteZerocopy>::VectoredBufferReadyFuture<T>>

where T: IoVectoredBuf,

Like write_zerocopy, except that it writes from a buffer implements IoVectoredBuf into the source.

impl AsyncWriteZerocopy for TcpStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

The future that will be resolved when the buffer is safe to be reused.

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

The future that will be resolved when the vectored buffer is safe to be reused.

async fn write_zerocopy<T>( &mut self, buf: T, ) -> BufResult<usize, <TcpStream as AsyncWriteZerocopy>::BufferReadyFuture<T>>

where T: IoBuf,

Write some bytes from buffer into this source using the underlying zero-copy mechanism. It returns a result of the underlying write operation and a future that will be resolved when the buffer is safe to be reused.

async fn write_zerocopy_vectored<T>( &mut self, buf: T, ) -> BufResult<usize, <TcpStream as AsyncWriteZerocopy>::VectoredBufferReadyFuture<T>>

where T: IoVectoredBuf,

Like write_zerocopy, except that it writes from a buffer implements IoVectoredBuf into the source.

impl Clone for TcpStream

fn clone(&self) -> TcpStream

Returns a duplicate 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 FromRawFd for TcpStream

Available on Unix only.

unsafe fn from_raw_fd(fd: i32) -> TcpStream

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

impl<'a> Splittable for &'a TcpStream

type ReadHalf = ReadHalf<'a, TcpStream>

The type of the read half, which normally implements AsyncRead or AsyncReadAt.

type WriteHalf = WriteHalf<'a, TcpStream>

The type of the write half, which normally implements AsyncWrite or AsyncWriteAt.

fn split( self, ) -> (<&'a TcpStream as Splittable>::ReadHalf, <&'a TcpStream as Splittable>::WriteHalf)

Consumes self and returns a tuple containing separate read and write halves.

impl<'a> Splittable for &'a mut TcpStream

type ReadHalf = ReadHalf<'a, TcpStream>

The type of the read half, which normally implements AsyncRead or AsyncReadAt.

type WriteHalf = WriteHalf<'a, TcpStream>

The type of the write half, which normally implements AsyncWrite or AsyncWriteAt.

fn split( self, ) -> (<&'a mut TcpStream as Splittable>::ReadHalf, <&'a mut TcpStream as Splittable>::WriteHalf)

Consumes self and returns a tuple containing separate read and write halves.

impl Splittable for TcpStream

type ReadHalf = TcpStream

The type of the read half, which normally implements AsyncRead or AsyncReadAt.

type WriteHalf = TcpStream

The type of the write half, which normally implements AsyncWrite or AsyncWriteAt.

fn split( self, ) -> (<TcpStream as Splittable>::ReadHalf, <TcpStream as Splittable>::WriteHalf)

Consumes self and returns a tuple containing separate read and write halves.

impl ToSharedFd<Socket> for TcpStream

fn to_shared_fd(&self) -> SharedFd<Socket>

Return a cloned SharedFd.