Структура TcpListener

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

TCP-сервер, прослушивающий подключения.

После создания TcpListener путем привязки к адресу сокета, он прослушивает входящие TCP-подключения. Эти подключения могут быть приняты путем вызова accept или через итерацию по incoming, возвращающему итератор.

Сокет будет закрыт, когда структура выйдет из области видимости.

Трансмиссия Control Protocol определяется в IETF RFC 793.

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

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();

for stream in listener.incoming() {
    match stream {
        Ok(stream) => {
            println!("новое подключение: {}", stream.peer_addr().unwrap());
        }
        Err(e) => {
            println!("ошибка подключения: {}", e);
        }
    }
}
}

Методы

bind

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

Создает новый TcpListener, который будет привязан к указанному адресу.

Возвращаемый TcpListener готов для принятия подключений.

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

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

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
}

local_addr

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

Возвращает локальный адрес сокета этого слушателя.

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
println!("адрес: {:?}", listener.local_addr().unwrap());
}

try_clone

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

Создает новый независимо владеемый дескриптор того же нижележащего сокета.

Возвращенный TcpListener является ссылкой на тот же сокет, что и этот объект. Оба дескриптора могут использоваться для принятия подключений, и они будут обрабатывать разные подключения.

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
let listener_clone = listener.try_clone().unwrap();
}

accept

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

Принимает новое входящее подключение из этого слушателя.

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

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
match listener.accept() {
    Ok((_socket, addr)) => println!("новое подключение: {}", addr),
    Err(e) => println!("не удалось принять подключение: {}", e),
}
}

incoming

#![allow(unused)]
fn main() {
pub fn incoming(&self) -> Incoming<'_>
}

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

Итератор никогда не возвращает None и также не содержит ошибок ввода-вывода. Вместо этого ошибки ввода-вывода могут быть получены при вызове next итератора.

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();

for stream in listener.incoming() {
    match stream {
        Ok(stream) => {
            println!("новое подключение: {}", stream.peer_addr().unwrap());
        }
        Err(e) => {
            println!("ошибка подключения: {}", e);
        }
    }
}
}

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::TcpListener;

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

ttl

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

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

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

Примеры

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

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

set_only_v6

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

Устанавливает значение IPV6_V6ONLY для этого сокета.

Если это значение true, то сокет может быть привязан только к IPv6-адресам, и IPv4-подключения не будут приниматься сокетом, привязанным к IPv6-адресу.

Если это значение false, то сокет может быть привязан к IPv6-адресам, и IPv4-подключения будут приняты через IPv4-отображение на IPv6.

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
listener.set_only_v6(false).expect("не удалось установить only_v6");
}

only_v6

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

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

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

Примеры

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

let listener = TcpListener::bind("127.0.0.1:80").unwrap();
listener.set_only_v6(false).expect("не удалось установить only_v6");
assert_eq!(listener.only_v6().unwrap_or(true), false);
}

take_error

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

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

Примеры

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

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

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::TcpListener;
use std::thread;
use std::io;

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

thread::spawn(move || {
    for stream in listener.incoming() {
        match stream {
            Ok(s) => {
                // обрабатываем поток
            }
            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                // ждем, пока сокет станет готовым
                thread::sleep(std::time::Duration::from_millis(100));
                continue;
            }
            Err(e) => panic!("неожиданная ошибка ввода-вывода: {}", e),
        }
    }
});
}

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

AsFd

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

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

AsRawFd

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

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

From<TcpListener>

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

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

From<TcpListener>

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

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

IntoRawFd

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

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

Debug

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

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

Связанные функции

socket2

#![allow(unused)]
fn main() {
impl TcpListener
}

Расширенные операции, доступные при включении функции net в крейте socket2.

Примечания

• Сокет автоматически закрывается при выходе из области видимости
• Все методы блокирующие, если не установлен неблокирующий режим
• Для асинхронных операций используйте крейты async-std или tokio