use serde::{Deserialize, Serialize};
use crate::chunk::TransferChunks;
use crate::error::{BlobError, Result};
use crate::hash::Hash;
use crate::wire::WIRE_VERSION;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Manifest {
pub version: u16,
pub id: String,
pub filename: Option<String>,
pub total_len: u64,
pub chunk_size: u32,
pub root: Hash,
pub created_ms: i64,
}
impl Manifest {
pub fn validate(&self, max_blob_size: u64) -> Result<()> {
if self.version != WIRE_VERSION {
return Err(BlobError::UnsupportedVersion(self.version));
}
validate_id(&self.id)?;
TransferChunks::validate_chunk_size(self.chunk_size)?;
if self.total_len > max_blob_size {
return Err(BlobError::InvalidManifest(format!(
"total_len {} exceeds the configured max blob size {max_blob_size}",
self.total_len
)));
}
Ok(())
}
pub fn chunks(&self) -> Result<TransferChunks> {
TransferChunks::new(self.chunk_size, self.total_len)
}
pub fn suggested_filename(&self) -> Option<String> {
let raw = self.filename.as_deref()?;
let name = std::path::Path::new(raw)
.components()
.filter_map(|c| match c {
std::path::Component::Normal(s) => s.to_str(),
_ => None,
})
.next_back()?;
if name.is_empty() {
None
} else {
Some(name.to_string())
}
}
}
pub(crate) fn validate_id(id: &str) -> Result<()> {
let ok = !id.is_empty()
&& id.len() <= 200
&& id != ".."
&& !id.starts_with('@')
&& !id.contains(['/', '\\', '*', '?', '#', '$'])
&& !id.chars().any(char::is_whitespace);
if ok {
Ok(())
} else {
Err(BlobError::InvalidManifest(format!(
"id {id:?} is not a valid single key segment"
)))
}
}
#[derive(Debug, Clone)]
pub struct BlobSpec {
pub(crate) id: String,
pub(crate) filename: Option<String>,
pub(crate) chunk_size: u32,
pub(crate) created_ms: i64,
}
impl BlobSpec {
pub fn new(id: impl Into<String>) -> Self {
BlobSpec {
id: id.into(),
filename: None,
chunk_size: crate::chunk::DEFAULT_CHUNK_SIZE,
created_ms: 0,
}
}
pub fn filename(mut self, filename: impl Into<String>) -> Self {
self.filename = Some(filename.into());
self
}
pub fn chunk_size(mut self, bytes: u32) -> Self {
self.chunk_size = bytes;
self
}
pub fn created_ms(mut self, ms: i64) -> Self {
self.created_ms = ms;
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::chunk::DEFAULT_CHUNK_SIZE;
fn manifest() -> Manifest {
Manifest {
version: WIRE_VERSION,
id: "abc".into(),
filename: Some("f.bin".into()),
total_len: DEFAULT_CHUNK_SIZE as u64 * 2 + 100,
chunk_size: DEFAULT_CHUNK_SIZE,
root: Hash::of(b"whatever"),
created_ms: 42,
}
}
#[test]
fn valid_manifest_passes() {
let m = manifest();
m.validate(u64::MAX).unwrap();
assert_eq!(m.chunks().unwrap().count(), 3);
}
#[test]
fn wrong_version_rejected() {
let m = Manifest {
version: 3,
..manifest()
};
assert!(matches!(
m.validate(u64::MAX),
Err(BlobError::UnsupportedVersion(3))
));
}
#[test]
fn bad_chunk_size_rejected_not_clamped() {
for bad in [0u32, 1024, DEFAULT_CHUNK_SIZE + 1, u32::MAX] {
let m = Manifest {
chunk_size: bad,
..manifest()
};
assert!(m.validate(u64::MAX).is_err(), "chunk_size {bad}");
}
}
#[test]
fn oversized_blob_rejected() {
let m = Manifest {
total_len: 1024 * 1024 + 1,
..manifest()
};
assert!(m.validate(1024 * 1024).is_err());
}
#[test]
fn bad_ids_rejected() {
for bad in [
"",
"a/b",
"a*",
"a?x",
"..",
"a b",
"@verbatim",
"a\\b",
"@",
] {
let m = Manifest {
id: bad.into(),
..manifest()
};
assert!(m.validate(u64::MAX).is_err(), "id {bad:?}");
}
}
#[test]
fn leading_at_ids_would_be_unservable() {
let pattern: zenoh::key_expr::KeyExpr = "p/**".try_into().unwrap();
let verbatim: zenoh::key_expr::KeyExpr = "p/@id/manifest".try_into().unwrap();
let ordinary: zenoh::key_expr::KeyExpr = "p/x@y/manifest".try_into().unwrap();
assert!(
!pattern.intersects(&verbatim),
"if this ever passes, the leading-@ id rule can be relaxed"
);
assert!(pattern.intersects(&ordinary));
assert!(validate_id("@id").is_err());
assert!(validate_id("x@y").is_ok());
}
#[test]
fn suggested_filename_is_traversal_safe() {
let cases = [
(Some("report.pcap"), Some("report.pcap")),
(Some("/etc/passwd"), Some("passwd")),
(Some("../../x.bin"), Some("x.bin")),
(Some("a/b/c.txt"), Some("c.txt")),
(Some(".."), None),
(Some(""), None),
(None, None),
];
for (input, expected) in cases {
let m = Manifest {
filename: input.map(String::from),
..manifest()
};
assert_eq!(m.suggested_filename().as_deref(), expected, "{input:?}");
}
}
}