Struct SocksClientHandshake 

pub struct SocksClientHandshake {
    request: SocksRequest,
    state: State,
    reply: Option<SocksReply>,
}

The client (initiator) side of a SOCKS handshake.

Create you have one of these with SocksClientHandshake::new(), and then use Handshake::step to drive it.

Fields

request: SocksRequest

The request that we are currently trying to negotiate with the proxy.

state: State

Our current state in negotiating that request.

reply: Option<SocksReply>

If present, the return message that we received from the proxy.

Implementations

impl SocksClientHandshake

pub fn new(request: SocksRequest) -> Self

Construct a new SocksClientHandshake that will attempt to negotiate with a peer using request.

pub fn into_reply(self) -> Option<SocksReply>

Consume this handshake’s state; if it finished successfully, return the SocksReply that we got from the proxy..

fn send_v4(&mut self) -> Result<ImplNextStep>

Send the client side of the socks 4 handshake.

fn handle_v4(&mut self, r: &mut Reader<'_>) -> Result<ImplNextStep>

Handle a SOCKSv4 response.

fn send_v5_initial(&mut self) -> Result<ImplNextStep>

Send our initial socks5 message (which negotiates our authentication methods).

fn handle_v5_auth(&mut self, r: &mut Reader<'_>) -> Result<ImplNextStep>

Try to handle a socks5 reply telling us what authentication method to use, and reply as appropriate.

fn generate_v5_username_auth(&self) -> Result<Vec<u8>>

Return a message to perform username/password authentication.

fn handle_v5_username_ack(&mut self, r: &mut Reader<'_>) -> Result<ImplNextStep>

Try to handle a reply from the socks5 proxy to acknowledge our username/password authentication, and reply as appropriate.

fn generate_v5_command(&self) -> Result<Vec<u8>>

Return a message to encode our final socks5 request.

(This can be done either in response getting an ACK for our authentication, or in response to being told that we don’t need to authenticate.)

fn handle_v5_final(&mut self, r: &mut Reader<'_>) -> Result<ImplNextStep>

Handle a final socks5 reply.

Trait Implementations

impl Clone for SocksClientHandshake

fn clone(&self) -> SocksClientHandshake

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SocksClientHandshake

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

Formats the value using the given formatter.

impl Handshake for SocksClientHandshake

type Output = <Option<SocksReply> as IntoIterator>::Item

Output from the handshake: the meaning, as we understand it

fn step<'b, P: ReadPrecision>( &mut self, buffer: &'b mut Buffer<P>, ) -> Result<NextStep<'b, <Self as Handshake>::Output, P>, Error>

Drive a handshake forward, determining what the next step is

fn handshake(&mut self, input: &[u8]) -> TResult<Action>

👎Deprecated:

use the new Handshake::step API instead

Try to advance the handshake, given some peer input in input.

impl HandshakeImpl for SocksClientHandshake

fn handshake_impl(&mut self, input: &mut Reader<'_>) -> Result<ImplNextStep>

Actual implementation, to be provided

fn call_handshake_impl(&mut self, input: &[u8]) -> (usize, Result<ImplNextStep>)

Helper, used by public API implementations to call handshake_impl.

impl HasHandshakeOutput<<Option<SocksReply> as IntoIterator>::Item> for SocksClientHandshake

fn take_output(&mut self) -> Option<<Option<SocksReply> as IntoIterator>::Item>

Obtain the output from a handshake completed with .handshake

impl HasHandshakeState for SocksClientHandshake

fn set_failed(&mut self)

Set the state to Failed