Struct mio::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

A non-blocking TCP stream between a local socket and a remote socket.

The socket will be closed when the value is dropped.

Examples

use mio::{Events, Ready, Poll, PollOpt, Token};
use mio::net::TcpStream;
use std::time::Duration;

let stream = TcpStream::connect(&"127.0.0.1:34254".parse()?)?;

let poll = Poll::new()?;
let mut events = Events::with_capacity(128);

// Register the socket with `Poll`
poll.register(&stream, Token(0), Ready::writable(),
              PollOpt::edge())?;

poll.poll(&mut events, Some(Duration::from_millis(100)))?;

// The socket might be ready at this point

Methods

impl TcpStream

fn connect(addr: &SocketAddr) -> Result<TcpStream>

Create a new TCP stream and issue a non-blocking connect to the specified address.

This convenience method is available and uses the system's default options when creating a socket which is then connected. If fine-grained control over the creation of the socket is desired, you can use net2::TcpBuilder to configure a socket and then pass its socket to TcpStream::connect_stream to transfer ownership into mio and schedule the connect operation.

fn connect_stream(stream: TcpStream, addr: &SocketAddr) -> Result<TcpStream>

Creates a new TcpStream from the pending socket inside the given std::net::TcpBuilder, 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.

fn from_stream(stream: TcpStream) -> Result<TcpStream>

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

This function is intended to be used to wrap a TCP stream from the standard library in the mio equivalent. The conversion here will automatically set stream to nonblocking and the returned object should be ready to get associated with an event loop.

Note that the TCP stream here will not have connect called on it, so it should already be connected via some other means (be it manually, the net2 crate, or the standard library).

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

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

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

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

fn try_clone(&self) -> Result<TcpStream>

Creates a new independently owned handle to the underlying socket.

The returned TcpStream is a reference to the same stream that this object references. Both handles will read and write the same stream of data, and options set on one stream will be propagated to the other stream.

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

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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

Sets the value for the SO_LINGER option on this socket.

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

Gets the value of the SO_LINGER option on this socket.

For more information about this option, see set_linger.

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

Get the value of the SO_ERROR option on this socket.

This will retrieve the stored error in the underlying socket, clearing the field in the process. This can be useful for checking errors between calls.

fn read_bufs(&self, bufs: &mut [&mut IoVec]) -> Result<usize>

Read in a list of buffers all at once.

This operation will attempt to read bytes from this socket and place them into the list of buffers provided. Note that each buffer is an IoVec which can be created from a byte slice.

The buffers provided will be filled in sequentially. A buffer will be entirely filled up before the next is written to.

The number of bytes read is returned, if successful, or an error is returned otherwise. If no bytes are available to be read yet then a "would block" error is returned. This operation does not block.

On Unix this corresponds to the readv syscall.

fn write_bufs(&self, bufs: &[&IoVec]) -> Result<usize>

Write a list of buffers all at once.

This operation will attempt to write a list of byte buffers to this socket. Note that each buffer is an IoVec which can be created from a byte slice.

The buffers provided will be written sequentially. A buffer will be entirely written before the next is written.

The number of bytes written is returned, if successful, or an error is returned otherwise. If the socket is not currently writable then a "would block" error is returned. This operation does not block.

On Unix this corresponds to the writev syscall.

Trait Implementations

impl Debug for TcpStream

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Read for TcpStream

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.

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.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

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

Creates an adaptor which will chain this stream with another.

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

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.

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.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

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

Creates an adaptor which will chain this stream with another.

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

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

impl Write for TcpStream

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

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

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

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

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

Attempts to write an entire buffer into this write.

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

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

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

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

impl<'a> Write for &'a TcpStream

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

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

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

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

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

Attempts to write an entire buffer into this write.

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

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

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

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

impl Evented for TcpStream

fn register(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Register self with the given Poll instance.

fn reregister(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Re-register self with the given Poll instance.

fn deregister(&self, poll: &Poll) -> Result<()>

Deregister self from the given Poll instance

impl IntoRawFd for TcpStream

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl AsRawFd for TcpStream

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl FromRawFd for TcpStream

unsafe fn from_raw_fd(fd: RawFd) -> TcpStream

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