Struct tokio_socks::tcp::Socks5Stream

pub struct Socks5Stream { /* fields omitted */ }

A SOCKS5 client.

For convenience, it can be dereferenced to tokio_tcp::TcpStream.

Methods

impl Socks5Stream

pub fn connect<'t, P, T>(
    proxy: P,
    target: T
) -> Result<ConnectFuture<'static, 't, P::Output>, Error> where
    P: ToProxyAddrs,
    T: IntoTargetAddr<'t>, 

Connects to a target server through a SOCKS5 proxy.

Error

It propagates the error that occurs in the conversion from T to TargetAddr.

pub fn connect_with_password<'a, 't, P, T>(
    proxy: P,
    target: T,
    username: &'a str,
    password: &'a str
) -> Result<ConnectFuture<'a, 't, P::Output>, Error> where
    P: ToProxyAddrs,
    T: IntoTargetAddr<'t>, 

Connects to a target server through a SOCKS5 proxy using given username and password.

Error

It propagates the error that occurs in the conversion from T to TargetAddr.

pub fn into_inner(self) -> TcpStream

Consumes the Socks5Stream, returning the inner tokio_tcp::TcpStream.

pub fn target_addr(&self) -> TargetAddr

Returns the target address that the proxy server connects to.

Methods from Deref<Target = TcpStream>

pub fn poll_read_ready(&self, mask: Ready) -> Result<Async<Ready>, Error>

Check the TCP stream's read readiness state.

The mask argument allows specifying what readiness to notify on. This can be any value, including platform specific readiness, except writable. HUP is always implicitly included on platforms that support it.

If the resource is not ready for a read then Async::NotReady is returned and the current task is notified once a new event is received.

The stream will remain in a read-ready state until calls to poll_read return NotReady.

Panics

This function panics if:

• ready includes writable.
• called from outside of a task context.

Examples

use mio::Ready;
use futures::Async;
use futures::Future;
use tokio::net::TcpStream;
use std::net::SocketAddr;

let addr = "127.0.0.1:34254".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    match stream.poll_read_ready(Ready::readable()) {
        Ok(Async::Ready(_)) => println!("read ready"),
        Ok(Async::NotReady) => println!("not read ready"),
        Err(e) => eprintln!("got error: {}", e),
}
});

pub fn poll_write_ready(&self) -> Result<Async<Ready>, Error>

Check the TCP stream's write readiness state.

This always checks for writable readiness and also checks for HUP readiness on platforms that support it.

If the resource is not ready for a write then Async::NotReady is returned and the current task is notified once a new event is received.

The I/O resource will remain in a write-ready state until calls to poll_write return NotReady.

Panics

This function panics if called from outside of a task context.

Examples

use futures::Async;
use futures::Future;
use tokio::net::TcpStream;
use std::net::SocketAddr;

let addr = "127.0.0.1:34254".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    match stream.poll_write_ready() {
        Ok(Async::Ready(_)) => println!("write ready"),
        Ok(Async::NotReady) => println!("not write ready"),
        Err(e) => eprintln!("got error: {}", e),
}
});

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

Returns the local address that this stream is bound to.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    assert_eq!(stream.local_addr().unwrap(),
        SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));
});

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

Returns the remote address that this stream is connected to.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    assert_eq!(stream.peer_addr().unwrap(),
        SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080)));
});

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

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.

Return

On success, returns Ok(Async::Ready(num_bytes_read)).

If no data is available for reading, the method returns Ok(Async::NotReady) and arranges for the current task to receive a notification when the socket becomes readable or is closed.

Panics

This function will panic if called from outside of a task context.

Examples

use tokio::net::TcpStream;
use futures::Async;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|mut stream| {
    let mut buf = [0; 10];
    match stream.poll_peek(&mut buf) {
       Ok(Async::Ready(len)) => println!("read {} bytes", len),
       Ok(Async::NotReady) => println!("no data available"),
       Err(e) => eprintln!("got error: {}", e),
    }
});

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

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

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::{Shutdown, SocketAddr};

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.shutdown(Shutdown::Both)
});

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

Gets the value of the TCP_NODELAY option on this socket.

For more information about this option, see set_nodelay.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_nodelay(true).expect("set_nodelay call failed");;
    assert_eq!(stream.nodelay().unwrap_or(false), true);
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_nodelay(true).expect("set_nodelay call failed");
});

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

Gets the value of the SO_RCVBUF option on this socket.

For more information about this option, see set_recv_buffer_size.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_recv_buffer_size(100).expect("set_recv_buffer_size failed");
    assert_eq!(stream.recv_buffer_size().unwrap_or(0), 100);
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_recv_buffer_size(100).expect("set_recv_buffer_size failed");
});

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

Gets the value of the SO_SNDBUF option on this socket.

For more information about this option, see set_send_buffer.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_send_buffer_size(100).expect("set_send_buffer_size failed");
    assert_eq!(stream.send_buffer_size().unwrap_or(0), 100);
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_send_buffer_size(100).expect("set_send_buffer_size failed");
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_keepalive(None).expect("set_keepalive failed");
    assert_eq!(stream.keepalive().unwrap(), None);
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_keepalive(None).expect("set_keepalive failed");
});

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

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_ttl(100).expect("set_ttl failed");
    assert_eq!(stream.ttl().unwrap_or(0), 100);
});

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

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.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_ttl(100).expect("set_ttl failed");
});

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

Reads the linger duration for this socket by getting the SO_LINGER option.

For more information about this option, see set_linger.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_linger(None).expect("set_linger failed");
    assert_eq!(stream.linger().unwrap(), None);
});

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

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

This option controls the action taken when a stream has unsent messages and the stream is closed. If SO_LINGER is set, the system shall block the process until it can transmit the data or until the time expires.

If SO_LINGER is not specified, and the stream is closed, the system handles the call in a way that allows the process to continue as quickly as possible.

Examples

use tokio::net::TcpStream;
use futures::Future;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
let stream = TcpStream::connect(&addr);
stream.map(|stream| {
    stream.set_linger(None).expect("set_linger failed");
});

Trait Implementations

impl DerefMut for Socks5Stream

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Deref for Socks5Stream

type Target = TcpStream

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Debug for Socks5Stream

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

Formats the value using the given formatter.

impl Read for Socks5Stream

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, appending them to 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 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 Socks5Stream

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, appending them to 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 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 Socks5Stream

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

Write a buffer into this writer, 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 writer.

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 Socks5Stream

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

Write a buffer into this writer, 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 writer.

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 AsyncWrite for Socks5Stream

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.

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.

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

Attempt to write bytes from buf into the object.

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 Socks5Stream

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.

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.

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

Attempt to write bytes from buf into the object.

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

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

impl AsyncRead for Socks5Stream

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

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

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.

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

Attempt to read from the AsyncRead into buf.

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.

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 Socks5Stream

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

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

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.

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

Attempt to read from the AsyncRead into buf.

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.

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

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