| |
| use mb3_dat::{Document, Limits, Version, World}; |
| use std::ffi::OsString; |
| use std::fmt; |
| use std::fs::{self, File, OpenOptions}; |
| use std::io::{self, BufRead, BufReader, Write}; |
| use std::path::{Path, PathBuf}; |
| use std::sync::atomic::{AtomicU64, Ordering}; |
|
|
| const HELP: &str = "nanobrush inspect INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush validate INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush convert INPUT OUTPUT --to txt|dat-201501280|dat-201512200 [--from auto|txt|dat] [--force] [LIMITS]\nLIMITS: --max-bytes N --max-items N --max-string-bytes N --max-owned-bytes N\nUse -- before positional paths beginning with a dash. TXT input is UTF-8; output has a BOM.\nExit: 0 success/help, 1 invalid data or I/O failure, 2 usage error.\n"; |
| #[derive(Debug)] |
| pub struct Error { |
| pub usage: bool, |
| message: String, |
| } |
| impl fmt::Display for Error { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.write_str(&self.message) |
| } |
| } |
| impl std::error::Error for Error {} |
| impl From<io::Error> for Error { |
| fn from(e: io::Error) -> Self { |
| fail(e.to_string()) |
| } |
| } |
| fn fail(message: impl Into<String>) -> Error { |
| Error { |
| usage: false, |
| message: message.into(), |
| } |
| } |
| fn usage(message: impl Into<String>) -> Error { |
| Error { |
| usage: true, |
| message: message.into(), |
| } |
| } |
| type Result<T> = std::result::Result<T, Error>; |
| #[derive(Clone, Copy)] |
| enum InputFormat { |
| Auto, |
| Txt, |
| Dat, |
| } |
| #[derive(Clone, Copy)] |
| enum To { |
| Txt, |
| Dat(Version), |
| } |
| struct Options { |
| command: String, |
| paths: Vec<PathBuf>, |
| from: InputFormat, |
| to: Option<To>, |
| force: bool, |
| limits: Limits, |
| } |
| fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> { |
| let mut args = args.into_iter(); |
| let command = args.next().ok_or_else(|| usage(HELP))?; |
| if command == "--help" || command == "-h" { |
| return Ok(None); |
| } |
| let command = command |
| .into_string() |
| .map_err(|_| usage("command must be UTF-8"))?; |
| if !matches!(command.as_str(), "inspect" | "validate" | "convert") { |
| return Err(usage("expected inspect, validate or convert; use --help")); |
| } |
| let mut options = Options { |
| command, |
| paths: Vec::new(), |
| from: InputFormat::Auto, |
| to: None, |
| force: false, |
| limits: Limits::default(), |
| }; |
| let mut positional = false; |
| let mut seen = std::collections::HashSet::new(); |
| while let Some(arg) = args.next() { |
| if !positional && arg == "--" { |
| positional = true; |
| continue; |
| } |
| if !positional && (arg == "--help" || arg == "-h") { |
| return Ok(None); |
| } |
| if !positional && arg.as_encoded_bytes().starts_with(b"-") { |
| let flag = arg.to_str().ok_or_else(|| usage("option must be UTF-8"))?; |
| if !seen.insert(flag.to_owned()) { |
| return Err(usage(format!("duplicate option {flag}"))); |
| } |
| if flag == "--force" { |
| options.force = true; |
| continue; |
| } |
| if !matches!( |
| flag, |
| "--from" |
| | "--to" |
| | "--max-bytes" |
| | "--max-items" |
| | "--max-string-bytes" |
| | "--max-owned-bytes" |
| ) { |
| return Err(usage(format!("unknown option {flag}"))); |
| } |
| let value = args |
| .next() |
| .ok_or_else(|| usage(format!("missing value for {flag}")))?; |
| let value = value |
| .to_str() |
| .ok_or_else(|| usage("option value must be UTF-8"))?; |
| match flag { |
| "--from" => { |
| options.from = match value { |
| "auto" => InputFormat::Auto, |
| "txt" => InputFormat::Txt, |
| "dat" => InputFormat::Dat, |
| _ => return Err(usage("--from requires auto, txt or dat")), |
| } |
| } |
| "--to" => { |
| options.to = Some(match value { |
| "txt" => To::Txt, |
| "dat-201501280" => To::Dat(Version::V201501280), |
| "dat-201512200" => To::Dat(Version::V201512200), |
| _ => { |
| return Err(usage("--to requires txt, dat-201501280 or dat-201512200")); |
| } |
| }) |
| } |
| _ => { |
| if value.is_empty() || !value.bytes().all(|b| b.is_ascii_digit()) { |
| return Err(usage("limits must be nonnegative decimal integers")); |
| } |
| let n = value |
| .parse::<usize>() |
| .map_err(|_| usage("limit outside platform usize range"))?; |
| match flag { |
| "--max-bytes" => options.limits.max_bytes = n, |
| "--max-items" => options.limits.max_items = n, |
| "--max-string-bytes" => options.limits.max_string_bytes = n, |
| _ => options.limits.max_owned_bytes = n, |
| } |
| } |
| } |
| } else { |
| options.paths.push(arg.into()); |
| } |
| } |
| if options.command == "convert" { |
| if options.paths.len() != 2 || options.to.is_none() { |
| return Err(usage("convert requires INPUT OUTPUT --to FORMAT")); |
| } |
| } else if options.paths.len() != 1 || options.to.is_some() || options.force { |
| return Err(usage( |
| "inspect/validate require one INPUT and no --to/--force", |
| )); |
| } |
| Ok(Some(options)) |
| } |
| struct Input { |
| world: World, |
| version: Option<Version>, |
| } |
| fn load(path: &Path, from: InputFormat, limits: &Limits) -> Result<Input> { |
| let mut file = |
| BufReader::new(File::open(path).map_err(|e| fail(format!("{}: {e}", path.display())))?); |
| let dat = match from { |
| InputFormat::Dat => true, |
| InputFormat::Txt => false, |
| InputFormat::Auto => file.fill_buf()?.starts_with(b"Mb3World"), |
| }; |
| if dat { |
| let d = |
| mb3_dat::read(file, limits).map_err(|e| fail(format!("{}: {e}", path.display())))?; |
| Ok(Input { |
| world: d.world, |
| version: Some(d.version), |
| }) |
| } else { |
| let world = |
| mb3_txt::read(file, limits).map_err(|e| fail(format!("{}: {e}", path.display())))?; |
| Ok(Input { |
| world, |
| version: None, |
| }) |
| } |
| } |
| static NEXT_TEMP: AtomicU64 = AtomicU64::new(0); |
| struct Temp(PathBuf); |
| impl Drop for Temp { |
| fn drop(&mut self) { |
| let _ = fs::remove_file(&self.0); |
| } |
| } |
| fn same_file(a: &fs::Metadata, b: &fs::Metadata) -> bool { |
| #[cfg(unix)] |
| { |
| use std::os::unix::fs::MetadataExt; |
| a.dev() == b.dev() && a.ino() == b.ino() |
| } |
| #[cfg(not(unix))] |
| { |
| let _ = (a, b); |
| false |
| } |
| } |
| fn save(input: &Path, output: &Path, bytes: &[u8], force: bool) -> Result<()> { |
| let parent = output |
| .parent() |
| .filter(|p| !p.as_os_str().is_empty()) |
| .unwrap_or(Path::new(".")); |
| let parent = fs::canonicalize(parent)?; |
| let name = output |
| .file_name() |
| .ok_or_else(|| fail("output requires a filename"))?; |
| let output = parent.join(name); |
| let input_meta = fs::metadata(input)?; |
| match fs::symlink_metadata(&output) { |
| Ok(meta) => { |
| if !meta.is_file() || meta.file_type().is_symlink() { |
| return Err(fail( |
| "output must be a regular file, not a symlink or directory", |
| )); |
| } |
| if same_file(&input_meta, &meta) |
| || fs::canonicalize(input)? == fs::canonicalize(&output)? |
| { |
| return Err(fail( |
| "input and output must be different files (including hard links)", |
| )); |
| } |
| if !force { |
| return Err(fail("output exists; use --force to replace it")); |
| } |
| } |
| Err(e) if e.kind() == io::ErrorKind::NotFound => (), |
| Err(e) => return Err(e.into()), |
| } |
| let mut created = None; |
| for _ in 0..100 { |
| let path = parent.join(format!( |
| ".nanobrush-{}-{}.tmp", |
| std::process::id(), |
| NEXT_TEMP.fetch_add(1, Ordering::Relaxed) |
| )); |
| let mut options = OpenOptions::new(); |
| options.create_new(true).write(true); |
| #[cfg(unix)] |
| { |
| use std::os::unix::fs::OpenOptionsExt; |
| options.mode(0o600); |
| } |
| match options.open(&path) { |
| Ok(file) => { |
| created = Some((Temp(path), file)); |
| break; |
| } |
| Err(e) if e.kind() == io::ErrorKind::AlreadyExists => (), |
| Err(e) => return Err(e.into()), |
| } |
| } |
| let (temp, mut file) = |
| created.ok_or_else(|| fail("cannot allocate a unique output temporary file"))?; |
| file.write_all(bytes)?; |
| file.sync_all()?; |
| drop(file); |
| publish(temp, &output, force) |
| } |
| fn publish(temp: Temp, output: &Path, force: bool) -> Result<()> { |
| if force { |
| fs::rename(&temp.0, output)?; |
| } else { |
| fs::hard_link(&temp.0, output)?; |
| } |
| Ok(()) |
| } |
| |
| |
| pub fn run(args: impl IntoIterator<Item = OsString>, stdout: &mut dyn Write) -> Result<()> { |
| let Some(o) = parse(args)? else { |
| stdout.write_all(HELP.as_bytes())?; |
| return Ok(()); |
| }; |
| let input = load(&o.paths[0], o.from, &o.limits)?; |
| match o.command.as_str() { |
| "inspect" => { |
| let w = &input.world; |
| let planes: usize = w.brushes.iter().map(|b| b.planes.len()).sum(); |
| let polygons: usize = w |
| .brushes |
| .iter() |
| .flat_map(|b| &b.planes) |
| .map(|p| p.polygon.as_ref().map_or(0, Vec::len)) |
| .sum(); |
| let anchors: usize = w.patches.iter().map(|p| p.anchors.len()).sum(); |
| let points: usize = w |
| .patches |
| .iter() |
| .map(|p| p.computed.as_ref().map_or(0, |c| c.points.len())) |
| .sum(); |
| let normals: usize = w |
| .patches |
| .iter() |
| .map(|p| p.computed.as_ref().map_or(0, |c| c.normals.len())) |
| .sum(); |
| let version = input |
| .version |
| .map_or("null".into(), |v| (v as u32).to_string()); |
| writeln!( |
| stdout, |
| "{{\"format\":\"{}\",\"dat_version\":{},\"computed\":{},\"brushes\":{},\"planes\":{},\"patches\":{},\"string_properties\":{},\"uv_properties\":{},\"polygon_vertices\":{},\"anchors\":{},\"points\":{},\"normals\":{}}}", |
| if input.version.is_some() { |
| "mb3dat" |
| } else { |
| "mb3txt" |
| }, |
| version, |
| w.computed, |
| w.brushes.len(), |
| planes, |
| w.patches.len(), |
| w.string_properties.len(), |
| w.uv_properties.len(), |
| polygons, |
| anchors, |
| points, |
| normals |
| )?; |
| } |
| "validate" => writeln!( |
| stdout, |
| "valid: {}", |
| if input.version.is_some() { |
| "mb3dat" |
| } else { |
| "mb3txt" |
| } |
| )?, |
| _ => { |
| let bytes = match o.to.ok_or_else(|| usage("missing --to"))? { |
| To::Txt => { |
| mb3_txt::encode(&input.world, &o.limits).map_err(|e| fail(e.to_string()))? |
| } |
| To::Dat(version) => mb3_dat::encode( |
| &Document { |
| version, |
| world: input.world, |
| }, |
| &o.limits, |
| ) |
| .map_err(|e| fail(e.to_string()))?, |
| }; |
| save(&o.paths[0], &o.paths[1], &bytes, o.force)?; |
| } |
| } |
| Ok(()) |
| } |
| #[cfg(test)] |
| mod tests; |
|
|
