Enum SocketAddr

#[non_exhaustive]
pub enum SocketAddr {
    Inet(SocketAddr),
    Unix(SocketAddr),
}

Any address that Arti can listen on or connect to.

We use this type when we want to make streams without being concerned whether they are AF_UNIX streams, TCP streams, or so forth.

To avoid confusion, you might want to avoid importing this type directly. Instead, import rtcompat::general and refer to this type as general::SocketAddr.

String representation

Any general::SocketAddr has up to two string representations:

1. A qualified representation, consisting of a schema (either “unix” or “inet”), followed by a single colon, followed by the address itself represented as a string.

   Examples: unix:/path/to/socket, inet:127.0.0.1:9999, inet:[::1]:9999.

   The “unnamed” AF_UNIX address is represented as unix:.

2. A unqualified representation, consisting of a net::SocketAddr address represented as a string.

   Examples: 127.0.0.1:9999, [::1]:9999.

Note that not every general::SocketAddr has a string representation! Currently, the ones that might not be representable are:

• “Abstract” AF_UNIX addresses (a Linux feature)
• AF_UNIX addresses whose path name is not UTF-8.

Note also that string representations may contain whitespace or other unusual characters. /var/run/arti socket is a valid filename, so unix:/var/run/arti socket is a valid representation.

We may add new schemas in the future. If we do, any new schema will begin with an ascii alphabetical character, and will consist only of ascii alphanumeric characters, the character -, and the character _.

Network address representation

When representing a net::Socketaddr address as a string, we use the formats implemented by std::net::SocketAddr’s FromStr implementation. In contrast with the textual representations of Ipv4Addr and Ipv6Addr, these formats are not currently very well specified by Rust. Therefore we describe them here:

• A SocketAddrV4 is encoded as:
  • an IPv4 address,
  • a colon (:),
  • a 16-bit decimal integer.
• A SocketAddrV6 is encoded as:
  • a left square bracket ([),
  • an IPv6 address,
  • optionally, a percent sign (%) and a 32-bit decimal integer
  • a right square bracket (]),
  • a colon (:),
  • a 16-bit decimal integer.

Note that the above implementation does not provide any way to encode the flowinfo member of a SocketAddrV6. Any flowinfo information set in an address will therefore be lost when the address is encoded.

TODO: We should try to get Rust’s stdlib specify these formats, so we don’t have to. There is an open PR at https://github.com/rust-lang/rust/pull/131790.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Inet(SocketAddr)

An IPv4 or IPv6 address on the internet.

Unix(SocketAddr)

A local AF_UNIX address.

(Note that unix::SocketAddr is unconstructable on platforms where it is not supported.)

Implementations

impl SocketAddr

pub fn display_lossy(&self) -> DisplayLossy<'_>

Return a wrapper object that can be used to display this address.

The resulting display might be lossy, depending on whether this address can be represented as a string.

The displayed format here is intentionally undocumented; it may change in the future.

pub fn try_to_string(&self) -> Option<String>

If possible, return a qualified string representation for this address.

Otherwise return None.

pub fn as_pathname(&self) -> Option<&Path>

If this address has an associated filesystem path, return that path.

Trait Implementations

impl<'a> Arbitrary<'a> for SocketAddr

fn arbitrary(u: &mut Unstructured<'a>) -> Result<SocketAddr, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for SocketAddr

fn clone(&self) -> SocketAddr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SocketAddr

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

Formats the value using the given formatter.

impl From<SocketAddr> for SocketAddr

fn from(value: SocketAddr) -> SocketAddr

Converts to this type from the input type.

impl From<SocketAddr> for SocketAddr

fn from(value: SocketAddr) -> SocketAddr

Converts to this type from the input type.

impl FromStr for SocketAddr

type Err = AddrParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<SocketAddr, <SocketAddr as FromStr>::Err>

Parses a string s to return a value of this type.

impl NetStreamListener<SocketAddr> for Listener

type Stream = Stream

The type of connections returned by Self::incoming().

type Incoming = IncomingStreams

The type of [stream::Stream] returned by Self::incoming().

fn incoming(self) -> IncomingStreams

Wrap this listener into a new [stream::Stream] that yields streams and addresses.

fn local_addr(&self) -> IoResult<SocketAddr>

Return the local address that this listener is bound to.

impl PartialEq for SocketAddr

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

Return true if two SocketAddrs are equal.

For Inet addresses, delegates to std::net::SocketAddr::eq.

For Unix addresses, treats two addresses as equal if any of the following is true:

• Both addresses have the same path.
• Both addresses are unnamed.
• (Linux only) Both addresses have the same abstract name.

Addresses of different types are always unequal.

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

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