interprocess-docfix 1.2.2

Interprocess communication toolkit. Docs fixed.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use super::imports::*;
use std::{
    io::{self, IoSlice, IoSliceMut},
    marker::PhantomData,
    mem::ManuallyDrop,
};
use to_method::To;

#[repr(transparent)]
pub(super) struct FdOps(pub(super) c_int, PhantomData<*mut ()>);
impl FdOps {
    pub fn new(fd: c_int) -> Self {
        Self(fd, PhantomData)
    }
    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
        let (success, bytes_read) = unsafe {
            let length_to_read = buf.len();
            let size_or_err =
                libc::read(self.as_raw_fd(), buf.as_mut_ptr() as *mut _, length_to_read);
            (size_or_err >= 0, size_or_err as usize)
        };
        if success {
            Ok(bytes_read)
        } else {
            Err(io::Error::last_os_error())
        }
    }
    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
        let (success, bytes_read) = unsafe {
            let num_bufs = bufs.len().try_to::<c_int>().unwrap_or(c_int::MAX);
            let size_or_err =
                libc::readv(self.as_raw_fd(), bufs.as_mut_ptr() as *const _, num_bufs);
            (size_or_err >= 0, size_or_err as usize)
        };
        if success {
            Ok(bytes_read)
        } else {
            Err(io::Error::last_os_error())
        }
    }
    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
        let (success, bytes_written) = unsafe {
            let length_to_write = buf.len();
            let size_or_err =
                libc::write(self.as_raw_fd(), buf.as_ptr() as *const _, length_to_write);
            (size_or_err >= 0, size_or_err as usize)
        };
        if success {
            Ok(bytes_written)
        } else {
            Err(io::Error::last_os_error())
        }
    }
    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
        let (success, bytes_written) = unsafe {
            let num_bufs = bufs.len().try_to::<c_int>().unwrap_or(c_int::MAX);
            let size_or_err = libc::writev(self.as_raw_fd(), bufs.as_ptr() as *const _, num_bufs);
            (size_or_err >= 0, size_or_err as usize)
        };
        if success {
            Ok(bytes_written)
        } else {
            Err(io::Error::last_os_error())
        }
    }
    pub fn flush(&self) -> io::Result<()> {
        let success = unsafe { libc::fsync(self.as_raw_fd()) >= 0 };
        if success {
            Ok(())
        } else {
            Err(io::Error::last_os_error())
        }
    }
}
impl AsRef<c_int> for FdOps {
    fn as_ref(&self) -> &c_int {
        &self.0
    }
}
impl AsRef<FdOps> for c_int {
    fn as_ref(&self) -> &FdOps {
        unsafe {
            // SAFETY: #[repr(transparent)] guarantees layout compatibility
            &*(self as *const _ as *const FdOps)
        }
    }
}
impl AsRawFd for FdOps {
    fn as_raw_fd(&self) -> c_int {
        self.0
    }
}
impl IntoRawFd for FdOps {
    fn into_raw_fd(self) -> c_int {
        let self_ = ManuallyDrop::new(self);
        self_.as_raw_fd()
    }
}
impl FromRawFd for FdOps {
    unsafe fn from_raw_fd(fd: c_int) -> Self {
        Self::new(fd)
    }
}
impl Drop for FdOps {
    fn drop(&mut self) {
        unsafe { close_fd(self.0) };
    }
}
unsafe impl Send for FdOps {}
unsafe impl Sync for FdOps {}

pub(super) unsafe fn close_fd(fd: i32) {
    let error = unsafe {
        let mut error = None;
        // If the close() call fails, the loop starts and keeps retrying until either the error
        // value isn't Interrupted (in which case the assertion fails) or the close operation
        // properly fails with a non-Interrupted error type. Why does Unix even have this
        // idiotic error type?
        while libc::close(fd) != 0 {
            let current_error = io::Error::last_os_error();
            if current_error.kind() != io::ErrorKind::Interrupted {
                // An actual close error happened – return early now
                error = Some(current_error);
                break;
            }
        }
        error
    };
    if let Some(e) = error {
        panic!("failed to close file descriptor: {}", e);
    }
}