use std::io::{self, Write}; use std::time::Duration; use serialport::SerialPortType; mod network; mod usb_direct; #[cfg(windows)] mod win_spool; pub use network::{ cache_entries_from_devices, merge_lan_devices, network_device, parse_network_target, probe_host, remember_in_cache, scan_local_subnets, validate_cache, LanPrinterCacheEntry, NetworkTransport, DEFAULT_PORT, PROBE_TIMEOUT, }; /// Common baud rates for USB POS printers (115200 first — many modern devices). pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800]; #[derive(Debug, Clone, PartialEq, Eq)] pub enum PrinterTarget { Serial(String), UsbDirect { vid: u16, pid: u16, bus: u8, address: u8, }, WinSpooler(String), /// Raw ESC/POS over TCP (typically port 9100). Network { host: String, port: u16, }, } #[derive(Debug, Clone, PartialEq, Eq)] pub struct PrinterDevice { pub id: String, pub display_name: String, pub target: PrinterTarget, } #[derive(Debug)] pub enum PrintError { NotFound, Open(String), Write(String), Serial(serialport::Error), } impl From for PrintError { fn from(value: serialport::Error) -> Self { Self::Serial(value) } } pub trait PrinterTransport { fn write_all(&mut self, data: &[u8]) -> io::Result<()>; fn flush(&mut self) -> io::Result<()>; } pub struct SerialTransport { port: Box, pub baud_rate: u32, } impl SerialTransport { pub fn open(port_name: &str) -> Result { let mut last_err = String::from("no baud rate succeeded"); for &baud in &BAUD_RATES { match serialport::new(port_name, baud) .timeout(Duration::from_millis(2000)) .open() { Ok(port) => { return Ok(Self { port, baud_rate: baud }); } Err(e) => last_err = format!("{baud} baud: {e}"), } } Err(PrintError::Open(last_err)) } } impl PrinterTransport for SerialTransport { fn write_all(&mut self, data: &[u8]) -> io::Result<()> { self.port.write_all(data) } fn flush(&mut self) -> io::Result<()> { self.port.flush() } } /// List local POS printers: USB printer-class, Windows spooler, USB-serial. /// Does **not** include LAN discovery (see `discover_printers` / print dialog). pub fn list_printers() -> Result, PrintError> { list_local_printers() } pub fn list_local_printers() -> Result, PrintError> { let mut devices = usb_direct::list_usb_printer_devices(); #[cfg(windows)] devices.extend(win_spool::list_windows_spooler_printers()); devices.extend(list_serial_devices()?); Ok(devices) } pub fn list_usb_serial_printers() -> Result, serialport::Error> { list_serial_devices() } fn list_serial_devices() -> Result, serialport::Error> { let mut devices = Vec::new(); for port in serialport::available_ports()? { // Only USB-attached serial devices: Linux often lists dozens of empty // /dev/ttyS* (PCI/Unknown) that are not connected to anything. let SerialPortType::UsbPort(info) = &port.port_type else { continue; }; let product = info .product .as_deref() .or(info.serial_number.as_deref()) .unwrap_or("USB device"); let label = format!( "{} — {product} (serial {}:{})", port.port_name, fmt_vid_pid(info.vid), fmt_vid_pid(info.pid) ); devices.push(PrinterDevice { id: format!("serial:{}", port.port_name), display_name: label, target: PrinterTarget::Serial(port.port_name.clone()), }); } devices.sort_by(|a, b| a.display_name.cmp(&b.display_name)); Ok(devices) } /// True when a serial port type is a connected USB device (possible POS printer). pub fn is_usb_serial_candidate(port_type: &SerialPortType) -> bool { matches!(port_type, SerialPortType::UsbPort(_)) } pub fn open_printer(target: &PrinterTarget) -> Result, PrintError> { match target { PrinterTarget::Serial(port) => Ok(Box::new(SerialTransport::open(port)?)), PrinterTarget::UsbDirect { vid, pid, bus, address, } => Ok(Box::new(usb_direct::UsbDirectTransport::open( *vid, *pid, *bus, *address, )?)), #[cfg(windows)] PrinterTarget::WinSpooler(name) => Ok(Box::new(win_spool::WinSpoolerTransport::new( name.clone(), ))), #[cfg(not(windows))] PrinterTarget::WinSpooler(_) => Err(PrintError::Open( "Windows spooler printing is only available on Windows".into(), )), PrinterTarget::Network { host, port } => { Ok(Box::new(NetworkTransport::open(host, *port)?)) } } } /// Open by manual name: network `host`/`host:port`, then serial/COM, then Windows spooler. pub fn open_printer_by_name(name: &str) -> Result, PrintError> { let name = name.trim(); if name.is_empty() { return Err(PrintError::NotFound); } if let Some((host, port)) = parse_network_target(name) { // Prefer TCP when the string looks like a host/IP (avoids treating paths as hosts). if looks_like_network_name(name) { return Ok(Box::new(NetworkTransport::open(&host, port)?)); } } if let Ok(transport) = SerialTransport::open(name) { return Ok(Box::new(transport)); } // Fall back to network parse for hostnames that failed serial open. if let Some((host, port)) = parse_network_target(name) { return Ok(Box::new(NetworkTransport::open(&host, port)?)); } #[cfg(windows)] { return Ok(Box::new(win_spool::WinSpoolerTransport::new( name.to_string(), ))); } #[cfg(not(windows))] Err(PrintError::Open(format!( "could not open printer '{name}' (serial or TCP)" ))) } fn looks_like_network_name(name: &str) -> bool { let s = name.trim(); if s.starts_with('/') || s.chars().any(|c| c == '\\') { return false; } // COM ports, Windows-style let upper = s.to_ascii_uppercase(); if upper.starts_with("COM") && upper[3..].chars().all(|c| c.is_ascii_digit()) { return false; } s.contains('.') || s.contains(':') || s.eq_ignore_ascii_case("localhost") } fn fmt_vid_pid(v: u16) -> String { format!("{v:04x}") } impl PrinterTransport for Box { fn write_all(&mut self, data: &[u8]) -> io::Result<()> { (**self).write_all(data) } fn flush(&mut self) -> io::Result<()> { (**self).flush() } } pub fn print_bytes(transport: &mut T, data: &[u8]) -> Result<(), PrintError> { transport .write_all(data) .map_err(|e| PrintError::Write(e.to_string()))?; transport .flush() .map_err(|e| PrintError::Write(e.to_string()))?; Ok(()) } /// Stable key for remembering the last successful printer across reconnects. /// USB uses vid:pid only (bus/address change when replugged). pub fn printer_preference_key(target: &PrinterTarget) -> String { match target { PrinterTarget::Serial(port) => format!("serial:{port}"), PrinterTarget::WinSpooler(name) => format!("winspool:{name}"), PrinterTarget::UsbDirect { vid, pid, .. } => { format!("usb:{vid:04x}:{pid:04x}") } PrinterTarget::Network { host, port } => format!("net:{host}:{port}"), } } pub fn manual_printer_preference_key(name: &str) -> String { format!("manual:{}", name.trim()) } /// Index of a discovered printer matching a stored preference key, if still connected. pub fn find_preferred_printer_index(printers: &[PrinterDevice], key: &str) -> Option { let key = key.trim(); if key.is_empty() || key.starts_with("manual:") { return None; } printers .iter() .position(|p| printer_preference_key(&p.target) == key) } pub struct MockTransport { pub written: Vec, } impl MockTransport { pub fn new() -> Self { Self { written: Vec::new() } } } impl Default for MockTransport { fn default() -> Self { Self::new() } } impl PrinterTransport for MockTransport { fn write_all(&mut self, data: &[u8]) -> io::Result<()> { self.written.extend_from_slice(data); Ok(()) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } #[cfg(test)] mod tests { use super::*; use serialport::UsbPortInfo; #[test] fn mock_transport_records_bytes() { let mut mock = MockTransport::new(); print_bytes(&mut mock, &[1, 2, 3]).unwrap(); assert_eq!(mock.written, vec![1, 2, 3]); } #[test] fn list_printers_returns_vec() { let list = list_printers(); assert!(list.is_ok()); } #[test] fn non_usb_serial_ports_are_not_candidates() { assert!(!is_usb_serial_candidate(&SerialPortType::PciPort)); assert!(!is_usb_serial_candidate(&SerialPortType::BluetoothPort)); assert!(!is_usb_serial_candidate(&SerialPortType::Unknown)); } #[test] fn usb_serial_port_is_candidate() { let usb = SerialPortType::UsbPort(UsbPortInfo { vid: 0x0416, pid: 0x5011, serial_number: None, manufacturer: None, product: Some("POS-58".into()), }); assert!(is_usb_serial_candidate(&usb)); } #[test] fn preference_key_ignores_usb_bus_address() { let a = PrinterTarget::UsbDirect { vid: 0x0416, pid: 0x5011, bus: 1, address: 2, }; let b = PrinterTarget::UsbDirect { vid: 0x0416, pid: 0x5011, bus: 3, address: 9, }; assert_eq!(printer_preference_key(&a), printer_preference_key(&b)); assert_eq!(printer_preference_key(&a), "usb:0416:5011"); } #[test] fn finds_preferred_printer_by_key() { let printers = vec![ PrinterDevice { id: "serial:COM1".into(), display_name: "COM1".into(), target: PrinterTarget::Serial("COM1".into()), }, PrinterDevice { id: "winspool:POS".into(), display_name: "POS".into(), target: PrinterTarget::WinSpooler("POS".into()), }, PrinterDevice { id: "net:10.0.0.5:9100".into(), display_name: "10.0.0.5:9100".into(), target: PrinterTarget::Network { host: "10.0.0.5".into(), port: 9100, }, }, ]; assert_eq!( find_preferred_printer_index(&printers, "winspool:POS"), Some(1) ); assert_eq!(find_preferred_printer_index(&printers, "serial:COM9"), None); assert_eq!( find_preferred_printer_index(&printers, "manual:COM3"), None ); assert_eq!( find_preferred_printer_index(&printers, "net:10.0.0.5:9100"), Some(2) ); } #[test] fn preference_key_for_network() { let t = PrinterTarget::Network { host: "192.168.1.20".into(), port: 9100, }; assert_eq!(printer_preference_key(&t), "net:192.168.1.20:9100"); } #[test] fn open_by_name_rejects_empty() { assert!(matches!( open_printer_by_name(" "), Err(PrintError::NotFound) )); } }