nnn/noice.c

921 lines
15 KiB
C
Raw Normal View History

2015-11-20 14:36:40 +00:00
/* See LICENSE file for copyright and license details. */
#include <sys/stat.h>
2014-10-07 06:05:30 +00:00
#include <sys/types.h>
2014-10-22 15:27:08 +00:00
#include <sys/wait.h>
2014-10-07 06:05:30 +00:00
2015-06-09 08:12:17 +00:00
#include <curses.h>
#include <dirent.h>
2014-10-07 06:05:30 +00:00
#include <errno.h>
#include <fcntl.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>
2015-06-09 08:12:17 +00:00
#include <signal.h>
#include <stdarg.h>
2014-10-07 06:05:30 +00:00
#include <stdio.h>
2015-06-09 08:12:17 +00:00
#include <stdlib.h>
2014-10-07 06:05:30 +00:00
#include <string.h>
#include <unistd.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-22 16:41:16 +00:00
#undef MIN
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
};
/* Supported actions */
enum action {
SEL_QUIT = 1,
SEL_BACK,
SEL_GOIN,
SEL_FLTR,
2015-01-27 08:47:57 +00:00
SEL_TYPE,
SEL_NEXT,
SEL_PREV,
SEL_PGDN,
SEL_PGUP,
SEL_HOME,
SEL_END,
SEL_CD,
SEL_MTIME,
SEL_REDRAW,
SEL_RUN,
SEL_RUNARG,
};
struct key {
int sym; /* Key pressed */
enum action act; /* Action */
char *run; /* Program to run */
char *env; /* Environment variable to run */
};
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;
time_t t;
};
/* Global context */
struct entry *dents;
int n, cur;
char *path, *oldpath;
char *fltr;
int idle;
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);
char *makepath(char *dir, char *name);
#undef dprintf
int
dprintf(int fd, const char *fmt, ...)
{
char buf[BUFSIZ];
int r;
va_list ap;
va_start(ap, fmt);
r = vsnprintf(buf, sizeof(buf), fmt, ap);
if (r > 0)
write(fd, buf, r);
va_end(ap);
return r;
}
2014-10-22 13:10:04 +00:00
void *
xmalloc(size_t size)
{
void *p;
p = malloc(size);
2014-10-22 13:15:27 +00:00
if (p == NULL)
2014-10-22 13:10:04 +00:00
printerr(1, "malloc");
return p;
}
void *
2014-10-22 13:15:27 +00:00
xrealloc(void *p, size_t size)
2014-10-22 13:10:04 +00:00
{
2014-10-22 13:15:27 +00:00
p = realloc(p, size);
if (p == NULL)
2014-10-22 13:10:04 +00:00
printerr(1, "realloc");
2014-10-22 13:15:27 +00:00
return p;
}
char *
xstrdup(const char *s)
{
char *p;
p = strdup(s);
if (p == NULL)
printerr(1, "strdup");
return p;
}
char *
xdirname(const char *path)
{
char *p, *tmp;
/* Some implementations of dirname(3) may modify `path' and some
2014-10-31 23:56:26 +00:00
* return a pointer inside `path' and we cannot free(3) the
* original string if we lose track of it. */
tmp = xstrdup(path);
p = dirname(tmp);
2014-10-22 14:21:53 +00:00
if (p == NULL) {
free(tmp);
printerr(1, "dirname");
2014-10-22 14:21:53 +00:00
}
/* Make sure this is a malloc(3)-ed string */
p = xstrdup(p);
2014-10-22 14:05:14 +00:00
free(tmp);
return p;
}
void
spawn(const char *file, const char *arg, const char *dir)
{
pid_t pid;
int status;
pid = fork();
if (pid == 0) {
if (dir != NULL)
chdir(dir);
execlp(file, file, arg, NULL);
_exit(1);
} else {
/* Ignore interruptions */
while (waitpid(pid, &status, 0) == -1)
DPRINTF_D(status);
DPRINTF_D(pid);
}
}
char *
xgetenv(char *name, char *fallback)
{
2015-11-26 13:42:41 +00:00
char *value;
if (name == NULL)
return fallback;
2015-11-26 13:42:41 +00:00
value = getenv(name);
return value ? value : fallback;
}
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 | REG_ICASE) != 0)
2014-10-09 09:33:49 +00:00
continue;
if (regexec(&regex, file, 0, NULL, 0) == 0) {
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 | REG_ICASE);
if (r != 0) {
2014-10-22 13:10:04 +00:00
errbuf = xmalloc(COLS * sizeof(char));
regerror(r, regex, errbuf, COLS * sizeof(char));
printmsg(errbuf);
free(errbuf);
}
return r;
}
int
visible(regex_t *regex, char *file)
{
2014-12-20 19:21:03 +00:00
return regexec(regex, file, 0, NULL, 0) == 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
if (mtimeorder)
return b->t - a->t;
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 */
timeout(1000); /* One second */
2014-10-07 11:37:23 +00:00
}
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-22 13:08:16 +00:00
fprintf(stderr, "%s: %s\n", prefix, strerror(errno));
2014-10-07 06:05:30 +00:00
exit(ret);
}
/* Clear the last line */
void
clearprompt(void)
{
printmsg("");
}
/* Print prompt on the last line */
void
printprompt(char *str)
{
clearprompt();
printw(str);
}
/* Returns SEL_* if key is bound and 0 otherwise
Also modifies the run and env pointers (used on SEL_{RUN,RUNARG}) */
2014-10-07 06:05:30 +00:00
int
nextsel(char **run, char **env)
2014-10-07 06:05:30 +00:00
{
int c, i;
2014-10-07 06:05:30 +00:00
c = getch();
if (c == -1)
idle++;
else
idle = 0;
2014-12-20 19:14:10 +00:00
for (i = 0; i < LEN(bindings); i++)
if (c == bindings[i].sym) {
*run = bindings[i].run;
*env = bindings[i].env;
return bindings[i].act;
}
2014-10-07 06:05:30 +00:00
return 0;
}
char *
readln(void)
{
char ln[LINE_MAX];
timeout(-1);
echo();
curs_set(TRUE);
2015-11-20 11:55:41 +00:00
memset(ln, 0, sizeof(ln));
wgetnstr(stdscr, ln, sizeof(ln) - 1);
noecho();
curs_set(FALSE);
timeout(1000);
2015-11-20 17:41:11 +00:00
return ln[0] ? strdup(ln) : NULL;
}
2015-01-27 08:47:57 +00:00
/*
* Read one key and modify the provided string accordingly.
* Returns 0 when more input is expected and 1 on completion.
*/
int
readmore(char **str)
{
int c, ret = 0;
2015-02-17 17:03:51 +00:00
int i;
2015-01-27 08:47:57 +00:00
char *ln = *str;
timeout(-1);
2015-01-27 08:47:57 +00:00
if (ln != NULL)
i = strlen(ln);
else
i = 0;
DPRINTF_D(i);
curs_set(TRUE);
c = getch();
switch (c) {
case KEY_ENTER:
case '\r':
2015-01-27 08:47:57 +00:00
ret = 1;
break;
case KEY_BACKSPACE:
case CONTROL('H'):
2015-01-27 08:47:57 +00:00
i--;
if (i > 0) {
ln = xrealloc(ln, (i + 1) * sizeof(*ln));
ln[i] = '\0';
} else {
free(ln);
ln = NULL;
}
break;
default:
i++;
ln = xrealloc(ln, (i + 1) * sizeof(*ln));
ln[i - 1] = c;
ln[i] = '\0';
2015-01-27 08:47:57 +00:00
}
2015-01-27 08:47:57 +00:00
curs_set(FALSE);
*str = ln;
timeout(1000);
2015-01-27 08:47:57 +00:00
return ret;
}
2014-10-07 06:05:30 +00:00
int
2014-10-22 16:26:35 +00:00
canopendir(char *path)
2014-10-07 06:05:30 +00:00
{
DIR *dirp;
dirp = opendir(path);
2014-12-20 19:35:27 +00:00
if (dirp == NULL)
2014-10-07 06:05:30 +00:00
return 0;
2014-12-20 19:35:27 +00:00
closedir(dirp);
return 1;
2014-10-07 06:05:30 +00:00
}
void
printent(struct entry *ent, int active)
{
char *name;
unsigned int maxlen = COLS - strlen(CURSR) - 1;
char cm = 0;
/* Copy name locally */
2014-10-22 13:15:27 +00:00
name = xstrdup(ent->name);
if (S_ISDIR(ent->mode)) {
cm = '/';
maxlen--;
} else if (S_ISLNK(ent->mode)) {
cm = '@';
maxlen--;
} else if (S_ISSOCK(ent->mode)) {
cm = '=';
maxlen--;
} else if (S_ISFIFO(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-22 15:21:50 +00:00
int
dentfill(char *path, struct entry **dents,
2014-10-22 15:21:50 +00:00
int (*filter)(regex_t *, char *), regex_t *re)
{
DIR *dirp;
2014-10-22 15:21:50 +00:00
struct dirent *dp;
struct stat sb;
char *newpath;
2014-12-17 11:48:34 +00:00
int r, n = 0;
dirp = opendir(path);
if (dirp == NULL)
return 0;
2014-10-22 15:21:50 +00:00
while ((dp = readdir(dirp)) != NULL) {
/* Skip self and parent */
if (strcmp(dp->d_name, ".") == 0
|| strcmp(dp->d_name, "..") == 0)
continue;
if (filter(re, dp->d_name) == 0)
continue;
*dents = xrealloc(*dents, (n + 1) * sizeof(**dents));
(*dents)[n].name = xstrdup(dp->d_name);
/* Get mode flags */
newpath = makepath(path, dp->d_name);
r = lstat(newpath, &sb);
2014-10-22 15:21:50 +00:00
if (r == -1)
printerr(1, "lstat");
2014-10-22 15:21:50 +00:00
(*dents)[n].mode = sb.st_mode;
(*dents)[n].t = sb.st_mtime;
2014-10-22 15:21:50 +00:00
n++;
}
/* Should never be null */
r = closedir(dirp);
if (r == -1)
printerr(1, "closedir");
2014-10-22 15:21:50 +00:00
return n;
}
void
dentfree(struct entry *dents, int n)
{
int i;
for (i = 0; i < n; i++)
free(dents[i].name);
free(dents);
}
char *
makepath(char *dir, char *name)
{
2014-11-14 12:50:41 +00:00
char path[PATH_MAX];
/* Handle absolute path */
if (name[0] == '/') {
2014-11-14 12:50:41 +00:00
strlcpy(path, name, sizeof(path));
} else {
/* Handle root case */
if (strcmp(dir, "/") == 0) {
2014-11-14 12:50:41 +00:00
strlcpy(path, "/", sizeof(path));
strlcat(path, name, sizeof(path));
} else {
2014-11-14 12:50:41 +00:00
strlcpy(path, dir, sizeof(path));
strlcat(path, "/", sizeof(path));
strlcat(path, name, sizeof(path));
}
}
2014-11-14 12:50:41 +00:00
return xstrdup(path);
}
/* Return the position of the matching entry or 0 otherwise */
int
dentfind(struct entry *dents, int n, char *cwd, char *path)
{
int i;
char *tmp;
if (path == NULL)
return 0;
for (i = 0; i < n; i++) {
tmp = makepath(cwd, dents[i].name);
DPRINTF_S(path);
DPRINTF_S(tmp);
if (strcmp(tmp, path) == 0) {
free(tmp);
return i;
}
free(tmp);
}
return 0;
}
int
populate(void)
2014-10-07 06:05:30 +00:00
{
regex_t re;
int r;
2014-10-22 15:33:59 +00:00
/* Can fail when permissions change while browsing */
if (canopendir(path) == 0)
return -1;
2014-10-07 06:05:30 +00:00
/* Search filter */
r = setfilter(&re, fltr);
if (r != 0)
return -1;
dentfree(dents, n);
n = 0;
dents = NULL;
n = dentfill(path, &dents, visible, &re);
2014-10-07 06:05:30 +00:00
qsort(dents, n, sizeof(*dents), entrycmp);
2014-10-07 06:05:30 +00:00
/* Find cur from history */
cur = dentfind(dents, n, path, oldpath);
2014-12-17 11:54:57 +00:00
free(oldpath);
oldpath = NULL;
return 0;
}
2014-10-07 11:23:44 +00:00
void
redraw(void)
{
int nlines, odd;
char *cwd;
int i;
2014-10-07 06:05:30 +00:00
nlines = MIN(LINES - 4, n);
/* Clean screen */
erase();
2014-10-07 06:05:30 +00:00
/* Strip trailing slashes */
for (i = strlen(path) - 1; i > 0; i--)
if (path[i] == '/')
path[i] = '\0';
else
break;
DPRINTF_D(cur);
DPRINTF_S(path);
/* No text wrapping in cwd line */
cwd = xmalloc(COLS * sizeof(char));
strlcpy(cwd, path, COLS * sizeof(char));
cwd[COLS - strlen(CWD) - 1] = '\0';
printw(CWD "%s\n\n", cwd);
/* Print listing */
odd = ISODD(nlines);
if (cur < nlines / 2) {
for (i = 0; i < nlines; i++)
printent(&dents[i], i == cur);
} else if (cur >= n - nlines / 2) {
for (i = n - nlines; i < n; i++)
printent(&dents[i], i == cur);
} else {
for (i = cur - nlines / 2;
i < cur + nlines / 2 + odd; i++)
printent(&dents[i], i == cur);
}
}
void
browse(const char *ipath, const char *ifilter)
{
int r, fd;
regex_t re;
char *newpath;
struct stat sb;
char *name, *bin, *dir, *tmp, *run, *env;
int nowtyping = 0;
oldpath = NULL;
path = xstrdup(ipath);
fltr = xstrdup(ifilter);
begin:
/* Path and filter should be malloc(3)-ed strings at all times */
r = populate();
if (r == -1) {
if (!nowtyping) {
printwarn();
goto nochange;
}
}
for (;;) {
redraw();
2014-10-07 06:05:30 +00:00
2015-01-27 08:47:57 +00:00
/* Handle filter-as-you-type mode */
if (nowtyping)
goto moretyping;
2014-10-07 06:05:30 +00:00
nochange:
switch (nextsel(&run, &env)) {
case SEL_QUIT:
2014-10-07 06:05:30 +00:00
free(path);
free(fltr);
2014-10-22 16:28:27 +00:00
dentfree(dents, n);
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 ||
strcmp(path, ".") == 0 ||
strchr(path, '/') == NULL)
2014-10-07 06:05:30 +00:00
goto nochange;
dir = xdirname(path);
if (canopendir(dir) == 0) {
free(dir);
printwarn();
goto nochange;
}
/* Save history */
oldpath = path;
2014-10-22 15:53:38 +00:00
path = dir;
/* Reset filter */
free(fltr);
fltr = xstrdup(ifilter);
goto begin;
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;
newpath = makepath(path, name);
DPRINTF_S(newpath);
/* Get path info */
fd = open(newpath, O_RDONLY | O_NONBLOCK);
if (fd == -1) {
printwarn();
free(newpath);
goto nochange;
}
r = fstat(fd, &sb);
if (r == -1) {
printwarn();
close(fd);
free(newpath);
goto nochange;
}
close(fd);
DPRINTF_U(sb.st_mode);
2014-10-22 15:55:26 +00:00
2014-10-22 15:50:30 +00:00
switch (sb.st_mode & S_IFMT) {
case S_IFDIR:
if (canopendir(newpath) == 0) {
printwarn();
free(newpath);
goto nochange;
}
free(path);
path = newpath;
/* Reset filter */
free(fltr);
fltr = xstrdup(ifilter);
goto begin;
2014-10-22 15:50:30 +00:00
case S_IFREG:
bin = openwith(newpath);
2014-10-07 06:05:30 +00:00
if (bin == NULL) {
2014-10-07 14:47:35 +00:00
printmsg("No association");
free(newpath);
2014-10-07 06:05:30 +00:00
goto nochange;
}
2014-10-07 11:37:23 +00:00
exitcurses();
spawn(bin, newpath, NULL);
2014-10-07 11:37:23 +00:00
initcurses();
free(newpath);
2014-12-18 09:13:45 +00:00
continue;
2014-10-22 15:50:30 +00:00
default:
printmsg("Unsupported file");
goto nochange;
2014-10-07 06:05:30 +00:00
}
case SEL_FLTR:
/* Read filter */
printprompt("filter: ");
tmp = readln();
if (tmp == NULL)
tmp = xstrdup(ifilter);
2015-01-27 07:58:32 +00:00
/* Check and report regex errors */
r = setfilter(&re, tmp);
if (r != 0) {
2014-10-10 12:02:26 +00:00
free(tmp);
goto nochange;
}
free(fltr);
fltr = tmp;
DPRINTF_S(fltr);
2014-11-26 16:09:03 +00:00
/* Save current */
if (n > 0)
oldpath = makepath(path, dents[cur].name);
goto begin;
2015-01-27 08:47:57 +00:00
case SEL_TYPE:
nowtyping = 1;
tmp = NULL;
moretyping:
printprompt("type: ");
if (tmp != NULL)
printw("%s", tmp);
r = readmore(&tmp);
DPRINTF_D(r);
DPRINTF_S(tmp);
if (r == 1)
nowtyping = 0;
/* Check regex errors */
if (tmp != NULL) {
2015-01-27 08:47:57 +00:00
r = setfilter(&re, tmp);
if (r != 0)
if (nowtyping) {
goto moretyping;
} else {
free(tmp);
goto nochange;
}
}
2015-01-27 08:47:57 +00:00
/* Copy or reset filter */
free(fltr);
2015-01-27 08:47:57 +00:00
if (tmp != NULL)
fltr = xstrdup(tmp);
2015-01-27 08:47:57 +00:00
else
fltr = xstrdup(ifilter);
2015-01-27 08:47:57 +00:00
/* Save current */
if (n > 0)
oldpath = makepath(path, dents[cur].name);
if (!nowtyping)
free(tmp);
goto begin;
case SEL_NEXT:
if (cur < n - 1)
cur++;
break;
case SEL_PREV:
if (cur > 0)
cur--;
break;
case SEL_PGDN:
if (cur < n - 1)
cur += MIN((LINES - 4) / 2, n - 1 - cur);
break;
case SEL_PGUP:
if (cur > 0)
cur -= MIN((LINES - 4) / 2, cur);
break;
case SEL_HOME:
cur = 0;
break;
case SEL_END:
cur = n - 1;
break;
case SEL_CD:
/* Read target dir */
printprompt("chdir: ");
tmp = readln();
if (tmp == NULL) {
clearprompt();
goto nochange;
}
newpath = makepath(path, tmp);
free(tmp);
if (canopendir(newpath) == 0) {
free(newpath);
printwarn();
goto nochange;
}
2014-10-22 15:56:31 +00:00
free(path);
path = newpath;
free(fltr);
fltr = xstrdup(ifilter); /* Reset filter */
2014-10-22 15:56:31 +00:00
DPRINTF_S(path);
goto begin;
case SEL_MTIME:
mtimeorder = !mtimeorder;
/* Save current */
if (n > 0)
oldpath = makepath(path, dents[cur].name);
goto begin;
case SEL_REDRAW:
/* Save current */
if (n > 0)
oldpath = makepath(path, dents[cur].name);
goto begin;
case SEL_RUN:
run = xgetenv(env, run);
exitcurses();
spawn(run, NULL, path);
initcurses();
break;
case SEL_RUNARG:
name = dents[cur].name;
run = xgetenv(env, run);
exitcurses();
spawn(run, name, path);
initcurses();
break;
}
/* Screensaver */
if (idletimeout != 0 && idle == idletimeout) {
idle = 0;
exitcurses();
spawn(idlecmd, NULL, NULL);
initcurses();
}
2014-10-07 06:05:30 +00:00
}
}
int
main(int argc, char *argv[])
{
char cwd[PATH_MAX], *ipath;
2014-10-21 11:03:53 +00:00
char *ifilter;
2015-03-12 12:57:34 +00:00
/* Confirm we are in a terminal */
if (!isatty(STDIN_FILENO))
printerr(1, "isatty");
2014-10-21 11:03:53 +00:00
if (getuid() == 0)
2014-11-25 15:20:06 +00:00
ifilter = ".";
2014-10-21 11:03:53 +00:00
else
2014-11-25 15:20:06 +00:00
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 = "/";
}
signal(SIGINT, SIG_IGN);
2014-10-07 06:05:30 +00:00
/* Test initial path */
2014-10-22 16:26:35 +00:00
if (canopendir(ipath) == 0)
2014-10-07 06:05:30 +00:00
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;
}