BlueGit

timfa posprint

Files

posprint / src / print / win_spool.rs

win_spool.rs

fixes
timfa Tim Falken · pushed by timfa · 4 months ago
4ab2186f History
win_spool.rs 8.8 KiB Download Raw
1//! Windows print spooler discovery and RAW printing (like Moirai print-bridge).
2
3use std::io;
4use std::process::Command;
5
6#[cfg(windows)]
7use std::os::windows::process::CommandExt;
8
9use serde::Deserialize;
10
11use super::{PrintError, PrinterDevice, PrinterTarget};
12
13#[cfg(windows)]
14const CREATE_NO_WINDOW: u32 = 0x0800_0000;
15
16#[cfg(windows)]
17fn hidden_command(program: &str) -> Command {
18 let mut command = Command::new(program);
19 command.creation_flags(CREATE_NO_WINDOW);
20 command
21}
22
23#[cfg(not(windows))]
24fn hidden_command(program: &str) -> Command {
25 Command::new(program)
26}
27
28const POS_NAME_PATTERNS: &[&str] = &[
29 "gooj", "pt-210", "pt210", "pos-58", "pos58", "thermal", "receipt", "58mm", "pos", "escpos",
30];
31
32#[derive(Debug, Deserialize)]
33struct WinPrinterRow {
34 #[serde(rename = "Name")]
35 name: String,
36 #[serde(rename = "PortName")]
37 port: String,
38 #[serde(rename = "DriverName")]
39 driver: String,
40}
41
42pub fn list_windows_spooler_printers() -> Vec<PrinterDevice> {
43 let Ok(rows) = query_printers() else {
44 return Vec::new();
45 };
46
47 let usable: Vec<_> = rows
48 .into_iter()
49 .filter(|row| !row.name.is_empty() && !is_com_port(&row.port))
50 .collect();
51
52 let mut matched = Vec::new();
53 let mut rest = Vec::new();
54
55 for row in usable {
56 let device = PrinterDevice {
57 id: format!("winspool:{}", row.name),
58 display_name: format!(
59 "{} — Windows printer ({})",
60 row.name,
61 row.port.trim()
62 ),
63 target: PrinterTarget::WinSpooler(row.name.clone()),
64 };
65
66 if is_raw_driver(&row.driver) || matches_pos_name(&row.name) {
67 matched.push(device);
68 } else {
69 rest.push(device);
70 }
71 }
72
73 matched.extend(rest);
74 matched
75}
76
77fn query_printers() -> Result<Vec<WinPrinterRow>, PrintError> {
78 let output = hidden_command("powershell")
79 .args([
80 "-NoProfile",
81 "-ExecutionPolicy",
82 "Bypass",
83 "-Command",
84 "Get-Printer | Select-Object Name, PortName, DriverName | ConvertTo-Json -Compress",
85 ])
86 .output()
87 .map_err(|e| PrintError::Open(e.to_string()))?;
88
89 if !output.status.success() {
90 let stderr = String::from_utf8_lossy(&output.stderr);
91 return Err(PrintError::Open(stderr.trim().to_string()));
92 }
93
94 let text = String::from_utf8_lossy(&output.stdout).trim().to_string();
95 if text.is_empty() {
96 return Ok(Vec::new());
97 }
98
99 if let Ok(rows) = serde_json::from_str::<Vec<WinPrinterRow>>(&text) {
100 return Ok(rows);
101 }
102 if let Ok(row) = serde_json::from_str::<WinPrinterRow>(&text) {
103 return Ok(vec![row]);
104 }
105 Ok(Vec::new())
106}
107
108fn is_com_port(port: &str) -> bool {
109 let port = port.trim();
110 port.len() >= 4
111 && port[..3].eq_ignore_ascii_case("COM")
112 && port[3..].chars().all(|c| c.is_ascii_digit())
113}
114
115fn is_raw_driver(driver: &str) -> bool {
116 let driver = driver.to_ascii_lowercase();
117 driver.contains("generic")
118 || driver.contains("text only")
119 || driver.contains("raw")
120 || driver.contains("escpos")
121}
122
123fn matches_pos_name(name: &str) -> bool {
124 let lower = name.to_ascii_lowercase();
125 POS_NAME_PATTERNS.iter().any(|needle| lower.contains(needle))
126}
127
128pub struct WinSpoolerTransport {
129 printer_name: String,
130}
131
132impl WinSpoolerTransport {
133 pub fn new(printer_name: impl Into<String>) -> Self {
134 Self {
135 printer_name: printer_name.into(),
136 }
137 }
138}
139
140impl super::PrinterTransport for WinSpoolerTransport {
141 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
142 let tmp = tempfile::NamedTempFile::new()?;
143 std::fs::write(tmp.path(), data)?;
144
145 let safe_printer = self.printer_name.replace('\'', "''");
146 let safe_file = tmp
147 .path()
148 .to_string_lossy()
149 .replace('\'', "''");
150
151 let script = format!(
152 r#"
153$ErrorActionPreference = 'Stop'
154Add-Type @"
155using System;
156using System.Runtime.InteropServices;
157public class RawPrinterHelper {{
158 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
159 public class DOCINFOA {{
160 [MarshalAs(UnmanagedType.LPStr)] public string pDocName;
161 [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile;
162 [MarshalAs(UnmanagedType.LPStr)] public string pDataType;
163 }}
164 [DllImport("winspool.drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi)]
165 public static extern bool OpenPrinter(string szPrinter, out IntPtr hPrinter, IntPtr pd);
166 [DllImport("winspool.drv", EntryPoint = "ClosePrinter", SetLastError = true)]
167 public static extern bool ClosePrinter(IntPtr hPrinter);
168 [DllImport("winspool.drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi)]
169 public static extern bool StartDocPrinter(IntPtr hPrinter, int level, [In] DOCINFOA di);
170 [DllImport("winspool.drv", EntryPoint = "EndDocPrinter", SetLastError = true)]
171 public static extern bool EndDocPrinter(IntPtr hPrinter);
172 [DllImport("winspool.drv", EntryPoint = "StartPagePrinter", SetLastError = true)]
173 public static extern bool StartPagePrinter(IntPtr hPrinter);
174 [DllImport("winspool.drv", EntryPoint = "EndPagePrinter", SetLastError = true)]
175 public static extern bool EndPagePrinter(IntPtr hPrinter);
176 [DllImport("winspool.drv", EntryPoint = "WritePrinter", SetLastError = true)]
177 public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, int dwCount, out int dwWritten);
178 public static void SendBytesToPrinter(string printerName, byte[] bytes) {{
179 IntPtr hPrinter;
180 if (!OpenPrinter(printerName, out hPrinter, IntPtr.Zero)) {{
181 throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "OpenPrinter failed");
182 }}
183 try {{
184 DOCINFOA di = new DOCINFOA();
185 di.pDocName = "posprint";
186 di.pDataType = "RAW";
187 if (!StartDocPrinter(hPrinter, 1, di)) {{
188 throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "StartDocPrinter failed");
189 }}
190 try {{
191 if (!StartPagePrinter(hPrinter)) {{
192 throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "StartPagePrinter failed");
193 }}
194 try {{
195 const int chunkSize = 512;
196 for (int offset = 0; offset < bytes.Length; offset += chunkSize) {{
197 int length = Math.Min(chunkSize, bytes.Length - offset);
198 IntPtr unmanagedBytes = Marshal.AllocCoTaskMem(length);
199 try {{
200 Marshal.Copy(bytes, offset, unmanagedBytes, length);
201 int written;
202 if (!WritePrinter(hPrinter, unmanagedBytes, length, out written) || written != length) {{
203 throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "WritePrinter failed");
204 }}
205 }} finally {{
206 Marshal.FreeCoTaskMem(unmanagedBytes);
207 }}
208 }}
209 }} finally {{
210 EndPagePrinter(hPrinter);
211 }}
212 }} finally {{
213 EndDocPrinter(hPrinter);
214 }}
215 }} finally {{
216 ClosePrinter(hPrinter);
217 }}
218 }}
219}}
220"@
221$bytes = [System.IO.File]::ReadAllBytes('{safe_file}')
222[RawPrinterHelper]::SendBytesToPrinter('{safe_printer}', $bytes)
223Write-Output 'OK'
224"#
225 );
226
227 let output = hidden_command("powershell")
228 .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &script])
229 .output()
230 .map_err(io::Error::other)?;
231
232 if !output.status.success() {
233 let stderr = String::from_utf8_lossy(&output.stderr);
234 return Err(io::Error::other(stderr.trim()));
235 }
236
237 let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
238 if stdout != "OK" {
239 return Err(io::Error::other(stdout));
240 }
241 Ok(())
242 }
243
244 fn flush(&mut self) -> io::Result<()> {
245 Ok(())
246 }
247}
248
249#[cfg(test)]
250mod tests {
251 use super::*;
252
253 #[test]
254 fn list_spooler_does_not_panic() {
255 let _ = list_windows_spooler_printers();
256 }
257
258 #[test]
259 fn detects_com_ports() {
260 assert!(is_com_port("COM3"));
261 assert!(!is_com_port("USB001"));
262 }
263}