Struct UnixSeqpacketListener 

pub struct UnixSeqpacketListener { /* private fields */ }

An unix domain listener for sequential packet connections.

See UnixSeqpacketConn for a description of this type of connection.

Registering with Xio (xio-rs) a feature = “xio-rs”

A XioEventPipe is implemented on this function. During initial registration an attempt set nonblocking mode is performed during initial registration.

See examples below.

Registering with Mio (mio) a feature = “mio”

A Source is implemented on the instance.During initial registration an attempt set nonblocking mode is performed during initial registration.

Examples

use tempfile::TempDir;
 
let dir = tempfile::tempdir().unwrap();
let mut file_path = dir.path().join("seqpacket_listener.socket");
 
let listener = uds_fork::UnixSeqpacketListener::bind(&file_path)
    .expect("Create seqpacket listener");
let _client = uds_fork::UnixSeqpacketConn::connect(&file_path).unwrap();
let (conn, _addr) = listener.accept_unix_addr().unwrap();
conn.send(b"Welcome").unwrap();

Xio

let listener = uds_fork::UnixSeqpacketListener::bind(file_path).unwrap();
 
let mut reg = XioPollRegistry::<ESS>::new().unwrap();
let mut event_buf = XioPollRegistry::<ESS>::allocate_events(128.try_into().unwrap());
 
// either
let a_wrapped =
    reg.get_registry()
        .en_register_wrap(listener, XioEventUid::manual(1), XioChannel::INPUT)
        .unwrap();
  
// or 
    reg.get_registry()
        .en_register&mut listener, XioEventUid::manual(1), XioChannel::INPUT)
        .unwrap();
 
// so depending on the method, use either:
a_wrapped.inner();
 
// or continue using a directly

Mio:

let listener = uds_fork::UnixSeqpacketListener::bind(file_path).unwrap();
 
let mut poll = Poll::new().expect("create mio poll");
let mut events = Events::with_capacity(10);
 
poll.registry()
    .register(&mut listener, Token(1), Interest::READABLE)
    .unwrap();
// ...

Implementations

impl UnixSeqpacketListener

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

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

pub fn bind_unix_addr(addr: &UnixSocketAddr) -> Result<Self, 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 the socket is listening on.

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

Accepts a new incoming connection to this listener.

Rustdocs:

This function will block the calling thread until a new Unix connection is established. When established, the corresponding UnixSeqpacketConn and the remote peer’s address will be returned.

Examples

use uds_fork::UnixSeqpacketListener;

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

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

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

Accepts a new incoming connection to this listener.

See Self::accept.

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 std::unix::net::UnixListener.

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

Creates a new file descriptor listening for the same connections.

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

Sets a maximum duration to wait in a single accept() on this socket.

None disables a previously set timeout. An error is returned if the duration is zero.

Operating System Support

Only Linux appers to apply timeouts to accept().
On macOS, FreeBSD and NetBSD, timeouts are silently ignored.
On Illumos setting timeouts for all unix domain sockets silently fails.

On OSes where timeouts are known to not work, this function will return an error even if setting the timeout didn’t fail.

Examples

let listener = UnixSeqpacketListener::bind_unix_addr(&addr).unwrap();
listener.set_timeout(Some(Duration::new(0, 200_000_000))).unwrap();
let err = listener.accept_unix_addr().unwrap_err();
assert_eq!(err.kind(), ErrorKind::WouldBlock);

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

Returns the timeout for accept() on this socket.

None is returned if there is no timeout.

Even if a timeout has is set, it is ignored by accept() on most operating systems except Linux.

Examples

let listener = UnixSeqpacketListener::bind_unix_addr(&addr).unwrap();
assert_eq!(listener.timeout().unwrap(), None);
let timeout = Some(Duration::new(2, 0));
listener.set_timeout(timeout).unwrap();
assert_eq!(listener.timeout().unwrap(), timeout);

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

Enables or disables nonblocking-ness of [accept_unix_addr()](#method.accept_unix addr).

The returned connnections will still be in blocking mode regardsless.

Consider using the nonblocking variant of this type instead; this method mostly exists for feature parity with std’s UnixListener.

Examples

use tempfile::TempDir;
 
let dir = tempfile::tempdir().unwrap();
let mut file_path = dir.path().join("nonblocking_seqpacket_listener1.socket");
 
let addr = UnixSocketAddr::from_path(&file_path).unwrap();
let listener = UnixSeqpacketListener::bind_unix_addr(&addr).expect("create listener");
listener.set_nonblocking(true).expect("enable noblocking mode");
assert_eq!(listener.accept_unix_addr().unwrap_err().kind(), ErrorKind::WouldBlock);

pub fn incoming(&self) -> Incoming<'_>

Returns an iterator over incoming connections.

Rustdoc:

The iterator will never return None and will also not yield the peer’s UnixSocketAddr structure.

use std::thread;
use uds_fork::{UnixSeqpacketConn, UnixSeqpacketListener};

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

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

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

Trait Implementations

impl AsFd for UnixSeqpacketListener

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl AsRawFd for UnixSeqpacketListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for UnixSeqpacketListener

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

Formats the value using the given formatter.

impl From<OwnedFd> for UnixSeqpacketListener

fn from(ofd: OwnedFd) -> Self

Converts to this type from the input type.

impl From<UnixSeqpacketListener> for OwnedFd

fn from(value: UnixSeqpacketListener) -> Self

Converts to this type from the input type.

impl FromRawFd for UnixSeqpacketListener

unsafe fn from_raw_fd(fd: RawFd) -> Self

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

impl<'a> IntoIterator for &'a UnixSeqpacketListener

type Item = Result<UnixSeqpacketConn, Error>

The type of the elements being iterated over.

type IntoIter = Incoming<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Incoming<'a>

Creates an iterator from a value.

impl IntoRawFd for UnixSeqpacketListener

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl Source for UnixSeqpacketListener

fn register( &mut self, registry: &Registry, token: Token, interests: Interest, ) -> Result<()>

Register self with the given Registry instance.

fn reregister( &mut self, registry: &Registry, token: Token, interests: Interest, ) -> Result<()>

Re-register self with the given Registry instance.

fn deregister(&mut self, registry: &Registry) -> Result<()>

Deregister self from the given Registry instance.

impl<ESSR: EsInterfaceRegistry> XioEventPipe<ESSR> for UnixSeqpacketListener

fn connect_event_pipe( &mut self, ess: &XioRegistry<ESSR>, ev_uid: XioEventUid, channel: XioChannel, ) -> XioResult<()>

Should connect the self to the endpoint which is provided by the argument ess.

fn modify_event_pipe( &mut self, ess: &XioRegistry<ESSR>, ev_uid: XioEventUid, channel: XioChannel, ) -> XioResult<()>

This interface function should be reimplemented soon.

fn disconnect_event_pipe(&mut self, ess: &XioRegistry<ESSR>) -> XioResult<()>

Should disconnect self from the ess provided endpoint. An instance which implements the logic should check that the ess matches the ess used when self was initially registered (if available).