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
|
//! Stdin input reading for the thin client.
//!
//! Reads raw bytes from stdin and forwards them to the main event loop.
//! Unlike the monolithic herdr, the thin client does NOT parse the input
//! into key/mouse/paste events — it just sends the raw bytes to the server
//! as `ClientMessage::Input`. The server handles parsing.
//!
//! This is simpler and more reliable because:
//! - The server has the same input parsing code
//! - We avoid duplicating parsing logic in the client
//! - Raw forwarding preserves all escape sequences faithfully
use std::io::{self, Read};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
#[cfg(unix)]
use std::os::fd::AsRawFd;
use tokio::sync::mpsc;
use super::ClientLoopEvent;
// ---------------------------------------------------------------------------
// Stdin reader thread
// ---------------------------------------------------------------------------
/// Reads raw bytes from stdin and sends them to the main event loop.
///
/// This runs on a dedicated thread because stdin reading is blocking.
/// The main loop receives the raw bytes and forwards them as
/// `ClientMessage::Input` to the server.
pub fn stdin_reader_loop(event_tx: mpsc::Sender<ClientLoopEvent>, should_quit: &Arc<AtomicBool>) {
let stdin = io::stdin();
let mut reader = stdin.lock();
let mut scratch = [0u8; 4096];
let mut buffer = Vec::new();
while !should_quit.load(Ordering::Acquire) {
match reader.read(&mut scratch) {
Ok(0) => break,
Ok(n) => {
buffer.extend_from_slice(&scratch[..n]);
for data in crate::raw_input::drain_complete_input_bytes(&mut buffer) {
if event_tx
.blocking_send(ClientLoopEvent::StdinInput(data))
.is_err()
{
return;
}
}
if !buffer.is_empty() && stdin_read_ready(&reader, 10) == Some(false) {
if let Some(data) = crate::raw_input::flush_incomplete_input_bytes(&mut buffer)
{
if event_tx
.blocking_send(ClientLoopEvent::StdinInput(data))
.is_err()
{
return;
}
}
}
}
Err(err) => {
if err.kind() == io::ErrorKind::Interrupted {
continue;
}
break;
}
}
}
}
#[cfg(unix)]
fn stdin_read_ready<R: AsRawFd>(reader: &R, timeout_ms: i32) -> Option<bool> {
poll_read_ready(reader.as_raw_fd(), timeout_ms)
}
#[cfg(not(unix))]
fn stdin_read_ready<R>(_reader: &R, _timeout_ms: i32) -> Option<bool> {
None
}
#[cfg(unix)]
fn poll_read_ready(fd: i32, timeout_ms: i32) -> Option<bool> {
#[repr(C)]
struct PollFd {
fd: i32,
events: i16,
revents: i16,
}
unsafe extern "C" {
fn poll(fds: *mut PollFd, nfds: usize, timeout: i32) -> i32;
}
const POLLIN: i16 = 0x0001;
let mut pfd = PollFd {
fd,
events: POLLIN,
revents: 0,
};
let result = unsafe { poll(&mut pfd as *mut PollFd, 1, timeout_ms) };
if result < 0 {
None
} else {
Some(result > 0)
}
}
// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------
#[cfg(test)]
mod tests {
// The stdin reader thread is hard to unit test since it reads from actual stdin.
// Integration tests will verify the full client→server input flow.
// Here we test the event type construction.
use super::*;
#[test]
fn stdin_input_event_carries_raw_bytes() {
let data = vec![0x1b, b'[', b'A']; // Up arrow escape sequence
let event = ClientLoopEvent::StdinInput(data.clone());
match event {
ClientLoopEvent::StdinInput(d) => assert_eq!(d, data),
_ => panic!("expected StdinInput event"),
}
}
}
|
