Struct async_rustbus::rustbus_core::wire::UnixFd

pub struct UnixFd(_);

UnixFd is a wrapper around RawFd, to ensure that opened FDs are closed again, while still having the possibility of having multiple references to it.

“Ownership” as in responsibility of closing the FD works as follows:

1. You can call take_raw_fd(). At this point UnixFd releases ownership. You are now responsible of closing the FD.
2. You can call get_raw_fd(). This will not release ownership, UnixFd will still close it if no more references to it exist.

UnixFds and messages

1. When a UnixFd is marshalled rustbus will dup() the FD so that the message and the original UnixFd do not depend on each others lifetime. You are free to use or close the original one.
2. When a UnixFd is unmarshalled rustbus will NOT dup() the FD. This means if you call take_raw_fd(), it is gone from the message too! If you do not want this, you have to call dup() and then get_raw_fd() or take_raw_fd()

Implementations

impl UnixFd

pub fn new(fd: i32) -> UnixFd

pub fn get_raw_fd(&self) -> Option<i32>

Gets a non-owning RawFd. If None is returned. then this UnixFd has already been taken by somebody else and is no longer valid.

pub fn take_raw_fd(self) -> Option<i32>

Gets a owning RawFd from the UnixFd. Subsequent attempt to get the RawFd from other UnixFd referencing the same file descriptor will fail.

pub fn dup(&self) -> Result<UnixFd, DupError>

Duplicate the underlying FD so you can use it as you will. This is different from just calling clone(). Clone only makes a new ref to the same underlying FD.

Trait Implementations

impl Clone for UnixFd

pub fn clone(&self) -> UnixFd

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnixFd

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

Formats the value using the given formatter.

impl Hash for UnixFd

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Marshal for UnixFd

pub fn marshal(&self, ctx: &mut MarshalContext<'_, '_>) -> Result<(), Error>

fn marshal_as_variant(
    &self,
    ctx: &mut MarshalContext<'_, '_>
) -> Result<(), Error>

impl PartialEq<UnixFd> for UnixFd

Allow for the comparison of UnixFd even after the RawFd has been taken, to see if they originally referred to the same thing.

pub fn eq(&self, other: &UnixFd) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Signature for UnixFd

pub fn signature() -> Type

pub fn alignment() -> usize

pub fn sig_str(s_buf: &mut SignatureBuffer)

Appends the signature of the type to the SignatureBuffer.

pub fn has_sig(sig: &str) -> bool

Check if this type fulfills this signature. This may expect to only be called with valid signatures. But it might be called with the wrong signature. This means for example you must check the length before indexing.

unsafe fn valid_slice(_bo: ByteOrder) -> bool

If this returns true, it indicates that for implementing type T, Rust’s [T] is identical to DBus’s array format and can be copied into a message after aligning the first element.

impl<'buf, 'fds> Unmarshal<'buf, 'fds> for UnixFd

pub fn unmarshal(
    ctx: &mut UnmarshalContext<'fds, 'buf>
) -> Result<(usize, UnixFd), Error>

impl Eq for UnixFd