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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
//! Platform-specific process and filesystem operations.
//!
//! Centralizes OS-dependent behavior behind a clean boundary so core
//! modules don't scatter `#[cfg]` branches through product logic.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ForegroundProcess {
pub pid: u32,
pub name: String,
pub argv0: Option<String>,
pub argv: Option<Vec<String>>,
pub cmdline: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ForegroundJob {
pub process_group_id: u32,
pub processes: Vec<ForegroundProcess>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Signal {
Hangup,
Terminate,
Kill,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ClipboardCommand {
pub program: &'static str,
pub args: &'static [&'static str],
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ClipboardImage {
pub bytes: Vec<u8>,
pub extension: &'static str,
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum LimitedRead {
Empty,
Complete(Vec<u8>),
Oversized,
}
pub(crate) fn read_limited_reader(
mut reader: impl std::io::Read,
max_bytes: usize,
) -> std::io::Result<LimitedRead> {
let mut bytes = Vec::new();
let mut buffer = [0_u8; 8192];
while bytes.len() < max_bytes {
let remaining = max_bytes - bytes.len();
let read_len = remaining.min(buffer.len());
let bytes_read = match reader.read(&mut buffer[..read_len]) {
Ok(bytes_read) => bytes_read,
Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
Err(err) => return Err(err),
};
if bytes_read == 0 {
return if bytes.is_empty() {
Ok(LimitedRead::Empty)
} else {
Ok(LimitedRead::Complete(bytes))
};
}
bytes.extend_from_slice(&buffer[..bytes_read]);
}
let mut sentinel = [0_u8; 1];
loop {
return match reader.read(&mut sentinel) {
Ok(0) if bytes.is_empty() => Ok(LimitedRead::Empty),
Ok(0) => Ok(LimitedRead::Complete(bytes)),
Ok(_) => Ok(LimitedRead::Oversized),
Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
Err(err) => Err(err),
};
}
}
#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
pub use linux::*;
#[cfg(target_os = "macos")]
mod macos;
#[cfg(target_os = "macos")]
pub use macos::*;
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
mod fallback;
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
pub use fallback::*;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn read_limited_reader_returns_complete_data_under_limit() {
let input = std::io::Cursor::new(b"image".to_vec());
assert_eq!(
read_limited_reader(input, 16).expect("limited read"),
LimitedRead::Complete(b"image".to_vec())
);
}
#[test]
fn read_limited_reader_returns_empty_for_empty_input() {
let input = std::io::Cursor::new(Vec::<u8>::new());
assert_eq!(
read_limited_reader(input, 16).expect("limited read"),
LimitedRead::Empty
);
}
#[test]
fn read_limited_reader_accepts_data_exactly_at_limit() {
let input = std::io::Cursor::new(b"four".to_vec());
assert_eq!(
read_limited_reader(input, 4).expect("limited read"),
LimitedRead::Complete(b"four".to_vec())
);
}
#[test]
fn read_limited_reader_rejects_data_over_limit() {
let input = std::io::Cursor::new(b"oversized".to_vec());
assert_eq!(
read_limited_reader(input, 4).expect("limited read"),
LimitedRead::Oversized
);
}
#[test]
fn read_limited_reader_retries_interrupted_reads() {
struct InterruptedOnce {
interrupted: bool,
inner: std::io::Cursor<Vec<u8>>,
}
impl std::io::Read for InterruptedOnce {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
if !self.interrupted {
self.interrupted = true;
return Err(std::io::ErrorKind::Interrupted.into());
}
self.inner.read(buffer)
}
}
let input = InterruptedOnce {
interrupted: false,
inner: std::io::Cursor::new(b"image".to_vec()),
};
assert_eq!(
read_limited_reader(input, 16).expect("limited read"),
LimitedRead::Complete(b"image".to_vec())
);
}
}
|
