mm(1): updates to use new unveil api

CONTRIBUTING

@@ -1,29 +1,26 @@
 Make sure to read our code of conduct in the CONDUCT file.
 
-
-Copyright Information
-=====================
-
-When editing a file, create a copyright statement correlated to your
-identity so that it is easier to keep track of who has touched what file.
-Pseudonymous contributions are welcome (and encouraged). Place new copyright
-information below existing copyright information. If there is an existing
-copyright statement:
+When contributing a pull request to the main branch, please sign your commits
+with a PGP key and add your name and the year to the bottom of the list of
+copyright holders for the file. For example, an existing copyright header might
+read:
 
  * Copyright (c) 2022–2023 Emma Tebibyte <emma@tebibyte.media>
 
-you would add your name below it like this:
+You would add your name below it like this:
 
  * Copyright (c) 2022–2023 Emma Tebibyte <emma@tebibyte.media>
  * Copyright (c) 20XX Your Name <your e-mail address or website>
 
+We accept contributions from people using aliases.
+
 Only list years in which you modified the source file. For example:
 
  * Copyright (c) 2020–2021, 2023 Your Name <your-address@example.com>
 
 This header shows that “Your Name” worked on this source file in 2020, 2021, and
-2023. Please use the en dash (“–”, U+2013) to separate consecutive years in the
-copyright notice.
+2023. Please use the en dash (“–”) to separate the years in the copyright
+notice.
 
 If you are contributing a new file, please prepend the following license header
 text to it, replacing the proper text on the copyright line:
@@ -95,10 +92,6 @@ notice:
  *     USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
-Style
-=====
-
 Make sure lines never exceed 80 columns in width when using four-character
 indentation steps. This helps contributors with smaller screens, those using
 side-by-side editor windows or panes, and those who have no text wrapping in
@@ -111,13 +104,8 @@ style guide for the usage text’s output format [0].
 If committing a new utility, please include tests and documentation (see
 tests/ and docs/) for the new tool.
 
-Committing
-==========
-
-When contributing to Bonsai, please sign your commit with a PGP key and create
-the commit with an identity which can be easily contacted.
-
-Format commit messages following these guidelines:
+If committing a new source file, format the commit message following these
+guidelines:
 
 $ git commit -m 'tool(1): add feature x'
 
@@ -143,13 +131,7 @@ $ git commit -m 'tool(1): fix #42 & add feature x'
 
 Commit messages should be written in the present tense.
 
-
-References
-==========
-
 [0] <http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style>
-
-
 --
 This work © 2023–2024 by Emma Tebibyte is licensed under CC BY-SA 4.0. To view a
 copy of this license, visit <http://creativecommons.org/licenses/by-sa/4.0/>

Makefile

@@ -22,9 +22,9 @@ OS_INCLUDE != test -e include/$(OS).mk && printf 'include/$(OS).mk\n' \
 	|| printf '/dev/null\n'
 
 # normalized prefix
-PREFIX_N != realpath $(PREFIX)
+PREFIX_N != dirname $(PREFIX)/.
 MANDIR != test $(PREFIX_N) = / && printf '/usr/share/man\n' \
-	|| printf '$(PREFIX_N)/man\n'
+	|| printf '/share/man\n'
 SYSEXITS != printf '\043include <sysexits.h>\n' | cpp -M - | tr ' ' '\n' \
 	| sed -n 's/sysexits\.h//p' || printf 'include\n'
 
@@ -42,7 +42,7 @@ BIN = build/bin
 default: all test
 
 .PHONY: all
-all: dj false fop hru intcmp mm npc peek rpn scrut str strcmp swab true
+all: dj false fop hru intcmp mm npc rpn scrut str strcmp swab true
 
 # keep build/include until bindgen(1) has stdin support
 # https://github.com/rust-lang/rust-bindgen/issues/2703
@@ -54,9 +54,9 @@ clean:
 	rm -rf build dist
 
 dist: all docs
-	mkdir -p $(DESTDIR)/$(PREFIX_N)/bin $(DESTDIR)/$(MANDIR)/man1
-	cp build/bin/* $(DESTDIR)/$(PREFIX_N)/bin
-	cp build/docs/*.1 $(DESTDIR)/$(MANDIR)/man1
+	mkdir -p $(DESTDIR)/$(PREFIX)/bin $(DESTDIR)/$(PREFIX)/$(MANDIR)/man1
+	cp build/bin/* $(DESTDIR)/$(PREFIX)/bin
+	cp build/docs/*.1 $(DESTDIR)/$(PREFIX)/$(MANDIR)/man1
 
 .PHONY: install
 install: dist
@@ -95,7 +95,7 @@ build/o/libstrerror.rlib: build src/libstrerror.rs
 		src/libstrerror.rs
 
 build/o/libsysexits.rlib: build/include/sysexits.h
-	bindgen --default-macro-constant-type signed --use-core --formatter=none \
+	bindgen --fit-macro-constant-types --default-macro-constant-type unsigned --use-core --formatter=none \
 		build/include/sysexits.h | $(RUSTC) $(RUSTFLAGS) --crate-type lib -o $@ -
 
 # bandage solution until bindgen(1) gets stdin support
@@ -137,11 +137,6 @@ npc: build/bin/npc
 build/bin/npc: src/npc.c build
 	$(CC) $(CFLAGS) -o $@ src/npc.c
 
-.PHONY: peek
-peek: build/bin/peek
-build/bin/peek: src/peek.c build
-	$(CC) $(CFLAGS) -o $@ src/peek.c
-
 .PHONY: rpn
 rpn: build/bin/rpn
 build/bin/rpn: src/rpn.rs build rustlibs

README

@@ -1,28 +1,24 @@
 “Seek not to walk the path of the masters; seek what they sought.”
 – Matsuo Basho
 
-Bonsai’s Harakit is an alternative to the standard POSIX utilities that aims to
-be simpler, easier, and more powerful. These tools are the result of careful
-examination of the current state common Unix utilities, POSIX-compliant and
-otherwise, following frustrations with design decisions and implementation
-details. They represent a vision of accomplishing everyday use cases with tools
-that follow the Unix philosophy of “do one thing and do it well” without
-clinging to the past.
+The Bonsai harakit utilities are a replacement for standard POSIX utilities
+which aim to fill its niche while expanding on their capabilities. These new
+tools are the result of the careful examination of the current state of POSIX
+and Unix utilies. The Unix Philosophy of “do one thing and do it well” are their
+core but they avoid clinging to the past.
 
-The intent of Harakit is not to conform to or extend POSIX, like the GNU or BSD
-utilities do, but to invent new utilities to perform the same tasks in more
-intuitive ways. GNU and BSD extensions are convenient but often unhealthy,
-forgetting the purposes of the tools they extend, or building into existing
-utilities features that would be more useful as their own tools to be used
-anywhere. Other utility sets aim to provide a number of fully-featured
-programs to be used individually, Harakit utilities are meant to be easily
-composable and work together in pipelines.
+The era of the original Unix tools has been long and fruitful, but they have
+their flaws. This project originated from frustrations with the way certain
+tools work and how other projects that extend POSIX don’t make anything better.
+
+This project will not follow in the footsteps of GNU; extensions of POSIX will
+not be found here. GNU extensions are a gateway to the misuse of the shell. The
+harakit utilities will intentionally discourage use of the shell for purposes
+beyond its scope.
 
 See docs/ for more on the specific utilities currently implemented.
 
-
 Building
-========
 
 Harakit utilities require a POSIX-compliant environment to compile, including a
 C compiler and preprocessor (cc(1) and cpp(1) by default), an edition 2023 Rust
@@ -47,22 +43,7 @@ To remove all build and distributable files:
 
 $ make clean
 
-
-Contributing
-============
-
-See the CONTRIBUTING file for contribution guidelines.
-
-
-Community
-=========
-
-xmpp://bonsai@covenant.murderu.us
-irc://feeling.murderu.us/#bonsai
-
-
 Read More
-=========
 
 An Introduction to the Unix Shell
 <https://porkmail.org/era/unix/shell>
@@ -76,10 +57,6 @@ Master Foo Discourses on the Unix-Nature
 Shell Programming!
 <https://tldp.org/LDP/abs/html/why-shell.html>
 
-UNIX Style, or cat -v Considered Harmful
-<http://harmful.cat-v.org/cat-v/>
-
-
 --
 Copyright © 2023–2024 Emma Tebibyte <emma@tebibyte.media>
 Copyright © 2024 DTB <trinity@trinity.moe>

docs/peek.1

@@ -1,111 +0,0 @@
-.\" Copyright (c) 2023-2024 DTB <trinity@trinity.moe>
-.\" Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-.\"
-.\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
-.\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
-.\"
-.TH PEEK 1 2024-08-14 "Harakit X.X.X"
-.SH NAME
-peek \(en read from the standard input, furtively
-.\"
-.SH SYNOPSIS
-
-peek
-.RB [ -i ]
-.\"
-.SH DESCRIPTION
-
-Read input from the standard input with terminal echo disabled.
-.\"
-.SH OPTIONS
-
-.IP \fB-i\fP
-Allows input to come from sources other than terminals (pipes).
-.\"
-.SH DIAGNOSTICS
-
-In the event of an error, a debug message will be printed and the program will
-exit with the appropriate
-.BR sysexits.h (3)
-error code.
-
-In order to ensure the user\(cqs terminal is still usable after premature
-termination, the program attempts to handle the SIGINT signal; if it cannot,
-an error message is printed and execution continues. If the program is
-interrupted, it exits unsuccessfully without an error message.
-.\"
-.SH RATIONALE
-
-This tool was originally written to accept passwords in shell scripts as an
-extremely simple alternative to the GNU Privacy Guard project\(cqs
-.BR pinentry (1)
-utility.
-
-Accepting input without showing what is being typed is useful when keying in
-secrets in public settings or in places where surveillance cameras are
-installed.
-.\"
-.SH CAVEATS
-
-This program does nothing to prevent others from seeing the key presses input to
-a keyboard. It also does not protect against the sound of typing being analyzed
-to determine what was input without needing to see screen or keyboard.
-
-Accepting secrets in shell scripts is probably not advisable.
-
-On systems that support it, the
-.BR ioctl (2)
-command TIOCSTI can be used to insert characters into the standard input. This
-doesn't allow snooping but can be used for general mischief.
-.\"
-.SH EXAMPLES
-
-This is an
-.BR sh (1p)
-command line that hashes a given password. It uses
-.BR head (1p)
-to only accept one line of input,
-.BR xargs (1p)
-and
-.BR printf (1p)
-to strip the trailing newline,
-.BR htpasswd (1) 
-from Apache\(cqs utilities to hash the input with the bcrypt algorithm, and
-.BR cut (1p)
-to print only the resulting hash:
-
-.RS
-$ peek | head -n 1 | xargs printf '%s' | htpasswd -nBi _ | cut -d : -f 2
-.RE
-
-This is an
-.BR sh (1p)
-command line that allows a user to write blindly into a text file but displaying
-only written lines. Some writers have the habit of prematurely revising their 
-work and use tools with functionality similar to this to prevent it. 
-It uses
-.BR mm (1)
-to pipe the output of the program to both the standard error and the regular
-file writing.txt:
-
-.RS
-$ echo Input ^D to quit. && peek | mm -eo - >writing.txt
-.RE
-.\"
-.SH AUTHOR
-
-Written by DTB
-.MT trinity@trinity.moe
-.ME .
-.\"
-.SH COPYRIGHT
-
-Copyright \(co 2023-2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
-<https://gnu.org/licenses/gpl.html>.
-.\"
-.SH SEE ALSO
-.BR ioctl (2),
-.BR ioctl_tty (2),
-.BR read (1p),
-.BR sh (1p),
-.BR stty (1p)

src/false.c

@@ -8,12 +8,13 @@
  */
 
 #ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2) */
+#	include <unistd.h> /* NULL, pledge(2), unveil(2) */
 #endif
 
 int main(void) {
 #ifdef __OpenBSD__
-	pledge(NULL, NULL);
+	(void)pledge(NULL, NULL);
+	(void)unveil(NULL, NULL);
 #endif
 	return 1;
 }

src/fop.rs

@@ -18,8 +18,8 @@
 
 use std::{
 	env::args,
-	io::{ Read, stdin, stdout, Write },
-	process::{ Command, exit, Stdio },
+	io::{ Error, Read, Write, stdin, stdout },
+	process::{ Command, ExitCode, Stdio, exit },
 };
 
 extern crate getopt;
@@ -32,25 +32,36 @@ use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
-fn main() {
+fn err(argv0: &String, e: Error) {
+	eprintln!("{}: {}", argv0, e.strerror());
+}
+
+fn usage(argv0: &String) -> u8 {
+	eprintln!("Usage: {} [-d delimiter] index command [args...]", argv0);
+	EX_USAGE
+}
+
+fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
 	let mut d = '\u{1E}'.to_string(); /* ASCII record separator */
 	let mut optind = 1;
 
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio proc exec");
+		let promises = Promises::new("exec proc stdio unveil");
 		if let Err(e) = pledge(Some(promises), None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			exit(EX_OSERR);
+			err(&argv[0], e);
+			return ExitCode::from(EX_OSERR);
+		}
+
+		if let Err(e) = unveil(None, None) {
+			err(&argv[0], e);
+			return ExitCode::from(EX_OSERR);
 		}
 	}
 
-	let usage = format!(
-		"Usage: {} [-d delimiter] index command [args...]",
-		argv[0],
-	);
+	if argv.len() == 1 { return ExitCode::from(usage(&argv[0])); }
 
 	while let Some(opt) = argv.getopt("d:") {
 		match opt.opt() {
@@ -60,8 +71,7 @@ fn main() {
 				optind = opt.ind();
 			},
 			_ => {
-				eprintln!("{}", usage);
-				exit(EX_USAGE);
+				return ExitCode::from(usage(&argv[0]));
 			}
 		};
 	}
@@ -69,7 +79,7 @@ fn main() {
 	/* parse the specified index as a number we can use */
 	let index = argv[optind].parse::<usize>().unwrap_or_else(|e| {
 		eprintln!("{}: {}: {}", argv[0], argv[1], e);
-		exit(EX_DATAERR);
+		exit(EX_DATAERR.into());
 	});
 
 	/* index of the argv[0] for the operator command */
@@ -77,15 +87,14 @@ fn main() {
 
 	/* argv[0] of the operator command */
 	let operator = argv.get(command_arg).unwrap_or_else(|| {
-		eprintln!("{}", usage);
-		exit(EX_USAGE);
+		exit(usage(&argv[0]).into());
 	});
 
 	/* read entire standard input into memory */
 	let mut buf = String::new();
 	if let Err(e) = stdin().read_to_string(&mut buf) {
-		eprintln!("{}: {}", argv[0], e.strerror());
-		exit(EX_IOERR);
+		err(&argv[0], e);
+		exit(EX_IOERR.into());
 	};
 
 	/* split the buffer by the delimiter (by default, '\u{1E}') */
@@ -105,18 +114,14 @@ fn main() {
 		.stdout(Stdio::piped()) /* piped stdout to handle output ourselves */
 		.spawn()
 		.unwrap_or_else( |e| {
-			eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
-			exit(EX_UNAVAILABLE);
+			err(&argv[0], e);
+			exit(EX_UNAVAILABLE.into());
 		});
 
 	/* get field we want to pipe into spawned program */
 	let field = fields.get(index).unwrap_or_else(|| {
-		eprintln!(
-			"{}: {}: No such index in input",
-			argv[0],
-			index.to_string(),
-		);
-		exit(EX_DATAERR);
+		eprintln!("{}: {}: no such index in input", argv[0], index);
+		exit(EX_DATAERR.into());
 	});
 
 	/* get the stdin of the newly spawned program and feed it the field val */
@@ -126,8 +131,8 @@ fn main() {
 	}
 
 	let output = spawned.wait_with_output().unwrap_or_else(|e| {
-		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
-		exit(EX_IOERR);
+		err(&argv[0], e);
+		exit(EX_IOERR.into());
 	});
 
 	/* get the output with which the original field will be replaced */
@@ -143,8 +148,8 @@ fn main() {
 
 	/* convert the output of the program to UTF-8 */
 	let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
-		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
-		exit(EX_IOERR);
+		eprintln!("{}: {}", argv[0], e);
+		exit(EX_IOERR.into());
 	});
 
 	/* store the new field in the old fields vector */
@@ -154,7 +159,9 @@ fn main() {
 	stdout().write_all(
 		fields.join(&d.to_string()).as_bytes()
 	).unwrap_or_else(|e| {
-		eprintln!("{}: {}", argv[0], e.strerror());
-		exit(EX_IOERR);
+		err(&argv[0], e);
+		exit(EX_IOERR.into());
 	});
+
+	ExitCode::SUCCESS
 }

src/hru.rs

@@ -19,7 +19,7 @@
 use std::{
 	cmp::Ordering,
 	env::args,
-	io::{ stdin, stdout, Write },
+	io::{ Write, stdin, stdout },
 	process::{ ExitCode, exit },
 };
 
@@ -31,7 +31,7 @@ use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE, EX_USAGE };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
 /* list of SI prefixes */
 const LIST: [(u32, &str); 10] = [
@@ -47,6 +47,16 @@ const LIST: [(u32, &str); 10] = [
 	(30, "Q"), /* quetta */
 ];
 
+fn err(argv0: &String, message: String, code: Option<u8>) -> ExitCode {
+	eprintln!("{}: {}", argv0, message);
+	ExitCode::from(code.unwrap_or(1 /* unknown error */))
+}
+
+fn usage(argv0: &String) -> ExitCode {
+	eprintln!("Usage: {}", argv0);
+	ExitCode::from(EX_USAGE)
+}
+
 fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
 	/* preserve decimal places in output by casting to a float */
 	let mut out = (input as f64, (0_u32, "")); 
@@ -81,53 +91,48 @@ fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
 
-	if let Some(_) = argv.get(1) {
-		eprintln!("Usage: {}", argv[0]);
-		return ExitCode::from(EX_USAGE as u8);
-	}
+	if let Some(_) = argv.get(1) { return usage(&argv[0]); }
 
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR as u8);
+		let promises = Promises::new("stdio unveil");
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], e.strerror(), Some(EX_OSERR));
+		}
+
+		if let Err(e) = unveil(None, None) {
+			return err(&argv[0], e.strerror(), Some(EX_OSERR));
 		}
 	}
 
 	let mut buf = String::new();
 
-	while let Ok(_) = stdin().read_line(&mut buf) {
-		if buf.is_empty() { return ExitCode::SUCCESS; }
+	if let Err(e) = stdin().read_line(&mut buf) {
+		return err(&argv[0], e.strerror(), Some(EX_IOERR));
+	}
 
-		let n: u128 = match buf.trim().parse() {
-			Ok(f) => {
-				buf.clear();
-				f
-			},
-			Err(err) => {
-				eprintln!("{}: {}", argv[0], err);
-				return ExitCode::from(EX_DATAERR as u8);
-			},
-		};
+	if buf.is_empty() { return ExitCode::SUCCESS; }
 
-		let (number, prefix) = match convert(n) {
-			Ok(x) => x,
-			Err(err) => {
-				eprintln!("{}: {}", argv[0], err);
-				return ExitCode::from(EX_SOFTWARE as u8);
-			},
-		};
+	let n: u128 = match buf.trim().parse() {
+		Ok(f) => {
+			buf.clear();
+			f
+		},
+		Err(e) => return err(&argv[0], e.to_string(), Some(EX_DATAERR)),
+	};
 
-		let si_prefix = format!("{}B", prefix.1);
+	let (number, prefix) = convert(n).unwrap_or_else(|e| {
+		let _ = err(&argv[0], e.to_string(), None);
+		exit(EX_SOFTWARE.into());
+	});
 
-		/* round output number to one decimal place */
-		let out = ((number * 10.0).round() / 10.0).to_string();
+	let si_prefix = prefix.1.to_owned() + "B";
 
-		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
-			.unwrap_or_else(|e| {
-				eprintln!("{}: {}", argv[0], e.strerror());
-				exit(EX_IOERR);
-			});
+	/* round output number to one decimal place */
+	let rounded = (number * 10.0).round() / 10.0;
+	let out = rounded.to_string() + " " + &si_prefix + &'\n'.to_string();
+
+	if let Err(e) = stdout().write_all(out.as_bytes()) {
+		return err(&argv[0], e.strerror(), Some(EX_IOERR));
 	}
 
 	ExitCode::SUCCESS

src/intcmp.rs

@@ -26,27 +26,35 @@ extern crate getopt;
 extern crate sysexits;
 
 use getopt::GetOpt;
-use sysexits::EX_USAGE;
+use sysexits::{ EX_DATAERR, EX_USAGE };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate openbsd;
 #[cfg(target_os="openbsd")] extern crate strerror;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 #[cfg(target_os="openbsd")] use strerror::StrError;
 
-fn usage(s: &str) -> ExitCode {
-	eprintln!("Usage: {} [-egl] integer integer...", s);
-	ExitCode::from(EX_USAGE as u8)
+fn err(argv0: &String, e: String, code: u8) -> ExitCode {
+	eprintln!("{}: {}", argv0, e);
+	ExitCode::from(code)
+}
+
+fn usage(argv0: &str) -> ExitCode {
+	eprintln!("Usage: {} [-egl] integer integer...", argv0);
+	ExitCode::from(EX_USAGE)
 }
 
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
 
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR as u8);
+		let promises = Promises::new("stdio unveil");
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], e.strerror(), EX_OSERR);
+		}
+
+		if let Err(e) = unveil(None, None) {
+			return err(&argv[0], e.strerror(), EX_OSERR);
 		}
 	}
 
@@ -78,8 +86,8 @@ fn main() -> ExitCode {
 		match arg.parse::<usize>() { /* parse current operand */
 			Ok(n) => currn = n,
 			Err(e) => {
-				eprintln!("{}: {}: {}", &argv[0], arg, e);
-				return ExitCode::from(EX_USAGE as u8);
+				let error = arg.to_owned() + ": " + &e.to_string();
+				return err(&argv[0], error, EX_DATAERR);
 			}
 		}
 

src/libopenbsd.rs

@@ -43,6 +43,10 @@ impl Promises {
 	}
 }
 
+impl Default for Promises {
+	fn default() -> Self { Promises::new("") }
+}
+
 pub fn pledge(
 	promises: Option<Promises>, execpromises: Option<Promises>
 ) -> Result<(), Error> {
@@ -65,14 +69,12 @@ pub fn pledge(
 pub struct UnveilPerms(CString);
 
 impl UnveilPerms {
-	pub fn new(permissions: Vec<char>) -> Self {
-		if permissions.is_empty() {
-			return UnveilPerms(CString::new("").unwrap());
-		}
-
-		UnveilPerms(
-			CString::new(permissions.iter().collect::<String>()).unwrap()
-		)
+	pub fn new<T: IntoIterator<Item = char>>(permissions: T) -> Self {
+		let perms = CString::new(
+			permissions.into_iter().collect::<String>()
+		).unwrap();
+		
+		UnveilPerms(perms)
 	}
 }
 
@@ -83,9 +85,9 @@ pub fn unveil(
 	let path_c = path.map(CString::new).map(Result::unwrap);
 	let arg1 = path_c.map(|p| p.into_raw() as *const c_char).unwrap_or(null());
 
-	let arg2 = permissions
-		.map(|p| p.0.into_raw() as *const c_char)
-		.unwrap_or(null());
+	let arg2 = permissions.map(|p| {
+		p.0.into_raw() as *const c_char
+	}).unwrap_or(null());
 
 	unsafe {
 		match openbsd::unveil(arg1, arg2) {

src/mm.rs

@@ -20,9 +20,9 @@
 use std::{
 	env::args,
 	fs::File,
-	io::{ stdin, stdout, stderr, BufWriter, Read, Write },
+	io::{ Error, BufWriter, Read, Write, stderr, stdin, stdout },
 	os::fd::{ AsRawFd, FromRawFd },
-	process::{ exit, ExitCode },
+	process::{ ExitCode, exit},
 };
 
 extern crate getopt;
@@ -47,15 +47,23 @@ use ArgMode::*;
 
 enum ArgMode { In, Out }
 
+fn err(argv0: &String, e: Error, code: Option<u8>) -> ExitCode {
+	eprintln!("{}: {}", argv0, e.strerror());
+	ExitCode::from(code.unwrap_or(1 /* unknown error */))
+}
+
+fn usage(argv0: &String) -> ExitCode {
+	eprintln!("Usage: {} [-aetu] [-i input] [-o output]", argv0);
+	ExitCode::from(EX_USAGE)
+}
+
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<_>>();
-	let usage = format!("Usage: {} [-aetu] [-i input] [-o output]", argv[0]);
 
 	#[cfg(target_os="openbsd")] {
 		let promises = Promises::new("cpath rpath stdio unveil wpath");
-		if let Err(e) = pledge(Some(promises), None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR as u8);
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], e, Some(EX_OSERR));
 		}
 	}
 
@@ -85,8 +93,7 @@ fn main() -> ExitCode {
 				mode = Some(Out); /* latest argument == -o */
 			},
 			Err(_) | Ok(_) => {
-				eprintln!("{}", usage);
-				return ExitCode::from(EX_USAGE as u8);
+				return usage(&argv[0]);
 			},
 		};
 
@@ -108,32 +115,28 @@ fn main() -> ExitCode {
 
 	#[cfg(target_os="openbsd")] {
 		for input in &ins {
-			let perms = UnveilPerms::new(vec!['r']);
+			let perms = UnveilPerms::new(['r']);
 
 			if let Err(e) = unveil(Some(&input), Some(perms)) {
-				eprintln!("{}: {}", argv[0], e.strerror());
-				return ExitCode::from(EX_OSERR as u8);
+				return err(&argv[0], e, Some(EX_OSERR));
 			}
 		}
 
 		for output in &outs {
-			let perms = UnveilPerms::new(vec!['c', 'w']);
+			let perms = UnveilPerms::new(['c', 'w']);
 
 			if let Err(e) = unveil(Some(&output), Some(perms)) {
-				eprintln!("{}: {}", argv[0], e.strerror());
-				return ExitCode::from(EX_OSERR as u8);
+				return err(&argv[0], e, Some(EX_OSERR));
 			}
 		}
 
 		if let Err(e) = unveil(None, None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR as u8);
+			return err(&argv[0], e, Some(EX_OSERR));
 		}
 	}
 
 	if ins.is_empty() && outs.is_empty() && argv.len() > optind {
-		eprintln!("Usage: {}", usage);
-		return ExitCode::from(EX_USAGE as u8);
+		return usage(&argv[0]);
 	}
 
 	/* use stdin if no inputs are specified */
@@ -153,8 +156,8 @@ fn main() -> ExitCode {
 		match File::open(file) {
 			Ok(f) => f,
 			Err(e) => {
-				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
-				exit(EX_IOERR);
+				let _ = err(&(argv[0].clone() + ": " + file), e, None);
+				exit(EX_IOERR.into());
 			},
 		}
 	}).collect::<Vec<_>>();
@@ -180,8 +183,8 @@ fn main() -> ExitCode {
 		match options {
 			Ok(f) => return f,
 			Err(e) => {
-				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
-				exit(EX_IOERR);
+				let _ = err(&(argv[0].clone() + ": " + file), e, None);
+				exit(EX_IOERR.into());
 			},
 		};
 	}).collect::<Vec<_>>();
@@ -205,21 +208,19 @@ fn main() -> ExitCode {
 	for file in inputs {
 		for byte in file.bytes().map(|b| {
 			b.unwrap_or_else(|e| {
-				eprintln!("{}: {}", argv[0], e.strerror());
-				exit(EX_IOERR);
+				let _ = err(&argv[0], e, None);
+				exit(EX_IOERR.into());
 			})
 		}) {
 			for out in &mut outputs {
 				if let Err(e) = out.write(&[byte]) {
-					eprintln!("{}: {}", argv[0], e.strerror());
-					return ExitCode::from(EX_IOERR as u8);
+					return err(&argv[0], e, Some(EX_IOERR));
 				}
 
 				if u {
 					/* immediately flush the output for -u */
 					if let Err(e) = out.flush() { 
-						eprintln!("{}: {}", argv[0], e.strerror());
-						return ExitCode::from(EX_IOERR as u8);
+						return err(&argv[0], e, Some(EX_IOERR));
 					}
 				}
 			}

src/npc.c

@@ -20,7 +20,7 @@
 #include <stdio.h> /* fprintf(3), fputs(3), getc(3), perror(3), putc(3), stdin,
                     * stdout, EOF */
 #include <sysexits.h> /* EX_IOERR, EX_OK, EX_OSERR, EX_USAGE */
-#include <unistd.h> /* pledge(2), getopt(3) */
+#include <unistd.h> /* NULL, getopt(3), pledge(2), unveil(2) */
 
 char *program_name = "npc";
 
@@ -44,7 +44,7 @@ int main(int argc, char *argv[]) {
 	char showtab = 0; /* prints tab characters in caret notation */
 
 #ifdef __OpenBSD__
-	if (pledge("stdio", NULL) == -1) {
+	if (pledge("stdio unveil", NULL) == -1 || unveil(NULL, NULL)) {
 		perror(argv[0] == NULL ? program_name : argv[0]);
 		return EX_OSERR;
 	}

src/peek.c

@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-#include <signal.h> /* sigaction(2), signal(2), struct sigaction, SIGINT */
-#include <stdbool.h> /* bool */
-#include <stdio.h> /* fprintf(3), fgetc(3), perror(3), fputc(3), stderr, stdin,
-                    * stdout, EOF, NULL */
-#include <stdlib.h> /* exit(3), EXIT_FAILURE */
-#include <sysexits.h> /* EX_IOERR, EX_OK, EX_USAGE */
-#include <termios.h> /* tcgetattr(3), tcsetattr(3), struct termios, ECHO */
-#include <unistd.h> /* getopt(3), isatty(3), pledge(2), unveil(2),
-                     * STDIN_FILENO */
-
-char *program_name = "peek";
-
-/* Restores terminal echo; otherwise when a user ^Cs the terminal would
- * continue to not display typed text. If sig isn't zero, this will terminate
- * the program. */
-static void
-restore_echo(int sig) {
-	static struct termios t;
-
-	/* Failure isn't reported because this is the termination routine anyway;
-	 * errors will be obvious. */
-	if (tcgetattr(STDIN_FILENO, &t) == 0) {
-		t.c_lflag |= ECHO;
-		(void)tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
-	}
-
-	if (sig != 0) { exit(EXIT_FAILURE); } /* Terminated by signal. */
-
-	return;
-}
-
-static int
-ioerr(char *argv0) {
-	perror(argv0);
-	restore_echo(0);
-	return EX_IOERR;
-}
-
-static int
-usage(char *argv0) {
-	(void)fprintf(stderr, "Usage: %s [-i]\n", argv0);
-
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]){
-	bool is_term; /* Is stdin a terminal? */
-	bool must_be_term = 1; /* Must it be? */
-
-#ifdef __OpenBSD__
-	if (pledge("stdio tty unveil", "") != 0 || unveil(NULL, NULL) != 0) {
-		/* This isn't fatal; these return values could be cast to void just as
-		 * easily. */
-		(void)perror(argv[0] == NULL ? argv[0] : program_name);
-	}
-#endif
-
-	is_term = isatty(STDIN_FILENO);
-
-	if (argc > 0) { /* option parsing */
-		int c;
-
-		program_name = argv[0];
-
-		while ((c = getopt(argc, argv, "i")) != -1) {
-			switch (c) {
-				case 'i':	must_be_term = 0; break;
-				default:	return usage(argv[0]);
-			}
-		}
-
-		if (argc > optind) { return usage(argv[0]); }
-	}
-
-	if (!is_term && must_be_term) {
-		(void)fprintf(
-		    stderr,
-		    "%s: Must be run in a terminal (specify -i to skip this check)\n",
-		    argv[0]
-		);
-		return EX_USAGE;
-	}
-
-	if (is_term) {
-		{ /* Install signal handler */
-			/* There isn't a difference in functionality between the signal(2)
-			 * and sigaction(2) methods. sigaction(2) is vastly preferred for
-			 * portability but some older systems only have signal(2). */
-			/* Errors aren't terminating because the worst that happens is some
-			 * terminal phooeyness if things go awry. */
-#if defined _POSIX_C_SOURCE
-			struct sigaction act = { 0 };
-
-			act.sa_handler = restore_echo;
-			if (sigaction(SIGINT, &act, NULL) != 0) { perror(program_name); }
-#else
-			if (signal(SIGINT, restore_echo) == SIG_ERR) {
-				perror(program_name);
-			}
-#endif
-		}
-
-		{ /* Banish terminal echo */
-			/* This terminates when it fails because it's the whole point of
-			 * the program. */
-			struct termios t;
-
-			if (tcgetattr(STDIN_FILENO, &t) != 0) {
-				return ioerr(program_name);
-			}
-			t.c_lflag ^= ECHO;
-			if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t) != 0) {
-				return ioerr(program_name);
-			}
-		}
-	}
-
-	{ /* Input loop */
-		int c;
-
-		while ((c = fgetc(stdin)) != EOF) {
-			if (fputc(c, stdout) == EOF) { return ioerr(program_name); }
-		}
-	}
-
-	if (is_term) { restore_echo(0); }
-
-	return EX_OK;
-}

src/rpn.rs

@@ -46,7 +46,7 @@ use std::{
 	collections::VecDeque,
 	env::args,
 	fmt::{ self, Display, Formatter },
-	io::stdin,
+	io::{ Error, Write, stdin, stdout },
 	process::ExitCode,
 };
 
@@ -54,13 +54,13 @@ use CalcType::*;
 
 extern crate sysexits;
 
-use sysexits::EX_DATAERR;
+use sysexits::{ EX_DATAERR, EX_IOERR };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate strerror;
 #[cfg(target_os="openbsd")] extern crate openbsd;
 #[cfg(target_os="openbsd")] use strerror::StrError;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
 #[derive(Clone, PartialEq, PartialOrd, Debug)]
 /* enum CalcType is a type containing operations used in the calculator */
@@ -120,12 +120,46 @@ impl Display for CalcType {
 #[derive(Debug, Clone)]
 struct EvaluationError {
 	message: String,
-	code: i32,
+	code: u8,
 }
 
-/* I’m no math nerd but I want the highest possible approximation of 0.9
- * repeating and it seems this can give it to me */
-const PRECISION_MOD: f64 = 0.9 + f64::EPSILON * 100.0;
+impl StrError for EvaluationError {
+	fn strerror(&self) -> String {
+		self.message.clone()
+	}
+}
+
+fn err<T: StrError>(argv0: &String, e: &T, code: Option<u8>) -> ExitCode {
+	eprintln!("{}: {}", argv0, e.strerror());
+	ExitCode::from(code.unwrap_or(1 /* unknown error */))
+}
+
+fn operate(
+	mut stack: VecDeque<f64>,
+	op: CalcType,
+) -> Result<VecDeque<f64>, EvaluationError> {
+	let vals = (stack.pop_back(), stack.pop_back());
+
+	if let (Some(x), Some(y)) = vals {
+		match op {
+			Add => stack.push_back(y + x),
+			Subtract => stack.push_back(y - x),
+			Multiply => stack.push_back(y * x),
+			Divide => stack.push_back(y / x),
+			Power => stack.push_back(y.powf(x)),
+			Floor => stack.push_back((y / x).floor()),
+			Modulo => stack.push_back(y % x),
+			_ => {},
+		};
+	} else {
+		return Err(EvaluationError {
+			message: format!("{}: unexpected operation", op),
+			code: EX_DATAERR,
+		})
+	}
+
+	Ok(stack)
+}
 
 fn eval(
 	input: &str,
@@ -145,6 +179,7 @@ fn eval(
 		.rev()
 		.map(|t| CalcType::from(t))
 		.collect();
+
 	let mut ops: VecDeque<CalcType> = VecDeque::new();
 
 	while let Some(n) = toks.pop_back() {
@@ -152,36 +187,15 @@ fn eval(
 			Val(v) => stack.push_back(v),
 			Invalid(i) => {
 				return Err(EvaluationError {
-					message: format!("{}: Invalid token", i),
+					message: format!("{}: invalid token", i),
 					code: EX_DATAERR,
 				})
 			},
 			op => {
 				ops.push_back(op.clone());
-				oper = true;
 
-				let vals = (
-					stack.pop_back(),
-					stack.pop_back(),
-				);
-
-				if let (Some(x), Some(y)) = vals {
-					match op {
-						Add => stack.push_back(y + x),
-						Subtract => stack.push_back(y - x),
-						Multiply => stack.push_back(y * x),
-						Divide => stack.push_back(y / x),
-						Power => stack.push_back(y.powf(x)),
-						Floor => stack.push_back((y / x).floor()),
-						Modulo => stack.push_back(y % x),
-						_ => {},
-					};
-				} else {
-					return Err(EvaluationError {
-						message: format!("{}: Unexpected operation", op),
-						code: EX_DATAERR,
-					})
-				}
+				oper = true; /* this is an operation */
+				return operate(stack, op).map(|s| (s, oper));
 			},
 		};
 	}
@@ -190,51 +204,46 @@ fn eval(
 }
 
 /* Round a float to the given precision level */
-fn round_precise(value: &f64, precision: usize) -> f64 {
-	let multiplier = 10_f64.powi(precision as i32);
+fn round_precise(value: &f64) -> f64 {
+	/* Set floating-point precision for correcting rounding errors based on
+	 * machine epsilon */
+	let precision = (-f64::EPSILON.log10()).floor() as i32;
+	let multiplier = 10_f64.powi(precision);
+
 	(value * multiplier).round() / multiplier
 }
 
+/* print the stack and let the caller know if evaluation should continue */
+fn unstack(stack: VecDeque<f64>, op: bool) -> Result<bool, Error> {
+	if let Some(val) = stack.iter().last() {
+		if !op { return Ok(true); }
+
+		let out = round_precise(val).to_string() + &'\n'.to_string();
+
+		return stdout().write_all(out.as_bytes()).map(|_| true);
+	} else {
+		return Ok(false);
+	}
+}
+
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
 
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), None) {
-			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR as u8);
+		let promises = Promises::new("stdio unveil");
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], &e, Some(EX_OSERR));
+		}
+
+		if let Err(e) = unveil(None, None) {
+			return err(&argv[0], &e, Some(EX_OSERR));
 		}
 	}
 
 	let mut stack = VecDeque::new();
 	let mut buf = String::new();
-	/* Set floating-point precision for correcting rounding errors based on
-	 * machine epsilon */
-	let precision = (-f64::EPSILON.log10() * PRECISION_MOD).ceil() as usize;
-	
-	if argv.get(1).is_none() { /* read from stdin */
-		while let Ok(_) = stdin().read_line(&mut buf) {
-			match eval(&buf.trim(), stack) {
-				Ok(s) => {
-					buf.clear();
-					stack = s.0.clone();
 
-					let val = match stack.iter().last() {
-						Some(v) => v,
-						None => break,
-					};
-
-					if s.1 == false { continue; }
-
-					println!("{}", round_precise(val, precision).to_string());
-				},
-				Err(err) => {
-					eprintln!("{}: {}", argv[0], err.message);
-					return ExitCode::from(err.code as u8);
-				},
-			};
-		}
-	} else { /* read from argv */
+	if argv.get(1).is_some() { /* read expressions from argv */
 		/* join argv into an owned String joined by spaces minus argv[0] */
 		let input = argv
 			.iter()
@@ -245,20 +254,44 @@ fn main() -> ExitCode {
 
 		match eval(&input, stack) {
 			Ok(s) => {
-				stack = s.0.clone();
+				/* we can ignore the return value of unstack() because we are
+				 * not continually evaluating from stdin */
+				if let Err(e) = unstack(s.0.clone(), s.1.clone()) {
+					return err(&argv[0], &e, Some(EX_IOERR));
+				}
 
-				let val = match stack.iter().last() {
-					Some(v) => v,
-					None => return ExitCode::SUCCESS,
-				};
-
-				println!("{}", round_precise(val, precision).to_string())
+				return ExitCode::SUCCESS;
 			},
-			Err(err) => {
-				eprintln!("{}: {}", argv[0], err.message);
-				return ExitCode::from(err.code as u8);
+			Err(e) => {
+				return err(&argv[0], &e, Some(e.code));
 			},
 		};
 	}
+
+	/* else, read from stdin */
+	loop { /* take input until EOF */
+		if let Err(e) = stdin().read_line(&mut buf) {
+			return err(&argv[0], &e, Some(EX_IOERR));
+		}
+
+		match eval(&buf.trim(), stack) {
+			Ok(s) => {
+				buf.clear();
+				stack = s.0.clone(); /* out with the old, in with the new */
+
+				match unstack(s.0, s.1) {
+					Ok(b) if b => continue,
+					Ok(_) => break,
+					Err(e) => {
+						return err(&argv[0], &e, Some(EX_IOERR))
+					},
+				};
+			},
+			Err(e) => {
+				return err(&argv[0], &e, Some(e.code));
+			},
+		};
+	}
+
 	ExitCode::SUCCESS
 }

src/str.c

@@ -25,7 +25,7 @@
 #include <sysexits.h> /* EX_OSERR, EX_USAGE */
 
 #ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2) */
+#	include <unistd.h> /* pledge(2), unveil(2) */
 #endif
 
 char *program_name = "str";
@@ -62,7 +62,7 @@ int main(int argc, char *argv[]) {
 	program_name = argv[0] == NULL ? program_name : argv[0];
 
 #ifdef __OpenBSD__
-	if (pledge("stdio", NULL) == -1) {
+	if (pledge("stdio unveil", NULL) == -1 || unveil(NULL, NULL) == -1) {
 		perror(program_name);
 		return EX_OSERR;
 	}

src/strcmp.c

@@ -20,7 +20,7 @@
 #include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
 
 #ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2) */
+#	include <unistd.h> /* pledge(2), unveil(2) */
 #endif
 
 char *program_name = "strcmp";
@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
 	unsigned int i;
 
 #ifdef __OpenBSD__
-	if (pledge("stdio", NULL) == -1) {
+	if (pledge("stdio unveil", NULL) == -1 || unveil(NULL, NULL) == -1) {
 		perror(argv[0] == NULL ? program_name : argv[0]);
 
 		return EX_OSERR;

src/swab.rs

@@ -33,31 +33,29 @@ use sysexits::{ EX_IOERR, EX_OK, EX_OSERR, EX_USAGE };
 use strerror::StrError;
 
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
-
-fn oserr(argv0: &str, e: Error) -> ExitCode {
+fn err(argv0: &str, e: Error, code: u8) -> ExitCode {
 	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(EX_OSERR as u8)
-}
-
-fn ioerr(argv0: &str, e: Error) -> ExitCode {
-	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(EX_IOERR as u8)
+	ExitCode::from(code)
 }
 
 fn usage(s: &str) -> ExitCode {
 	eprintln!("Usage: {} [-w word_size]", s);
-	ExitCode::from(EX_USAGE as u8)
+	ExitCode::from(EX_USAGE)
 }
 
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
 	
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), None) {
-			return oserr(&argv[0], e);
+		let promises = Promises::new("stdio unveil");
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], e, EX_OSERR);
+		}
+
+		if let Err(e) = unveil(None, None) {
+			return err(&argv[0], e, EX_OSERR);
 		}
 	}
 
@@ -88,22 +86,22 @@ fn main() -> ExitCode {
 
 	loop {
 		match input.read(&mut buf) {
-			Ok(0) => break ExitCode::from(EX_OK as u8), // read nothing; bye
+			Ok(0) => break ExitCode::from(EX_OK), // read nothing; bye
 			Ok(v) if v == wordsize => { // read full block; swab
 				let (left, right) = buf.split_at(v/2);
 
 				if let Err(e) = output.write(&right)
 						.and_then(|_| output.write(&left)) {
-					break ioerr(&argv[0], e);
+					break err(&argv[0], e, EX_IOERR);
 				}
 
 			},
 			Ok(v) => { // partial read; partially write
 				if let Err(e) = output.write(&buf[..v]) {
-					break ioerr(&argv[0], e);
+					break err(&argv[0], e, EX_IOERR);
 				}
 			},
-			Err(e) => break oserr(&argv[0], e)
+			Err(e) => break err(&argv[0], e, EX_OSERR)
 		}
 	}
 }

src/true.c

@@ -8,11 +8,12 @@
  */
 
 #ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2) */
+#	include <unistd.h> /* NULL, pledge(2), unveil(2) */
 #endif
 
 int main(void) {
 #ifdef __OpenBSD__
-	pledge(NULL, NULL);
+	(void)pledge(NULL, NULL);
+	(void)unveil(NULL, NULL);
 #endif
 }

tests/bonsai/fop.mk

@@ -24,6 +24,7 @@ fop_fail: $(BIN)/fop
 	! printf 'test\n' | $(BIN)/fop 1 cat
 	! printf 'test\n' | $(BIN)/fop 'test' cat
 	! printf 'test\n' | $(BIN)/fop -d'test' cat
+	! $(BIN)/fop
 
 .PHONY: fop_functionality
 fop_functionality: $(BIN)/fop

tests/bonsai/mm.mk

@@ -6,7 +6,7 @@
 # notice are preserved.  This file is offered as-is, without any warranty.
 
 .PHONY: mm_tests
-mm_tests: mm_args mm_help mm_stderr mm_remaining
+mm_tests: mm_args mm_help mm_stderr mm_remaining mm_remaining_options
 
 .PHONY: mm_none
 mm_none: $(BIN)/mm
@@ -32,3 +32,9 @@ mm_remaining: $(BIN)/mm
 	test "$$($(BIN)/mm -i README COPYING)" = "$$(cat README COPYING)"
 	$(BIN)/mm -i README -o /tmp/mm_test0 /tmp/mm_test1
 	diff /tmp/mm_test0 /tmp/mm_test1
+
+.PHONY: mm_remaining_options
+# check to make sure mm -i with trailing arguments interprets -o as one
+mm_remaining_options:
+	! $(BIN)/mm -i README COPYING -o - 2>&1 | cut -d: -f2 \
+		| xargs test " -o" =

tests/bonsai/npc.mk

@@ -1,6 +1,6 @@
 #!/bin/sh
 # Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 # SPDX-License-Identifier: FSFAP
 #
 # Copying and distribution of this file, with or without modification, are
@@ -26,7 +26,7 @@ npc_args:
 
 .PHONY: npc_ascii
 # Test 0x00 to 0x7f in input; in other words, the full 7b ASCII range.
-npc_ascii: npc_ascii_controls npc_ascii_uppers # npc_ascii_symbols \
+npc_ascii: npc_ascii_controls npc_ascii_symbols npc_ascii_uppers # \
 #	npc_ascii_lowers
 
 .PHONY: npc_ascii_controls
@@ -63,18 +63,14 @@ npc_ascii_controls:
 		| tail -n 1 \
 		| xargs -I out test "^K^L^M^N^O^P^Q^R^S^T^U^V^W^X^Y^Z^[^\^]^^^_"
 
-# This test is broken on Linux and will need closer inspection along with GNU
-# xargs(1).
-# .PHONY: npc_ascii_symbols
-# # ASCII 0x1f to 0x3f (^_ and symbols)
-# npc_ascii_symbols:
-# 	# shell quoting olympics
-# 	c="$(awk 'BEGIN{ for (i = 31; i < 64; ++i) printf("%c", i); print }')"
-# 
-# 	printf '%s\n' "$c" | $(BIN)/npc \
-# 		| sed -e s"/\'/\\\'/g" -e 's/"/\\"/g' \
-# 		| tr -d '\n' \
-# 		| xargs -I out test "^_ !\"#$$%&\'()*+,-./0123456789:;<=>?" = out
+.PHONY: npc_ascii_symbols
+# ASCII 0x1f to 0x3f (^_ and symbols)
+npc_ascii_symbols:
+	# shell quoting olympics
+	awk 'BEGIN{ for (i = 31; i < 64; ++i) printf("%c", i); print }' \
+		| $(BIN)/npc \
+		| sed -e s"/\'/\\\'/g" -e 's/"/\\"/g' \
+		| xargs -I out test "^_ !\"#$$%&'()*+,-./0123456789:;<=>?" = out
 
 .PHONY: npc_ascii_uppers
 # ASCII 0x40 to 0x5f (uppercases)

tests/bonsai/peek.mk

@@ -1,24 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-# Testing peek is hard as it requires visual confirmation that text isn't being
-# echoed. These tests don't go that far but are a start, and have already
-# caught a bug in -i behavior.
-
-.PHONY: peek_tests
-peek_tests: peek_help peek_stdio
-
-.PHONY: peek_help
-peek_help: $(BIN)/peek
-	! $(BIN)/peek -h
-
-.PHONY: peek_stdio
-# Test peek -i
-peek_stdio: $(BIN)/peek
-	printf 'Test.\n' \
-		| $(BIN)/peek -i \
-		| xargs test 'Test.' =

tests/bonsai/rpn.mk

@@ -6,7 +6,7 @@
 # notice are preserved.  This file is offered as-is, without any warranty.
 
 .PHONY: rpn_tests
-rpn_tests: rpn_help rpn_add rpn_sub rpn_mul rpn_div rpn_mod rpn_flr
+rpn_tests: rpn_help rpn_add rpn_sub rpn_mul rpn_div rpn_mod rpn_flr rpn_stdin
 
 .PHONY: rpn_help
 rpn_help: $(BIN)/rpn
@@ -41,3 +41,8 @@ rpn_mod: $(BIN)/rpn
 rpn_flr: $(BIN)/rpn
 	test "$$($(BIN)/rpn 12 5 //)" -eq 2
 	test "$$($(BIN)/rpn 9 4 //)" -eq 2
+
+# done last because all operations have been tested
+.PHONY: rpn_stdin
+rpn_stdin: $(BIN)/rpn
+	test "$$(printf '1\n2\n+\n3\n-\n' | $(BIN)/rpn | tail -n1)" -eq 0