Struct TcpStream 

pub struct TcpStream { /* private fields */ }

A TCP stream between a local and a remote socket.

The socket will be closed when the value is dropped.

The read and write methods can be interrupted using the Canceller object created with the stream.

Otherwise similar to std::net::TcpStream.

Implementations

impl TcpStream

pub fn connect<A: ToSocketAddrs>(address: A) -> Result<(Self, Canceller)>

Creates a new TCP stream with an object used to cancel read/write operations, and connects it to a remote address.

Examples found in repository

examples/example1.rs (line 38)

fn main() {
    let (listener, listener_canceller) = TcpListener::bind("127.0.0.1:0").unwrap();
    let address = listener.local_addr().unwrap();
    let server = thread::spawn(move || {
        println!("Server: ready");
        let (mut socket, socket_canceller, addr) = listener.accept().unwrap();
        println!("Server: got connection from {}", addr);

        let connection = thread::spawn(move || {
            println!("Connection: ready");
            let mut buf = [0; 16];
            let len = socket.read(&mut buf).unwrap();
            println!("Connection: read {}", String::from_utf8_lossy(&buf[..len]));
            println!("Connection: try reading more.");
            match socket.read(&mut buf) {
                Ok(0) => println!("Connection: socket closed."),
                Err(ref e) if is_cancelled(e) => println!("Connection: cancelled."),
                ref e => panic!("Connection: unexpected {:?}", e),
            }
        });

        println!("Server: try accepting more.");
        if is_cancelled(&listener.accept().unwrap_err()) {
            println!("Server: accept cancelled.");
        }

        socket_canceller.cancel().unwrap();
        connection.join().unwrap();
    });

    thread::sleep(Duration::from_secs(2));
    let (mut socket, socket_canceller) = TcpStream::connect(&address).unwrap();
    let client = thread::spawn(move || {
        println!("Client: ready");
        thread::sleep(Duration::from_secs(2));
        println!("Client: write data.");
        socket.write(b"Hello!").unwrap();
        println!("Client: try reading.");
        let mut buf = [0; 16];
        match socket.read(&mut buf) {
            Ok(0) => println!("Client: socket closed."),
            Err(ref e) if is_cancelled(e) => println!("Client: cancelled."),
            ref e => panic!("Client: unexpected {:?}", e),
        }
    });

    thread::sleep(Duration::from_secs(4));
    socket_canceller.cancel().unwrap();
    thread::sleep(Duration::from_secs(2));
    listener_canceller.cancel().unwrap();

    server.join().unwrap();
    client.join().unwrap();
}

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

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

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

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

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

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

pub fn try_clone(&self) -> Result<(Self, Canceller)>

Creates a new independently owned handle to the underlying socket. The Cancellers associated with the original object and its clone are also independent.

pub fn set_read_timeout(&self, duration: Option<Duration>) -> Result<()>

Sets the read timeout.

pub fn set_write_timeout(&self, duration: Option<Duration>) -> Result<()>

Sets the write timeout.

pub fn read_timeout(&self) -> Result<Option<Duration>>

Gets the read timeout.

pub fn write_timeout(&self) -> Result<Option<Duration>>

Gets the write timeout.

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

Sets the value of the TCP_NODELAY option on this socket.

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

Gets the value of the TCP_NODELAY option for this socket.

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

Sets the value for the IP_TTL option on this socket.

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

Gets the value for the IP_TTL option for this socket.

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

Gets the value of the SO_ERROR option for this socket.

pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()>

Moves this TCP stream into or out of nonblocking mode.

Trait Implementations

impl Debug for TcpStream

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

Formats the value using the given formatter.

impl Read for TcpStream

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Reads data from the socket. This operation can be cancelled by the associated Canceller object.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

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

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

impl Write for TcpStream

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes data to the socket. This operation can be cancelled by the associated Canceller object.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

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

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

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

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.