Merge remote-tracking branch 'origin/main' into jpeg-notices

This commit is contained in:
FredApps
2026-11-15 15:06:50 +01:00
19 changed files with 2661 additions and 38 deletions
Generated
+18
View File
@@ -1920,6 +1920,7 @@ dependencies = [
"craft-heif",
"craft-jpeg",
"craft-metadata",
"craft-video",
"crc32fast",
"exr",
"flate2",
@@ -1969,6 +1970,13 @@ dependencies = [
"zune-jpeg",
]
[[package]]
name = "craft-jsonrpc"
version = "0.1.0"
dependencies = [
"serde_json",
]
[[package]]
name = "craft-jxl"
version = "0.1.0"
@@ -2057,6 +2065,16 @@ dependencies = [
"serde_json",
]
[[package]]
name = "craft-mcmat"
version = "0.1.0"
dependencies = [
"craft-zip",
"serde",
"serde_json",
"thiserror 2.0.21",
]
[[package]]
name = "craft-media"
version = "0.1.0"
+2
View File
@@ -51,6 +51,7 @@ craft-dialogs = { path = "crates/dialogs" }
craft-doc-binary = { path = "crates/doc-binary" }
craft-docx = { path = "crates/docx" }
craft-document-bundle = { path = "crates/document-bundle" }
craft-mcmat = { path = "crates/mcmat" }
craft-designcraft-format = { path = "crates/designcraft-format" }
craft-dxf = { path = "crates/dxf" }
craft-drawingml = { path = "crates/drawingml" }
@@ -88,6 +89,7 @@ craft-indd = { path = "crates/indd" }
craft-jmap = { path = "crates/jmap" }
craft-ical = { path = "crates/ical" }
craft-jpeg = { path = "crates/jpeg" }
craft-jsonrpc = { path = "crates/jsonrpc" }
craft-jxl = { path = "crates/jxl" }
craft-kiwi = { path = "crates/kiwi" }
craft-keymap = { path = "crates/keymap" }
+47 -1
View File
@@ -531,10 +531,32 @@ pub fn write_cube(l: &LutFile) -> String {
s.push_str(&format!("DOMAIN_MAX {} {} {}\n", l.domain_max[0], l.domain_max[1], l.domain_max[2]));
}
s.push_str(&format!("LUT_3D_SIZE {}\n", l.size));
write_cube_rows(&mut s, l);
s
}
/// Writes a `.cube` file with a creator comment, section comments and an explicit input domain.
///
/// This layout is useful for exported LUTs; [`write_cube`] keeps its compact layout for embedded
/// tables. Values retain six decimal places, and their order and quantisation belong to the
/// caller. A default domain is written as `0.0` and `1.0` for compatibility with export consumers.
pub fn write_cube_commented(l: &LutFile, creator: &str) -> String {
let mut s = format!("#Created by: {creator}\nTITLE \"{}\"\n\n#LUT size\nLUT_3D_SIZE {}\n\n#data domain\n", l.title.replace('"', "'"), l.size);
if l.domain_is_default() {
s.push_str("DOMAIN_MIN 0.0 0.0 0.0\nDOMAIN_MAX 1.0 1.0 1.0\n");
} else {
s.push_str(&format!("DOMAIN_MIN {} {} {}\n", l.domain_min[0], l.domain_min[1], l.domain_min[2]));
s.push_str(&format!("DOMAIN_MAX {} {} {}\n", l.domain_max[0], l.domain_max[1], l.domain_max[2]));
}
s.push_str("\n#LUT data points\n");
write_cube_rows(&mut s, l);
s
}
fn write_cube_rows(s: &mut String, l: &LutFile) {
for c in l.data.as_chunks::<3>().0 {
s.push_str(&format!("{:.6} {:.6} {:.6}\n", c[0], c[1], c[2]));
}
s
}
fn luma(c: [f32; 3]) -> f32 {
@@ -602,6 +624,30 @@ pub fn builtin(id: &str) -> Option<LutFile> {
mod tests {
use super::*;
#[test]
fn commented_cube_preserves_export_header_and_rows() {
let mut lut = super::LutFile::identity(2).unwrap();
lut.title = "A \"look\"".into();
let text = super::write_cube_commented(&lut, "ExampleCraft");
assert!(text.starts_with("#Created by: ExampleCraft\nTITLE \"A 'look'\"\n\n#LUT size\nLUT_3D_SIZE 2\n\n#data domain\nDOMAIN_MIN 0.0 0.0 0.0\nDOMAIN_MAX 1.0 1.0 1.0\n\n#LUT data points\n"));
let parsed = super::parse_cube(&text).unwrap();
assert_eq!(parsed.data, lut.data);
assert_eq!(parsed.title, "A 'look'");
assert_eq!(text.lines().count(), 11 + 8);
let rows = |s: &str| s.lines().filter(|line| line.starts_with(|c: char| c.is_ascii_digit())).map(str::to_owned).collect::<Vec<_>>();
assert_eq!(rows(&text), rows(&super::write_cube(&lut)));
}
#[test]
fn commented_cube_keeps_nondefault_domain_and_sample_precision() {
let mut lut = super::LutFile::identity(2).unwrap();
lut.domain_min = [0.125, 0.25, 0.375];
lut.domain_max = [0.625, 0.75, 0.875];
lut.data[0] = 0.833344;
let parsed = super::parse_cube(&super::write_cube_commented(&lut, "ExampleCraft")).unwrap();
assert_eq!(parsed, lut);
}
#[test]
fn cube_title_hashes_and_comment_quotes_are_distinct() {
let rows = "LUT_1D_SIZE 2\n0 0 0 # low\n1 1 1 # high\n";
+1
View File
@@ -49,4 +49,5 @@ image = { version = "0.25", default-features = false, features = ["png", "jpeg",
sha2 = { version = "0.10", default-features = false, features = ["std"] }
[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
craft-video = { workspace = true, features = ["av1-decode"] }
jxl-oxide = { version = "=0.12.6", default-features = false, features = ["rayon"] }
+107 -5
View File
@@ -25,12 +25,17 @@ fn pq_encode(nits: f32) -> f32 {
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
fn hlg_signal(rgb: [f32; 3]) -> [f32; 3] {
const K: [f32; 3] = [0.2627, 0.6780, 0.0593];
const GAMMA: f32 = 1.2;
const A: f32 = 0.17883277;
const B: f32 = 0.28466892;
const C: f32 = 0.559_910_7;
rgb.map(|v| {
let s = if v.is_finite() { v.clamp(0.0, 12.0) / 12.0 } else { 0.0 };
if s <= 1.0 / 12.0 { (3.0 * s).sqrt() } else { A * (12.0 * s - B).ln() + C }
let display = rgb.map(|v| (if v.is_finite() { v.max(0.0) } else { 0.0 }) * (HDR_REFERENCE_WHITE_NITS / crate::cicp::HLG_PEAK_NITS));
let y = K[0] * display[0] + K[1] * display[1] + K[2] * display[2];
let inverse_ootf = if y > 0.0 { y.powf((1.0 - GAMMA) / GAMMA) } else { 0.0 };
display.map(|v| {
let scene = (v * inverse_ootf).clamp(0.0, 1.0);
if scene <= 1.0 / 12.0 { (3.0 * scene).sqrt() } else { A * (12.0 * scene - B).ln() + C }
})
}
@@ -39,8 +44,14 @@ fn hlg_signal(rgb: [f32; 3]) -> [f32; 3] {
pub fn encode_avif_with_speed(img: &Image, quality: u8, speed: u8) -> Result<Vec<u8>, CodecError> {
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
{
let mut enc =
ravif::Encoder::new().with_quality(f32::from(quality.clamp(1, 100))).with_speed(speed.clamp(1, 10)).with_bit_depth(ravif::BitDepth::Ten);
let mut enc = ravif::Encoder::new()
.with_quality(f32::from(quality.clamp(1, 100)))
.with_alpha_quality(f32::from(quality.clamp(1, 100)))
.with_speed(speed.clamp(1, 10))
.with_bit_depth(ravif::BitDepth::Ten);
if let Some(exif) = img.meta.exif.as_deref() {
enc = enc.with_exif(exif);
}
let alpha_mode = if img.layout().has_alpha() { ravif::AlphaColorMode::UnassociatedClean } else { ravif::AlphaColorMode::UnassociatedDirty };
enc = enc.with_alpha_color_mode(alpha_mode);
let w = img.width() as usize;
@@ -209,3 +220,94 @@ pub fn encode_avif_hdr(
Err(CodecError::unsupported(Format::Avif, "AVIF encoding is not available in this build"))
}
}
#[cfg(test)]
mod tests {
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
#[test]
fn sdr_avif_uses_requested_alpha_quality() {
use crate::{ChannelLayout, Image};
let pixels: Vec<ravif::RGBA8> = (0..1024).map(|i| ravif::RGBA8::new(100, 120, 140, ((i * 37) % 256) as u8)).collect();
let samples: Vec<u8> = pixels.iter().flat_map(|p| [p.r, p.g, p.b, p.a]).collect();
let image = Image::from_u8(32, 32, ChannelLayout::Rgba, samples).unwrap();
let actual = super::encode_avif_with_speed(&image, 20, 10).unwrap();
let expected = ravif::Encoder::new()
.with_quality(20.0)
.with_alpha_quality(20.0)
.with_speed(10)
.with_bit_depth(ravif::BitDepth::Ten)
.with_alpha_color_mode(ravif::AlphaColorMode::UnassociatedClean)
.encode_rgba(ravif::Img::new(&pixels, 32, 32))
.unwrap()
.avif_file;
assert!(actual == expected, "encoded alpha must use the requested quality");
}
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
#[test]
fn sdr_avif_keeps_exif_metadata() {
use crate::{ChannelLayout, Image};
let exif = b"II*\0shared-avif-exif".to_vec();
let mut image = Image::from_u8(2, 1, ChannelLayout::Rgb, vec![20, 40, 60, 80, 100, 120]).unwrap();
image.meta.exif = Some(exif.clone());
let avif = super::encode_avif_with_speed(&image, 80, 8).unwrap();
assert!(avif.windows(exif.len()).any(|window| window == exif.as_slice()));
}
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
#[test]
fn hlg_mapping_matches_reference_white_and_peak() {
let white = super::hlg_signal([1.0; 3]);
assert!(white.iter().all(|&value| (value - 0.75).abs() < 0.005), "{white:?}");
let peak = super::hlg_signal([crate::cicp::HLG_PEAK_NITS / super::HDR_REFERENCE_WHITE_NITS; 3]);
assert!(peak.iter().all(|&value| (value - 1.0).abs() < 0.005), "{peak:?}");
let invalid = super::hlg_signal([f32::NAN, -1.0, f32::INFINITY]);
assert_eq!(invalid, [0.0; 3]);
}
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
#[test]
fn hlg_encoded_output_signals_bt2020_hlg() {
let avif = super::encode_avif_hdr(1, 1, &[1.0; 3], 100, 10, None, super::HdrTransfer::Hlg).unwrap();
let nclx = avif.windows(4).position(|window| window == b"nclx").expect("the AVIF has nclx color metadata");
let color = avif.get(nclx + 4..nclx + 11).expect("complete nclx color metadata");
assert_eq!(&color[..2], &[0, 9], "BT.2020 primaries");
assert_eq!(&color[2..4], &[0, 18], "BT.2100 HLG transfer");
assert_eq!(&color[4..6], &[0, 9], "BT.2020 non-constant luminance matrix");
assert!(!avif.windows(4).any(|window| window == b"clli"), "HLG does not signal PQ content-light metadata");
}
#[cfg(all(feature = "avif", not(target_arch = "wasm32")))]
#[test]
fn hlg_encoded_pixels_preserve_reference_white_and_peak() {
let mut rgb = Vec::new();
for _ in 0..32 {
for x in 0..64 {
let level = if x < 32 { 1.0 } else { crate::cicp::HLG_PEAK_NITS / super::HDR_REFERENCE_WHITE_NITS };
rgb.extend_from_slice(&[level; 3]);
}
}
let avif = super::encode_avif_hdr(64, 32, &rgb, 100, 10, None, super::HdrTransfer::Hlg).unwrap();
let mut offset = 0;
let payload = loop {
let header = avif.get(offset..offset + 8).expect("complete AVIF box header");
let size = u32::from_be_bytes(header[..4].try_into().unwrap()) as usize;
assert!(size >= 8 && offset + size <= avif.len(), "valid AVIF box size");
if &header[4..] == b"mdat" {
break &avif[offset + 8..offset + size];
}
offset += size;
};
let mut decoder = craft_video::av1::decode::Decoder::new();
let mut frames = decoder.decode(payload).unwrap();
frames.extend(decoder.flush_result().unwrap());
let luma = &frames.first().expect("encoded AV1 frame").planes[0];
assert!((i32::from(luma[16 * 64 + 16]) - 767).abs() <= 5, "diffuse white");
assert!((i32::from(luma[16 * 64 + 48]) - 1023).abs() <= 5, "peak white");
}
}
+14
View File
@@ -0,0 +1,14 @@
[package]
name = "craft-jsonrpc"
description = "Bounded JSON-RPC 2.0 server envelopes without transport or application routing"
version.workspace = true
edition.workspace = true
license.workspace = true
rust-version.workspace = true
repository.workspace = true
[lints]
workspace = true
[dependencies]
serde_json = { workspace = true }
+31
View File
@@ -0,0 +1,31 @@
# craft-jsonrpc
`craft-jsonrpc` provides bounded JSON-RPC 2.0 server envelopes independently of a transport or an
application's method router. It can read a bounded newline-delimited message, parse it from bytes,
check request IDs and batch sizes, dispatch requests and notifications separately, and build
response envelopes. It does not start a server, choose an MCP protocol version, or interpret tool
names and arguments.
`Limits` defaults to 64 MiB per message and 4096 batch entries. `parse_json` checks the byte limit
before deserialization, and `process` rejects an oversized batch before calling any handler.
For newline-delimited transports, `read_line` bounds memory while reading; after an over-limit
line, the caller must close the stream or discard the rest of that line.
`serde_json`'s nesting limit remains in effect. Response sizes are the caller's responsibility.
A valid request receives the handler's result or error with its original string, numeric, or null
ID. The default accepts numeric IDs as required by [JSON-RPC 2.0](https://www.jsonrpc.org/specification#request_object),
which discourages fractional values. Set `integer_ids_only` and clear `allow_null_ids` for
protocols such as MCP that require integer or string IDs. A legacy server can retain its previous
null-ID behavior independently. An omitted ID is a notification: it calls the separate notification
handler and gets no reply.
Malformed batch entries receive an invalid-request error; an empty batch gets one error response;
a batch containing only notifications has no response. Invalid parameter shapes receive an
invalid-params error for requests and no reply for notifications. The handler decides whether
object or array parameters are valid for each method.
The caller may inspect the bounded parsed value before `process` to support an existing legacy
protocol. Parse failures and limit failures are returned explicitly so each transport can choose
its error and connection policy; `parse_error_response` builds the JSON-RPC parse error.
The envelope behavior is extracted from StencilCraft's JSON-lines MCP/control server. App-specific
method routing, legacy control requests, and MCP lifecycle policy stay with the app.
+197
View File
@@ -0,0 +1,197 @@
//! Bounded JSON-RPC 2.0 server envelopes without a transport or application router.
//!
//! Parse a bounded line with [`parse_json`], then pass the value to [`process`]. A host may
//! inspect the parsed value first for a legacy protocol. `process` validates envelopes, dispatches
//! requests and notifications separately, and constructs single or batch replies. The host owns
//! the transport, method semantics and response-size policy.
#![forbid(unsafe_code)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
use serde_json::{Value, json};
use std::io::BufRead;
/// Bounds on a single JSON document and on the number of requests in a batch.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Limits {
pub max_message_bytes: usize,
pub max_batch_items: usize,
/// Reject fractional JSON numbers as IDs for protocols that require integer IDs.
pub integer_ids_only: bool,
/// Permit an explicit null request ID, as JSON-RPC does; some protocols prohibit it.
pub allow_null_ids: bool,
}
impl Default for Limits {
fn default() -> Self {
Self { max_message_bytes: 64 * 1024 * 1024, max_batch_items: 4096, integer_ids_only: false, allow_null_ids: true }
}
}
/// Failure before dispatch. An over-limit batch is rejected before any callback is invoked.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ParseError {
MessageTooLarge,
InvalidJson,
BatchTooLarge,
}
impl std::fmt::Display for ParseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::MessageTooLarge => "JSON-RPC message exceeds the byte limit",
Self::InvalidJson => "invalid JSON",
Self::BatchTooLarge => "JSON-RPC batch exceeds the item limit",
})
}
}
impl std::error::Error for ParseError {}
/// Error reading a newline-delimited message. After `TooLong`, close or otherwise discard the
/// remaining input line before reading another message.
#[derive(Debug)]
pub enum LineError {
Io(std::io::Error),
TooLong,
}
impl std::fmt::Display for LineError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Io(error) => write!(f, "message read failed: {error}"),
Self::TooLong => f.write_str("message exceeds the byte limit"),
}
}
}
impl std::error::Error for LineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(error) => Some(error),
Self::TooLong => None,
}
}
}
/// Read at most `max_bytes` before a newline, without allocating for an oversized line. The
/// newline is consumed but omitted from the returned bytes. EOF with no bytes returns `None`;
/// an empty line returns `Some(Vec::new())`.
pub fn read_line<R: BufRead>(reader: &mut R, max_bytes: usize) -> Result<Option<Vec<u8>>, LineError> {
let mut line = Vec::new();
loop {
let bytes = reader.fill_buf().map_err(LineError::Io)?;
if bytes.is_empty() {
return Ok((!line.is_empty()).then_some(line));
}
let newline = bytes.iter().position(|&byte| byte == b'\n');
let len = newline.unwrap_or(bytes.len());
if line.len().saturating_add(len) > max_bytes {
return Err(LineError::TooLong);
}
line.extend_from_slice(&bytes[..len]);
reader.consume(len + usize::from(newline.is_some()));
if newline.is_some() {
return Ok(Some(line));
}
}
}
/// Parse JSON after checking its byte length. `serde_json` also bounds nesting depth.
pub fn parse_json(bytes: &[u8], limits: Limits) -> Result<Value, ParseError> {
if bytes.len() > limits.max_message_bytes {
return Err(ParseError::MessageTooLarge);
}
serde_json::from_slice(bytes).map_err(|_| ParseError::InvalidJson)
}
/// A validated request or notification. A present null `id` is distinct from an omitted `id`.
#[derive(Clone, Copy, Debug)]
pub struct Request<'a> {
pub id: Option<&'a Value>,
pub method: &'a str,
pub params: Option<&'a Value>,
}
/// Inspect a single request envelope. This validates its JSON-RPC version, method and ID;
/// [`process`] additionally validates parameter shape before dispatching it.
pub fn request(value: &Value, limits: Limits) -> Option<Request<'_>> {
let object = value.as_object()?;
let id = object.get("id");
let valid_id = id.is_none_or(|v| {
(v.is_null() && limits.allow_null_ids) || v.is_string() || if limits.integer_ids_only { v.is_i64() || v.is_u64() } else { v.is_number() }
});
if object.get("jsonrpc").and_then(Value::as_str) != Some("2.0") || !valid_id {
return None;
}
Some(Request { id, method: object.get("method")?.as_str()?, params: object.get("params") })
}
/// A JSON-RPC error returned by a method handler.
#[derive(Clone, Debug, PartialEq)]
pub struct RpcError {
pub code: i64,
pub message: String,
pub data: Option<Value>,
}
impl RpcError {
pub fn new(code: i64, message: impl Into<String>) -> Self {
Self { code, message: message.into(), data: None }
}
}
/// Build an error response, including optional error data.
pub fn error_response(id: Value, error: RpcError) -> Value {
let mut detail = json!({"code": error.code, "message": error.message});
if let (Some(data), Some(object)) = (error.data, detail.as_object_mut()) {
object.insert("data".into(), data);
}
json!({"jsonrpc": "2.0", "id": id, "error": detail})
}
/// Build the standard parse-error response for input that is not JSON.
pub fn parse_error_response() -> Value {
error_response(Value::Null, RpcError::new(-32700, "Parse error"))
}
fn invalid_request() -> Value {
error_response(Value::Null, RpcError::new(-32600, "Invalid Request"))
}
fn one<F, N>(value: &Value, limits: Limits, on_request: &mut F, on_notification: &mut N) -> Option<Value>
where
F: FnMut(Request<'_>) -> Result<Value, RpcError>,
N: FnMut(Request<'_>),
{
let Some(request) = request(value, limits) else { return Some(invalid_request()) };
let id = request.id;
if request.params.is_some_and(|v| !v.is_object() && !v.is_array()) {
return id.map(|id| error_response(id.clone(), RpcError::new(-32602, "Invalid params")));
}
let Some(id) = id else {
on_notification(request);
return None;
};
Some(match on_request(request) {
Ok(result) => json!({"jsonrpc": "2.0", "id": id, "result": result}),
Err(error) => error_response(id.clone(), error),
})
}
/// Process a parsed JSON-RPC message. Notifications never receive a response. Invalid batch
/// entries produce individual errors; an empty batch produces one invalid-request response.
/// A batch over the limit returns [`ParseError::BatchTooLarge`] without invoking either callback.
pub fn process<F, N>(value: &Value, limits: Limits, mut on_request: F, mut on_notification: N) -> Result<Option<Value>, ParseError>
where
F: FnMut(Request<'_>) -> Result<Value, RpcError>,
N: FnMut(Request<'_>),
{
let Some(batch) = value.as_array() else { return Ok(one(value, limits, &mut on_request, &mut on_notification)) };
if batch.len() > limits.max_batch_items {
return Err(ParseError::BatchTooLarge);
}
if batch.is_empty() {
return Ok(Some(invalid_request()));
}
let responses: Vec<_> = batch.iter().filter_map(|v| one(v, limits, &mut on_request, &mut on_notification)).collect();
Ok((!responses.is_empty()).then_some(Value::Array(responses)))
}
+172
View File
@@ -0,0 +1,172 @@
use craft_jsonrpc::{Limits, ParseError, RpcError, parse_error_response, parse_json, process};
use serde_json::{Value, json};
#[test]
fn batches_preserve_ids_order_and_suppress_notification_replies() {
let input = json!([
{"jsonrpc": "2.0", "method": "notifications/initialized"},
{"jsonrpc": "2.0", "id": "a", "method": "ping"},
{"jsonrpc": "2.0", "id": 2, "method": "unknown"},
17,
{"jsonrpc": "2.0", "id": null, "method": "ping"}
]);
let mut notifications = Vec::new();
let result = process(
&input,
Limits::default(),
|request| match request.method {
"ping" => Ok(json!({})),
_ => Err(RpcError::new(-32601, "Method not found")),
},
|request| notifications.push(request.method.to_owned()),
)
.unwrap()
.unwrap();
assert_eq!(notifications, ["notifications/initialized"]);
assert_eq!(
result,
json!([
{"jsonrpc":"2.0", "id":"a", "result":{}},
{"jsonrpc":"2.0", "id":2, "error":{"code":-32601,"message":"Method not found"}},
{"jsonrpc":"2.0", "id":null, "error":{"code":-32600,"message":"Invalid Request"}},
{"jsonrpc":"2.0", "id":null, "result":{}}
])
);
}
#[test]
fn notifications_never_receive_responses_including_all_notification_batches() {
let input = json!([
{"jsonrpc":"2.0", "method":"tools/call", "params":{"name":"mutating"}},
{"jsonrpc":"2.0", "method":"notifications/initialized"}
]);
let mut requests = 0;
let mut notices = 0;
let result = process(
&input,
Limits::default(),
|_| {
requests += 1;
Ok(Value::Null)
},
|_| notices += 1,
)
.unwrap();
assert!(result.is_none());
assert_eq!(requests, 0);
assert_eq!(notices, 2);
}
#[test]
fn invalid_envelopes_and_params_return_standard_errors() {
for id in [json!(true), json!([]), json!({})] {
let input = json!({"jsonrpc":"2.0", "id":id, "method":"ping"});
let reply = process(&input, Limits::default(), |_| panic!("invalid id dispatched"), |_| panic!("invalid id notified")).unwrap().unwrap();
assert_eq!(reply["id"], Value::Null);
assert_eq!(reply["error"]["code"], -32600);
}
for input in [json!({}), json!({"jsonrpc":"1.0", "id":1, "method":"ping"}), json!({"jsonrpc":"2.0", "id":1}), json!([])] {
let reply =
process(&input, Limits::default(), |_| panic!("invalid request dispatched"), |_| panic!("invalid notification")).unwrap().unwrap();
assert_eq!(reply["error"]["code"], -32600);
}
let input = json!({"jsonrpc":"2.0", "id":4, "method":"ping", "params":17});
let reply = process(&input, Limits::default(), |_| panic!("invalid params dispatched"), |_| {}).unwrap().unwrap();
assert_eq!(reply["id"], 4);
assert_eq!(reply["error"]["code"], -32602);
let notification = json!({"jsonrpc":"2.0", "method":"notice", "params":17});
assert!(process(&notification, Limits::default(), |_| panic!("invalid request"), |_| panic!("invalid notification")).unwrap().is_none());
}
#[test]
fn arrays_are_valid_params_and_errors_can_include_data() {
let input = json!({"jsonrpc":"2.0", "id":-7, "method":"test", "params":[1, 2]});
let reply = process(
&input,
Limits::default(),
|request| {
assert_eq!(request.params, Some(&json!([1, 2])));
let mut error = RpcError::new(-32000, "failure");
error.data = Some(json!({"why":"example"}));
Err(error)
},
|_| {},
)
.unwrap()
.unwrap();
assert_eq!(reply, json!({"jsonrpc":"2.0", "id":-7, "error":{"code":-32000,"message":"failure","data":{"why":"example"}}}));
}
#[test]
fn parse_and_batch_limits_apply_before_dispatch() {
let limits = Limits { max_message_bytes: 3, max_batch_items: 1, ..Limits::default() };
assert_eq!(parse_json(b"null", limits), Err(ParseError::MessageTooLarge));
assert_eq!(parse_json(b"123", limits).unwrap(), json!(123));
assert_eq!(parse_json(b"{", limits), Err(ParseError::InvalidJson));
assert_eq!(parse_error_response()["error"]["code"], -32700);
let input = json!([{"jsonrpc":"2.0", "id":1, "method":"ping"}, {"jsonrpc":"2.0", "method":"notice"}]);
assert_eq!(
process(&input, limits, |_| panic!("over-limit batch dispatched"), |_| panic!("over-limit batch notified")),
Err(ParseError::BatchTooLarge)
);
let one = json!([{"jsonrpc":"2.0", "id":1, "method":"ping"}]);
assert_eq!(process(&one, limits, |_| Ok(json!({})), |_| {}).unwrap().unwrap().as_array().unwrap().len(), 1);
}
#[test]
fn invalid_utf8_and_excessive_nesting_are_rejected() {
assert_eq!(parse_json(&[0xff], Limits::default()), Err(ParseError::InvalidJson));
let nested = format!("{}0{}", "[".repeat(200), "]".repeat(200));
assert_eq!(parse_json(nested.as_bytes(), Limits::default()), Err(ParseError::InvalidJson));
}
#[test]
fn bounded_line_read_handles_chunks_empty_lines_and_eof() {
use std::io::{BufReader, Cursor};
let mut reader = BufReader::with_capacity(2, Cursor::new(b"abc\n\nxy"));
assert_eq!(craft_jsonrpc::read_line(&mut reader, 3).unwrap(), Some(b"abc".to_vec()));
assert_eq!(craft_jsonrpc::read_line(&mut reader, 3).unwrap(), Some(Vec::new()));
assert_eq!(craft_jsonrpc::read_line(&mut reader, 3).unwrap(), Some(b"xy".to_vec()));
assert_eq!(craft_jsonrpc::read_line(&mut reader, 3).unwrap(), None);
let mut too_long = BufReader::with_capacity(2, Cursor::new(b"abcd\n"));
assert!(matches!(craft_jsonrpc::read_line(&mut too_long, 3), Err(craft_jsonrpc::LineError::TooLong)));
}
#[test]
fn bounded_line_read_propagates_io_errors() {
struct Broken;
impl std::io::Read for Broken {
fn read(&mut self, _: &mut [u8]) -> std::io::Result<usize> {
Err(std::io::Error::other("broken"))
}
}
let mut reader = std::io::BufReader::new(Broken);
assert!(matches!(craft_jsonrpc::read_line(&mut reader, 1), Err(craft_jsonrpc::LineError::Io(_))));
}
#[test]
fn inspect_single_request_distinguishes_null_ids_and_invalid_envelopes() {
let request = json!({"jsonrpc":"2.0", "id":null, "method":"ping"});
let parsed = craft_jsonrpc::request(&request, Limits::default()).unwrap();
assert_eq!(parsed.id, Some(&Value::Null));
assert_eq!(parsed.method, "ping");
let notification = json!({"jsonrpc":"2.0", "method":"ping"});
assert!(craft_jsonrpc::request(&notification, Limits::default()).unwrap().id.is_none());
assert!(craft_jsonrpc::request(&json!({"jsonrpc":"2.0", "id":false, "method":"ping"}), Limits::default()).is_none());
assert!(craft_jsonrpc::request(&json!({"method":"ping"}), Limits::default()).is_none());
}
#[test]
fn numeric_ids_follow_the_selected_protocol_policy() {
let input = json!({"jsonrpc":"2.0", "id":1.5, "method":"ping"});
let reply = process(&input, Limits::default(), |_| Ok(json!({})), |_| {}).unwrap().unwrap();
assert_eq!(reply["id"], json!(1.5));
let strict = Limits { integer_ids_only: true, ..Limits::default() };
let reply = process(&input, strict, |_| panic!("fractional ID dispatched"), |_| {}).unwrap().unwrap();
assert_eq!(reply["id"], Value::Null);
assert_eq!(reply["error"]["code"], -32600);
let no_null = Limits { allow_null_ids: false, ..strict };
let null_id = json!({"jsonrpc":"2.0", "id":null, "method":"ping"});
let reply = process(&null_id, no_null, |_| panic!("null ID dispatched"), |_| {}).unwrap().unwrap();
assert_eq!(reply["error"]["code"], -32600);
}
+17
View File
@@ -0,0 +1,17 @@
[package]
name = "craft-mcmat"
description = "Bounded portable material archive interchange for Craft applications"
version.workspace = true
edition.workspace = true
license.workspace = true
rust-version.workspace = true
repository.workspace = true
[lints]
workspace = true
[dependencies]
craft-zip = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
+17
View File
@@ -0,0 +1,17 @@
# craft-mcmat
A bounded reader and writer for portable MaterialCraft `.mcmat` ZIP packages. A package
contains `material.json`, named texture maps and a source package. Applications interpret
parameter values and cook or render maps themselves; this crate does not depend on an app's
model. It supports callers that read either version 1 or version 2 of the manifest, or both.
`is_material` checks for a manifest with a bounded ZIP index; `Material::open` takes caller-provided version, entry-count, map-count, per-entry and total
expanded-byte limits. Each subsequent `read` and `read_source` shares that budget, including
repeated references to the same ZIP member. Duplicate member names are refused. The manifest
preserves unknown fields at the top level and on maps; parameter, input and preset objects are
kept as JSON values so their unknown fields survive too. `write` preserves the caller's source
entry name and map names, and rejects duplicate archive member names through `craft-zip`.
The source package is opaque. Version 1 commonly names `source.mcraft`; MaterialCraft's version 2
writer names `source.sbs`. Callers that invoke another application must preserve the source's
format and extension rather than infer it from `.mcmat` alone.
+216
View File
@@ -0,0 +1,216 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
//! Bounded interchange for MaterialCraft portable materials (`.mcmat`).
//!
//! The manifest and its version belong to the format, while interpreting parameter values,
//! cooking maps and opening the source package belong to the caller. Unknown fields survive
//! deserialization and serialization, including fields added by later versions.
use std::collections::BTreeMap;
use craft_zip::{Archive, Compression, Writer};
use serde::{Deserialize, Serialize};
use serde_json::Value;
pub const FORMAT: &str = "craft-material";
pub const MANIFEST_ENTRY: &str = "material.json";
/// A portable manifest; typed parameter values remain JSON so applications can adapt their own model.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Manifest {
pub format: String,
pub version: u32,
pub name: String,
pub graph: String,
pub size: [u32; 2],
pub maps: Vec<MapEntry>,
#[serde(default)]
pub parameters: Vec<Value>,
#[serde(default)]
pub inputs: Vec<Value>,
#[serde(default)]
pub presets: Vec<Value>,
pub source: String,
#[serde(flatten)]
pub extra: BTreeMap<String, Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MapEntry {
pub usage: String,
pub file: String,
#[serde(flatten)]
pub extra: BTreeMap<String, Value>,
}
/// All limits are supplied by the consumer, including the versions it understands.
#[derive(Clone, Copy, Debug)]
pub struct Limits {
pub min_version: u32,
pub max_version: u32,
pub max_entries: u64,
pub max_maps: usize,
pub max_manifest_bytes: u64,
pub max_entry_bytes: u64,
pub max_total_bytes: u64,
}
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("invalid portable material: {0}")]
Invalid(String),
#[error("unsupported portable material version {0}")]
Version(u32),
#[error("portable material limit: {0}")]
Limit(String),
#[error("portable material archive: {0}")]
Archive(#[from] craft_zip::Error),
}
/// Whether a bounded ZIP index contains a material manifest. This does not validate the manifest.
pub fn is_material(bytes: &[u8], max_entries: u64) -> bool {
Archive::open(bytes, craft_zip::Limits { max_entries, max_total_bytes: 0 })
.is_ok_and(|archive| !archive.has_duplicate_names() && archive.contains(MANIFEST_ENTRY))
}
/// Manifest and original archive, retaining one shared expanded-byte budget across reads.
pub struct Material<'a> {
pub manifest: Manifest,
archive: Archive<'a>,
max_entry_bytes: u64,
}
impl<'a> Material<'a> {
pub fn open(bytes: &'a [u8], limits: Limits) -> Result<Self, Error> {
let mut archive = Archive::open(bytes, craft_zip::Limits { max_entries: limits.max_entries, max_total_bytes: limits.max_total_bytes })?;
if archive.has_duplicate_names() {
return Err(Error::Invalid("duplicate archive entries".into()));
}
let json = archive.read(MANIFEST_ENTRY, limits.max_manifest_bytes)?.ok_or_else(|| Error::Invalid("material.json is missing".into()))?;
let manifest: Manifest = serde_json::from_slice(&json).map_err(|e| Error::Invalid(format!("material.json: {e}")))?;
if manifest.format != FORMAT {
return Err(Error::Invalid(format!("format `{}`", manifest.format)));
}
if !(limits.min_version..=limits.max_version).contains(&manifest.version) {
return Err(Error::Version(manifest.version));
}
if manifest.maps.len() > limits.max_maps {
return Err(Error::Limit(format!("{} maps exceeds {}", manifest.maps.len(), limits.max_maps)));
}
Ok(Self { manifest, archive, max_entry_bytes: limits.max_entry_bytes })
}
/// Read one named member, charging it to the same budget as previous reads.
pub fn read(&mut self, name: &str) -> Result<Vec<u8>, Error> {
self.archive.read(name, self.max_entry_bytes)?.ok_or_else(|| Error::Invalid(format!("{name} is missing")))
}
pub fn read_source(&mut self) -> Result<Vec<u8>, Error> {
self.read(&self.manifest.source.clone())
}
}
/// Write a manifest, its named maps, and the source. Duplicate member names are rejected.
pub fn write(manifest: &Manifest, maps: &[(String, Vec<u8>)], source: &[u8]) -> Result<Vec<u8>, Error> {
// Flattened fields must not serialize a second copy of a known key.
const KNOWN: &[&str] = &["format", "version", "name", "graph", "size", "maps", "parameters", "inputs", "presets", "source"];
if manifest.extra.keys().any(|key| KNOWN.contains(&key.as_str()))
|| manifest.maps.iter().any(|map| map.extra.contains_key("usage") || map.extra.contains_key("file"))
{
return Err(Error::Invalid("an extra field duplicates a known field".into()));
}
let json = serde_json::to_vec_pretty(manifest).map_err(|e| Error::Invalid(format!("material.json: {e}")))?;
let mut writer = Writer::new();
writer.add(MANIFEST_ENTRY, &json, Compression::Deflated)?;
for (name, bytes) in maps {
writer.add(name, bytes, Compression::Stored)?;
}
writer.add(&manifest.source, source, Compression::Stored)?;
Ok(writer.finish()?)
}
#[cfg(test)]
mod tests {
use super::*;
fn limits() -> Limits {
Limits {
min_version: 1,
max_version: 2,
max_entries: 100,
max_maps: 4,
max_manifest_bytes: 4096,
max_entry_bytes: 100,
max_total_bytes: 8192,
}
}
fn sample(version: u32) -> Manifest {
serde_json::from_value(serde_json::json!({
"format": "craft-material", "version": version, "name": "Stone", "graph": "Stone", "size": [64, 64],
"maps": [{"usage": "baseColor", "file": "maps/base.png", "colorSpace": "srgb", "futureMap": true}],
"parameters": [{"id": "rough", "value": {"t": "float", "v": 0.25}, "futureParam": 42}],
"inputs": [{"identifier": "curvature", "kind": "gray"}], "presets": [],
"source": if version == 1 { "source.mcraft" } else { "source.sbs" }, "futureField": {"keep": true}
}))
.unwrap()
}
#[test]
fn both_protocol_versions_keep_unknown_fields_and_payloads() {
for version in [1, 2] {
let manifest = sample(version);
let bytes = write(&manifest, &[("maps/base.png".into(), vec![1, 2, 3])], b"source").unwrap();
assert!(is_material(&bytes, 100));
assert!(!is_material(&bytes, 1));
let mut material = Material::open(&bytes, limits()).unwrap();
assert_eq!(material.manifest, manifest);
assert_eq!(material.read("maps/base.png").unwrap(), [1, 2, 3]);
assert_eq!(material.read_source().unwrap(), b"source");
let json = serde_json::to_value(&material.manifest).unwrap();
assert_eq!(json["futureField"]["keep"], true);
assert_eq!(json["maps"][0]["futureMap"], true);
assert_eq!(json["parameters"][0]["futureParam"], 42);
}
}
#[test]
fn limits_apply_to_the_manifest_maps_and_aggregate_reads() {
let manifest = sample(2);
let bytes = write(&manifest, &[("maps/base.png".into(), vec![1; 8])], &[2; 8]).unwrap();
let mut unsupported = limits();
unsupported.max_version = 1;
assert!(matches!(Material::open(&bytes, unsupported), Err(Error::Version(2))));
let mut no_maps = limits();
no_maps.max_maps = 0;
assert!(matches!(Material::open(&bytes, no_maps), Err(Error::Limit(_))));
let mut tiny_entry = limits();
tiny_entry.max_entry_bytes = 7;
assert!(Material::open(&bytes, tiny_entry).unwrap().read("maps/base.png").is_err());
let json_len = serde_json::to_vec_pretty(&manifest).unwrap().len() as u64;
let mut aggregate = limits();
aggregate.max_total_bytes = json_len + 15;
let mut material = Material::open(&bytes, aggregate).unwrap();
assert_eq!(material.read("maps/base.png").unwrap().len(), 8);
assert!(material.read_source().is_err());
}
#[test]
fn refuses_extra_fields_that_duplicate_known_keys() {
let mut manifest = sample(2);
manifest.extra.insert("version".into(), 3.into());
assert!(write(&manifest, &[], b"source").is_err());
manifest.extra.remove("version");
manifest.maps[0].extra.insert("file".into(), "other".into());
assert!(write(&manifest, &[], b"source").is_err());
}
#[test]
fn refuses_duplicate_names_on_write() {
let manifest = sample(2);
let duplicate = [("maps/base.png".to_string(), vec![1]), ("maps/base.png".to_string(), vec![2])];
assert!(write(&manifest, &duplicate, b"source").is_err());
}
}
+955
View File
@@ -0,0 +1,955 @@
//! Based on the direct CUPS transport from contributor PR #156 (ahmedhosnypro),
//! kept separate from the broader network-printing registry in PR #116.
//! IPP/1.1 straight to the local CUPS server: printer discovery (`CUPS-Get-Printers`,
//! `CUPS-Get-Default`) and job submission (`Print-Job`) over HTTP/1.1, for when `lpstat`/`lp`
//! are missing (a sandboxed install, where the print dialog would otherwise have no printers).
//! Implemented from the public IPP encoding (RFC 2910/8010) and semantics (RFC 8011) and
//! CUPS's IPP documentation; the scheduler is reached on its socket or selected TCP endpoint.
//!
//! # Blocking and authorization
//! The caller authorizes endpoint selection. The absolute exchange deadline covers all request
//! writes and reply reads **after connection**. Standard-library DNS resolution and Unix socket
//! connection are blocking OS calls outside that deadline. TCP connection attempts have their
//! own timeout. This is not a whole-operation deadline API: do not call it on a UI thread or
//! promise bounded completion for arbitrary named hosts/Unix listeners. No detached timeout
//! thread is spawned; callers needing cancellation must supply a separately bounded transport.
#[cfg(all(test, unix))]
mod tests;
use super::{Duplex, Error, Job, Printer, Scaling};
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream, ToSocketAddrs};
#[cfg(unix)]
use std::os::unix::net::UnixStream;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU32, Ordering};
use std::time::{Duration, Instant};
/// Where the local scheduler listens: its socket, else its loopback port.
const CUPS_SOCKET: &str = "/run/cups/cups.sock";
/// Caps on what the server may hand back: a reply is read into memory before it is parsed.
const MAX_BODY: usize = 1 << 20;
const MAX_HEADERS: usize = 8 << 10;
const MAX_PRINTERS: usize = 256;
const MAX_NAME: usize = 256;
/// A job's title on the wire; IPP values are u16-length, and no real title is this long.
const MAX_JOB_NAME: usize = 255;
/// A wedged scheduler must not hang the dialog; a job may carry megabytes and is given longer.
const CONNECT_TIMEOUT: Duration = Duration::from_secs(1);
const DISCOVERY_TIMEOUT: Duration = Duration::from_secs(2);
const JOB_TIMEOUT: Duration = Duration::from_secs(30);
/// IPP operation codes: the standard Print-Job, and CUPS's discovery extensions.
const OPERATION_PRINT_JOB: u16 = 0x0002;
const OPERATION_CUPS_GET_DEFAULT: u16 = 0x4001;
const OPERATION_CUPS_GET_PRINTERS: u16 = 0x4002;
/// IPP value tags and group delimiters (RFC 8010 §5.1); the ones this client sends or reads.
const GROUP_OPERATION: u8 = 0x01;
const GROUP_JOB: u8 = 0x02;
const GROUP_END: u8 = 0x03;
const GROUP_PRINTER: u8 = 0x04;
const TAG_INTEGER: u8 = 0x21;
const TAG_BOOLEAN: u8 = 0x22;
const TAG_NAME: u8 = 0x42;
const TAG_KEYWORD: u8 = 0x44;
const TAG_URI: u8 = 0x45;
const TAG_CHARSET: u8 = 0x47;
const TAG_LANGUAGE: u8 = 0x48;
const TAG_MIME: u8 = 0x49;
static REQUEST_ID: AtomicU32 = AtomicU32::new(1);
/// How the scheduler is reached: its unix socket, else its loopback port.
#[derive(Clone, Debug)]
pub enum Server {
Unix(PathBuf),
Tcp(SocketAddr),
/// A caller-authorized host. DNS is resolved once for each connection attempt.
Named(String, u16),
}
impl Server {
/// Parse an explicitly selected CUPS_SERVER value, without connecting. No URLs,
/// credentials, control characters or HTTP authority delimiters are accepted.
pub fn parse(value: &str) -> Result<Self, Error> {
if value.starts_with('/') {
return Ok(Self::Unix(value.into()));
}
if value.is_empty() || value.len() > 255 || value.bytes().any(|c| c.is_ascii_control() || c.is_ascii_whitespace() || b"/@?#\\".contains(&c)) {
return Err(Error::Spool("invalid CUPS server".into()));
}
let (host, port) = if let Some(rest) = value.strip_prefix('[') {
let (host, tail) = rest.split_once(']').ok_or_else(|| Error::Spool("invalid CUPS IPv6 host".into()))?;
if !host.contains(':') {
return Err(Error::Spool("bracketed CUPS host must be IPv6".into()));
}
let port = if tail.is_empty() {
631
} else {
tail.strip_prefix(':')
.and_then(|p| p.parse::<u16>().ok())
.filter(|p| *p != 0)
.ok_or_else(|| Error::Spool("invalid CUPS port".into()))?
};
(host, port)
} else if value.matches(':').count() > 1 {
// A bare IPv6 address is a host. A colon after its scope name may
// specify a port without cutting an address hextet in half.
if let Some((_, zone)) = value.split_once('%')
&& zone.contains(':')
{
let (host, port) = value.rsplit_once(':').ok_or_else(|| Error::Spool("invalid CUPS endpoint".into()))?;
(host, port.parse::<u16>().ok().filter(|p| *p != 0).ok_or_else(|| Error::Spool("invalid CUPS port".into()))?)
} else {
(value, 631)
}
} else {
match value.rsplit_once(':') {
Some((host, port)) => (host, port.parse::<u16>().ok().filter(|p| *p != 0).ok_or_else(|| Error::Spool("invalid CUPS port".into()))?),
None => (value, 631),
}
};
if host.is_empty() || host.contains(['[', ']']) {
return Err(Error::Spool("invalid CUPS host".into()));
}
if let Ok(ip) = host.parse::<std::net::IpAddr>() {
return Ok(Self::Tcp(SocketAddr::new(ip, port)));
}
if host.contains(':') {
let (ip, zone) = host.split_once('%').ok_or_else(|| Error::Spool("invalid CUPS IPv6 host".into()))?;
if ip.parse::<std::net::Ipv6Addr>().is_err()
|| zone.is_empty()
|| !zone.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-' | b'.'))
{
return Err(Error::Spool("invalid CUPS IPv6 scope".into()));
}
} else if host.contains('%') {
return Err(Error::Spool("invalid CUPS host".into()));
}
Ok(Self::Named(host.into(), port))
}
fn authority(&self) -> String {
match self {
Self::Unix(_) => "localhost".into(),
Self::Tcp(addr) => addr.to_string().replace('%', "%25"),
Self::Named(host, port) if host.contains(':') => format!("[{}]:{port}", host.replace('%', "%25")),
Self::Named(host, port) => format!("{host}:{port}"),
}
}
}
/// Local scheduler candidates, honoring the user's explicit CUPS_SERVER setting.
/// No requests are made by this function; apps must authorize selection before use.
pub fn configured_servers() -> Result<Vec<Server>, Error> {
if let Some(value) = std::env::var_os("CUPS_SERVER").filter(|v| !v.is_empty()) {
return Ok(vec![Server::parse(&value.to_string_lossy())?]);
}
Ok(vec![
Server::Unix(CUPS_SOCKET.into()),
Server::Unix("/var/run/cups/cups.sock".into()),
Server::Unix("/private/var/run/cupsd".into()),
Server::Tcp(([127, 0, 0, 1], 631).into()),
])
}
fn endpoints() -> [Server; 2] {
[Server::Unix(PathBuf::from(CUPS_SOCKET)), Server::Tcp(([127, 0, 0, 1], 631).into())]
}
/// Whether the local CUPS server is reachable: its socket, else its loopback port. A missing
/// scheduler is a normal `false`, not an error.
pub fn cups_reachable() -> bool {
endpoints().iter().any(reachable)
}
/// Probe a caller-authorized endpoint without sending a print request.
/// DNS and Unix connect have the blocking limitations documented on this module.
pub fn reachable(server: &Server) -> bool {
connect(server).is_ok()
}
fn connect(server: &Server) -> std::io::Result<Stream> {
match server {
#[cfg(unix)]
Server::Unix(path) => UnixStream::connect(path).map(Stream::Unix),
#[cfg(not(unix))]
Server::Unix(_) => Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "Unix sockets unavailable")),
Server::Named(host, port) => {
// Validate even directly constructed public variants before resolving or writing headers.
let endpoint = if host.contains(':') { format!("[{host}]:{port}") } else { format!("{host}:{port}") };
let parsed = Server::parse(&endpoint).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
if matches!(parsed, Server::Unix(_)) {
return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "a named CUPS host cannot be a Unix path"));
}
let addr = (host.as_str(), *port)
.to_socket_addrs()?
.next()
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "CUPS host has no address"))?;
TcpStream::connect_timeout(&addr, CONNECT_TIMEOUT).map(Stream::Tcp)
}
// A loopback connect either answers promptly or the server is not there.
Server::Tcp(addr) => TcpStream::connect_timeout(addr, CONNECT_TIMEOUT).map(|s| {
let _ = s.set_nodelay(true);
Stream::Tcp(s)
}),
}
}
/// A connection to the scheduler.
enum Stream {
#[cfg(unix)]
Unix(UnixStream),
Tcp(TcpStream),
}
impl Stream {
fn set_timeouts(&self, timeout: Duration) -> std::io::Result<()> {
let (read, write) = match self {
#[cfg(unix)]
Stream::Unix(s) => (s.set_read_timeout(Some(timeout)), s.set_write_timeout(Some(timeout))),
Stream::Tcp(s) => (s.set_read_timeout(Some(timeout)), s.set_write_timeout(Some(timeout))),
};
read.and(write)
}
}
impl Read for Stream {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
match self {
#[cfg(unix)]
Stream::Unix(s) => s.read(buf),
Stream::Tcp(s) => s.read(buf),
}
}
}
impl Write for Stream {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
match self {
#[cfg(unix)]
Stream::Unix(s) => s.write(buf),
Stream::Tcp(s) => s.write(buf),
}
}
fn flush(&mut self) -> std::io::Result<()> {
match self {
#[cfg(unix)]
Stream::Unix(s) => s.flush(),
Stream::Tcp(s) => s.flush(),
}
}
}
/// The server's queues (CUPS-Get-Printers) and its default destination (CUPS-Get-Default), for
/// the Print dialog when `lpstat` is missing. A default the queue list lacks is appended, so
/// the dialog always has a selection to restore; a default that cannot be named still leaves
/// the queues usable.
pub fn printers() -> Result<Vec<Printer>, Error> {
printers_at(&endpoints())
}
pub fn printers_at(endpoints: &[Server]) -> Result<Vec<Printer>, Error> {
let queues = discover(endpoints, OPERATION_CUPS_GET_PRINTERS)?;
let default = discover(endpoints, OPERATION_CUPS_GET_DEFAULT).ok().and_then(|names| names.into_iter().next());
let mut printers: Vec<Printer> = Vec::new();
for name in queues {
if printers.len() >= MAX_PRINTERS {
break;
}
if !printers.iter().any(|p| p.name == name) {
printers.push(Printer { description: String::new(), default: default.as_deref() == Some(name.as_str()), name, two_sided: None });
}
}
if let Some(name) = default
&& !printers.iter().any(|p| p.name == name)
{
printers.push(Printer { description: String::new(), name, default: true, two_sided: None });
}
Ok(printers)
}
/// The printer names a discovery reply carries: every queue (CUPS-Get-Printers), or the default
/// destination (CUPS-Get-Default).
fn discover(endpoints: &[Server], operation: u16) -> Result<Vec<String>, Error> {
let reply = post(endpoints, "/", &discovery_request(operation), DISCOVERY_TIMEOUT, true)?;
let parsed = parse_reply(&reply)?;
if status_ok(parsed.status) { Ok(parsed.names) } else { Err(refused(parsed.status)) }
}
/// Submit the PDF as a Print-Job to the printer (the job's, else the server's default); the
/// reply is the job message, like `lp` prints it (`request id is Office-12`). The driver's own
/// job options (PPD keywords) are not sent on this path: they have no IPP equivalents without
/// reading the printer's capabilities, which is another request.
pub fn print_job(pdf: &[u8], job: &Job) -> Result<String, Error> {
print_job_at(&endpoints(), pdf, job)
}
pub(crate) fn print_job_at(endpoints: &[Server], pdf: &[u8], job: &Job) -> Result<String, Error> {
let queue = match &job.printer {
Some(name) => name.clone(),
None => discover(endpoints, OPERATION_CUPS_GET_DEFAULT)?
.into_iter()
.next()
.ok_or_else(|| Error::Spool("the print server has no default printer; choose one in the dialog".into()))?,
};
if !is_queue_name(&queue) {
return Err(Error::Spool(format!("not a printer name: {queue}")));
}
let reply = post(endpoints, &format!("/printers/{queue}"), &print_job_request(&queue, pdf, job), JOB_TIMEOUT, false)?;
let parsed = parse_reply(&reply)?;
if !status_ok(parsed.status) {
return Err(refused(parsed.status));
}
Ok(match parsed.job_id {
Some(id) => format!("request id is {queue}-{id}"),
None => format!("the job was accepted by {queue}"),
})
}
/// A queue class can route a job to any member printer. Keep the destination kind
/// explicit rather than guessing it from a name shared by a printer and a class.
#[derive(Clone, Debug)]
pub struct Destination {
pub name: String,
pub is_class: bool,
}
/// List both printer queues and classes from caller-selected CUPS endpoints.
/// The caller owns endpoint selection/authorization; this API does not discover network hosts.
pub fn destinations_at(endpoints: &[Server]) -> Result<Vec<Queue>, Error> {
let mut out = queues_at(endpoints, false)?;
out.extend(queues_at(endpoints, true)?);
if out.len() > MAX_PRINTERS {
return Err(Error::Spool("too many CUPS destinations".into()));
}
let default = default_at(endpoints)?;
for queue in &mut out {
queue.is_default = default.as_deref() == Some(queue.name.as_str());
}
Ok(out)
}
/// List either printer queues or classes, without resolving defaults. Applications can
/// explicitly choose whether an optional class/default query failure should hide otherwise
/// usable printer queues. No error is swallowed here except CUPS's absent/unsupported list.
pub fn queues_at(endpoints: &[Server], is_class: bool) -> Result<Vec<Queue>, Error> {
let operation = if is_class { 0x4005 } else { OPERATION_CUPS_GET_PRINTERS };
let reply = post(endpoints, "/", &discovery_request(operation), DISCOVERY_TIMEOUT, true)?;
let parsed = parse_reply(&reply)?;
if !status_ok(parsed.status) {
if parsed.status == 0x0406 || (is_class && parsed.status == 0x0501) {
return Ok(Vec::new());
}
return Err(refused(parsed.status));
}
let mut queues = parsed.queues;
for queue in &mut queues {
queue.is_class = is_class;
}
Ok(queues)
}
/// The scheduler's default queue; not-found means no default has been configured.
pub fn default_at(endpoints: &[Server]) -> Result<Option<String>, Error> {
let reply = post(endpoints, "/", &discovery_request(OPERATION_CUPS_GET_DEFAULT), DISCOVERY_TIMEOUT, true)?;
let parsed = parse_reply(&reply)?;
if parsed.status == 0x0406 {
return Ok(None);
}
if !status_ok(parsed.status) {
return Err(refused(parsed.status));
}
Ok(parsed.names.into_iter().next())
}
/// Metadata from one CUPS printer group, without losing which fields belong together.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Queue {
pub name: String,
pub info: String,
pub state: u32,
pub accepting_jobs: bool,
pub is_default: bool,
pub is_class: bool,
}
impl Default for Queue {
fn default() -> Self {
Self { name: String::new(), info: String::new(), state: 3, accepting_jobs: true, is_default: false, is_class: false }
}
}
/// Submit once to an explicitly selected queue/class, returning the numeric server job id.
/// An absent id is an uncertain accepted outcome, not permission to retry the document.
pub fn submit_at(endpoints: &[Server], destination: &Destination, pdf: &[u8], job: &Job) -> Result<u32, Error> {
submit_as_at(endpoints, destination, pdf, job, "")
}
/// As [`submit_at`], with the user name supplied by the application, never inferred from
/// process credentials. Once any request bytes may have been sent, no other endpoint is tried.
pub fn submit_as_at(endpoints: &[Server], destination: &Destination, pdf: &[u8], job: &Job, user: &str) -> Result<u32, Error> {
let path = destination_path(destination)?;
if user.len() > MAX_JOB_NAME || user.chars().any(char::is_control) {
return Err(Error::Spool("invalid CUPS user name".into()));
}
if job.copies == 0 || job.copies > 999 {
return Err(Error::Spool("copies must be between 1 and 999".into()));
}
let mut last = Error::Spool("no CUPS endpoint selected".into());
for endpoint in endpoints {
let mut stream = match connect(endpoint) {
Ok(stream) => stream,
Err(error) => {
last = Error::Spool(format!("CUPS connection failed: {error}"));
continue;
}
};
let authority = endpoint.authority();
let request = print_job_request_for(&authority, &path, pdf, job, user);
// Never retry exchange errors: the scheduler may already have accepted the job.
let reply = exchange(&mut stream, &authority, &path, &request, JOB_TIMEOUT)?;
let parsed = parse_reply(&reply)?;
if !status_ok(parsed.status) {
return Err(refused(parsed.status));
}
return parsed
.job_id
.filter(|id| *id != 0 && *id <= i32::MAX as u32)
.ok_or_else(|| Error::Spool("CUPS accepted the job without a usable job id; do not resubmit".into()));
}
Err(last)
}
/// Encode one destination as a URI path segment, never as routing syntax. Names from
/// discovery may include spaces or Unicode. Reject separators, controls and dot segments
/// rather than relying on a server to keep an encoded traversal request harmless.
fn destination_path(destination: &Destination) -> Result<String, Error> {
let name = &destination.name;
if name.is_empty()
|| name.len() > MAX_NAME
|| matches!(name.as_str(), "." | "..")
|| name.chars().any(|c| c.is_control() || matches!(c, '/' | '\\'))
{
return Err(Error::Spool("invalid CUPS destination name".into()));
}
let kind = if destination.is_class { "classes" } else { "printers" };
let mut path = format!("/{kind}/");
for byte in name.bytes() {
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~') {
path.push(char::from(byte));
} else {
use std::fmt::Write as _;
write!(&mut path, "%{byte:02X}").map_err(|_| Error::Spool("could not encode CUPS destination".into()))?;
}
}
Ok(path)
}
/// A CUPS queue name: ASCII letters, digits and `_`, `-`, `.` — what the scheduler accepts, and
/// what cannot break the printer URI's path.
fn is_queue_name(name: &str) -> bool {
!name.is_empty() && name.len() <= MAX_NAME && name.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-' | b'.'))
}
/// One IPP request and its reply body. Discovery may try each endpoint in turn; a job is given
/// to the first endpoint that accepts a connection, once: a retry could print it twice.
pub(crate) fn post(endpoints: &[Server], path: &str, body: &[u8], timeout: Duration, retry: bool) -> Result<Vec<u8>, Error> {
let mut failed: Option<Error> = None;
for server in endpoints {
let mut stream = match connect(server) {
Ok(stream) => stream,
Err(e) => {
failed = Some(Error::Spool(format!("the print server could not be reached: {e}")));
continue;
}
};
match exchange(&mut stream, &server.authority(), path, body, timeout) {
Ok(reply) => return Ok(reply),
Err(e) => {
failed = Some(e);
if !retry {
break;
}
}
}
}
Err(failed.unwrap_or_else(|| Error::Spool("the print server could not be reached".into())))
}
/// Send one IPP request and read the reply's body.
fn exchange(stream: &mut Stream, authority: &str, path: &str, body: &[u8], timeout: Duration) -> Result<Vec<u8>, Error> {
let mut stream = DeadlineReader { stream, end: Instant::now() + timeout };
let head = format!(
"POST {path} HTTP/1.1\r\nHost: {authority}\r\nContent-Type: application/ipp\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
stream
.write_all(head.as_bytes())
.and_then(|()| stream.write_all(body))
.and_then(|()| stream.flush())
.map_err(|e| Error::Spool(format!("the request could not be sent to the print server: {e}")))?;
let reply = read_reply(&mut stream)?;
validate_reply_identity(body, &reply)?;
Ok(reply)
}
/// One absolute deadline shared by request writes and reply reads after connection.
struct DeadlineReader<'a> {
stream: &'a mut Stream,
end: Instant,
}
impl Write for DeadlineReader<'_> {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
let left = self
.end
.checked_duration_since(Instant::now())
.filter(|d| !d.is_zero())
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::TimedOut, "CUPS exchange deadline exceeded"))?;
self.stream.set_timeouts(left)?;
self.stream.write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
self.stream.flush()
}
}
fn validate_reply_identity(request: &[u8], reply: &[u8]) -> Result<(), Error> {
if reply.get(..2) != Some(&[1, 1]) || request.get(4..8).is_none() || request.get(4..8) != reply.get(4..8) {
return Err(Error::Spool("CUPS reply version or request id does not match; do not resubmit".into()));
}
Ok(())
}
impl Read for DeadlineReader<'_> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let left = self
.end
.checked_duration_since(Instant::now())
.filter(|d| !d.is_zero())
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::TimedOut, "CUPS reply deadline exceeded"))?;
#[cfg(not(target_os = "macos"))]
self.stream.set_timeouts(left)?;
#[cfg(target_os = "macos")]
if let Err(error) = self.stream.set_timeouts(left) {
// Darwin rejects timeout updates on a disconnected Unix socket even
// when a complete reply is still buffered. Never fall back to a
// blocking read: drain at most this buffer, or fail on WouldBlock.
// Every subsequent read rechecks the same absolute deadline above.
if error.raw_os_error() == Some(22)
&& let Stream::Unix(stream) = self.stream
{
stream.set_nonblocking(true)?;
let result = stream.read(buf);
let restored = stream.set_nonblocking(false);
return result.and_then(|count| restored.map(|()| count));
}
return Err(error);
}
self.stream.read(buf)
}
}
fn read_reply(stream: &mut impl Read) -> Result<Vec<u8>, Error> {
let mut head = Vec::new();
let mut byte = [0u8; 1];
loop {
if head.len() >= MAX_HEADERS {
return Err(Error::Spool("the print server sent a header block that is too large".into()));
}
match stream.read(&mut byte) {
Ok(0) => return Err(Error::Spool("the print server closed the connection before sending its reply".into())),
Ok(_) => head.push(byte[0]),
Err(e) => return Err(Error::Spool(format!("the print server's reply could not be read: {e}"))),
}
if head.ends_with(b"\r\n\r\n") {
break;
}
}
let head = String::from_utf8_lossy(&head);
let Some(status_line) = head.lines().next() else { return Err(Error::Spool("the print server sent an unreadable reply".into())) };
let code = status_line
.strip_prefix("HTTP/")
.and_then(|rest| rest.split_once(' '))
.and_then(|(_, code)| code.split_whitespace().next())
.and_then(|code| code.parse::<u16>().ok())
.ok_or_else(|| Error::Spool("the print server sent an unreadable reply".into()))?;
match code {
200..=299 => {}
401 => return Err(Error::Spool("the print server requires authentication".into())),
426 => return Err(Error::Spool("the print server only accepts encrypted connections".into())),
_ => return Err(Error::Spool(format!("the print server refused the request (HTTP {code})"))),
}
let mut content_length: Option<usize> = None;
let mut chunked = false;
for line in head.lines().skip(1) {
// The empty line ends the header block; any other line without a colon is malformed.
if line.is_empty() {
continue;
}
let Some((name, value)) = line.split_once(':') else {
return Err(Error::Spool("the print server sent an unreadable header".into()));
};
match name.trim().to_ascii_lowercase().as_str() {
"content-length" => {
let len = value.trim().parse::<usize>().map_err(|_| Error::Spool("invalid Content-Length".into()))?;
if content_length.replace(len).is_some() {
return Err(Error::Spool("duplicate Content-Length".into()));
}
}
// Only `identity` is not a transfer encoding to be decoded.
"transfer-encoding" => {
if chunked || !value.trim().eq_ignore_ascii_case("chunked") {
return Err(Error::Spool("unsupported Transfer-Encoding".into()));
}
chunked = true;
}
_ => {}
}
}
if chunked {
if content_length.is_some() {
return Err(Error::Spool("ambiguous reply framing".into()));
}
return read_chunks(stream);
}
let Some(len) = content_length else { return Err(Error::Spool("the print server sent no Content-Length".into())) };
if len > MAX_BODY {
return Err(Error::Spool(format!("the print server's reply is too large ({len} bytes)")));
}
let mut body = vec![0u8; len];
stream.read_exact(&mut body).map_err(|e| Error::Spool(format!("the print server's reply was cut short: {e}")))?;
Ok(body)
}
fn read_chunks(stream: &mut impl Read) -> Result<Vec<u8>, Error> {
fn line(stream: &mut impl Read) -> Result<Vec<u8>, Error> {
let mut out = Vec::new();
for _ in 0..MAX_HEADERS {
let mut byte = [0];
stream.read_exact(&mut byte).map_err(|e| Error::Spool(format!("truncated chunk: {e}")))?;
out.push(byte[0]);
if out.ends_with(b"\r\n") {
out.truncate(out.len() - 2);
return Ok(out);
}
}
Err(Error::Spool("chunk line exceeds limit".into()))
}
let mut body = Vec::new();
for _ in 0..100_000 {
let header = line(stream)?;
let size = header.split(|b| *b == b';').next().unwrap_or_default();
if size.is_empty() || !size.iter().all(u8::is_ascii_hexdigit) {
return Err(Error::Spool("invalid chunk size".into()));
}
let len = std::str::from_utf8(size)
.ok()
.and_then(|s| usize::from_str_radix(s, 16).ok())
.ok_or_else(|| Error::Spool("invalid chunk size".into()))?;
if len == 0 {
let mut total = 0usize;
loop {
let trailer = line(stream)?;
total = total.saturating_add(trailer.len() + 2);
if total > MAX_HEADERS {
return Err(Error::Spool("chunk trailers exceed limit".into()));
}
if trailer.is_empty() {
return Ok(body);
}
if !trailer.contains(&b':') {
return Err(Error::Spool("invalid chunk trailer".into()));
}
}
}
let end = body.len().checked_add(len).filter(|n| *n <= MAX_BODY).ok_or_else(|| Error::Spool("chunked reply exceeds limit".into()))?;
let start = body.len();
body.resize(end, 0);
stream.read_exact(&mut body[start..]).map_err(|e| Error::Spool(format!("truncated chunk: {e}")))?;
let mut crlf = [0; 2];
stream.read_exact(&mut crlf).map_err(|e| Error::Spool(format!("truncated chunk: {e}")))?;
if crlf != *b"\r\n" {
return Err(Error::Spool("invalid chunk terminator".into()));
}
}
Err(Error::Spool("too many chunks".into()))
}
/// An IPP request being built: a version, an operation and a request id, then attributes, then
/// the document.
struct Request {
bytes: Vec<u8>,
}
impl Request {
fn new(operation: u16) -> Self {
// IPP 1.1: version, operation, a request id (any nonzero value).
let mut bytes = vec![1, 1];
bytes.extend(operation.to_be_bytes());
bytes.extend(REQUEST_ID.fetch_add(1, Ordering::Relaxed).max(1).to_be_bytes());
Request { bytes }
}
fn group(&mut self, tag: u8) {
self.bytes.push(tag);
}
fn end(&mut self) {
self.bytes.push(GROUP_END);
}
fn attribute(&mut self, tag: u8, name: &str, value: &[u8]) {
let (Ok(name_len), Ok(value_len)) = (u16::try_from(name.len()), u16::try_from(value.len())) else {
return;
};
self.bytes.push(tag);
self.bytes.extend(name_len.to_be_bytes());
self.bytes.extend(name.as_bytes());
self.bytes.extend(value_len.to_be_bytes());
self.bytes.extend(value);
}
/// An additional value of the previous attribute (a `1setOf`): the name is empty.
fn additional(&mut self, tag: u8, value: &str) {
self.attribute(tag, "", value.as_bytes());
}
}
/// A discovery request: the operation's required attributes, then the names to be answered with.
fn discovery_request(operation: u16) -> Vec<u8> {
let mut r = Request::new(operation);
r.group(GROUP_OPERATION);
r.attribute(TAG_CHARSET, "attributes-charset", b"utf-8");
r.attribute(TAG_LANGUAGE, "attributes-natural-language", b"en");
r.attribute(TAG_URI, "printer-uri", b"ipp://localhost/");
r.attribute(TAG_KEYWORD, "requested-attributes", b"printer-name");
r.additional(TAG_KEYWORD, "printer-info");
r.additional(TAG_KEYWORD, "printer-state");
r.additional(TAG_KEYWORD, "printer-is-accepting-jobs");
r.end();
r.bytes
}
/// A Print-Job request for `queue`: the job's options as IPP attributes, the PDF as the document
/// data that follows the end of attributes.
fn print_job_request(queue: &str, pdf: &[u8], job: &Job) -> Vec<u8> {
print_job_request_path(&format!("/printers/{queue}"), pdf, job)
}
fn print_job_request_path(path: &str, pdf: &[u8], job: &Job) -> Vec<u8> {
print_job_request_for("localhost", path, pdf, job, "")
}
fn print_job_request_for(authority: &str, path: &str, pdf: &[u8], job: &Job, user: &str) -> Vec<u8> {
let mut r = Request::new(OPERATION_PRINT_JOB);
r.group(GROUP_OPERATION);
r.attribute(TAG_CHARSET, "attributes-charset", b"utf-8");
r.attribute(TAG_LANGUAGE, "attributes-natural-language", b"en");
r.attribute(TAG_URI, "printer-uri", format!("ipp://{authority}{path}").as_bytes());
if !user.is_empty() {
r.attribute(TAG_NAME, "requesting-user-name", user.as_bytes());
}
r.attribute(TAG_NAME, "job-name", truncate_utf8(&job.title, MAX_JOB_NAME).as_bytes());
r.attribute(TAG_MIME, "document-format", b"application/pdf");
r.group(GROUP_JOB);
r.attribute(TAG_INTEGER, "copies", &job.copies.clamp(1, 999).to_be_bytes());
r.attribute(TAG_BOOLEAN, "collate", &[u8::from(job.collate)]);
if let Some(duplex) = job.duplex {
r.attribute(
TAG_KEYWORD,
"sides",
match duplex {
Duplex::Off => "one-sided",
Duplex::LongEdge => "two-sided-long-edge",
Duplex::ShortEdge => "two-sided-short-edge",
}
.as_bytes(),
);
}
if job.grayscale {
r.attribute(TAG_KEYWORD, "print-color-mode", b"monochrome");
}
// PWG 5100.13 §6.2.5: `none` keeps every sheet at its size, `auto-fit` shrinks only
// oversized ones — the same choices `lp`'s fit-to-page and print-scaling options make.
r.attribute(
TAG_KEYWORD,
"print-scaling",
match job.scaling {
Scaling::Exact => "none",
Scaling::ShrinkToFit => "auto-fit",
}
.as_bytes(),
);
r.end();
r.bytes.extend(pdf);
r.bytes
}
/// The string cut to at most `max` bytes, at a character boundary.
fn truncate_utf8(s: &str, max: usize) -> &str {
if s.len() <= max {
return s;
}
let mut end = max;
while !s.is_char_boundary(end) {
end -= 1;
}
// `end` is a checked boundary; nothing is the only name that cannot be cut.
s.get(..end).unwrap_or_default()
}
/// The parsed parts of a reply: the IPP status, the printer names in its printer groups, and a
/// submission's job id.
struct Reply {
status: u16,
names: Vec<String>,
queues: Vec<Queue>,
job_id: Option<u32>,
}
/// A cursor over a reply: `None` at the end or past a length, never an over-read.
struct Reader<'a> {
bytes: &'a [u8],
pos: usize,
}
impl<'a> Reader<'a> {
fn take(&mut self, len: usize) -> Option<&'a [u8]> {
let end = self.pos.checked_add(len)?;
let taken = self.bytes.get(self.pos..end)?;
self.pos = end;
Some(taken)
}
fn array<const N: usize>(&mut self) -> Option<[u8; N]> {
<[u8; N]>::try_from(self.take(N)?).ok()
}
fn u16(&mut self) -> Option<u16> {
self.array::<2>().map(u16::from_be_bytes)
}
}
fn parse_reply(reply: &[u8]) -> Result<Reply, Error> {
let malformed = || Error::Spool("the print server sent a malformed reply".into());
let mut r = Reader { bytes: reply, pos: 0 };
let _version = r.array::<2>().ok_or_else(malformed)?;
let status = r.u16().ok_or_else(malformed)?;
let _request_id = r.array::<4>().ok_or_else(malformed)?;
let (mut names, mut job_id, mut group) = (Vec::new(), None, 0u8);
let mut queues = Vec::new();
let mut queue = Queue::default();
loop {
let Some(tag) = r.array::<1>().map(|t| t[0]) else { return Err(malformed()) };
match tag {
GROUP_END => {
if !queue.name.is_empty() {
queues.push(queue);
}
break;
}
GROUP_OPERATION | GROUP_JOB | GROUP_PRINTER | 0x05 => {
if !queue.name.is_empty() {
if queues.len() >= MAX_PRINTERS {
return Err(malformed());
}
queues.push(std::mem::take(&mut queue));
} else {
queue = Queue::default();
}
group = tag;
}
// An attribute: name and value, each u16-length. An empty name is an additional
// value of the previous one (the attributes read here are single-valued, so those
// are ignored). Group tags not in the registry and collections (the attributes
// requested here are never collections) are refused, not guessed.
0x10..=0x33 | 0x35..=0x4A => {
let name_len = r.u16().ok_or_else(malformed)?;
if usize::from(name_len) > MAX_NAME {
return Err(malformed());
}
let name_bytes = r.take(usize::from(name_len)).ok_or_else(malformed)?;
let name = std::str::from_utf8(name_bytes).map_err(|_| malformed())?;
let value_len = r.u16().ok_or_else(malformed)?;
let value = r.take(usize::from(value_len)).ok_or_else(malformed)?;
match (group, name, tag) {
(GROUP_PRINTER, "printer-name", TAG_NAME) => {
if let Some(printer) = std::str::from_utf8(value).ok().filter(|n| !n.is_empty() && n.len() <= MAX_NAME) {
if names.len() >= MAX_PRINTERS {
return Err(Error::Spool("too many CUPS destinations".into()));
}
if !queue.name.is_empty() {
return Err(malformed());
}
queue.name = printer.to_string();
names.push(printer.to_string());
}
}
(GROUP_PRINTER, "printer-info", 0x41 | TAG_NAME) => {
// Human descriptions are text, not queue identifiers. Their u16
// wire length and the whole-response MAX_BODY cap bound allocation.
queue.info = std::str::from_utf8(value).map_err(|_| malformed())?.to_owned();
}
(GROUP_PRINTER, "printer-state", 0x23 | TAG_INTEGER) => {
queue.state = u32::from_be_bytes(value.try_into().map_err(|_| malformed())?);
}
(GROUP_PRINTER, "printer-is-accepting-jobs", TAG_BOOLEAN) => {
queue.accepting_jobs = match value {
[0] => false,
[1] => true,
_ => return Err(malformed()),
};
}
(GROUP_JOB, "job-id", TAG_INTEGER) => {
if let Ok(id) = <[u8; 4]>::try_from(value) {
job_id = Some(u32::from_be_bytes(id));
}
}
_ => {}
}
}
_ => return Err(malformed()),
}
}
Ok(Reply { status, names, queues, job_id })
}
/// Successful IPP status codes are `0x00xx` (RFC 8011 Appendix B).
fn status_ok(status: u16) -> bool {
status < 0x0100
}
/// The IPP status code's name, for the error the user sees.
fn status_name(status: u16) -> Option<&'static str> {
Some(match status {
0x0400 => "bad request",
0x0401 => "forbidden",
0x0402 => "not authenticated",
0x0403 => "not authorized",
0x0404 => "not possible",
0x0406 => "printer not found",
0x0408 => "request too large",
0x040A => "PDF is not a supported document format for this printer",
0x0412 => "the document could not be accessed",
0x0500 => "internal error",
0x0501 => "operation not supported",
0x0502 => "service unavailable",
0x0503 => "IPP version not supported",
0x0504 => "device error",
0x0505 => "temporary error",
0x0506 => "the printer is not accepting jobs",
0x0507 => "the printer is busy",
_ => return None,
})
}
fn refused(status: u16) -> Error {
match status_name(status) {
Some(name) => Error::Spool(format!("the print server refused the request ({name})")),
None => Error::Spool(format!("the print server refused the request (IPP status 0x{status:04X})")),
}
}
+593
View File
@@ -0,0 +1,593 @@
//! The IPP client against a fake CUPS server (a unix socket or a loopback port): discovery,
//! Print-Job, and the malformed replies it must refuse without a panic.
use super::*;
use crate as spool;
use crate::cups::{self as ipp, Server};
use std::collections::VecDeque;
use std::io::{Read, Write};
use std::sync::Mutex;
use std::sync::mpsc::{self, Receiver};
use std::time::Duration;
const TIMEOUT: Duration = Duration::from_secs(2);
/// A fake CUPS server: each connection carries one request; the next canned reply goes back
/// (nothing, when the list is out — the client then sees a hang-up). Every request is recorded
/// for the assertions.
struct FakeCups {
server: Server,
requests: Receiver<Vec<u8>>,
}
impl FakeCups {
fn on_unix(replies: Vec<Vec<u8>>) -> std::io::Result<Self> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("cups.sock");
let listener = std::os::unix::net::UnixListener::bind(&path)?;
// The socket must outlive this function; the folder is left for the process to reap.
std::mem::forget(dir);
let requests = listen_unix(listener, replies);
Ok(FakeCups { server: Server::Unix(path), requests })
}
fn on_tcp(replies: Vec<Vec<u8>>) -> std::io::Result<Self> {
let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
let server = Server::Tcp(listener.local_addr()?);
let requests = listen_tcp(listener, replies);
Ok(FakeCups { server, requests })
}
fn request(&self) -> Result<Vec<u8>, mpsc::RecvTimeoutError> {
self.requests.recv_timeout(Duration::from_secs(5))
}
/// The server as the one-endpoint list the client functions take.
fn endpoint(&self) -> &[Server] {
std::slice::from_ref(&self.server)
}
}
fn listen_unix(listener: std::os::unix::net::UnixListener, replies: Vec<Vec<u8>>) -> Receiver<Vec<u8>> {
let (tx, rx) = mpsc::channel();
let replies = Mutex::new(VecDeque::from(replies));
std::thread::spawn(move || {
for stream in listener.incoming().flatten() {
serve(stream, &replies, &tx);
}
});
rx
}
fn listen_tcp(listener: std::net::TcpListener, replies: Vec<Vec<u8>>) -> Receiver<Vec<u8>> {
let (tx, rx) = mpsc::channel();
let replies = Mutex::new(VecDeque::from(replies));
std::thread::spawn(move || {
for stream in listener.incoming().flatten() {
serve(stream, &replies, &tx);
}
});
rx
}
fn serve(mut stream: impl Read + Write, replies: &Mutex<VecDeque<Vec<u8>>>, requests: &mpsc::Sender<Vec<u8>>) {
let Some(request) = read_request(&mut stream) else { return };
let Some(body) = ipp_body(&request) else { return };
let request_id = body.get(4..8).map(|id| id.to_vec());
let _ = requests.send(request);
// A list out of replies is a server that hangs up before answering.
let Ok(mut replies) = replies.lock() else { return };
if let Some(mut reply) = replies.pop_front() {
if let Some(body) = reply.windows(4).position(|w| w == b"\r\n\r\n").map(|at| at + 4)
&& reply.get(body..body + 2) == Some(&[1, 1])
&& let Some(id) = request_id
&& let Some(destination) = reply.get_mut(body + 4..body + 8)
{
destination.copy_from_slice(&id);
}
let _ = stream.write_all(&reply);
let _ = stream.flush();
}
}
/// One HTTP request: the headers (bounded), then the `Content-Length` body it announces.
fn read_request(stream: &mut impl Read) -> Option<Vec<u8>> {
let mut buf = Vec::new();
let mut byte = [0u8; 1];
loop {
match stream.read(&mut byte) {
Ok(0) | Err(_) => return None,
Ok(_) => buf.push(byte[0]),
}
if buf.ends_with(b"\r\n\r\n") {
break;
}
if buf.len() > 1 << 16 {
return None;
}
}
let head = String::from_utf8_lossy(&buf);
let len: usize = head.lines().find_map(|l| l.strip_prefix("Content-Length:")).and_then(|v| v.trim().parse().ok())?;
let head_len = buf.len();
buf.resize(head_len + len, 0);
stream.read_exact(&mut buf[head_len..]).ok()?;
Some(buf)
}
/// An HTTP reply carrying `body`, as CUPS would send it.
fn http_reply(body: &[u8]) -> Vec<u8> {
let mut out = format!("HTTP/1.1 200 OK\r\nContent-Type: application/ipp\r\nContent-Length: {}\r\n\r\n", body.len()).into_bytes();
out.extend(body);
out
}
/// An IPP reply body: `status`, then the attribute groups as raw bytes, then end of attributes.
fn ipp_reply(status: u16, groups: &[&[u8]]) -> Vec<u8> {
let mut out = vec![1, 1];
out.extend(status.to_be_bytes());
out.extend(1u32.to_be_bytes());
for &group in groups {
out.extend(group);
}
out.push(0x03);
out
}
fn group(tag: u8) -> Vec<u8> {
vec![tag]
}
fn printer_name(name: &str) -> Vec<u8> {
attr(0x42, "printer-name", name.as_bytes())
}
/// One attribute, framed the way the client frames them, so `has` finds it in a request.
fn attr(tag: u8, name: &str, value: &[u8]) -> Vec<u8> {
let mut out = vec![tag];
out.extend((name.len() as u16).to_be_bytes());
out.extend(name.as_bytes());
out.extend((value.len() as u16).to_be_bytes());
out.extend(value);
out
}
fn has(bytes: &[u8], needle: &[u8]) -> bool {
!needle.is_empty() && bytes.windows(needle.len()).any(|w| w == needle)
}
/// The IPP part of a recorded request: everything after the HTTP head.
fn ipp_body(request: &[u8]) -> Option<&[u8]> {
let at = request.windows(4).position(|w| w == b"\r\n\r\n")?;
request.get(at + 4..)
}
fn entry(name: &str, default: bool) -> spool::Printer {
spool::Printer { description: String::new(), name: name.into(), default, two_sided: None }
}
#[test]
fn discovery_finds_queues_and_the_default_over_a_unix_socket() {
let fake = FakeCups::on_unix(vec![
http_reply(&ipp_reply(
0x0000,
&[
&group(0x01),
&printer_name("Office_Laser"),
&group(0x04),
&printer_name("Office_Laser"),
&group(0x04),
&printer_name("Label_Writer"),
&group(0x04),
&printer_name("Office_Laser"),
],
)),
http_reply(&ipp_reply(0x0000, &[&group(0x01), &group(0x04), &printer_name("Office_Laser")])),
])
.unwrap();
let printers = ipp::printers_at(fake.endpoint()).unwrap();
assert_eq!(printers, [entry("Office_Laser", true), entry("Label_Writer", false)], "each queue once, the default marked");
let taken = fake.request().unwrap();
let queues = ipp_body(&taken).unwrap();
assert_eq!(&queues[..4], &[1, 1, 0x40, 0x02], "IPP 1.1, CUPS-Get-Printers");
assert!(has(queues, b"ipp://localhost/"));
assert!(has(queues, &attr(0x44, "requested-attributes", b"printer-name")));
assert!(has(queues, b"printer-is-accepting-jobs"), "only the attributes the dialog needs are asked for");
let taken = fake.request().unwrap();
let default = ipp_body(&taken).unwrap();
assert_eq!(&default[..4], &[1, 1, 0x40, 0x01], "CUPS-Get-Default");
}
#[test]
fn a_print_job_carries_the_pdf_and_the_options() {
let pdf: Vec<u8> = b"%PDF-1.7 fake print job\n".iter().copied().cycle().take(1 << 20).collect();
let job = spool::Job {
printer: Some("Office".into()),
copies: 2,
collate: false,
duplex: Some(spool::Duplex::LongEdge),
grayscale: true,
scaling: spool::Scaling::ShrinkToFit,
title: "memo.pdf".into(),
..Job::default()
};
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(
0x0000,
&[&group(0x01), &group(0x02), &attr(0x21, "job-id", &12u32.to_be_bytes()), &attr(0x23, "job-state", &[3u8])],
))])
.unwrap();
let message = ipp::print_job_at(fake.endpoint(), &pdf, &job).unwrap();
assert_eq!(message, "request id is Office-12", "the same message lp prints");
let taken = fake.request().unwrap();
let request = ipp_body(&taken).unwrap();
assert_eq!(&request[..4], &[1, 1, 0x00, 0x02], "IPP 1.1, Print-Job");
assert!(has(request, b"ipp://localhost/printers/Office"));
let mut copies = group(0x02);
copies.extend(attr(0x21, "copies", &2u32.to_be_bytes()));
assert!(has(request, &copies), "copies are a job attribute");
assert!(has(request, &attr(0x22, "collate", &[0])));
assert!(has(request, &attr(0x44, "sides", b"two-sided-long-edge")));
assert!(has(request, &attr(0x44, "print-color-mode", b"monochrome")));
assert!(has(request, &attr(0x44, "print-scaling", b"auto-fit")));
assert!(has(request, &attr(0x49, "document-format", b"application/pdf")));
assert!(has(request, &attr(0x42, "job-name", b"memo.pdf")));
assert!(request.ends_with(&pdf), "the whole job is the document data");
}
#[test]
fn the_default_printer_is_used_when_the_job_has_none() {
let fake = FakeCups::on_tcp(vec![
http_reply(&ipp_reply(0x0000, &[&group(0x01), &group(0x04), &printer_name("Office")])),
http_reply(&ipp_reply(0x0000, &[&group(0x01), &group(0x02), &attr(0x21, "job-id", &7u32.to_be_bytes())])),
])
.unwrap();
let message = ipp::print_job_at(fake.endpoint(), b"%PDF-1.7\n", &Job::default()).unwrap();
assert_eq!(message, "request id is Office-7");
let default = fake.request().unwrap();
assert_eq!(&ipp_body(&default).unwrap()[..4], &[1, 1, 0x40, 0x01], "the default comes from CUPS-Get-Default");
let taken = fake.request().unwrap();
assert!(has(ipp_body(&taken).unwrap(), b"ipp://localhost/printers/Office"), "the resolved default is the target");
}
#[test]
fn a_default_outside_the_queue_list_still_gets_its_marker() {
let fake = FakeCups::on_unix(vec![
http_reply(&ipp_reply(0x0000, &[&group(0x01), &group(0x04), &printer_name("Office_Laser")])),
http_reply(&ipp_reply(0x0000, &[&group(0x01), &group(0x04), &printer_name("Label_Writer")])),
])
.unwrap();
let printers = ipp::printers_at(fake.endpoint()).unwrap();
assert_eq!(
printers,
[entry("Office_Laser", false), entry("Label_Writer", true)],
"the default joins the list, so the dialog has a selection to restore"
);
}
#[test]
fn no_default_printer_is_an_error_when_the_job_names_none() {
let fake = FakeCups::on_unix(vec![http_reply(&ipp_reply(0x0000, &[&group(0x01)]))]).unwrap();
let err = ipp::print_job_at(fake.endpoint(), b"%PDF-1.7\n", &Job::default()).unwrap_err();
assert!(err.to_string().contains("no default printer"), "{err}");
}
#[test]
fn a_printer_name_that_cannot_be_a_uri_path_is_refused() {
let fake = FakeCups::on_tcp(vec![]).unwrap();
let mut long = "x".repeat(257);
long.push('y');
for name in ["Office (east)", "../../admin", "", "a b", "Brother/HL", "Копир", long.as_str()] {
let job = spool::Job { printer: Some(name.into()), ..Job::default() };
assert_eq!(
ipp::print_job_at(fake.endpoint(), b"pdf", &job),
Err(spool::Error::Spool(format!("not a printer name: {name}"))),
"{name:?} cannot go in the printer URI's path"
);
}
}
#[test]
fn an_ipp_refusal_is_an_error_that_names_the_problem() {
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0x0506, &[&group(0x01)]))]).unwrap();
let job = spool::Job { printer: Some("Office".into()), ..Job::default() };
assert_eq!(
ipp::print_job_at(fake.endpoint(), b"%PDF-1.7\n", &job),
Err(spool::Error::Spool("the print server refused the request (the printer is not accepting jobs)".into()))
);
}
#[test]
fn malformed_replies_are_errors_never_a_panic() {
let bodies: Vec<(&str, Vec<u8>)> = vec![
// Shorter than an IPP header.
("shorter than an IPP header", vec![1, 1, 0]),
// A reply that ends inside an attribute: the name is announced, the value never comes.
("cut inside an attribute", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0x42, 0x00, 0x20, b'p']),
// A value tag the registry does not know.
("unknown value tag", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0xFF, 0x00, 0x00, 0x00, 0x00]),
// A collection, which the attributes asked for never are.
("collection", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0x34, 0x00, 0x00, 0x00, 0x00]),
// A group tag that is no delimiter in the registry.
("reserved delimiter", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x06]),
// A length within the cap that runs past the reply, and one past the cap.
("length past the reply", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0x42, 0x00, 0xFE, b'p']),
("length past the cap", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0x42, 0xFF, 0xFF, b'p']),
// No end of attributes before the body runs out.
("no end of attributes", vec![1, 1, 0, 0, 0, 0, 0, 1, 0x04, 0x42, 0x00, 0x01, b'x']),
];
for (why, body) in bodies {
let fake = FakeCups::on_unix(vec![http_reply(&body)]).unwrap();
let result = ipp::printers_at(fake.endpoint());
assert!(result.is_err(), "{why}: the reply must be an error, not a panic or a success");
}
}
#[test]
fn http_replies_that_cannot_carry_an_answer_are_refused() {
let replies: Vec<(&str, Vec<u8>)> = vec![
("requires authentication", b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n".to_vec()),
("demands a TLS upgrade", b"HTTP/1.1 426 Upgrade Required\r\nContent-Length: 0\r\n\r\n".to_vec()),
("chunked", b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n25\r\nthe body is chunked\r\n0\r\n\r\n".to_vec()),
("no Content-Length", b"HTTP/1.1 200 OK\r\nContent-Type: application/ipp\r\n\r\n".to_vec()),
("Content-Length past the cap", b"HTTP/1.1 200 OK\r\nContent-Length: 99999999\r\n\r\n".to_vec()),
("unreadable status line", b"not HTTP at all\r\n\r\n".to_vec()),
];
for (why, reply) in replies {
let fake = FakeCups::on_unix(vec![reply]).unwrap();
let result = ipp::post(&[fake.server], "/", b"ignored", TIMEOUT, true);
assert!(result.is_err(), "{why}: the reply must be an error, not a panic or a success");
}
// A server that takes the request and hangs up.
let fake = FakeCups::on_unix(vec![]).unwrap();
assert!(ipp::post(&[fake.server], "/", b"ignored", TIMEOUT, true).is_err(), "a hang-up is an error");
}
#[test]
fn a_server_that_answers_is_reachable_and_silence_is_not() {
let fake = FakeCups::on_unix(vec![]).unwrap();
assert!(ipp::reachable(&fake.server), "a unix socket that accepts connections is reachable");
let fake = FakeCups::on_tcp(vec![]).unwrap();
assert!(ipp::reachable(&fake.server), "a loopback port that accepts connections is reachable");
let absent = Server::Unix("/nonexistent/craft-print-test.sock".into());
assert!(!ipp::reachable(&absent), "a socket nothing listens on is not reachable");
let addr = {
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
listener.local_addr().unwrap()
};
assert!(!ipp::reachable(&Server::Tcp(addr)), "a port nothing listens on is not reachable");
}
#[test]
fn chunked_reply_is_bounded_and_rejects_ambiguous_framing() {
let good = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nabc\r\n2\r\nde\r\n0\r\n\r\n";
assert_eq!(super::read_reply(&mut &good[..]).unwrap(), b"abcde");
for bad in [
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Length: 0\r\n\r\n0\r\n\r\n".as_slice(),
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n100001\r\n",
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n3\r\na",
b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nContent-Length: 0\r\n\r\n",
] {
assert!(super::read_reply(&mut &bad[..]).is_err());
}
}
#[test]
fn explicit_server_rejects_header_injection_and_malformed_port() {
for value in ["host\r\nInjected: yes", "host:0", "host:99999", "http://host", "user@host", ""] {
assert!(Server::parse(value).is_err(), "{value:?}");
}
assert_eq!(Server::parse("[::1]:631").unwrap().authority(), "[::1]:631");
assert_eq!(Server::parse("print.example:8631").unwrap().authority(), "print.example:8631");
}
#[test]
fn class_submission_preserves_authority_user_and_numeric_job_id() {
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0, &[&group(2), &attr(0x21, "job-id", &42u32.to_be_bytes())]))]).unwrap();
let destination = super::Destination { name: "Studio".into(), is_class: true };
assert_eq!(super::submit_as_at(fake.endpoint(), &destination, b"pdf", &Job::default(), "artist").unwrap(), 42);
let request = fake.request().unwrap();
assert!(has(&request, b"POST /classes/Studio HTTP/1.1"));
assert!(has(&request, format!("Host: {}", fake.server.authority()).as_bytes()));
assert!(has(ipp_body(&request).unwrap(), format!("ipp://{}/classes/Studio", fake.server.authority()).as_bytes()));
assert!(has(ipp_body(&request).unwrap(), &attr(0x42, "requesting-user-name", b"artist")));
}
#[test]
fn uncertain_submission_never_tries_the_second_endpoint() {
let first = FakeCups::on_tcp(vec![]).unwrap();
let second = FakeCups::on_tcp(vec![]).unwrap();
let destination = super::Destination { name: "Studio".into(), is_class: false };
assert!(super::submit_at(&[first.server.clone(), second.server.clone()], &destination, b"pdf", &Job::default()).is_err());
let _ = first.request().unwrap();
assert!(second.requests.recv_timeout(Duration::from_millis(100)).is_err());
}
#[test]
fn queue_metadata_stays_with_its_printer_group() {
let bytes = ipp_reply(
0,
&[
&group(4),
&attr(0x41, "printer-info", b"Studio printer"),
&printer_name("First"),
&attr(0x23, "printer-state", &5u32.to_be_bytes()),
&attr(0x22, "printer-is-accepting-jobs", &[0]),
&group(4),
&printer_name("Second"),
],
);
let reply = super::parse_reply(&bytes).unwrap();
assert_eq!(reply.queues.len(), 2);
assert_eq!(reply.queues[0].info, "Studio printer");
assert_eq!(reply.queues[0].state, 5);
assert!(!reply.queues[0].accepting_jobs);
assert!(reply.queues[1].info.is_empty());
assert!(reply.queues[1].accepting_jobs);
}
#[test]
fn reply_identity_and_metadata_request_are_checked() {
let request = super::discovery_request(0x4002);
assert!(has(&request, b"printer-info"));
let mut reply = vec![1, 1, 0, 0];
reply.extend_from_slice(&request[4..8]);
reply.push(3);
assert!(super::validate_reply_identity(&request, &reply).is_ok());
reply[7] ^= 1;
assert!(super::validate_reply_identity(&request, &reply).is_err());
reply[4..8].copy_from_slice(&request[4..8]);
reply[0] = 9;
assert!(super::validate_reply_identity(&request, &reply).is_err());
}
#[test]
fn slow_reply_cannot_reset_the_absolute_deadline() {
let (client, mut peer) = std::os::unix::net::UnixStream::pair().unwrap();
let producer = std::thread::spawn(move || {
// Finite work and a joined handle: no abandoned timeout worker.
for _ in 0..20 {
if peer.write_all(b"x").is_err() {
break;
}
std::thread::sleep(Duration::from_millis(20));
}
});
let start = std::time::Instant::now();
let mut stream = super::Stream::Unix(client);
let mut reader = super::DeadlineReader { stream: &mut stream, end: start + Duration::from_millis(80) };
let mut bytes = [0; 20];
assert!(reader.read_exact(&mut bytes).is_err(), "trickle reads must not extend the absolute deadline");
drop(stream);
producer.join().unwrap();
assert!(start.elapsed() < Duration::from_secs(3));
}
#[test]
fn blocked_upload_obeys_the_same_absolute_deadline() {
let (client, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
let start = std::time::Instant::now();
let mut stream = super::Stream::Unix(client);
let mut writer = super::DeadlineReader { stream: &mut stream, end: start + Duration::from_millis(80) };
let chunk = [0u8; 64 * 1024];
let mut timed_out = false;
// A peer that never drains cannot turn each partial write into a fresh timeout budget.
for _ in 0..512 {
if writer.write_all(&chunk).is_err() {
timed_out = true;
break;
}
}
assert!(timed_out, "blocked upload must terminate without a reader");
assert!(start.elapsed() < Duration::from_secs(3));
}
#[test]
fn recorded_request_body_requires_complete_http_headers() {
assert!(ipp_body(b"POST / HTTP/1.1\r\n").is_none());
assert_eq!(ipp_body(b"POST / HTTP/1.1\r\n\r\nbody"), Some(b"body".as_slice()));
}
#[test]
fn named_destinations_encode_one_path_segment_on_both_wire_fields() {
for is_class in [false, true] {
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0, &[&group(2), &attr(0x21, "job-id", &42u32.to_be_bytes())]))]).unwrap();
let destination = super::Destination { name: "Office café%20?#".into(), is_class };
assert_eq!(super::submit_as_at(fake.endpoint(), &destination, b"pdf", &Job::default(), "artist").unwrap(), 42);
let kind = if is_class { "classes" } else { "printers" };
let path = format!("/{kind}/Office%20caf%C3%A9%2520%3F%23");
let request = fake.request().unwrap();
assert!(has(&request, format!("POST {path} HTTP/1.1").as_bytes()));
assert!(has(ipp_body(&request).unwrap(), format!("ipp://{}{path}", fake.server.authority()).as_bytes()));
}
}
#[test]
fn destination_path_rejects_routing_syntax_before_connecting() {
for name in ["", ".", "..", "../admin", "a/b", "a\\b", "a\r\nb", "a\0b"] {
let destination = super::Destination { name: name.into(), is_class: false };
assert!(super::destination_path(&destination).is_err(), "{name:?}");
}
let destination = super::Destination { name: "x".repeat(257), is_class: false };
assert!(super::destination_path(&destination).is_err());
}
#[test]
fn separate_queue_query_preserves_optional_discovery_errors() {
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0x0403, &[&group(1)]))]).unwrap();
assert!(super::queues_at(fake.endpoint(), true).is_err(), "authorization refusal is not an empty class list");
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0x0501, &[&group(1)]))]).unwrap();
assert!(super::queues_at(fake.endpoint(), true).unwrap().is_empty(), "unsupported class operation is absent");
let fake = FakeCups::on_tcp(vec![http_reply(&ipp_reply(0, &[&group(1), &group(4), &printer_name("Pool")]))]).unwrap();
let queues = super::queues_at(fake.endpoint(), true).unwrap();
assert_eq!(queues.len(), 1);
assert!(queues[0].is_class);
assert!(!queues[0].is_default, "default resolution is caller-owned for this API");
let request = fake.request().unwrap();
assert_eq!(&ipp_body(&request).unwrap()[..4], &[1, 1, 0x40, 0x05]);
}
#[test]
fn ipv6_endpoint_keeps_scope_for_resolution_and_escapes_wire_authority() {
assert_eq!(Server::parse("[::1]").unwrap().authority(), "[::1]:631");
assert_eq!(Server::parse("::1").unwrap().authority(), "[::1]:631");
let scoped = Server::parse("[fe80::1%en0]:8631").unwrap();
assert!(matches!(&scoped, Server::Named(host, 8631) if host == "fe80::1%en0"));
assert_eq!(scoped.authority(), "[fe80::1%25en0]:8631");
assert_eq!(Server::parse("fe80::1%en0:8631").unwrap().authority(), scoped.authority());
assert_eq!(Server::parse("fe80::1%en0").unwrap().authority(), "[fe80::1%25en0]:631");
assert!(Server::parse("[host]:631").is_err());
assert_eq!(super::connect(&Server::Named("/invalid".into(), 631)).err().unwrap().kind(), std::io::ErrorKind::InvalidInput);
for bad in ["[::1]junk", "[::1]:0", "[::1]:abc", "[fe80::1%]:631", "[fe80::1%x%y]:631", "host%zone"] {
assert!(Server::parse(bad).is_err(), "{bad}");
}
}
#[test]
fn long_printer_descriptions_are_not_limited_like_queue_names() {
let description = "Studio ".repeat(200);
let body = ipp_reply(0, &[&group(1), &group(4), &printer_name("Studio"), &attr(0x41, "printer-info", description.as_bytes())]);
let parsed = super::parse_reply(&body).unwrap();
assert_eq!(parsed.queues[0].info, description);
}
#[test]
fn destination_limit_is_explicit_and_never_silently_truncates() {
let mut body = vec![1, 1, 0, 0, 0, 0, 0, 1];
for index in 0..super::MAX_PRINTERS {
body.push(4);
body.extend(printer_name(&format!("Printer{index}")));
}
body.push(3);
assert_eq!(super::parse_reply(&body).unwrap().queues.len(), super::MAX_PRINTERS);
assert_eq!(body.pop(), Some(3));
body.push(4);
body.extend(printer_name("OneTooMany"));
body.push(3);
assert!(super::parse_reply(&body).err().unwrap().to_string().contains("too many CUPS destinations"));
}
#[test]
fn closed_unix_peer_keeps_its_buffered_reply_readable_with_a_deadline() {
let (client, mut peer) = std::os::unix::net::UnixStream::pair().unwrap();
let body = ipp_reply(0, &[&group(1), &group(4), &printer_name("Studio")]);
peer.write_all(&http_reply(&body)).unwrap();
drop(peer);
let mut stream = super::Stream::Unix(client);
let mut reader = super::DeadlineReader { stream: &mut stream, end: std::time::Instant::now() + Duration::from_secs(1) };
assert_eq!(super::read_reply(&mut reader).unwrap(), body);
let mut byte = [0];
assert_eq!(reader.read(&mut byte).unwrap(), 0);
reader.end = std::time::Instant::now();
assert_eq!(reader.read(&mut byte).unwrap_err().kind(), std::io::ErrorKind::TimedOut);
}
#[test]
fn stalled_unix_peer_still_fails_within_the_absolute_read_deadline() {
let (client, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
let start = std::time::Instant::now();
let mut stream = super::Stream::Unix(client);
let mut reader = super::DeadlineReader { stream: &mut stream, end: start + Duration::from_millis(80) };
let mut byte = [0];
let error = reader.read(&mut byte).unwrap_err();
assert!(matches!(error.kind(), std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock));
assert!(start.elapsed() < Duration::from_secs(3));
}
+4
View File
@@ -8,6 +8,10 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
/// Direct local-CUPS transport, independent of command-line spooler selection.
#[cfg(not(target_arch = "wasm32"))]
pub mod cups;
#[cfg(any(test, windows))]
mod progress;
#[cfg(any(test, windows))]
+143 -20
View File
@@ -470,6 +470,55 @@ fn linked_file(item: &[u8], at: usize) -> Result<LinkedFile> {
Ok(out)
}
/// Header of an embedded (`liFD`) linked-layer item, without reading its payload.
/// Offsets are relative to the item (not its enclosing eight-byte length field).
/// A deferred reader can supply just the header, then validate the payload range
/// against the full record length before reading those bytes.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct EmbeddedFileHeader {
/// Lossy UTF-8 identifier, matching Photoshop metadata display semantics.
pub uuid: String,
/// Lossy UTF-16 filename with trailing NULs removed.
pub name: String,
/// Start of the payload within the item.
pub data_offset: usize,
/// Declared payload length; the payload need not be resident.
pub data_len: usize,
}
impl EmbeddedFileHeader {
/// Borrow the payload only when the supplied complete item contains it.
pub fn payload<'a>(&self, item: &'a [u8]) -> Option<&'a [u8]> {
item.get(self.data_offset..self.data_offset.checked_add(self.data_len)?)
}
}
/// Read an embedded item's header from a possibly partial/deferred item buffer.
/// This deliberately does not require its declared payload to be present. A malformed
/// header or a non-embedded item is an error, not an empty embedded file. Callers walking
/// framed records may continue to the next record after such an error.
/// Ported from PhotoCraft's linked-item reader; record versions remain forward-compatible.
pub fn embedded_file_header(item: &[u8]) -> Result<EmbeddedFileHeader> {
let mut r = Reader::new(item);
let kind = r.array::<4>()?;
let _version = r.u32()?;
let uuid = String::from_utf8_lossy(&read_pascal(&mut r, 1)?).into_owned();
// A filename is metadata, never an unbounded allocation. Check before decoding.
if r.clone().u32()? > 32_768 {
return Err(PsdError::LimitExceeded("linked filename exceeds 32768 UTF-16 units"));
}
let name = UnicodeString::read(&mut r)?.to_string_lossy();
r.skip(8)?; // file type and creator
let data_len = usize::try_from(r.u64()?).map_err(|_| PsdError::LimitExceeded("linked payload exceeds address space"))?;
if r.u8()? != 0 {
crate::descriptor::VersionedDescriptor::read(&mut r)?;
}
if kind != *b"liFD" {
return Err(PsdError::invalid("linked item is not embedded"));
}
Ok(EmbeddedFileHeader { uuid, name, data_offset: r.pos(), data_len })
}
/// The four-character file type Photoshop records for an embedded file, from its first bytes:
/// `8BPS` (`8BPB` for a PSB), `PNGf`, `JPEG`, `TIFF`, `GIFf`, or four spaces.
pub fn file_type(bytes: &[u8]) -> [u8; 4] {
@@ -519,7 +568,29 @@ pub struct LinkedRecord<'a> {
pub raw: &'a [u8],
}
impl LinkedRecord<'_> {
impl<'a> LinkedRecord<'a> {
/// The complete item, excluding framing and padding; absent for a damaged tail.
pub fn item(&self) -> Option<&'a [u8]> {
framed_record(self.raw).map(|(item, _)| item)
}
/// Copy this complete record under a new ID, leaving the payload byte-identical.
/// Selection policy belongs to the caller; malformed tails cannot be copied.
pub fn copy_with_uuid(&self, new_uuid: &str) -> Option<Vec<u8>> {
let item = self.item()?;
let old_end = 9usize.checked_add(usize::from(*item.get(8)?))?;
let new_len = u8::try_from(new_uuid.len()).ok()?;
let mut copy = item.get(..8)?.to_vec();
copy.push(new_len);
copy.extend_from_slice(new_uuid.as_bytes());
copy.extend_from_slice(item.get(old_end..)?);
let mut out = Vec::with_capacity(copy.len() + 11);
out.put_u64(copy.len() as u64);
out.extend(copy);
out.resize(out.len().next_multiple_of(4), 0);
Some(out)
}
/// The unique id as text, when it is readable and valid UTF-8.
pub fn uuid_str(&self) -> Option<&str> {
std::str::from_utf8(self.uuid?).ok()
@@ -545,17 +616,26 @@ fn record_uuid(item: &[u8]) -> Option<&[u8]> {
/// The records of a linked layer block's data, in order, each with its unique id when its header
/// is readable. A tail that is no complete record is returned as one record without an id.
pub fn linked_records(data: &[u8]) -> Vec<LinkedRecord<'_>> {
let mut out = Vec::new();
iter_linked_records(data).collect()
}
/// Stream the same raw views as [`linked_records`] without allocating a record list.
/// Complete frames with malformed inner headers do not hide subsequent frames;
/// an incomplete tail is yielded once with no identifier.
pub fn iter_linked_records(data: &[u8]) -> impl Iterator<Item = LinkedRecord<'_>> {
let mut rest = data;
while !rest.is_empty() {
std::iter::from_fn(move || {
if rest.is_empty() {
return None;
}
let Some((item, raw)) = framed_record(rest) else {
out.push(LinkedRecord { uuid: None, raw: rest });
break;
let tail = rest;
rest = &[];
return Some(LinkedRecord { uuid: None, raw: tail });
};
out.push(LinkedRecord { uuid: record_uuid(item), raw });
rest = rest.get(raw.len()..).unwrap_or_default();
}
out
Some(LinkedRecord { uuid: record_uuid(item), raw })
})
}
/// The unique ids of every record of a linked layer block's data that has a readable one.
@@ -653,18 +733,7 @@ pub fn contains_linked_record(data: &[u8], record: &[u8]) -> bool {
/// field and padding; the rest of the record (embedded, external or alias data) is kept.
pub fn copy_linked_record(data: &[u8], uuid: &str, new_uuid: &str) -> Option<Vec<u8>> {
let record = linked_records(data).into_iter().find(|r| r.uuid == Some(uuid.as_bytes()))?;
let (item, _) = framed_record(record.raw)?;
let old_end = 9usize.checked_add(usize::from(*item.get(8)?))?;
let new_len = u8::try_from(new_uuid.len()).ok()?;
let mut copy = item.get(..8)?.to_vec();
copy.push(new_len);
copy.extend_from_slice(new_uuid.as_bytes());
copy.extend_from_slice(item.get(old_end..)?);
let mut out = Vec::with_capacity(copy.len() + 11);
out.put_u64(copy.len() as u64);
out.extend(copy);
out.resize(out.len().next_multiple_of(4), 0);
Some(out)
record.copy_with_uuid(new_uuid)
}
impl PsdFile {
@@ -1111,3 +1180,57 @@ mod tests {
assert!(u64::from(w) * u64::from(h) <= MAX_BAKE_PIXELS);
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod embedded_header_tests {
use super::*;
#[test]
fn headers_do_not_require_resident_payload() {
let data = encode_embedded_file("id", "a.psd", b"payload");
let record = iter_linked_records(&data).next().unwrap();
let item = record.item().unwrap();
let header = embedded_file_header(item).unwrap();
assert_eq!(header.uuid, "id");
assert_eq!(header.name, "a.psd");
assert_eq!(header.payload(item), Some(&b"payload"[..]));
assert_eq!(embedded_file_header(&item[..header.data_offset]).unwrap(), header);
assert_eq!(header.payload(&item[..header.data_offset]), None);
for n in 0..header.data_offset {
assert!(embedded_file_header(&item[..n]).is_err());
}
}
#[test]
fn filename_limits_and_lossy_metadata_are_preserved() {
let data = encode_embedded_file("x", &"a".repeat(32767), b"");
let item = iter_linked_records(&data).next().unwrap().item().unwrap();
assert_eq!(embedded_file_header(item).unwrap().name.len(), 32767);
let data = encode_embedded_file("x", &"a".repeat(32768), b"");
assert!(embedded_file_header(iter_linked_records(&data).next().unwrap().item().unwrap()).is_err());
let data = encode_embedded_file("x", "y", b"payload");
let mut item = iter_linked_records(&data).next().unwrap().item().unwrap().to_vec();
item[9] = 0xff;
item[14..16].copy_from_slice(&0xd800u16.to_be_bytes());
let h = embedded_file_header(&item).unwrap();
assert_eq!(h.uuid, "\u{fffd}");
assert_eq!(h.name, "\u{fffd}");
item[0..4].copy_from_slice(b"liFE");
assert!(embedded_file_header(&item).is_err());
}
#[test]
fn malformed_inner_records_do_not_hide_later_files() {
let mut data = vec![0; 8]; // A complete empty item, not a truncated frame.
data.extend(encode_embedded_file("wanted", "x", b"ok"));
data.extend([1, 2, 3]); // Incomplete tail retained, never interpreted as an item.
let records: Vec<_> = iter_linked_records(&data).collect();
assert_eq!(records, linked_records(&data));
assert!(embedded_file_header(records[0].item().unwrap()).is_err());
let item = records[1].item().unwrap();
assert_eq!(embedded_file_header(item).unwrap().payload(item), Some(&b"ok"[..]));
assert_eq!(records[2].item(), None);
assert_eq!(records[2].raw, &[1, 2, 3]);
}
}
+4 -3
View File
@@ -8,9 +8,10 @@ no `unsafe`, builds for `wasm32-unknown-unknown`).
The optional `av1-large-encode` feature exposes `LargeEncoder`, a tiled rav1e-backed encoder for
8-bit 4:2:0 frames up to 8192 samples per side. Use it when the clean-room `Encoder`'s one-tile
limits (4096 samples per side and 2304 superblocks) would reject the frame. It supports constant
quantizer rate control and emits one low-latency packet per input frame. The fallback is native
only; the clean-room encoder remains available without the feature and supports 8- and 10-bit
input.
quantizer rate control. `push` returns packets available so far, which can be empty while frames
are buffered; `finish` returns delayed packets. Each packet includes its input frame number for
matching durations. The fallback is native only; the clean-room encoder remains available without
the feature and supports 8- and 10-bit input.
## What is implemented
+122 -8
View File
@@ -12,6 +12,14 @@ pub struct LargeEncoder {
width: usize,
height: usize,
seq_header: Option<Vec<u8>>,
finished: bool,
}
/// An encoded frame and the number of the input frame it represents.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BufferedPacket {
pub input_frame_number: u64,
pub packet: Packet,
}
impl LargeEncoder {
@@ -50,11 +58,13 @@ impl LargeEncoder {
ec.max_key_frame_interval = cfg.keyint.clamp(1, 120) as u64;
ec.tiles = std::thread::available_parallelism().map_or(4, |n| n.get()).clamp(2, 16);
let ctx = Config::new().with_encoder_config(ec).new_context().map_err(|e| Error::InvalidConfig(format!("rav1e: {e}")))?;
Ok(Self { ctx, width: cfg.width as usize, height: cfg.height as usize, seq_header: None })
Ok(Self { ctx, width: cfg.width as usize, height: cfg.height as usize, seq_header: None, finished: false })
}
/// Encodes one frame. The frame planes must match the configured 4:2:0 dimensions.
pub fn encode_with_key(&mut self, frame: &Frame<'_>, force_key: bool) -> Result<Packet, Error> {
fn submit(&mut self, frame: &Frame<'_>, force_key: bool) -> Result<(), Error> {
if self.finished {
return Err(Error::InvalidFrame("AV1 encoder was already finished".into()));
}
if frame.y_stride < self.width
|| frame.uv_stride < self.width / 2
|| frame.y.len() < frame.y_stride.saturating_mul(self.height)
@@ -70,14 +80,54 @@ impl LargeEncoder {
let params =
FrameParameters { frame_type_override: if force_key { FrameTypeOverride::Key } else { FrameTypeOverride::No }, ..Default::default() };
self.ctx.send_frame((input, params)).map_err(|e| Error::InvalidFrame(format!("rav1e: {e}")))?;
Ok(())
}
fn packet(&mut self, packet: rav1e::prelude::Packet<u8>) -> Result<BufferedPacket, Error> {
let (data, seq) = sample_data(&packet.data)?;
if self.seq_header.is_none() {
self.seq_header = seq;
}
Ok(BufferedPacket { input_frame_number: packet.input_frameno, packet: Packet { data, keyframe: packet.frame_type == FrameType::KEY } })
}
fn drain(&mut self) -> Result<Vec<BufferedPacket>, Error> {
let mut packets = Vec::new();
loop {
match self.ctx.receive_packet() {
Ok(packet) => packets.push(self.packet(packet)?),
Err(rav1e::prelude::EncoderStatus::Encoded) => {}
Err(rav1e::prelude::EncoderStatus::NeedMoreData) if !self.finished => return Ok(packets),
Err(rav1e::prelude::EncoderStatus::LimitReached) if self.finished => return Ok(packets),
Err(e) => return Err(Error::InvalidFrame(format!("rav1e: {e}"))),
}
}
}
/// Submit a frame and return all packets available now, which may be empty while the encoder
/// buffers input. Call [`Self::finish`] after the last frame to retrieve delayed packets.
pub fn push(&mut self, frame: &Frame<'_>, force_key: bool) -> Result<Vec<BufferedPacket>, Error> {
self.submit(frame, force_key)?;
self.drain()
}
/// Finish the stream and return its remaining packets. Repeated calls return no packets.
pub fn finish(&mut self) -> Result<Vec<BufferedPacket>, Error> {
if !self.finished {
self.ctx.send_frame(None).map_err(|e| Error::InvalidFrame(format!("rav1e: {e}")))?;
self.finished = true;
}
self.drain()
}
/// Encodes one frame if a packet is immediately available. The input is accepted even if
/// rav1e needs more frames and this returns an error; new callers should use [`Self::push`].
pub fn encode_with_key(&mut self, frame: &Frame<'_>, force_key: bool) -> Result<Packet, Error> {
self.submit(frame, force_key)?;
loop {
match self.ctx.receive_packet() {
Ok(packet) => {
let (data, seq) = sample_data(&packet.data)?;
if self.seq_header.is_none() {
self.seq_header = seq;
}
return Ok(Packet { data, keyframe: packet.frame_type == FrameType::KEY });
return Ok(self.packet(packet)?.packet);
}
Err(rav1e::prelude::EncoderStatus::Encoded) => continue,
Err(rav1e::prelude::EncoderStatus::NeedMoreData | rav1e::prelude::EncoderStatus::LimitReached) => {
@@ -153,3 +203,67 @@ fn sample_data(data: &[u8]) -> Result<(Vec<u8>, Option<Vec<u8>>), Error> {
}
Ok((sample, sequence))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn buffered_frames_are_returned_with_input_numbers_and_finish_drains() {
let cfg = EncoderConfig::new(64, 48, 24, 1);
let mut encoder = LargeEncoder::with_speed(&cfg, 10).unwrap();
assert!(encoder.av1c().is_none());
let y = vec![96; 64 * 48];
let uv = vec![128; 32 * 24];
let frame = Frame { y: &y, u: &uv, v: &uv, y_stride: 64, uv_stride: 32 };
let mut packets = Vec::new();
for i in 0..4 {
packets.extend(encoder.push(&frame, i == 2).unwrap());
}
packets.extend(encoder.finish().unwrap());
assert_eq!(packets.iter().map(|p| p.input_frame_number).collect::<Vec<_>>(), [0, 1, 2, 3]);
assert!(packets[0].packet.keyframe);
assert!(packets[2].packet.keyframe, "requested key frame");
assert!(encoder.av1c().is_some());
#[cfg(feature = "av1-decode")]
{
let mut decoder = crate::av1::decode::Decoder::with_threads(1);
let mut frames = Vec::new();
for packet in &packets {
frames.extend(decoder.decode(&packet.packet.data).unwrap());
}
frames.extend(decoder.flush_result().unwrap());
assert_eq!(frames.len(), 4);
assert!(frames.iter().all(|frame| (frame.width, frame.height) == (64, 48)));
}
assert!(encoder.finish().unwrap().is_empty());
assert!(encoder.push(&frame, false).is_err());
}
#[test]
fn a_large_frame_can_be_flushed_even_when_the_first_push_is_buffered() {
let cfg = EncoderConfig::new(4112, 16, 30, 1);
let mut encoder = LargeEncoder::with_speed(&cfg, 10).unwrap();
let y = vec![64; 4112 * 16];
let uv = vec![128; 2056 * 8];
let frame = Frame { y: &y, u: &uv, v: &uv, y_stride: 4112, uv_stride: 2056 };
let mut packets = encoder.push(&frame, false).unwrap();
packets.extend(encoder.finish().unwrap());
assert_eq!(packets.len(), 1);
assert_eq!(packets[0].input_frame_number, 0);
assert!(packets[0].packet.keyframe);
assert!(!packets[0].packet.data.is_empty());
assert!(encoder.av1c().is_some());
}
#[test]
fn invalid_frame_is_not_queued_and_empty_stream_finishes() {
let cfg = EncoderConfig::new(64, 48, 24, 1);
let mut encoder = LargeEncoder::with_speed(&cfg, 10).unwrap();
let short = [0; 1];
let frame = Frame { y: &short, u: &short, v: &short, y_stride: 64, uv_stride: 32 };
assert!(encoder.push(&frame, false).is_err());
assert!(encoder.finish().unwrap().is_empty());
assert!(encoder.av1c().is_none());
}
}
+1 -1
View File
@@ -23,7 +23,7 @@ mod writer;
#[cfg(all(feature = "av1-large-encode", not(target_arch = "wasm32")))]
mod large;
#[cfg(all(feature = "av1-large-encode", not(target_arch = "wasm32")))]
pub use large::LargeEncoder;
pub use large::{BufferedPacket, LargeEncoder};
use bitw::obu;
use craft_media::bitstream::BitWriter;