Структура UdpSocket

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

UDP-сокет.

User Datagram Protocol (UDP) определяется в IETF RFC 768.

После создания UdpSocket путем привязки к адресу сокета, данные могут быть отправлены и получены с помощью методов этого типа.

NOTE: Эта структура доступна в crate std для платформ wasm32-unknown-unknown, начиная с Rust 1.39.0, но в настоящее время она поддерживает только клиентские сокеты и не поддерживает серверные сокеты.

Примеры

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    {
        let socket = UdpSocket::bind("127.0.0.1:34254")?;

        // Читаем из сокета
        let mut buf = [0; 1024];
        let (amt, src) = socket.recv_from(&mut buf)?;

        // Отправляем ответ
        let buf = &mut buf[..amt];
        buf.reverse();
        socket.send_to(buf, &src)?;
    } // сокет закрывается здесь
    Ok(())
}

Методы

bind

#![allow(unused)]
fn main() {
pub fn bind<A: ToSocketAddrs>(addr: A) -> Result<UdpSocket>
}

Создает новый UDP-сокет из заданного адреса.

Адрес типа A может быть любым типом, реализующим ToSocketAddrs. Смотрите его документацию для примеров.

Если addr дает несколько адресов, bind попытается привязаться к каждому из них, пока один не сработает. Если ни один из адресов не работает, возвращается ошибка от последней попытки.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
}

peer_addr

#![allow(unused)]
fn main() {
pub fn peer_addr(&self) -> Result<SocketAddr>
}

Возвращает адрес сокета удаленного узла, к которому подключен этот сокет.

Этот сокет должен быть подключен с помощью connect.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.connect("127.0.0.1:8080").unwrap();
println!("Подключен к {}", socket.peer_addr().unwrap());
}

local_addr

#![allow(unused)]
fn main() {
pub fn local_addr(&self) -> Result<SocketAddr>
}

Возвращает адрес локального сокета этого подключения.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
println!("Локальный адрес: {}", socket.local_addr().unwrap());
}

connect

#![allow(unused)]
fn main() {
pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> Result<()>
}

Подключает этот UDP-сокет к удаленному адресу.

Когда сокет подключен, методы send и recv будут использовать указанный адрес для отправки и получения данных. Кроме того, будут отфильтрованы пакеты, поступающие с других адресов.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.connect("127.0.0.1:8080").expect("Не удалось подключиться");
}

send

#![allow(unused)]
fn main() {
pub fn send(&self, buf: &[u8]) -> Result<usize>
}

Отправляет данные в удаленный адрес, к которому подключен этот сокет.

Сокет должен быть подключен с помощью connect перед вызовом этого метода.

Возвращает количество записанных байт.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.connect("127.0.0.1:8080").unwrap();
socket.send(&[0; 10]).expect("Не удалось отправить данные");
}

recv

#![allow(unused)]
fn main() {
pub fn recv(&self, buf: &mut [u8]) -> Result<usize>
}

Получает данные из сокета.

Сокет должен быть подключен с помощью connect перед вызовом этого метода.

Возвращает количество прочитанных байт.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.connect("127.0.0.1:8080").unwrap();
let mut buf = [0; 10];
let amt = socket.recv(&mut buf).expect("Не удалось получить данные");
println!("Получено {} байт", amt);
}

send_to

#![allow(unused)]
fn main() {
pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> Result<usize>
}

Отправляет данные по указанному адресу.

В отличие от send, этот метод может использоваться без предварительного подключения к адресу.

Возвращает количество записанных байт.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.send_to(&[0; 10], "127.0.0.1:8080").expect("Не удалось отправить данные");
}

recv_from

#![allow(unused)]
fn main() {
pub fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>
}

Получает данные из сокета и возвращает адрес отправителя.

Возвращает кортеж (количество_байт, адрес_отправителя).

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let mut buf = [0; 10];
let (amt, src) = socket.recv_from(&mut buf).expect("Не удалось получить данные");
println!("Получено {} байт от {}", amt, src);
}

broadcast

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

Получает значение параметра SO_BROADCAST для этого сокета.

Для получения дополнительной информации смотрите set_broadcast.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_broadcast(false).unwrap();
assert_eq!(socket.broadcast().unwrap(), false);
}

set_broadcast

#![allow(unused)]
fn main() {
pub fn set_broadcast(&self, broadcast: bool) -> Result<()>
}

Устанавливает значение параметра SO_BROADCAST для этого сокета.

Если установлено true, то сокет может отправлять пакеты на широковещательный адрес.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_broadcast(true).expect("Не удалось установить broadcast");
}

multicast_loop_v4

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

Получает значение параметра IP_MULTICAST_LOOP для этого сокета.

Для получения дополнительной информации смотрите set_multicast_loop_v4.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_loop_v4(false).unwrap();
assert_eq!(socket.multicast_loop_v4().unwrap(), false);
}

set_multicast_loop_v4

#![allow(unused)]
fn main() {
pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> Result<()>
}

Устанавливает значение параметра IP_MULTICAST_LOOP для этого сокета.

Если установлено true, то многоадресные пакеты будут доставляться обратно в локальный сокет.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_loop_v4(true).expect("Не удалось установить multicast_loop_v4");
}

multicast_ttl_v4

#![allow(unused)]
fn main() {
pub fn multicast_ttl_v4(&self) -> Result<u32>
}

Получает значение параметра IP_MULTICAST_TTL для этого сокета.

Для получения дополнительной информации смотрите set_multicast_ttl_v4.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_ttl_v4(1).unwrap();
assert_eq!(socket.multicast_ttl_v4().unwrap(), 1);
}

set_multicast_ttl_v4

#![allow(unused)]
fn main() {
pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> Result<()>
}

Устанавливает значение параметра IP_MULTICAST_TTL для этого сокета.

Устанавливает время жизни (TTL) для многоадресных пакетов.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_ttl_v4(1).expect("Не удалось установить multicast_ttl_v4");
}

multicast_loop_v6

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

Получает значение параметра IPV6_MULTICAST_LOOP для этого сокета.

Для получения дополнительной информации смотрите set_multicast_loop_v6.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_loop_v6(false).unwrap();
assert_eq!(socket.multicast_loop_v6().unwrap(), false);
}

set_multicast_loop_v6

#![allow(unused)]
fn main() {
pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> Result<()>
}

Устанавливает значение параметра IPV6_MULTICAST_LOOP для этого сокета.

Если установлено true, то многоадресные пакеты будут доставляться обратно в локальный сокет.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_multicast_loop_v6(true).expect("Не удалось установить multicast_loop_v6");
}

ttl

#![allow(unused)]
fn main() {
pub fn ttl(&self) -> Result<u32>
}

Получает значение параметра IP_TTL для этого сокета.

Для получения дополнительной информации смотрите set_ttl.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_ttl(100).expect("Не удалось установить TTL");
assert_eq!(socket.ttl().unwrap_or(0), 100);
}

set_ttl

#![allow(unused)]
fn main() {
pub fn set_ttl(&self, ttl: u32) -> Result<()>
}

Устанавливает значение параметра IP_TTL для этого сокета.

Этот параметр устанавливает время жизни (Time-To-Live) для пакетов, отправленных из этого сокета.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_ttl(100).expect("Не удалось установить TTL");
}

join_multicast_v4

#![allow(unused)]
fn main() {
pub fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> Result<()>
}

Присоединяется к многоадресной группе IPv4.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let multiaddr = Ipv4Addr::new(224, 0, 0, 1);
let interface = Ipv4Addr::new(0, 0, 0, 0);
socket.join_multicast_v4(&multiaddr, &interface).expect("Не удалось присоединиться к группе");
}

join_multicast_v6

#![allow(unused)]
fn main() {
pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> Result<()>
}

Присоединяется к многоадресной группе IPv6.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let multiaddr = Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 1);
socket.join_multicast_v6(&multiaddr, 0).expect("Не удалось присоединиться к группе");
}

leave_multicast_v4

#![allow(unused)]
fn main() {
pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> Result<()>
}

Покидает многоадресную группу IPv4.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let multiaddr = Ipv4Addr::new(224, 0, 0, 1);
let interface = Ipv4Addr::new(0, 0, 0, 0);
socket.leave_multicast_v4(&multiaddr, &interface).expect("Не удалось покинуть группу");
}

leave_multicast_v6

#![allow(unused)]
fn main() {
pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> Result<()>
}

Покидает многоадресную группу IPv6.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let multiaddr = Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 1);
socket.leave_multicast_v6(&multiaddr, 0).expect("Не удалось покинуть группу");
}

set_nonblocking

#![allow(unused)]
fn main() {
pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()>
}

Переводит сокет в неблокирующий режим.

Если nonblocking равно true, то операции над сокетом, которые блокировали бы, будут возвращать ошибки вместо блокировки. Если nonblocking равно false, то сокет будет работать в блокирующем режиме.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
socket.set_nonblocking(true).expect("Не удалось установить неблокирующий режим");

let mut buf = [0; 10];
match socket.recv_from(&mut buf) {
    Ok((n, addr)) => println!("Получено {} байт от {}", n, addr),
    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
        // Данные пока не доступны
    }
    Err(e) => panic!("Неожиданная ошибка ввода-вывода: {}", e),
}
}

take_error

#![allow(unused)]
fn main() {
pub fn take_error(&self) -> Result<Option<Error>>
}

Получает значение параметра сокета SO_ERROR.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
if let Ok(Some(error)) = socket.take_error() {
    println!("Ошибка сокета: {}", error);
}
}

peek

#![allow(unused)]
fn main() {
pub fn peek(&self, buf: &mut [u8]) -> Result<usize>
}

Читает данные из сокета без удаления их из буфера.

Эта функция работает как recv, но данные, прочитанные через peek, остаются доступными для последующих вызовов recv.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let mut buf = [0; 10];
let n = socket.peek(&mut buf).expect("Ошибка peek");
println!("Просмотрено {} байт: {:?}", n, &buf[..n]);
}

peek_from

#![allow(unused)]
fn main() {
pub fn peek_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>
}

Читает данные из сокета без удаления их из буфера и возвращает адрес отправителя.

Эта функция работает как recv_from, но данные, прочитанные через peek_from, остаются доступными для последующих вызовов recv_from.

Примеры

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

let socket = UdpSocket::bind("127.0.0.1:34254").unwrap();
let mut buf = [0; 10];
let (n, addr) = socket.peek_from(&mut buf).expect("Ошибка peek_from");
println!("Просмотрено {} байт от {}: {:?}", n, addr, &buf[..n]);
}

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

AsFd

#![allow(unused)]
fn main() {
impl AsFd for UdpSocket
}

Используется операционной системой для представления низкоуровневого дескриптора файла.

AsRawFd

#![allow(unused)]
fn main() {
impl AsRawFd for UdpSocket
}

Представляет необработанный дескриптор файла.

From<UdpSocket>

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

Преобразует UdpSocket в Arc<UdpSocket>.

From<UdpSocket>

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

Преобразует UdpSocket в Socket.

IntoRawFd

#![allow(unused)]
fn main() {
impl IntoRawFd for UdpSocket
}

Потребляет этот объект, возвращая необработанный дескриптор файла.

Debug

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

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

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

use std::net::UdpSocket;
use std::thread;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:0")?;
    
    // Настройка параметров сокета
    socket.set_broadcast(true)?;
    socket.set_ttl(64)?;
    socket.set_nonblocking(false)?;
    
    // Подключение к удаленному адресу
    socket.connect("127.0.0.1:8080")?;
    
    // Отправка данных
    socket.send(b"Hello, server!")?;
    
    // Получение ответа
    let mut buf = [0; 1024];
    let amt = socket.recv(&mut buf)?;
    
    println!("Получен ответ: {} байт", amt);
    Ok(())
}