Struct otter_api_tests::imports::uds::nonblocking::UnixSeqpacketListener

#[repr(transparent)]
pub struct UnixSeqpacketListener { /* fields omitted */ }

A non-blocking unix domain listener for sequential-packet connections.

Differs from UnixSeqpacketListener in that accept() returns non-blocking connection sockets and doesn’t block if no client connect()ions are pending.

This type can be used with mio if the mio feature is enabled:

uds = { version = "x.y", features=["mio"] }

Examples

use uds::nonblocking::{UnixSeqpacketListener, UnixSeqpacketConn};
use std::io::ErrorKind;

let listener = UnixSeqpacketListener::bind("nonblocking_seqpacket_listener.socket")
    .expect("Cannot create nonblocking seqpacket listener");

// doesn't block if no connections are waiting:
assert_eq!(listener.accept_unix_addr().unwrap_err().kind(), ErrorKind::WouldBlock);

// returned connections are nonblocking:
let _client = UnixSeqpacketConn::connect("nonblocking_seqpacket_listener.socket").unwrap();
let (conn, _addr) = listener.accept_unix_addr().unwrap();
assert_eq!(conn.recv(&mut[0u8; 20]).unwrap_err().kind(), ErrorKind::WouldBlock);

Registering with mio (v0.7):

use uds::nonblocking::{UnixSeqpacketListener, UnixSeqpacketConn};
use mio_07::{Poll, Events, Token, Interest};
use std::io::ErrorKind;

# let _ = std::fs::remove_file("seqpacket.sock");
let listener = UnixSeqpacketListener::bind("seqpacket.sock")
    .expect("create nonblocking seqpacket listener");

let mut poll = Poll::new().expect("create mio poll");
let mut events = Events::with_capacity(10);
poll.registry()
    .register(&mut &listener, Token(0), Interest::READABLE)
    .expect("register unix seqpacket listener with mio");

let _conn = UnixSeqpacketConn::connect("seqpacket.sock")
    .expect("create nonblocking seqpacket socket and connect to listener");

poll.poll(&mut events, None).expect("receive mio notifications");
let current_events = events.iter().collect::<Vec<_>>();
assert!(current_events.len() > 0);
assert_eq!(current_events[0].token(), Token(0));
let (_, _addr) = listener.accept_unix_addr().expect("accept connection");

Implementations

impl NonblockingUnixSeqpacketListener

pub fn bind<P>(path: P) -> Result<NonblockingUnixSeqpacketListener, Error> where
    P: AsRef<Path>, 

Creates a socket that listens for seqpacket connections on the specified socket file.

pub fn bind_unix_addr(
    addr: &UnixSocketAddr
) -> Result<NonblockingUnixSeqpacketListener, Error>

Creates a socket that listens for seqpacket connections on the specified address.

pub fn local_unix_addr(&self) -> Result<UnixSocketAddr, Error>

Returns the address this listener was bound to.

pub fn accept_unix_addr(
    &self
) -> Result<(NonblockingUnixSeqpacketConn, UnixSocketAddr), Error>

Accepts a non-blocking connection, non-blockingly.

Examples

Doesn’t block if no connections are waiting:

let _ = std::fs::remove_file("nonblocking_seqpacket_listener.socket");
let listener = UnixSeqpacketListener::bind("nonblocking_seqpacket_listener.socket")
    .expect("Cannot create nonblocking seqpacket listener");
assert_eq!(listener.accept_unix_addr().unwrap_err().kind(), ErrorKind::WouldBlock);
std::fs::remove_file("nonblocking_seqpacket_listener.socket").unwrap();

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

Returns the value of the SO_ERROR option.

This might never produce any errors for listeners. It is therefore unlikely to be useful, but is provided for parity with mios UnixListener.

Examples

let listener = uds::nonblocking::UnixSeqpacketListener::bind_unix_addr(
    &uds::UnixSocketAddr::new("@nonblocking_take_error").unwrap()
).unwrap();

assert!(listener.accept_unix_addr().is_err());
assert!(listener.take_error().unwrap().is_none());

pub fn try_clone(&self) -> Result<NonblockingUnixSeqpacketListener, Error>

Creates a new file descriptor listening for the same connections.

Trait Implementations

impl AsRawFd for NonblockingUnixSeqpacketListener

pub fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl Debug for NonblockingUnixSeqpacketListener

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Drop for NonblockingUnixSeqpacketListener

pub fn drop(&mut self)

Executes the destructor for this type.

impl FromRawFd for NonblockingUnixSeqpacketListener

pub unsafe fn from_raw_fd(fd: i32) -> NonblockingUnixSeqpacketListener

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for NonblockingUnixSeqpacketListener

pub fn into_raw_fd(self) -> i32

Consumes this object, returning the raw underlying file descriptor.