Struct tokio_core::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

An I/O object representing a TCP stream connected to a remote endpoint.

A TCP stream can either be created by connecting to an endpoint or by accepting a connection from a listener. Inside the stream is access to the raw underlying I/O object as well as streams for the read/write notifications on the stream itself.

Implementations

impl TcpStream

pub fn connect(addr: &SocketAddr, handle: &Handle) -> TcpStreamNew

Create a new TCP stream connected to the specified address.

This function 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. If an error happens during the connection or during the socket creation, that error will be returned to the future instead.

pub fn connect2(addr: &SocketAddr) -> TcpStreamNew

Create a new TCP stream connected to the specified address.

This is the same as connect, but uses the default reactor instead of taking an explicit &Handle.

pub fn from_stream(stream: TcpStream, handle: &Handle) -> Result<TcpStream>

Create a new TcpStream from a net::TcpStream.

This function will convert a TCP stream in the standard library to a TCP stream ready to be used with the provided event loop handle. The object returned is associated with the event loop and ready to perform I/O.

pub fn connect_stream(
    stream: TcpStream,
    addr: &SocketAddr,
    handle: &Handle
) -> Box<dyn Future<Item = TcpStream, Error = Error> + Send>

Creates a new TcpStream from the pending socket inside the given std::net::TcpStream, connecting it to the address specified.

This constructor allows configuring the socket before it's actually connected, and this function will transfer ownership to the returned TcpStream if successful. An unconnected TcpStream can be created with the net2::TcpBuilder type (and also configured via that route).

The platform specific behavior of this function looks like:

• On Unix, the socket is placed into nonblocking mode and then a connect call is issued.

• On Windows, the address is stored internally and the connect operation is issued when the returned TcpStream is registered with an event loop. Note that on Windows you must bind a socket before it can be connected, so if a custom TcpBuilder is used it should be bound (perhaps to INADDR_ANY) before this method is called.

pub fn poll_read(&self) -> Async<()>

Test whether this socket is ready to be read or not.

If the socket is not readable then the current task is scheduled to get a notification when the socket does become readable. That is, this is only suitable for calling in a Future::poll method and will automatically handle ensuring a retry once the socket is readable again.

pub fn poll_write(&self) -> Async<()>

Test whether this socket is ready to be written to or not.

If the socket is not writable then the current task is scheduled to get a notification when the socket does become writable. That is, this is only suitable for calling in a Future::poll method and will automatically handle ensuring a retry once the socket is writable again.

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

Returns the local address that this stream is bound to.

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

Returns the remote address that this stream is connected to.

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

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

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

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.

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.

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

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.

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

Gets the value of the SO_RCVBUF option on this socket.

For more information about this option, see set_recv_buffer_size.

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

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.

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

Gets the value of the SO_SNDBUF option on this socket.

For more information about this option, see set_send_buffer.

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

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.

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

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.

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.

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.

pub fn set_only_v6(&self, only_v6: bool) -> Result<()>

Sets the value for the IPV6_V6ONLY option on this socket.

If this is set to true then the socket is restricted to sending and receiving IPv6 packets only. In this case two IPv4 and IPv6 applications can bind the same port at the same time.

If this is set to false then the socket can be used to send and receive packets from an IPv4-mapped IPv6 address.

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

Gets the value of the IPV6_V6ONLY option for this socket.

For more information about this option, see set_only_v6.

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

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

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

reads the linger duration for this socket by getting the SO_LINGER option

Trait Implementations

impl AsRawFd for TcpStream

pub fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncRead for TcpStream

pub unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool

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

pub fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, Error>

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

pub fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>

Attempt to read from the AsyncRead into buf.

pub fn framed<T>(self, codec: T) -> Framed<Self, T> where
    Self: AsyncWrite,
    T: Decoder + Encoder, 

👎 Deprecated since 0.1.7:

Use tokio_codec::Decoder::framed instead

Provides a Stream and Sink interface for reading and writing to this I/O object, using Decode and Encode to read and write the raw data.

pub fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite, 

Helper method for splitting this read/write object into two halves.

impl<'a> AsyncRead for &'a TcpStream

pub unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool

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

pub fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, Error>

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

pub fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>

Attempt to read from the AsyncRead into buf.

pub fn framed<T>(self, codec: T) -> Framed<Self, T> where
    Self: AsyncWrite,
    T: Decoder + Encoder, 

👎 Deprecated since 0.1.7:

Use tokio_codec::Decoder::framed instead

Provides a Stream and Sink interface for reading and writing to this I/O object, using Decode and Encode to read and write the raw data.

pub fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite, 

Helper method for splitting this read/write object into two halves.

impl AsyncWrite for TcpStream

pub fn shutdown(&mut self) -> Poll<(), Error>

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

pub fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, Error>

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

pub fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>

Attempt to write bytes from buf into the object.

pub fn poll_flush(&mut self) -> Result<Async<()>, Error>

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

impl<'a> AsyncWrite for &'a TcpStream

pub fn shutdown(&mut self) -> Poll<(), Error>

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

pub fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, Error>

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

pub fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>

Attempt to write bytes from buf into the object.

pub fn poll_flush(&mut self) -> Result<Async<()>, Error>

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

impl Debug for TcpStream

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

Formats the value using the given formatter.

impl Read for TcpStream

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

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

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

pub unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

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

impl<'a> Read for &'a TcpStream

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

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

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

pub unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

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

impl Write for TcpStream

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

Write a buffer into this writer, returning how many bytes were written.

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

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

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

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

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

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

Attempts to write an entire buffer into this writer.

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

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

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

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

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

impl<'a> Write for &'a TcpStream

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

Write a buffer into this writer, returning how many bytes were written.

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

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

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

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

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

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

Attempts to write an entire buffer into this writer.

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

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

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

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

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