use std::io::{self, Write}; use std::time::Duration; use serialport::{SerialPortInfo, SerialPortType}; mod usb_direct; #[cfg(windows)] mod win_spool; /// 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), } #[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 POS printers: USB printer-class, Windows spooler, then USB-serial and /// OS-paired Classic Bluetooth SPP ports. pub fn list_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()? { if let Some(device) = serial_device_from_port(&port) { devices.push(device); } } devices.sort_by(|a, b| a.display_name.cmp(&b.display_name)); Ok(devices) } /// USB-serial or OS-paired Classic Bluetooth SPP. Skips empty PCI/`ttyS*` noise. pub fn is_serial_printer_candidate(port_type: &SerialPortType) -> bool { is_usb_serial_candidate(port_type) || is_bluetooth_serial_candidate(port_type) } /// 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(_)) } /// True when `serialport` reports a Classic Bluetooth SPP / RFCOMM port. pub fn is_bluetooth_serial_candidate(port_type: &SerialPortType) -> bool { matches!(port_type, SerialPortType::BluetoothPort) } /// Linux RFCOMM node (`/dev/rfcomm0`) even if enumeration typed it as Unknown. fn is_rfcomm_device_name(port_name: &str) -> bool { let base = port_name.rsplit(['/', '\\']).next().unwrap_or(port_name); base.len() >= 6 && base[..6].eq_ignore_ascii_case("rfcomm") } /// Map an enumerated serial port to a printer entry, or skip PCI/`ttyS*` noise. pub fn serial_device_from_port(port: &SerialPortInfo) -> Option { if !is_serial_printer_candidate(&port.port_type) && !is_rfcomm_device_name(&port.port_name) { return None; } Some(PrinterDevice { id: format!("serial:{}", port.port_name), display_name: serial_port_display_name(port), target: PrinterTarget::Serial(port.port_name.clone()), }) } fn serial_port_display_name(port: &SerialPortInfo) -> String { match &port.port_type { SerialPortType::UsbPort(info) => { let product = info .product .as_deref() .or(info.serial_number.as_deref()) .unwrap_or("USB device"); format!( "{} — {product} (serial {}:{})", port.port_name, fmt_vid_pid(info.vid), fmt_vid_pid(info.pid) ) } SerialPortType::BluetoothPort => format!("{} — Bluetooth", port.port_name), _ if is_rfcomm_device_name(&port.port_name) => { format!("{} — Bluetooth", port.port_name) } _ => format!("{} — serial", port.port_name), } } 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(), )), } } /// Match a printer from `list_printers()` by `"auto"`, device `id`, preference key (`usb:vid:pid`), or `display_name`. pub fn find_matching_printer<'a>( printers: &'a [PrinterDevice], name: &str, ) -> Option<&'a PrinterDevice> { let name = name.trim(); if name.is_empty() { return None; } if name.eq_ignore_ascii_case("auto") { return printers.first(); } printers.iter().find(|p| { p.id == name || printer_preference_key(&p.target) == name || p.display_name == name }) } /// Open by manual name: tries discovered printers (`id`, `usb:vid:pid`, `"auto"`), then serial/COM, then Windows spooler queue name. pub fn open_printer_by_name(name: &str) -> Result, PrintError> { let name = name.trim(); if name.is_empty() { return Err(PrintError::NotFound); } if let Ok(printers) = list_printers() { if let Some(matched) = find_matching_printer(&printers, name) { return open_printer(&matched.target); } } let serial_name = name.strip_prefix("serial:").unwrap_or(name); if let Ok(transport) = SerialTransport::open(serial_name) { return Ok(Box::new(transport)); } #[cfg(windows)] { return Ok(Box::new(win_spool::WinSpoolerTransport::new( name.to_string(), ))); } #[cfg(not(windows))] Err(PrintError::Open(format!( "could not open serial port '{name}'" ))) } /// IEEE 1284 device ID if the printer exposes one (USB direct only). pub fn printer_device_id(target: &PrinterTarget) -> Option { match target { PrinterTarget::UsbDirect { vid, pid, bus, address } => { usb_direct::read_device_id(*vid, *pid, *bus, *address) } _ => None, } } /// Detect the command language of a printer (ESC/POS unless clearly TSPL). pub fn detect_printer(target: &PrinterTarget) -> crate::protocol::Detection { let id = printer_device_id(target); crate::protocol::detect(target, id.as_deref()) } /// Ask a bidirectional USB printer something and return its raw reply. pub fn query_printer(target: &PrinterTarget, request: &[u8]) -> Option> { match target { PrinterTarget::UsbDirect { vid, pid, bus, address } => usb_direct::query( *vid, *pid, *bus, *address, request, Duration::from_millis(800), ), _ => None, } } 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}") } } } 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::{SerialPortInfo, 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()); } fn sample_usb_port_type() -> SerialPortType { SerialPortType::UsbPort(UsbPortInfo { vid: 0x0416, pid: 0x5011, serial_number: None, manufacturer: None, product: Some("POS-58".into()), }) } #[test] fn pci_and_unknown_serial_ports_are_not_candidates() { assert!(!is_serial_printer_candidate(&SerialPortType::PciPort)); assert!(!is_serial_printer_candidate(&SerialPortType::Unknown)); assert!(!is_usb_serial_candidate(&SerialPortType::BluetoothPort)); assert!(!is_usb_serial_candidate(&SerialPortType::PciPort)); assert!(!is_usb_serial_candidate(&SerialPortType::Unknown)); } #[test] fn usb_and_bluetooth_serial_ports_are_candidates() { let usb = sample_usb_port_type(); assert!(is_usb_serial_candidate(&usb)); assert!(is_serial_printer_candidate(&usb)); assert!(is_bluetooth_serial_candidate(&SerialPortType::BluetoothPort)); assert!(is_serial_printer_candidate(&SerialPortType::BluetoothPort)); } #[test] fn bluetooth_serial_device_is_labeled() { let port = SerialPortInfo { port_name: "COM5".into(), port_type: SerialPortType::BluetoothPort, }; let device = serial_device_from_port(&port).expect("bluetooth candidate"); assert_eq!(device.id, "serial:COM5"); assert_eq!(device.display_name, "COM5 — Bluetooth"); assert_eq!(device.target, PrinterTarget::Serial("COM5".into())); } #[test] fn linux_rfcomm_is_listed_even_if_type_unknown() { let port = SerialPortInfo { port_name: "/dev/rfcomm0".into(), port_type: SerialPortType::Unknown, }; let device = serial_device_from_port(&port).expect("rfcomm candidate"); assert_eq!(device.display_name, "/dev/rfcomm0 — Bluetooth"); assert_eq!(device.target, PrinterTarget::Serial("/dev/rfcomm0".into())); } #[test] fn empty_pci_ttys_ports_are_not_listed() { let pci = SerialPortInfo { port_name: "/dev/ttyS0".into(), port_type: SerialPortType::PciPort, }; assert!(serial_device_from_port(&pci).is_none()); let unknown = SerialPortInfo { port_name: "/dev/ttyS1".into(), port_type: SerialPortType::Unknown, }; assert!(serial_device_from_port(&unknown).is_none()); } #[test] fn usb_serial_device_keeps_vid_pid_label() { let port = SerialPortInfo { port_name: "/dev/ttyUSB0".into(), port_type: sample_usb_port_type(), }; let device = serial_device_from_port(&port).expect("usb candidate"); assert!(device.display_name.contains("POS-58")); assert!(device.display_name.contains("0416:5011")); assert!(!device.display_name.contains("Bluetooth")); } #[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()), }, ]; 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 ); } #[test] fn matches_discovered_printer_by_id_key_or_auto() { let printers = vec![ PrinterDevice { id: "usb:28e9:0289:0:1".into(), display_name: "micro-printer — USB 28e9:0289 (direct)".into(), target: PrinterTarget::UsbDirect { vid: 0x28e9, pid: 0x0289, bus: 0, address: 1, }, }, PrinterDevice { id: "serial:/dev/cu.usbserial-1410".into(), display_name: "/dev/cu.usbserial-1410 — POS-58 (serial 0416:5011)".into(), target: PrinterTarget::Serial("/dev/cu.usbserial-1410".into()), }, ]; assert_eq!( find_matching_printer(&printers, "auto").map(|p| p.id.as_str()), Some("usb:28e9:0289:0:1") ); assert_eq!( find_matching_printer(&printers, "usb:28e9:0289:0:1").map(|p| p.id.as_str()), Some("usb:28e9:0289:0:1") ); assert_eq!( find_matching_printer(&printers, "usb:28e9:0289").map(|p| p.id.as_str()), Some("usb:28e9:0289:0:1") ); assert_eq!( find_matching_printer(&printers, "serial:/dev/cu.usbserial-1410").map(|p| p.id.as_str()), Some("serial:/dev/cu.usbserial-1410") ); assert!(find_matching_printer(&printers, "usb:9999:9999").is_none()); assert!(find_matching_printer(&[], "auto").is_none()); } }