# [−][src]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`[src]

#### `pub fn connect(addr: &SocketAddr) -> Result<TcpStream>`[src]

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.

#### `pub fn connect_stream(stream: TcpStream, addr: &SocketAddr) -> Result<TcpStream>`[src]

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.

#### `pub fn from_stream(stream: TcpStream) -> Result<TcpStream>`[src]

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

#### `pub fn peer_addr(&self) -> Result<SocketAddr>`[src]

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

#### `pub fn local_addr(&self) -> Result<SocketAddr>`[src]

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

#### `pub fn try_clone(&self) -> Result<TcpStream>`[src]

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.

#### `pub fn shutdown(&self, how: Shutdown) -> Result<()>`[src]

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<()>`[src]

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>`[src]

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<()>`[src]

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>`[src]

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<()>`[src]

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>`[src]

Gets the value of the `SO_SNDBUF` option on this socket.

For more information about this option, see `set_send_buffer_size`.

#### `pub fn set_keepalive(&self, keepalive: Option<Duration>) -> Result<()>`[src]

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>>`[src]

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<()>`[src]

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>`[src]

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<()>`[src]

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>`[src]

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<()>`[src]

Sets the value for the `SO_LINGER` option on this socket.

#### `pub fn linger(&self) -> Result<Option<Duration>>`[src]

Gets the value of the `SO_LINGER` option on this socket.

For more information about this option, see `set_linger`.

#### `pub fn take_error(&self) -> Result<Option<Error>>`[src]

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.

#### `pub fn peek(&self, buf: &mut [u8]) -> Result<usize>`[src]

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 read_bufs(&self, bufs: &mut [&mut IoVec]) -> Result<usize>`[src]

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.

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

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 Evented for TcpStream`[src]

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

Register `self` with the given `Poll` instance. Read more

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

Re-register `self` with the given `Poll` instance. Read more

#### `fn deregister(&self, poll: &Poll) -> Result<()>`[src]

Deregister `self` from the given `Poll` instance Read more

### `impl Debug for TcpStream`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl Read for TcpStream`[src]

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

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

#### `fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>`1.36.0[src]

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

#### `unsafe fn initializer(&self) -> Initializer`[src]

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

Determines if this `Read`er can work with buffers of uninitialized memory. Read more

#### `fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>`1.0.0[src]

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

#### `fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>`1.0.0[src]

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

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

Read the exact number of bytes required to fill `buf`. Read more

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn by_ref(&mut self) -> &mut Self` 1.0.0[src]

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

#### `fn bytes(self) -> Bytes<Self>`1.0.0[src]

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

####
ⓘImportant traits for Chain<T, U>

### Important traits for Chain<T, U>

`impl<T, U> Read for Chain<T, U> where
T: Read,
U: Read,`
`fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,` 1.0.0[src]

Creates an adaptor which will chain this stream with another. Read more

####
ⓘImportant traits for Take<T>

### Important traits for Take<T>

`impl<T> Read for Take<T> where
T: Read,`
`fn take(self, limit: u64) -> Take<Self>`1.0.0[src]

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

### `impl<'a> Read for &'a TcpStream`[src]

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

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

#### `fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>`1.36.0[src]

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

#### `unsafe fn initializer(&self) -> Initializer`[src]

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

Determines if this `Read`er can work with buffers of uninitialized memory. Read more

#### `fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>`1.0.0[src]

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

#### `fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>`1.0.0[src]

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

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

Read the exact number of bytes required to fill `buf`. Read more

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn by_ref(&mut self) -> &mut Self` 1.0.0[src]

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

#### `fn bytes(self) -> Bytes<Self>`1.0.0[src]

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

####
ⓘImportant traits for Chain<T, U>

### Important traits for Chain<T, U>

`impl<T, U> Read for Chain<T, U> where
T: Read,
U: Read,`
`fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,` 1.0.0[src]

Creates an adaptor which will chain this stream with another. Read more

####
ⓘImportant traits for Take<T>

### Important traits for Take<T>

`impl<T> Read for Take<T> where
T: Read,`
`fn take(self, limit: u64) -> Take<Self>`1.0.0[src]

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

### `impl Write for TcpStream`[src]

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

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

#### `fn flush(&mut self) -> Result<()>`[src]

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

#### `fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>`1.36.0[src]

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

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

Attempts to write an entire buffer into this writer. Read more

#### `fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>`1.0.0[src]

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

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn by_ref(&mut self) -> &mut Self` 1.0.0[src]

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

### `impl<'a> Write for &'a TcpStream`[src]

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

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

#### `fn flush(&mut self) -> Result<()>`[src]

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

#### `fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>`1.36.0[src]

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

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

Attempts to write an entire buffer into this writer. Read more

#### `fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>`1.0.0[src]

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

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn by_ref(&mut self) -> &mut Self` 1.0.0[src]

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

### `impl IntoRawFd for TcpStream`[src]

#### `fn into_raw_fd(self) -> RawFd`[src]

Consumes this object, returning the raw underlying file descriptor. Read more

### `impl AsRawFd for TcpStream`[src]

#### `fn as_raw_fd(&self) -> RawFd`[src]

Extracts the raw file descriptor. Read more

### `impl FromRawFd for TcpStream`[src]

####
ⓘImportant traits for TcpStream

### Important traits for TcpStream

`impl Read for TcpStreamimpl<'a> Read for &'a TcpStreamimpl Write for TcpStreamimpl<'a> Write for &'a TcpStream`
`unsafe fn from_raw_fd(fd: RawFd) -> TcpStream`[src]

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

## Auto Trait Implementations

### `impl Send for TcpStream`

### `impl Unpin for TcpStream`

### `impl Sync for TcpStream`

### `impl UnwindSafe for TcpStream`

### `impl RefUnwindSafe for TcpStream`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)