Struct std::os::unix::net::SocketAddr

pub struct SocketAddr { /* private fields */ }

This is supported on Unix only.

An address associated with a Unix socket.

Examples

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

let socket = match UnixListener::bind("/tmp/sock") {
    Ok(sock) => sock,
    Err(e) => {
        println!("Couldn't bind: {:?}", e);
        return
    }
};
let addr = socket.local_addr().expect("Couldn't get local address");

Implementations

impl SocketAddr

pub fn from_path<P>(path: P) -> Result<SocketAddr> where
    P: AsRef<Path>, 

🔬 This is a nightly-only experimental API. (unix_socket_creation #93423)

Constructs a SockAddr with the family AF_UNIX and the provided path.

Errors

Returns an error if the path is longer than SUN_LEN or if it contains NULL bytes.

Examples

#![feature(unix_socket_creation)]
use std::os::unix::net::SocketAddr;
use std::path::Path;

let address = SocketAddr::from_path("/path/to/socket")?;
assert_eq!(address.as_pathname(), Some(Path::new("/path/to/socket")));

Creating a SocketAddr with a NULL byte results in an error.

#![feature(unix_socket_creation)]
use std::os::unix::net::SocketAddr;

assert!(SocketAddr::from_path("/path/with/\0/bytes").is_err());

pub fn is_unnamed(&self) -> bool

Returns true if the address is unnamed.

Examples

A named address:

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

fn main() -> std::io::Result<()> {
    let socket = UnixListener::bind("/tmp/sock")?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.is_unnamed(), false);
    Ok(())
}

An unnamed address:

use std::os::unix::net::UnixDatagram;

fn main() -> std::io::Result<()> {
    let socket = UnixDatagram::unbound()?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.is_unnamed(), true);
    Ok(())
}

pub fn as_pathname(&self) -> Option<&Path>

Returns the contents of this address if it is a pathname address.

Examples

With a pathname:

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

fn main() -> std::io::Result<()> {
    let socket = UnixListener::bind("/tmp/sock")?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/sock")));
    Ok(())
}

Without a pathname:

use std::os::unix::net::UnixDatagram;

fn main() -> std::io::Result<()> {
    let socket = UnixDatagram::unbound()?;
    let addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(addr.as_pathname(), None);
    Ok(())
}

pub fn as_abstract_namespace(&self) -> Option<&[u8]>

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

This is supported on Android or Linux only.

Returns the contents of this address if it is an abstract namespace without the leading null byte.

Examples

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

fn main() -> std::io::Result<()> {
    let namespace = b"hidden";
    let namespace_addr = SocketAddr::from_abstract_namespace(&namespace[..])?;
    let socket = UnixListener::bind_addr(&namespace_addr)?;
    let local_addr = socket.local_addr().expect("Couldn't get local address");
    assert_eq!(local_addr.as_abstract_namespace(), Some(&namespace[..]));
    Ok(())
}

pub fn from_abstract_namespace(namespace: &[u8]) -> Result<SocketAddr>

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

This is supported on Android or Linux only.

Creates an abstract domain socket address from a namespace

An abstract address does not create a file unlike traditional path-based Unix sockets. The advantage of this is that the address will disappear when the socket bound to it is closed, so no filesystem clean up is required.

The leading null byte for the abstract namespace is automatically added.

This is a Linux-specific extension. See more at unix(7).

Errors

This will return an error if the given namespace is too long

Examples

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

fn main() -> std::io::Result<()> {
    let addr = SocketAddr::from_abstract_namespace(b"hidden")?;
    let listener = match UnixListener::bind_addr(&addr) {
        Ok(sock) => sock,
        Err(err) => {
            println!("Couldn't bind: {:?}", err);
            return Err(err);
        }
    };
    Ok(())
}

Trait Implementations

impl Clone for SocketAddr

fn clone(&self) -> SocketAddr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SocketAddr

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

Formats the value using the given formatter.