Enum AncillaryData

pub enum AncillaryData<'a> {
    FileDescriptors(Cow<'a, [c_int]>),
    Credentials {
        pid: pid_t,
        uid: uid_t,
        gid: gid_t,
    },
}

Available on Unix only.

Ancillary data to be sent through a Unix domain socket or read from an input buffer.

Ancillary data gives unique possibilities to Unix domain sockets which no other POSIX API has: passing file descriptors between two processes which do not have a parent-child relationship. It also can be used to transfer credentials of a process reliably.

Variants

FileDescriptors(Cow<'a, [c_int]>)

One or more file descriptors to be sent.

Credentials

Available on Linux and (GNU or musl or target_env="musleabi" or target_env="musleabihf"), or Emscripten, or Redox only.

Credentials to be sent. The specified values are checked by the system when sent for all users except for the superuser – for senders, this means that the correct values need to be filled out, otherwise, an error is returned; for receivers, this means that the credentials are to be trusted for authentification purposes. For convenience, the credentials function provides a value which is known to be valid when sent.

Fields

pid: pid_t

The process identificator (PID) for the process.

uid: uid_t

The user identificator (UID) of the user who started the process.

gid: gid_t

The group identificator (GID) of the user who started the process.

Implementations

impl<'a> AncillaryData<'a>

pub const ENCODED_SIZE_OF_CREDENTIALS: usize = 28usize

The size of a single AncillaryData::Credentials element when packed into the Unix ancillary data format. Useful for allocating a buffer when you expect to receive credentials.

pub const fn encoded_size_of_file_descriptors(num_descriptors: usize) -> usize

Calculates the size of an AncillaryData::FileDescriptors element with the specified amount of file descriptors when packed into the Unix ancillary data format. Useful for allocating a buffer when you expect to receive a specific amount of file descriptors.

pub fn clone_ref(&'a self) -> Self

Inexpensievly clones self by borrowing the FileDescriptors variant or copying the Credentials variant.

pub fn encoded_size(&self) -> usize

Returns the size of an ancillary data element when packed into the Unix ancillary data format.

pub fn encode( op: impl IntoIterator<Item = Self>, ) -> EncodedAncillaryData<'static>

Encodes the ancillary data into EncodedAncillaryData which is ready to be sent via a Unix domain socket.

impl AncillaryData<'static>

pub fn credentials() -> Self

Available on Linux and (GNU or musl or target_env="musleabi" or target_env="musleabihf"), or Emscripten, or Redox only.

Fetches the credentials of the process from the system and returns a value which can be safely sent to another process without the system complaining about an unauthorized attempt to impersonate another process/user/group.

If you want to send credentials to another process, this is usually the function you need to obtain the desired ancillary payload.

Trait Implementations

impl<'a> Clone for AncillaryData<'a>

fn clone(&self) -> AncillaryData<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AncillaryData<'a>

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

Formats the value using the given formatter.

impl<'b> FromIterator<AncillaryData<'b>> for EncodedAncillaryData<'static>

fn from_iter<I: IntoIterator<Item = AncillaryData<'b>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> Hash for AncillaryData<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for AncillaryData<'a>

fn eq(&self, other: &AncillaryData<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for AncillaryData<'a>

impl<'a> StructuralPartialEq for AncillaryData<'a>