//! Windows print spooler discovery and RAW printing (like Moirai print-bridge). use std::io; use std::process::Command; #[cfg(windows)] use std::os::windows::process::CommandExt; use serde::Deserialize; use super::{PrintError, PrinterDevice, PrinterTarget}; #[cfg(windows)] const CREATE_NO_WINDOW: u32 = 0x0800_0000; #[cfg(windows)] fn hidden_command(program: &str) -> Command { let mut command = Command::new(program); command.creation_flags(CREATE_NO_WINDOW); command } #[cfg(not(windows))] fn hidden_command(program: &str) -> Command { Command::new(program) } const POS_NAME_PATTERNS: &[&str] = &[ "gooj", "pt-210", "pt210", "pos-58", "pos58", "thermal", "receipt", "58mm", "pos", "escpos", ]; #[derive(Debug, Deserialize)] struct WinPrinterRow { #[serde(rename = "Name")] name: String, #[serde(rename = "PortName")] port: String, #[serde(rename = "DriverName")] driver: String, } pub fn list_windows_spooler_printers() -> Vec { let Ok(rows) = query_printers() else { return Vec::new(); }; let usable: Vec<_> = rows .into_iter() .filter(|row| !row.name.is_empty() && !is_com_port(&row.port)) .collect(); let mut matched = Vec::new(); let mut rest = Vec::new(); for row in usable { let device = PrinterDevice { id: format!("winspool:{}", row.name), display_name: format!( "{} — Windows printer ({})", row.name, row.port.trim() ), target: PrinterTarget::WinSpooler(row.name.clone()), }; if is_raw_driver(&row.driver) || matches_pos_name(&row.name) { matched.push(device); } else { rest.push(device); } } matched.extend(rest); matched } fn query_printers() -> Result, PrintError> { let output = hidden_command("powershell") .args([ "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "Get-Printer | Select-Object Name, PortName, DriverName | ConvertTo-Json -Compress", ]) .output() .map_err(|e| PrintError::Open(e.to_string()))?; if !output.status.success() { let stderr = String::from_utf8_lossy(&output.stderr); return Err(PrintError::Open(stderr.trim().to_string())); } let text = String::from_utf8_lossy(&output.stdout).trim().to_string(); if text.is_empty() { return Ok(Vec::new()); } if let Ok(rows) = serde_json::from_str::>(&text) { return Ok(rows); } if let Ok(row) = serde_json::from_str::(&text) { return Ok(vec![row]); } Ok(Vec::new()) } fn is_com_port(port: &str) -> bool { let port = port.trim(); port.len() >= 4 && port[..3].eq_ignore_ascii_case("COM") && port[3..].chars().all(|c| c.is_ascii_digit()) } fn is_raw_driver(driver: &str) -> bool { let driver = driver.to_ascii_lowercase(); driver.contains("generic") || driver.contains("text only") || driver.contains("raw") || driver.contains("escpos") } fn matches_pos_name(name: &str) -> bool { let lower = name.to_ascii_lowercase(); POS_NAME_PATTERNS.iter().any(|needle| lower.contains(needle)) } pub struct WinSpoolerTransport { printer_name: String, } impl WinSpoolerTransport { pub fn new(printer_name: impl Into) -> Self { Self { printer_name: printer_name.into(), } } } impl super::PrinterTransport for WinSpoolerTransport { fn write_all(&mut self, data: &[u8]) -> io::Result<()> { // Close the handle before PowerShell reads: NamedTempFile keeps the file // open, and on Windows that blocks ReadAllBytes ("used by another process"). let tmp = tempfile::NamedTempFile::new()?; std::fs::write(tmp.path(), data)?; let tmp_path = tmp.into_temp_path(); let safe_printer = self.printer_name.replace('\'', "''"); let safe_file = tmp_path.to_string_lossy().replace('\'', "''"); let script = format!( r#" $ErrorActionPreference = 'Stop' Add-Type @" using System; using System.Runtime.InteropServices; public class RawPrinterHelper {{ [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public class DOCINFOA {{ [MarshalAs(UnmanagedType.LPStr)] public string pDocName; [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile; [MarshalAs(UnmanagedType.LPStr)] public string pDataType; }} [DllImport("winspool.drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi)] public static extern bool OpenPrinter(string szPrinter, out IntPtr hPrinter, IntPtr pd); [DllImport("winspool.drv", EntryPoint = "ClosePrinter", SetLastError = true)] public static extern bool ClosePrinter(IntPtr hPrinter); [DllImport("winspool.drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi)] public static extern bool StartDocPrinter(IntPtr hPrinter, int level, [In] DOCINFOA di); [DllImport("winspool.drv", EntryPoint = "EndDocPrinter", SetLastError = true)] public static extern bool EndDocPrinter(IntPtr hPrinter); [DllImport("winspool.drv", EntryPoint = "StartPagePrinter", SetLastError = true)] public static extern bool StartPagePrinter(IntPtr hPrinter); [DllImport("winspool.drv", EntryPoint = "EndPagePrinter", SetLastError = true)] public static extern bool EndPagePrinter(IntPtr hPrinter); [DllImport("winspool.drv", EntryPoint = "WritePrinter", SetLastError = true)] public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, int dwCount, out int dwWritten); public static void SendBytesToPrinter(string printerName, byte[] bytes) {{ IntPtr hPrinter; if (!OpenPrinter(printerName, out hPrinter, IntPtr.Zero)) {{ throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "OpenPrinter failed"); }} try {{ DOCINFOA di = new DOCINFOA(); di.pDocName = "posprint"; di.pDataType = "RAW"; if (!StartDocPrinter(hPrinter, 1, di)) {{ throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "StartDocPrinter failed"); }} try {{ if (!StartPagePrinter(hPrinter)) {{ throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "StartPagePrinter failed"); }} try {{ const int chunkSize = 512; for (int offset = 0; offset < bytes.Length; offset += chunkSize) {{ int length = Math.Min(chunkSize, bytes.Length - offset); IntPtr unmanagedBytes = Marshal.AllocCoTaskMem(length); try {{ Marshal.Copy(bytes, offset, unmanagedBytes, length); int written; if (!WritePrinter(hPrinter, unmanagedBytes, length, out written) || written != length) {{ throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "WritePrinter failed"); }} }} finally {{ Marshal.FreeCoTaskMem(unmanagedBytes); }} }} }} finally {{ EndPagePrinter(hPrinter); }} }} finally {{ EndDocPrinter(hPrinter); }} }} finally {{ ClosePrinter(hPrinter); }} }} }} "@ $bytes = [System.IO.File]::ReadAllBytes('{safe_file}') [RawPrinterHelper]::SendBytesToPrinter('{safe_printer}', $bytes) Write-Output 'OK' "# ); let output = hidden_command("powershell") .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &script]) .output() .map_err(io::Error::other)?; // Keep tmp_path alive until PowerShell has finished reading it. drop(tmp_path); if !output.status.success() { let stderr = String::from_utf8_lossy(&output.stderr); return Err(io::Error::other(stderr.trim())); } let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string(); if stdout != "OK" { return Err(io::Error::other(stdout)); } Ok(()) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } #[cfg(test)] mod tests { use super::*; #[test] fn list_spooler_does_not_panic() { let _ = list_windows_spooler_printers(); } #[test] fn detects_com_ports() { assert!(is_com_port("COM3")); assert!(!is_com_port("USB001")); } #[test] fn temp_payload_readable_after_handle_closed() { // Mirrors write_all: PowerShell ReadAllBytes needs the file closed on Windows. let tmp = tempfile::NamedTempFile::new().unwrap(); std::fs::write(tmp.path(), b"escpos").unwrap(); let path = tmp.into_temp_path(); let bytes = std::fs::read(&path).unwrap(); assert_eq!(bytes, b"escpos"); } }