Struct `SocketAddrV6`

struct SocketAddrV6 { ... }

An IPv6 socket address.

IPv6 socket addresses consist of an IPv6 address, a 16-bit port number, as well as fields containing the traffic class, the flow label, and a scope identifier (see IETF RFC 2553, Section 3.3 for more details).

See SocketAddr for a type encompassing both IPv4 and IPv6 socket addresses.

Portability

SocketAddrV6 is intended to be a portable representation of socket addresses and is likely not the same as the internal socket address type used by the target operating system's API. Like all repr(Rust) structs, however, its exact layout remains undefined and should not be relied upon between builds.

Textual representation

SocketAddrV6 provides a FromStr implementation, based on the bracketed format recommended by IETF RFC 5952, with scope identifiers based on those specified in IETF RFC 4007.

It accepts addresses consisting of the following elements, in order:

A left square bracket ([)
The textual representation of an IPv6 address
Optionally, a percent sign (%) followed by the scope identifier encoded as a decimal integer
A right square bracket (])
A colon (:)
The port, encoded as a decimal integer.

For example, the string [2001:db8::413]:443 represents a SocketAddrV6 with the address 2001:db8::413 and port 443. The string [2001:db8::413%612]:443 represents the same address and port, with a scope identifier of 612.

Other formats are not accepted.

Examples

use std::net::{Ipv6Addr, SocketAddrV6};

let socket = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);

assert_eq!("[2001:db8::1]:8080".parse(), Ok(socket));
assert_eq!(socket.ip(), &Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
assert_eq!(socket.port(), 8080);

let mut with_scope = socket.clone();
with_scope.set_scope_id(3);
assert_eq!("[2001:db8::1%3]:8080".parse(), Ok(with_scope));

Implementations

`impl SocketAddrV6`

const fn new(ip: Ipv6Addr, port: u16, flowinfo: u32, scope_id: u32) -> SocketAddrV6

Creates a new socket address from an IPv6 address, a 16-bit port number, and the flowinfo and scope_id fields.

For more information on the meaning and layout of the flowinfo and scope_id parameters, see IETF RFC 2553, Section 3.3.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);

const fn ip(self: &Self) -> &Ipv6Addr

Returns the IP address associated with this socket address.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
assert_eq!(socket.ip(), &Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

const fn set_ip(self: &mut Self, new_ip: Ipv6Addr)

Changes the IP address associated with this socket address.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
socket.set_ip(Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));
assert_eq!(socket.ip(), &Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));

const fn port(self: &Self) -> u16

Returns the port number associated with this socket address.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
assert_eq!(socket.port(), 8080);

const fn set_port(self: &mut Self, new_port: u16)

Changes the port number associated with this socket address.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
socket.set_port(4242);
assert_eq!(socket.port(), 4242);

const fn flowinfo(self: &Self) -> u32

Returns the flow information associated with this address.

This information corresponds to the sin6_flowinfo field in C's netinet/in.h, as specified in IETF RFC 2553, Section 3.3. It combines information about the flow label and the traffic class as specified in IETF RFC 2460, respectively Section 6 and Section 7.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);
assert_eq!(socket.flowinfo(), 10);

const fn set_flowinfo(self: &mut Self, new_flowinfo: u32)

Changes the flow information associated with this socket address.

See SocketAddrV6::flowinfo's documentation for more details.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);
socket.set_flowinfo(56);
assert_eq!(socket.flowinfo(), 56);

const fn scope_id(self: &Self) -> u32

Returns the scope ID associated with this address.

This information corresponds to the sin6_scope_id field in C's netinet/in.h, as specified in IETF RFC 2553, Section 3.3.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);
assert_eq!(socket.scope_id(), 78);

const fn set_scope_id(self: &mut Self, new_scope_id: u32)

Changes the scope ID associated with this socket address.

See SocketAddrV6::scope_id's documentation for more details.

Examples

use std::net::{SocketAddrV6, Ipv6Addr};

let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);
socket.set_scope_id(42);
assert_eq!(socket.scope_id(), 42);

`impl SocketAddrV6`

fn parse_ascii(b: &[u8]) -> Result<Self, AddrParseError>

Parse an IPv6 socket address from a slice of bytes.

#![feature(addr_parse_ascii)]

use std::net::{Ipv6Addr, SocketAddrV6};

let socket = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);

assert_eq!(SocketAddrV6::parse_ascii(b"[2001:db8::1]:8080"), Ok(socket));

`impl Clone for SocketAddrV6`

fn clone(self: &Self) -> SocketAddrV6

`impl Copy for SocketAddrV6`

`impl Debug for SocketAddrV6`

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

`impl Display for SocketAddrV6`

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

`impl Eq for SocketAddrV6`

`impl Freeze for SocketAddrV6`

`impl FromStr for SocketAddrV6`

fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError>

`impl Hash for SocketAddrV6`

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

`impl Ord for SocketAddrV6`

fn cmp(self: &Self, other: &SocketAddrV6) -> Ordering

`impl PartialEq for SocketAddrV6`

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

`impl PartialOrd for SocketAddrV6`

fn partial_cmp(self: &Self, other: &SocketAddrV6) -> Option<Ordering>

`impl RefUnwindSafe for SocketAddrV6`

`impl Send for SocketAddrV6`

`impl StructuralPartialEq for SocketAddrV6`

`impl Sync for SocketAddrV6`

`impl Unpin for SocketAddrV6`

`impl UnsafeUnpin for SocketAddrV6`

`impl UnwindSafe for SocketAddrV6`

`impl<T> Any for SocketAddrV6`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for SocketAddrV6`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for SocketAddrV6`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for SocketAddrV6`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for SocketAddrV6`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for SocketAddrV6`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for SocketAddrV6`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for SocketAddrV6`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>