Структура Ipv4Addr

#![allow(unused)]
fn main() {
pub struct Ipv4Addr(_);
}

Адрес IPv4.

IPv4-адреса определяются как 32-битные целые числа в IETF RFC 791. Они обычно представляются в точечно-десятичной нотации, которая состоит из четырех октетов, разделенных точками.

См. также IpAddr для типа, представляющий либо IPv4, либо IPv6.

Представление в памяти

Ipv4Addr представляет собой 32-битное целое число без знака, хранящееся в сетевом порядке байт (big-endian). Это то же представление, что и в системных вызовах Unix и Windows.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let localhost = Ipv4Addr::new(127, 0, 0, 1);
assert_eq!("127.0.0.1".parse(), Ok(localhost));

let broadcast = Ipv4Addr::new(255, 255, 255, 255);
assert_eq!(broadcast, Ipv4Addr::BROADCAST);
}

Константы

UNSPECIFIED

#![allow(unused)]
fn main() {
pub const UNSPECIFIED: Ipv4Addr = Ipv4Addr::new(0, 0, 0, 0);
}

Неспецифицированный адрес IPv4: 0.0.0.0.

Это соответствует константе INADDR_ANY в системных вызовах.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::UNSPECIFIED;
assert_eq!(addr, Ipv4Addr::new(0, 0, 0, 0));
assert!(addr.is_unspecified());
}

LOCALHOST

#![allow(unused)]
fn main() {
pub const LOCALHOST: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
}

Адрес обратной петли IPv4: 127.0.0.1.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::LOCALHOST;
assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));
assert!(addr.is_loopback());
}

BROADCAST

#![allow(unused)]
fn main() {
pub const BROADCAST: Ipv4Addr = Ipv4Addr::new(255, 255, 255, 255);
}

Широковещательный адрес IPv4: 255.255.255.255.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::BROADCAST;
assert_eq!(addr, Ipv4Addr::new(255, 255, 255, 255));
assert!(addr.is_broadcast());
}

Методы

new

#![allow(unused)]
fn main() {
pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr
}

Создает новый IPv4-адрес из четырех восьмибитных октетов.

Результат представляет собой адрес a.b.c.d.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
assert_eq!(addr.to_string(), "127.0.0.1");
}

octets

#![allow(unused)]
fn main() {
pub const fn octets(&self) -> [u8; 4]
}

Возвращает четыре восьмибитных октета, из которых состоит адрес.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
assert_eq!(addr.octets(), [127, 0, 0, 1]);
}

is_unspecified

#![allow(unused)]
fn main() {
pub const fn is_unspecified(&self) -> bool
}

Возвращает true, если это неспецифицированный адрес (0.0.0.0).

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let unspecified = Ipv4Addr::new(0, 0, 0, 0);
let localhost = Ipv4Addr::new(127, 0, 0, 1);

assert!(unspecified.is_unspecified());
assert!(!localhost.is_unspecified());
}

is_loopback

#![allow(unused)]
fn main() {
pub const fn is_loopback(&self) -> bool
}

Возвращает true, если это адрес обратной петли (127.0.0.0/8).

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let localhost = Ipv4Addr::new(127, 0, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(localhost.is_loopback());
assert!(!other.is_loopback());
}

is_private

#![allow(unused)]
fn main() {
pub const fn is_private(&self) -> bool
}

Возвращает true, если это частный адрес.

Частные адреса IPv4 определены в IETF RFC 1918:

• 10.0.0.0/8
• 172.16.0.0/12
• 192.168.0.0/16

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let private1 = Ipv4Addr::new(10, 0, 0, 1);
let private2 = Ipv4Addr::new(172, 16, 0, 1);
let private3 = Ipv4Addr::new(192, 168, 1, 1);
let public = Ipv4Addr::new(8, 8, 8, 8);

assert!(private1.is_private());
assert!(private2.is_private());
assert!(private3.is_private());
assert!(!public.is_private());
}

is_link_local

#![allow(unused)]
fn main() {
pub const fn is_link_local(&self) -> bool
}

Возвращает true, если это link-local адрес (169.254.0.0/16).

Link-local адреса определены в IETF RFC 3927.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let link_local = Ipv4Addr::new(169, 254, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(link_local.is_link_local());
assert!(!other.is_link_local());
}

is_global

#![allow(unused)]
fn main() {
pub fn is_global(&self) -> bool
}

Возвращает true, если это глобальный (публично маршрутизируемый) адрес.

Глобальные адреса - это все адреса, которые не зарезервированы для специальных целей.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let global = Ipv4Addr::new(8, 8, 8, 8);
let private = Ipv4Addr::new(192, 168, 1, 1);

assert!(global.is_global());
assert!(!private.is_global());
}

is_shared

#![allow(unused)]
fn main() {
pub fn is_shared(&self) -> bool
}

Возвращает true, если это shared-адрес (100.64.0.0/10).

Shared-адреса определены в IETF RFC 6598.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let shared = Ipv4Addr::new(100, 64, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(shared.is_shared());
assert!(!other.is_shared());
}

is_benchmarking

#![allow(unused)]
fn main() {
pub fn is_benchmarking(&self) -> bool
}

Возвращает true, если это benchmarking-адрес (198.18.0.0/15).

Benchmarking-адреса определены в IETF RFC 2544.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let benchmarking = Ipv4Addr::new(198, 18, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(benchmarking.is_benchmarking());
assert!(!other.is_benchmarking());
}

is_reserved

#![allow(unused)]
fn main() {
pub fn is_reserved(&self) -> bool
}

Возвращает true, если это зарезервированный адрес (240.0.0.0/4).

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let reserved = Ipv4Addr::new(240, 0, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(reserved.is_reserved());
assert!(!other.is_reserved());
}

is_multicast

#![allow(unused)]
fn main() {
pub const fn is_multicast(&self) -> bool
}

Возвращает true, если это многоадресный адрес (224.0.0.0/4).

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let multicast = Ipv4Addr::new(224, 0, 0, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(multicast.is_multicast());
assert!(!other.is_multicast());
}

is_broadcast

#![allow(unused)]
fn main() {
pub const fn is_broadcast(&self) -> bool
}

Возвращает true, если это широковещательный адрес (255.255.255.255).

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let broadcast = Ipv4Addr::new(255, 255, 255, 255);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(broadcast.is_broadcast());
assert!(!other.is_broadcast());
}

is_documentation

#![allow(unused)]
fn main() {
pub fn is_documentation(&self) -> bool
}

Возвращает true, если это адрес, зарезервированный для документации.

Адреса документации определены в IETF RFC 5737:

• 192.0.2.0/24
• 198.51.100.0/24
• 203.0.113.0/24

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let doc1 = Ipv4Addr::new(192, 0, 2, 1);
let doc2 = Ipv4Addr::new(198, 51, 100, 1);
let doc3 = Ipv4Addr::new(203, 0, 113, 1);
let other = Ipv4Addr::new(192, 168, 1, 1);

assert!(doc1.is_documentation());
assert!(doc2.is_documentation());
assert!(doc3.is_documentation());
assert!(!other.is_documentation());
}

to_ipv6_compatible

#![allow(unused)]
fn main() {
pub const fn to_ipv6_compatible(&self) -> Ipv6Addr
}

Преобразует адрес IPv4 в IPv4-совместимый адрес IPv6.

IPv4-совместимые адреса IPv6 устарели. Вместо них используйте to_ipv6_mapped.

Примеры

#![allow(unused)]
fn main() {
use std::net::{Ipv4Addr, Ipv6Addr};

let ipv4 = Ipv4Addr::new(192, 0, 2, 1);
let ipv6_compatible = ipv4.to_ipv6_compatible();

assert_eq!(
    ipv6_compatible,
    Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc000, 0x201)
);
}

to_ipv6_mapped

#![allow(unused)]
fn main() {
pub const fn to_ipv6_mapped(&self) -> Ipv6Addr
}

Преобразует адрес IPv4 в IPv4-отображенный адрес IPv6.

Примеры

#![allow(unused)]
fn main() {
use std::net::{Ipv4Addr, Ipv6Addr};

let ipv4 = Ipv4Addr::new(192, 0, 2, 1);
let ipv6_mapped = ipv4.to_ipv6_mapped();

assert_eq!(
    ipv6_mapped,
    Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x201)
);
}

to_bits

#![allow(unused)]
fn main() {
pub const fn to_bits(&self) -> u32
}

Возвращает 32-битное представление адреса в порядке байт хоста.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(0x7f, 0, 0, 1);
assert_eq!(addr.to_bits(), 0x7f000001);
}

from_bits

#![allow(unused)]
fn main() {
pub const fn from_bits(bits: u32) -> Ipv4Addr
}

Создает Ipv4Addr из 32-битного представления в порядке байт хоста.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::from_bits(0x7f000001);
assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));
}

Трайт-реализации

From<[u8; 4]>

#![allow(unused)]
fn main() {
impl From<[u8; 4]> for Ipv4Addr
}

Преобразует [u8; 4] в Ipv4Addr.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let bytes = [127, 0, 0, 1];
let addr = Ipv4Addr::from(bytes);
assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));
}

From<u32>

#![allow(unused)]
fn main() {
impl From<u32> for Ipv4Addr
}

Преобразует u32 в Ipv4Addr.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::from(0x7f000001);
assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));
}

Into<[u8; 4]>

#![allow(unused)]
fn main() {
impl Into<[u8; 4]> for Ipv4Addr
}

Преобразует Ipv4Addr в [u8; 4].

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
let bytes: [u8; 4] = addr.into();
assert_eq!(bytes, [127, 0, 0, 1]);
}

Into<u32>

#![allow(unused)]
fn main() {
impl Into<u32> for Ipv4Addr
}

Преобразует Ipv4Addr в u32.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(127, 0, 0, 1);
let bits: u32 = addr.into();
assert_eq!(bits, 0x7f000001);
}

Display, Debug

#![allow(unused)]
fn main() {
impl Display for Ipv4Addr
impl Debug for Ipv4Addr
}

Реализует отображение и отладочное отображение для Ipv4Addr.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(192, 168, 1, 1);
println!("IP адрес: {}", addr); // "192.168.1.1"
println!("Отладочная информация: {:?}", addr); // "192.168.1.1"
}

PartialEq, Eq, PartialOrd, Ord, Hash

#![allow(unused)]
fn main() {
impl PartialEq for Ipv4Addr
impl Eq for Ipv4Addr
impl PartialOrd for Ipv4Addr
impl Ord for Ipv4Addr
impl Hash for Ipv4Addr
}

Реализует сравнение и хеширование для Ipv4Addr.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;
use std::collections::HashMap;

let addr1 = Ipv4Addr::new(192, 168, 1, 1);
let addr2 = Ipv4Addr::new(192, 168, 1, 1);
let addr3 = Ipv4Addr::new(10, 0, 0, 1);

assert_eq!(addr1, addr2);
assert_ne!(addr1, addr3);

let mut map = HashMap::new();
map.insert(addr1, "router");
}

FromStr

#![allow(unused)]
fn main() {
impl FromStr for Ipv4Addr
}

Реализует парсинг из строки для Ipv4Addr.

Примеры

#![allow(unused)]
fn main() {
use std::net::Ipv4Addr;
use std::str::FromStr;

let addr = Ipv4Addr::from_str("192.168.1.1").unwrap();
assert_eq!(addr, Ipv4Addr::new(192, 168, 1, 1));
}

Примеры использования

Создание и проверка IPv4 адресов

use std::net::Ipv4Addr;

fn analyze_ipv4(addr: Ipv4Addr) {
    println!("Анализ IPv4 адреса: {}", addr);
    println!("  Октеты: {:?}", addr.octets());
    println!("  32-битное значение: 0x{:08x}", addr.to_bits());
    
    // Проверка свойств
    let properties = [
        ("неспецифицированный", addr.is_unspecified()),
        ("обратная петля", addr.is_loopback()),
        ("частный", addr.is_private()),
        ("link-local", addr.is_link_local()),
        ("глобальный", addr.is_global()),
        ("shared", addr.is_shared()),
        ("benchmarking", addr.is_benchmarking()),
        ("зарезервированный", addr.is_reserved()),
        ("многоадресный", addr.is_multicast()),
        ("широковещательный", addr.is_broadcast()),
        ("для документации", addr.is_documentation()),
    ];
    
    for (name, value) in properties {
        if value {
            println!("  ✓ {}", name);
        }
    }
}

fn main() {
    let addresses = [
        Ipv4Addr::UNSPECIFIED,
        Ipv4Addr::LOCALHOST,
        Ipv4Addr::BROADCAST,
        Ipv4Addr::new(10, 0, 0, 1),
        Ipv4Addr::new(192, 168, 1, 1),
        Ipv4Addr::new(224, 0, 0, 1),
        Ipv4Addr::new(8, 8, 8, 8),
    ];
    
    for addr in addresses {
        analyze_ipv4(addr);
        println!();
    }
}

Преобразование между форматами

use std::net::Ipv4Addr;

fn demonstrate_conversions() {
    let original = Ipv4Addr::new(192, 168, 1, 1);
    
    // Преобразование в массив байт
    let bytes: [u8; 4] = original.octets();
    println!("Оригинальный: {}", original);
    println!("Массив байт: {:?}", bytes);
    
    // Преобразование из массива байт
    let from_bytes = Ipv4Addr::from(bytes);
    println!("Из массива байт: {}", from_bytes);
    
    // Преобразование в u32
    let bits = original.to_bits();
    println!("32-битное значение: 0x{:08x}", bits);
    
    // Преобразование из u32
    let from_bits = Ipv4Addr::from_bits(bits);
    println!("Из 32-битного: {}", from_bits);
    
    // IPv6 преобразования
    let ipv6_mapped = original.to_ipv6_mapped();
    println!("IPv4-отображенный IPv6: {}", ipv6_mapped);
    
    let ipv6_compatible = original.to_ipv6_compatible();
    println!("IPv4-совместимый IPv6: {}", ipv6_compatible);
}

fn main() {
    demonstrate_conversions();
}

Фильтрация IP-адресов

use std::net::Ipv4Addr;

struct NetworkFilter;

impl NetworkFilter {
    fn is_allowed(addr: Ipv4Addr) -> bool {
        // Запрещаем специальные адреса
        if addr.is_unspecified() || addr.is_loopback() {
            return false;
        }
        
        // Запрещаем частные адреса
        if addr.is_private() {
            return false;
        }
        
        // Запрещаем зарезервированные и специальные диапазоны
        if addr.is_link_local() || addr.is_shared() || 
           addr.is_benchmarking() || addr.is_reserved() ||
           addr.is_documentation() {
            return false;
        }
        
        // Разрешаем только глобальные адреса
        addr.is_global()
    }
    
    fn filter_addresses(addrs: Vec<Ipv4Addr>) -> Vec<Ipv4Addr> {
        addrs.into_iter()
            .filter(|&addr| Self::is_allowed(addr))
            .collect()
    }
}

fn main() {
    let test_addresses = vec![
        Ipv4Addr::UNSPECIFIED,
        Ipv4Addr::LOCALHOST,
        Ipv4Addr::new(10, 0, 0, 1),
        Ipv4Addr::new(192, 168, 1, 1),
        Ipv4Addr::new(169, 254, 0, 1),
        Ipv4Addr::new(8, 8, 8, 8), // Google DNS - разрешен
        Ipv4Addr::new(1, 1, 1, 1), // Cloudflare DNS - разрешен
    ];
    
    println!("Все адреса:");
    for addr in &test_addresses {
        println!("  {} - {}", addr, if NetworkFilter::is_allowed(*addr) { "✓" } else { "✗" });
    }
    
    let filtered = NetworkFilter::filter_addresses(test_addresses);
    println!("\nРазрешенные адреса:");
    for addr in filtered {
        println!("  {}", addr);
    }
}