//! USB printer-class device discovery and RAW bulk printing (libusb). use std::io; use std::time::Duration; use rusb::{Context, Device, DeviceHandle, Direction, TransferType, UsbContext}; use super::{PrintError, PrinterDevice, PrinterTarget}; const USB_CLASS_PRINTER: u8 = 0x07; const WRITE_CHUNK: usize = 512; pub fn list_usb_printer_devices() -> Vec { let Ok(context) = Context::new() else { return Vec::new(); }; let Ok(devices) = context.devices() else { return Vec::new(); }; let mut out = Vec::new(); for device in devices.iter() { let Ok(desc) = device.device_descriptor() else { continue; }; if !device_has_printer_interface(&device) { continue; } let vid = desc.vendor_id(); let pid = desc.product_id(); let bus = device.bus_number(); let address = device.address(); let product = read_product_string(&device, &desc).unwrap_or_else(|| { format!("USB printer {vid:04x}:{pid:04x}") }); out.push(PrinterDevice { id: format!("usb:{bus}:{address}:{vid:04x}:{pid:04x}"), display_name: format!("{product} — USB {vid:04x}:{pid:04x} (direct)"), target: PrinterTarget::UsbDirect { vid, pid, bus, address, }, }); } out } fn device_has_printer_interface(device: &Device) -> bool { for config_index in 0..device.device_descriptor().map(|d| d.num_configurations()).unwrap_or(0) { let Ok(config) = device.config_descriptor(config_index) else { continue; }; for interface in config.interfaces() { for descriptor in interface.descriptors() { if descriptor.class_code() == USB_CLASS_PRINTER { return true; } } } } false } fn read_product_string(device: &Device, desc: &rusb::DeviceDescriptor) -> Option { if desc.product_string_index().is_none() { return None; } let handle = device.open().ok()?; let lang = handle .read_languages(Duration::from_millis(200)) .ok()? .into_iter() .next()?; handle .read_product_string(lang, desc, Duration::from_millis(200)) .ok() } pub struct UsbDirectTransport { handle: DeviceHandle, endpoint: u8, timeout: Duration, } impl UsbDirectTransport { pub fn open(vid: u16, pid: u16, bus: u8, address: u8) -> Result { let context = Context::new().map_err(|e| PrintError::Open(e.to_string()))?; let device = find_device(&context, vid, pid, bus, address) .ok_or(PrintError::NotFound)?; let handle = device .open() .map_err(|e| PrintError::Open(e.to_string()))?; #[cfg(any(target_os = "linux", target_os = "macos"))] if handle.kernel_driver_active(0).unwrap_or(false) { let _ = handle.detach_kernel_driver(0); } let (interface, endpoint) = find_printer_out_endpoint(&device)?; handle .claim_interface(interface) .map_err(|e| PrintError::Open(e.to_string()))?; Ok(Self { handle, endpoint, timeout: Duration::from_secs(5), }) } } impl super::PrinterTransport for UsbDirectTransport { fn write_all(&mut self, data: &[u8]) -> io::Result<()> { for chunk in data.chunks(WRITE_CHUNK) { self.handle .write_bulk(self.endpoint, chunk, self.timeout) .map_err(io::Error::other)?; } Ok(()) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } fn find_device( context: &Context, vid: u16, pid: u16, bus: u8, address: u8, ) -> Option> { let devices = context.devices().ok()?; for device in devices.iter() { let Ok(desc) = device.device_descriptor() else { continue; }; if desc.vendor_id() == vid && desc.product_id() == pid && device.bus_number() == bus && device.address() == address { return Some(device); } } None } fn find_printer_out_endpoint(device: &Device) -> Result<(u8, u8), PrintError> { let config = device .active_config_descriptor() .or_else(|_| device.config_descriptor(0)) .map_err(|e| PrintError::Open(e.to_string()))?; for interface in config.interfaces() { for descriptor in interface.descriptors() { if descriptor.class_code() != USB_CLASS_PRINTER { continue; } let iface = descriptor.interface_number(); for endpoint in descriptor.endpoint_descriptors() { if endpoint.direction() == Direction::Out { return Ok((iface, endpoint.address())); } } } } for interface in config.interfaces() { for descriptor in interface.descriptors() { let iface = descriptor.interface_number(); for endpoint in descriptor.endpoint_descriptors() { if endpoint.transfer_type() == TransferType::Bulk && endpoint.direction() == Direction::Out { return Ok((iface, endpoint.address())); } } } } Err(PrintError::Open("no USB OUT endpoint found".into())) } #[cfg(test)] mod tests { use super::*; #[test] fn list_usb_devices_does_not_panic() { let _ = list_usb_printer_devices(); } }