gawk

main.c (6078B)

---

 /* Copyright 2020, 2021 Jacob R. Edwards
  *
  * This file is part of gawk.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <dirent.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 
 #include "command.h"
 #include "gawk.h"
 #include "net.h"
 #include "util.h"
 #include "config.h"	/* must be included last */
 
 static char tmpdir[] = "/tmp/gawk-XXXXXXXXXXX";
 static int fatal;
 
 void
 putprompt(char const *prompt)
 {
 	if (isatty(STDIN_FILENO))
 		fputs(prompt, stderr);
 	else if (errno == ENOTTY)
 		errno = 0;
 }
 
 int
 input(char *buf, int size, char const *delims, char const *prompt, FILE *fp)
 {
 	int next;
 	static unsigned int len;
 	static char bb[MY_INPUT_MAX];
 
 	if (len <= 0) {
 		putprompt(prompt);
 refill_bufbuf:
 		if (fgets(bb + len, sizeof(bb) - len, fp) == NULL)
 			return 1;
 		len = strlen(bb);
 	}
 
 	next = strcspn(bb, delims);
 	if (bb[next] == '\0') {
 		if (len >= sizeof(buf) - 1) {
 too_big:
 			warn(0, "input too large");
 			return 1;
 		}
 		goto refill_bufbuf;
 	}
 	if (next >= size)
 		goto too_big;
 
 	bb[next++] = '\0';
 	strlcpy(buf, bb, size);
 	memmove(bb, bb + next, len - next);
 	len -= next;
 
 	return 0;
 }
 
 int
 runpipe(struct command *cmds, int *indexes, int count, char **item)
 {
 	int i;
 	int r;
 
 	for (i = 0; i < count; ++i) {
 		r = cmds[i].f(cmds[i].argc, cmds[i].argv, indexes[i]++, item);
 		if (r != PASS && r != NEXT)
 			return r;
 		if (cmds[i].negate)
 			r = !r;
 		if (r)
 			return NEXT;
 	}
 	return PASS;
 }
 
 int
 gphsplit(char **item, int size, char *buf)
 {
 	int n;
 
 	n = argsplit(item, size, buf, "\t\r", 0) - 1;
 	if (n != 4 && (n < 4 || n > 5 || strcmp(item[GI_PLUS], "+") != 0))
 		return ERROR;
 	return 0;
 }
 
 int
 runpipes(char const *cache, struct command *cmds, int count)
 {
 	FILE *fp;
 	char buf[MY_LINE_MAX];
 	char *item[GI_NULL + 2];
 	int error;
 	int indexes[count];
 
 	memset(indexes, 0, sizeof(indexes));
 
 	fp = wfopen(cache, "r");
 	if (fp == NULL)
 		return UNWIND;
 
 	error = 0;
 	while (error != FAIL && fgets(buf, sizeof(buf), fp) && *buf != '.')
 		if (gphsplit(item, sizeof(item), buf) == 0)
 			error = runpipe(cmds, indexes, count, item);
 	wfclose(fp);
 	return error;
 }
 
 command *
 getcom(char const *s, struct bind const *const binds, int size)
 {
 	int i;
 
 	if (strlen(s) != 1)
 		return NULL;
 	for (i = 0; i < size; ++i)
 		if (*s == binds[i].c)
 			return binds[i].f;
 	return NULL;
 }
 
 int
 execute(char const *cache, char *input, int depth, char **addr)
 {
 	int i;
 	int nbufs;
 	char *bufs[MY_PIPE_MAX];
 	struct command cmds[MY_PIPE_MAX];
 
 	nbufs = argsplit(bufs, LEN(bufs), input, separators[1], 0);
 	if (nbufs < 0) {
 		warn(0, "pipeline too long");
 		return ERROR;
 	}
 		
 	for (i = 0; i < nbufs; ++i) {
 		cmds[i].argc = argsplit(cmds[i].argv, LEN(cmds[i].argv),
 		    bufs[i], separators[2], 1);
 		if (cmds[i].argc < 1) {
 			if (cmds[i].argc < 0)
 				warn(0, "command %d: Too many arguments", i);
 			else if (nbufs > 1)
 				warn(0, "command %d: Empty command", i);
 			return ERROR;
 		}
 		if (cmds[i].argv[0][0] != negate) {
 			cmds[i].negate = 0;
 		} else {
 			cmds[i].negate = 1;
 			cmds[i].argv[0]++;
 		}
 	}
 
 	for (i = 0; i < nbufs; ++i) {
 		cmds[i].f = getcom(cmds[i].argv[0], itembinds, LEN(itembinds));
 		if (cmds[i].f == NULL) {
 			if (i > 0) {
 				warn(0, "'%s': Not a pipeline command",
 				    cmds[i].argv[0]);
 				return ERROR;
 			}
 			cmds[i].f = getcom(cmds[i].argv[0], binds, LEN(binds));
 			if (cmds[i].f == NULL) {
 				warn(0, "'%s': Not a command", cmds[i].argv[0]);
 				return ERROR;
 			}
 			return cmds[i].f(cmds[i].argc, cmds[i].argv, depth, addr);
 		}
 	}
 
 	return runpipes(cache, cmds, nbufs);
 }
 
 void
 tmp_mkpath(char *cache, char **addr)
 {
 	char tmp[MY_PATH_MAX];
 
 	tr(tmp, addr[AR_PATH], '/', '-');
 	snprintf(cache, MY_PATH_MAX, "%s/%s_%s_%s",
 	    tmpdir, addr[AR_HOST], addr[AR_PORT], tmp);
 }
 
 int
 gawk(char **addr)
 {
 	static int depth;
 	char cache[MY_PATH_MAX];
 	char inbuf[MY_INPUT_MAX];
 	char prompt[MY_PROMPT_MAX];
 	int done;
 	int mycache;
 
 	tmp_mkpath(cache, addr);
 	if (exists(cache)) {
 		mycache = 0;
 	} else {
 		if (gopher(addr, cache, 0, timeout) == 1)
 			return ERROR;
 		mycache = 1;
 	}
 
 	++depth;
 
 	snprintf(prompt, sizeof(prompt), "(%d) [%s] %s ",
 	    depth, addr[AR_HOST], addr[AR_PATH]);
 	done = 0;
 	while (!fatal && done <= 0 &&
 	    input(inbuf, sizeof(inbuf), separators[0], prompt, stdin) == 0) {
 		done = execute(cache, inbuf, depth, addr);
 	}
 
 	if (mycache)
 		wremove(cache);
 	if (feof(stdin))
 		done = depth;
 	else if (ferror(stdin) && !fatal) {
 		warn(errno, "stdin");
 		return fatal = -1;
 	}
 
 	--depth;
 	return done - 1;
 }
 
 void
 cleanup(void)
 {
 	DIR *dir;
 	char path[MY_PATH_MAX];
 	struct dirent *ent;
 
 	dir = opendir(tmpdir);
 	if (dir == NULL)
 		return;	/* ENOTDIR */
 	while ((ent = readdir(dir)) != NULL) {
 		if (ent->d_type == DT_REG) {
 			snprintf(path, sizeof(path), "%s/%s", tmpdir, ent->d_name);
 			wremove(path);
 		}
 	}
 	wremove(tmpdir);
 }
 
 void
 sighandler(int sig)
 {
 	cleanup();
 	exit(EXIT_FAILURE);
 }
 
 int
 main(int argc, char *argv[])
 {
 	int status;
 
 	if (argc > 1 && *argv[1] == '-') {
 		fprintf(stderr, "usage: %s [path [host [port]]]\n", getprogname());
 		return 1;
 	}
 
 #ifdef __OpenBSD__
 	if (pledge("stdio rpath wpath cpath inet dns proc exec", NULL) == -1)
 		die(errno, "pledge");
 #endif /* __OpenBSD__ */
 
 	signal(SIGCHLD, SIG_IGN);
 	signal(SIGINT, sighandler);
 
 	if (mkdtemp(tmpdir) == NULL)
 		die(errno, "mkdtemp");
 	status = sgoto(argc, argv, 0, default_address);
 	if (wremove(tmpdir) == -1)
 		return 1;
 
 	return status;
 }