Makefile: removes deprecated variable

I could trace strcmp(1) as far back as
<293436c5ad/src/streq.c>
in my repo.

CONTRIBUTING

@@ -1,26 +1,29 @@
 Make sure to read our code of conduct in the CONDUCT file.
 
-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 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:
 
  * 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 (“–”) to separate the years in the copyright
-notice.
+2023. Please use the en dash (“–”, U+2013) to separate consecutive 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:
@@ -92,6 +95,10 @@ 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
@@ -99,12 +106,18 @@ their editor or terminal.
 
 For usage text and help messages, do not implement a -h option. Instead, print
 usage information when any erroneous option is specified. Follow the NetBSD
-style guide for the usage text’s output format [1].
+style guide for the usage text’s output format [0].
 
-[1] <http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style>
+If committing a new utility, please include tests and documentation (see
+tests/ and docs/) for the new tool.
 
-If committing a new source file, format the commit message following these
-guidelines:
+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:
 
 $ git commit -m 'tool(1): add feature x'
 
@@ -130,6 +143,13 @@ $ 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

@@ -1,4 +1,4 @@
-# Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+# Copyright (c) 2023–2025 Emma Tebibyte <emma@tebibyte.media>
 # Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
 # Copyright (c) 2023 Sasha Koshka <sashakoshka@tebibyte.media>
 # Copyright (c) 2024 Aaditya Aryal <aryalaadi123@gmail.com>
@@ -16,20 +16,33 @@
 DESTDIR ?= dist
 PREFIX ?= /usr/local
 
-MANDIR != [ $(PREFIX) = / ] && printf '/usr/share/man\n' \
-	|| printf '/share/man\n'
-SYSEXITS != printf '\043include <sysexits.h>\n' | cpp -M - | sed 's/ /\n/g' \
+# for conditionally compiling OS features
+OS != uname
+OS_INCLUDE != test -e include/$(OS).mk && printf 'include/$(OS).mk\n' \
+	|| printf '/dev/null\n'
+
+# normalized prefix
+PREFIX_N != realpath $(PREFIX)
+MANDIR != test $(PREFIX_N) = / && printf '/usr/share/man\n' \
+	|| printf '$(PREFIX_N)/man\n'
+SYSEXITS != printf '\043include <sysexits.h>\n' | cpp -M - | tr ' ' '\n' \
 	| sed -n 's/sysexits\.h//p' || printf 'include\n'
 
 CC ?= cc
 RUSTC ?= rustc
-RUSTLIBS = --extern getopt=build/o/libgetopt.rlib \
-	--extern sysexits=build/o/libsysexits.rlib \
-	--extern strerror=build/o/libstrerror.rlib
+RUSTFLAGS += --extern getopt=build/o/libgetopt.rlib \
+	--extern strerror=build/o/libstrerror.rlib \
+	--extern sysexits=build/o/libsysexits.rlib
 CFLAGS += -I$(SYSEXITS)
 
+# testing requires the absolute path to the bin directory set
+BIN = build/bin
+
+.PHONY: default
+default: all test
+
 .PHONY: all
-all: docs dj false fop hru intcmp mm npc rpn scrut str strcmp swab true
+all: dj false fileis fop hru intcmp mm npc peek rpn str strcmp swab true
 
 # keep build/include until bindgen(1) has stdin support
 # https://github.com/rust-lang/rust-bindgen/issues/2703
@@ -40,19 +53,26 @@ build:
 clean:
 	rm -rf build dist
 
-dist: all
-	mkdir -p $(DESTDIR)/$(PREFIX)/bin $(DESTDIR)/$(PREFIX)/share/man/man1
-	cp build/bin/* $(DESTDIR)/$(PREFIX)/bin
-	cp build/docs/*.1 $(DESTDIR)/$(PREFIX)/$(MANDIR)/man1
+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
 
 .PHONY: install
 install: dist
 	cp -r $(DESTDIR)/* /
 
+TESTFILES != for file in tests/*.mk; do printf '%s ' "$$file"; done
+
+TESTS != printf '%s\n' "$(TESTFILES)" | xargs -n1 basename \
+	| sed 's/\.mk/_tests/g'
+
+include $(TESTFILES)
+
 .PHONY: test
-test: build /tmp/getopt
+test: all $(TESTS) /tmp/getopt
+	@echo $(TESTS)
 	/tmp/getopt
-	tests/posix-compat.sh
 
 /tmp/getopt: src/libgetopt.rs
 	$(RUSTC) --test -o /tmp/getopt src/libgetopt.rs
@@ -64,9 +84,12 @@ docs: docs/ build
 		"s/X\.X\.X/$$(git describe --tags --long | cut -d'-' -f1)/g")"; \
 		sed "s/$$original/$$title/g" <"$$file" >"build/$$file"; done
 
+# include OS feature libraries for compilation
+include $(OS_INCLUDE)
+
 .PHONY: rustlibs
-rustlibs: build/o/libsysexits.rlib build/o/libgetopt.rlib \
-	build/o/libstrerror.rlib
+rustlibs: build/o/libgetopt.rlib build/o/libstrerror.rlib \
+	 build/o/libsysexits.rlib $(OSLIB)
 
 build/o/libgetopt.rlib: build src/libgetopt.rs
 	$(RUSTC) $(RUSTFLAGS) --crate-type=lib --crate-name=getopt \
@@ -76,13 +99,14 @@ build/o/libstrerror.rlib: build src/libstrerror.rs
 	$(RUSTC) $(RUSTFLAGS) --crate-type=lib -o $@ \
 		src/libstrerror.rs
 
-# bandage solution until bindgen(1) gets stdin support
-build/o/libsysexits.rlib: build $(SYSEXITS)sysexits.h
-	printf '\043define EXIT_FAILURE 1\n' | cat - $(SYSEXITS)sysexits.h \
-		> build/include/sysexits.h 
-	bindgen --default-macro-constant-type signed --use-core --formatter=none \
+build/o/libsysexits.rlib: build/include/sysexits.h
+	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
+build/include/sysexits.h: build $(SYSEXITS)sysexits.h
+	printf '\043define EXIT_FAILURE 1\n' | cat - $(SYSEXITS)sysexits.h > $@
+
 .PHONY: dj
 dj: build/bin/dj
 build/bin/dj: src/dj.c build
@@ -93,40 +117,45 @@ false: build/bin/false
 build/bin/false: src/false.c build
 	$(CC) $(CFLAGS) -o $@ src/false.c
 
+.PHONY: fileis
+fileis: build/bin/fileis
+build/bin/fileis: src/fileis.rs build rustlibs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/fileis.rs
+
 .PHONY: fop
 fop: build/bin/fop
 build/bin/fop: src/fop.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/fop.rs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/fop.rs
 
 .PHONY: hru
 hru: build/bin/hru
 build/bin/hru: src/hru.rs build rustlibs 
-	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/hru.rs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/hru.rs
 
 .PHONY: intcmp
 intcmp: build/bin/intcmp
-build/bin/intcmp: src/intcmp.c build
-	$(CC) $(CFLAGS) -o $@ src/intcmp.c
+build/bin/intcmp: src/intcmp.rs build rustlibs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/intcmp.rs
 
 .PHONY: mm
 mm: build/bin/mm
-build/bin/mm: src/mm.c build
-	$(CC) $(CFLAGS) -o $@ src/mm.c
+build/bin/mm: src/mm.rs build rustlibs 
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/mm.rs
 
 .PHONY: npc
 npc: build/bin/npc
 build/bin/npc: src/npc.c build
-	$(CC) $(CFLAGAS) -o $@ src/npc.c
+	$(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
-	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/rpn.rs
-
-.PHONY: scrut
-scrut: build/bin/scrut
-build/bin/scrut: src/scrut.c build
-	$(CC) $(CFLAGS) -o $@ src/scrut.c
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/rpn.rs
 
 .PHONY: str
 str: build/bin/str
@@ -141,7 +170,7 @@ build/bin/strcmp: src/strcmp.c build
 .PHONY: swab
 swab: build/bin/swab
 build/bin/swab: src/swab.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/swab.rs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/swab.rs
 
 .PHONY: true
 true: build/bin/true

README

@@ -1,24 +1,28 @@
 “Seek not to walk the path of the masters; seek what they sought.”
 – Matsuo Basho
 
-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.
+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 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.
+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.
 
 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
@@ -43,7 +47,22 @@ 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>
@@ -57,6 +76,10 @@ 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>

STYLE

@@ -0,0 +1,254 @@
+“Everyone knows that debugging is twice as hard as writing a program in the
+first place. So if you’re as clever as you can be when you write it, how
+will you ever debug it?”
+	– Brian Kernighan, The Elements of Programming Style
+
+
+The following guidelines are conducive to clear and readable code that is
+consistent with the style of the rest of the Bonsai Computer System.
+
+
+Use
+===
+
+ 0. A single line for control flow statements short enough to be easily
+ understood at a glance:
+
+	if !(argc < 0) { usage(program_name); }
+
+ This applies to C switch statements and cases and Rust match statements, as
+ well:
+
+	switch (value) { /* aligning stuff to make it easier to read is fine */
+		case possibility: variable = foo;  break;
+		default:          variable = NULL; break;
+	}
+
+ 1. Switch cases in C and match arms in Rust should start another level of
+ indentation:
+
+	switch (value) {
+		case possibility:
+			statement;
+			break;
+		default:
+			statement;
+			break;
+	}
+
+	match result {
+		Ok(n) => variable = n,
+		Err(e) => error = e,
+	}
+
+ 2. Braces in control flow where their inclusion is left optional in C:
+
+	if (condition) { statement; }
+
+ 3. Empty lines between different kinds of statements:
+
+	int t;
+
+	assert(io->bufuse > 0);
+	assert(io->bufuse <= io->bs);
+
+	if ((t = write(io->fd, io->buf, io->bufuse)) < 0) {
+		io->error = errno;
+		t = 0;
+	} else if (t > 0) {
+		memmove(io->buf, &(io->buf)[t], (io->bufuse -= t));
+	}
+
+	io->bytes += t;
+	io->prec  += (t > 0 && io->bufuse > 0);
+	io->rec   += (t > 0 && io->bufuse == 0);
+
+	return io;
+
+ 4. Compiler options that yield the most useful warnings, such as -Wpedantic in
+ a lot of C compilers. Fix the warnings, too [0].
+
+ 5. One more level of indentation and one argument per line when a function
+ call or statement header is too long to fit on one line:
+
+	let usage = format!(
+		"Usage: {} [-d delimiter] index command [args...]",
+		argv[0],
+	);
+
+ 6. One more level of indentation than the keyword that initiated a multi-line
+ block.
+
+	if (condition) {
+		statement;
+		statement;
+	}
+
+ 7. The return value of all non-void functions, or explicitly ignore them (like
+ casting to void in C) [0]:
+
+	if ((a = malloc(sizeof char)) == NULL) {          /* handle this error */
+		(void)fprintf(stderr, "oh noes!");   /* explicitly ignore this one */
+		return EX_OSERR;       /* ...because the program is exiting anyway */
+	}
+
+ 8. The smallest possible scope for data [0].
+
+ 9. Comments noting all the symbols and macros used from a C header file, next
+ to its include macro:
+
+	#include <unistd.h> /* close(2), getopt(3), lseek(2), read(2), write(2),
+	(space-aligned)      * optarg, optind, STDIN_FILENO, STDOUT_FILENO */
+
+ 10. Spaces in control flow statements, after the keyword and before the
+ opening brace:
+
+	for (i = 2; i < argc; ++i) {
+
+
+ 11. In Rust, a trailing comma on all arguments or fields that are on their own
+ lines:
+
+	return Err(EvaluationError {
+		message: format!("{}: Invalid token", i),
+		code: EX_DATAERR,
+	})
+
+ 12. In Rust, place extern statements after use statements that include standard
+ library crates. Group like statements:
+
+	use std::fs::Path;
+
+	extern crate strerror;
+	extern crate sysexits;
+
+	use strerror::StrError;
+	use sysexits::{ EX_OSERR, EX_USAGE };
+
+ 13. If text is on the same line as a brace, spaces after an opening brace and
+ before a closing one:
+
+	use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
+
+ 14. Alphabetic sorting, where applicable:
+
+	use std::io::{ BufWriter, Read, Write, stderr, stdin, stdout }
+
+ 15. In Rust, use the to_owned() method on string types (str, OsStr, CStr, etc.)
+ and the to_string() method on other types.
+
+
+Avoid
+=====
+
+ 16. Unbounded loops [0].
+
+ 17. Function pointers [0].
+
+ 18. Heap memory allocation [0].
+
+ 19. Using too much nested logic (within reason).
+
+ 20. Too many levels of dereferences [0]:
+
+	/* do not do this */
+	for (size_t i = 0; i < sizeof a / sizeof *a; ++i) {
+		if (a[i].id == MATCH) { a[i].val = 0; }
+	}
+
+	/* do this */
+	for (struct MadeUp *s = &a[0]; *s != NULL; s = &s[1]) {
+		if (s->id == MATCH) { s->val = 0; }
+	}
+
+ 21. Using C preprocessor macros; the fewer, the better [0].
+
+ 22. The exit(3p) and std::process::exit() functions; returning from the main
+ function skips a system call.
+
+
+Do Not Use
+==========
+
+ 23. More than the length of one printed page for a function [0].
+
+ 24. Recursion, as it’s complex and can unexpectedly overflow the stack [0].
+
+ 25. Any functionality not in the POSIX C specification and language features not
+ in C99.
+
+ 26. Do-while loops, as they’re unique to C and confusing for casual programmers.
+
+ 27. Labels and goto statements; use sensible flow control [0].
+
+ 28. Pointer arithmetic, as it tends to be confusing and unnecessary; use
+ index-reference patterns like &p[1] instead of p + 1. &p[n] is the address at
+ p + sizeof p * n, not p + n, like pointer arithmetic suggests.
+
+ 29. C struct bitfields in unions, to access certain bits of bigger data types,
+ as it’s poorly defined in the C standards; use bit arithmetic.
+
+ 30. C trigraphs.
+
+ 31. Inclusions in C header files, to prevent multiple file inclusions.
+
+ 32. C preprocessor variables to prevent multiple inclusions of the same file,
+ such as:
+
+	#ifdef _FILE
+	#define _FILE
+	/* file body */
+	#endif /* ifdef _FILE */
+
+ Instead, take the time to ensure other files aren’t including any files twice.
+
+ 33. The gets(3p) function from <stdio.h>, as it’s impossible to prevent buffer
+ overflows when it's used; use fgets(3p) from <stdio.h>.
+
+ 34. The scanf(3p) function from <stdio.h> [1].
+
+ 35. Any functionality not described in the latest POSIX make(1) specification.
+
+ 36. Macros which panic on failure in Rust (such as the print!() and println!()
+ macros). Use a function and handle any errors. However, do use the eprintln!()
+ macro for error messages. Handling an error for writing an error message is
+ redundant.
+
+
+Usage Text
+==========
+
+This section is adapted from the NetBSD style guide [2].
+
+When programs are invoked incorrectly and in the synopsis of manual pages, uasge
+text should be provided to the user. The following is the format used by this
+project for this purpose:
+
+All optional arguments are to be placed in square brackets (U+005B, U+005D).
+Mutually exclusive arguments can be separated by a vertical line (U+007C).
+Groups of arguments should be specified in alphabetical order in most cases. The
+order of arguments and an example of these rules follows:
+
+ 0. Options with no option arguments.
+ 1. Options with option arguments. Arguments should be specified inside the same
+ square brackets as the options.
+ 3. Non-option arguments.
+
+	"usage: f [-aDde] [-b b_arg] [-m m_arg] req1 req2 [opt1 [opt2]]\n"
+	"usage: f [-a | -b] [-c [-de] [-n number]]\n"
+
+
+References
+==========
+
+[0] <https://web.eecs.umich.edu/~imarkov/10rules.pdf>
+[1] <http://sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html>
+[2] <http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style>
+
+--
+Copyright © 2024 Emma Tebibyte <emma@tebibyte.media>
+Copyright © 2024 DTB <trinity@trinity.moe>
+Copyright © Wikipedia contributors
+
+This work is licensed under CC BY-SA 4.0. To view a copy of this license, visit
+<http://creativecommons.org/licenses/by-sa/4.0/>.

docs/dj.1

@@ -4,32 +4,24 @@
 .\" 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 DJ 1 2024-06-17 "Harakit X.X.X"
+.TH DJ 1 2024-07-14 "Harakit X.X.X"
 .SH NAME
 dj \(en disk jockey
 .\"
 .SH SYNOPSIS
 
 dj
-.RB ( -AdHnq )
-.RB ( -a
-.RB [ byte ])
-.RB ( -c
-.RB [ count ])
+.RB [ -Hn ]
+.RB [ -a\ byte ]
+.RB [ -c\ count ]
 
-.RB ( -i
-[\fBinput file\fP])
-.RB ( -b
-[\fBinput block size\fP])
-.RB ( -s
-[\fBinput offset\fP])
+.RB [ -i\ file ]
+.RB [ -b\ block_size ]
+.RB [ -s\ offset ]
 
-.RB ( -o
-[\fBoutput file\fP])
-.RB ( -B
-[\fBoutput block size\fP])
-.RB ( -S
-[\fBoutput offset\fP])
+.RB [ -o\ file ]
+.RB [ -B\ block_size ]
+.RB [ -S\ offset ]
 .\"
 .SH DESCRIPTION
 
@@ -42,68 +34,109 @@ respectively. This language is inherited from the
 .BR dd (1p)
 utility and used here to decrease ambiguity.
 
-When seeking or skipping to a byte, writing or reading starts at the byte
-immediately subsequent to the specified byte.
+The offset used when skipping or seeking refers to how many bytes are skipped
+or sought. Running
+.BR dj (1)
+with a skip offset of 1 skips one byte into the input and reads from the second
+byte onwards. A programmer may think of a file as a zero-indexed array of
+bytes; in this analogy, the offset given is the index of the byte at which to
+start reading or writing.
 .\"
 .SH OPTIONS
 
-.IP \fB-i\fP
+.IP \fB-i\fP\ \fIfile\fP
 Takes a file path as an argument and opens it for use as an input.
-.IP \fB-b\fP
+.IP \fB-b\fP\ \fIblock_size\fP
 Takes a numeric argument as the size in bytes of the input buffer, the default
 being 1024.
 .IP \fB-s\fP
-Takes a numeric argument as the number of bytes to skip into the input
-before starting to read. If the standard input is used, bytes read to this point
-are discarded.
+Takes a numeric argument as the index of the byte at which reading will
+commence; \(lqskips\(rq that number of bytes. If the standard input is used,
+bytes read to this point are discarded.
 .IP \fB-o\fP
 Takes a file path as an argument and opens it for use as an output.
-.IP \fB-B\fP
-Does the same as
-.B -b
-but for the output buffer.
+.IP \fB-B\fP\ \fIblock_size\fP
+Takes a numeric argument as the size in bytes of the output buffer, the default
+being 1024. Note that this option only affects the size of output writes and not
+the amount of output data itself. See the CAVEATS section.
 .IP \fB-S\fP
-Seeks a number of bytes through the output before starting to write from
-the input. If the output is a stream, null characters are printed.
+Takes a numeric argument as the index of the byte at which writing will
+commence; \(lqseeks\(rq that number of bytes. If the standard output is used,
+null characters are printed.
 .IP \fB-a\fP
 Accepts a single literal byte with which the input buffer is padded in the event
-of an incomplete read from the input file.
-.IP \fB-A\fP
-Specifying this option pads the input buffer with null bytes in the event of an
-incomplete read. This is equivalent to specifying
-.B -a
-with a null byte instead of a character.
+of an incomplete read from the input file. If the option argument is empty, the
+null byte is used.
 .IP \fB-c\fP
-Specifies a number of reads to make. The default is 0, in which case the
-input is read until a partial or empty read is made.
-.IP \fB-d\fP
-Prints invocation information before program execution as described in the
-DIAGNOSTICS section. Each invocation increments the debug level of the
-program.
+Specifies a number of blocks to read. The default is 0, in which case the input
+is read until a partial or empty read is made.
 .IP \fB-H\fP
-Prints diagnostics messages in a human-readable manner as described in the
+Prints diagnostic messages in a human-readable manner as described in the
 DIAGNOSTICS section.
 .IP \fB-n\fP
 Retries failed reads once before exiting.
-.IP \fB-q\fP
-Suppresses error messages which print when a read or write is partial or
-empty. Each invocation decrements the debug level of the program.
 .\"
 .SH STANDARD INPUT
 
 The standard input shall be used as an input if no inputs are specified or if
-one or more of the input files is \(lq-\(rq.
+input file is \(lq-\(rq.
 .\"
 .SH STANDARD OUTPUT
 The standard output shall be used as an output if no inputs are specified or if
-one or more of the input files is \(lq-\(rq.
+the output file is \(lq-\(rq.
+.\"
+.SH EXAMPLES
+
+The following
+.BR sh (1p)
+line:
+
+.RS
+printf 'Hello, world!\(rsn' | dj -c 1 -b 7 -s 7 2>/dev/null
+.RE
+
+Produces the following output:
+
+.RS
+world!
+.RE
+
+The following
+.BR sh (1p)
+lines run sequentially:
+
+.RS
+tr '\(rs0' 0    </dev/zero | dj -c 1 -b 6 -o hello.txt
+
+tr '\(rs0' H    </dev/zero | dj -c 1 -b 1 -o hello.txt
+
+tr '\(rs0' e    </dev/zero | dj -c 1 -b 1 -o hello.txt -S 1
+
+tr '\(rs0' l    </dev/zero | dj -c 1 -b 2 -o hello.txt -S 2
+
+tr '\(rs0' o    </dev/zero | dj -c 1 -b 1 -o hello.txt -S 4
+
+tr '\(rs0' '\(rsn' </dev/zero | dj -c 1 -b 1 -o hello.txt -S 5
+
+dj -i hello.txt
+.RE
+
+Produce the following output:
+
+.RS
+Hello
+.RE
+
+It may be particularly illuminating to print the contents of the example
+.B hello.txt
+after each
+.BR dj (1)
+invocation.
 .\"
 .SH DIAGNOSTICS
 
-On a partial or empty read, unless the
-.B -q
-option is specified, a diagnostic message is printed. Then, the program exits
-unless the
+On a partial or empty read, a diagnostic message is printed. Then, the program
+exits unless the
 .B -n
 option is specified.
 
@@ -128,20 +161,6 @@ option may be specified. In this event, the following format is used instead:
 {ASCII line feed}
 .RE
 
-If the
-.B -d
-option is specified, debug information will be printed at the beginning of
-execution. This output contains information regarding how the program was
-invoked. The following example is the result of running the program with
-.B -d
-as the only argument:
-
-.RS
-argv0=dj
-in=<stdin>      ibs=1024        skip=0  align=ff       count=0
-out=<stdout>    obs=1024        seek=0  debug= 3       noerror=0
-.RE
-
 In non-recoverable errors that don\(cqt pertain to the read-write cycle, a
 diagnostic message is printed and the program exits with the appropriate
 .BR sysexits.h (3)
@@ -156,17 +175,33 @@ is specified along with the
 option and a count, actual byte output is the product of the count and the input
 block size and therefore may be lower than expected. If the
 .B -a
-or
-.B -A
-options are specified, this could make written data nonsensical.
+option is specified, this could make written data nonsensical.
 .\"
 .SH CAVEATS
 
 Existing files are not truncated on ouput and are instead overwritten.
 
-Many lowercase options have capitalized variants and vice-versa which can be
-confusing. Capitalized options tend to affect output or are more intense
-versions of lowercase options.
+Option variants that have lowercase and uppercase forms could be confused for
+each other. The former affects input and the latter affects output.
+
+The
+.B -B
+option could be mistaken for the count in bytes of data written to the output.
+This conception is intuitive but incorrect, as the
+.B -c
+option controls the number of blocks to read and the
+.B -b
+option sets the size of the blocks. The
+.B -B
+option is similar to the latter but sets the size of blocks to be written,
+regardless of the amount of data that will actually be written. In practice,
+this means the input buffer should be very large to make use of modern hardware
+input and output speeds.
+
+The skipped or sought bytes while processing irregular files, such as streams,
+are reported in the diagnostic output, because they were actually read or
+written. This is as opposed to bytes skipped while processing regular files,
+which are not reported.
 .\"
 .SH RATIONALE
 
@@ -187,3 +222,5 @@ Copyright \(co 2023 DTB. License AGPLv3+: GNU AGPL version 3 or later
 .\"
 .SH SEE ALSO
 .BR dd (1p)
+.BR lseek (3p)
+.BR mm (1)

docs/fileis.1

@@ -1,17 +1,17 @@
 .\" Copyright (c) 2024 DTB <trinity@trinity.moe>
-.\" Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+.\" Copyright (c) 2024–2025 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 SCRUT 1 2024-06-06 "Harakit X.X.X"
+.TH FILEIS 1 2025-02-24 "Harakit X.X.X"
 .SH NAME
-scrut \(en scrutinize file properties
+fileis \(en scrutinize file properties
 .SH SYNOPSIS
 
-scrut
-.RB ( -LSbcdefgkprsuwx )
-.RB [ file... ]
+fileis
+.RB [ -LSbcdefgkprsuwx ]
+.B file...
 .\"
 .SH DESCRIPTION
 
@@ -82,5 +82,6 @@ Copyright \(co 2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
 .\"
 .SH SEE ALSO
 .BR access (3p),
+.BR chown (1p),
 .BR lstat (3p),
 .BR test (1p)

docs/fop.1

@@ -22,7 +22,7 @@ Performs operations on specified fields in data read from the standard input.
 .\"
 .SH OPTIONS
 
-.IP \fB-d\fP
+.IP \fB-d\fP\ \fIdelimiter\fP
 Sets a delimiter by which the input data will be split into fields. The default
 is an ASCII record separator.
 .\"

docs/intcmp.1

@@ -11,9 +11,7 @@ intcmp \(en compare integers
 .SH SYNOPSIS
 
 intcmp
-.RB ( -egl )
-.RB [ integer ]
-.RB [ integer... ]
+.RB [ -egl ]\ integer\ integer...
 .SH DESCRIPTION
 Compare integers to each other.
 .\"

docs/mm.1

@@ -3,18 +3,16 @@
 .\" 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 MM 1 2024-06-17 "Harakit X.X.X"
+.TH MM 1 2024-07-14 "Harakit X.X.X"
 .SH NAME
 mm \(en middleman
 .\"
 .SH SYNOPSIS
 
 mm
-.RB ( -aenu )
-.RB ( -i
-.RB [ input ])
-.RB ( -o
-.RB [ output ])
+.RB [ -aetu ]
+.RB [ -i\ input ]
+.RB [ -o\ output ]
 .\"
 .SH DESCRIPTION
 
@@ -23,19 +21,25 @@ Catenate input files and write them to the start of each output file or stream.
 .SH OPTIONS
 
 .IP \fB-a\fP
-Opens subsequent outputs for appending rather than updating.
+Opens outputs for appending rather than updating.
 .IP \fB-e\fP
 Use the standard error as an output.
-.IP \fB-i\fP
-Opens a path as an input. If one or more of the input files is \(lq-\(rq or if
-no inputs are specified, the standard input shall be used.
-.IP \fB-o\fP
-Opens a path as an output. If one or more of the output files is \(lq-\(rq or if
-no outputs are specified, the standard output shall be used.
+.IP \fB-t\fP
+Causes outputs to be overwritten instead of being truncated.
 .IP \fB-u\fP
 Ensures neither input or output will be buffered.
-.IP \fB-n\fP
-Causes SIGINT signals to be ignored.
+.IP \fB-i\fP\ \fIinput\fP
+Opens a path as an input. If one or more of the input files is \(lq-\(rq or if
+no inputs are specified, the standard input shall be used. If specified as the
+last option and if there are trailing arguments to the program, they shall be
+appended to the list of files to use as inputs.
+.IP \fB-o\fP\ \fIoutput\fP
+Opens a path as an output. If one or more of the output files is \(lq-\(rq or if
+no outputs are specified and the
+.B -e
+option is not specified, the standard output shall be used. If specified as the
+last option and if there are trailing arguments to the program, they shall be
+appended to the list of files to use as outputs.
 .\"
 .SH DIAGNOSTICS
 
@@ -47,10 +51,6 @@ exits with the appropriate
 .BR sysexits.h (3)
 status.
 .\"
-.SH CAVEATS
-
-Existing files are not truncated on ouput and are instead overwritten.
-.\"
 .SH RATIONALE
 
 The

docs/npc.1

@@ -11,7 +11,7 @@ npc \(en show non-printing characters
 .SH SYNOPSIS
 
 npc
-.RB ( -et )
+.RB [ -et ]
 .\"
 .SH DESCRIPTION
 

docs/peek.1

@@ -0,0 +1,111 @@
+.\" 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)

docs/str.1

@@ -11,8 +11,7 @@ str \(en test string arguments
 .SH SYNOPSIS
 
 str
-.RB [ type ]
-.RB [ string... ]
+.B type string...
 .\"
 .SH DESCRIPTION
 

docs/strcmp.1

@@ -4,15 +4,14 @@
 .\" 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 STRCMP 1 2024-06-17 "Harakit X.X.X"
+.TH STRCMP 1 2024-07-15 "Harakit X.X.X"
 .SH NAME
 strcmp \(en compare strings
 .\"
 .SH SYNOPSIS
 
 strcmp
-.RM [ string ]
-.RB [ strings... ]
+.B string string...
 .\"
 .SH DESCRIPTION
 
@@ -21,15 +20,15 @@ Check whether string arguments are the same.
 .SH DIAGNOSTICS
 
 The program will exit successfully if the strings are identical. Otherwise, it
-will exit with an error code of 1 if a string passed has a lesser byte value
-than one of the prior strings:
+will exit with an error code less than 128 if a string passed has a lesser byte
+value than one of the prior strings:
 
 .RS
 strcmp b a
 .RE
 
-or with an error code of 255 if it has a greater byte value than one of the
-prior strings:
+or with an error code greater than 128 if it has a greater byte value than one
+of the prior strings:
 
 .RS
 strcmp a b

docs/swab.1

@@ -11,11 +11,7 @@ swab \(en swap bytes
 .SH SYNOPSIS
 
 swab
-.RB ( -f )
-.RB ( -w
-.R [
-.B word size
-.R ])
+.RB [ -w\ word_size ]
 .\"
 .SH DESCRIPTION
 
@@ -23,13 +19,10 @@ Swap the latter and former halves of a block of bytes.
 .\"
 .SH OPTIONS
 
-.IP \fB-f\fP
-Ignore SIGINT signal.
-.IP \fB-w\fP
-Configures the word size; that is, the size in bytes of the block size
-on which to operate. The default word size is 2. The word size must be
-cleanly divisible by 2, otherwise the block of bytes being processed can\(cqt be
-halved.
+.IP \fB-w\fP\ \fIword_size\fP
+Configures the word size; that is, the size in bytes of the block size on which
+to operate. The default word size is 2. The word size must be cleanly divisible
+by 2, otherwise the block of bytes being processed can\(cqt be halved.
 .\"
 .SH EXAMPLES
 
@@ -40,6 +33,7 @@ line:
 .RS
 printf 'hello world!\(rsn' | swab
 .RE
+.\" If you change this, make sure to change it in tests/bonsai/swab.mk too.
 
 Produces the following output:
 

include/FreeBSD.mk

@@ -0,0 +1,6 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.

include/OpenBSD.mk

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+OSLIB = build/o/libopenbsd.rlib
+RUSTFLAGS += --extern openbsd=$(OSLIB)
+
+$(OSLIB): src/libopenbsd.rs
+	$(RUSTC) $(RUSTFLAGS) --crate-type=lib --crate-name=openbsd \
+		-o $@ src/libopenbsd.rs

src/dj.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -16,286 +17,133 @@
  * along with this program. If not, see https://www.gnu.org/licenses/.
  */
 
-#include <ctype.h> /* isupper(3), tolower(3) */
+#include <assert.h> /* assert(3) */
 #include <errno.h> /* errno */
 #include <fcntl.h> /* open(2) */
+#include <stdbool.h> /* bool */
 #include <stdio.h> /* fprintf(3), stderr */
-#include <stdlib.h> /* free(3), malloc(3), strtol(3), size_t */
+#include <stdlib.h> /* malloc(3), strtol(3), size_t */
 #include <string.h> /* memcpy(3), memmove(3), memset(3) */
-#include <sysexits.h> /* EX_OK, EX_USAGE */
+#include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
 #include <unistd.h> /* close(2), getopt(3), lseek(2), read(2), write(2),
-                     * optarg, optind, STDIN_FILENO, STDOUT_FILENO */
-extern int errno;
+                     * pledge(2), unveil(2), optarg, optind, STDIN_FILENO,
+					 * STDOUT_FILENO */
+#include <sys/stat.h> /* S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR */
+
+char *program_name = "dj";
 
 /* dj uses two structures that respectively correspond to the reading and
  * writing ends of its jockeyed "pipe". User-configurable members are noted
  * with their relevant options. */
 struct Io {
-	int bs;			/* buffer size (-bB) */
-	size_t bufuse;	/* buffer usage */
 	char *buf;      /* buffer */
-	int bytes;		/* bytes processed */
+	char *fn;       /* file name (-io) */
+	size_t bs;    	/* buffer size (-bB) */
+	size_t bufuse;	/* buffer usage */
+	size_t bytes; 	/* bytes processed */
+	size_t prec;  	/* partial records processed */
+	size_t rec;   	/* records processed */
+	long seek;  	/* remaining bytes to seek/skip (-sS) */
+	int error;  	/* errno */
 	int fd;         /* file descriptor */
 	int fl;         /* file opening flags */
-	char *fn;		/* file name (may be stdin_name or stdout_name) (-io) */
-	int prec;		/* partial records processed */
-	int rec;		/* records processed */
-	long seek;		/* bytes to seek/skip (will be 0 after skippage) (-sS) */
-} ep[2]; /* "engineered pipe"; also "extended play", for the deejay */
+};
 
-/* Additionally, the following global variables are used to store user options.
- */
-
-/* (-a)  */ static int align; /* Only the lower 8b are used but align is
-                               * negative if no alignment is being done. */
-
-/* (-c)  */ static int count; /* 0 if dj(1) runs until no more reads are
-                               * possible. */
-
-/* ASCII field separator delimited statistics */
-            static char *fmt_asv   = "%d\037%d\036%d\037%d\035%d\036%d\034";
-/* human-readable statistics */
-            static char *fmt_human = "%d+%d > %d+%d; %d > %d\n";
-/* pointer to chosen formatting */
-/* (-H)  */ static char *fmt_output; /* fmt_asv (default) or fmt_human (-H) */
-
-/* (-dq) */ static char debug;       /*
- *  -d  increments             dj -qq | 0 - no diagnostic output whatsoever
- *   -q decrements             dj -q  | 1 - typical output without
- *                                    |     notifications on partial reads or
- *                                    |     writes
- *                             dj     | 2 - typical output (default)
- *                             dj -d  | 3 - verbose status messages */
-
-/* (-n)  */ static char noerror;     /* 0 - exits on partial reads or writes
-                                      *     (default)
-                                      * 1 - retries on partial reads/writes
-                                      *     (-n) */
-
-/* Non-configurable defaults. */
-#define bs_default 1024 /* GNU dd(1) default; twice POSIX but a neat 2^10 */
-static char *program_name = "<no argv[0]>";
 static char *stdin_name = "<stdin>";
 static char *stdout_name = "<stdout>";
-static int read_flags = O_RDONLY; /* These flags are consistent with Busybox */
-static int write_flags = O_WRONLY | O_CREAT; /* dd(1). */
 
-/* Macro to set defaults for user-configurable options. */
-#define setdefaults do{ \
-	align = -1; \
-	count = 0; \
-	debug = 2; \
-	fmt_output = fmt_asv; \
-	noerror = 0; \
-	ep[0].fl = read_flags; \
-	Io_setdefaults(&ep[0]); \
-	ep[1].fl = write_flags; \
-	Io_setdefaults(&ep[1]); }while(0)
+static int creat_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
+	| S_IWOTH; /* Consistent with touch(1p). */
+static int read_flags = O_RDONLY; /* Consistent with Busybox dd(1). */
+static int write_flags = O_WRONLY | O_CREAT;
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
-/* Macro to check if fd is a std* file, e.g. stdin. */
-#define fdisstd(fd) \
-		((fd) == STDIN_FILENO \
-		|| (fd) == STDOUT_FILENO \
-		|| (fd) == STDERR_FILENO)
+/* Macro to check if fd is stdin or stdout */
+#define fdisstd(fd) ((fd) == STDIN_FILENO || (fd) == STDOUT_FILENO)
 
-/* Macro to call the cleanup functions that operate on struct io on the
- * particular io[2] used in main. Error conditions are not checked because this
- * is only used when the program is about to terminate (hence its name). */
-#define terminate(io) do{ \
-	Io_buffree(&(io)[0]); \
-	Io_buffree(&(io)[1]); \
-	Io_fdclose(&(io)[0]); \
-	Io_fdclose(&(io)[1]); }while(0)
-
-/* Allocates *io's buffer. Returns NULL if unsuccessful. */
-static void *
-Io_bufalloc(struct Io *io){
-
-	return (io->buf = malloc(io->bs * (sizeof *io->buf)));
-}
-
-/* Frees *io's buffer. Returns io. */
-static struct Io *
-Io_buffree(struct Io *io){
-
-	free(io->buf);
-
-	return io;
-}
-
-/* Fills the unused portion of io's buffer with padding, updating io->bufuse.
- * Returns io. */
-static struct Io *
-Io_bufrpad(struct Io *io, int padding){
-	
-	memset(io->buf + io->bufuse, padding, io->bs - io->bufuse);
-	io->bufuse = io->bs;
-
-	return io;
-}
-
-/* Copies from the buffer in src as much as possible to the free space in the
- * dest buffer, removing the copied units from src and permuting the remaining
- * units in the src buffer to the start of the buffer, modifying both the src
- * and dest bufuse and returning dest. */
-static struct Io*
-Io_bufxapp(struct Io *dest, struct Io *src){
-	int n;
-
-	n = MIN(src->bufuse, dest->bs - dest->bufuse);
-	memcpy(dest->buf + dest->bufuse, src->buf, n);
-	dest->bufuse += n;
-	memmove(src->buf, src->buf + n, src->bs - n);
-	src->bufuse -= n;
-
-	return dest;
-}
-
-/* Copies from the buffer in src to the buffer in dest no more than n units,
- * removing the copied units from src and permuting the remaining units in the
- * src buffer to the start of the buffer, modifying both the src and dest
- * bufuse and returning dest. */
-static struct Io*
-Io_bufxfer(struct Io *dest, struct Io *src, int n){
-
-	memcpy(dest->buf, src->buf, (dest->bufuse = n));
-	memmove(src->buf, src->buf + n, (src->bufuse -= n));
-
-	return dest;
-}
-
-/* Closes io->fn and returns -1 on error, otherwise io->fd. */
-static int
-Io_fdclose(struct Io *io){
-
-	return fdisstd(io->fd)
-		? 0
-		: close(io->fd);
-}
-
-/* Opens io->fn and saves the file descriptor into io->fd. Returns io->fd,
- * which will be -1 if an error occured. */
-static int
-Io_fdopen(struct Io *io, char *fn){
-	int fd;
-	
-	if((fd = open(fn, io->fl,
-					/* these are the flags used by touch(1p) */
-					S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))
-				!= -1
-			&& Io_fdclose(io) == 0){
-		io->fd = fd;
-		io->fn = fn;
-	}
-
-	return fd;
-}
-
-/* Seeks io->seek bytes through *io's file descriptor, (counter-intuitively)
- * returning -1 if successful and a sysexits.h exit code if an unrecoverable
- * error occurred. io->buf will be cleared of useful bytes and io->seek will
- * be set to zero to indicate the seek occurred. */
-static int
-Io_fdseek(struct Io *io){
-	int (*op)(int, void *, size_t);
-	
-	if(!fdisstd(io->fd) && lseek(io->fd, io->seek, SEEK_SET) != -1)
-		return -1;
-
-	/* repeated code to get the condition out of the loop */
-	if(io->fl == write_flags){
-		memset(io->buf, '\0', io->bs);
-		/* We're going to cheat and use bufuse as the retval for write(2),
-		 * which is fine because it'll be zeroed as this function returns
-		 * anyway. */
-		do{
-			if((io->bufuse = write(io->fd, io->buf, MIN(io->bs, io->seek)))
-					== 0)
-				/* second chance */
-				io->bufuse = write(io->fd, io->buf, MIN(io->bs, io->seek));
-		}while((io->seek -= io->bufuse) > 0 && io->bufuse != 0);
-	}else if(io->fl == read_flags){
-		do{
-			if((io->bufuse = read(io->fd, io->buf, MIN(io->bs, io->seek)))
-					== 0)
-				/* second chance */
-				io->bufuse = read(io->fd, io->buf, MIN(io->bs, io->seek));
-		}while((io->seek -= io->bufuse) > 0 && io->bufuse != 0);
-	}else
-		return EX_SOFTWARE;
-
-	io->bufuse = 0;
-
-	return -1;
-}
-
-/* Reads io->bs bytes from *io's file descriptor into io->buf, storing the
- * number of read bytes in io->bufuse and updating io->bytes. If io->bufuse is
- * 0, errno will probably be set. Returns io. */
+/* Completes one Io block read */
 static struct Io *
 Io_read(struct Io *io) {
+	int t;
 
-	io->bytes += (io->bufuse = read(io->fd, io->buf, io->bs));
+	assert(io->bs > 0);
+	assert(io->bufuse < io->bs);
+
+	if ((t = read(io->fd, &(io->buf)[io->bufuse], io->bs - io->bufuse)) < 0) {
+		io->error = errno;
+		t = 0;
+	}
+
+	io->bufuse += t;
+	io->bytes  += t;
+	io->prec   += (0 < io->bufuse && io->bufuse < io->bs);
+	io->rec    += (io->bufuse == io->bs);
+
+	assert(io->bufuse <= io->bs);
 
 	return io;
 }
 
-/* Sets the variables in a struct *io to the defaults. Identifies the read/
- * write ends of the "pipe" by checking io->fl. Returns io. */
-static struct Io *
-Io_setdefaults(struct Io *io){
-
-	io->bs = bs_default;
-	io->buf = NULL;
-	io->bytes = 0;
-	io->fd = (io->fl == read_flags) ? STDIN_FILENO : STDOUT_FILENO;
-	io->fn = (io->fl == read_flags) ? stdin_name   : stdout_name;
-	io->prec = 0;
-	io->rec = 0;
-	io->seek = 0;
-
-	return io;
-}
-
-/* Writes io->bufuse units from io->buf to io->fd, permuting any unwritten
- * bytes to the start of io->buf and updating io->bufuse. If io->bufuse doesn't
- * change, errno will probably be set. Returns io. */
+/* Completes one Io block write */
 static struct Io *
 Io_write(struct Io *io) {
 	int t;
 
-	if((t = write(io->fd, io->buf, io->bufuse)) > 0)
-		memmove(io->buf, io->buf + t, (io->bufuse -= t));
+	assert(io->bufuse > 0);
+	assert(io->bufuse <= io->bs);
+
+	if ((t = write(io->fd, io->buf, io->bufuse)) < 0) {
+		io->error = errno;
+		t = 0;
+	} else if (t > 0) {
+		(void)memmove(io->buf, &(io->buf)[t], (io->bufuse -= t));
+	}
+
 	io->bytes += t;
+	io->prec  += (t > 0 && io->bufuse > 0);
+	io->rec   += (t > 0 && io->bufuse == 0);
 
 	return io;
 }
 
-/* Prints an error message suitable for the event of an operating system error,
- * with the error itself to be described in the string s. */
 static int
-oserr(char *s){
-
-	fprintf(stderr, "%s: %s: %s\n", program_name, s, strerror(errno));
+oserr(char *e, int n) { /* program_name: [failing component:] error */
+	(void)fprintf(stderr, "%s: ", program_name);
+	if (e != NULL) { (void)fprintf(stderr, "%s: ", e); }
+	(void)fprintf(stderr, "%s\n", strerror(n));
 
 	return EX_OSERR;
 }
 
 /* Prints statistics regarding the use of dj, particularly partially and
- * completely read and written records, accessing debug, ep, and fmt_output. */
-static void
-output(void){
-
-	if(debug >= 1)
-		fprintf(stderr, fmt_output,
-			ep[0].rec, ep[0].prec, ep[1].rec, ep[1].prec,
-			ep[0].bytes, ep[1].bytes);
-
-	return;
+ * completely read and written records. */
+static int
+fprintio(FILE *stream, char *fmt, struct Io io[2]) {
+	return fprintf(
+		stream,
+		fmt,
+		io[0].rec,
+		io[0].prec,
+		io[1].rec,
+		io[1].prec,
+		io[0].bytes,
+		io[1].bytes
+	);
 }
 
+/* To be assigned to main:fmt and used with printio(). */
+static char *fmt_asv =
+	"%d" /* io[0].rec   */ "\037" /* ASCII US */
+	"%d" /* io[0].prec  */ "\036" /* ASCII RS */
+	"%d" /* io[1].rec   */ "\037" /* ASCII US */
+	"%d" /* io[1].prec  */ "\035" /* ASCII GS */
+	"%d" /* io[0].bytes */ "\036" /* ASCII RS */
+	"%d" /* io[1].bytes */ "\034" /* ASCII FS */
+	"\n"
+;
+static char *fmt_human = "%d+%d > %d+%d; %d > %d\n";
+
 /* Parses the string s to an integer, returning either the integer or in the
  * case of an error a negative integer. This is used for argument parsing
  * (e.g. -B [int]) in dj and no negative integer would be valid anyway. */
@@ -305,148 +153,286 @@ parse(char *s){
 
 	errno = 0;
 	r = strtol(s, &s, 0);
-	return (*s == '\0' /* no chars left unparsed */ && errno == 0)
-		? r
-		: -1;
+	return (*s == '\0' /* no chars left unparsed */ && errno == 0) ? r : -1;
 }
 
 static int
-usage(void){
-
-	fprintf(stderr, "Usage: %s (-AdfHqQ) (-a [byte]) (-c [count])\n"
-		"\t(-i [input file]) (-b [input block size]) (-s [input offset])\n"
-		"\t(-o [output file]) (-B [output block size]) (-S [output offset])\n",
-		program_name);
+usage(char *argv0) {
+	(void)fprintf(
+		stderr,
+		"Usage: %s [-Hn] [-a byte] [-c count]\n"
+		"\t[-i file] [-b block_size] [-s offset]\n"
+		"\t[-o file] [-B block_size] [-S offset]\n",
+		argv0
+	);
 
 	return EX_USAGE;
 }
 
 int main(int argc, char *argv[]) {
-	int c;
-	int i;
+   	int align;    /* low 8b used, negative if no alignment is being done */
+	int count;    /* -1 if dj(1) runs until no more reads are possible */
+	char *fmt;    /* set to fmt_asv (default) or fmt_human (-H) */
+	size_t i;     /* side of io (in or out) being modified */
+	bool retry;   /* false if exits on partial reads or writes */
+	struct Io io[2 /* { in, out } */];
 
-	setdefaults;
+#ifdef __OpenBSD__
+	if (pledge("cpath rpath stdio unveil wpath", NULL) == -1) {
+		return oserr(NULL, errno);
+	}
+#endif
+
+	/* Set defaults. */
+	align = -1;
+	count = -1;
+	fmt = fmt_asv;
+	retry = 0;
+	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
+		io[i].bs = 1024 /* 1 KiB */; /* GNU dd(1) default; POSIX says 512B */
+		io[i].bufuse = 0;
+		io[i].bytes = 0;
+		io[i].fd = i == 0 ? STDIN_FILENO : STDOUT_FILENO;
+		io[i].fn = i == 0 ? stdin_name   : stdout_name;
+		io[i].fl = i == 0 ? read_flags   : write_flags;
+		io[i].error = 0;
+		io[i].prec = 0;
+		io[i].rec = 0;
+		io[i].seek = 0;
+	}
 
 	if (argc > 0) {
+		int c;
+
 		program_name = argv[0];
-		while((c = getopt(argc, argv, "a:Ab:B:c:di:hHnqs:S:o:")) != -1)
+		while ((c = getopt(argc, argv, "a:b:B:c:i:hHns:S:o:")) != -1) {
 			switch (c) {
-			case 'i': case 'o':
+				case 'i': case 'o': /* input, output */
 					i = (c == 'o');
-				if(optarg[0] == '-' && optarg[1] == '\0'){ /* optarg == "-" */
-					ep[i].fd = (i == 0) ? STDIN_FILENO : STDOUT_FILENO;
-					ep[i].fn = (i == 0) ? stdin_name   : stdout_name;
+
+					/* optarg == "-" (stdin/stdout) */
+					if (optarg[0] == '-' && optarg[1] == '\0') { 
+						io[i].fd = i == 0 ? STDIN_FILENO : STDOUT_FILENO;
+						io[i].fn = i == 0 ? stdin_name   : stdout_name;
 						break;
-				}else if(Io_fdopen(&ep[i], optarg) != -1)
+					} else {
+						int fd;
+
+#ifdef __OpenBSD__
+						if (unveil(optarg, i == 0 ? "r" : "wc") == -1) {
+							return oserr(NULL, errno);
+						}
+#endif
+
+						if (
+							(fd = open(optarg, io[i].fl, creat_mode)) != -1
+							&& (fdisstd(io[i].fd) || close(io[i].fd) == 0)
+						) {
+							io[i].fd = fd;
+							io[i].fn = optarg;
 							break;
-				terminate(ep);
-				return oserr(optarg);
-			case 'A': align = '\0'; break;
-			case 'd': ++debug; break;
-			case 'n': noerror = 1; break;
-			case 'H': fmt_output = fmt_human; break;
-			case 'q': --debug; break;
-			case 'a':
-				if(optarg[0] != '\0' && optarg[1] == '\0'){
+						}
+					}
+
+					return oserr(optarg, errno);
+					/* UNREACHABLE */
+				case 'n': retry = 1; break; /* retry failed reads once */
+				case 'H': fmt = fmt_human; break; /* human-readable output */
+				case 'a': /* input buffer padding */
+					if (optarg[0] == '\0' || optarg[1] == '\0') {
 						align = optarg[0];
 						break;
 					}
 					/* FALLTHROUGH */
-			case 'c': case 'b': case 's': case 'B': case 'S':
-				if(c == 'c' && (count = parse(optarg)) >= 0)
-					break;
-				i = isupper(c);
-				c = tolower(c);
-				if((c == 'b' && (ep[i].bs = parse(optarg)) > 0)
-						|| (c == 's' && (ep[i].seek = parse(optarg)) >= 0))
-					break;
+				case 'c': /* number of reads */
+				case 'b': case 'B': /* input/output block size */
+				case 's': case 'S': /* (s)kip/(S)eek in input/output */
+					if (c == 'c' && (count = parse(optarg)) >= 0) { break; }
+
+					i = (c >= 'A' && c <= 'Z');
+					c |= 0x20; /* 0b 0010 0000 (ASCII) make lowercase */
+
+					if ( /* if -b or -s is parsed out correctly */
+						(c == 'b' && (io[i].bs = parse(optarg)) > 0)
+						|| (c == 's' && (io[i].seek = parse(optarg)) >= 0)
+					) { break; } /* don't error */
+
 					/* FALLTHROUGH */
 				default:
-				terminate(ep);
-				return usage();
+					return usage(program_name);
+			}
 		}
 	}
 
-	if(debug >= 3)
-		fprintf(stderr,
-			"argv0=%s\n"
-			"in=%s\tibs=%d\tskip=%ld\talign=%hhx\tcount=%d\n"
-			"out=%s\tobs=%d\tseek=%ld\tdebug=%2d\tnoerror=%d\n",
-			program_name,
-			ep[0].fn, ep[0].bs, ep[0].seek, align, count,
-			ep[1].fn, ep[1].bs, ep[1].seek, debug, noerror);
+#ifdef __OpenBSD__
+	if (unveil(NULL, NULL) == -1) { return oserr(NULL, errno); }
+#endif
 
-	if(argc > optind){
-		terminate(ep);
-		return usage();
-	}
+	assert(io->fd != STDIN_FILENO  || io->fl == read_flags);
+	assert(io->fd != STDOUT_FILENO || io->fl == write_flags);
 
-	for(i = 0; i <= 1; ++i){
-		if(Io_bufalloc(&ep[i]) == NULL){
-			fprintf(stderr, "%s: Failed to allocate %d bytes\n",
-				program_name, ep[i].bs);
-			terminate(ep);
+	if (argc > optind) { return usage(program_name); }
+
+	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
+		/* buffer allocation */
+		if ((io[i].buf = malloc(io[i].bs * (sizeof *(io[i].buf)))) == NULL) {
+			(void)fprintf(
+				stderr, "%s: Failed to allocate %zd bytes\n",
+				program_name, io[i].bs
+			);
 			return EX_OSERR;
-		}else if(ep[i].seek > 0)
-			switch(Io_fdseek(&ep[i])){
-			case EX_OK:
-				output();
-				terminate(ep);
-				return EX_OK;
+		}
+
+		/* easy seeking */
+		if (!fdisstd(io[i].fd) && lseek(io[i].fd, io[i].seek, SEEK_SET) != -1) {
+			io[i].seek = 0;
 		}
 	}
 
-	do{	/* read */
-		Io_read(&ep[0]);
-		if(!noerror && ep[0].bufuse == 0)
-			Io_read(&ep[0]); /* second chance */
-		if(ep[0].bufuse == 0) /* that's all she wrote */
-			break;
-		else if(ep[0].bufuse < ep[0].bs){
-			++ep[0].prec;
-			if(debug >= 2){
-				fprintf(stderr, "%s: Partial read:\n\t", program_name);
-				output();
+	assert(io[1].bufuse == 0); /* requirement for hard seeking */
+
+	/* hard seeking; t is io[1].bufuse, before Io_write subtracts from it */
+	for(size_t t; io[1].seek > 0; io[1].seek -= (t - io[1].bufuse)) {
+		(void)memset(
+			io[1].buf, '\0', /* set buf to all nulls */
+			(t = io[1].bufuse = MIN(io[1].bs, io[1].seek)) /* saturate block */
+		);
+
+		if (Io_write(&io[1])->bufuse == t && !retry && io[1].error == 0) {
+			(void)Io_write(&io[1]); /* second chance */
 		}
-			if(!noerror)
-				count = 1;
-			if(align >= 0)
-				Io_bufrpad(&ep[0], align);
-		}else
-			++ep[0].rec;
 
-		/* write */
-		do{	if(ep[1].bs > ep[0].bs){ /* io[1].bs > io[0].bs */
-				Io_bufxapp(&ep[1], &ep[0]);
-				if(ep[0].bs + ep[1].bufuse <= ep[1].bs && count != 1)
-					continue; /* we could write more */
-			}else
-				Io_bufxfer(&ep[1], &ep[0], MIN(ep[0].bufuse, ep[1].bs));
+		if (io[1].error != 0) { return oserr(io[1].fn, io[1].error); }
 
-			c = ep[1].bufuse;
-			Io_write(&ep[1]);
-			if(!noerror && ep[1].bufuse == c)
-				Io_write(&ep[1]); /* second chance */
-			if(c == ep[1].bufuse){ /* no more love */
+		if (io[1].bufuse == t) { break; } /* all writes failed! */
+	}
+
+	io[1].bufuse = 0; /* reset after hard seek */
+
+	if (io[1].seek > 0) { /* hard seeking failed */
+		(void)fprintio(stderr, fmt, io);
+		return oserr(io[1].fn, errno);
+	}
+
+	for (	;
+			count == -1 || count > 0;
+			count -= (count != -1) /* decrement if counting */
+	) {
+		assert(io[0].bufuse == 0);
+
+		{ /* read */
+			long skipping;
+			size_t t;
+
+			/* hack to intentionally get a partial read from Io_read */
+			if ((skipping = MIN(io[0].seek, io[0].bs)) > 0) {
+				io[0].bufuse = io[0].bs - (size_t)skipping;
+			}
+
+			t = io[0].bufuse;
+			if (Io_read(&io[0])->bufuse == t && !retry && io[0].error == 0) {
+				(void)Io_read(&io[0]); /* second chance */
+			}
+
+			assert(io[0].bufuse >= t);
+
+			if (io[0].bufuse == t) { break; } /* that's all she wrote */
+
+			if (/* t < io[0].bufuse && */ io[0].bufuse < io[0].bs) {
+				(void)fprintf(stderr, "%s: Partial read:\n\t", program_name);
+				(void)fprintio(stderr, fmt, io);
+
+				if (!retry) { count = 1; }
+
+				if (align >= 0) {
+					/* fill the rest of the ibuf with padding */
+					(void)memset(
+						&(io[0].buf)[io[0].bufuse],
+						align,
+						io[0].bs - io[0].bufuse
+					);
+
+					io->bufuse = io->bs;
+				}
+			}
+
+			if (skipping > 0) {
+				io[0].seek -= skipping;
+				io[0].bufuse = 0;
+				count += (count != -1); /* increment if counting */
+				continue;
+			}
+		}
+
+		assert(io[0].bufuse > 0);
+
+		while (io[0].bufuse > 0) { /* write */
+			if (io[0].bs <= io[1].bs) {
+				int n;
+
+				(void)memcpy( /* saturate obuf */
+					io[1].buf, io[0].buf,
+				   (io[1].bufuse = (n = MIN(io[0].bufuse, io[1].bs)))
+				);
+
+				/* permute the copied units out of ibuf */
+				(void)memmove(io[0].buf, &(io[0].buf)[n], (io[0].bufuse -= n));
+			} else /* if(io[0].bs > io[1].bs) */ {
+				int n;
+
+				/* drain what we can from ibuf */
+				(void)memcpy(
+					&(io[1].buf)[io[1].bufuse], io[0].buf,
+				    (n = MIN(io[0].bufuse, io[1].bs - io[1].bufuse))
+				);
+				io[1].bufuse += n;
+
+				/* permute out the copied units */
+				(void)memmove(io[0].buf, &(io[0].buf)[n], io[0].bs - n);
+				io[0].bufuse -= n;
+
+				if(io[0].bs + io[1].bufuse <= io[1].bs && count != 1) {
+					continue; /* obuf not saturated - we could write more */
+				}
+			}
+
+			{ /* writes actually happen, or die */
+				size_t t;
+
+				t = io[1].bufuse;
+				if (Io_write(&io[1])->bufuse == t
+						&& !retry
+						&& io[1].error == 0) {
+					(void)Io_write(&io[1]); /* second chance */
+				}
+
+				assert(io[1].error == 0 || io[1].bufuse == t);
+				/* if the Io_writes errored, bufuse wouldn't have changed, and
+				 * the error will be reported at the end of the read/write
+				 * loop */
+
+				assert(io[1].bufuse <= t);
+
+				if (io[1].bufuse == t) { /* no more love */
 					count = 1;
 					break;
-			}else if(c > ep[1].bufuse && ep[1].bufuse > 0){
-				ep[1].prec += 1;
-				if(debug >= 2){
-					fprintf(stderr, "%s: Partial write:\n\t", program_name);
-					output();
 				}
-				if(!noerror)
-					count = 1;
-			}else if(ep[1].bufuse == 0 && c < ep[1].bs)
-				++ep[1].prec;
-			else
-				++ep[1].rec;
-		}while(ep[0].bufuse > 0);
-	}while(count == 0 || --count > 0);
+			}
 
-	output();
-	terminate(ep);
+			if (0 < io[1].bufuse /* && io[1].bufuse < t */) {
+				(void)fprintf(stderr, "%s: Partial write:\n\t", program_name);
+				(void)fprintio(stderr, fmt, io);
+
+				if(!retry) { count = 1; }
+			}
+		}
+	}
+
+	(void)fprintio(stderr, fmt, io);
+
+	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
+		if (io[i].error) { return oserr(io[i].fn, io[i].error); }
+	}
 
 	return EX_OK;
 }

src/false.c

@@ -1,9 +1,19 @@
 /*
- * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2024 DTB <trinity@trinity.moe>
  * SPDX-License-Identifier: CC0
  *
  * This work is marked with CC0 1.0. To view a copy of this license, visit
  * <http://creativecommons.org/publicdomain/zero/1.0>.
  */
 
-int main() { return 1; }
+#ifdef __OpenBSD__
+#	include <unistd.h> /* pledge(2) */
+#endif
+
+int main(void) {
+#ifdef __OpenBSD__
+	(void)pledge("stdio", "");
+#endif
+	return 1;
+}

src/fileis.rs

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * 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/.
+ */
+
+use std::{
+	env::args,
+	fs::metadata,
+	os::unix::fs::{ FileTypeExt, MetadataExt },
+	process::ExitCode,
+};
+
+extern crate getopt;
+extern crate strerror;
+extern crate sysexits;
+
+use getopt::GetOpt;
+use strerror::StrError;
+use sysexits::EX_USAGE;
+
+const OPTS: &str = "bcdefgkprsuwxLS";
+
+fn usage(argv0: &str) -> ExitCode {
+	eprintln!("Usage: {} [-{}] file...", argv0, OPTS);
+	ExitCode::from(EX_USAGE)
+}
+
+fn main() -> ExitCode {
+	let argv = args().collect::<Vec<_>>();
+
+	let mut sel = String::with_capacity(OPTS.len()); // selected options
+	let mut optind: usize = 1; // argv[0]
+
+	while let Some(opt) = argv.getopt(OPTS) {
+		if let Ok(optchr) = opt.opt() { sel.push_str(optchr); }
+		else { return usage(&argv[0]); }
+
+		optind = opt.ind();
+	}
+
+	if optind == argv.len() { return usage(&argv[0]); }
+
+	for arg in argv.iter().skip(optind) {
+		let fmeta = match metadata(arg) {
+			Ok(m) => m,
+			Err(e) => { // no perms or nonexistent
+				eprintln!("{}: {}: {}", argv[0], arg, e.strerror());
+				return ExitCode::FAILURE;
+			},
+		};
+
+		let fmode = fmeta.mode();
+		let ftype = fmeta.file_type();
+
+		for selection in sel.chars() { // run all selected tests
+			match selection {
+				'b' if ftype.is_block_device() => (),
+				'c' if ftype.is_char_device() => (),
+				'e' => (), // exists or metadata would have errored
+				'd' if fmeta.is_dir() => (),
+				'f' if fmeta.is_file() => (),
+				'g' if fmode & 0o2000 /* S_ISGID */ != 0 => (), // setgid
+				'k' if fmode & 0o1000 /* S_ISVTX */ != 0 => (), // setvtx
+				'p' if ftype.is_fifo() => (),
+				'r' if fmode & 0o0400 /* S_IRUSR */ != 0 => (), // read access
+				'u' if fmode & 0o4000 /* S_ISUID */ != 0 => (), // setuid
+				'w' if fmode & 0o0200 /* S_IWUSR */ != 0 => (), // write access
+				'x' if fmode & 0o0100 /* S_IXUSR */ != 0 => (), // exec access
+				'L' if fmeta.is_symlink() => (),
+				'S' if ftype.is_socket() => (),
+				_ => { return ExitCode::FAILURE; }
+			}
+		}
+	}
+
+	ExitCode::SUCCESS
+}

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;
@@ -30,97 +30,138 @@ use getopt::GetOpt;
 use strerror::StrError;
 use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
 
-fn main() {
-	let argv = args().collect::<Vec<String>>();
-	let mut d = '\u{1E}'.to_string();
-	let mut index_arg = 0;
+#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
+#[cfg(target_os="openbsd")] extern crate openbsd;
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
-	let usage = format!(
-		"Usage: {} [-d delimiter] index command [args...]",
-		argv[0],
-	);
+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("exec proc stdio unveil");
+		if let Err(e) = pledge(Some(promises), None) {
+			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);
+		}
+	}
+
+	if argv.len() == 1 { return ExitCode::from(usage(&argv[0])); }
 
 	while let Some(opt) = argv.getopt("d:") {
 		match opt.opt() {
-			Ok(_) => {
-				/* unwrap because Err(OptError::MissingArg) will be returned if
-				 * opt.arg() is None */
+			Ok("d") => {
+				/* delimiter */
 				d = opt.arg().unwrap();
-				index_arg = opt.ind();
+				optind = opt.ind();
 			},
-			Err(_) => {
-				eprintln!("{}", usage);
-				exit(EX_USAGE);
+			_ => {
+				return ExitCode::from(usage(&argv[0]));
 			}
 		};
 	}
 
-	let command_arg = index_arg as usize + 1;
-
-	argv.get(command_arg).unwrap_or_else(|| {
-		eprintln!("{}", usage);
-		exit(EX_USAGE);
-	});
-
-	let index = argv[index_arg].parse::<usize>().unwrap_or_else(|e| {
+	/* 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 */
+	let command_arg = optind as usize + 1;
+
+	/* argv[0] of the operator command */
+	let operator = argv.get(command_arg).unwrap_or_else(|| {
+		exit(usage(&argv[0]).into());
+	});
+
+	/* read entire standard input into memory */
 	let mut buf = String::new();
-	let _ = stdin().read_to_string(&mut buf);
+	if let Err(e) = stdin().read_to_string(&mut buf) {
+		err(&argv[0], e);
+		exit(EX_IOERR.into());
+	};
+
+	/* split the buffer by the delimiter (by default, '\u{1E}') */
 	let mut fields = buf.split(&d).collect::<Vec<&str>>();
 
-	let opts = argv
+	/* collect arguments for the operator command */
+	let command_args = argv
 		.iter()
 		.clone()
-		.skip(command_arg + 1)
+		.skip(command_arg + 1) /* skip the command name */
 		.collect::<Vec<&String>>();
 
-	let mut spawned = Command::new(argv.get(command_arg).unwrap())
-		.args(opts)
+	/* spawn the command to operate on the field */
+	let mut spawned = Command::new(operator)
+		.args(command_args) /* spawn with the specified arguments */
 		.stdin(Stdio::piped())
-		.stdout(Stdio::piped())
+		.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 */
 	if let Some(mut child_stdin) = spawned.stdin.take() {
 		let _ = child_stdin.write_all(field.as_bytes());
-		drop(child_stdin);
+		drop(child_stdin); /* stay safe! drop your children! */
 	}
 
 	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 */
 	let mut replace = output.stdout.clone();
 
-	if replace.pop() != Some(b'\n') { replace = output.stdout; }
+	/* pop trailing newline out if the input did not contain it */
+	if fields[index].chars().last() != Some('\n') /* no newline */
+		&& replace.pop() != Some(b'\n') { /* pop last char of replacement */
+		/* restore replacement to original command output if popped char was not
+		 * a newline */
+		replace = output.stdout;
+	}
 
+	/* 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 */
 	fields[index] = &new_field;
 
+	/* fop it */ 
 	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 },
 };
 
@@ -27,42 +27,61 @@ extern crate strerror;
 extern crate sysexits;
 
 use strerror::StrError;
-use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE };
+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, unveil };
+
+/* list of SI prefixes */
 const LIST: [(u32, &str); 10] = [
-	(3, "k"),
-	(6, "M"),
-	(9, "G"),
-	(12, "T"),
-	(15, "P"),
-	(18, "E"),
-	(21, "Z"),
-	(24, "Y"),
-	(27, "R"),
-	(30, "Q")
+	(3, "k"), /* kilo */
+	(6, "M"), /* mega */
+	(9, "G"), /* giga */
+	(12, "T"), /* tera */
+	(15, "P"), /* peta */
+	(18, "E"), /* exa */
+	(21, "Z"), /* zetta */
+	(24, "Y"), /* yotta */
+	(27, "R"), /* ronna */
+	(30, "Q"), /* quetta */
 ];
 
-fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
+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, "")); 
-	if input < 1000 { return Ok(out); }
+
+	if input < 1000 { return Ok(out); } /* too low to convert */
 
 	for (n, p) in LIST {
 		let c = match 10_u128.checked_pow(n) {
 			Some(c) => c,
-			None => {
+			None => { /* too big for the laws of computing :( */
 				return Err(format!("10^{}: Integer overflow", n.to_string()));
 			},
 		};
 
 		match c.cmp(&input) {
-			Ordering::Less => {
+			Ordering::Less => { /* c < input */
+				/* the program will keep assigning out every loop until either
+				 * the list runs out of higher prefix bases or the input is
+				 * greater than the prefix base */
 				out = (input as f64 / c as f64, (n, p));
 			},
-			Ordering::Equal => {
+			Ordering::Equal => { /* c == input */
 				return Ok((input as f64 / c as f64, (n, p)));
 			},
-			Ordering::Greater => {},
+			Ordering::Greater => {}, /* c > input */
 		};
 	}
 
@@ -71,8 +90,26 @@ 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) { return usage(&argv[0]); }
+
+	#[cfg(target_os="openbsd")] {
+		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 let Err(e) = stdin().read_line(&mut buf) {
+		return err(&argv[0], e.strerror(), Some(EX_IOERR));
+	}
+
 	if buf.is_empty() { return ExitCode::SUCCESS; }
 
 	let n: u128 = match buf.trim().parse() {
@@ -80,29 +117,22 @@ fn main() -> ExitCode {
 			buf.clear();
 			f
 		},
-			Err(err) => {
-				eprintln!("{}: {}", argv[0], err);
-				return ExitCode::from(EX_DATAERR as u8);
-			},
+		Err(e) => return err(&argv[0], e.to_string(), Some(EX_DATAERR)),
 	};
 
-		let (number, prefix) = match convert(n) {
-			Ok(x) => x,
-			Err(err) => {
-				eprintln!("{}: {}", argv[0], err);
-				return ExitCode::from(EX_SOFTWARE as u8);
-			},
-		};
-
-		let si_prefix = format!("{}B", prefix.1);
-
-		let out = ((number * 10.0).round() / 10.0).to_string();
-
-		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
-			.unwrap_or_else(|e| {
-				eprintln!("{}: {}", argv[0], e.strerror());
-				exit(EX_IOERR);
+	let (number, prefix) = convert(n).unwrap_or_else(|e| {
+		let _ = err(&argv[0], e.to_string(), None);
+		exit(EX_SOFTWARE.into());
 	});
+
+	let si_prefix = prefix.1.to_owned() + "B";
+
+	/* 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.c

@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2023 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 <errno.h> /* errno */
-#include <stdio.h> /* fprintf(3), stderr */
-#include <stdlib.h> /* strtol(3), size_t, EXIT_FAILURE */
-#include <unistd.h> /* getopt(3), optind */
-#include <sysexits.h>
-
-/* 0b00? */		/*                     Equal | -e  | 0b001 | 1 */
-#define EQUAL	0x01	/*                   Greater | -g  | 0b010 | 2 */
-/* 0b0?0 */		/*          Greater or Equal | -ge | 0b011 | 3 */
-#define GREATER	0x02	/*                      Less | -l  | 0b100 | 4 */
-/* 0b?00 */		/*             Less or Equal | -le | 0b101 | 5 */
-#define LESS	0x04	/* Inequal (Greater or Less) | -gl | 0b110 | 6 */
-
-static char *program_name = "intcmp";
-
-int main(int argc, char *argv[]){
-	int c;
-	size_t i;
-	unsigned char mode;
-	int r; /* reference integer */
-
-	mode = 0;
-
-	if(argc < 3)
-		goto usage;
-
-	while((c = getopt(argc, argv, "egl")) != -1)
-		switch(c){
-		case 'e': mode |= EQUAL;   break;
-		case 'g': mode |= GREATER; break;
-		case 'l': mode |= LESS;	   break;
-		default:  goto usage;
-		}
-
-	if(optind + 2 /* ref cmp */ > argc){
-usage:		fprintf(stderr,
-			"Usage: %s (-eghl) [integer] [integer...]\n",
-			argv[0] == NULL ? program_name : argv[0]);
-		return EX_USAGE;
-	}
-
-	i = optind;
-
-	do{	r = c;
-		c = strtol(argv[i], &argv[i], 10);
-		if(*argv[i] != '\0' || errno != 0){
-			fprintf(stderr, "%s: argument #%d: Invalid integer\n",
-				argv[0], (int)i);
-			return EX_USAGE;
-		}
-
-		if(i == optind)
-			continue;
-
-		/* rule enforcement; if a mode isn't permitted and the numbers
-		 * correspond to it, return 1 */
-		if(		(!(mode & EQUAL) && r == c)
-				|| (!(mode & GREATER) && r > c)
-				|| (!(mode & LESS) && r < c))
-			return 1;
-	}while(++i < argc);
-	
-	return 0;
-}

src/intcmp.rs

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * 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/.
+ */
+
+use std::{
+	env::args,
+	process::ExitCode
+};
+
+extern crate getopt;
+extern crate sysexits;
+
+use getopt::GetOpt;
+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, unveil };
+#[cfg(target_os="openbsd")] use strerror::StrError;
+
+fn err(argv0: &String, e: String, code: u8) -> ExitCode {
+	eprintln!("{}: {}", argv0, e);
+	ExitCode::from(code)
+}
+
+fn usage(argv0: &String) -> 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 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);
+		}
+	}
+
+	let mut e = false; /* args can be == */
+	let mut g = false; /* args can be > */
+	let mut l = false; /* args can be < */
+	let mut optind = 0;
+
+	if argv.len() < 3 { return usage(&argv[0]); }
+
+	while let Some(opt) = argv.getopt("egl") {
+		match opt.opt() {
+			Ok("e") => e = true,
+			Ok("g") => g = true,
+			Ok("l") => l = true,
+			_ => return usage(&argv[0]),
+		}
+		optind = opt.ind();
+	}
+
+	if !e & !g & !l { return usage(&argv[0]); }
+
+	if argv.len() - optind < 2 /* see usage */ { return usage(&argv[0]); }
+
+	let mut prev: Option<usize> = None; /* no previous operand */
+	let mut currn: usize;
+
+	for arg in argv.iter().skip(optind) { /* iterate operands */
+		match arg.parse::<usize>() { /* parse current operand */
+			Ok(n) => currn = n,
+			Err(e) => {
+				let error = arg.to_owned() + ": " + &e.to_string();
+				return err(&argv[0], error, EX_DATAERR);
+			}
+		}
+
+		if let Some(prevn) = prev { /* if there was a previous opr., test */
+			if (!e && prevn == currn)
+					|| (!g && prevn > currn)
+					|| (!l && prevn < currn)
+				{ return ExitCode::FAILURE; }
+		}
+
+		prev = Some(currn); /* there is a previous operand */
+	}
+
+	ExitCode::SUCCESS
+}

src/libopenbsd.rs

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * 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/.
+ */
+
+use std::{
+	ffi::{ CString, c_char },
+	io::Error,
+	ptr::null,
+};
+
+mod openbsd {
+	use std::ffi::{ c_char, c_int };
+	extern "C" {
+		pub fn pledge(arg1: *const c_char, arg2: *const c_char) -> c_int;
+
+		pub fn unveil(arg1: *const c_char, arg2: *const c_char) -> c_int;
+
+		pub fn __errno() -> *mut c_int;
+	}
+}
+
+pub struct Promises(*const c_char);
+
+impl Promises {
+	pub fn new(promises: &str) -> Self {
+		let p = CString::new(promises).unwrap();
+
+		Promises(p.into_raw() as *const c_char)
+	}
+}
+
+impl Default for Promises {
+	fn default() -> Self { Promises::new("") }
+}
+
+pub fn pledge(
+	promises: Option<Promises>, execpromises: Option<Promises>
+) -> Result<(), Error> {
+	/* From pledge(2):
+	 *
+	 * Passing NULL to promises or execpromises specifies to not change
+	 * the current value. */
+	let arg1 = promises.unwrap_or(Promises(null())).0;
+	let arg2 = execpromises.unwrap_or(Promises(null())).0;
+
+	unsafe {
+		match openbsd::pledge(arg1, arg2) {
+			-1 => Err(Error::from_raw_os_error(*openbsd::__errno())),
+			0 => Ok(()),
+			_ => panic!(), /* unreachable */
+		}
+	}
+}
+
+pub struct UnveilPerms(CString);
+
+impl UnveilPerms {
+	pub fn new<T: IntoIterator<Item = char>>(permissions: T) -> Self {
+		let perms = CString::new(
+			permissions.into_iter().collect::<String>()
+		).unwrap();
+		
+		UnveilPerms(perms)
+	}
+}
+
+pub fn unveil(
+	path: Option<&str>,
+	permissions: Option<UnveilPerms>,
+) -> Result<(), Error> {
+	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());
+
+	unsafe {
+		match openbsd::unveil(arg1, arg2) {
+			-1 => Err(Error::from_raw_os_error(*openbsd::__errno())),
+			0 => Ok(()),
+			_ => panic!(), /* unreachable */
+		}
+	}
+}

src/mm.c

@@ -1,236 +0,0 @@
-/*
- * Copyright (c) 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 <errno.h> /* errno */
-#include <signal.h> /* signal(2), SIG_ERR, SIG_IGN, SIGINT */
-#include <stdio.h> /* fclose(3), fopen(3), fprintf(3), getc(3), putc(3),
-                    * setvbuf(3), size_t, _IONBF, NULL */
-#include <stdlib.h> /* free(3), realloc(3) */
-#include <string.h> /* strcmp(3), strerror(3) */
-#include <unistd.h> /* getopt(3) */
-#if !defined EX_IOERR || !defined EX_OK || !defined EX_OSERR \
-		|| !defined EX_USAGE
-#	include <sysexits.h>
-#endif
-extern int errno;
-
-/* This structure is how open files are tracked. */
-struct Files{
-	size_t a;	/* allocation */
-	size_t s;	/* used size */
-	char *mode;	/* file opening mode */
-	char **names;	/* file names */
-	FILE **files;	/* file pointers */
-};
-
-/* How much to grow the allocation when it's saturated. */
-#ifndef ALLOC_INCREMENT
-#	define ALLOC_INCREMENT 1
-#endif
-
-/* How much to grow the allocation at program start. */
-#ifndef ALLOC_INITIAL
-#	define ALLOC_INITIAL 10
-#endif
-
-/* pre-allocated strings */
-static char *program_name = "<no argv[0]>";
-static char *stdin_name = "<stdin>";
-static char *stdout_name = "<stdout>";
-static char *stderr_name = "<stderr>";
-static char *(fmode[]) = { (char []){"rb"}, (char []){"rb+"} };
-static char *wharsh = "wb";
-
-/* Adds the open FILE pointer for the file at the path s to the files struct,
- * returning the FILE if successful and NULL if not, allocating more memory in
- * the files buffers as needed. */
-static FILE *
-Files_append(struct Files *files, FILE *file, char *name){
-
-	if(file == NULL || (files->s == files->a
-			&& ((files->files = realloc(files->files,
-					(files->a += (files->a == 0)
-						? ALLOC_INITIAL
-						: ALLOC_INCREMENT)
-					* sizeof *(files->files))) == NULL
-				|| (files->names = realloc(files->names,
-					files->a * sizeof *(files->names))) == NULL)))
-		return NULL;
-
-	files->names[files->s] = name;
-	return files->files[files->s++] = file;
-}
-
-/* Opens the file at the path p and puts it in the files struct, returning NULL
- * if either the opening or the placement of the open FILE pointer fail. */
-#define Files_open(files, p) \
-	Files_append((files), fopen((p), (files)->mode), (p))
-
-/* Prints a diagnostic message based on errno and returns an exit status
- * appropriate for an OS error. */
-static int
-oserr(char *s, char *r){
-
-	fprintf(stderr, "%s: %s: %s\n", s, r, strerror(errno));
-
-	return EX_OSERR;
-}
-
-/* Hijacks i and j from main and destructs the files[2] struct used by main by
- * closing its files and freeing its files and names arrays, returning retval
- * from main. */
-#define terminate \
-	for(i = 0; i < 2; ++i){ \
-		for(j = 0; j < files[i].s; ++j) \
-			if(files[i].files[j] != stdin \
-					&& files[i].files[j] != stdout \
-					&& files[i].files[j] != stderr) \
-				fclose(files[i].files[j]); \
-		free(files[i].files); \
-		free(files[i].names); \
-	} \
-	return retval
-
-/* Prints a usage text, in which s is the program being run (i.e. argv[0]), and
- * returns an exit status appropriate for a usage error. */
-int usage(char *s){
-
-	fprintf(stderr, "Usage: %s (-aenu) (-i [input])... (-o [output])...\n", s);
-
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]){
-	int c;
-	struct Files files[2]; /* {read, write} */
-	size_t i;
-	size_t j;
-	size_t k; /* loop index but also unbuffer status */
-	int retval;
-
-	/* Initializes the files structs with their default values, standard
-	 * input and standard output. If an input or an output is specified
-	 * these initial values will be overwritten, so to, say, use mm(1)
-	 * equivalently to tee(1p), -o - will need to be specified before
-	 * additional files to ensure standard output is still written. */
-	for(i = 0; i < 2; ++i){
-		files[i].a = 0;
-		files[i].s = 0;
-		files[i].mode = fmode[i];
-		files[i].files = NULL;
-		files[i].names = NULL;
-		Files_append(&files[i], i == 0 ? stdin : stdout,
-			i == 0 ? stdin_name : stdout_name);
-		files[i].s = 0;
-	}
-
-	k = 0;
-
-	if(argc > 0)
-		program_name = argv[0];
-
-	if(argc > 1)
-		while((c = getopt(argc, argv, "aehi:no:u")) != -1)
-			switch(c){
-			case 'a': /* "rb+" -> "ab" */
-				files[1].mode[0] = 'a';
-				files[1].mode[2] = '\0';
-				break;
-			case 'e':
-				if(Files_append(&files[1], stderr, stderr_name) != NULL)
-					break;
-				retval = oserr(argv[0], "-e");
-				terminate;
-			case 'i':
-				if((strcmp(optarg, "-") == 0 && Files_append(&files[0],
-							stdin, stdin_name) != NULL)
-						|| Files_open(&files[0], optarg) != NULL)
-					break;
-				retval = oserr(argv[0], optarg);
-				terminate;
-			case 'o':
-				if((strcmp(optarg, "-") == 0 && Files_append(&files[1],
-							stdout, stdout_name) != NULL)
-						|| Files_open(&files[1], optarg) != NULL)
-					break;
-				/* does not exist, so try to create it */
-				if(errno == ENOENT){
-					files[1].mode = wharsh;
-					if(Files_open(&files[1], optarg) != NULL){
-						files[1].mode = fmode[1];
-						break;
-					}
-				}
-				retval = oserr(argv[0], optarg);
-				terminate;
-			case 'n':
-				if(signal(SIGINT, SIG_IGN) != SIG_ERR)
-					break;
-				retval = oserr(argv[0], "-n");
-				terminate;
-			case 'u':
-				k = 1;
-				break;
-			default:
-				retval = usage(argv[0]);
-				terminate;
-			}
-
-	if(optind != argc){
-		retval = usage(argv[0]);
-		terminate;
-	}
-
-	files[0].s += files[0].s == 0;
-	files[1].s += files[1].s == 0;
-	
-	/* Unbuffer files. */
-	if(k){
-		for(i = 0;
-			i < files[0].s;
-			setvbuf(files[0].files[i++], NULL, _IONBF, 0));
-		for(i = 0;
-			i < files[1].s;
-			setvbuf(files[1].files[i++], NULL, _IONBF, 0));
-	}
-
-	retval = EX_OK;
-
-	/* Actual program loop. */
-	for(i = 0; i < files[0].s; ++i) /* iterate ins */
-		while((c = getc(files[0].files[i])) != EOF) /* iterate chars */
-			for(j = 0; j < files[1].s; ++j) /* iterate outs */
-				if(putc(c, files[1].files[j]) == EOF){
-					/* notebook's full */
-					retval = EX_IOERR;
-					fprintf(stderr, "%s: %s: %s\n",
-						program_name, files[1].names[j], strerror(errno));
-					if(fclose(files[1].files[j]) == EOF)
-						fprintf(stderr, "%s: %s: %s\n",
-							program_name, files[1].names[j], strerror(errno));
-					/* massage out the tense muscle */
-					for(k = j--; k < files[1].s - 1; ++k){
-						files[1].files[k] = files[1].files[k+1];
-						files[1].names[k] = files[1].names[k+1];
-					}
-					if(--files[1].s == 0)
-						terminate;
-				}
-
-	terminate;
-}

src/mm.rs

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 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/.
+ */
+
+use std::{
+	env::args,
+	fs::File,
+	io::{ Error, BufWriter, Read, Write, stderr, stdin, stdout },
+	os::fd::{ AsRawFd, FromRawFd },
+	process::{ ExitCode, exit},
+};
+
+extern crate getopt;
+extern crate strerror;
+extern crate sysexits;
+
+use getopt::GetOpt;
+use strerror::StrError;
+use sysexits::{ EX_IOERR, EX_USAGE };
+
+#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
+#[cfg(target_os="openbsd")] extern crate openbsd;
+#[cfg(target_os="openbsd")]
+use openbsd::{
+	Promises,
+	UnveilPerms,
+	pledge,
+	unveil,
+};
+
+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<_>>();
+
+	#[cfg(target_os="openbsd")] {
+		let promises = Promises::new("cpath rpath stdio unveil wpath");
+		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+			return err(&argv[0], e, Some(EX_OSERR));
+		}
+	}
+
+	let mut a = false; /* append to the file */
+	let mut e = false; /* use stderr as an output */
+	let mut t = true; /* do not truncate the file before writing */
+	let mut u = false; /* unbuffer i/o */
+	let mut ins = Vec::new(); /* initial input file path vector */
+	let mut outs = Vec::new(); /* initial output file path vector */
+	let mut mode: Option<ArgMode> = None; /* mode set by last-used option */
+	let mut optind = 0;
+
+	while let Some(opt) = argv.getopt("aei:o:tu") {
+		match opt.opt() {
+			Ok("a") => a = true,
+			Ok("e") => e = true, 
+			Ok("u") => u = true,
+			Ok("t") => t = false,
+			Ok("i") => { /* add inputs */
+				let input = opt.arg().unwrap();
+				ins.push(input);
+				mode = Some(In); /* latest argument == -i */
+			},
+			Ok("o") => { /* add output */
+				let output = opt.arg().unwrap();
+				outs.push(output);
+				mode = Some(Out); /* latest argument == -o */
+			},
+			Err(_) | Ok(_) => {
+				return usage(&argv[0]);
+			},
+		};
+
+		optind = opt.ind();
+	}
+
+	let remaining = argv.iter().skip(optind);
+
+	/* check the last flag specified */
+	if let Some(m) = mode {
+		for arg in remaining {
+			/* move the subsequent arguments to the list of inputs or outputs */
+			match m {
+				In => ins.push(arg.to_string()),
+				Out => outs.push(arg.to_string()),
+			};
+		}
+	}
+
+	#[cfg(target_os="openbsd")] {
+		for input in &ins {
+			let perms = UnveilPerms::new(['r']);
+
+			if let Err(e) = unveil(Some(&input), Some(perms)) {
+				return err(&argv[0], e, Some(EX_OSERR));
+			}
+		}
+
+		for output in &outs {
+			let perms = UnveilPerms::new(['c', 'w']);
+
+			if let Err(e) = unveil(Some(&output), Some(perms)) {
+				return err(&argv[0], e, Some(EX_OSERR));
+			}
+		}
+
+		if let Err(e) = unveil(None, None) {
+			return err(&argv[0], e, Some(EX_OSERR));
+		}
+	}
+
+	if ins.is_empty() && outs.is_empty() && argv.len() > optind {
+		return usage(&argv[0]);
+	}
+
+	/* use stdin if no inputs are specified */
+	if ins.is_empty() { ins.push("-".to_string()); }
+
+	/* use stdout if no outputs are specified */
+	if outs.is_empty() && !e { outs.push("-".to_string()); }
+	
+	/* map all path strings to files */
+	let inputs = ins.iter().map(|file| {
+		/* if a file is “-”, it is stdin */
+		if *file == "-" {
+			/* portable way to access stdin as a file */
+			return unsafe { File::from_raw_fd(stdin().as_raw_fd()) };
+		}
+
+		match File::open(file) {
+			Ok(f) => f,
+			Err(e) => {
+				let _ = err(&(argv[0].clone() + ": " + file), e, None);
+				exit(EX_IOERR.into());
+			},
+		}
+	}).collect::<Vec<_>>();
+
+	/* map all path strings to files */
+	let mut outputs = outs.iter().map(|file| {
+		/* of a file is “-”, it is stdout */
+		if *file == "-" {
+			/* portable way to access stdout as a file */
+			return unsafe { File::from_raw_fd(stdout().as_raw_fd()) }; 
+		}
+
+		let options = File::options()
+			/* don’t truncate if -t is specified, append if -a is specified */
+			.truncate(t)
+			.append(a)
+			/* enable the ability to create and write to files */
+			.create(true)
+			.write(true)
+			/* finally, open the file! */
+			.open(file);
+
+		match options {
+			Ok(f) => return f,
+			Err(e) => {
+				let _ = err(&(argv[0].clone() + ": " + file), e, None);
+				exit(EX_IOERR.into());
+			},
+		};
+	}).collect::<Vec<_>>();
+
+	/* if -e is specified, use stderr */
+	if e {
+		/* portable way to access stderr as a file */
+		outputs.push(unsafe { File::from_raw_fd(stderr().as_raw_fd()) });
+	}
+
+	let mut outputs = outputs.iter().map(|o| {
+		if u {
+			/* unbuffered writing through a buffer of capacity 0 */
+			BufWriter::with_capacity(0, o)
+		} else {
+			/* theoretically buffered writing */
+			BufWriter::new(o)
+		}
+	}).collect::<Vec<_>>();
+
+	for file in inputs {
+		for byte in file.bytes().map(|b| {
+			b.unwrap_or_else(|e| {
+				let _ = err(&argv[0], e, None);
+				exit(EX_IOERR.into());
+			})
+		}) {
+			for out in &mut outputs {
+				if let Err(e) = out.write(&[byte]) {
+					return err(&argv[0], e, Some(EX_IOERR));
+				}
+
+				if u {
+					/* immediately flush the output for -u */
+					if let Err(e) = out.flush() { 
+						return err(&argv[0], e, Some(EX_IOERR));
+					}
+				}
+			}
+		}
+	}
+
+	ExitCode::SUCCESS
+}

src/npc.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2023 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -16,46 +17,72 @@
  * along with this program. If not, see https://www.gnu.org/licenses/.
  */
 
-#include <stdio.h> /* fprintf(3), fputs(3), getc(3), putc(3), stdin, stdout,
-                    * EOF */
-#include <stdlib.h> /* EXIT_FAILURE, EXIT_SUCCESS */
-#include <unistd.h> /* getopt(3) */
-#include <sysexits.h>
+#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> /* NULL, getopt(3), pledge(2), unveil(2) */
 
-int main(int argc, char *argv[]){
-	int c;
-	char showend;
-	char showtab;
+char *program_name = "npc";
 
-	showend = 0;
-	showtab = 0;
+static int
+ioerr(char *argv0) {
+	perror(argv0);
 
-	if(argc > 0)
-		while((c = getopt(argc, argv, "et")) != -1)
-			switch(c){
-			case 'e':	showend = 1; break;
-			case 't':	showtab = 1; break;
-			default:	goto usage;
+	return EX_IOERR;
 }
 
-	if(argc > optind){
-usage:		fprintf(stderr, "Usage: %s (-eht)\n", argv[0]);
+static int
+usage(char *argv0) {
+	(void)fprintf(stderr, "Usage: %s [-et]\n", argv0);
+
 	return EX_USAGE;
 }
 
+int main(int argc, char *argv[]) {
+	int c;
+	char showend = 0; /* print a dollar sign before each newline */
+	char showtab = 0; /* prints tab characters in caret notation */
+
+#ifdef __OpenBSD__
+	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL)) {
+		perror(argv[0] == NULL ? program_name : argv[0]);
+		return EX_OSERR;
+	}
+#endif
+
+	if (argc > 0) {
+		program_name = argv[0];
+
+		while ((c = getopt(argc, argv, "et")) != -1) {
+			switch (c){
+				case 'e': showend = 1; break;
+				case 't': showtab = 1; break;
+				default:  return usage(program_name);
+			}
+		}
+	}
+
+	if (argc > optind) { return usage(program_name); }
+
 	while ((c = getc(stdin)) != EOF) {
-		if((c & 0x80) != 0)
-			fputs("M-", stdout);
+		if ((c & 0x80) != 0 && fputs("M-", stdout) == EOF) {
+			return ioerr(argv[0]);
+		}
+
 		switch (c ^ 0x80 /* 0b 1000 0000 */) {
-		case 0x7f:	fputs("^?", stdout);
+			case 0x7f: /* ASCII DEL (127d) */
+				if(fputs("^?", stdout) == EOF) { return ioerr(argv[0]); }
 				break;
-		case '\n':	if(showend)
-					putc('$', stdout);
+			case '\n':
+				if (showend && fputc('$', stdout) == EOF) {
+					return ioerr(argv[0]);
+				}
 			default:
-			if(c >= ' ' || c == '\n' || (!showtab && c == '\t'))
-				putc(c, stdout);
-			else
-				fprintf(stdout, "^%c", c + '@');
+				if (c >= ' ' || c == '\n' || (!showtab && c == '\t')) {
+					if (fputc(c, stdout) == EOF) { return ioerr(argv[0]); }
+				} else if (fprintf(stdout, "^%c", c + '@') < 0) {
+					return ioerr(argv[0]);
+				}
 		}
 	}
 

src/peek.c

@@ -0,0 +1,147 @@
+/*
+ * 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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -46,18 +46,24 @@ use std::{
 	collections::VecDeque,
 	env::args,
 	fmt::{ self, Display, Formatter },
-	io::stdin,
+	io::{ Error, Write, stdin, stdout },
 	process::ExitCode,
 };
 
 use CalcType::*;
 
+extern crate strerror;
 extern crate sysexits;
 
-use sysexits::EX_DATAERR;
+use strerror::StrError;
+use sysexits::{ EX_DATAERR, EX_IOERR };
+
+#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
+#[cfg(target_os="openbsd")] extern crate openbsd;
+#[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
+/* enum CalcType is a type containing operations used in the calculator */
 enum CalcType {
 	Add,
 	Subtract,
@@ -114,50 +120,25 @@ 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;
-
-fn eval(
-	input: &str,
-	initial_stack: VecDeque<f64>,
-) -> Result<(VecDeque<f64>, bool), EvaluationError> {
-	let mut stack = initial_stack;
-	let mut oper = false;
-
-	if input.is_empty() {
-		stack.clear();
-		return Ok((stack, oper));
+impl StrError for EvaluationError {
+	fn strerror(&self) -> String {
+		self.message.clone()
+	}
 }
 
-	// Split the input into tokens.
-	let mut toks: VecDeque<CalcType> = input
-		.split_whitespace()
-		.rev()
-		.map(|t| CalcType::from(t))
-		.collect();
-	let mut ops: VecDeque<CalcType> = VecDeque::new();
+fn err<T: StrError>(argv0: &String, e: &T, code: Option<u8>) -> ExitCode {
+	eprintln!("{}: {}", argv0, e.strerror());
+	ExitCode::from(code.unwrap_or(1 /* unknown error */))
+}
 
-	while let Some(n) = toks.pop_back() {
-		match n {
-			Val(v) => stack.push_back(v),
-			Invalid(i) => {
-				return Err(EvaluationError {
-					message: format!("{}: Invalid token", i),
-					code: EX_DATAERR,
-				})
-			},
-			op => {
-				ops.push_back(op.clone());
-				oper = true;
-
-				let vals = (
-					stack.pop_back(),
-					stack.pop_back(),
-				);
+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 {
@@ -172,10 +153,49 @@ fn eval(
 		};
 	} else {
 		return Err(EvaluationError {
-						message: format!("{}: Unexpected operation", op),
+			message: format!("{}: unexpected operation", op),
 			code: EX_DATAERR,
 		})
 	}
+
+	Ok(stack)
+}
+
+fn eval(
+	input: &str,
+	initial_stack: VecDeque<f64>,
+) -> Result<(VecDeque<f64>, bool), EvaluationError> {
+	let mut stack = initial_stack;
+	let mut oper = false;
+
+	if input.is_empty() {
+		stack.clear();
+		return Ok((stack, oper));
+	}
+
+	/* Split the input into tokens. */
+	let mut toks: VecDeque<CalcType> = input
+		.split_whitespace()
+		.rev()
+		.map(|t| CalcType::from(t))
+		.collect();
+
+	let mut ops: VecDeque<CalcType> = VecDeque::new();
+
+	while let Some(n) = toks.pop_back() {
+		match n {
+			Val(v) => stack.push_back(v),
+			Invalid(i) => {
+				return Err(EvaluationError {
+					message: format!("{}: invalid token", i),
+					code: EX_DATAERR,
+				})
+			},
+			op => {
+				ops.push_back(op.clone());
+
+				oper = true; /* this is an operation */
+				return operate(stack, op).map(|s| (s, oper));
 			},
 		};
 	}
@@ -183,66 +203,95 @@ fn eval(
 	Ok((stack, oper))
 }
 
-// Round a float to the given precision level
-fn round_precise(value: &f64, precision: usize) -> f64 {
-	let multiplier = 10_f64.powi(precision as i32);
+/* Round a float to the given precision level */
+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 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() {
-		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 {
+	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()
 			.skip(1)
 			.map(|x| x.to_owned())
-			.collect::<Vec<String>>()
+			.collect::<Vec<_>>()
 			.join(" ");
 
 		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::from(0),
-				};
-
-				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));
 			},
 		};
 	}
-	ExitCode::from(0)
+
+	/* 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/scrut.c

@@ -17,91 +17,100 @@
  * along with this program. If not, see https://www.gnu.org/licenses/.
  */
 
+#include <assert.h> /* assert(3) */
 #include <stdio.h> /* fprintf(3), stderr, NULL */
 #include <stdlib.h> /* EXIT_FAILURE, EXIT_SUCCESS */
 #include <string.h> /* memset(3), strchr(3) */
-#ifndef EX_USAGE
-#	include <sysexits.h>
-#endif
-#include <unistd.h> /* access(3), getopt(3), F_OK, R_OK, W_OK, X_OK */
+#include <sysexits.h> /* EX_OSERR, EX_USAGE */
+#include <unistd.h> /* access(3), getopt(3), pledge(2), unveil(2), F_OK, R_OK,
+					 * W_OK, X_OK */
 #include <sys/stat.h> /* lstat(3), stat struct, S_ISBLK, S_ISCHR, S_ISDIR,
                        * S_ISFIFO, S_ISGID, S_ISREG, S_ISLNK, S_ISSOCK,
                        * S_ISUID, S_ISVTX */
 
-static char args[] = "bcdefghkprsuwxLS";
-static char ops[(sizeof args) / (sizeof *args)];
-static char *program_name = "scrut";
+char *program_name = "scrut";
+#define OPTS "bcdefgkprsuwxLS"
+/* this is an array so main:sel's size can be known at compile time */
+static char opts[] = OPTS;
 
-int main(int argc, char *argv[]){
-	struct stat buf;
-	int c;
-	size_t i;
-	char *p;
-
-	if(argc < 2)
-		goto usage;
-
-	memset(ops, '\0', sizeof ops);
-	while((c = getopt(argc, argv, args)) != -1)
-		if((p = strchr(args, c)) == NULL)
-			goto usage;
-		else
-			ops[p - args] = c;
-	/* straighten out ops */
-	for(i = 0, p = ops; i < (sizeof ops) / (sizeof *ops); ++i)
-		if(ops[i] != '\0'){
-			*p = ops[i];
-			if(&ops[i] != p++)
-				ops[i] = '\0';
-		}
-
-	if(optind == argc)
-		goto usage;
-
-	argv += optind;
-	do{	if(access(*argv, F_OK) != 0 || lstat(*argv, &buf) == -1)
-			return EXIT_FAILURE; /* doesn't exist or isn't stattable */
-
-		for(i = 0; ops[i] != '\0'; ++i)
-			if(ops[i] == 'e')
-				continue;
-			else if(ops[i] == 'h'){
-usage:				fprintf(stderr, "Usage: %s (-%s) [file...]\n",
-					argv[0] == NULL
-						? program_name
-						: argv[0],
-					args);
+static int
+usage(char *argv0) {
+	(void)fprintf(stderr, "Usage: %s [-" OPTS "] file...\n", argv0);
 
 	return EX_USAGE;
-			}else if(
-					(ops[i] == 'b'
-						&& !S_ISBLK(buf.st_mode))
-					|| (ops[i] == 'c'
-						&& !S_ISCHR(buf.st_mode))
-					|| (ops[i] == 'd'
-						&& !S_ISDIR(buf.st_mode))
-					|| (ops[i] == 'f'
-						&& !S_ISREG(buf.st_mode))
-					|| (ops[i] == 'g'
-						&& !(buf.st_mode & S_ISGID))
-					|| (ops[i] == 'k'
-						&& !(buf.st_mode & S_ISVTX))
-					|| (ops[i] == 'p'
-						&& !S_ISFIFO(buf.st_mode))
-					|| (ops[i] == 'r'
-						&& access(*argv, R_OK) != 0)
-					|| (ops[i] == 'u'
-						&& !(buf.st_mode & S_ISUID))
-					|| (ops[i] == 'w'
-						&& access(*argv, W_OK) != 0)
-					|| (ops[i] == 'x'
-						&& access(*argv, X_OK) != 0)
-					|| (ops[i] == 'L'
-						&& !S_ISLNK(buf.st_mode))
-					|| (ops[i] == 'S'
-						&& !S_ISSOCK(buf.st_mode)))
-				return EXIT_FAILURE;
-	}while(*++argv != NULL);
+}
+
+int main(int argc, char *argv[]) {
+	char sel[(sizeof opts) / (sizeof *opts)];
+
+	program_name = argv[0] == NULL ? program_name : argv[0];
+
+#ifdef __OpenBSD__
+	if (pledge("rpath stdio unveil", "") == -1) {
+		perror(program_name);
+		return EX_OSERR;
+	}
+#endif
+
+	if (argc < 2) { return usage(program_name); }
+
+	{ /* option parsing */
+		char *p;
+
+		memset(sel, '\0', sizeof sel);
+		for (int c; (c = getopt(argc, argv, opts)) != -1;) {
+			if ((p = strchr(opts, c)) == NULL) { return usage(argv[0]); }
+			else {
+				assert(p - opts < sizeof sel / sizeof *sel); /* bounds check */
+				sel[p - opts] = c;
+			}
+		}
+
+		/* straighten out selections; permute out nulls */
+		p = sel;
+		for (size_t i = 0; i < (sizeof sel) / (sizeof *sel); ++i) {
+			if (sel[i] != '\0') {
+				*p = sel[i];
+				if (&sel[i] != p++) { sel[i] = '\0'; }
+			}
+		}
+	}
+
+	if (optind == argc) { return usage(argv[0]); }
+
+	for (argv += optind ; *argv != NULL; argv = &argv[1]) {
+		struct stat buf;
+
+#ifdef __OpenBSD__
+		if (unveil(*argv, "rw") == -1) {
+			perror(program_name);
+			return EX_OSERR;
+		}
+#endif
+
+		if(access(*argv, F_OK) != 0 || lstat(*argv, &buf) == -1) {
+			return EXIT_FAILURE; /* doesn't exist or isn't stattable */
+		}
+
+		for (size_t i = 0; sel[i] != '\0'; ++i) {
+			if (
+					(sel[i] == 'b' && !S_ISBLK(buf.st_mode))
+					|| (sel[i] == 'c' && !S_ISCHR(buf.st_mode))
+					|| (sel[i] == 'd' && !S_ISDIR(buf.st_mode))
+					|| (sel[i] == 'e' && 0)
+					|| (sel[i] == 'f' && !S_ISREG(buf.st_mode))
+					|| (sel[i] == 'g' && !(buf.st_mode & S_ISGID))
+					|| (sel[i] == 'k' && !(buf.st_mode & S_ISVTX))
+					|| (sel[i] == 'p' && !S_ISFIFO(buf.st_mode))
+					|| (sel[i] == 'r' && access(*argv, R_OK) != 0)
+					|| (sel[i] == 'u' && !(buf.st_mode & S_ISUID))
+					|| (sel[i] == 'w' && access(*argv, W_OK) != 0)
+					|| (sel[i] == 'x' && access(*argv, X_OK) != 0)
+					|| (sel[i] == 'L' && !S_ISLNK(buf.st_mode))
+					|| (sel[i] == 'S' && !S_ISSOCK(buf.st_mode))
+			) { return EXIT_FAILURE; }
+		}
+	}
 
 	return EXIT_SUCCESS;
 }

src/str.c

@@ -19,12 +19,16 @@
 
 #include <ctype.h>
 #include <stddef.h> /* NULL */
-#include <stdio.h> /* fprintf(3) */
-#include <stdlib.h> /* EXIT_FAILURE */
+#include <stdio.h> /* fprintf(3), perror(3) */
+#include <stdlib.h> /* size_t, EXIT_FAILURE */
 #include <string.h> /* strcmp(3) */
-#include <sysexits.h>
+#include <sysexits.h> /* EX_OSERR, EX_USAGE */
 
-static char *program_name = "str";
+#ifdef __OpenBSD__
+#	include <unistd.h> /* pledge(2), unveil(2) */
+#endif
+
+char *program_name = "str";
 
 static struct {
 	char *name;
@@ -41,35 +45,52 @@ static struct {
 	{ "isprint", isprint },
 	{ "ispunct", ispunct },
 	{ "isspace", isspace },
-	{ "isupper", isupper }
+	{ "isupper", isupper },
+	{ NULL, NULL } /* marks end */
 };
 
-int main(int argc, char *argv[]){
-	int ctype;
-	int i;
-	int r;
-
-	if(argc >= 3){
-		for(ctype = 0; ctype < (sizeof ctypes) / (sizeof *ctypes);
-				++ctype)
-			if(strcmp(argv[1], ctypes[ctype].name) == 0)
-				goto pass;
-	}
-
-	fprintf(stderr, "Usage: %s [type] [string...]\n",
-		argv[0] == NULL ? program_name : argv[0]);
+static int
+usage(char *argv0) {
+	(void)fprintf(stderr, "Usage: %s type string...\n", argv0);
 
 	return EX_USAGE;
-
-pass:	for(argv += 2, r = 1; *argv != NULL; ++argv)
-		for(i = 0; argv[0][i] != '\0'; ++i)
-			/* First checks if argv[0][i] is valid ASCII; ctypes(3)
-			 * don't handle non-ASCII.
-			 * This is bad. */
-			if((unsigned char)argv[0][i] < 0x80 && !ctypes[ctype].f(argv[0][i]))
-				return 1;
-			else
-				r = 0;
-
-	return r;
+}
+
+int main(int argc, char *argv[]) {
+	size_t ctype; // selected from ctypes.h; index of ctype
+	int retval; // initially fail but becomes success on the first valid char
+	program_name = argv[0] == NULL ? program_name : argv[0];
+
+#ifdef __OpenBSD__
+	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
+		perror(program_name);
+		return EX_OSERR;
+	}
+#endif
+
+	if (argc < 3) { return usage(program_name); }
+
+	for ( /* iterate ctypes */
+		ctype = 0;
+		ctypes[ctype].f != NULL /* break at the end of ctypes */
+			&& strcmp(argv[1], ctypes[ctype].name) != 0; /* break at match */
+		++ctype
+	);
+
+	if (ctypes[ctype].f == NULL) { return usage(argv[0]); }
+
+	/* iterate args */
+	for (argv += 2, retval = EXIT_FAILURE; *argv != NULL; ++argv) {
+		for (size_t i = 0; argv[0][i] != '\0'; ++i) { /* iterate arg bytes */
+			/* First checks if argv[0][i] is valid ASCII; ctypes(3) don't
+			 * handle non-ASCII. This is bad. */
+			if(
+				(unsigned char)argv[0][i] < 0x80 // argv[0][i] is ASCII,
+					&& !ctypes[ctype].f(argv[0][i]) // so use ctypes(3)
+			) { return EXIT_FAILURE; }
+			else { retval = EXIT_SUCCESS; }
+		}
+	}
+
+	return retval;
 }

src/strcmp.c

@@ -1,24 +1,62 @@
-#include <stdio.h> /* fprintf(3), stderr */
-#include <stdlib.h> /* EXIT_FAILURE */
-#include <sysexits.h>
+/*
+ * Copyright (c) 2023 DTB <trinity@trinity.moe>
+ * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * 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 <stdio.h> /* fprintf(3), perror(3), stderr */
+#include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
 
-static char *program_name = "strcmp";
+#ifdef __OpenBSD__
+#	include <unistd.h> /* pledge(2), unveil(2) */
+#endif
+
+char *program_name = "strcmp";
 
 int main(int argc, char *argv[]) {
-	int i;
+	unsigned int i;
+
+#ifdef __OpenBSD__
+	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
+		perror(argv[0] == NULL ? program_name : argv[0]);
+
+		return EX_OSERR;
+	}
+#endif
 
 	if (argc < 3) {
-		fprintf(stderr, "Usage: %s [string] [string...]\n",
-			argv[0] == NULL ? program_name : argv[0]);
+		(void)fprintf(
+			stderr,
+			"Usage: %s string string...\n",
+			argv[0] == NULL ? program_name : argv[0]
+		);
+
 		return EX_USAGE;
 	}
 
-	for(; *argv[1] != '\0'; ++argv[1])
-		for(i = 2; i < argc; ++i)
-			if(*argv[i-1] > *argv[i])
+	for (; *argv[1] != '\0'; ++argv[1]) {
+		for (i = 2; i < argc; ++i) {
+			/* a former string has a greater byte value */
+			if (*argv[i-1] > *argv[i]) { 
 				return 1;
-			else if(*argv[i-1] < *argv[i]++)
+			/* a latter string has a greater byte value */
+			} else if (*argv[i-1] < *argv[i]++) {
 				return -1; /* actually 255 */
-
-	return 0;
+			}
+		}
+	}
+
+	return EX_OK;
 }

src/swab.rs

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -18,70 +19,89 @@
 
 use std::{
 	env::args,
-	io::{ stdin, stdout, Error, ErrorKind, Read, Write },
+	io::{ stdin, stdout, Error, Read, Write },
 	process::ExitCode,
 	vec::Vec
 };
 
 extern crate getopt;
-use getopt::GetOpt;
-
 extern crate sysexits;
-use sysexits::{ EX_OK, EX_OSERR, EX_USAGE };
+extern crate strerror;
 
-fn oserr(s: &str, e: Error) -> ExitCode {
-	eprintln!("{}: {}", s, e);
-	ExitCode::from(EX_OSERR as u8)
+use getopt::GetOpt;
+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, unveil };
+
+fn err(argv0: &String, e: Error, code: u8) -> ExitCode {
+	eprintln!("{}: {}", argv0, e.strerror());
+	ExitCode::from(code)
 }
 
-fn usage(s: &str) -> ExitCode {
-	eprintln!("Usage: {} (-f) (-w [wordsize])", s);
-	ExitCode::from(EX_USAGE as u8)
+fn usage(s: &String) -> ExitCode {
+	eprintln!("Usage: {} [-w word_size]", s);
+	ExitCode::from(EX_USAGE)
 }
 
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
-	let mut buf: Vec<u8> = Vec::new();
+	
+	#[cfg(target_os="openbsd")] {
+		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);
+		}
+	}
+
+	let mut buf: Vec<u8> = Vec::new(); // holds the sequence getting swabbed
 	let mut input = stdin();
 	let mut output = stdout().lock();
+	let mut optind: usize = 1;   // argv[0]
+	let mut wordsize: usize = 2; // default; mimics dd(1p) conv=swab
 
-	let mut force = false;
-	let mut wordsize: usize = 2;
-
-	while let Some(opt) = argv.getopt("fw:") {
+	while let Some(opt) = argv.getopt("w:") {
 		match opt.opt() {
-			Ok("f") => force = true,
 			Ok("w") => {
-				if let Some(arg) = opt.arg() {
-					match arg.parse::<usize>() {
-						Ok(w) if w % 2 == 0 => { wordsize = w; () },
+					match opt.arg().unwrap().parse::<usize>() {
+						Ok(w) if w % 2 == 0 => { wordsize = w; },
 						_ => { return usage(&argv[0]); },
 					}
-				}
+				optind = opt.ind();
 			},
 			_ => { return usage(&argv[0]); }
 		}
 	}
 
+	if optind < argv.len() {
+		return usage(&argv[0]);
+	}
+
 	buf.resize(wordsize, 0);
 
 	loop {
 		match input.read(&mut buf) {
-			Ok(0) => break ExitCode::from(EX_OK as u8),
-			Ok(v) if v == wordsize => {
+			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 oserr(&argv[0], e)
+					break err(&argv[0], e, EX_IOERR);
 				}
+
 			},
-			Ok(v) => {
+			Ok(v) => { // partial read; partially write
 				if let Err(e) = output.write(&buf[..v]) {
-					break oserr(&argv[0], e)
+					break err(&argv[0], e, EX_IOERR);
 				}
 			},
-			Err(e) if e.kind() == ErrorKind::Interrupted && force => continue,
-			Err(e) => break oserr(&argv[0], e)
+			Err(e) => break err(&argv[0], e, EX_OSERR)
 		}
 	}
 }

src/true.c

@@ -1,9 +1,18 @@
 /*
- * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2024 DTB <trinity@trinity.moe>
  * SPDX-License-Identifier: CC0
  *
  * This work is marked with CC0 1.0. To view a copy of this license, visit
  * <http://creativecommons.org/publicdomain/zero/1.0>.
  */
 
-int main() {}
+#ifdef __OpenBSD__
+#	include <unistd.h> /* pledge(2) */
+#endif
+
+int main(void) {
+#ifdef __OpenBSD__
+	(void)pledge("stdio", "");
+#endif
+}

tests/README

@@ -0,0 +1,25 @@
+Tests
+=====
+
+The Harakit testing suite verifies the functionality of Harakit utilities
+and checks for regressions and other issues relating to compliance to our
+standards of practice.
+
+Tests inherit the environment set by the top-level Makefile, which sets the BIN
+variable to the build/bin directory at the root of the project; therefore, each
+binary is located at $(BIN)/tool for idiomatic access.
+
+Each test contains a set of PHONY targets which are prefixed with the name of
+the tool being tested and an underscore. The first target is tests, which
+depends on all the other targets in the test file. These test files are each
+included in the top Makefile, so they can be called from the root of the
+repository. This also means that BIN can be set manually so that tests can be
+run using make(1) inside of the tests directory:
+
+	$ make -f dj.mk BIN=../build/bin dj_tests
+
+--
+Copyright © 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+
+This work is licensed under CC BY-SA 4.0. To view a copy of this license, visit
+<http://creativecommons.org/licenses/by-sa/4.0/>.

tests/dj.mk

@@ -0,0 +1,48 @@
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PRAGMA: command_comment
+
+/dev/full:
+/dev/null:
+
+.PHONY: dj_tests
+dj_tests: dj_help dj_full dj_null # dj_skip_stdin
+
+.PHONY: dj_full
+# Linux has a /dev/full pseudodevice useful for testing errors.
+dj_full: $(BIN)/dj /dev/full
+	case "$$(uname)" in \
+	Linux) \
+		! $(BIN)/dj -Hi /dev/zero -o /dev/full 2>&1 \
+			| tee /dev/stderr \
+			| xargs -I out test '1+0 > 0+0; 1024 > 0' = out \
+		;; \
+	esac
+
+.PHONY: dj_help
+dj_help: $(BIN)/dj
+	! $(BIN)/dj -h
+
+.PHONY: dj_null
+# Read nothing from /dev/null, write nothing to /dev/null.
+dj_null: $(BIN)/dj /dev/null
+	$(BIN)/dj -Hi /dev/null -o /dev/null 2>&1 \
+		| tee /dev/stderr \
+		| xargs -I out test '0+0 > 0+0; 0 > 0' = out
+
+# This test currently fails. This is probably due to dj(1) being stale relative
+# to the main harakit branch. TODO: Reassess once the testing branch is merged.
+# .PHONY: dj_skip_stdin
+# # Test skipping stdin.
+# dj_skip_stdin: $(BIN)/dj
+# 	# Pipe 1024B of '\0' into dj(1); skip the first 24B; expect 1000B written.
+# 	dd count=1 bs=1024 </dev/zero 2>/dev/null \
+# 		| $(BIN)/dj -H -s 24 -o /dev/null 2>&1 \
+# 		| tee /dev/stderr \
+# 		| xargs -I out test '1+0 > 1+0; 1024 > 1000' = out

tests/false.mk

@@ -0,0 +1,18 @@
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: false_tests
+false_tests: false_test false_help
+
+.PHONY: false
+false_test: $(BIN)/false
+	! $(BIN)/false
+
+.PHONY: false_help
+false_help: $(BIN)/false
+	! $(BIN)/false -h

tests/fileis.mk

@@ -0,0 +1,46 @@
+#!/bin/sh
+# 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.
+
+.PRAGMA: command_comment
+
+.PHONY: fileis_tests 
+fileis_tests: fileis_help fileis_options
+
+.PHONY: fileis_help
+fileis_help: $(BIN)/fileis
+	! $(BIN)/fileis -h
+
+.PHONY: fileis_options
+# fileis tests file attributes, but files of a certain attribute aren't
+# guaranteed to be present on a system. This test checks all of the files in
+# harakit and, if test(1p) says a file matches a certain attribute, then checks
+# fileis.
+# opts are space-delimited (for command splitting), sel is not
+fileis_options: $(BIN)/fileis
+	set -e; \
+	opts="b c d e f g k p r s u w x L S"; \
+	sel=; \
+	find . -name .git -prune -o -print \
+		| while read -r f; do \
+			for opt in $$opts; \
+				do if ! printf "%s\n" $$sel | grep $$opt >/dev/null; then \
+					if test -$$opt "$$f"; then \
+						if ! $(BIN)/fileis -$$opt "$$f"; \
+							then printf "[!!] fileis -%s failed on %s.\n" \
+								$$opt "$$f"; \
+						fi; \
+						sel="$$sel$$opt"; \
+						printf "[OK] Tested fileis -%s using %s\n" \
+							$$opt "$$f"; \
+					fi; \
+				fi; \
+			done; \
+			if printf "%s\n" "$$opts" | sed 's/ //g' | xargs test "$$sel" =; \
+				then break; \
+			fi; \
+		done

tests/fop.mk

@@ -0,0 +1,32 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: fop_tests
+fop_tests: fop_functionality fop_delimiter fop_help fop_fail
+
+.PHONY: fop_help
+fop_help: $(BIN)/fop
+	! $(BIN)/fop -h
+
+.PHONY: fop_delimiter
+fop_delimiter: $(BIN)/fop
+	test "$$(printf 'test1 test1 test1\n' | $(BIN)/fop -d' ' 2 sed 's/1/4/g')" \
+		= 'test1 test1 test4'
+	test "$$(printf 'meowsetwoofsetribbit\n' \
+		| $(BIN)/fop -d 'set' 1 sed 's/woof/meow/g')" = 'meowsetmeowsetribbit'
+
+.PHONY: fop_fail
+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
+	test "$$(printf 'test1\036test1\036test1\n' | $(BIN)/fop 1 sed 's/1/4/g')" \
+		= "$$(printf 'test1\036test4\036test1\n')"

tests/hru.mk

@@ -0,0 +1,32 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: hru_tests
+hru_tests: hru_help hru_functionality hru_negative hru_regressions
+
+.PHONY: hru_help
+hru_help: $(BIN)/hru
+	! $(BIN)/hru -h
+
+.PHONY: hru_functionality
+hru_functionality: $(BIN)/hru
+	test "$$(printf '1234\n' | $(BIN)/hru)" = '1.2 kB'
+	test "$$(printf '0\n' | $(BIN)/hru)" = '0 B'
+
+.PHONY: hru_negative
+hru_negative: $(BIN)/hru
+	! printf '%s\n' '-1' | $(BIN)/hru
+
+.PHONY: hru_regressions
+hru_regressions: $(BIN)/hru
+	n=1; \
+	while true; \
+	do \
+		printf '%s\n' "$$n" | $(BIN)/hru || break; \
+		n="$$(($$n * 10))"; \
+	done; \
+	printf 'Max float: %s\n' "$$n"

tests/intcmp.mk

@@ -0,0 +1,67 @@
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: intcmp_tests
+intcmp_tests: intcmp_help intcmp_none intcmp_e intcmp_g intcmp_l intcmp_combined
+
+.PHONY: intcmp_help
+intcmp_help: $(BIN)/intcmp
+	! $(BIN)/intcmp -h
+
+# These test that integer comparisons are working as they should. For the sake
+# of readability (to facilitate faster skimming) these recipes follow a
+# columned format:
+#	$binary       -flags d d d d  # op
+# For flag meanings reference intcmp(1) (though they are somewhat self
+# explanatory). d here refers to a decimal number; a mixture of 1s, 2s, and 3s
+# (a particularly lovely number) arranged to demonstrate easily the operation
+# under scrutiny. The commented op is the operation that is true for the given
+# numbers. For example:
+#	$(BIN)/intcmp   -e   3 3 3 3  # ==
+# op here is ==; 3 == 3 == 3 == 3. The flag being used is -e, to test for
+# equality, so this test should succeed.
+#	! $(BIN)/intcmp -l   3 2 1    # >
+# op here is >; 3 > 2 > 1. The flag being used is -l, to test for each integer
+# being less than the next, so intcmp should fail - hence the ! at the start of
+# the invocation. If this test failed, intcmp(1) would be confusing -l for -g,
+# so that would be a good place to start looking for bugs.
+
+.PHONY: intcmp_none
+intcmp_none: $(BIN)/intcmp
+	! $(BIN)/intcmp 1 2
+
+.PHONY: intcmp_e
+intcmp_e: $(BIN)/intcmp
+	$(BIN)/intcmp   -e   3 3 3    # ==
+	! $(BIN)/intcmp -e   1 2 3    # <
+	! $(BIN)/intcmp -e   3 2 1    # >
+
+.PHONY: intcmp_g
+intcmp_g: $(BIN)/intcmp
+	$(BIN)/intcmp   -g   3 2 1    # >
+	! $(BIN)/intcmp -g   3 3 3    # ==
+	! $(BIN)/intcmp -g   1 2 3    # <
+	$(BIN)/intcmp   -ge  3 3 1    # >=
+	! $(BIN)/intcmp -ge  1 2 3    # <
+
+.PHONY: intcmp_l
+intcmp_l: $(BIN)/intcmp
+	$(BIN)/intcmp   -l   1 2 3    # <
+	! $(BIN)/intcmp -l   3 3 3    # ==
+	! $(BIN)/intcmp -l   3 2 1    # >
+	$(BIN)/intcmp   -le  1 3 3    # <=
+	! $(BIN)/intcmp -le  3 2 1    # >
+
+.PHONY: intcmp_combined
+intcmp_combined: $(BIN)/intcmp
+	$(BIN)/intcmp   -gl  1 2 3    # <
+	$(BIN)/intcmp   -gl  3 2 1    # >
+	$(BIN)/intcmp   -gl  1 3 1    # !=
+	! $(BIN)/intcmp -gl  3 3 3    # ==
+	$(BIN)/intcmp   -egl 3 1 1 3  # >, ==, <
+	! $(BIN)/intcmp -egl foo      # huh?

tests/mm.mk

@@ -0,0 +1,40 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: mm_tests
+mm_tests: mm_args mm_help mm_stderr mm_remaining mm_remaining_options
+
+.PHONY: mm_none
+mm_none: $(BIN)/mm
+	test "$$(printf 'meow\n' | $(BIN)/mm)" = meow
+
+.PHONY: mm_args
+# mm(1) will error if positional arguments are given without -i or -o
+mm_args: $(BIN)/mm
+	! $(BIN)/mm argument
+
+.PHONY: mm_help
+mm_help: $(BIN)/mm
+	! $(BIN)/mm -h
+
+.PHONY: mm_stderr
+# check if stderr is empty upon specifying -e
+mm_stderr: $(BIN)/mm
+	test "$$(printf 'test\n' | $(BIN)/mm -e 2>&1 >/dev/null )" = "test"
+
+.PHONY: mm_remaining
+# check to make sure remaining arguments are used
+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/npc.mk

@@ -0,0 +1,94 @@
+#!/bin/sh
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PRAGMA: command_comment
+
+.PHONY: npc_tests
+npc_tests: npc_help npc_args npc_ascii
+
+.PHONY: npc_help
+npc_help: $(BIN)/npc
+	! $(BIN)/npc -h
+
+.PHONY: npc_args
+# arg parsing
+npc_args:
+	$(BIN)/npc -e </dev/null
+	$(BIN)/npc -t </dev/null
+	$(BIN)/npc -et </dev/null
+	! $(BIN)/npc -et 5 </dev/null
+
+.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_lowers
+
+.PHONY: npc_ascii_controls
+# (control characters)
+npc_ascii_controls:
+	# The following test prints the bytes 0x00 (inclusive) through 0x20
+	# (exclusive) and pipes them through npc(1). npc(1) should then replace all
+	# non-printing, non-space (in the isspace(3p) sense) characters with their
+	# graphical carat-char counterparts (see the npc(1) man page). The head(1p)
+	# invocation then strips off everything past the first line (or past the
+	# first newline byte, 0x0A) and xargs(1p) is used to test(1p) the output
+	# against the known good answer.
+
+	# Immediately before that newline, 0x09 is printed - in ASCII, the
+	# horizontal tab. If xargs' -I option is used, tr(1p) should used to delete
+	# that tab. If the tab is left as part of input, OpenBSD's xargs(1)
+	# implementation has been observed to strip it along with the other
+	# trailing whitespace (the newline), but Busybox's and GNU's xargs(1)
+	# implementations have been observed to leave the tab in. All three
+	# implementations strip off the trailing tab if `-I` is not used. The POSIX
+	# specification for `-I` is ambiguous as to which behavior is correct.
+	# This comment is the result of much bewilderment and debugging.
+
+	# ASCII 0x00 to 0x0a (before the newline, due to xargs(1p) issues)
+	awk 'BEGIN{ for (i = 0; i < 32; ++i) printf("%c", i); }' \
+		| $(BIN)/npc \
+		| head -n 1 \
+		| xargs test "^@^A^B^C^D^E^F^G^H" =
+
+	# ASCII 0x0a (otherwise the head|tail sequence won't work) to 0x1f
+	awk 'BEGIN{ for (i = 0; i < 32; ++i) printf("%c", i); print }' \
+		| $(BIN)/npc \
+		| head -n 2 \
+		| 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_uppers
+# ASCII 0x40 to 0x5f (uppercases)
+npc_ascii_uppers:
+	awk 'BEGIN{ for (i = 64; i < 96; ++i) printf("%c", i); print }' \
+		| $(BIN)/npc \
+		| sed 's/\\/\\\\/' \
+		| xargs -I out test @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ = out
+
+# This test is broken and will need closer inspection along with the npc(1)
+# source.
+# .PHONY: npc_ascii_lowers
+# # ASCII 0x60 to 0x7f (lowercases)
+# npc_ascii_lowers:
+# 	awk 'BEGIN{ for (i = 96; i < 128; ++i) printf("%c", i); print }' \
+# 		| $(BIN)/npc \
+# 		| xargs -I out test "\`abcdefghijklmnopqrstuvwxyz{|}~^?" = out

tests/peek.mk

@@ -0,0 +1,24 @@
+# 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/posix-compat.sh

@@ -1,24 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
-# 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.
-
-set -e
-
-if ! ls Makefile >/dev/null 2>&1
-then
-	printf '%s: Run this script in the root of the project.\n' "$0" 1>&2 
-	exit 1
-fi
-
-printf "Starting POSIX compatibility testing.\n"
-
-for utility in tests/posix/*; do
-	printf '%s: %s: Testing utility.\n' "$0" "$utility"
-	"$utility"
-	printf '\n'
-done

tests/rpn.mk

@@ -0,0 +1,48 @@
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: rpn_tests
+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
+	! $(BIN)/rpn -h
+
+.PHONY: rpn_add
+rpn_add: $(BIN)/rpn
+	test "$$($(BIN)/rpn 1 2 +)" -eq 3
+	test "$$($(BIN)/rpn 0.2 0.1 +)" = 0.3
+
+.PHONY: rpn_sub
+rpn_sub: $(BIN)/rpn
+	test "$$($(BIN)/rpn 23 5 -)" -eq 18
+	test "$$($(BIN)/rpn 0.3 0.1 -)" = 0.2
+
+.PHONY: rpn_mul
+rpn_mul: $(BIN)/rpn
+	test "$$($(BIN)/rpn 1.2 3 '*')" = 3.6
+	test "$$($(BIN)/rpn 0 3 '*')" -eq 0
+
+.PHONY: rpn_div
+rpn_div: $(BIN)/rpn
+	test "$$($(BIN)/rpn 12 5 /)" = 2.4
+	test "$$($(BIN)/rpn 3 0 /)" = inf
+
+.PHONY: rpn_mod
+rpn_mod: $(BIN)/rpn
+	test "$$($(BIN)/rpn 12 5 %)" -eq 2
+	test "$$($(BIN)/rpn 9 4 %)" -eq 1
+
+.PHONY: rpn_flr
+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

tests/str.mk

@@ -0,0 +1,20 @@
+# 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.
+
+.PRAGMA: command_comment
+
+.PHONY: str_tests
+str_tests: str_help str_isalpha
+
+.PHONY: str_help
+str_help: $(BIN)/str
+	! $(BIN)/str -h
+
+.PHONY: str_isalpha
+str_isalpha: $(BIN)/str
+	$(BIN)/str   isalpha c
+	! $(BIN)/str isalpha 3

tests/strcmp.mk

@@ -0,0 +1,31 @@
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+NAME = strcmp
+TARGET = $(NAME)_tests
+BINARY = $(BIN)/$(NAME)
+
+.PHONY: strcmp_tests
+strcmp_tests: strcmp_equals strcmp_help strcmp_nocmp strcmp_unequals
+
+.PHONY: strcmp_equals
+strcmp_equals: $(BIN)/strcmp
+	$(BIN)/strcmp equals equals
+	$(BIN)/strcmp - -
+
+.PHONY: strcmp_help
+strcmp_help: $(BIN)/strcmp
+	! $(BIN)/strcmp -h
+
+.PHONY: strcmp_nocmp
+strcmp_nocmp: $(BIN)/strcmp
+	! $(BIN)/strcmp nocmp
+
+.PHONY: strcmp_unequals
+strcmp_unequals: $(BIN)/strcmp
+	! $(BIN)/strcmp unequals equals

tests/swab.mk

@@ -0,0 +1,22 @@
+# 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.
+
+.PRAGMA: command_comment
+
+.PHONY: swab_tests
+swab_tests: swab_help swab_examples
+
+.PHONY: swab_help
+swab_help: $(BIN)/swab
+	! $(BIN)/swab -h
+
+.PHONY: swab_examples
+# These are the examples present in the man page.
+swab_examples: $(BIN)/swab
+	printf 'hello world!\n' \
+		| $(BIN)/swab \
+		| xargs -I out test 'ehll oowlr!d' = out

tests/true.mk

@@ -0,0 +1,19 @@
+#!/bin/sh
+# Copyright (c) 2024 DTB <trinity@trinity.moe>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# 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.
+
+.PHONY: true_tests
+true_tests: true_test
+
+.PHONY: true_help
+true_help: $(BIN)/true
+	$(BIN)/true -h
+
+.PHONY: true_test
+true_test: $(BIN)/true
+	$(BIN)/true