pg(1): start work on a quoted strtok(3) and internal environment

Makefile

@@ -107,10 +107,10 @@ npc: build/bin/npc
 build/bin/npc: src/npc.c build
 	$(CC) $(CFLAGS) -o $@ src/npc.c
 
-.PHONY: peek
+.PHONY: pg
-peek: build/bin/peek
+pg: build/bin/pg
-build/bin/peek: src/peek.c build
+build/bin/pg: src/pg.c build
-	$(CC) $(CFLAGS) -o $@ src/peek.c
+	$(CC) $(CFLAGS) -o $@ src/pg.c
 
 .PHONY: rpn
 rpn: build/bin/rpn

docs/peek.1

@@ -1,90 +0,0 @@
-.\" Copyright (c) 2023-2024 DTB <trinity@trinity.moe>
-.\"
-.\" 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
-
-.SH NAME
-
-peek \(en read from the standard input, furtively
-
-.SH SYNOPSIS
-
-peek
-.RB ( -i )
-
-.SH DESCRIPTION
-
-Peek reads input from the standard input with terminal echo disabled.
-
-.SH OPTIONS
-
-.B -i
-.RS
-Allows input to come from sources other than terminals (i.e. a pipe).
-.RE
-
-.SH DIAGNOSTICS
-
-Peek prints an error message and exits with the appropriate status from
-sysexits.h(3) if it encounters an unrecoverable error.
-
-Peek tries to handle the signal SIGINT (^C) to ensure the user's terminal is
-still usable after premature termination; if the signal can't be handled, it
-prints an error message and continues. If peek 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's pinentry(1).
-Accepting input without showing what is being typed is useful when keying in
-secrets in public settings or places with installed surveillance cameras.
-
-.SH BUGS
-
-This does nothing to prevent others seeing the keyboard being used to input
-secrets or mask the sound of typing. Audio or video recordings of typing can be
-used to determine what was input without needing to see the characters appear
-on the screen.
-
-Accepting secrets in shell scripts is probably not adviseable.
-
-On systems that support it, the ioctl(2) command TIOCSTI can be used to insert
-characters into the standard input going to peek. This doesn't allow snooping
-but can be used for general mischief.
-
-.SH EXAMPLES
-
-This is an sh(1p) command line that hashes a given password. It uses head(1p)
-to only accept one line of input, xargs(1p) and printf(1p) to strip the
-trailing newline, htpasswd(1) from Apache's utilities to hash the input with
-the bcrypt algorithm, and cut(1p) to print only the resulting hash:
-
-.RS
-.R $ peek | head -n 1 | xargs printf '%s' | htpasswd -nBi _ | cut -d : -f 2
-.RE
-
-This is an sh(1p) command line that lets a user blindly write into a text file,
-only able to see written lines. Some writers have the habit of prematurely
-revising their work and use tools like this to prevent it. It uses mm(1) to
-pipe the output of peek to both the standard error and the regular file
-writing.txt.
-
-.RS
-.R $ echo Input ^D to quit. && peek | mm -eo - >writing.txt
-.RE
-
-.SH AUTHOR
-
-Written by DTB <trinity@trinity.moe>.
-
-.SH COPYRIGHT
-
-Copyright (c) 2023-2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
-<https://gnu.org/licenses/gpl.html>.
-
-.SH SEE ALSO
-
-ioctl(2), ioctl_tty(2), read(1), sh(1)

docs/pg.1

@@ -0,0 +1,41 @@
+.\" Copyright (c) 2024 DTB <trinity@trinity.moe>
+.\"
+.\" 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 PG 1
+
+.SH NAME
+
+pg \(en paginate
+
+.SH SYNOPSIS
+
+pg
+.RB ( -p
+.RB [ prompt ])
+
+.SH DESCRIPTION
+
+Pg prints standard input to standard output, accepting commands between pages.
+
+.SH OPTIONS
+
+.B -p
+.RS
+Replaces the default prompt (": ") with the next argument.
+.RE
+
+.SH DIAGNOSTICS
+
+Pg returns an unsuccessful exit code if the tty couldn't be opened or if pg was
+invoked incorrectly (with any arguments).
+
+.SH RATIONALE
+
+Plan 9 from Bell Labs had p(1), a similar "cooked"-mode paginator (as opposed
+to "raw" mode, which a vast majority of paginators use).
+
+.SH SEE ALSO
+
+more(1)

src/peek.c

@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-#include <signal.h> /* sigaction(2), signal(2), struct sigaction, SIGINT */
-#include <stdio.h> /* fprintf(3), fgetc(3), perror(3), fputc(3), stderr, stdin,
-                    * stdout, EOF, NULL */
-#include <stdlib.h> /* exit(3), EXIT_FAILURE */
-#if !defined EX_IOERR || !defined EX_OK || !defined EX_USAGE
-#	include <sysexits.h>
-#endif
-#include <termios.h> /* tcgetattr(3), tcsetattr(3), struct termios, ECHO */
-#include <unistd.h> /* getopt(3), isatty(3), STDIN_FILENO */
-
-static 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;
-
-	tcgetattr(STDIN_FILENO, &t);
-	t.c_lflag |= ECHO;
-	tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
-
-	/* If, for whatever ungodly reason, exit(3) returns, the user will notice
-	 * their typed characters on the screen. */
-	if(sig != 0)
-		exit(EXIT_FAILURE);
-
-	return;
-}
-
-static int ioerr(char *s){ perror(s); restore_echo(0); return EX_IOERR; }
-static int usage(char *s){
-	fprintf(stderr, "Usage: %s (-1enot) (-p [program [arguments...]])\n", s);
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]){
-
-	if(argc < 1)
-		return usage(program_name);
-
-	{ /* option parsing */
-		char allow_nonterminals;
-		int c;
-
-		allow_nonterminals = 0;
-		while((c = getopt(argc, argv, "i")) != -1)
-			switch(c){
-			case 'i':	allow_nonterminals = 1; break;
-			default:	return usage(argv[0]);
-			}
-
-		if(argc > optind)
-			return usage(argv[0]);
-
-		if(!allow_nonterminals && isatty(STDIN_FILENO) != 1){
-			fprintf(stderr, "%s: Must be run in a terminal"
-			    " (option -i skips this check)\n", argv[0]);
-			return EX_USAGE;
-		}
-	}
-
-	{ /* 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 configurations can only use 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(argv[0]);
-#else
-		if(signal(SIGINT, restore_echo) == SIG_ERR)
-			perror(argv[0]);
-#endif
-	}
-	
-	{ /* banish terminal echo */
-		struct termios t;
-
-		tcgetattr(STDIN_FILENO, &t);
-		t.c_lflag ^= ECHO;
-		tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
-	}
-
-	{ /* actual input loop */
-		int c;
-
-		while((c = fgetc(stdin)) != EOF)
-			if(fputc(c, stdout) == EOF)
-				return ioerr(argv[0]);
-	}
-
-	restore_echo(0);
-
-	return EX_OK;
-}

src/pg.c

@@ -0,0 +1,260 @@
+/*
+ * 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 <stdio.h> /* fclose(3), feof(3), fgetc(3), fgets(3), fopen(3),
+                    * fprintf(3), fputc(3), stderr, stdin, stdout, EOF, FILE,
+                    * NULL */
+#include <stdlib.h> /* size_t */
+#include <string.h> /* strchr(3), strcmp(3), strerror(3), strtok(3) */
+#include <unistd.h> /* getopt(3) */
+
+/* Commands start with cmd_. They take an argc and NULL-terminated argv, like
+ * main, and return a status from <sysexits.h>. Return values other than EX_OK
+ * and EX_USAGE cause pg(1) to exit with that value, except EX_UNAVAILABLE,
+ * which causes pg(1) to exit with the status EX_OK. */
+#include <sysexits.h>
+
+#define CMDLINE_MAX 99+1 /* Maximum length of command line. */
+
+static char *whitespace = " \n\r\t\v";
+
+static struct {
+	size_t quantity;
+	enum { LINES = 0, BYTES = 1 } type;
+} default_page_unit = { 22, LINES } /* Plan 9 default */;
+static FILE *input;
+static char *prompt = ": ";
+static char *program_name = "pg";
+
+static char *permute_out(char *str, size_t index){
+	size_t j;
+
+	for(j = index; str[j - 1] != '\0'; ++j)
+		str[j - 1] = str[j];
+
+	return str;
+}
+
+/* strtok(3p), but supports double-quotes and escapes (but only for escaping
+ * quotes). UTF-8 is safe only in str. Unmatched quotes in str are considered
+ * literal. The behavior of strtok_quoted when '"' or '\\' are in sep is
+ * undefined. */
+/* TODO: Seems to only ever return NULL. */
+static char *strtok_quoted(char *str, char *sep){
+	static char *s;
+	size_t i;
+	size_t j;
+
+	if(str != NULL)
+		s = str;
+
+	while(strchr(sep, *s) == NULL)
+		if(*++s == '\0')
+			return NULL; /* no remaining characters except seperators */
+
+	{
+		char in_escape;
+		int in_quotes;
+
+		in_escape = 0;
+		in_quotes = -1;
+		for(i = 0; s[i] != '\0'; ++i)
+			switch(s[i]){
+			case '\\':
+				if(in_escape)
+					permute_out(s, i--);
+				in_escape = !in_escape;
+				break;
+			case '"':
+				if(in_escape){
+					s[i] = s[i - 1];
+					permute_out(s, i--);
+				}else if(in_quotes != -1){
+					permute_out(s, in_quotes);
+					--i;
+					permute_out(s, i--);
+					in_quotes = -1;
+				}else
+					in_quotes = i;
+				break;
+			case '\0':
+				return s;
+			default:
+				if(!in_escape && strchr(sep, s[i]) != NULL){
+					s[i] = '\0';
+					return s;
+				}
+			}
+	}
+
+	return s;
+}
+
+/* Page at most l bytes from f without consideration of a buffer (print them to
+ * stdout). */
+static int pg_b_u(FILE *f, size_t l){
+	int c;
+
+	while((c = fgetc(f)) != EOF)
+		if((c = fputc(c, stdout)) == EOF || --l == 0)
+			break;
+
+	return c;
+}
+
+/* Page at most l lines, which are lengths of characters terminated by nl, from
+ * f without consideration of a buffer (print them to stdout). */
+static int pg_l_u(FILE *f, size_t l, char nl){
+	int c;
+
+	while((c = fgetc(f)) != EOF)
+		if((c = fputc(c, stdout)) == EOF || (l -= (c == nl)) == 0)
+			break;
+
+	return c;
+}
+
+static int cmd_quit(int argc, char **argv, char **envp){return EX_UNAVAILABLE;}
+static int cmd_default_page(int argc, char **argv, char **envp){
+
+	if(argc > 1) /* This shouldn't be possible. */
+		return EX_USAGE;
+	if(default_page_unit.type == BYTES)
+		return pg_b_u(input, default_page_unit.quantity) == EOF
+			? EX_UNAVAILABLE
+			: EX_OK;
+	else if(default_page_unit.type == LINES)
+		return pg_l_u(input, default_page_unit.quantity, '\n') == EOF
+			? EX_UNAVAILABLE
+			: EX_OK;
+	else
+		return EX_SOFTWARE;
+}
+static int cmd_page_down_lines(int argc, char **argv, char **envp){
+
+	switch(argc){
+	case 1:
+		return cmd_default_page(argc, argv, envp);
+	case 2: /* not implemented */
+	default:
+		fprintf(stderr, "Usage: %s" /*" (lines)"*/ "\n", argv[0]);
+		return EX_USAGE;
+	}
+}
+
+/* A CmdMap must be NULL-terminated. */
+static struct CmdMap{ char *name; int (*fn)(int, char **, char **); }
+builtins[] = {
+	{ "", cmd_default_page },
+	{ "+", cmd_page_down_lines },
+
+	/* don't make the user feel trapped */
+	{ ":q", cmd_quit }, { ":q!", cmd_quit },
+	{ "exit", cmd_quit }, { "q", cmd_quit }, { "Q", cmd_quit },
+	{ "quit", cmd_quit }, { "ZZ", cmd_quit },
+	
+	{ NULL, NULL }
+};
+
+#define ARGV_MAX 10
+/* Find and execute the command in the command map, given a corresponding
+ * command line. */
+static int cmdline_exec(struct CmdMap *map, char *cmdline, char **envp){
+	/* Command line word splitting is naive and based on whitespace ONLY; no
+	 * fancy quoting or escaping here. Adding that would (ideally) entail
+	 * replacing strtok(3) with something specific to this task. */
+	static int argc;
+	static char *argv[ARGV_MAX];
+
+	if((argv[(argc = 0)] = strtok(cmdline, whitespace)) == NULL){
+		while(cmdline[0] != '\0')
+			cmdline = &cmdline[1];
+		argv[argc] = cmdline;
+		argv[++argc] = NULL;
+	}else{
+		while((argv[++argc] = strtok(NULL, whitespace)) != NULL
+		      && argc < ARGV_MAX);
+	}
+
+	for(; map->name != NULL; map = &map[1])
+		if(strcmp(map->name, argv[0]) == 0)
+			return map->fn(argc, argv, envp);
+
+	fprintf(stderr, "%s: %s: not found\n", program_name, argv[0]);
+	return EX_USAGE;
+}
+
+int usage(char *s){
+	fprintf(stderr, "Usage: %s (-p [prompt])\n", s);
+	return EX_USAGE;
+}
+
+int main(int argc, char *argv[]){
+	unsigned char cmd[CMDLINE_MAX];
+	FILE *t;
+
+	input = stdin;
+
+	if(argc < 1)
+		program_name = argv[0];
+	else{
+		int c;
+
+		while((c = getopt(argc, argv, "p:")) != -1)
+			switch(c){
+			case 'p': prompt = optarg; break;
+			default:
+				return usage(program_name);
+			}
+	}
+
+	if(argc > optind)
+		return usage(program_name);
+
+
+	if((t = fopen("/dev/tty", "rb")) == NULL){
+		fprintf(stderr, "%s: /dev/tty: %s\n", program_name, strerror(errno));
+		return EX_OSERR;
+	}
+
+	for(;;){
+		fputs(prompt, stderr);
+		fgets((char *)cmd, (sizeof cmd) / (sizeof *cmd), t);
+		if(strchr((char *)cmd, '\n') == NULL){ /* fast-forward stream */
+			int c;
+
+			while((c = fgetc(t)) != '\n')
+				if(c == EOF)
+					break;
+		}
+
+		if(feof(t))
+			return EX_OK;
+
+		{	int r;
+			switch((r = cmdline_exec(builtins, (char *)cmd, NULL))){
+			case EX_OK: case EX_USAGE: break;
+			case EX_UNAVAILABLE: return EX_OK;
+			default: return r;
+		}	}
+	}
+
+	/* UNREACHABLE */
+	return EX_SOFTWARE;
+}