nnn/noice.c

690 lines
12 KiB
C
Raw Normal View History

#include <sys/stat.h>
2014-10-07 06:05:30 +00:00
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <dirent.h>
#include <curses.h>
#include <libgen.h>
#include <limits.h>
2014-10-07 06:05:30 +00:00
#include <locale.h>
2014-10-09 09:33:49 +00:00
#include <regex.h>
2014-10-07 06:05:30 +00:00
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include "queue.h"
#include "util.h"
2014-10-07 06:05:30 +00:00
#ifdef DEBUG
2014-10-08 08:36:17 +00:00
#define DEBUG_FD 8
#define DPRINTF_D(x) dprintf(DEBUG_FD, #x "=%d\n", x)
#define DPRINTF_U(x) dprintf(DEBUG_FD, #x "=%u\n", x)
#define DPRINTF_S(x) dprintf(DEBUG_FD, #x "=%s\n", x)
#define DPRINTF_P(x) dprintf(DEBUG_FD, #x "=0x%p\n", x)
2014-10-07 06:05:30 +00:00
#else
#define DPRINTF_D(x)
2014-10-08 08:36:17 +00:00
#define DPRINTF_U(x)
2014-10-07 06:05:30 +00:00
#define DPRINTF_S(x)
#define DPRINTF_P(x)
#endif /* DEBUG */
#define LEN(x) (sizeof(x) / sizeof(*(x)))
2014-10-07 06:49:46 +00:00
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#define ISODD(x) ((x) & 1)
#define CONTROL(c) ((c) ^ 0x40)
2014-10-07 06:05:30 +00:00
2014-10-07 15:36:29 +00:00
struct assoc {
2014-10-09 09:33:49 +00:00
char *regex; /* Regex to match on filename */
char *bin; /* Program */
2014-10-07 15:36:29 +00:00
};
2014-10-21 10:15:27 +00:00
#include "config.h"
2014-10-07 15:36:29 +00:00
struct entry {
char *name;
mode_t mode;
};
struct history {
int pos;
SLIST_ENTRY(history) entry;
};
SLIST_HEAD(histhead, history) histhead = SLIST_HEAD_INITIALIZER(histhead);
2014-10-07 06:05:30 +00:00
/*
* Layout:
* .---------
* | cwd: /mnt/path
* |
2014-10-07 14:55:14 +00:00
* | file0
2014-10-07 06:05:30 +00:00
* | file1
2014-10-07 14:55:14 +00:00
* | > file2
* | file3
* | file4
2014-10-07 06:05:30 +00:00
* ...
* | filen
* |
2014-10-07 14:55:14 +00:00
* | Permission denied
2014-10-07 06:05:30 +00:00
* '------
*/
void printmsg(char *msg);
void printwarn(void);
void printerr(int ret, char *prefix);
void
spawn(const char *file, const char *arg)
{
pid_t pid;
int status;
pid = fork();
if (pid == 0) {
execlp(file, file, arg, NULL);
_exit(1);
} else {
/* Ignore interruptions */
while (waitpid(pid, &status, 0) == -1)
DPRINTF_D(status);
DPRINTF_D(pid);
}
}
2014-10-07 06:05:30 +00:00
char *
openwith(char *file)
2014-10-07 06:05:30 +00:00
{
2014-10-09 09:33:49 +00:00
regex_t regex;
char *bin = NULL;
2014-10-07 06:05:30 +00:00
int i;
2014-10-09 09:33:49 +00:00
for (i = 0; i < LEN(assocs); i++) {
if (regcomp(&regex, assocs[i].regex,
REG_NOSUB | REG_EXTENDED) != 0)
continue;
if (regexec(&regex, file, 0, NULL, 0) != REG_NOMATCH) {
bin = assocs[i].bin;
2014-10-09 09:33:49 +00:00
break;
}
}
DPRINTF_S(bin);
return bin;
2014-10-07 06:05:30 +00:00
}
int
setfilter(regex_t *regex, char *filter)
{
char *errbuf;
int r;
r = regcomp(regex, filter, REG_NOSUB | REG_EXTENDED);
if (r != 0) {
errbuf = malloc(COLS * sizeof(char));
regerror(r, regex, errbuf, COLS * sizeof(char));
printmsg(errbuf);
free(errbuf);
}
return r;
}
int
visible(regex_t *regex, char *file)
{
if (regexec(regex, file, 0, NULL, 0) != REG_NOMATCH)
return 1;
return 0;
}
2014-10-07 06:05:30 +00:00
int
entrycmp(const void *va, const void *vb)
2014-10-07 06:05:30 +00:00
{
const struct entry *a, *b;
2014-10-07 06:05:30 +00:00
a = (struct entry *)va;
b = (struct entry *)vb;
2014-10-07 06:05:30 +00:00
return strcmp(a->name, b->name);
2014-10-07 06:05:30 +00:00
}
2014-10-07 11:37:23 +00:00
void
initcurses(void)
{
initscr();
cbreak();
noecho();
nonl();
intrflush(stdscr, FALSE);
keypad(stdscr, TRUE);
curs_set(FALSE); /* Hide cursor */
}
void
exitcurses(void)
{
endwin(); /* Restore terminal */
}
2014-10-07 14:47:35 +00:00
/* Messages show up at the bottom */
2014-10-07 06:05:30 +00:00
void
2014-10-07 14:47:35 +00:00
printmsg(char *msg)
2014-10-07 06:05:30 +00:00
{
move(LINES - 1, 0);
2014-10-07 14:47:35 +00:00
printw("%s\n", msg);
}
/* Display warning as a message */
void
printwarn(void)
{
printmsg(strerror(errno));
2014-10-07 06:05:30 +00:00
}
/* Kill curses and display error before exiting */
void
printerr(int ret, char *prefix)
{
2014-10-07 17:59:41 +00:00
exitcurses();
2014-10-07 06:05:30 +00:00
printf("%s: %s\n", prefix, strerror(errno));
exit(ret);
}
/*
* Returns 0 normally
* On movement it updates *cur
2014-10-21 15:34:31 +00:00
* Returns SEL_{QUIT,BACK,GOIN,FLTR,SH,CD} otherwise
2014-10-07 06:05:30 +00:00
*/
enum {
SEL_QUIT = 1,
SEL_BACK,
SEL_GOIN,
SEL_FLTR,
SEL_SH,
SEL_CD,
};
2014-10-07 06:05:30 +00:00
int
nextsel(int *cur, int max)
{
int c;
c = getch();
switch (c) {
case 'q':
return SEL_QUIT;
2014-10-10 11:59:30 +00:00
/* Back */
2014-10-07 06:05:30 +00:00
case KEY_BACKSPACE:
case KEY_LEFT:
case 'h':
return SEL_BACK;
2014-10-10 11:59:30 +00:00
/* Inside */
2014-10-07 06:05:30 +00:00
case KEY_ENTER:
case '\r':
case KEY_RIGHT:
case 'l':
return SEL_GOIN;
2014-10-10 11:59:30 +00:00
/* Filter */
case '/':
case '&':
return SEL_FLTR;
2014-10-10 11:59:30 +00:00
/* Next */
2014-10-07 06:05:30 +00:00
case 'j':
case KEY_DOWN:
case CONTROL('N'):
2014-10-07 06:05:30 +00:00
if (*cur < max - 1)
(*cur)++;
break;
2014-10-10 11:59:30 +00:00
/* Previous */
2014-10-07 06:05:30 +00:00
case 'k':
case KEY_UP:
case CONTROL('P'):
2014-10-07 06:05:30 +00:00
if (*cur > 0)
(*cur)--;
break;
2014-10-10 12:46:13 +00:00
/* Page down */
case KEY_NPAGE:
case CONTROL('D'):
if (*cur < max -1)
(*cur) += MIN((LINES - 4) / 2, max - 1 - *cur);
break;
/* Page up */
case KEY_PPAGE:
case CONTROL('U'):
if (*cur > 0)
(*cur) -= MIN((LINES - 4) / 2, *cur);
break;
case '!':
return SEL_SH;
case 'c':
return SEL_CD;
2014-10-07 06:05:30 +00:00
}
return 0;
}
char *
readln(void)
{
int c;
int i = 0;
char *ln = NULL;
int y, x, x0;
echo();
curs_set(TRUE);
/* Starting point */
getyx(stdscr, y, x);
x0 = x;
while (c = getch()) {
if (c == KEY_ENTER || c == '\r')
break;
if (c == KEY_BACKSPACE) {
getyx(stdscr, y, x);
if (x >= x0) {
if (i > 0) {
ln = realloc(ln, (i - 1) * sizeof(*ln));
i--;
} else {
free(ln);
ln = NULL;
}
move(y, x);
printw("%c", ' ');
move(y, x);
} else {
move(y, x0);
}
continue;
}
ln = realloc(ln, (i + 1) * sizeof(*ln));
ln[i] = c;
i++;
}
if (ln != NULL) {
ln = realloc(ln, (i + 1) * sizeof(*ln));
ln[i] = '\0';
}
curs_set(FALSE);
noecho();
return ln;
}
2014-10-07 06:05:30 +00:00
int
testopendir(char *path)
{
DIR *dirp;
dirp = opendir(path);
if (dirp == NULL) {
return 0;
} else {
closedir(dirp);
return 1;
}
}
void
printent(struct entry *ent, int active)
{
char *name;
unsigned int maxlen = COLS - strlen(CURSR) - 1;
char cm = 0;
/* Copy name locally */
name = strdup(ent->name);
if (name == NULL)
printerr(1, "strdup name");
if (S_ISDIR(ent->mode)) {
cm = '/';
maxlen--;
} else if (S_ISLNK(ent->mode)) {
cm = '@';
maxlen--;
2014-10-21 14:36:23 +00:00
} else if (ent->mode & S_IXUSR) {
cm = '*';
maxlen--;
}
/* No text wrapping in entries */
if (strlen(name) > maxlen)
name[maxlen] = '\0';
if (cm == 0)
printw("%s%s\n", active ? CURSR : EMPTY, name);
else
printw("%s%s%c\n", active ? CURSR : EMPTY, name, cm);
free(name);
}
2014-10-07 06:05:30 +00:00
void
browse(const char *ipath, const char *ifilter)
2014-10-07 06:05:30 +00:00
{
DIR *dirp;
int dfd;
2014-10-07 06:05:30 +00:00
struct dirent *dp;
struct entry *dents;
2014-10-07 06:05:30 +00:00
int i, n, cur;
int r, ret;
char *path = realpath(ipath, NULL);
char *filter = strdup(ifilter);
regex_t filter_re;
char *cwd;
struct stat sb;
2014-10-07 06:05:30 +00:00
cur = 0;
2014-10-07 06:05:30 +00:00
begin:
2014-10-10 07:11:50 +00:00
/* Path and filter should be malloc(3)-ed strings at all times */
2014-10-07 06:05:30 +00:00
n = 0;
dents = NULL;
2014-10-08 15:39:07 +00:00
dirp = opendir(path);
2014-10-07 06:05:30 +00:00
if (dirp == NULL) {
2014-10-07 14:47:35 +00:00
printwarn();
2014-10-07 06:05:30 +00:00
goto nochange;
} else {
if (chdir(path) == -1)
printwarn();
2014-10-07 06:05:30 +00:00
}
/* Search filter */
r = setfilter(&filter_re, filter);
if (r != 0)
goto nochange;
2014-10-07 06:05:30 +00:00
while ((dp = readdir(dirp)) != NULL) {
char *name;
2014-10-07 06:05:30 +00:00
/* Skip self and parent */
if (strcmp(dp->d_name, ".") == 0
|| strcmp(dp->d_name, "..") == 0)
2014-10-07 06:05:30 +00:00
continue;
if (!visible(&filter_re, dp->d_name))
continue;
2014-10-08 19:55:44 +00:00
/* Deep copy because readdir(3) reuses the entries */
2014-10-07 06:05:30 +00:00
dents = realloc(dents, (n + 1) * sizeof(*dents));
if (dents == NULL)
printerr(1, "realloc");
dents[n].name = strdup(dp->d_name);
if (dents[n].name == NULL)
printerr(1, "strdup");
2014-10-10 10:14:55 +00:00
/* Handle root case */
if (strcmp(path, "/") == 0)
asprintf(&name, "/%s", dents[n].name);
else
asprintf(&name, "%s/%s", path, dents[n].name);
/* Get mode flags */
r = lstat(name, &sb);
free(name);
if (r == -1)
printerr(1, "stat");
dents[n].mode = sb.st_mode;
2014-10-07 06:05:30 +00:00
n++;
}
/* Make sure cur is in range */
cur = MIN(cur, n - 1);
qsort(dents, n, sizeof(*dents), entrycmp);
2014-10-07 06:05:30 +00:00
for (;;) {
2014-10-07 11:23:44 +00:00
int nlines;
int maxlen;
int odd;
char *pathnew;
char *name;
char *bin;
int fd;
char *dir;
char *tmp;
regex_t re;
struct history *hist;
2014-10-07 11:23:44 +00:00
2014-10-07 06:05:30 +00:00
redraw:
2014-10-07 11:23:44 +00:00
nlines = MIN(LINES - 4, n);
2014-10-07 06:05:30 +00:00
/* Clean screen */
erase();
/* Strip trailing slashes */
2014-10-10 10:14:55 +00:00
for (i = strlen(path) - 1; i > 0; i--)
2014-10-07 06:05:30 +00:00
if (path[i] == '/')
path[i] = '\0';
else
break;
DPRINTF_D(cur);
DPRINTF_S(path);
/* No text wrapping in cwd line */
cwd = malloc(COLS * sizeof(char));
2014-10-08 12:08:29 +00:00
strlcpy(cwd, path, COLS * sizeof(char));
cwd[COLS - strlen(CWD) - 1] = '\0';
2014-10-10 10:14:55 +00:00
printw(CWD "%s\n\n", cwd);
2014-10-07 06:05:30 +00:00
/* Print listing */
odd = ISODD(nlines);
2014-10-07 06:49:46 +00:00
if (cur < nlines / 2) {
for (i = 0; i < nlines; i++)
printent(&dents[i], i == cur);
2014-10-07 06:49:46 +00:00
} else if (cur >= n - nlines / 2) {
for (i = n - nlines; i < n; i++)
printent(&dents[i], i == cur);
2014-10-07 06:49:46 +00:00
} else {
for (i = cur - nlines / 2;
i < cur + nlines / 2 + odd; i++)
printent(&dents[i], i == cur);
2014-10-07 06:49:46 +00:00
}
2014-10-07 06:05:30 +00:00
nochange:
ret = nextsel(&cur, n);
switch (ret) {
case SEL_QUIT:
2014-10-07 06:05:30 +00:00
free(path);
2014-10-10 07:11:50 +00:00
free(filter);
/* Forget history */
while (!SLIST_EMPTY(&histhead)) {
hist = SLIST_FIRST(&histhead);
SLIST_REMOVE_HEAD(&histhead, entry);
free(hist);
}
2014-10-07 06:05:30 +00:00
return;
case SEL_BACK:
2014-10-10 10:14:55 +00:00
/* There is no going back */
if (strcmp(path, "/") == 0) {
2014-10-07 06:05:30 +00:00
goto nochange;
} else {
2014-10-07 06:49:46 +00:00
dir = dirname(path);
tmp = malloc(strlen(dir) + 1);
2014-10-08 12:08:29 +00:00
strlcpy(tmp, dir, strlen(dir) + 1);
2014-10-07 06:49:46 +00:00
free(path);
path = tmp;
free(filter);
filter = strdup(ifilter); /* Reset filter */
/* Recall history */
hist = SLIST_FIRST(&histhead);
if (hist != NULL) {
cur = hist->pos;
DPRINTF_D(hist->pos);
SLIST_REMOVE_HEAD(&histhead, entry);
free(hist);
} else {
cur = 0;
}
2014-10-07 06:05:30 +00:00
goto out;
}
case SEL_GOIN:
2014-10-07 14:07:56 +00:00
/* Cannot descend in empty directories */
if (n == 0)
goto nochange;
name = dents[cur].name;
/* Handle root case */
if (strcmp(path, "/") == 0)
asprintf(&pathnew, "/%s", name);
else
asprintf(&pathnew, "%s/%s", path, name);
2014-10-08 08:36:17 +00:00
DPRINTF_S(name);
DPRINTF_S(pathnew);
/* Get path info */
fd = open(pathnew, O_RDONLY | O_NONBLOCK);
if (fd == -1) {
printwarn();
free(pathnew);
goto nochange;
}
r = fstat(fd, &sb);
close(fd);
if (r == -1) {
printwarn();
free(pathnew);
goto nochange;
}
DPRINTF_U(sb.st_mode);
/* Directory */
if (S_ISDIR(sb.st_mode)) {
free(path);
path = pathnew;
free(filter);
filter = strdup(ifilter); /* Reset filter */
/* Save history */
hist = malloc(sizeof(struct history));
hist->pos = cur;
SLIST_INSERT_HEAD(&histhead, hist, entry);
cur = 0;
goto out;
}
2014-10-08 15:39:07 +00:00
/* Regular file */
if (S_ISREG(sb.st_mode)) {
2014-10-07 06:05:30 +00:00
/* Open with */
bin = openwith(name);
2014-10-07 06:05:30 +00:00
if (bin == NULL) {
2014-10-07 14:47:35 +00:00
printmsg("No association");
2014-10-08 12:27:46 +00:00
free(pathnew);
2014-10-07 06:05:30 +00:00
goto nochange;
}
2014-10-07 11:37:23 +00:00
exitcurses();
spawn(bin, pathnew);
2014-10-07 11:37:23 +00:00
initcurses();
free(pathnew);
2014-10-07 06:05:30 +00:00
goto redraw;
}
/* All the rest */
printmsg("Unsupported file");
free(pathnew);
goto nochange;
case SEL_FLTR:
/* Read filter */
printmsg("");
move(LINES - 1, 0);
printw("filter: ");
tmp = readln();
if (tmp == NULL) {
printmsg("");
goto nochange;
}
r = setfilter(&re, tmp);
if (r != 0) {
2014-10-10 12:02:26 +00:00
free(tmp);
goto nochange;
}
free(filter);
filter = tmp;
filter_re = re;
DPRINTF_S(filter);
cur = 0;
goto out;
case SEL_SH:
exitcurses();
spawn("/bin/sh", NULL);
initcurses();
2014-10-21 13:57:09 +00:00
break;
case SEL_CD:
/* Read target dir */
printmsg("");
move(LINES - 1, 0);
printw("chdir: ");
tmp = readln();
if (tmp == NULL) {
printmsg("");
goto nochange;
}
if (testopendir(tmp) == 0) {
printwarn();
goto nochange;
} else {
free(path);
path = realpath(tmp, NULL);
free(tmp);
free(filter);
filter = strdup(ifilter); /* Reset filter */
DPRINTF_S(path);
cur = 0;
goto out;
}
}
2014-10-07 06:05:30 +00:00
}
out:
for (i = 0; i < n; i++)
free(dents[i].name);
2014-10-07 06:05:30 +00:00
free(dents);
2014-10-10 10:24:19 +00:00
/* Should never be null */
r = closedir(dirp);
if (r == -1)
printerr(1, "closedir");
2014-10-07 06:05:30 +00:00
goto begin;
}
int
main(int argc, char *argv[])
{
char cwd[PATH_MAX], *ipath;
2014-10-21 11:03:53 +00:00
char *ifilter;
if (getuid() == 0)
ifilter = ".*";
else
ifilter = "^[^.].*"; /* Hide dotfiles */
2014-10-07 06:05:30 +00:00
if (argv[1] != NULL) {
ipath = argv[1];
} else {
ipath = getcwd(cwd, sizeof(cwd));
if (ipath == NULL)
ipath = "/";
}
2014-10-07 06:05:30 +00:00
/* Test initial path */
if (!testopendir(ipath))
printerr(1, ipath);
/* Set locale before curses setup */
setlocale(LC_ALL, "");
2014-10-07 11:37:23 +00:00
initcurses();
2014-10-07 06:05:30 +00:00
browse(ipath, ifilter);
2014-10-07 06:05:30 +00:00
2014-10-07 11:37:23 +00:00
exitcurses();
2014-10-07 06:05:30 +00:00
return 0;
}