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

[src]

impl UnixListener

[src]

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

创建绑定到指定套接字的新 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

[src]

pub fn bind_addr(socket_addr: &SocketAddr) -> Result<UnixListener>

🔬 This is a nightly-only experimental API. (unix_socket_abstract #85410)

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

Examples

#![feature(unix_socket_abstract)]
use std::os::unix::net::{UnixListener};

fn main() -> std::io::Result<()> {
    let listener1 = UnixListener::bind("path/to/socket")?;
    let addr = listener1.local_addr()?;

    let listener2 = match UnixListener::bind_addr(&addr) {
        Ok(sock) => sock,
        Err(err) => {
            println!("Couldn't bind: {:?}", err);
            return Err(err);
        }
    };
    Ok(())
}

Run

[src]

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

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

该函数将阻塞调用线程，直到建立新的 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

[src]

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

为底层套接字创建一个新的独立的拥有所有权的句柄。

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

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

[src]

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

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

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

[src]

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

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

这将导致 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

[src]

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

返回 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。

[src]

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

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

迭代器将永远不会返回 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(())
}