Escape LF in board file, refuse to store or print control chars

.gitignore

@@ -0,0 +1 @@
+/bulb

Makefile

@@ -0,0 +1,30 @@
+.POSIX:
+.SUFFIXES:
+HARE=hare
+HAREFLAGS=
+
+DESTDIR=
+PREFIX=/usr/local
+BINDIR=$(PREFIX)/bin
+MANDIR=$(PREFIX)/share/man
+
+all: bulb
+
+bulb:
+	$(HARE) build $(HAREFLAGS) -o $@ cmd/$@/
+
+check:
+	$(HARE) test $(HAREFLAGS)
+
+clean:
+	rm -f bulb
+
+install:
+	mkdir -p $(DESTDIR)$(BINDIR) $(DESTDIR)$(MANDIR)/man1
+	install -Dm755 bulb $(DESTDIR)$(BINDIR)/bulb
+	install -Dm755 doc/*.1 $(DESTDIR)$(MANDIR)/man1
+
+uninstall:
+	rm -f $(DESTDIR)$(BINDIR)/bulb
+
+.PHONY: all check clean install uninstall

README.md

@@ -22,26 +22,15 @@ re-writing chat history.
 
 ## Usage
 
-To list available boards:
-
-```
-bulb
 ```
+bulb: bulletin board
 
-To post a message:
+Usage: bulb [-hlpu] [-b <board>] [-n <number>]
 
+-h: print this help text
+-b <board>: specify a board other than general
+-l: list available boards and exit
+-n <number>: display N most recent messages
+-p: post a message (from stdin)
+-u: operate undercover (anonymously)
 ```
-bulb post
-bulb post -b <board-name>
-```
-
-To read recent messages:
-
-```
-bulb read
-bulb read -b <board-name>
-bulb read -n <message-count>
-```
-
-Note that when not specified, the board name defaults to `general`. For this
-reason, it is recommended to ensure that a board with this name exists.

cmd/bulb/main.ha

@@ -1,8 +1,8 @@
-use bulb;
 use errors;
 use fmt;
 use fs;
 use getopt;
+use internal::bulb;
 use io;
 use os;
 use path;
@@ -19,82 +19,67 @@ export fn main() void = {
 	const cmd = getopt::parse(
 		os::args,
 		"bulletin board",
-		("post", [
-			('a', "post anonymously"),
-			('b', "board", "post on a board other than general"),
-		]): getopt::subcmd_help,
-		("read", [
-			('b', "board", "read a board other than general"),
-			('n', "number", "display N most recent messages"),
-		]): getopt::subcmd_help);
+		('b', "board", "specify a board other than general"),
+		('l', "list available boards and exit"),
+		('n', "number", "display N most recent messages"),
+		('p', "post a message (from stdin)"),
+		('u', "operate undercover (anonymously)"));
 	defer getopt::finish(&cmd);
 
-	match (cmd.subcmd) {
-	case let subcmd: (str, *getopt::command) =>
-		if (subcmd.0 == "post") {
-			subcmd_post(subcmd.1);
-		} else if (subcmd.0 == "read") {
-			match (subcmd_read(subcmd.1)) {
-			case errors::invalid =>
-				getopt::printhelp(os::stdout, name, cmd.help)!;
-				os::exit(os::status::FAILURE);
-			case void => void;
-			};
-		};
-	case void =>
-		subcmd_ls(&cmd);
-	};
-};
-
-fn subcmd_post(cmd: *getopt::command) void = {
-	let anonymous = false;
 	let board     = default_board;
-	for (let opt .. cmd.opts) {
-		switch (opt.0) {
-		case 'a' => anonymous = true;
-		case 'b' => board = opt.1;
-		case     => abort();
-		};
-	};
-
-	let user_name = if (anonymous) void else get_user_name();
-	let message   = strings::join(" ", cmd.args...);
-	defer free(message);
+	let list      = false;
+	let number    = 8;
+	let post      = false;
+	let anonymous = false;
 	
-	match (bulb::post(os::stdin, board, user_name)) {
-	case let err: bulb::error =>
-		fmt::errorf("{}: Could not read {}: {}\n", name, board, bulb::strerror(err))!;
-	case void => void;
-	};
-};
-
-fn subcmd_read(cmd: *getopt::command) (void | errors::invalid) = {
-	let board  = default_board;
-	let number = 8;
 	for (let opt .. cmd.opts) {
 		switch (opt.0) {
 		case 'b' =>
 			board = opt.1;
+		case 'l' =>
+			list = true;
 		case 'n' =>
 			match (strconv::stoi(opt.1)) {
-			case let num: int => number = num;
-			case => return errors::invalid;
+			case let num: int =>
+				number = num;
+			case =>
+				fmt::errorf("{}: option -{} requires a number\n", name, opt.0)!;
+				getopt::printusage(os::stdout, name, cmd.help)!;
+				os::exit(os::status::FAILURE);
 			};
+		case 'p' =>
+			post = true;
+		case 'u' =>
+			anonymous = true;
 		case => abort();
 		};
 	};
 
+	if (list) {
+		// list boards and exit
+		match (bulb::list(os::stdout)) {
+		case let err: bulb::error =>
+			fmt::errorf("{}: could not list boards: {}\n", name, bulb::strerror(err))!;
+			os::exit(os::status::FAILURE);
+		case void =>
+			os::exit(os::status::SUCCESS);
+		};
+	};
+
+	if (post) {
+		// post a message (from stdin)
+		let user_name = if (anonymous) void else get_user_name();
+		match (bulb::post(os::stdin, board, user_name)) {
+		case let err: bulb::error =>
+			fmt::errorf("{}: could not post to {}: {}\n", name, board, bulb::strerror(err))!;
+		case void => void;
+		};
+	};
+
+	// read latest posts on the board
 	match (bulb::read(os::stdout, board, number)) {
 	case let err: bulb::error =>
-		fmt::errorf("{}: Could not read {}: {}\n", name, board, bulb::strerror(err))!;
-	case void => void;
-	};
-};
-
-fn subcmd_ls(cmd: *getopt::command) void = {
-	match (bulb::list(os::stdout)) {
-	case let err: bulb::error =>
-		fmt::errorf("{}: Could not list boards: {}\n", name, bulb::strerror(err))!;
+		fmt::errorf("{}: could not read {}: {}\n", name, board, bulb::strerror(err))!;
 	case void => void;
 	};
 };

doc/bulb.1

@@ -0,0 +1,102 @@
+.\" Copyright (c) 2024 Sasha Koshka <sashakoshka@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 BULB 1 2024-10-11
+.SH NAME
+bulb \(en bulletin board
+.\"
+.SH SYNOPSIS
+
+bulb
+.RB [ -hlpu ]
+.RB [ -b\ board ]
+.RB [ -n\ number ]
+.\"
+.SH DESCRIPTION
+
+Read from and post to boards (text files) on the system. Posts are plain text,
+multiline, and each one is tagged with the user name of its author.
+.\"
+.SH OPTIONS
+
+.IP \fB-h\fP
+Prints the help text and exits.
+.IP \fB-b\fP\ \fIboard\fP
+Specifies a board other than \(lqgeneral\(rq.
+.IP \fB-l\fP
+Lists available boards and exits.
+.IP \fB-n\fP\ \fInumber\fP
+Takes a numeric argument as the amount of recent posts to print out, the default
+being 8.
+.IP \fB-p\fP
+Posts a message read from the standard input. See the STANDARD INPUT section.
+.IP \fB-u\fP
+Operates undercover. All posts made will be under the name \(lqanonymous\(rq.
+.\"
+.SH ENVIRONMENT
+
+The BULBPATH environment variable specifies a colon-separated list of
+directories (much like PATH) in which to search for boards. Directories at the
+start take precedence over directories at the end. It has a value of
+.I /var/bulb
+by default.
+.SH FILES
+.I /var/bulb/*
+.\"
+.SH STANDARD INPUT
+
+When the
+.B -p
+option is supplied, the standard input will be read until EOF. The resulting
+text will be posted under the name of the current user in whichever board is
+selected.
+.\"
+.SH STANDARD OUTPUT
+
+If the
+.B -l
+option is supplied, a list of available boards will be written to the standard
+output. If not, the last
+.B -n
+messages in the selected board will be written.
+.\"
+.SH DIAGNOSTICS
+
+In the event of an I/O error, a debug message will be printed and the program
+will exit with an error code. In the event of a bad invocation, a debug message
+will be printed alongside usage text and the program will exit with an error
+code.
+.\"
+.SH RATIONALE
+
+The commands
+.BR talk (1p),
+and
+.BR write (1p),
+and
+.BR wall (1p)
+can be used effectively for textual intra-system communication, but they require
+that the receiving user(s) be both logged in and monitoring their terminal for
+any messages to ever get through. The
+.BR bulb (1)
+command was written to support asynchronous, persistent conversations between
+users of the same system.
+.\"
+.SH AUTHOR
+
+Written by Sasha Koshka
+.MT sashakoshka@tebibyte.media
+.ME .
+.\"
+.SH COPYRIGHT
+
+Copyright \(co 2024 Sasha Koshka (pseudonymous). License GPLv3+: GNU GPL version
+3 or later <https://gnu.org/licenses/gpl.html>
+\."
+.SH SEE ALSO
+
+.BR talk (1p),
+.BR write (1p),
+.BR wall (1p)

internal/bulb/bulb.ha

@@ -1,3 +1,4 @@
+use ascii;
 use bufio;
 use fs;
 use fmt;
@@ -6,6 +7,17 @@ use os;
 use path;
 use strings;
 
+// TODO
+// two issues:
+// A: posts are stored exactly as they are formatted
+// B: posts need to be sanitized from control chars going in and going out
+// C: specifying a number of posts to read only works with lines because it
+//    cant separate out the individual posts
+//
+// all of these can be fixed by escaping line breaks as the post is written to
+// the board, and then rendering them once they get to the reading stage.
+// sanitize the text at both stages.
+
 let bulb_path: []str = [];
 @init fn bulb_path() void = bulb_path = strings::split(os::tryenv("BULBPATH", "/var/bulb"), ":");
 @fini fn bulb_path() void = free(bulb_path);
@@ -29,7 +41,37 @@ export fn read(output: io::handle, board: str, number: int) (void | error) = {
 	// we add 1 to account for the blank line that will always be at the
 	// bottom
 	seek_to_nth_last_line(file, number + 1)?;
-	io::copy(output, file)?;
+	
+	static let output_wbuf: [os::BUFSZ]u8 = [0...];
+	let output = bufio::init(output, [], output_wbuf);
+	let file   = bufio::newscanner(file);
+	defer bufio::finish(&file);
+
+	let saw_escape = false;
+	for (true) {
+		let byte = match (bufio::scan_byte(&file)?) {
+		case let byte: u8 => yield byte;
+		case io::EOF      => break;
+		};
+
+		if (byte == '\x1b') {
+			saw_escape = true;
+		} else {
+			if (byte == '\n') {
+				if (saw_escape) {
+					fmt::fprint(&output, "\n  ")?;
+				} else {
+					fmt::fprint(&output, "\n")?;
+				};
+			} else if (!ascii::iscntrl(byte: rune)) {
+				let fake_buffer: [1]u8 = [byte];
+				io::write(&output, fake_buffer)?;
+			};
+			saw_escape = false;
+		};
+	};
+	
+	bufio::flush(&output)?;
 };
 
 export fn post(input: io::handle, board: str, user_name: (str | void)) (void | error) = {
@@ -44,27 +86,26 @@ export fn post(input: io::handle, board: str, user_name: (str | void)) (void | e
 	};
 
 	static let file_wbuf: [os::BUFSZ]u8 = [0...];
-	let file = bufio::init(file, [], file_wbuf);
-	let scanner = bufio::newscanner(input);
-	defer bufio::finish(&scanner);
+	let file  = bufio::init(file, [], file_wbuf);
+	let input = bufio::newscanner(input);
+	defer bufio::finish(&input);
 
 	let saw_break = false;
 	fmt::fprintf(&file, "{}: ", user)?;
 	for (true) {
-		let byte = match (bufio::scan_byte(&scanner)?) {
+		let byte = match (bufio::scan_byte(&input)?) {
 		case let byte: u8 => yield byte;
 		case io::EOF      => break;
 		};
 		
 		if (saw_break) {
-			fmt::fprint(&file, "\n  ")?;
+			fmt::fprint(&file, "\x1b\n")?;
 			saw_break = false;
 		};
 
-		switch (byte) {
-		case '\n' =>
+		if (byte == '\n') {
 			saw_break = true;
-		case =>
+		} else if (!ascii::iscntrl(byte: rune)) {
 			let fake_buffer: [1]u8 = [byte];
 			io::write(&file, fake_buffer)?;
 		};