BlueGit

timfa posprint

Add raw TCP 9100 network printer transport.

Introduce PrinterTarget::Network, NetworkTransport, host:port parsing, and LAN probe helpers without wiring discovery into the UI yet.

Co-authored-by: Cursor <cursoragent@cursor.com>

timfa Tim Falken · pushed by timfa

Authored 2026-07-28 · 3 months ago

Hash
32c21ccb9a73da6ed5cd8768320be5ab593af81b
Parent
c59e32ea
2 files changed +545 −3
src/print/mod.rs +78 −3
@@ -3,10 +3,17 @@ use std::time::Duration;
3 3
4 4 use serialport::SerialPortType;
5 5
6 mod network;
6 7 mod usb_direct;
7 8 #[cfg(windows)]
8 9 mod win_spool;
9 10
11 pub use network::{
12 cache_entries_from_devices, merge_lan_devices, network_device, parse_network_target,
13 probe_host, remember_in_cache, scan_local_subnets, validate_cache, LanPrinterCacheEntry,
14 NetworkTransport, DEFAULT_PORT, PROBE_TIMEOUT,
15 };
16
10 17 /// Common baud rates for USB POS printers (115200 first — many modern devices).
11 18 pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800];
12 19
@@ -20,6 +27,11 @@ pub enum PrinterTarget {
20 27 address: u8,
21 28 },
22 29 WinSpooler(String),
30 /// Raw ESC/POS over TCP (typically port 9100).
31 Network {
32 host: String,
33 port: u16,
34 },
23 35 }
24 36
25 37 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -81,8 +93,13 @@ impl PrinterTransport for SerialTransport {
81 93 }
82 94 }
83 95
84 /// List POS printers: USB printer-class devices, Windows spooler queues, then serial ports.
96 /// List local POS printers: USB printer-class, Windows spooler, USB-serial.
97 /// Does **not** include LAN discovery (see `discover_printers` / print dialog).
85 98 pub fn list_printers() -> Result<Vec<PrinterDevice>, PrintError> {
99 list_local_printers()
100 }
101
102 pub fn list_local_printers() -> Result<Vec<PrinterDevice>, PrintError> {
86 103 let mut devices = usb_direct::list_usb_printer_devices();
87 104
88 105 #[cfg(windows)]
@@ -149,20 +166,35 @@ pub fn open_printer(target: &PrinterTarget) -> Result<Box<dyn PrinterTransport>,
149 166 PrinterTarget::WinSpooler(_) => Err(PrintError::Open(
150 167 "Windows spooler printing is only available on Windows".into(),
151 168 )),
169 PrinterTarget::Network { host, port } => {
170 Ok(Box::new(NetworkTransport::open(host, *port)?))
171 }
152 172 }
153 173 }
154 174
155 /// Open by manual name: tries serial/COM first, then Windows spooler queue name.
175 /// Open by manual name: network `host`/`host:port`, then serial/COM, then Windows spooler.
156 176 pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
157 177 let name = name.trim();
158 178 if name.is_empty() {
159 179 return Err(PrintError::NotFound);
160 180 }
161 181
182 if let Some((host, port)) = parse_network_target(name) {
183 // Prefer TCP when the string looks like a host/IP (avoids treating paths as hosts).
184 if looks_like_network_name(name) {
185 return Ok(Box::new(NetworkTransport::open(&host, port)?));
186 }
187 }
188
162 189 if let Ok(transport) = SerialTransport::open(name) {
163 190 return Ok(Box::new(transport));
164 191 }
165 192
193 // Fall back to network parse for hostnames that failed serial open.
194 if let Some((host, port)) = parse_network_target(name) {
195 return Ok(Box::new(NetworkTransport::open(&host, port)?));
196 }
197
166 198 #[cfg(windows)]
167 199 {
168 200 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
@@ -172,10 +204,23 @@ pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, Pri
172 204
173 205 #[cfg(not(windows))]
174 206 Err(PrintError::Open(format!(
175 "could not open serial port '{name}'"
207 "could not open printer '{name}' (serial or TCP)"
176 208 )))
177 209 }
178 210
211 fn looks_like_network_name(name: &str) -> bool {
212 let s = name.trim();
213 if s.starts_with('/') || s.chars().any(|c| c == '\\') {
214 return false;
215 }
216 // COM ports, Windows-style
217 let upper = s.to_ascii_uppercase();
218 if upper.starts_with("COM") && upper[3..].chars().all(|c| c.is_ascii_digit()) {
219 return false;
220 }
221 s.contains('.') || s.contains(':') || s.eq_ignore_ascii_case("localhost")
222 }
223
179 224 fn fmt_vid_pid(v: u16) -> String {
180 225 format!("{v:04x}")
181 226 }
@@ -209,6 +254,7 @@ pub fn printer_preference_key(target: &PrinterTarget) -> String {
209 254 PrinterTarget::UsbDirect { vid, pid, .. } => {
210 255 format!("usb:{vid:04x}:{pid:04x}")
211 256 }
257 PrinterTarget::Network { host, port } => format!("net:{host}:{port}"),
212 258 }
213 259 }
214 260
@@ -322,6 +368,14 @@ mod tests {
322 368 display_name: "POS".into(),
323 369 target: PrinterTarget::WinSpooler("POS".into()),
324 370 },
371 PrinterDevice {
372 id: "net:10.0.0.5:9100".into(),
373 display_name: "10.0.0.5:9100".into(),
374 target: PrinterTarget::Network {
375 host: "10.0.0.5".into(),
376 port: 9100,
377 },
378 },
325 379 ];
326 380 assert_eq!(
327 381 find_preferred_printer_index(&printers, "winspool:POS"),
@@ -332,5 +386,26 @@ mod tests {
332 386 find_preferred_printer_index(&printers, "manual:COM3"),
333 387 None
334 388 );
389 assert_eq!(
390 find_preferred_printer_index(&printers, "net:10.0.0.5:9100"),
391 Some(2)
392 );
393 }
394
395 #[test]
396 fn preference_key_for_network() {
397 let t = PrinterTarget::Network {
398 host: "192.168.1.20".into(),
399 port: 9100,
400 };
401 assert_eq!(printer_preference_key(&t), "net:192.168.1.20:9100");
402 }
403
404 #[test]
405 fn open_by_name_rejects_empty() {
406 assert!(matches!(
407 open_printer_by_name(" "),
408 Err(PrintError::NotFound)
409 ));
335 410 }
336 411 }
@@ -3,10 +3,17 @@ use std::time::Duration;
3
3
4use serialport::SerialPortType;
4use serialport::SerialPortType;
5
5
6mod network;
6mod usb_direct;
7mod usb_direct;
7#[cfg(windows)]
8#[cfg(windows)]
8mod win_spool;
9mod win_spool;
9
10
11pub use network::{
12 cache_entries_from_devices, merge_lan_devices, network_device, parse_network_target,
13 probe_host, remember_in_cache, scan_local_subnets, validate_cache, LanPrinterCacheEntry,
14 NetworkTransport, DEFAULT_PORT, PROBE_TIMEOUT,
15};
16
10/// Common baud rates for USB POS printers (115200 first — many modern devices).
17/// Common baud rates for USB POS printers (115200 first — many modern devices).
11pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800];
18pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800];
12
19
@@ -20,6 +27,11 @@ pub enum PrinterTarget {
20 address: u8,
27 address: u8,
21 },
28 },
22 WinSpooler(String),
29 WinSpooler(String),
30 /// Raw ESC/POS over TCP (typically port 9100).
31 Network {
32 host: String,
33 port: u16,
34 },
23}
35}
24
36
25#[derive(Debug, Clone, PartialEq, Eq)]
37#[derive(Debug, Clone, PartialEq, Eq)]
@@ -81,8 +93,13 @@ impl PrinterTransport for SerialTransport {
81 }
93 }
82}
94}
83
95
84/// List POS printers: USB printer-class devices, Windows spooler queues, then serial ports.
96/// List local POS printers: USB printer-class, Windows spooler, USB-serial.
97/// Does **not** include LAN discovery (see `discover_printers` / print dialog).
85pub fn list_printers() -> Result<Vec<PrinterDevice>, PrintError> {
98pub fn list_printers() -> Result<Vec<PrinterDevice>, PrintError> {
99 list_local_printers()
100}
101
102pub fn list_local_printers() -> Result<Vec<PrinterDevice>, PrintError> {
86 let mut devices = usb_direct::list_usb_printer_devices();
103 let mut devices = usb_direct::list_usb_printer_devices();
87
104
88 #[cfg(windows)]
105 #[cfg(windows)]
@@ -149,20 +166,35 @@ pub fn open_printer(target: &PrinterTarget) -> Result<Box<dyn PrinterTransport>,
149 PrinterTarget::WinSpooler(_) => Err(PrintError::Open(
166 PrinterTarget::WinSpooler(_) => Err(PrintError::Open(
150 "Windows spooler printing is only available on Windows".into(),
167 "Windows spooler printing is only available on Windows".into(),
151 )),
168 )),
169 PrinterTarget::Network { host, port } => {
170 Ok(Box::new(NetworkTransport::open(host, *port)?))
171 }
152 }
172 }
153}
173}
154
174
155/// Open by manual name: tries serial/COM first, then Windows spooler queue name.
175/// Open by manual name: network `host`/`host:port`, then serial/COM, then Windows spooler.
156pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
176pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
157 let name = name.trim();
177 let name = name.trim();
158 if name.is_empty() {
178 if name.is_empty() {
159 return Err(PrintError::NotFound);
179 return Err(PrintError::NotFound);
160 }
180 }
161
181
182 if let Some((host, port)) = parse_network_target(name) {
183 // Prefer TCP when the string looks like a host/IP (avoids treating paths as hosts).
184 if looks_like_network_name(name) {
185 return Ok(Box::new(NetworkTransport::open(&host, port)?));
186 }
187 }
188
162 if let Ok(transport) = SerialTransport::open(name) {
189 if let Ok(transport) = SerialTransport::open(name) {
163 return Ok(Box::new(transport));
190 return Ok(Box::new(transport));
164 }
191 }
165
192
193 // Fall back to network parse for hostnames that failed serial open.
194 if let Some((host, port)) = parse_network_target(name) {
195 return Ok(Box::new(NetworkTransport::open(&host, port)?));
196 }
197
166 #[cfg(windows)]
198 #[cfg(windows)]
167 {
199 {
168 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
200 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
@@ -172,10 +204,23 @@ pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, Pri
172
204
173 #[cfg(not(windows))]
205 #[cfg(not(windows))]
174 Err(PrintError::Open(format!(
206 Err(PrintError::Open(format!(
175 "could not open serial port '{name}'"
207 "could not open printer '{name}' (serial or TCP)"
176 )))
208 )))
177}
209}
178
210
211fn looks_like_network_name(name: &str) -> bool {
212 let s = name.trim();
213 if s.starts_with('/') || s.chars().any(|c| c == '\\') {
214 return false;
215 }
216 // COM ports, Windows-style
217 let upper = s.to_ascii_uppercase();
218 if upper.starts_with("COM") && upper[3..].chars().all(|c| c.is_ascii_digit()) {
219 return false;
220 }
221 s.contains('.') || s.contains(':') || s.eq_ignore_ascii_case("localhost")
222}
223
179fn fmt_vid_pid(v: u16) -> String {
224fn fmt_vid_pid(v: u16) -> String {
180 format!("{v:04x}")
225 format!("{v:04x}")
181}
226}
@@ -209,6 +254,7 @@ pub fn printer_preference_key(target: &PrinterTarget) -> String {
209 PrinterTarget::UsbDirect { vid, pid, .. } => {
254 PrinterTarget::UsbDirect { vid, pid, .. } => {
210 format!("usb:{vid:04x}:{pid:04x}")
255 format!("usb:{vid:04x}:{pid:04x}")
211 }
256 }
257 PrinterTarget::Network { host, port } => format!("net:{host}:{port}"),
212 }
258 }
213}
259}
214
260
@@ -322,6 +368,14 @@ mod tests {
322 display_name: "POS".into(),
368 display_name: "POS".into(),
323 target: PrinterTarget::WinSpooler("POS".into()),
369 target: PrinterTarget::WinSpooler("POS".into()),
324 },
370 },
371 PrinterDevice {
372 id: "net:10.0.0.5:9100".into(),
373 display_name: "10.0.0.5:9100".into(),
374 target: PrinterTarget::Network {
375 host: "10.0.0.5".into(),
376 port: 9100,
377 },
378 },
325 ];
379 ];
326 assert_eq!(
380 assert_eq!(
327 find_preferred_printer_index(&printers, "winspool:POS"),
381 find_preferred_printer_index(&printers, "winspool:POS"),
@@ -332,5 +386,26 @@ mod tests {
332 find_preferred_printer_index(&printers, "manual:COM3"),
386 find_preferred_printer_index(&printers, "manual:COM3"),
333 None
387 None
334 );
388 );
389 assert_eq!(
390 find_preferred_printer_index(&printers, "net:10.0.0.5:9100"),
391 Some(2)
392 );
393 }
394
395 #[test]
396 fn preference_key_for_network() {
397 let t = PrinterTarget::Network {
398 host: "192.168.1.20".into(),
399 port: 9100,
400 };
401 assert_eq!(printer_preference_key(&t), "net:192.168.1.20:9100");
402 }
403
404 #[test]
405 fn open_by_name_rejects_empty() {
406 assert!(matches!(
407 open_printer_by_name(" "),
408 Err(PrintError::NotFound)
409 ));
335 }
410 }
336}
411}
src/print/network.rs added +467 −0
@@ -0,0 +1,467 @@
1 //! Raw ESC/POS over TCP (JetDirect / port 9100). No CUPS/IPP.
2
3 use std::io::{self, Write};
4 use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream, UdpSocket};
5 use std::sync::mpsc;
6 use std::thread;
7 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
8
9 use super::{PrintError, PrinterDevice, PrinterTarget, PrinterTransport};
10
11 /// Default raw ESC/POS TCP port (Epson / Star / most thermal POS).
12 pub const DEFAULT_PORT: u16 = 9100;
13
14 /// Connect timeout when opening for print.
15 pub const PRINT_CONNECT_TIMEOUT: Duration = Duration::from_secs(3);
16
17 /// Short connect timeout used while probing the LAN.
18 pub const PROBE_TIMEOUT: Duration = Duration::from_millis(250);
19
20 /// How many probe workers to run in parallel during a subnet scan.
21 const SCAN_WORKERS: usize = 64;
22
23 pub struct NetworkTransport {
24 stream: TcpStream,
25 }
26
27 impl NetworkTransport {
28 pub fn open(host: &str, port: u16) -> Result<Self, PrintError> {
29 let addr = resolve_socket_addr(host, port)?;
30 let stream = TcpStream::connect_timeout(&addr, PRINT_CONNECT_TIMEOUT).map_err(|e| {
31 PrintError::Open(format!("TCP {host}:{port}: {e}"))
32 })?;
33 let _ = stream.set_nodelay(true);
34 let _ = stream.set_write_timeout(Some(Duration::from_secs(10)));
35 Ok(Self { stream })
36 }
37 }
38
39 impl PrinterTransport for NetworkTransport {
40 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
41 self.stream.write_all(data)
42 }
43
44 fn flush(&mut self) -> io::Result<()> {
45 self.stream.flush()
46 }
47 }
48
49 /// Parse `host`, `host:port`, or `tcp://host:port` into (host, port).
50 pub fn parse_network_target(raw: &str) -> Option<(String, u16)> {
51 let s = raw.trim();
52 if s.is_empty() {
53 return None;
54 }
55 let s = s
56 .strip_prefix("tcp://")
57 .or_else(|| s.strip_prefix("TCP://"))
58 .unwrap_or(s)
59 .trim();
60
61 // [ipv6]:port — not required for typical POS; skip for now.
62 if s.starts_with('[') {
63 return None;
64 }
65
66 if let Some((host, port_str)) = s.rsplit_once(':') {
67 // Avoid treating IPv4 as host:port when there are multiple colons.
68 if host.parse::<Ipv4Addr>().is_ok() || (!host.is_empty() && !host.contains(':')) {
69 if let Ok(port) = port_str.parse::<u16>() {
70 if port != 0 && !host.is_empty() {
71 return Some((host.to_string(), port));
72 }
73 }
74 }
75 }
76
77 // Bare hostname / IPv4 → default port.
78 if s.parse::<Ipv4Addr>().is_ok() || (!s.is_empty() && !s.contains('/')) {
79 return Some((s.to_string(), DEFAULT_PORT));
80 }
81 None
82 }
83
84 pub fn network_device(host: &str, port: u16) -> PrinterDevice {
85 let port = if port == 0 { DEFAULT_PORT } else { port };
86 PrinterDevice {
87 id: format!("net:{host}:{port}"),
88 display_name: format!("{host}:{port} — LAN (TCP)"),
89 target: PrinterTarget::Network {
90 host: host.to_string(),
91 port,
92 },
93 }
94 }
95
96 pub fn probe_host(host: &str, port: u16, timeout: Duration) -> bool {
97 let Ok(addr) = resolve_socket_addr(host, port) else {
98 return false;
99 };
100 TcpStream::connect_timeout(&addr, timeout).is_ok()
101 }
102
103 fn resolve_socket_addr(host: &str, port: u16) -> Result<SocketAddr, PrintError> {
104 if let Ok(ip) = host.parse::<IpAddr>() {
105 return Ok(SocketAddr::new(ip, port));
106 }
107 // Hostname: use blocking resolve with first result.
108 let mut addrs = std::net::ToSocketAddrs::to_socket_addrs(&(host, port)).map_err(|e| {
109 PrintError::Open(format!("resolve {host}: {e}"))
110 })?;
111 addrs
112 .next()
113 .ok_or_else(|| PrintError::Open(format!("resolve {host}: no addresses")))
114 }
115
116 /// Cached LAN printer entry (persisted in `AppConfig`).
117 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
118 pub struct LanPrinterCacheEntry {
119 pub host: String,
120 pub port: u16,
121 #[serde(default)]
122 pub last_seen_unix: u64,
123 }
124
125 impl LanPrinterCacheEntry {
126 pub fn new(host: impl Into<String>, port: u16) -> Self {
127 Self {
128 host: host.into(),
129 port: if port == 0 { DEFAULT_PORT } else { port },
130 last_seen_unix: unix_now(),
131 }
132 }
133 }
134
135 fn unix_now() -> u64 {
136 SystemTime::now()
137 .duration_since(UNIX_EPOCH)
138 .map(|d| d.as_secs())
139 .unwrap_or(0)
140 }
141
142 /// Re-check cached hosts; return only those that still accept TCP on the port.
143 pub fn validate_cache(cache: &[LanPrinterCacheEntry]) -> Vec<PrinterDevice> {
144 let (tx, rx) = mpsc::channel();
145 let mut handles = Vec::new();
146 for entry in cache {
147 let host = entry.host.clone();
148 let port = if entry.port == 0 {
149 DEFAULT_PORT
150 } else {
151 entry.port
152 };
153 let tx = tx.clone();
154 handles.push(thread::spawn(move || {
155 if probe_host(&host, port, PROBE_TIMEOUT) {
156 let _ = tx.send(network_device(&host, port));
157 }
158 }));
159 }
160 drop(tx);
161 for h in handles {
162 let _ = h.join();
163 }
164 let mut out: Vec<_> = rx.into_iter().collect();
165 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
166 out.dedup_by(|a, b| a.id == b.id);
167 out
168 }
169
170 /// Scan local IPv4 /24 subnets for open TCP `port`.
171 pub fn scan_local_subnets(port: u16) -> Vec<PrinterDevice> {
172 let port = if port == 0 { DEFAULT_PORT } else { port };
173 let mut targets: Vec<Ipv4Addr> = Vec::new();
174 for (ip, prefix) in local_ipv4_subnets() {
175 targets.extend(hosts_in_subnet(ip, prefix));
176 }
177 targets.sort();
178 targets.dedup();
179
180 if targets.is_empty() {
181 return Vec::new();
182 }
183
184 let (job_tx, job_rx) = mpsc::channel::<Ipv4Addr>();
185 let (hit_tx, hit_rx) = mpsc::channel::<PrinterDevice>();
186
187 let workers = SCAN_WORKERS.min(targets.len()).max(1);
188 let job_rx = std::sync::Arc::new(std::sync::Mutex::new(job_rx));
189 let mut handles = Vec::with_capacity(workers);
190 for _ in 0..workers {
191 let job_rx = std::sync::Arc::clone(&job_rx);
192 let hit_tx = hit_tx.clone();
193 handles.push(thread::spawn(move || {
194 loop {
195 let ip = {
196 let Ok(rx) = job_rx.lock() else {
197 break;
198 };
199 match rx.recv() {
200 Ok(ip) => ip,
201 Err(_) => break,
202 }
203 };
204 let host = ip.to_string();
205 if probe_host(&host, port, PROBE_TIMEOUT) {
206 let _ = hit_tx.send(network_device(&host, port));
207 }
208 }
209 }));
210 }
211 drop(hit_tx);
212
213 for ip in targets {
214 let _ = job_tx.send(ip);
215 }
216 drop(job_tx);
217
218 for h in handles {
219 let _ = h.join();
220 }
221
222 let mut out: Vec<_> = hit_rx.into_iter().collect();
223 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
224 out.dedup_by(|a, b| a.id == b.id);
225 out
226 }
227
228 /// Merge validated cache hits with a fresh scan; refresh `last_seen` for survivors.
229 pub fn merge_lan_devices(
230 validated_cache: &[PrinterDevice],
231 scanned: &[PrinterDevice],
232 ) -> Vec<PrinterDevice> {
233 let mut out = Vec::new();
234 for d in validated_cache.iter().chain(scanned.iter()) {
235 if !out.iter().any(|x: &PrinterDevice| x.id == d.id) {
236 out.push(d.clone());
237 }
238 }
239 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
240 out
241 }
242
243 pub fn cache_entries_from_devices(devices: &[PrinterDevice]) -> Vec<LanPrinterCacheEntry> {
244 let now = unix_now();
245 let mut entries = Vec::new();
246 for d in devices {
247 if let PrinterTarget::Network { host, port } = &d.target {
248 entries.push(LanPrinterCacheEntry {
249 host: host.clone(),
250 port: *port,
251 last_seen_unix: now,
252 });
253 }
254 }
255 entries.sort_by(|a, b| (&a.host, a.port).cmp(&(&b.host, b.port)));
256 entries.dedup_by(|a, b| a.host == b.host && a.port == b.port);
257 entries
258 }
259
260 /// Remember a successful network print in the durable LAN cache.
261 pub fn remember_in_cache(cache: &mut Vec<LanPrinterCacheEntry>, host: &str, port: u16) {
262 let port = if port == 0 { DEFAULT_PORT } else { port };
263 let now = unix_now();
264 if let Some(existing) = cache.iter_mut().find(|e| e.host == host && e.port == port) {
265 existing.last_seen_unix = now;
266 return;
267 }
268 cache.push(LanPrinterCacheEntry {
269 host: host.to_string(),
270 port,
271 last_seen_unix: now,
272 });
273 cache.sort_by(|a, b| (&a.host, a.port).cmp(&(&b.host, b.port)));
274 }
275
276 fn local_ipv4_subnets() -> Vec<(Ipv4Addr, u8)> {
277 let mut out = Vec::new();
278
279 #[cfg(unix)]
280 {
281 out.extend(unix_ipv4_subnets());
282 }
283
284 // Always include the default-route interface /24 when available.
285 if let Some(ip) = primary_ipv4() {
286 if !ip.is_loopback() && !is_link_local(ip) {
287 out.push((ip, 24));
288 }
289 }
290
291 out.sort_by_key(|(ip, p)| (u32::from(*ip), *p));
292 out.dedup();
293 out
294 }
295
296 fn primary_ipv4() -> Option<Ipv4Addr> {
297 let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
298 // No packets need to be sent; connect selects a route and local address.
299 socket.connect("8.8.8.8:80").ok()?;
300 match socket.local_addr().ok()?.ip() {
301 IpAddr::V4(ip) => Some(ip),
302 IpAddr::V6(_) => None,
303 }
304 }
305
306 fn is_link_local(ip: Ipv4Addr) -> bool {
307 ip.octets()[0] == 169 && ip.octets()[1] == 254
308 }
309
310 fn hosts_in_subnet(ip: Ipv4Addr, prefix: u8) -> Vec<Ipv4Addr> {
311 let prefix = prefix.min(30);
312 let ip_u = u32::from(ip);
313 let mask = if prefix == 0 {
314 0
315 } else {
316 !0u32 << (32 - prefix)
317 };
318 let network = ip_u & mask;
319 let broadcast = network | !mask;
320 let mut hosts = Vec::new();
321 // Skip network and broadcast addresses.
322 let mut cur = network.saturating_add(1);
323 while cur < broadcast {
324 let host = Ipv4Addr::from(cur);
325 if host != ip && !host.is_loopback() && !is_link_local(host) {
326 hosts.push(host);
327 }
328 cur = cur.saturating_add(1);
329 }
330 hosts
331 }
332
333 #[cfg(unix)]
334 fn unix_ipv4_subnets() -> Vec<(Ipv4Addr, u8)> {
335 use std::ptr;
336
337 let mut out = Vec::new();
338 unsafe {
339 let mut ifap: *mut libc::ifaddrs = ptr::null_mut();
340 if libc::getifaddrs(&mut ifap) != 0 {
341 return out;
342 }
343 let mut cursor = ifap;
344 while !cursor.is_null() {
345 let entry = &*cursor;
346 if !entry.ifa_addr.is_null()
347 && (*entry.ifa_addr).sa_family as i32 == libc::AF_INET
348 && !entry.ifa_netmask.is_null()
349 {
350 let addr = &*(entry.ifa_addr as *const libc::sockaddr_in);
351 let mask = &*(entry.ifa_netmask as *const libc::sockaddr_in);
352 let ip = Ipv4Addr::from(u32::from_be(addr.sin_addr.s_addr));
353 let mask_u = u32::from_be(mask.sin_addr.s_addr);
354 if !ip.is_loopback() && !is_link_local(ip) && mask_u != 0 {
355 let prefix = mask_u.count_ones() as u8;
356 // Cap scan size: only /24 or narrower (more specific).
357 if (16..=30).contains(&prefix) {
358 out.push((ip, prefix.min(24)));
359 }
360 }
361 }
362 cursor = entry.ifa_next;
363 }
364 libc::freeifaddrs(ifap);
365 }
366 out
367 }
368
369 /// Approximate wall time for a full /24 probe (for tests / UI hints).
370 #[allow(dead_code)]
371 pub fn estimate_scan_budget(host_count: usize) -> Duration {
372 let batches = host_count.div_ceil(SCAN_WORKERS).max(1);
373 PROBE_TIMEOUT * batches as u32 + Duration::from_millis(50)
374 }
375
376 #[cfg(test)]
377 mod tests {
378 use super::*;
379 use std::net::TcpListener;
380 use std::thread;
381
382 #[test]
383 fn parse_host_and_optional_port() {
384 assert_eq!(
385 parse_network_target("192.168.1.50"),
386 Some(("192.168.1.50".into(), 9100))
387 );
388 assert_eq!(
389 parse_network_target("192.168.1.50:9100"),
390 Some(("192.168.1.50".into(), 9100))
391 );
392 assert_eq!(
393 parse_network_target("tcp://pos.local:9101"),
394 Some(("pos.local".into(), 9101))
395 );
396 assert_eq!(parse_network_target(""), None);
397 assert_eq!(parse_network_target(" "), None);
398 }
399
400 #[test]
401 fn probe_finds_local_listener() {
402 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
403 let port = listener.local_addr().unwrap().port();
404 let accept = thread::spawn(move || {
405 let _ = listener.accept();
406 });
407 assert!(probe_host("127.0.0.1", port, Duration::from_secs(1)));
408 let _ = accept.join();
409 }
410
411 #[test]
412 fn network_transport_writes_to_listener() {
413 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
414 let port = listener.local_addr().unwrap().port();
415 let accept = thread::spawn(move || {
416 let (mut stream, _) = listener.accept().unwrap();
417 let mut buf = [0u8; 4];
418 use std::io::Read;
419 stream.read_exact(&mut buf).unwrap();
420 buf
421 });
422 let mut transport = NetworkTransport::open("127.0.0.1", port).unwrap();
423 transport.write_all(&[1, 2, 3, 4]).unwrap();
424 transport.flush().unwrap();
425 assert_eq!(accept.join().unwrap(), [1, 2, 3, 4]);
426 }
427
428 #[test]
429 fn hosts_in_slash24_skips_network_and_broadcast() {
430 let hosts = hosts_in_subnet(Ipv4Addr::new(192, 168, 1, 10), 24);
431 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 0)));
432 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 255)));
433 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 10))); // self
434 assert!(hosts.contains(&Ipv4Addr::new(192, 168, 1, 1)));
435 assert_eq!(hosts.len(), 253);
436 }
437
438 #[test]
439 fn merge_dedupes_by_id() {
440 let a = network_device("192.168.0.5", 9100);
441 let b = network_device("192.168.0.5", 9100);
442 let c = network_device("192.168.0.6", 9100);
443 let merged = merge_lan_devices(&[a.clone()], &[b, c.clone()]);
444 assert_eq!(merged.len(), 2);
445 assert!(merged.iter().any(|d| d.id == a.id));
446 assert!(merged.iter().any(|d| d.id == c.id));
447 }
448
449 #[test]
450 fn cache_roundtrip_helpers() {
451 let devices = vec![network_device("10.0.0.8", 9100)];
452 let entries = cache_entries_from_devices(&devices);
453 assert_eq!(entries.len(), 1);
454 assert_eq!(entries[0].host, "10.0.0.8");
455 let mut cache = entries;
456 remember_in_cache(&mut cache, "10.0.0.9", 9100);
457 assert_eq!(cache.len(), 2);
458 remember_in_cache(&mut cache, "10.0.0.8", 9100);
459 assert_eq!(cache.len(), 2);
460 }
461
462 #[test]
463 fn estimate_scan_budget_is_finite() {
464 let _ = Instant::now();
465 assert!(estimate_scan_budget(254) > Duration::from_millis(0));
466 }
467 }
@@ -0,0 +1,467 @@
1//! Raw ESC/POS over TCP (JetDirect / port 9100). No CUPS/IPP.
2
3use std::io::{self, Write};
4use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream, UdpSocket};
5use std::sync::mpsc;
6use std::thread;
7use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
8
9use super::{PrintError, PrinterDevice, PrinterTarget, PrinterTransport};
10
11/// Default raw ESC/POS TCP port (Epson / Star / most thermal POS).
12pub const DEFAULT_PORT: u16 = 9100;
13
14/// Connect timeout when opening for print.
15pub const PRINT_CONNECT_TIMEOUT: Duration = Duration::from_secs(3);
16
17/// Short connect timeout used while probing the LAN.
18pub const PROBE_TIMEOUT: Duration = Duration::from_millis(250);
19
20/// How many probe workers to run in parallel during a subnet scan.
21const SCAN_WORKERS: usize = 64;
22
23pub struct NetworkTransport {
24 stream: TcpStream,
25}
26
27impl NetworkTransport {
28 pub fn open(host: &str, port: u16) -> Result<Self, PrintError> {
29 let addr = resolve_socket_addr(host, port)?;
30 let stream = TcpStream::connect_timeout(&addr, PRINT_CONNECT_TIMEOUT).map_err(|e| {
31 PrintError::Open(format!("TCP {host}:{port}: {e}"))
32 })?;
33 let _ = stream.set_nodelay(true);
34 let _ = stream.set_write_timeout(Some(Duration::from_secs(10)));
35 Ok(Self { stream })
36 }
37}
38
39impl PrinterTransport for NetworkTransport {
40 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
41 self.stream.write_all(data)
42 }
43
44 fn flush(&mut self) -> io::Result<()> {
45 self.stream.flush()
46 }
47}
48
49/// Parse `host`, `host:port`, or `tcp://host:port` into (host, port).
50pub fn parse_network_target(raw: &str) -> Option<(String, u16)> {
51 let s = raw.trim();
52 if s.is_empty() {
53 return None;
54 }
55 let s = s
56 .strip_prefix("tcp://")
57 .or_else(|| s.strip_prefix("TCP://"))
58 .unwrap_or(s)
59 .trim();
60
61 // [ipv6]:port — not required for typical POS; skip for now.
62 if s.starts_with('[') {
63 return None;
64 }
65
66 if let Some((host, port_str)) = s.rsplit_once(':') {
67 // Avoid treating IPv4 as host:port when there are multiple colons.
68 if host.parse::<Ipv4Addr>().is_ok() || (!host.is_empty() && !host.contains(':')) {
69 if let Ok(port) = port_str.parse::<u16>() {
70 if port != 0 && !host.is_empty() {
71 return Some((host.to_string(), port));
72 }
73 }
74 }
75 }
76
77 // Bare hostname / IPv4 → default port.
78 if s.parse::<Ipv4Addr>().is_ok() || (!s.is_empty() && !s.contains('/')) {
79 return Some((s.to_string(), DEFAULT_PORT));
80 }
81 None
82}
83
84pub fn network_device(host: &str, port: u16) -> PrinterDevice {
85 let port = if port == 0 { DEFAULT_PORT } else { port };
86 PrinterDevice {
87 id: format!("net:{host}:{port}"),
88 display_name: format!("{host}:{port} — LAN (TCP)"),
89 target: PrinterTarget::Network {
90 host: host.to_string(),
91 port,
92 },
93 }
94}
95
96pub fn probe_host(host: &str, port: u16, timeout: Duration) -> bool {
97 let Ok(addr) = resolve_socket_addr(host, port) else {
98 return false;
99 };
100 TcpStream::connect_timeout(&addr, timeout).is_ok()
101}
102
103fn resolve_socket_addr(host: &str, port: u16) -> Result<SocketAddr, PrintError> {
104 if let Ok(ip) = host.parse::<IpAddr>() {
105 return Ok(SocketAddr::new(ip, port));
106 }
107 // Hostname: use blocking resolve with first result.
108 let mut addrs = std::net::ToSocketAddrs::to_socket_addrs(&(host, port)).map_err(|e| {
109 PrintError::Open(format!("resolve {host}: {e}"))
110 })?;
111 addrs
112 .next()
113 .ok_or_else(|| PrintError::Open(format!("resolve {host}: no addresses")))
114}
115
116/// Cached LAN printer entry (persisted in `AppConfig`).
117#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
118pub struct LanPrinterCacheEntry {
119 pub host: String,
120 pub port: u16,
121 #[serde(default)]
122 pub last_seen_unix: u64,
123}
124
125impl LanPrinterCacheEntry {
126 pub fn new(host: impl Into<String>, port: u16) -> Self {
127 Self {
128 host: host.into(),
129 port: if port == 0 { DEFAULT_PORT } else { port },
130 last_seen_unix: unix_now(),
131 }
132 }
133}
134
135fn unix_now() -> u64 {
136 SystemTime::now()
137 .duration_since(UNIX_EPOCH)
138 .map(|d| d.as_secs())
139 .unwrap_or(0)
140}
141
142/// Re-check cached hosts; return only those that still accept TCP on the port.
143pub fn validate_cache(cache: &[LanPrinterCacheEntry]) -> Vec<PrinterDevice> {
144 let (tx, rx) = mpsc::channel();
145 let mut handles = Vec::new();
146 for entry in cache {
147 let host = entry.host.clone();
148 let port = if entry.port == 0 {
149 DEFAULT_PORT
150 } else {
151 entry.port
152 };
153 let tx = tx.clone();
154 handles.push(thread::spawn(move || {
155 if probe_host(&host, port, PROBE_TIMEOUT) {
156 let _ = tx.send(network_device(&host, port));
157 }
158 }));
159 }
160 drop(tx);
161 for h in handles {
162 let _ = h.join();
163 }
164 let mut out: Vec<_> = rx.into_iter().collect();
165 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
166 out.dedup_by(|a, b| a.id == b.id);
167 out
168}
169
170/// Scan local IPv4 /24 subnets for open TCP `port`.
171pub fn scan_local_subnets(port: u16) -> Vec<PrinterDevice> {
172 let port = if port == 0 { DEFAULT_PORT } else { port };
173 let mut targets: Vec<Ipv4Addr> = Vec::new();
174 for (ip, prefix) in local_ipv4_subnets() {
175 targets.extend(hosts_in_subnet(ip, prefix));
176 }
177 targets.sort();
178 targets.dedup();
179
180 if targets.is_empty() {
181 return Vec::new();
182 }
183
184 let (job_tx, job_rx) = mpsc::channel::<Ipv4Addr>();
185 let (hit_tx, hit_rx) = mpsc::channel::<PrinterDevice>();
186
187 let workers = SCAN_WORKERS.min(targets.len()).max(1);
188 let job_rx = std::sync::Arc::new(std::sync::Mutex::new(job_rx));
189 let mut handles = Vec::with_capacity(workers);
190 for _ in 0..workers {
191 let job_rx = std::sync::Arc::clone(&job_rx);
192 let hit_tx = hit_tx.clone();
193 handles.push(thread::spawn(move || {
194 loop {
195 let ip = {
196 let Ok(rx) = job_rx.lock() else {
197 break;
198 };
199 match rx.recv() {
200 Ok(ip) => ip,
201 Err(_) => break,
202 }
203 };
204 let host = ip.to_string();
205 if probe_host(&host, port, PROBE_TIMEOUT) {
206 let _ = hit_tx.send(network_device(&host, port));
207 }
208 }
209 }));
210 }
211 drop(hit_tx);
212
213 for ip in targets {
214 let _ = job_tx.send(ip);
215 }
216 drop(job_tx);
217
218 for h in handles {
219 let _ = h.join();
220 }
221
222 let mut out: Vec<_> = hit_rx.into_iter().collect();
223 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
224 out.dedup_by(|a, b| a.id == b.id);
225 out
226}
227
228/// Merge validated cache hits with a fresh scan; refresh `last_seen` for survivors.
229pub fn merge_lan_devices(
230 validated_cache: &[PrinterDevice],
231 scanned: &[PrinterDevice],
232) -> Vec<PrinterDevice> {
233 let mut out = Vec::new();
234 for d in validated_cache.iter().chain(scanned.iter()) {
235 if !out.iter().any(|x: &PrinterDevice| x.id == d.id) {
236 out.push(d.clone());
237 }
238 }
239 out.sort_by(|a, b| a.display_name.cmp(&b.display_name));
240 out
241}
242
243pub fn cache_entries_from_devices(devices: &[PrinterDevice]) -> Vec<LanPrinterCacheEntry> {
244 let now = unix_now();
245 let mut entries = Vec::new();
246 for d in devices {
247 if let PrinterTarget::Network { host, port } = &d.target {
248 entries.push(LanPrinterCacheEntry {
249 host: host.clone(),
250 port: *port,
251 last_seen_unix: now,
252 });
253 }
254 }
255 entries.sort_by(|a, b| (&a.host, a.port).cmp(&(&b.host, b.port)));
256 entries.dedup_by(|a, b| a.host == b.host && a.port == b.port);
257 entries
258}
259
260/// Remember a successful network print in the durable LAN cache.
261pub fn remember_in_cache(cache: &mut Vec<LanPrinterCacheEntry>, host: &str, port: u16) {
262 let port = if port == 0 { DEFAULT_PORT } else { port };
263 let now = unix_now();
264 if let Some(existing) = cache.iter_mut().find(|e| e.host == host && e.port == port) {
265 existing.last_seen_unix = now;
266 return;
267 }
268 cache.push(LanPrinterCacheEntry {
269 host: host.to_string(),
270 port,
271 last_seen_unix: now,
272 });
273 cache.sort_by(|a, b| (&a.host, a.port).cmp(&(&b.host, b.port)));
274}
275
276fn local_ipv4_subnets() -> Vec<(Ipv4Addr, u8)> {
277 let mut out = Vec::new();
278
279 #[cfg(unix)]
280 {
281 out.extend(unix_ipv4_subnets());
282 }
283
284 // Always include the default-route interface /24 when available.
285 if let Some(ip) = primary_ipv4() {
286 if !ip.is_loopback() && !is_link_local(ip) {
287 out.push((ip, 24));
288 }
289 }
290
291 out.sort_by_key(|(ip, p)| (u32::from(*ip), *p));
292 out.dedup();
293 out
294}
295
296fn primary_ipv4() -> Option<Ipv4Addr> {
297 let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
298 // No packets need to be sent; connect selects a route and local address.
299 socket.connect("8.8.8.8:80").ok()?;
300 match socket.local_addr().ok()?.ip() {
301 IpAddr::V4(ip) => Some(ip),
302 IpAddr::V6(_) => None,
303 }
304}
305
306fn is_link_local(ip: Ipv4Addr) -> bool {
307 ip.octets()[0] == 169 && ip.octets()[1] == 254
308}
309
310fn hosts_in_subnet(ip: Ipv4Addr, prefix: u8) -> Vec<Ipv4Addr> {
311 let prefix = prefix.min(30);
312 let ip_u = u32::from(ip);
313 let mask = if prefix == 0 {
314 0
315 } else {
316 !0u32 << (32 - prefix)
317 };
318 let network = ip_u & mask;
319 let broadcast = network | !mask;
320 let mut hosts = Vec::new();
321 // Skip network and broadcast addresses.
322 let mut cur = network.saturating_add(1);
323 while cur < broadcast {
324 let host = Ipv4Addr::from(cur);
325 if host != ip && !host.is_loopback() && !is_link_local(host) {
326 hosts.push(host);
327 }
328 cur = cur.saturating_add(1);
329 }
330 hosts
331}
332
333#[cfg(unix)]
334fn unix_ipv4_subnets() -> Vec<(Ipv4Addr, u8)> {
335 use std::ptr;
336
337 let mut out = Vec::new();
338 unsafe {
339 let mut ifap: *mut libc::ifaddrs = ptr::null_mut();
340 if libc::getifaddrs(&mut ifap) != 0 {
341 return out;
342 }
343 let mut cursor = ifap;
344 while !cursor.is_null() {
345 let entry = &*cursor;
346 if !entry.ifa_addr.is_null()
347 && (*entry.ifa_addr).sa_family as i32 == libc::AF_INET
348 && !entry.ifa_netmask.is_null()
349 {
350 let addr = &*(entry.ifa_addr as *const libc::sockaddr_in);
351 let mask = &*(entry.ifa_netmask as *const libc::sockaddr_in);
352 let ip = Ipv4Addr::from(u32::from_be(addr.sin_addr.s_addr));
353 let mask_u = u32::from_be(mask.sin_addr.s_addr);
354 if !ip.is_loopback() && !is_link_local(ip) && mask_u != 0 {
355 let prefix = mask_u.count_ones() as u8;
356 // Cap scan size: only /24 or narrower (more specific).
357 if (16..=30).contains(&prefix) {
358 out.push((ip, prefix.min(24)));
359 }
360 }
361 }
362 cursor = entry.ifa_next;
363 }
364 libc::freeifaddrs(ifap);
365 }
366 out
367}
368
369/// Approximate wall time for a full /24 probe (for tests / UI hints).
370#[allow(dead_code)]
371pub fn estimate_scan_budget(host_count: usize) -> Duration {
372 let batches = host_count.div_ceil(SCAN_WORKERS).max(1);
373 PROBE_TIMEOUT * batches as u32 + Duration::from_millis(50)
374}
375
376#[cfg(test)]
377mod tests {
378 use super::*;
379 use std::net::TcpListener;
380 use std::thread;
381
382 #[test]
383 fn parse_host_and_optional_port() {
384 assert_eq!(
385 parse_network_target("192.168.1.50"),
386 Some(("192.168.1.50".into(), 9100))
387 );
388 assert_eq!(
389 parse_network_target("192.168.1.50:9100"),
390 Some(("192.168.1.50".into(), 9100))
391 );
392 assert_eq!(
393 parse_network_target("tcp://pos.local:9101"),
394 Some(("pos.local".into(), 9101))
395 );
396 assert_eq!(parse_network_target(""), None);
397 assert_eq!(parse_network_target(" "), None);
398 }
399
400 #[test]
401 fn probe_finds_local_listener() {
402 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
403 let port = listener.local_addr().unwrap().port();
404 let accept = thread::spawn(move || {
405 let _ = listener.accept();
406 });
407 assert!(probe_host("127.0.0.1", port, Duration::from_secs(1)));
408 let _ = accept.join();
409 }
410
411 #[test]
412 fn network_transport_writes_to_listener() {
413 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
414 let port = listener.local_addr().unwrap().port();
415 let accept = thread::spawn(move || {
416 let (mut stream, _) = listener.accept().unwrap();
417 let mut buf = [0u8; 4];
418 use std::io::Read;
419 stream.read_exact(&mut buf).unwrap();
420 buf
421 });
422 let mut transport = NetworkTransport::open("127.0.0.1", port).unwrap();
423 transport.write_all(&[1, 2, 3, 4]).unwrap();
424 transport.flush().unwrap();
425 assert_eq!(accept.join().unwrap(), [1, 2, 3, 4]);
426 }
427
428 #[test]
429 fn hosts_in_slash24_skips_network_and_broadcast() {
430 let hosts = hosts_in_subnet(Ipv4Addr::new(192, 168, 1, 10), 24);
431 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 0)));
432 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 255)));
433 assert!(!hosts.contains(&Ipv4Addr::new(192, 168, 1, 10))); // self
434 assert!(hosts.contains(&Ipv4Addr::new(192, 168, 1, 1)));
435 assert_eq!(hosts.len(), 253);
436 }
437
438 #[test]
439 fn merge_dedupes_by_id() {
440 let a = network_device("192.168.0.5", 9100);
441 let b = network_device("192.168.0.5", 9100);
442 let c = network_device("192.168.0.6", 9100);
443 let merged = merge_lan_devices(&[a.clone()], &[b, c.clone()]);
444 assert_eq!(merged.len(), 2);
445 assert!(merged.iter().any(|d| d.id == a.id));
446 assert!(merged.iter().any(|d| d.id == c.id));
447 }
448
449 #[test]
450 fn cache_roundtrip_helpers() {
451 let devices = vec![network_device("10.0.0.8", 9100)];
452 let entries = cache_entries_from_devices(&devices);
453 assert_eq!(entries.len(), 1);
454 assert_eq!(entries[0].host, "10.0.0.8");
455 let mut cache = entries;
456 remember_in_cache(&mut cache, "10.0.0.9", 9100);
457 assert_eq!(cache.len(), 2);
458 remember_in_cache(&mut cache, "10.0.0.8", 9100);
459 assert_eq!(cache.len(), 2);
460 }
461
462 #[test]
463 fn estimate_scan_budget_is_finite() {
464 let _ = Instant::now();
465 assert!(estimate_scan_budget(254) > Duration::from_millis(0));
466 }
467}