Struct net_types::ip::Ipv4Addr

pub struct Ipv4Addr(/* private fields */);

An IPv4 address.

Layout

Ipv4Addr has the same layout as [u8; 4], which is the layout that most protocols use to represent an IPv4 address in their packet formats. This can be useful when parsing an IPv4 address from a packet. For example:

/// An ICMPv4 Redirect Message header.
///
/// `Icmpv4RedirectHeader` has the same layout as the header of an ICMPv4
/// Redirect Message.
#[repr(C)]
struct Icmpv4RedirectHeader {
    typ: u8,
    code: u8,
    checksum: [u8; 2],
    gateway: Ipv4Addr,
}

Implementations

impl Ipv4Addr

pub const fn new(bytes: [u8; 4]) -> Self

Creates a new IPv4 address.

pub const fn ipv4_bytes(self) -> [u8; 4]

Gets the bytes of the IPv4 address.

pub fn is_limited_broadcast(self) -> bool

Is this the limited broadcast address?

is_limited_broadcast is a shorthand for comparing against Ipv4::LIMITED_BROADCAST_ADDRESS.

pub fn is_class_e(self) -> bool

Is this a Class E address?

is_class_e is a shorthand for checking membership in Ipv4::CLASS_E_SUBNET.

pub fn to_ipv6_compatible(self) -> Ipv6Addr

Converts the address to an IPv4-compatible IPv6 address according to RFC 4291 Section 2.5.5.1.

IPv4-compatible IPv6 addresses were defined to assist in the IPv6 transition, and are now specified in RFC 4291 Section 2.5.5.1. The lowest-order 32 bits carry an IPv4 address, while the highest-order 96 bits are all set to 0 as in this diagram from the RFC:

|                80 bits               | 16 |      32 bits        |
+--------------------------------------+--------------------------+
|0000..............................0000|0000|    IPv4 address     |
+--------------------------------------+----+---------------------+

Per RFC 4291:

The ‘IPv4-Compatible IPv6 address’ is now deprecated because the current IPv6 transition mechanisms no longer use these addresses. New or updated implementations are not required to support this address type.

The more modern embedding format is IPv4-mapped IPv6 addressing - see to_ipv6_mapped.

pub fn to_ipv6_mapped(self) -> SpecifiedAddr<Ipv6Addr>

Converts the address to an IPv4-mapped IPv6 address according to RFC 4291 Section 2.5.5.2.

IPv4-mapped IPv6 addresses are used to represent the addresses of IPv4 nodes as IPv6 addresses, and are defined in RFC 4291 Section 2.5.5.2. The lowest-order 32 bits carry an IPv4 address, the middle order 16 bits carry the literal 0xFFFF, and the highest order 80 bits are set to 0 as in this diagram from the RFC:

|                80 bits               | 16 |      32 bits        |
+--------------------------------------+--------------------------+
|0000..............................0000|FFFF|    IPv4 address     |
+--------------------------------------+----+---------------------+

pub fn class(&self) -> Ipv4AddressClass

Returns the address’s class according to the obsoleted classful addressing architecture.

Trait Implementations

impl Clone for Ipv4Addr

fn clone(&self) -> Ipv4Addr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv4Addr

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

Formats the value using the given formatter.

impl Default for Ipv4Addr

fn default() -> Ipv4Addr

Returns the “default value” for a type.

impl Display for Ipv4Addr

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

Formats the value using the given formatter.

impl From<[u8; 4]> for Ipv4Addr

fn from(bytes: [u8; 4]) -> Ipv4Addr

Converts to this type from the input type.

impl From<Ipv4Addr> for Ipv4Addr

fn from(ip: Ipv4Addr) -> Ipv4Addr

Converts to this type from the input type.

impl From<Ipv4Addr> for Ipv4Addr

fn from(ip: Ipv4Addr) -> Ipv4Addr

Converts to this type from the input type.

impl From<Ipv4Addr> for Ipv6Addr

Ipv4Addr is convertible into Ipv6Addr through Ipv4Addr::to_ipv6_mapped.

fn from(addr: Ipv4Addr) -> Ipv6Addr

Converts to this type from the input type.

impl<A: Into<Ipv4Addr> + LinkLocalAddress + Copy> From<LinkLocalAddr<A>> for Ipv4Addr

fn from(addr: LinkLocalAddr<A>) -> Ipv4Addr

Converts to this type from the input type.

impl<A: Into<Ipv4Addr> + MulticastAddress + Copy> From<MulticastAddr<A>> for Ipv4Addr

fn from(addr: MulticastAddr<A>) -> Ipv4Addr

Converts to this type from the input type.

impl<A: Into<Ipv4Addr> + MappedAddress + Copy> From<NonMappedAddr<A>> for Ipv4Addr

fn from(addr: NonMappedAddr<A>) -> Ipv4Addr

Converts to this type from the input type.

impl<A: Into<Ipv4Addr> + SpecifiedAddress + Copy> From<SpecifiedAddr<A>> for Ipv4Addr

fn from(addr: SpecifiedAddr<A>) -> Ipv4Addr

Converts to this type from the input type.

impl FromBytes for Ipv4Addr

where [u8; 4]: FromBytes,

fn ref_from(bytes: &[u8]) -> Option<&Self>

where Self: Sized + NoCell,

Interprets the given bytes as a &Self without copying.

fn ref_from_prefix(bytes: &[u8]) -> Option<&Self>

where Self: Sized + NoCell,

Interprets the prefix of the given bytes as a &Self without copying.

fn ref_from_suffix(bytes: &[u8]) -> Option<&Self>

where Self: Sized + NoCell,

Interprets the suffix of the given bytes as a &Self without copying.

fn mut_from(bytes: &mut [u8]) -> Option<&mut Self>

where Self: Sized + IntoBytes + NoCell,

Interprets the given bytes as a &mut Self without copying.

fn mut_from_prefix(bytes: &mut [u8]) -> Option<&mut Self>

where Self: Sized + IntoBytes + NoCell,

Interprets the prefix of the given bytes as a &mut Self without copying.

fn mut_from_suffix(bytes: &mut [u8]) -> Option<&mut Self>

where Self: Sized + IntoBytes + NoCell,

Interprets the suffix of the given bytes as a &mut Self without copying.

fn slice_from(bytes: &[u8]) -> Option<&[Self]>

where Self: Sized + NoCell,

Interprets the given bytes as a &[Self] without copying.

fn slice_from_prefix(bytes: &[u8], count: usize) -> Option<(&[Self], &[u8])>

where Self: Sized + NoCell,

Interprets the prefix of the given bytes as a &[Self] with length equal to count without copying.

fn slice_from_suffix(bytes: &[u8], count: usize) -> Option<(&[u8], &[Self])>

where Self: Sized + NoCell,

Interprets the suffix of the given bytes as a &[Self] with length equal to count without copying.

fn mut_slice_from(bytes: &mut [u8]) -> Option<&mut [Self]>

where Self: Sized + IntoBytes + NoCell,

Interprets the given bytes as a &mut [Self] without copying.

fn mut_slice_from_prefix( bytes: &mut [u8], count: usize ) -> Option<(&mut [Self], &mut [u8])>

where Self: Sized + IntoBytes + NoCell,

Interprets the prefix of the given bytes as a &mut [Self] with length equal to count without copying.

fn mut_slice_from_suffix( bytes: &mut [u8], count: usize ) -> Option<(&mut [u8], &mut [Self])>

where Self: Sized + IntoBytes + NoCell,

Interprets the suffix of the given bytes as a &mut [Self] with length equal to count without copying.

fn read_from(bytes: &[u8]) -> Option<Self>

where Self: Sized,

Reads a copy of Self from bytes.

fn read_from_prefix(bytes: &[u8]) -> Option<Self>

where Self: Sized,

Reads a copy of Self from the prefix of bytes.

fn read_from_suffix(bytes: &[u8]) -> Option<Self>

where Self: Sized,

Reads a copy of Self from the suffix of bytes.

impl FromZeros for Ipv4Addr

where [u8; 4]: FromZeros,

fn zero(&mut self)

Overwrites self with zeros.

fn new_zeroed() -> Self

where Self: Sized,

Creates an instance of Self from zeroed bytes.

impl<I: Ip> GenericOverIp<I> for Ipv4Addr

type Type = <I as Ip>::Addr

The type of Self when its IP-generic parameter is replaced with the type NewIp.

impl Hash for Ipv4Addr

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 IntoBytes for Ipv4Addr

where [u8; 4]: IntoBytes,

fn as_bytes(&self) -> &[u8]

where Self: NoCell,

Gets the bytes of this value.

fn as_bytes_mut(&mut self) -> &mut [u8]

where Self: FromBytes + NoCell,

Gets the bytes of this value mutably.

fn write_to(&self, bytes: &mut [u8]) -> Option<()>

where Self: NoCell,

Writes a copy of self to bytes.

fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>

where Self: NoCell,

Writes a copy of self to the prefix of bytes.

fn write_to_suffix(&self, bytes: &mut [u8]) -> Option<()>

where Self: NoCell,

Writes a copy of self to the suffix of bytes.

impl IpAddress for Ipv4Addr

const BYTES: u8 = 4u8

The number of bytes in an address of this type.

type Version = Ipv4

The IP version type of this address.

fn mask(&self, bits: u8) -> Self

Masks off the top bits of the address.

fn bytes(&self) -> &[u8]

Gets the underlying bytes of the address.

fn to_ip_addr(&self) -> IpAddr

Converts a statically-typed IP address into a dynamically-typed one.

fn common_prefix_len(&self, other: &Ipv4Addr) -> u8

Calculates the common prefix length between this address and other.

fn is_unicast_in_subnet(&self, subnet: &Subnet<Self>) -> bool

Is this a unicast address contained in the given subnet?

fn is_loopback(&self) -> bool

Is this a loopback address?

impl LinkLocalAddress for Ipv4Addr

fn is_link_local(&self) -> bool

Is this address in the link-local subnet?

is_link_local returns true if self is in Ipv4::LINK_LOCAL_UNICAST_SUBNET or Ipv4::LINK_LOCAL_MULTICAST_SUBNET.

impl Ord for Ipv4Addr

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Ipv4Addr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Ipv4Addr

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl ScopeableAddress for Ipv4Addr

fn scope(&self)

The scope of this address.

Although IPv4 defines a link local subnet, IPv4 addresses are always considered to be in the global scope.

type Scope = ()

The type of all non-global scopes.

impl TryFrom<Ipv4Addr> for LinkLocalAddr<Ipv4Addr>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(addr: Ipv4Addr) -> Result<LinkLocalAddr<Ipv4Addr>, ()>

Performs the conversion.

impl TryFrom<Ipv4Addr> for MulticastAddr<Ipv4Addr>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(addr: Ipv4Addr) -> Result<MulticastAddr<Ipv4Addr>, ()>

Performs the conversion.

impl TryFrom<Ipv4Addr> for NonMappedAddr<Ipv4Addr>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(addr: Ipv4Addr) -> Result<NonMappedAddr<Ipv4Addr>, ()>

Performs the conversion.

impl TryFrom<Ipv4Addr> for SpecifiedAddr<Ipv4Addr>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(addr: Ipv4Addr) -> Result<SpecifiedAddr<Ipv4Addr>, ()>

Performs the conversion.

impl Copy for Ipv4Addr

impl Eq for Ipv4Addr

impl StructuralPartialEq for Ipv4Addr

impl Unaligned for Ipv4Addr

where [u8; 4]: Unaligned,