Struct std::os::unix::net::UnixListener1.10.0[−][src]

pub struct UnixListener(_);

This is supported on Unix only.

Expand description

表示 Unix 域套接字服务器的结构体。

Examples

use std::thread;
use std::os::unix::net::{UnixStream, UnixListener};

fn handle_client(stream: UnixStream) {
    // ...
}

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;

    // 接受连接并处理它们，为每个连接产生一个新线程
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                /* connection succeeded */
                thread::spawn(|| handle_client(stream));
            }
            Err(err) => {
                /* connection failed */
                break;
            }
        }
    }
    Ok(())
}

Run

Implementations

impl UnixListener

[src]

pub fn bind<P: AsRef<Path>>(path: P) -> Result<UnixListener>

[src]

创建绑定到指定套接字的新 UnixListener。

Examples

use std::os::unix::net::UnixListener;

let listener = match UnixListener::bind("/path/to/the/socket") {
    Ok(sock) => sock,
    Err(e) => {
        println!("Couldn't connect: {:?}", e);
        return
    }
};

Run

pub fn accept(&self) -> Result<(UnixStream, SocketAddr )>

[src]

接受与此侦听器的新传入连接。

该函数将阻塞调用线程，直到建立新的 Unix 连接为止。建立后，将返回相应的 UnixStream 和远程对等方的地址。

Examples

use std::os::unix::net::UnixListener;

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;

    match listener.accept() {
        Ok((socket, addr)) => println!("Got a client: {:?}", addr),
        Err(e) => println!("accept function failed: {:?}", e),
    }
    Ok(())
}

Run

pub fn try_clone(&self) -> Result<UnixListener>

[src]

为基础套接字创建一个新的独立拥有的句柄。

返回的 UnixListener 是与此 object 引用相同的套接字的引用。这两个句柄均可用于接受传入连接，并且在一个侦听器上设置的选项将影响另一个。

Examples

use std::os::unix::net::UnixListener;

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;
    let listener_copy = listener.try_clone().expect("try_clone failed");
    Ok(())
}

Run

pub fn local_addr(&self) -> Result<SocketAddr>

[src]

返回此侦听器的本地套接字地址。

Examples

use std::os::unix::net::UnixListener;

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;
    let addr = listener.local_addr().expect("Couldn't get local address");
    Ok(())
}

Run

pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()>

[src]

将套接字移入或移出非阻塞模式。

这将导致 accept 操作变为非阻塞，即立即从其调用中返回。如果 IO 操作成功，则返回 Ok，并且不需要进一步的操作。如果 IO 操作无法完成，需要重试，则返回类型为 io::ErrorKind::WouldBlock 的错误。

Examples

use std::os::unix::net::UnixListener;

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;
    listener.set_nonblocking(true).expect("Couldn't set non blocking");
    Ok(())
}

Run

pub fn take_error(&self) -> Result<Option<Error>>

[src]

返回 SO_ERROR 选项的值。

Examples

use std::os::unix::net::UnixListener;

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/tmp/sock")?;

    if let Ok(Some(err)) = listener.take_error() {
        println!("Got error: {:?}", err);
    }
    Ok(())
}

Run

特定于平台

在 Redox 上，它总是返回 None。

pub fn incoming(&self) -> Incoming<'_>ⓘ
Notable traits for Incoming<'a>
`impl<'a> Iterator for Incoming<'a> type Item = Result<UnixStream>;`

[src]

返回传入连接上的迭代器。

迭代器将永远不会返回 None，也不会产生对等方的 SocketAddr 结构体。

Examples

use std::thread;
use std::os::unix::net::{UnixStream, UnixListener};

fn handle_client(stream: UnixStream) {
    // ...
}

fn main() -> std::io::Result<()> {
    let listener = UnixListener::bind("/path/to/the/socket")?;

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                thread::spawn(|| handle_client(stream));
            }
            Err(err) => {
                break;
            }
        }
    }
    Ok(())
}