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

pub struct UnixStream(_);

This is supported on Unix only.

Expand description

Unix 流套接字。

Examples

use std::os::unix::net::UnixStream;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let mut stream = UnixStream::connect("/path/to/my/socket")?;
    stream.write_all(b"hello world")?;
    let mut response = String::new();
    stream.read_to_string(&mut response)?;
    println!("{}", response);
    Ok(())
}

Run

Implementations

[src]

impl UnixStream

[src]

pub fn connect<P: AsRef<Path>>(path: P) -> Result<UnixStream>

连接到以 path 命名的套接字。

Examples

use std::os::unix::net::UnixStream;

let socket = match UnixStream::connect("/tmp/sock") {
    Ok(sock) => sock,
    Err(e) => {
        println!("Couldn't connect: {:?}", e);
        return
    }
};

Run

[src]

pub fn connect_addr(socket_addr: &SocketAddr) -> Result<UnixStream>

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

连接到 address 指定的套接字。

Examples

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

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

    let sock = match UnixStream::connect_addr(&addr) {
        Ok(sock) => sock,
        Err(e) => {
            println!("Couldn't connect: {:?}", e);
            return Err(e)
        }
    };
    Ok(())
}

Run

[src]

pub fn pair() -> Result<(UnixStream, UnixStream )>

创建一对未命名的已连接套接字。

返回两个相互连接的 UnixStream。

Examples

use std::os::unix::net::UnixStream;

let (sock1, sock2) = match UnixStream::pair() {
    Ok((sock1, sock2)) => (sock1, sock2),
    Err(e) => {
        println!("Couldn't create a pair of sockets: {:?}", e);
        return
    }
};

Run

[src]

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

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

返回的 UnixStream 是与此对象引用相同的流的引用。两个句柄将读取和写入相同的数据流，并且在一个流上设置的选项将传播到另一流。

Examples

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let sock_copy = socket.try_clone().expect("Couldn't clone socket");
    Ok(())
}

Run

[src]

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

返回此连接本地一半的套接字地址。

Examples

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    Ok(())
}

Run

[src]

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

返回此连接的另一半的套接字地址。

Examples

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let addr = socket.peer_addr().expect("Couldn't get peer address");
    Ok(())
}

Run

[src]

pub fn peer_cred(&self) -> Result<UCred>

🔬 This is a nightly-only experimental API. (peer_credentials_unix_socket #42839)

获取此 Unix 域套接字的对等凭据。

Examples

#![feature(peer_credentials_unix_socket)]
use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let peer_cred = socket.peer_cred().expect("Couldn't get peer credentials");
    Ok(())
}

Run

[src]

pub fn set_read_timeout(&self, timeout: Option<Duration>) -> Result<()>

设置套接字的读取超时。

如果提供的值为 None，则 read 调用将无限期阻塞。如果将零 Duration 传递给此方法，则返回 Err。

Examples

use std::os::unix::net::UnixStream;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
    Ok(())
}

Run

如果将零 Duration 传递给此方法，则返回 Err：

use std::io;
use std::os::unix::net::UnixStream;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
    let err = result.unwrap_err();
    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
    Ok(())
}

Run

[src]

pub fn set_write_timeout(&self, timeout: Option<Duration>) -> Result<()>

设置套接字的写超时。

如果提供的值为 None，则 write 调用将无限期阻塞。如果将零 Duration 传递给此方法，则返回 Err。

Examples

use std::os::unix::net::UnixStream;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_write_timeout(Some(Duration::new(1, 0)))
        .expect("Couldn't set write timeout");
    Ok(())
}

Run

如果将零 Duration 传递给此方法，则返回 Err：

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

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:34254")?;
    let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
    let err = result.unwrap_err();
    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
    Ok(())
}

Run

[src]

pub fn read_timeout(&self) -> Result<Option<Duration>>

返回此套接字的读取超时。

Examples

use std::os::unix::net::UnixStream;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
    assert_eq!(socket.read_timeout()?, Some(Duration::new(1, 0)));
    Ok(())
}

Run

[src]

pub fn write_timeout(&self) -> Result<Option<Duration>>

返回此套接字的写入超时。

Examples

use std::os::unix::net::UnixStream;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_write_timeout(Some(Duration::new(1, 0)))
        .expect("Couldn't set write timeout");
    assert_eq!(socket.write_timeout()?, Some(Duration::new(1, 0)));
    Ok(())
}

Run

[src]

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

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

Examples

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_nonblocking(true).expect("Couldn't set nonblocking");
    Ok(())
}

Run

[src]

pub fn set_passcred(&self, passcred: bool) -> Result<()>

🔬 This is a nightly-only experimental API. (unix_socket_ancillary_data #76915)

移动套接字以将 unix 凭据作为 SocketAncillary 中的控制消息传递。

设置套接字选项 SO_PASSCRED。

Examples

#![feature(unix_socket_ancillary_data)]
use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.set_passcred(true).expect("Couldn't set passcred");
    Ok(())
}

Run

[src]

pub fn passcred(&self) -> Result<bool>

🔬 This is a nightly-only experimental API. (unix_socket_ancillary_data #76915)

获取用于在 SocketAncillary 中传递 unix 凭据的套接字的当前值。可以通过 set_passcred 更改此值。

获取套接字选项 SO_PASSCRED。

[src]

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

返回 SO_ERROR 选项的值。

Examples

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    if let Ok(Some(err)) = socket.take_error() {
        println!("Got error: {:?}", err);
    }
    Ok(())
}

Run

特定于平台

在 Redox 上，它总是返回 None。

[src]

pub fn shutdown(&self, how: Shutdown) -> Result<()>

关闭此连接的读取，写入或两半。

此函数将导致对指定部分的所有未决和 future I/O 调用立即返回适当的值 (请参见 Shutdown 的文档)。

Examples

use std::os::unix::net::UnixStream;
use std::net::Shutdown;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    socket.shutdown(Shutdown::Both).expect("shutdown function failed");
    Ok(())
}

Run

[src]

pub fn peek(&self, buf: &mut [u8 ]) -> Result<usize>

🔬 This is a nightly-only experimental API. (unix_socket_peek #76923)

从套接字所连接的远程地址接收套接字上的数据，而无需从队列中删除该数据。

成功时，返回偷看的字节数。

连续调用返回相同的数据。这是通过将 MSG_PEEK 作为标志传递给底层的 recv 系统调用来实现的。

Examples

#![feature(unix_socket_peek)]

use std::os::unix::net::UnixStream;

fn main() -> std::io::Result<()> {
    let socket = UnixStream::connect("/tmp/sock")?;
    let mut buf = [0; 10];
    let len = socket.peek(&mut buf).expect("peek failed");
    Ok(())
}