BlueGit

timfa posprint

Files

posprint / src / print / mod.rs

mod.rs

32c21ccb History
mod.rs 12.1 KiB Download Raw
1use std::io::{self, Write};
2use std::time::Duration;
3
4use serialport::SerialPortType;
5
6mod network;
7mod usb_direct;
8#[cfg(windows)]
9mod win_spool;
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
17/// Common baud rates for USB POS printers (115200 first — many modern devices).
18pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800];
19
20#[derive(Debug, Clone, PartialEq, Eq)]
21pub enum PrinterTarget {
22 Serial(String),
23 UsbDirect {
24 vid: u16,
25 pid: u16,
26 bus: u8,
27 address: u8,
28 },
29 WinSpooler(String),
30 /// Raw ESC/POS over TCP (typically port 9100).
31 Network {
32 host: String,
33 port: u16,
34 },
35}
36
37#[derive(Debug, Clone, PartialEq, Eq)]
38pub struct PrinterDevice {
39 pub id: String,
40 pub display_name: String,
41 pub target: PrinterTarget,
42}
43
44#[derive(Debug)]
45pub enum PrintError {
46 NotFound,
47 Open(String),
48 Write(String),
49 Serial(serialport::Error),
50}
51
52impl From<serialport::Error> for PrintError {
53 fn from(value: serialport::Error) -> Self {
54 Self::Serial(value)
55 }
56}
57
58pub trait PrinterTransport {
59 fn write_all(&mut self, data: &[u8]) -> io::Result<()>;
60 fn flush(&mut self) -> io::Result<()>;
61}
62
63pub struct SerialTransport {
64 port: Box<dyn serialport::SerialPort>,
65 pub baud_rate: u32,
66}
67
68impl SerialTransport {
69 pub fn open(port_name: &str) -> Result<Self, PrintError> {
70 let mut last_err = String::from("no baud rate succeeded");
71 for &baud in &BAUD_RATES {
72 match serialport::new(port_name, baud)
73 .timeout(Duration::from_millis(2000))
74 .open()
75 {
76 Ok(port) => {
77 return Ok(Self { port, baud_rate: baud });
78 }
79 Err(e) => last_err = format!("{baud} baud: {e}"),
80 }
81 }
82 Err(PrintError::Open(last_err))
83 }
84}
85
86impl PrinterTransport for SerialTransport {
87 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
88 self.port.write_all(data)
89 }
90
91 fn flush(&mut self) -> io::Result<()> {
92 self.port.flush()
93 }
94}
95
96/// List local POS printers: USB printer-class, Windows spooler, USB-serial.
97/// Does **not** include LAN discovery (see `discover_printers` / print dialog).
98pub fn list_printers() -> Result<Vec<PrinterDevice>, PrintError> {
99 list_local_printers()
100}
101
102pub fn list_local_printers() -> Result<Vec<PrinterDevice>, PrintError> {
103 let mut devices = usb_direct::list_usb_printer_devices();
104
105 #[cfg(windows)]
106 devices.extend(win_spool::list_windows_spooler_printers());
107
108 devices.extend(list_serial_devices()?);
109 Ok(devices)
110}
111
112pub fn list_usb_serial_printers() -> Result<Vec<PrinterDevice>, serialport::Error> {
113 list_serial_devices()
114}
115
116fn list_serial_devices() -> Result<Vec<PrinterDevice>, serialport::Error> {
117 let mut devices = Vec::new();
118 for port in serialport::available_ports()? {
119 // Only USB-attached serial devices: Linux often lists dozens of empty
120 // /dev/ttyS* (PCI/Unknown) that are not connected to anything.
121 let SerialPortType::UsbPort(info) = &port.port_type else {
122 continue;
123 };
124 let product = info
125 .product
126 .as_deref()
127 .or(info.serial_number.as_deref())
128 .unwrap_or("USB device");
129 let label = format!(
130 "{} — {product} (serial {}:{})",
131 port.port_name,
132 fmt_vid_pid(info.vid),
133 fmt_vid_pid(info.pid)
134 );
135 devices.push(PrinterDevice {
136 id: format!("serial:{}", port.port_name),
137 display_name: label,
138 target: PrinterTarget::Serial(port.port_name.clone()),
139 });
140 }
141 devices.sort_by(|a, b| a.display_name.cmp(&b.display_name));
142 Ok(devices)
143}
144
145/// True when a serial port type is a connected USB device (possible POS printer).
146pub fn is_usb_serial_candidate(port_type: &SerialPortType) -> bool {
147 matches!(port_type, SerialPortType::UsbPort(_))
148}
149
150pub fn open_printer(target: &PrinterTarget) -> Result<Box<dyn PrinterTransport>, PrintError> {
151 match target {
152 PrinterTarget::Serial(port) => Ok(Box::new(SerialTransport::open(port)?)),
153 PrinterTarget::UsbDirect {
154 vid,
155 pid,
156 bus,
157 address,
158 } => Ok(Box::new(usb_direct::UsbDirectTransport::open(
159 *vid, *pid, *bus, *address,
160 )?)),
161 #[cfg(windows)]
162 PrinterTarget::WinSpooler(name) => Ok(Box::new(win_spool::WinSpoolerTransport::new(
163 name.clone(),
164 ))),
165 #[cfg(not(windows))]
166 PrinterTarget::WinSpooler(_) => Err(PrintError::Open(
167 "Windows spooler printing is only available on Windows".into(),
168 )),
169 PrinterTarget::Network { host, port } => {
170 Ok(Box::new(NetworkTransport::open(host, *port)?))
171 }
172 }
173}
174
175/// Open by manual name: network `host`/`host:port`, then serial/COM, then Windows spooler.
176pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
177 let name = name.trim();
178 if name.is_empty() {
179 return Err(PrintError::NotFound);
180 }
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
189 if let Ok(transport) = SerialTransport::open(name) {
190 return Ok(Box::new(transport));
191 }
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
198 #[cfg(windows)]
199 {
200 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
201 name.to_string(),
202 )));
203 }
204
205 #[cfg(not(windows))]
206 Err(PrintError::Open(format!(
207 "could not open printer '{name}' (serial or TCP)"
208 )))
209}
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
224fn fmt_vid_pid(v: u16) -> String {
225 format!("{v:04x}")
226}
227
228impl PrinterTransport for Box<dyn PrinterTransport> {
229 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
230 (**self).write_all(data)
231 }
232
233 fn flush(&mut self) -> io::Result<()> {
234 (**self).flush()
235 }
236}
237
238pub fn print_bytes<T: PrinterTransport + ?Sized>(transport: &mut T, data: &[u8]) -> Result<(), PrintError> {
239 transport
240 .write_all(data)
241 .map_err(|e| PrintError::Write(e.to_string()))?;
242 transport
243 .flush()
244 .map_err(|e| PrintError::Write(e.to_string()))?;
245 Ok(())
246}
247
248/// Stable key for remembering the last successful printer across reconnects.
249/// USB uses vid:pid only (bus/address change when replugged).
250pub fn printer_preference_key(target: &PrinterTarget) -> String {
251 match target {
252 PrinterTarget::Serial(port) => format!("serial:{port}"),
253 PrinterTarget::WinSpooler(name) => format!("winspool:{name}"),
254 PrinterTarget::UsbDirect { vid, pid, .. } => {
255 format!("usb:{vid:04x}:{pid:04x}")
256 }
257 PrinterTarget::Network { host, port } => format!("net:{host}:{port}"),
258 }
259}
260
261pub fn manual_printer_preference_key(name: &str) -> String {
262 format!("manual:{}", name.trim())
263}
264
265/// Index of a discovered printer matching a stored preference key, if still connected.
266pub fn find_preferred_printer_index(printers: &[PrinterDevice], key: &str) -> Option<usize> {
267 let key = key.trim();
268 if key.is_empty() || key.starts_with("manual:") {
269 return None;
270 }
271 printers
272 .iter()
273 .position(|p| printer_preference_key(&p.target) == key)
274}
275
276pub struct MockTransport {
277 pub written: Vec<u8>,
278}
279
280impl MockTransport {
281 pub fn new() -> Self {
282 Self { written: Vec::new() }
283 }
284}
285
286impl Default for MockTransport {
287 fn default() -> Self {
288 Self::new()
289 }
290}
291
292impl PrinterTransport for MockTransport {
293 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
294 self.written.extend_from_slice(data);
295 Ok(())
296 }
297
298 fn flush(&mut self) -> io::Result<()> {
299 Ok(())
300 }
301}
302
303#[cfg(test)]
304mod tests {
305 use super::*;
306 use serialport::UsbPortInfo;
307
308 #[test]
309 fn mock_transport_records_bytes() {
310 let mut mock = MockTransport::new();
311 print_bytes(&mut mock, &[1, 2, 3]).unwrap();
312 assert_eq!(mock.written, vec![1, 2, 3]);
313 }
314
315 #[test]
316 fn list_printers_returns_vec() {
317 let list = list_printers();
318 assert!(list.is_ok());
319 }
320
321 #[test]
322 fn non_usb_serial_ports_are_not_candidates() {
323 assert!(!is_usb_serial_candidate(&SerialPortType::PciPort));
324 assert!(!is_usb_serial_candidate(&SerialPortType::BluetoothPort));
325 assert!(!is_usb_serial_candidate(&SerialPortType::Unknown));
326 }
327
328 #[test]
329 fn usb_serial_port_is_candidate() {
330 let usb = SerialPortType::UsbPort(UsbPortInfo {
331 vid: 0x0416,
332 pid: 0x5011,
333 serial_number: None,
334 manufacturer: None,
335 product: Some("POS-58".into()),
336 });
337 assert!(is_usb_serial_candidate(&usb));
338 }
339
340 #[test]
341 fn preference_key_ignores_usb_bus_address() {
342 let a = PrinterTarget::UsbDirect {
343 vid: 0x0416,
344 pid: 0x5011,
345 bus: 1,
346 address: 2,
347 };
348 let b = PrinterTarget::UsbDirect {
349 vid: 0x0416,
350 pid: 0x5011,
351 bus: 3,
352 address: 9,
353 };
354 assert_eq!(printer_preference_key(&a), printer_preference_key(&b));
355 assert_eq!(printer_preference_key(&a), "usb:0416:5011");
356 }
357
358 #[test]
359 fn finds_preferred_printer_by_key() {
360 let printers = vec![
361 PrinterDevice {
362 id: "serial:COM1".into(),
363 display_name: "COM1".into(),
364 target: PrinterTarget::Serial("COM1".into()),
365 },
366 PrinterDevice {
367 id: "winspool:POS".into(),
368 display_name: "POS".into(),
369 target: PrinterTarget::WinSpooler("POS".into()),
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 },
379 ];
380 assert_eq!(
381 find_preferred_printer_index(&printers, "winspool:POS"),
382 Some(1)
383 );
384 assert_eq!(find_preferred_printer_index(&printers, "serial:COM9"), None);
385 assert_eq!(
386 find_preferred_printer_index(&printers, "manual:COM3"),
387 None
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 ));
410 }
411}