interprocess 2.2.2

Interprocess communication toolkit
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

//! Unix-specific named pipe functionality.

use super::{c_wrappers, FdOps};
use crate::{
	os::unix::unixprelude::*,
	unnamed_pipe::{Recver as PubRecver, Sender as PubSender},
	Sealed,
};
use std::{
	fmt::{self, Debug, Formatter},
	io,
	os::fd::OwnedFd,
};

#[cfg(feature = "tokio")]
pub(crate) mod tokio;

/// Unix-specific extensions to synchronous named pipe senders and receivers.
#[allow(private_bounds)]
pub trait UnnamedPipeExt: AsFd + Sealed {
	/// Sets whether the nonblocking mode for the pipe half is enabled. By default, it is
	/// disabled.
	///
	/// In nonblocking mode, attempts to receive from a [`Recver`](PubRecver) when there is no
	/// data available, much like attempts to send data via a [`Sender`](PubSender) when the send
	/// buffer has filled up because the receiving side hasn't received enough bytes in time,
	/// never block like they normally do. Instead, a [`WouldBlock`](io::ErrorKind::WouldBlock)
	/// error is immediately returned, allowing the thread to perform useful actions in the
	/// meantime.
	#[inline]
	fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
		c_wrappers::set_nonblocking(self.as_fd(), nonblocking)
	}
}
#[cfg_attr(feature = "doc_cfg", doc(cfg(unix)))]
impl UnnamedPipeExt for PubRecver {}
#[cfg_attr(feature = "doc_cfg", doc(cfg(unix)))]
impl UnnamedPipeExt for PubSender {}

/// Like [platform-general `pipe()`](crate::unnamed_pipe::pipe), but allows pipe pairs to be
/// immediately created in nonblocking mode on Linux, eliding a `fcntl()`.
///
/// ## System calls
/// - `pipe2` (Linux)
/// - `pipe` (not Linux)
/// - `fcntl` (not Linux, only if `nonblocking` is `true`)
pub fn pipe(nonblocking: bool) -> io::Result<(PubSender, PubRecver)> {
	let (success, fds) = unsafe {
		let mut fds: [c_int; 2] = [0; 2];
		let result;
		#[cfg(any(target_os = "linux", target_os = "android"))]
		{
			result = libc::pipe2(
				fds.as_mut_ptr(),
				if nonblocking { libc::O_NONBLOCK } else { 0 },
			);
		}
		#[cfg(not(any(target_os = "linux", target_os = "android")))]
		{
			result = libc::pipe(fds.as_mut_ptr());
		}
		(result == 0, fds)
	};
	if success {
		let (w, r) = unsafe {
			// SAFETY: we just created both of those file descriptors, which means that neither of
			// them can be in use elsewhere.
			let w = OwnedFd::from_raw_fd(fds[1]);
			let r = OwnedFd::from_raw_fd(fds[0]);
			(w, r)
		};
		let w = PubSender(Sender(FdOps(w)));
		let r = PubRecver(Recver(FdOps(r)));
		#[cfg(not(any(target_os = "linux", target_os = "android")))]
		{
			if nonblocking {
				w.set_nonblocking(true)?;
				r.set_nonblocking(true)?;
			}
		}
		Ok((w, r))
	} else {
		Err(io::Error::last_os_error())
	}
}

// This is imported by a macro, hence the confusing name.
#[inline]
pub(crate) fn pipe_impl() -> io::Result<(PubSender, PubRecver)> {
	pipe(false)
}

pub(crate) struct Recver(FdOps);
impl Sealed for Recver {}
impl Debug for Recver {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		f.debug_struct("Recver")
			.field("fd", &self.0 .0.as_raw_fd())
			.finish()
	}
}
multimacro! {
	Recver,
	forward_rbv(FdOps, &),
	forward_sync_ref_read,
	forward_try_clone,
	forward_handle,
	derive_sync_mut_read,
}

pub(crate) struct Sender(FdOps);
impl Sealed for Sender {}
impl Debug for Sender {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		f.debug_struct("Sender")
			.field("fd", &self.0 .0.as_raw_fd())
			.finish()
	}
}

multimacro! {
	Sender,
	forward_rbv(FdOps, &),
	forward_sync_ref_write,
	forward_try_clone,
	forward_handle,
	derive_sync_mut_write,
}