Bruce/bb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improved memory allocation/error checking helper functions. Also

Browse Source 
reworked stderr so that it prints to the console on exit.
This commit is contained in:
Bruce Hill 2021-07-28 22:34:51 -07:00
parent fe75508665
commit 783f127199
4 changed files with 155 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -22,7 +22,7 @@ CWARN=-Wall -Wextra
CFLAGS += '-DBB_NAME="$(NAME)"' CFLAGS += '-DBB_NAME="$(NAME)"'
OSFLAGS != case $$(uname -s) in *BSD|Darwin) echo '-D_BSD_SOURCE';; Linux) echo '-D_GNU_SOURCE';; *) echo '-D_DEFAULT_SOURCE';; esac OSFLAGS != case $$(uname -s) in *BSD|Darwin) echo '-D_BSD_SOURCE';; Linux) echo '-D_GNU_SOURCE';; *) echo '-D_DEFAULT_SOURCE';; esac
CFILES=draw.c terminal.c CFILES=draw.c terminal.c utils.c
OBJFILES=$(CFILES:.c=.o) OBJFILES=$(CFILES:.c=.o)
all: $(NAME) all: $(NAME)

162
bb.c
View File

@ -7,6 +7,7 @@
// //
#include <ctype.h> #include <ctype.h>
#include <err.h>
#include <fcntl.h> #include <fcntl.h>
#include <glob.h> #include <glob.h>
#include <limits.h> #include <limits.h>
@ -36,11 +37,6 @@
#define SCROLLOFF MIN(5, (winsize.ws_row-4)/2) #define SCROLLOFF MIN(5, (winsize.ws_row-4)/2)
#define ONSCREEN (winsize.ws_row - 3) #define ONSCREEN (winsize.ws_row - 3)
#define new(t) memcheck(calloc(1, sizeof(t)))
#define xcalloc(a,b) memcheck(calloc(a,b))
#define xrealloc(a,b) memcheck(realloc(a,b))
#define clean_err(...) do { cleanup(); err(1, __VA_ARGS__); } while (0)
// Functions // Functions
void bb_browse(bb_t *bb, int argc, char *argv[]); void bb_browse(bb_t *bb, int argc, char *argv[]);
static void check_cmdfile(bb_t *bb); static void check_cmdfile(bb_t *bb);
@ -54,7 +50,6 @@ static void init_term(void);
static int is_simple_bbcmd(const char *s); static int is_simple_bbcmd(const char *s);
static entry_t* load_entry(bb_t *bb, const char *path); static entry_t* load_entry(bb_t *bb, const char *path);
static int matches_cmd(const char *str, const char *cmd); static int matches_cmd(const char *str, const char *cmd);
static void* memcheck(void *p);
static char* normalize_path(const char *path, char *pbuf); static char* normalize_path(const char *path, char *pbuf);
static int populate_files(bb_t *bb, const char *path); static int populate_files(bb_t *bb, const char *path);
static void print_bindings(int fd); static void print_bindings(int fd);
@ -91,6 +86,10 @@ static struct winsize winsize = {0};
static char cmdfilename[PATH_MAX] = {0}; static char cmdfilename[PATH_MAX] = {0};
static bb_t *current_bb = NULL; static bb_t *current_bb = NULL;
static char err_tmpfilename[PATH_MAX] = {0};
int stderr_dup_fd = -1, err_tmp_fd = -1;
FILE *err_file = NULL;
// //
// Use bb to browse the filesystem. // Use bb to browse the filesystem.
// //
@ -112,8 +111,7 @@ void bb_browse(bb_t *bb, int argc, char *argv[])
struct stat path_stat; struct stat path_stat;
const char *goto_file = NULL; const char *goto_file = NULL;
if (stat(full_initial_path, &path_stat) != 0) nonnegative(stat(full_initial_path, &path_stat), "Could not find initial path: \"%s\"", initial_path);
clean_err("Could not find initial path: \"%s\"", initial_path);
if (!S_ISDIR(path_stat.st_mode)) { if (!S_ISDIR(path_stat.st_mode)) {
char *slash = strrchr(full_initial_path, '/'); char *slash = strrchr(full_initial_path, '/');
*slash = '\0'; *slash = '\0';
@ -121,12 +119,12 @@ void bb_browse(bb_t *bb, int argc, char *argv[])
} }
if (populate_files(bb, full_initial_path)) if (populate_files(bb, full_initial_path))
clean_err("Could not find initial path: \"%s\"", full_initial_path); errx(EXIT_FAILURE, "Could not find initial path: \"%s\"", full_initial_path);
// Emergency fallback: // Emergency fallback:
bindings[0].key = KEY_CTRL_C; bindings[0].key = KEY_CTRL_C;
bindings[0].script = strdup("kill -INT $PPID"); bindings[0].script = check_strdup("kill -INT $PPID");
bindings[0].description = strdup("Kill the bb process"); bindings[0].description = check_strdup("Kill the bb process");
run_script(bb, "bbstartup"); run_script(bb, "bbstartup");
FILE *cmdfile = fopen(cmdfilename, "a"); FILE *cmdfile = fopen(cmdfilename, "a");
@ -170,7 +168,7 @@ static void check_cmdfile(bb_t *bb)
run_bbcmd(bb, cmd); run_bbcmd(bb, cmd);
if (bb->should_quit) break; if (bb->should_quit) break;
} }
free(cmd); delete(&cmd);
fclose(cmdfile); fclose(cmdfile);
unlink(cmdfilename); unlink(cmdfilename);
} }
@ -209,6 +207,17 @@ static void cleanup(void)
fflush(tty_out); fflush(tty_out);
tcsetattr(fileno(tty_out), TCSANOW, &orig_termios); tcsetattr(fileno(tty_out), TCSANOW, &orig_termios);
} }
if (err_tmp_fd != -1) {
fflush(stderr);
dup2(stderr_dup_fd, STDERR_FILENO); // Put stderr back to normal
char buf[256];
lseek(err_tmp_fd, 0, SEEK_SET);
for (ssize_t len; (len = read(err_tmp_fd, buf, sizeof(buf))) > 0; )
write(STDERR_FILENO, buf, len);
close(err_tmp_fd);
err_tmp_fd = stderr_dup_fd = -1;
unlink(err_tmpfilename);
}
} }
// //
@ -359,8 +368,7 @@ static void handle_next_key_binding(bb_t *bb)
// //
static void init_term(void) static void init_term(void)
{ {
if (tcsetattr(fileno(tty_out), TCSANOW, &bb_termios) == -1) nonnegative(tcsetattr(fileno(tty_out), TCSANOW, &bb_termios));
clean_err("Couldn't tcsetattr");
update_term_size(0); update_term_size(0);
// Initiate mouse tracking and disable text wrapping: // Initiate mouse tracking and disable text wrapping:
fputs(T_ENTER_BBMODE, tty_out); fputs(T_ENTER_BBMODE, tty_out);
@ -415,15 +423,14 @@ static entry_t* load_entry(bb_t *bb, const char *path)
ssize_t linkpathlen = -1; ssize_t linkpathlen = -1;
char linkbuf[PATH_MAX]; char linkbuf[PATH_MAX];
if (S_ISLNK(filestat.st_mode)) { if (S_ISLNK(filestat.st_mode)) {
linkpathlen = readlink(pbuf, linkbuf, sizeof(linkbuf)); linkpathlen = nonnegative(readlink(pbuf, linkbuf, sizeof(linkbuf)), "Couldn't read link: '%s'", pbuf);
if (linkpathlen < 0) clean_err("Couldn't read link: '%s'", pbuf);
linkbuf[linkpathlen] = '\0'; linkbuf[linkpathlen] = '\0';
while (linkpathlen > 0 && linkbuf[linkpathlen-1] == '/') linkbuf[--linkpathlen] = '\0'; while (linkpathlen > 0 && linkbuf[linkpathlen-1] == '/') linkbuf[--linkpathlen] = '\0';
if (stat(pbuf, &linkedstat) == -1) memset(&linkedstat, 0, sizeof(linkedstat)); if (stat(pbuf, &linkedstat) == -1) memset(&linkedstat, 0, sizeof(linkedstat));
} }
size_t pathlen = strlen(pbuf); size_t pathlen = strlen(pbuf);
size_t entry_size = sizeof(entry_t) + (pathlen + 1) + (size_t)(linkpathlen + 1); size_t entry_size = sizeof(entry_t) + (pathlen + 1) + (size_t)(linkpathlen + 1);
entry_t *entry = xcalloc(entry_size, 1); entry_t *entry = new_bytes(entry_size);
char *end = stpcpy(entry->fullname, pbuf); char *end = stpcpy(entry->fullname, pbuf);
if (linkpathlen >= 0) if (linkpathlen >= 0)
entry->linkname = strcpy(end + 1, linkbuf); entry->linkname = strcpy(end + 1, linkbuf);
@ -453,16 +460,6 @@ static int matches_cmd(const char *str, const char *cmd)
return *str == '\0' || *str == ':'; return *str == '\0' || *str == ':';
} }
//
// Memory allocation failures are unrecoverable in bb, so this wrapper just
// prints an error message and exits if that happens.
//
static void* memcheck(void *p)
{
if (!p) clean_err("Allocation failure");
return p;
}
// //
// Prepend `./` to relative paths, replace "~" with $HOME. // Prepend `./` to relative paths, replace "~" with $HOME.
// The normalized path is stored in `normalized`. // The normalized path is stored in `normalized`.
@ -532,7 +529,7 @@ static int populate_files(bb_t *bb, const char *path)
if (clear_future_history && !samedir) { if (clear_future_history && !samedir) {
for (bb_history_t *next, *h = bb->history ? bb->history->next : NULL; h; h = next) { for (bb_history_t *next, *h = bb->history ? bb->history->next : NULL; h; h = next) {
next = h->next; next = h->next;
free(h); delete(&h);
} }
bb_history_t *h = new(bb_history_t); bb_history_t *h = new(bb_history_t);
@ -553,8 +550,7 @@ static int populate_files(bb_t *bb, const char *path)
try_free_entry(bb->files[i]); try_free_entry(bb->files[i]);
bb->files[i] = NULL; bb->files[i] = NULL;
} }
free(bb->files); delete(&bb->files);
bb->files = NULL;
} }
bb->nfiles = 0; bb->nfiles = 0;
bb->cursor = 0; bb->cursor = 0;
@ -565,10 +561,10 @@ static int populate_files(bb_t *bb, const char *path)
size_t space = 0; size_t space = 0;
glob_t globbuf = {0}; glob_t globbuf = {0};
char *pat, *tmpglob = memcheck(strdup(bb->globpats)); char *pat, *tmpglob = check_strdup(bb->globpats);
while ((pat = strsep(&tmpglob, " ")) != NULL) while ((pat = strsep(&tmpglob, " ")) != NULL)
glob(pat, GLOB_NOSORT|GLOB_APPEND, NULL, &globbuf); glob(pat, GLOB_NOSORT|GLOB_APPEND, NULL, &globbuf);
free(tmpglob); delete(&tmpglob);
for (size_t i = 0; i < globbuf.gl_pathc; i++) { for (size_t i = 0; i < globbuf.gl_pathc; i++) {
// Don't normalize path so we can get "." and ".." // Don't normalize path so we can get "." and ".."
entry_t *entry = load_entry(bb, globbuf.gl_pathv[i]); entry_t *entry = load_entry(bb, globbuf.gl_pathv[i]);
@ -578,7 +574,7 @@ static int populate_files(bb_t *bb, const char *path)
} }
entry->index = bb->nfiles; entry->index = bb->nfiles;
if ((size_t)bb->nfiles + 1 > space) if ((size_t)bb->nfiles + 1 > space)
bb->files = xrealloc(bb->files, (space += 100)*sizeof(void*)); bb->files = grow(bb->files, space += 100);
bb->files[bb->nfiles++] = entry; bb->files[bb->nfiles++] = entry;
} }
globfree(&globbuf); globfree(&globbuf);
@ -657,12 +653,12 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
const char *value = strchr(cmd, ':'); const char *value = strchr(cmd, ':');
if (value) ++value; if (value) ++value;
if (matches_cmd(cmd, "bind:")) { // +bind:<keys>:<script> if (matches_cmd(cmd, "bind:")) { // +bind:<keys>:<script>
char *value_copy = memcheck(strdup(value)); char *value_copy = check_strdup(value);
char *keys = trim(value_copy); char *keys = trim(value_copy);
if (!keys[0]) { free(value_copy); return; } if (!keys[0]) { delete(&value_copy); return; }
char *script = strchr(keys+1, ':'); char *script = strchr(keys+1, ':');
if (!script) { if (!script) {
free(value_copy); delete(&value_copy);
flash_warn(bb, "No script provided."); flash_warn(bb, "No script provided.");
return; return;
} }
@ -683,16 +679,16 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
continue; continue;
char *script2; char *script2;
if (is_simple_bbcmd(script)) { if (is_simple_bbcmd(script)) {
script2 = memcheck(strdup(script)); script2 = check_strdup(script);
} else { } else {
const char *prefix = "set -e\n"; const char *prefix = "set -e\n";
script2 = xcalloc(strlen(prefix) + strlen(script) + 1, 1); script2 = new_bytes(strlen(prefix) + strlen(script) + 1);
sprintf(script2, "%s%s", prefix, script); sprintf(script2, "%s%s", prefix, script);
} }
binding_t binding = {keyval, script2, memcheck(strdup(description))}; binding_t binding = {keyval, script2, check_strdup(description)};
if (bindings[i].key == keyval) { if (bindings[i].key == keyval) {
free((char*)bindings[i].description); delete((char**)&bindings[i].description);
free((char*)bindings[i].script); delete((char**)&bindings[i].script);
for (; i + 1 < sizeof(bindings)/sizeof(bindings[0]) && bindings[i+1].key; i++) for (; i + 1 < sizeof(bindings)/sizeof(bindings[0]) && bindings[i+1].key; i++)
bindings[i] = bindings[i+1]; bindings[i] = bindings[i+1];
} }
@ -700,7 +696,7 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
break; break;
} }
} }
free(value_copy); delete(&value_copy);
} else if (matches_cmd(cmd, "cd:")) { // +cd: } else if (matches_cmd(cmd, "cd:")) { // +cd:
if (populate_files(bb, value)) if (populate_files(bb, value))
flash_warn(bb, "Could not open directory: \"%s\"", value); flash_warn(bb, "Could not open directory: \"%s\"", value);
@ -737,8 +733,7 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
fputs("\033[K", tty_out); fputs("\033[K", tty_out);
restore_term(&orig_termios); restore_term(&orig_termios);
signal(SIGTTOU, SIG_IGN); signal(SIGTTOU, SIG_IGN);
if (tcsetpgrp(fileno(tty_out), child->pid)) nonnegative(tcsetpgrp(fileno(tty_out), child->pid));
clean_err("Couldn't set pgrp");
kill(-(child->pid), SIGCONT); kill(-(child->pid), SIGCONT);
wait_for_process(&child); wait_for_process(&child);
signal(SIGTTOU, SIG_DFL); signal(SIGTTOU, SIG_DFL);
@ -758,7 +753,7 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
char pbuf[PATH_MAX]; char pbuf[PATH_MAX];
strcpy(pbuf, e->fullname); strcpy(pbuf, e->fullname);
char *lastslash = strrchr(pbuf, '/'); char *lastslash = strrchr(pbuf, '/');
if (!lastslash) clean_err("No slash found in filename: %s", pbuf); if (!lastslash) errx(EXIT_FAILURE, "No slash found in filename: %s", pbuf);
*lastslash = '\0'; // Split in two *lastslash = '\0'; // Split in two
try_free_entry(e); try_free_entry(e);
// Move to dir and reselect // Move to dir and reselect
@ -773,14 +768,13 @@ static void run_bbcmd(bb_t *bb, const char *cmd)
} else if (matches_cmd(cmd, "help")) { // +help } else if (matches_cmd(cmd, "help")) { // +help
char filename[PATH_MAX]; char filename[PATH_MAX];
sprintf(filename, "%s/bbhelp.XXXXXX", getenv("TMPDIR")); sprintf(filename, "%s/bbhelp.XXXXXX", getenv("TMPDIR"));
int fd = mkstemp(filename); int fd = nonnegative(mkstemp(filename), "Couldn't create temporary help file at %s", filename);
if (fd == -1) clean_err("Couldn't create temporary help file at %s", filename);
print_bindings(fd); print_bindings(fd);
close(fd); close(fd);
char script[512] = "less -rKX < "; char script[512] = "less -rKX < ";
strcat(script, filename); strcat(script, filename);
run_script(bb, script); run_script(bb, script);
if (unlink(filename) == -1) clean_err("Couldn't delete temporary help file: '%s'", filename); nonnegative(unlink(filename), "Couldn't delete temporary help file: '%s'", filename);
} else if (matches_cmd(cmd, "interleave:") || matches_cmd(cmd, "interleave")) { // +interleave } else if (matches_cmd(cmd, "interleave:") || matches_cmd(cmd, "interleave")) { // +interleave
bb->interleave_dirs = value ? (value[0] == '1') : !bb->interleave_dirs; bb->interleave_dirs = value ? (value[0] == '1') : !bb->interleave_dirs;
set_interleave(bb, bb->interleave_dirs); set_interleave(bb, bb->interleave_dirs);
@ -858,12 +852,11 @@ static int run_script(bb_t *bb, const char *cmd)
{ {
proc_t *proc = new(proc_t); proc_t *proc = new(proc_t);
signal(SIGTTOU, SIG_IGN); signal(SIGTTOU, SIG_IGN);
if ((proc->pid = fork()) == 0) { if ((proc->pid = nonnegative(fork())) == 0) {
pid_t pgrp = getpid(); pid_t pgrp = getpid();
(void)setpgid(0, pgrp); (void)setpgid(0, pgrp);
if (tcsetpgrp(STDIN_FILENO, pgrp)) nonnegative(tcsetpgrp(STDIN_FILENO, pgrp));
clean_err("Couldn't set pgrp"); const char **args = new(char*[4 + (size_t)bb->nselected + 1]);
const char **args = xcalloc(4 + (size_t)bb->nselected + 1, sizeof(char*));
int i = 0; int i = 0;
args[i++] = "sh"; args[i++] = "sh";
args[i++] = "-c"; args[i++] = "-c";
@ -880,13 +873,10 @@ static int run_script(bb_t *bb, const char *cmd)
dup2(fileno(tty_out), STDOUT_FILENO); dup2(fileno(tty_out), STDOUT_FILENO);
dup2(fileno(tty_in), STDIN_FILENO); dup2(fileno(tty_in), STDIN_FILENO);
execvp(args[0], (char**)args); execvp(args[0], (char**)args);
clean_err("Failed to execute command: '%s'", cmd); err(EXIT_FAILURE, "Failed to execute command: '%s'", cmd);
return -1; return -1;
} }
if (proc->pid == -1)
clean_err("Failed to fork");
(void)setpgid(getpid(), getpid()); (void)setpgid(getpid(), getpid());
LL_PREPEND(bb->running_procs, proc, running); LL_PREPEND(bb->running_procs, proc, running);
int status = wait_for_process(&proc); int status = wait_for_process(&proc);
@ -937,8 +927,8 @@ static void set_cursor(bb_t *bb, int newcur)
// //
static void set_globs(bb_t *bb, const char *globs) static void set_globs(bb_t *bb, const char *globs)
{ {
free(bb->globpats); delete(&bb->globpats);
bb->globpats = memcheck(strdup(globs)); bb->globpats = check_strdup(globs);
setenv("BBGLOB", bb->globpats, 1); setenv("BBGLOB", bb->globpats, 1);
} }
@ -1036,7 +1026,7 @@ static int try_free_entry(entry_t *e)
{ {
if (IS_SELECTED(e) || IS_VIEWED(e) || !IS_LOADED(e)) return 0; if (IS_SELECTED(e) || IS_VIEWED(e) || !IS_LOADED(e)) return 0;
LL_REMOVE(e, hash); LL_REMOVE(e, hash);
free(e); delete(&e);
return 1; return 1;
} }
@ -1086,13 +1076,11 @@ static int wait_for_process(proc_t **proc)
continue; continue;
if (WIFEXITED(status) || WIFSIGNALED(status)) { if (WIFEXITED(status) || WIFSIGNALED(status)) {
LL_REMOVE((*proc), running); LL_REMOVE((*proc), running);
free(*proc); delete(proc);
*proc = NULL;
} else if (WIFSTOPPED(status)) } else if (WIFSTOPPED(status))
break; break;
} }
if (tcsetpgrp(fileno(tty_out), getpid())) nonnegative(tcsetpgrp(fileno(tty_out), getpid()));
clean_err("Failed to set pgrp");
signal(SIGTTOU, SIG_DFL); signal(SIGTTOU, SIG_DFL);
return status; return status;
} }
@ -1146,9 +1134,9 @@ int main(int argc, char *argv[])
// Default values // Default values
setenv("TMPDIR", "/tmp", 0); setenv("TMPDIR", "/tmp", 0);
sprintf(cmdfilename, "%s/"BB_NAME".XXXXXX", getenv("TMPDIR")); sprintf(cmdfilename, "%s/"BB_NAME".XXXXXX", getenv("TMPDIR"));
int cmdfd; int cmdfd = nonnegative(
if ((cmdfd = mkostemp(cmdfilename, O_APPEND)) == -1) mkostemp(cmdfilename, O_APPEND),
clean_err("Couldn't create "BB_NAME" command file: '%s'", cmdfilename); "Couldn't create "BB_NAME" command file: '%s'", cmdfilename);
close(cmdfd); close(cmdfd);
setenv("BBCMD", cmdfilename, 1); setenv("BBCMD", cmdfilename, 1);
char xdg_config_home[PATH_MAX], xdg_data_home[PATH_MAX]; char xdg_config_home[PATH_MAX], xdg_data_home[PATH_MAX];
@ -1162,21 +1150,22 @@ int main(int argc, char *argv[])
static char bbpath[PATH_MAX]; static char bbpath[PATH_MAX];
// Hacky fix to allow `bb` to be run out of its build directory: // Hacky fix to allow `bb` to be run out of its build directory:
if (strncmp(argv[0], "./", 2) == 0) { if (strncmp(argv[0], "./", 2) == 0) {
if (realpath(argv[0], bbpath) == NULL) nonnull(realpath(argv[0], bbpath), "Could not resolve path: %s", bbpath);
clean_err("Could not resolve path: %s", bbpath);
char *slash = strrchr(bbpath, '/'); char *slash = strrchr(bbpath, '/');
if (!slash) clean_err("No slash found in real path: %s", bbpath); if (!slash) errx(EXIT_FAILURE, "No slash found in real path: %s", bbpath);
*slash = '\0'; *slash = '\0';
setenv("BBPATH", bbpath, 1); setenv("BBPATH", bbpath, 1);
} }
if (getenv("BBPATH")) { if (getenv("BBPATH")) {
if (asprintf(&newpath, "%s/"BB_NAME":%s/scripts:%s", nonnegative(
getenv("XDG_CONFIG_HOME"), getenv("BBPATH"), getenv("PATH")) < 0) asprintf(&newpath, "%s/"BB_NAME":%s/scripts:%s",
clean_err("Could not allocate memory for PATH"); getenv("XDG_CONFIG_HOME"), getenv("BBPATH"), getenv("PATH")),
"Could not allocate memory for PATH");
} else { } else {
if (asprintf(&newpath, "%s/"BB_NAME":%s/"BB_NAME":%s", nonnegative(
getenv("XDG_CONFIG_HOME"), getenv("sysconfdir"), getenv("PATH")) < 0) asprintf(&newpath, "%s/"BB_NAME":%s/"BB_NAME":%s",
clean_err("Could not allocate memory for PATH"); getenv("XDG_CONFIG_HOME"), getenv("sysconfdir"), getenv("PATH")),
"Could not allocate memory for PATH");
} }
setenv("PATH", newpath, 1); setenv("PATH", newpath, 1);
@ -1188,17 +1177,21 @@ int main(int argc, char *argv[])
sprintf(depthstr, "%d", depth + 1); sprintf(depthstr, "%d", depth + 1);
setenv("BBDEPTH", depthstr, 1); setenv("BBDEPTH", depthstr, 1);
tty_in = fopen("/dev/tty", "r"); atexit(cleanup);
if (!tty_in) clean_err("Couldn't open /dev/tty file for reading");
tty_out = fopen("/dev/tty", "w"); sprintf(err_tmpfilename, "%s/"BB_NAME".err.XXXXXX", getenv("TMPDIR"));
if (!tty_out) clean_err("Couldn't open /dev/tty file for writing"); err_tmp_fd = nonnegative(mkostemp(err_tmpfilename, O_RDWR), "Couldn't create error file");
if (tcgetattr(fileno(tty_out), &orig_termios)) stderr_dup_fd = nonnegative(dup(STDERR_FILENO));
clean_err("Couldn't tcgetattr"); nonnegative(dup2(err_tmp_fd, STDERR_FILENO), "Couldn't redirect error output");
tty_in = nonnull(fopen("/dev/tty", "r"));
tty_out = nonnull(fopen("/dev/tty", "w"));
nonnegative(tcgetattr(fileno(tty_out), &orig_termios));
memcpy(&bb_termios, &orig_termios, sizeof(bb_termios)); memcpy(&bb_termios, &orig_termios, sizeof(bb_termios));
cfmakeraw(&bb_termios); cfmakeraw(&bb_termios);
bb_termios.c_cc[VMIN] = 0; bb_termios.c_cc[VMIN] = 0;
bb_termios.c_cc[VTIME] = 1; bb_termios.c_cc[VTIME] = 1;
atexit(cleanup);
int signals[] = {SIGTERM, SIGINT, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGSEGV, SIGTSTP}; int signals[] = {SIGTERM, SIGINT, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGSEGV, SIGTSTP};
struct sigaction sa = {.sa_handler = &cleanup_and_raise, .sa_flags = (int)(SA_NODEFER | SA_RESETHAND)}; struct sigaction sa = {.sa_handler = &cleanup_and_raise, .sa_flags = (int)(SA_NODEFER | SA_RESETHAND)};
for (size_t i = 0; i < sizeof(signals)/sizeof(signals[0]); i++) for (size_t i = 0; i < sizeof(signals)/sizeof(signals[0]); i++)
@ -1213,7 +1206,6 @@ int main(int argc, char *argv[])
set_globs(&bb, "*"); set_globs(&bb, "*");
init_term(); init_term();
bb_browse(&bb, argc, argv); bb_browse(&bb, argc, argv);
cleanup();
if (bb.selected && print_selection) { if (bb.selected && print_selection) {
for (entry_t *e = bb.selected; e; e = e->selected.next) { for (entry_t *e = bb.selected; e; e = e->selected.next) {
@ -1229,10 +1221,10 @@ int main(int argc, char *argv[])
populate_files(&bb, NULL); populate_files(&bb, NULL);
while (bb.selected) while (bb.selected)
set_selected(&bb, bb.selected, 0); set_selected(&bb, bb.selected, 0);
free(bb.globpats); delete(&bb.globpats);
for (bb_history_t *next; bb.history; bb.history = next) { for (bb_history_t *next; bb.history; bb.history = next) {
next = bb.history->next; next = bb.history->next;
free(bb.history); delete(&bb.history);
} }
return 0; return 0;
} }

57
utils.c Normal file
View File

@ -0,0 +1,57 @@
//
// utils.c
// Copyright 2021 Bruce Hill
// Released under the MIT license with the Commons Clause
//
// This file contains implementations of some convenience functions for more
// easily error checking.
//
#include <err.h>
#include <stdarg.h>
#include <stdlib.h>
//
// If the given argument is nonnegative, print the error message and exit with
// failure. Otherwise, return the given argument.
//
int check_nonnegative(int negative_err, const char *err_msg, ...)
{
if (negative_err < 0) {
va_list args;
va_start(args, err_msg);
verr(EXIT_FAILURE, err_msg, args);
va_end(args);
}
return negative_err;
}
//
// If the given argument is NULL, print the error message and exit with
// failure. Otherwise return the given argument.
//
void *check_nonnull(void *p, const char *err_msg, ...)
{
if (p == NULL) {
va_list args;
va_start(args, err_msg);
verr(EXIT_FAILURE, err_msg, args);
va_end(args);
}
return p;
}
//
// For a given pointer to a memory-allocated pointer, free its memory and set
// the pointer to NULL. (This is a safer alternative to free() that
// automatically NULLs out the pointer so it can't be used after freeing)
//
void delete(void *p)
{
if (*(void**)p != NULL) {
free(*(void**)p);
*(void**)p = NULL;
}
}
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1

24
utils.h
View File

@ -1,16 +1,14 @@
// //
// utils.h // utils.h
// Copyright 2020 Bruce Hill // Copyright 2021 Bruce Hill
// Released under the MIT license with the Commons Clause // Released under the MIT license with the Commons Clause
// //
// This file contains some definitions of some utility macros. // This file contains some definitions of some utility macros and functions.
// //
#ifndef FILE_UTILS__H #ifndef FILE_UTILS__H
#define FILE_UTILS__H #define FILE_UTILS__H
#include <err.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#ifndef streq #ifndef streq
@ -55,6 +53,24 @@
((node)->name).next = NULL; \ ((node)->name).next = NULL; \
} while (0) } while (0)
#define S1(x) #x
#define S2(x) S1(x)
#define __LOCATION__ __FILE__ ":" S2(__LINE__)
// Error checking helper macros:
#define nonnegative(exp, ...) check_nonnegative(exp, __LOCATION__ ": `" #exp "` " __VA_ARGS__)
#define nonnull(exp, ...) check_nonnull(exp, __LOCATION__ ": `" #exp "` " __VA_ARGS__)
// Error-checking memory allocation helper macros:
#define new(t) check_nonnull(calloc(1, sizeof(t)), __LOCATION__ ": new(" #t ") failed")
#define new_bytes(n) check_nonnull(calloc(1, n), __LOCATION__ ": new_bytes(" #n ") failed")
#define grow(obj, new_count) check_nonnull(reallocarray(obj, (new_count), sizeof(obj[0])), __LOCATION__ ": grow(" #obj ", " #new_count ") failed")
#define check_strdup(s) check_nonnull(strdup(s), __LOCATION__ ": check_strdup(" #s ") failed")
int check_nonnegative(int negative_err, const char *err_msg, ...);
__attribute__((returns_nonnull))
void *check_nonnull(void *p, const char *err_msg, ...);
__attribute__((nonnull))
void delete(void *p);
#endif #endif
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1