Перечисление SocketAddr

#![allow(unused)]
fn main() {
pub enum SocketAddr {
    V4(SocketAddrV4),
    V6(SocketAddrV6),
}
}

Представляет адрес интернет-сокета, либо IPv4, либо IPv6.

Варианты

V4

#![allow(unused)]
fn main() {
V4(SocketAddrV4)
}

Адрес интернет-сокса IPv4.

V6

#![allow(unused)]
fn main() {
V6(SocketAddrV6)
}

Адрес интернет-сокса IPv6.

Примеры

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

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!("127.0.0.1:8080".parse(), Ok(socket));

let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 8080);
assert_eq!("[::1]:8080".parse(), Ok(socket));
}

Методы

new

#![allow(unused)]
fn main() {
pub const fn new(ip: IpAddr, port: u16) -> SocketAddr
}

Создает новый адрес сокета из IpAddr и номера порта.

Примеры

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

let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(addr.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
assert_eq!(addr.port(), 8080);
}

ip

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

Возвращает IP-адрес, связанный с этим адресом сокета.

Примеры

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

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
}

port

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

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

Примеры

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

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(socket.port(), 8080);
}

set_ip

#![allow(unused)]
fn main() {
pub fn set_ip(&mut self, new_ip: IpAddr)
}

Устанавливает IP-адрес, связанный с этим адресом сокета.

Примеры

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

let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
socket.set_ip(IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));
assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));
}

set_port

#![allow(unused)]
fn main() {
pub fn set_port(&mut self, new_port: u16)
}

Устанавливает номер порта, связанный с этим адресом сокета.

Примеры

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

let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
socket.set_port(1025);
assert_eq!(socket.port(), 1025);
}

is_ipv4

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

Возвращает true, если это адрес сокета IPv4.

Примеры

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

let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
assert_eq!(socket.is_ipv4(), true);
assert_eq!(socket.is_ipv6(), false);
}

is_ipv6

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

Возвращает true, если это адрес сокета IPv6.

Примеры

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

let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 8080);
assert_eq!(socket.is_ipv4(), false);
assert_eq!(socket.is_ipv6(), true);
}

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

From<SocketAddrV4>

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

Преобразует SocketAddrV4 в SocketAddr.

Примеры

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

let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);
let socket_addr = SocketAddr::from(addr);
assert_eq!(socket_addr.ip().to_string(), "127.0.0.1");
assert_eq!(socket_addr.port(), 8080);
}

From<SocketAddrV6>

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

Преобразует SocketAddrV6 в SocketAddr.

Примеры

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

let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
let socket_addr = SocketAddr::from(addr);
assert_eq!(socket_addr.ip().to_string(), "::1");
assert_eq!(socket_addr.port(), 8080);
}

From<(IpAddr, u16)>

#![allow(unused)]
fn main() {
impl From<(IpAddr, u16)> for SocketAddr
}

Преобразует кортеж (IpAddr, u16) в SocketAddr.

Примеры

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

let ip = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let port = 8080;
let socket_addr = SocketAddr::from((ip, port));
assert_eq!(socket_addr.ip().to_string(), "127.0.0.1");
assert_eq!(socket_addr.port(), 8080);
}

From<(Ipv4Addr, u16)>

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

Преобразует кортеж (Ipv4Addr, u16) в SocketAddr.

Примеры

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

let ip = Ipv4Addr::new(127, 0, 0, 1);
let port = 8080;
let socket_addr = SocketAddr::from((ip, port));
assert_eq!(socket_addr.ip().to_string(), "127.0.0.1");
assert_eq!(socket_addr.port(), 8080);
}

From<(Ipv6Addr, u16)>

#![allow(unused)]
fn main() {
impl From<(Ipv6Addr, u16)> for SocketAddr
}

Преобразует кортеж (Ipv6Addr, u16) в SocketAddr.

Примеры

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

let ip = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
let port = 8080;
let socket_addr = SocketAddr::from((ip, port));
assert_eq!(socket_addr.ip().to_string(), "::1");
assert_eq!(socket_addr.port(), 8080);
}

Display, Debug

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

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

Примеры

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

let socket = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
println!("Адрес сокета: {}", socket); // "127.0.0.1:8080"
println!("Отладочная информация: {:?}", socket); // "127.0.0.1:8080"
}

PartialEq, Eq, PartialOrd, Ord, Hash

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

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

Примеры

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

let socket1 = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
let socket2 = SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 8080);
let socket3 = SocketAddr::new(Ipv4Addr::new(192, 168, 0, 1).into(), 8080);

assert_eq!(socket1, socket2);
assert_ne!(socket1, socket3);

let mut map = HashMap::new();
map.insert(socket1, "localhost");
}

FromStr

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

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

Примеры

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

let socket = SocketAddr::from_str("127.0.0.1:8080").unwrap();
assert_eq!(socket.ip().to_string(), "127.0.0.1");
assert_eq!(socket.port(), 8080);

let socket = SocketAddr::from_str("[::1]:8080").unwrap();
assert_eq!(socket.ip().to_string(), "::1");
assert_eq!(socket.port(), 8080);
}

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

Создание и манипуляция адресами сокетов

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

// Создание адреса сокета IPv4
let ipv4_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1)), 8080);
println!("IPv4 адрес: {}", ipv4_addr);

// Создание адреса сокета IPv6
let ipv6_addr = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)), 8080);
println!("IPv6 адрес: {}", ipv6_addr);

// Изменение адреса и порта
let mut socket = ipv4_addr;
socket.set_ip(IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)));
socket.set_port(9090);
println!("Измененный адрес: {}", socket);

// Проверка типа адреса
println!("is_ipv4: {}", socket.is_ipv4());
println!("is_ipv6: {}", socket.is_ipv6());
}

Использование в сетевых операциях

use std::net::{TcpListener, SocketAddr};

fn main() -> std::io::Result<()> {
    // Создание слушателя с конкретным адресом сокета
    let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    let listener = TcpListener::bind(addr)?;
    
    println!("Слушаем на {}", listener.local_addr()?);
    
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                let peer_addr = stream.peer_addr()?;
                println!("Подключение от {}", peer_addr);
                
                // Проверка типа адреса клиента
                if peer_addr.is_ipv6() {
                    println!("Клиент использует IPv6");
                } else {
                    println!("Клиент использует IPv4");
                }
            }
            Err(e) => eprintln!("Ошибка подключения: {}", e),
        }
    }
    Ok(())
}

Сравнение и хеширование

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

let addr1: SocketAddr = "192.168.1.1:80".parse().unwrap();
let addr2: SocketAddr = "192.168.1.1:80".parse().unwrap();
let addr3: SocketAddr = "10.0.0.1:80".parse().unwrap();

// Сравнение
assert_eq!(addr1, addr2);
assert_ne!(addr1, addr3);

// Использование в HashSet
let mut set = HashSet::new();
set.insert(addr1);
set.insert(addr2); // Не добавится, так как дубликат
set.insert(addr3);

println!("Количество уникальных адресов: {}", set.len()); // 2
}