[][src]Enum tcp_stream::TcpStream

pub enum TcpStream {
    Plain(MioTcpStream),
    NativeTls(NativeTlsStream),
    OpenSsl(OpenSslStream),
    Rustls(RustlsStream),
}

Wrapper around plain or TLS TCP streams

Variants

Plain(MioTcpStream)

Wrapper around mio's TcpStream

NativeTls(NativeTlsStream)

Wrapper around a TLS stream hanled by native-tls

OpenSsl(OpenSslStream)

Wrapper around a TLS stream hanled by openssl

Rustls(RustlsStream)

Wrapper around a TLS stream hanled by rustls

Methods

impl TcpStream[src]

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

Wrapper around mio's TcpStream::connect

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

Wrapper around mio's TcpStream::connect_stream

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

Wrapper around mio's TcpStream::from_stream

pub fn into_tls(self, domain: &str) -> Result<Self, HandshakeError>[src]

Enable TLS

pub fn into_native_tls(
    self,
    connector: NativeTlsConnector,
    domain: &str
) -> Result<Self, HandshakeError>
[src]

Enable TLS using native-tls

pub fn into_openssl(
    self,
    connector: OpenSslConnector,
    domain: &str
) -> Result<Self, HandshakeError>
[src]

Enable TLS using openssl

pub fn into_rustls(
    self,
    connector: RustlsConnector,
    domain: &str
) -> Result<Self, HandshakeError>
[src]

Enable TLS using rustls

Methods from Deref<Target = MioTcpStream>

pub fn peer_addr(&self) -> Result<SocketAddr, Error>[src]

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

pub fn local_addr(&self) -> Result<SocketAddr, Error>[src]

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

pub fn try_clone(&self) -> Result<TcpStream, Error>[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<(), Error>[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<(), Error>[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, Error>[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<(), Error>[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, Error>[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<(), Error>[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, Error>[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<(), Error>[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>, Error>[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<(), Error>[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, Error>[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<(), Error>[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, Error>[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<(), Error>[src]

Sets the value for the SO_LINGER option on this socket.

pub fn linger(&self) -> Result<Option<Duration>, Error>[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>, 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, Error>[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, Error>[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, Error>[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 From<TcpStream> for TcpStream[src]

impl From<TlsStream<TcpStream>> for TcpStream[src]

impl From<SslStream<TcpStream>> for TcpStream[src]

impl From<StreamOwned<ClientSession, TcpStream>> for TcpStream[src]

impl DerefMut for TcpStream[src]

impl Debug for TcpStream[src]

impl Deref for TcpStream[src]

type Target = MioTcpStream

The resulting type after dereferencing.

impl Read for TcpStream[src]

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 Reader 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

fn by_ref(&mut self) -> &mut Self1.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

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

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_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

fn by_ref(&mut self) -> &mut Self1.0.0[src]

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

impl FromRawFd for TcpStream[src]

impl AsRawFd for TcpStream[src]

impl Evented for TcpStream[src]

impl AsyncWrite for TcpStream[src]

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

Attempt to write bytes from buf into the object. Read more

fn poll_flush(&mut self) -> Result<Async<()>, Error>[src]

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

fn write_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: Buf
[src]

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

impl AsyncRead for TcpStream[src]

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

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

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

Attempt to read from the AsyncRead into buf. Read more

fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: BufMut
[src]

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

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

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. Read more

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite
[src]

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

Auto Trait Implementations

impl Send for TcpStream

impl Sync for TcpStream

Blanket Implementations

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

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

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.

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.

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

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

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

impl<R> ReadBytesExt for R where
    R: Read + ?Sized

fn read_u8(&mut self) -> Result<u8, Error>

Reads an unsigned 8 bit integer from the underlying reader. Read more

fn read_i8(&mut self) -> Result<i8, Error>

Reads a signed 8 bit integer from the underlying reader. Read more

fn read_u16<T>(&mut self) -> Result<u16, Error> where
    T: ByteOrder, 

Reads an unsigned 16 bit integer from the underlying reader. Read more

fn read_i16<T>(&mut self) -> Result<i16, Error> where
    T: ByteOrder, 

Reads a signed 16 bit integer from the underlying reader. Read more

fn read_u24<T>(&mut self) -> Result<u32, Error> where
    T: ByteOrder, 

Reads an unsigned 24 bit integer from the underlying reader. Read more

fn read_i24<T>(&mut self) -> Result<i32, Error> where
    T: ByteOrder, 

Reads a signed 24 bit integer from the underlying reader. Read more

fn read_u32<T>(&mut self) -> Result<u32, Error> where
    T: ByteOrder, 

Reads an unsigned 32 bit integer from the underlying reader. Read more

fn read_i32<T>(&mut self) -> Result<i32, Error> where
    T: ByteOrder, 

Reads a signed 32 bit integer from the underlying reader. Read more

fn read_u48<T>(&mut self) -> Result<u64, Error> where
    T: ByteOrder, 

Reads an unsigned 48 bit integer from the underlying reader. Read more

fn read_i48<T>(&mut self) -> Result<i64, Error> where
    T: ByteOrder, 

Reads a signed 48 bit integer from the underlying reader. Read more

fn read_u64<T>(&mut self) -> Result<u64, Error> where
    T: ByteOrder, 

Reads an unsigned 64 bit integer from the underlying reader. Read more

fn read_i64<T>(&mut self) -> Result<i64, Error> where
    T: ByteOrder, 

Reads a signed 64 bit integer from the underlying reader. Read more

fn read_u128<T>(&mut self) -> Result<u128, Error> where
    T: ByteOrder, 

Reads an unsigned 128 bit integer from the underlying reader. Read more

fn read_i128<T>(&mut self) -> Result<i128, Error> where
    T: ByteOrder, 

Reads a signed 128 bit integer from the underlying reader. Read more

fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error> where
    T: ByteOrder, 

Reads an unsigned n-bytes integer from the underlying reader. Read more

fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error> where
    T: ByteOrder, 

Reads a signed n-bytes integer from the underlying reader. Read more

fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error> where
    T: ByteOrder, 

Reads an unsigned n-bytes integer from the underlying reader.

fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error> where
    T: ByteOrder, 

Reads a signed n-bytes integer from the underlying reader.

fn read_f32<T>(&mut self) -> Result<f32, Error> where
    T: ByteOrder, 

Reads a IEEE754 single-precision (4 bytes) floating point number from the underlying reader. Read more

fn read_f64<T>(&mut self) -> Result<f64, Error> where
    T: ByteOrder, 

Reads a IEEE754 double-precision (8 bytes) floating point number from the underlying reader. Read more

fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of unsigned 16 bit integers from the underlying reader. Read more

fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of unsigned 32 bit integers from the underlying reader. Read more

fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of unsigned 64 bit integers from the underlying reader. Read more

fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of unsigned 128 bit integers from the underlying reader. Read more

fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of signed 16 bit integers from the underlying reader. Read more

fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of signed 32 bit integers from the underlying reader. Read more

fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of signed 64 bit integers from the underlying reader. Read more

fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of signed 128 bit integers from the underlying reader. Read more

fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader. Read more

fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
    T: ByteOrder, 

Deprecated since 1.2.0:

please use read_f32_into instead

DEPRECATED. Read more

fn read_f64_into<T>(&mut self, dst: &mut [f64]) -> Result<(), Error> where
    T: ByteOrder, 

Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader. Read more

fn read_f64_into_unchecked<T>(&mut self, dst: &mut [f64]) -> Result<(), Error> where
    T: ByteOrder, 

Deprecated since 1.2.0:

please use read_f64_into instead

DEPRECATED. Read more

impl<W> WriteBytesExt for W where
    W: Write + ?Sized

fn write_u8(&mut self, n: u8) -> Result<(), Error>

Writes an unsigned 8 bit integer to the underlying writer. Read more

fn write_i8(&mut self, n: i8) -> Result<(), Error>

Writes a signed 8 bit integer to the underlying writer. Read more

fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 16 bit integer to the underlying writer. Read more

fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 16 bit integer to the underlying writer. Read more

fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 24 bit integer to the underlying writer. Read more

fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 24 bit integer to the underlying writer. Read more

fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 32 bit integer to the underlying writer. Read more

fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 32 bit integer to the underlying writer. Read more

fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 48 bit integer to the underlying writer. Read more

fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 48 bit integer to the underlying writer. Read more

fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 64 bit integer to the underlying writer. Read more

fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 64 bit integer to the underlying writer. Read more

fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned 128 bit integer to the underlying writer.

fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed 128 bit integer to the underlying writer.

fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned n-bytes integer to the underlying writer. Read more

fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed n-bytes integer to the underlying writer. Read more

fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder, 

Writes an unsigned n-bytes integer to the underlying writer. Read more

fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
    T: ByteOrder, 

Writes a signed n-bytes integer to the underlying writer. Read more

fn write_f32<T>(&mut self, n: f32) -> Result<(), Error> where
    T: ByteOrder, 

Writes a IEEE754 single-precision (4 bytes) floating point number to the underlying writer. Read more

fn write_f64<T>(&mut self, n: f64) -> Result<(), Error> where
    T: ByteOrder, 

Writes a IEEE754 double-precision (8 bytes) floating point number to the underlying writer. Read more