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
|
//! Stdin input reading for the thin client.
//!
//! Reads stdin bytes and forwards framed input to the main event loop.
//! Unlike the monolithic herdr, the thin client does NOT parse input into
//! key/mouse/paste events. It keeps enough byte-framing state to avoid splitting
//! terminal control strings, then sends bytes to the server as `ClientMessage::Input`.
//! The server handles semantic parsing.
//!
//! This is simpler and more reliable because:
//! - The server has the same input parsing code
//! - We avoid duplicating parsing logic in the client
//! - Host terminal control replies can be buffered or discarded before they leak
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 framer = crate::raw_input::RawInputByteFramer::default();
while !should_quit.load(Ordering::Acquire) {
match reader.read(&mut scratch) {
Ok(0) => break,
Ok(n) => {
for data in framer.push(&scratch[..n]) {
if event_tx
.blocking_send(ClientLoopEvent::StdinInput(data))
.is_err()
{
return;
}
}
if stdin_read_ready(&reader, 10) == Some(false) {
for data in framer.flush_timeout() {
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"),
}
}
}
|
