Struct TcpStream 

pub struct TcpStream {
    pub stream: TcpStream,
    pub extensions: Extensions,
    /* private fields */
}

Available on crate features std and tcp only.

A TCP stream with its Extensions.

It publishes an AbortIo in its own extensions: once called, dropping the stream sends a TCP RST instead of a FIN: SO_LINGER 0 only takes effect on close, which is the owner’s to do.

Fields

stream: TcpStream

extensions: Extensions

Implementations

impl TcpStream

pub fn new(stream: TcpStream) -> TcpStream

pub fn try_from_socket( socket: Socket, extensions: Extensions, ) -> Result<TcpStream, Error>

Available on target_family=unix or Windows only.

Convert an already usable TCP socket into a Rama TcpStream.

This is a synchronous adapter. It sets the socket to non-blocking mode and registers it with Tokio, but it does not complete a pending non-blocking connect(2).

Use TcpStream::try_from_connecting_socket when connect returned an in-progress error such as EINPROGRESS or WouldBlock; that async constructor waits for connect completion and checks the pending socket error before returning.

pub async fn try_from_connecting_socket( socket: Socket, extensions: Extensions, ) -> Result<TcpStream, Error>

Available on target_family=unix or Windows only.

Convert a TCP socket with a pending non-blocking connect into a Rama TcpStream, then wait for the connect attempt to complete.

Call this after invoking connect on a non-blocking socket when the OS reports that the connect is in progress. This mirrors Tokio’s own TCP connect flow: wait for write-readiness, then inspect the pending socket error with SO_ERROR.

pub async fn try_from_connecting_socket_with_timeout( socket: Socket, extensions: Extensions, timeout: Duration, ) -> Result<TcpStream, Error>

Available on target_family=unix or Windows only.

Convert a TCP socket with a pending non-blocking connect into a Rama TcpStream, then wait up to timeout for the connect attempt to complete.

If the timeout elapses, the stream is dropped and io::ErrorKind::TimedOut is returned.

Example

use rama_core::extensions::Extensions;
use rama_net::socket::core::{Domain, Protocol, Socket, Type};
use rama_tcp::TcpStream;
use std::{io, net::SocketAddr, time::Duration};

async fn connect_with_bound() -> io::Result<TcpStream> {
    // TEST-NET-1 documentation address; useful for examples because it
    // should not identify a real Internet host.
    let addr: SocketAddr = "192.0.2.1:80".parse().unwrap();
    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP))?;
    socket.set_nonblocking(true)?;

    match socket.connect(&addr.into()) {
        Ok(()) => {}
        Err(err)
            if matches!(
                err.kind(),
                io::ErrorKind::WouldBlock | io::ErrorKind::AlreadyExists
            ) => {}
        Err(err) => return Err(err),
    }

    TcpStream::try_from_connecting_socket_with_timeout(
        socket,
        Extensions::new(),
        Duration::from_secs(10),
    )
    .await
}

pub async fn finish_connect(self) -> Result<TcpStream, Error>

Wait for a pending non-blocking connect on this stream to complete.

Write-readiness signals that the connect attempt has finished, either successfully or with an error. The pending socket error is checked before success is returned.

pub async fn finish_connect_with_timeout( self, timeout: Duration, ) -> Result<TcpStream, Error>

Wait up to timeout for a pending non-blocking connect on this stream to complete.

If the timeout elapses, the stream is dropped and io::ErrorKind::TimedOut is returned.

pub fn try_from_std_tcp_stream( stream: TcpStream, extensions: Extensions, ) -> Result<TcpStream, Error>

Convert an already usable standard TCP stream into a Rama TcpStream.

This is a synchronous adapter. It does not complete a pending non-blocking connect; use TcpStream::finish_connect after conversion when the stream represents an in-progress connect attempt.

pub fn from_tokio_tcp_stream( stream: TcpStream, extensions: Extensions, ) -> TcpStream

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 AsSocketRef for TcpStream

Available on target_family=unix or Windows only.

fn as_socket_ref(&self) -> SockRef<'_>

Return a non-owning reference to this socket.

impl AsyncRead for TcpStream

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

Attempts to read from the AsyncRead into buf.

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_vectored( self: Pin<&mut TcpStream>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

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

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

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl Debug for TcpStream

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

Formats the value using the given formatter.

impl Drop for TcpStream

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl ExtensionsRef for TcpStream

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

impl From<TcpStream> for TcpStream

fn from(value: TcpStream) -> TcpStream

Converts to this type from the input type.

impl From<TcpStream> for TcpStream

fn from(value: TcpStream) -> TcpStream

The caller takes over the socket, and with it how it closes.

impl RawTcpStream for TcpStream

impl Socket for TcpStream

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

Try to get the local address of the socket.

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

Try to get the remote address of the socket.

impl<'__pin> Unpin for TcpStream

where <PinnedFieldsOfHelperStruct<__Origin<'__pin>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,