Enum Address 

pub enum Address {
    IPv4((Ipv4Addr, u16)),
    DomainName((String, u16)),
    IPv6((Ipv6Addr, u16)),
}

Represents a network address in various supported formats.

This enum is used to specify target addresses for SOCKS5 and HTTP proxy connections, supporting IPv4, IPv6, and domain name address types as defined in RFC 1928.

Variants

IPv4((Ipv4Addr, u16))

An IPv4 address with a port number.

DomainName((String, u16))

A domain name with a port number.

IPv6((Ipv6Addr, u16))

An IPv6 address with a port number.

Implementations

impl Address

pub async fn decode_from_reader<T>(reader: &mut T) -> Result<(Self, usize)>

where T: AsyncRead + Unpin,

Decodes a SOCKS5-like address from an asynchronous reader.

This method reads a network address from the provided asynchronous reader using the SOCKS5 address format (RFC 1928). It reads the address type byte, followed by the appropriate address data and port number.

According to RFC 1928, SOCKS5 address format is:

+------+----------+----------+
| ATYP | DST.ADDR | DST.PORT |
+------+----------+----------+
|  1   | Variable |    2     |
+------+----------+----------+

ATYP: Address type - 0x01 (IPv4), 0x03 (domain name), 0x04 (IPv6)

ADDR: Destination address, format depends on ATYP

PORT: Destination port, network byte order (big-endian)

pub async fn encode_to_writer<T>(&self, writer: &mut T) -> Result<usize>

where T: AsyncWrite + Unpin,

Encodes the address to a SOCKS5-like format and writes it to an asynchronous writer.

pub fn decode_from_buf(buf: &[u8]) -> Result<(Self, usize)>

Decodes a SOCKS5-like address from a byte buffer.

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

Encodes the address to a SOCKS5-like format and writes it to a byte buffer.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl From<&Address> for String

fn from(address: &Address) -> Self

Converts an &Address into an HTTP-style text representation.

impl From<Address> for String

fn from(value: Address) -> Self

Converts an Address into an HTTP-style text representation.

This implementation formats the address in HTTP-style notation:

• IPv4: “192.168.1.1:8080”
• IPv6: “[2001:db8::1]:8080”
• Domain: “example.com:443”

This format is suitable for use in HTTP headers and other textual representations.

impl Hash for Address

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Address

fn eq(&self, other: &Address) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&str> for Address

fn try_from(string: &str) -> Result<Self, Self::Error>

Attempts to parse an HTTP-style text address into an Address.

type Error = AddrError

The type returned in the event of a conversion error.

impl TryFrom<String> for Address

fn try_from(value: String) -> Result<Self, Self::Error>

Attempts to parse an HTTP-style text address into an Address.

type Error = AddrError

The type returned in the event of a conversion error.

impl Eq for Address

impl StructuralPartialEq for Address