mirrors
/
nnn
mirror of https://github.com/jarun/nnn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
nnn/nnn.c

1662 lines
35 KiB
C
Raw Blame History

/* See LICENSE file for copyright and license details. */
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/statvfs.h>
#include <sys/resource.h>
#include <curses.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <locale.h>
#include <regex.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <pwd.h>
#include <grp.h>
#define __USE_XOPEN_EXTENDED
#include <ftw.h>
#ifdef DEBUG
static int
xprintf(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)
r = write(fd, buf, r);
va_end(ap);
return r;
}
#define DEBUG_FD 8
#define DPRINTF_D(x) xprintf(DEBUG_FD, #x "=%d\n", x)
#define DPRINTF_U(x) xprintf(DEBUG_FD, #x "=%u\n", x)
#define DPRINTF_S(x) xprintf(DEBUG_FD, #x "=%s\n", x)
#define DPRINTF_P(x) xprintf(DEBUG_FD, #x "=0x%p\n", x)
#else
#define DPRINTF_D(x)
#define DPRINTF_U(x)
#define DPRINTF_S(x)
#define DPRINTF_P(x)
#endif /* DEBUG */
#define VERSION "v1.0"
#define LEN(x) (sizeof(x) / sizeof(*(x)))
#undef MIN
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#define ISODD(x) ((x) & 1)
#define CONTROL(c) ((c) ^ 0x40)
#define TOUPPER(ch) \
(((ch) >= 'a' && (ch) <= 'z') ? ((ch) - 'a' + 'A') : (ch))
#define MAX_CMD_LEN (PATH_MAX << 1)
#define CURSYM(flag) (flag ? CURSR : EMPTY)
struct assoc {
char *regex; /* Regex to match on filename */
char *bin; /* Program */
};
/* Supported actions */
enum action {
SEL_QUIT = 1,
SEL_BACK,
SEL_GOIN,
SEL_FLTR,
SEL_NEXT,
SEL_PREV,
SEL_PGDN,
SEL_PGUP,
SEL_HOME,
SEL_END,
SEL_CD,
SEL_CDHOME,
SEL_LAST,
SEL_TOGGLEDOT,
SEL_DETAIL,
SEL_STATS,
SEL_DFB,
SEL_FSIZE,
SEL_BSIZE,
SEL_MTIME,
SEL_REDRAW,
SEL_COPY,
SEL_HELP,
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 */
};
#include "config.h"
typedef struct entry {
char name[PATH_MAX];
mode_t mode;
time_t t;
off_t size;
off_t bsize;
} *pEntry;
typedef unsigned long ulong;
/* Global context */
static struct entry *dents;
static int ndents, cur;
static int idle;
static char *opener;
static char *fallback_opener;
static char *copier;
static char *desktop_manager;
static off_t blk_size;
static size_t fs_free;
static int open_max;
static const double div_2_pow_10 = 1.0 / 1024.0;
static const char* size_units[] = {"B", "K", "M", "G", "T", "P", "E", "Z", "Y"};
/*
* Layout:
* .---------
* | cwd: /mnt/path
* |
* | file0
* | file1
* | > file2
* | file3
* | file4
* ...
* | filen
* |
* | Permission denied
* '------
*/
static void printmsg(char *);
static void printwarn(void);
static void printerr(int, char *);
static rlim_t
max_openfds()
{
struct rlimit rl;
rlim_t limit;
limit = getrlimit(RLIMIT_NOFILE, &rl);
if (limit != 0)
return 32;
limit = rl.rlim_cur;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &rl) == 0)
return rl.rlim_max - 64;
if (limit > 128)
return limit - 64;
return 32;
}
static size_t
xstrlcpy(char *dest, const char *src, size_t n)
{
size_t i;
for (i = 0; i < n && *src; i++)
*dest++ = *src++;
if (n) {
*dest = '\0';
#ifdef CHECK_XSTRLCPY_RET
/* Compiling this out as we are not checking
the return value anywhere (controlled case).
Just returning the number of bytes copied. */
while(*src++)
i++;
#endif
}
return i;
}
/*
* The poor man's implementation of memrchr(3).
* We are only looking for '/' in this program.
*/
static void *
xmemrchr(const void *s, int c, size_t n)
{
unsigned char *p;
unsigned char ch = (unsigned char)c;
if (!s || !n)
return NULL;
p = (unsigned char *)s + n - 1;
while(n--)
if ((*p--) == ch)
return ++p;
return NULL;
}
#if 0
/* Some implementations of dirname(3) may modify `path' and some
* return a pointer inside `path'. */
static char *
xdirname(const char *path)
{
static char out[PATH_MAX];
char tmp[PATH_MAX], *p;
xstrlcpy(tmp, path, sizeof(tmp));
p = dirname(tmp);
if (p == NULL)
printerr(1, "dirname");
xstrlcpy(out, p, sizeof(out));
return out;
}
#endif
/*
* The following dirname(3) implementation does not
* change the input. We use a copy of the original.
*
* Modified from the glibc (GNU LGPL) version.
*/
static char *
xdirname(const char *path)
{
static char name[PATH_MAX];
char *last_slash;
xstrlcpy(name, path, PATH_MAX);
/* Find last '/'. */
last_slash = strrchr(name, '/');
if (last_slash != NULL && last_slash != name && last_slash[1] == '\0') {
/* Determine whether all remaining characters are slashes. */
char *runp;
for (runp = last_slash; runp != name; --runp)
if (runp[-1] != '/')
break;
/* The '/' is the last character, we have to look further. */
if (runp != name)
last_slash = xmemrchr(name, '/', runp - name);
}
if (last_slash != NULL) {
/* Determine whether all remaining characters are slashes. */
char *runp;
for (runp = last_slash; runp != name; --runp)
if (runp[-1] != '/')
break;
/* Terminate the name. */
if (runp == name) {
/* The last slash is the first character in the string.
We have to return "/". As a special case we have to
return "//" if there are exactly two slashes at the
beginning of the string. See XBD 4.10 Path Name
Resolution for more information. */
if (last_slash == name + 1)
++last_slash;
else
last_slash = name + 1;
} else
last_slash = runp;
last_slash[0] = '\0';
} else {
/* This assignment is ill-designed but the XPG specs require to
return a string containing "." in any case no directory part
is found and so a static and constant string is required. */
name[0] = '.';
name[1] = '\0';
}
return name;
}
static void
spawn(char *file, char *arg, char *dir, int notify)
{
pid_t pid;
int status;
pid = fork();
if (pid == 0) {
if (dir != NULL)
status = chdir(dir);
if (notify)
fprintf(stdout, "\n +-++-++-+\n | n n n |\n +-++-++-+\n\n");
execlp(file, file, arg, NULL);
_exit(1);
} else {
/* Ignore interruptions */
while (waitpid(pid, &status, 0) == -1)
DPRINTF_D(status);
DPRINTF_D(pid);
}
}
static char *
xgetenv(char *name, char *fallback)
{
char *value;
if (name == NULL)
return fallback;
value = getenv(name);
return value && value[0] ? value : fallback;
}
/*
* We assume none of the strings are NULL.
*
* Let's have the logic to sort numeric names in numeric order.
* E.g., the order '1, 10, 2' doesn't make sense to human eyes.
*
* If the absolute numeric values are same, we fallback to alphasort.
*/
static int
xstricmp(const char *s1, const char *s2)
{
static char *c1, *c2;
static long long num1, num2;
num1 = strtoll(s1, &c1, 10);
num2 = strtoll(s2, &c2, 10);
if (*c1 == '\0' && *c2 == '\0') {
if (num1 != num2) {
if (num1 > num2)
return 1;
else
return -1;
}
} else if (*c1 == '\0' && *c2 != '\0')
return -1;
else if (*c1 != '\0' && *c2 == '\0')
return 1;
while (*s2 && *s1 && TOUPPER(*s1) == TOUPPER(*s2))
s1++, s2++;
/* In case of alphabetically same names, make sure
lower case one comes before upper case one */
if (!*s1 && !*s2)
return 1;
return (int) (TOUPPER(*s1) - TOUPPER(*s2));
}
static char *
openwith(char *file)
{
regex_t regex;
char *bin = NULL;
unsigned int i;
for (i = 0; i < LEN(assocs); i++) {
if (regcomp(&regex, assocs[i].regex,
REG_NOSUB | REG_EXTENDED | REG_ICASE) != 0)
continue;
if (regexec(&regex, file, 0, NULL, 0) == 0) {
bin = assocs[i].bin;
break;
}
}
DPRINTF_S(bin);
return bin;
}
static int
setfilter(regex_t *regex, char *filter)
{
char errbuf[LINE_MAX];
size_t len;
int r;
r = regcomp(regex, filter, REG_NOSUB | REG_EXTENDED | REG_ICASE);
if (r != 0) {
len = COLS;
if (len > sizeof(errbuf))
len = sizeof(errbuf);
regerror(r, regex, errbuf, len);
printmsg(errbuf);
}
return r;
}
static void
initfilter(int dot, char **ifilter)
{
*ifilter = dot ? "." : "^[^.]";
}
static int
visible(regex_t *regex, char *file)
{
return regexec(regex, file, 0, NULL, 0) == 0;
}
static int
entrycmp(const void *va, const void *vb)
{
static pEntry pa, pb;
pa = (pEntry)va;
pb = (pEntry)vb;
/* Sort directories first */
if (S_ISDIR(pb->mode) && !S_ISDIR(pa->mode))
return 1;
else if (S_ISDIR(pa->mode) && !S_ISDIR(pb->mode))
return -1;
/* Do the actual sorting */
if (mtimeorder)
return pb->t - pa->t;
if (sizeorder) {
if (pb->size > pa->size)
return 1;
else if (pb->size < pa->size)
return -1;
}
if (bsizeorder) {
if (pb->bsize > pa->bsize)
return 1;
else if (pb->bsize < pa->bsize)
return -1;
}
return xstricmp(pa->name, pb->name);
}
static void
initcurses(void)
{
if (initscr() == NULL) {
char *term = getenv("TERM");
if (term != NULL)
fprintf(stderr, "error opening terminal: %s\n", term);
else
fprintf(stderr, "failed to initialize curses\n");
exit(1);
}
cbreak();
noecho();
nonl();
intrflush(stdscr, FALSE);
keypad(stdscr, TRUE);
curs_set(FALSE); /* Hide cursor */
timeout(1000); /* One second */
}
static void
exitcurses(void)
{
endwin(); /* Restore terminal */
}
/* Messages show up at the bottom */
static void
printmsg(char *msg)
{
move(LINES - 1, 0);
printw("%s\n", msg);
}
/* Display warning as a message */
static void
printwarn(void)
{
printmsg(strerror(errno));
}
/* Kill curses and display error before exiting */
static void
printerr(int ret, char *prefix)
{
exitcurses();
fprintf(stderr, "%s: %s\n", prefix, strerror(errno));
exit(ret);
}
/* Clear the last line */
static void
clearprompt(void)
{
printmsg("");
}
/* Print prompt on the last line */
static 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}) */
static int
nextsel(char **run, char **env)
{
int c;
unsigned int i;
c = getch();
if (c == -1)
idle++;
else
idle = 0;
for (i = 0; i < LEN(bindings); i++)
if (c == bindings[i].sym) {
*run = bindings[i].run;
*env = bindings[i].env;
return bindings[i].act;
}
return 0;
}
static char *
readln(void)
{
static char ln[LINE_MAX];
timeout(-1);
echo();
curs_set(TRUE);
memset(ln, 0, sizeof(ln));
wgetnstr(stdscr, ln, sizeof(ln) - 1);
noecho();
curs_set(FALSE);
timeout(1000);
return ln[0] ? ln : NULL;
}
static int
canopendir(char *path)
{
static DIR *dirp;
dirp = opendir(path);
if (dirp == NULL)
return 0;
closedir(dirp);
return 1;
}
/*
* Returns "dir/name or "/name"
*/
static char *
mkpath(char *dir, char *name, char *out, size_t n)
{
/* Handle absolute path */
if (name[0] == '/')
xstrlcpy(out, name, n);
else {
/* Handle root case */
if (strcmp(dir, "/") == 0)
snprintf(out, n, "/%s", name);
else
snprintf(out, n, "%s/%s", dir, name);
}
return out;
}
static void
printent(struct entry *ent, int active)
{
if (S_ISDIR(ent->mode))
printw("%s%s/\n", CURSYM(active), ent->name);
else if (S_ISLNK(ent->mode))
printw("%s%s@\n", CURSYM(active), ent->name);
else if (S_ISSOCK(ent->mode))
printw("%s%s=\n", CURSYM(active), ent->name);
else if (S_ISFIFO(ent->mode))
printw("%s%s|\n", CURSYM(active), ent->name);
else if (ent->mode & S_IXUSR)
printw("%s%s*\n", CURSYM(active), ent->name);
else
printw("%s%s\n", CURSYM(active), ent->name);
}
static void (*printptr)(struct entry *ent, int active) = &printent;
static char*
coolsize(off_t size)
{
static char size_buf[12]; /* Buffer to hold human readable size */
static int i;
static off_t fsize, tmp;
static long double rem;
i = 0;
fsize = size;
rem = 0;
while (fsize > 1024) {
tmp = fsize;
//fsize *= div_2_pow_10;
fsize >>= 10;
rem = tmp - (fsize << 10);
i++;
}
snprintf(size_buf, 12, "%.*Lf%s", i, fsize + rem * div_2_pow_10, size_units[i]);
return size_buf;
}
static void
printent_long(struct entry *ent, int active)
{
static char buf[18];
strftime(buf, 18, "%b %d %H:%M %Y", localtime(&ent->t));
if (active)
attron(A_REVERSE);
if (!bsizeorder) {
if (S_ISDIR(ent->mode))
printw("%s%-17.17s / %s/\n",
CURSYM(active), buf, ent->name);
else if (S_ISLNK(ent->mode))
printw("%s%-17.17s @ %s@\n",
CURSYM(active), buf, ent->name);
else if (S_ISSOCK(ent->mode))
printw("%s%-17.17s = %s=\n",
CURSYM(active), buf, ent->name);
else if (S_ISFIFO(ent->mode))
printw("%s%-17.17s | %s|\n",
CURSYM(active), buf, ent->name);
else if (S_ISBLK(ent->mode))
printw("%s%-17.17s b %s\n",
CURSYM(active), buf, ent->name);
else if (S_ISCHR(ent->mode))
printw("%s%-17.17s c %s\n",
CURSYM(active), buf, ent->name);
else if (ent->mode & S_IXUSR)
printw("%s%-17.17s %8.8s* %s*\n", CURSYM(active),
buf, coolsize(ent->size), ent->name);
else
printw("%s%-17.17s %8.8s %s\n", CURSYM(active),
buf, coolsize(ent->size), ent->name);
} else {
if (S_ISDIR(ent->mode))
printw("%s%-17.17s %8.8s/ %s/\n", CURSYM(active),
buf, coolsize(ent->bsize << 9), ent->name);
else if (S_ISLNK(ent->mode))
printw("%s%-17.17s @ %s@\n",
CURSYM(active), buf, ent->name);
else if (S_ISSOCK(ent->mode))
printw("%s%-17.17s = %s=\n",
CURSYM(active), buf, ent->name);
else if (S_ISFIFO(ent->mode))
printw("%s%-17.17s | %s|\n",
CURSYM(active), buf, ent->name);
else if (S_ISBLK(ent->mode))
printw("%s%-17.17s b %s\n",
CURSYM(active), buf, ent->name);
else if (S_ISCHR(ent->mode))
printw("%s%-17.17s c %s\n",
CURSYM(active), buf, ent->name);
else if (ent->mode & S_IXUSR)
printw("%s%-17.17s %8.8s* %s*\n", CURSYM(active),
buf, coolsize(ent->bsize << 9), ent->name);
else
printw("%s%-17.17s %8.8s %s\n", CURSYM(active),
buf, coolsize(ent->bsize << 9), ent->name);
}
if (active)
attroff(A_REVERSE);
}
static char
get_fileind(mode_t mode, char *desc)
{
static char c;
if (S_ISREG(mode)) {
c = '-';
sprintf(desc, "%s", "regular file");
if (mode & S_IXUSR)
strcat(desc, ", executable");
} else if (S_ISDIR(mode)) {
c = 'd';
sprintf(desc, "%s", "directory");
} else if (S_ISBLK(mode)) {
c = 'b';
sprintf(desc, "%s", "block special device");
} else if (S_ISCHR(mode)) {
c = 'c';
sprintf(desc, "%s", "character special device");
#ifdef S_ISFIFO
} else if (S_ISFIFO(mode)) {
c = 'p';
sprintf(desc, "%s", "FIFO");
#endif /* S_ISFIFO */
#ifdef S_ISLNK
} else if (S_ISLNK(mode)) {
c = 'l';
sprintf(desc, "%s", "symbolic link");
#endif /* S_ISLNK */
#ifdef S_ISSOCK
} else if (S_ISSOCK(mode)) {
c = 's';
sprintf(desc, "%s", "socket");
#endif /* S_ISSOCK */
#ifdef S_ISDOOR
/* Solaris 2.6, etc. */
} else if (S_ISDOOR(mode)) {
c = 'D';
desc[0] = '\0';
#endif /* S_ISDOOR */
} else {
/* Unknown type -- possibly a regular file? */
c = '?';
desc[0] = '\0';
}
return(c);
}
/* Convert a mode field into "ls -l" type perms field. */
static char *
get_lsperms(mode_t mode, char *desc)
{
static const char *rwx[] = {"---", "--x", "-w-", "-wx",
"r--", "r-x", "rw-", "rwx"};
static char bits[11];
bits[0] = get_fileind(mode, desc);
strcpy(&bits[1], rwx[(mode >> 6) & 7]);
strcpy(&bits[4], rwx[(mode >> 3) & 7]);
strcpy(&bits[7], rwx[(mode & 7)]);
if (mode & S_ISUID)
bits[3] = (mode & S_IXUSR) ? 's' : 'S';
if (mode & S_ISGID)
bits[6] = (mode & S_IXGRP) ? 's' : 'l';
if (mode & S_ISVTX)
bits[9] = (mode & S_IXOTH) ? 't' : 'T';
bits[10] = '\0';
return(bits);
}
static char *
get_output(char *buf, size_t bytes)
{
char *ret;
FILE *pf = popen(buf, "r");
if (pf) {
ret = fgets(buf, bytes, pf);
pclose(pf);
return ret;
}
return NULL;
}
/*
* Follows the stat(1) output closely
*/
static void
show_stats(char* fpath, char* fname, struct stat *sb)
{
char buf[PATH_MAX + 48];
char *perms = get_lsperms(sb->st_mode, buf);
char *p, *begin = buf;
clear();
/* Show file name or 'symlink' -> 'target' */
if (perms[0] == 'l') {
char symtgt[PATH_MAX];
ssize_t len = readlink(fpath, symtgt, PATH_MAX);
if (len != -1) {
symtgt[len] = '\0';
printw("\n\n File: '%s' -> '%s'", fname, symtgt);
}
} else
printw("\n File: '%s'", fname);
/* Show size, blocks, file type */
printw("\n Size: %-15llu Blocks: %-10llu IO Block: %-6llu %s",
sb->st_size, sb->st_blocks, sb->st_blksize, buf);
/* Show containing device, inode, hardlink count */
sprintf(buf, "%lxh/%lud", (ulong)sb->st_dev, (ulong)sb->st_dev);
printw("\n Device: %-15s Inode: %-11lu Links: %-9lu",
buf, sb->st_ino, sb->st_nlink);
/* Show major, minor number for block or char device */
if (perms[0] == 'b' || perms[0] == 'c')
printw(" Device type: %lx,%lx",
major(sb->st_rdev), minor(sb->st_rdev));
/* Show permissions, owner, group */
printw("\n Access: 0%d%d%d/%s Uid: (%lu/%s) Gid: (%lu/%s)",
(sb->st_mode >> 6) & 7, (sb->st_mode >> 3) & 7, sb->st_mode & 7,
perms,
sb->st_uid, (getpwuid(sb->st_uid))->pw_name,
sb->st_gid, (getgrgid(sb->st_gid))->gr_name);
/* Show last access time */
strftime(buf, 40, "%a %d-%b-%Y %T %z,%Z", localtime(&sb->st_atime));
printw("\n\n Access: %s", buf);
/* Show last modification time */
strftime(buf, 40, "%a %d-%b-%Y %T %z,%Z", localtime(&sb->st_mtime));
printw("\n Modify: %s", buf);
/* Show last status change time */
strftime(buf, 40, "%a %d-%b-%Y %T %z,%Z", localtime(&sb->st_ctime));
printw("\n Change: %s", buf);
if (S_ISREG(sb->st_mode)) {
/* Show file(1) output */
sprintf(buf, "file -b \"%s\" 2>&1", fpath);
p = get_output(buf, PATH_MAX + 48);
if (p) {
printw("\n\n ");
while (*p) {
if (*p == ',') {
*p = '\0';
printw(" %s\n", begin);
begin = p + 1;
}
p++;
}
printw(" %s", begin);
}
#ifdef SUPPORT_CHKSUM
/* Calculating checksums can take VERY long */
/* Show md5 */
sprintf(buf, "openssl md5 \"%s\" 2>&1", fpath);
p = get_output(buf, PATH_MAX + 48);
if (p) {
p = xmemrchr(buf, ' ', strlen(buf));
if (!p)
p = buf;
else
p++;
printw("\n md5: %s", p);
}
/* Show sha256 */
sprintf(buf, "openssl sha256 \"%s\" 2>&1", fpath);
p = get_output(buf, PATH_MAX + 48);
if (p) {
p = xmemrchr(buf, ' ', strlen(buf));
if (!p)
p = buf;
else
p++;
printw(" sha256: %s", p);
}
#endif
}
/* Show exit keys */
printw("\n\n << (D)");
while ((*buf = getch()) != 'D');
return;
}
static void
show_help(void)
{
char c;
clear();
printw("\n\
<< Key >> << Function >>\n\n\
[Up], k, ^P Previous entry\n\
[Down], j, ^N Next entry\n\
[PgUp], ^U Scroll half page up\n\
[PgDn], ^D Scroll half page down\n\
[Home], g, ^, ^A Jump to first entry\n\
[End], G, $, ^E Jump to last entry\n\
[Right], [Enter], l, ^M Open file or enter dir\n\
[Left], [Backspace], h, ^H Go to parent dir\n\
~ Jump to HOME dir\n\
- Jump to last visited dir\n\
o Open dir in desktop file manager\n\
/, & Filter dir contents\n\
c Show change dir prompt\n\
d Toggle detail view\n\
D Toggle current file details screen\n\
. Toggle hide .dot files\n\
s Toggle sort by file size\n\
S Toggle disk usage analyzer mode\n\
t Toggle sort by modified time\n\
! Spawn SHELL in PWD (fallback sh)\n\
z Run top\n\
e Edit entry in EDITOR (fallback vi)\n\
p Open entry in PAGER (fallback less)\n\
^K Invoke file name copier\n\
^L Force a redraw\n\
? Toggle help screen\n\
q Quit\n");
/* Show exit keys */
printw("\n\n << (?)");
while ((c = getch()) != '?');
return;
}
static int
sum_bsizes(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
{
/* Handle permission problems */
if(typeflag == FTW_NS) {
printmsg("No stats (permissions ?)");
return 0;
}
blk_size += sb->st_blocks;
return 0;
}
static int
getorder(size_t size)
{
switch (size) {
case 4096:
return 12;
case 512:
return 9;
case 8192:
return 13;
case 16384:
return 14;
case 32768:
return 15;
case 65536:
return 16;
case 131072:
return 17;
case 262144:
return 18;
case 524288:
return 19;
case 1048576:
return 20;
case 2048:
return 11;
case 1024:
return 10;
default:
return 0;
}
}
static int
dentfill(char *path, struct entry **dents,
int (*filter)(regex_t *, char *), regex_t *re)
{
static char newpath[PATH_MAX];
static DIR *dirp;
static struct dirent *dp;
static struct stat sb;
static struct statvfs svb;
static int r, n;
r = n = 0;
dirp = opendir(path);
if (dirp == NULL)
return 0;
while ((dp = readdir(dirp)) != NULL) {
/* Skip self and parent */
if ((dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
(dp->d_name[1] == '.' && dp->d_name[2] == '\0'))))
continue;
if (filter(re, dp->d_name) == 0)
continue;
if (((n >> 5) << 5) == n) {
*dents = realloc(*dents, (n + 32) * sizeof(**dents));
if (*dents == NULL)
printerr(1, "realloc");
}
xstrlcpy((*dents)[n].name, dp->d_name, sizeof((*dents)[n].name));
/* Get mode flags */
mkpath(path, dp->d_name, newpath, sizeof(newpath));
r = lstat(newpath, &sb);
if (r == -1)
printerr(1, "lstat");
(*dents)[n].mode = sb.st_mode;
(*dents)[n].t = sb.st_mtime;
(*dents)[n].size = sb.st_size;
if (bsizeorder) {
if (S_ISDIR(sb.st_mode)) {
blk_size = 0;
if (nftw(newpath, sum_bsizes, open_max, FTW_MOUNT | FTW_PHYS) == -1) {
printmsg("nftw(3) failed");
(*dents)[n].bsize = sb.st_blocks;
} else
(*dents)[n].bsize = blk_size;
} else
(*dents)[n].bsize = sb.st_blocks;
}
n++;
}
if (bsizeorder) {
r = statvfs(path, &svb);
if (r == -1)
fs_free = 0;
else
fs_free = svb.f_bavail << getorder(svb.f_bsize);
}
/* Should never be null */
r = closedir(dirp);
if (r == -1)
printerr(1, "closedir");
return n;
}
static void
dentfree(struct entry *dents)
{
free(dents);
}
/* Return the position of the matching entry or 0 otherwise */
static int
dentfind(struct entry *dents, int n, char *path)
{
if (!path)
return 0;
static int i;
static char *p;
p = xmemrchr(path, '/', strlen(path));
if (!p)
p = path;
else
/* We are assuming an entry with actual
name ending in '/' will not appear */
p++;
DPRINTF_S(p);
for (i = 0; i < n; i++)
if (strcmp(p, dents[i].name) == 0)
return i;
return 0;
}
static int
populate(char *path, char *oldpath, char *fltr)
{
static regex_t re;
static int r;
/* Can fail when permissions change while browsing */
if (canopendir(path) == 0)
return -1;
/* Search filter */
r = setfilter(&re, fltr);
if (r != 0)
return -1;
dentfree(dents);
ndents = 0;
dents = NULL;
ndents = dentfill(path, &dents, visible, &re);
qsort(dents, ndents, sizeof(*dents), entrycmp);
/* Find cur from history */
cur = dentfind(dents, ndents, oldpath);
return 0;
}
static void
redraw(char *path)
{
static char cwd[PATH_MAX];
static int nlines, odd;
static int i;
nlines = MIN(LINES - 4, ndents);
/* Clean screen */
erase();
/* 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 */
if (!realpath(path, cwd)) {
printmsg("Cannot resolve path");
return;
}
printw(CWD "%s\n\n", cwd);
/* Print listing */
odd = ISODD(nlines);
if (cur < (nlines >> 1)) {
for (i = 0; i < nlines; i++)
printptr(&dents[i], i == cur);
} else if (cur >= ndents - (nlines >> 1)) {
for (i = ndents - nlines; i < ndents; i++)
printptr(&dents[i], i == cur);
} else {
nlines >>= 1;
for (i = cur - nlines; i < cur + nlines + odd; i++)
printptr(&dents[i], i == cur);
}
if (showdetail) {
if (ndents) {
static char ind[2] = "\0\0";
static char sort[17];
if (mtimeorder)
sprintf(sort, "by time ");
else if (sizeorder)
sprintf(sort, "by size ");
else
sort[0] = '\0';
if (S_ISDIR(dents[cur].mode))
ind[0] = '/';
else if (S_ISLNK(dents[cur].mode))
ind[0] = '@';
else if (S_ISSOCK(dents[cur].mode))
ind[0] = '=';
else if (S_ISFIFO(dents[cur].mode))
ind[0] = '|';
else if (dents[cur].mode & S_IXUSR)
ind[0] = '*';
else
ind[0] = '\0';
if (!bsizeorder)
sprintf(cwd, "total %d %s[%s%s]", ndents, sort,
dents[cur].name, ind);
else
sprintf(cwd, "total %d by disk usage, %s free [%s%s]",
ndents, coolsize(fs_free), dents[cur].name, ind);
printmsg(cwd);
} else
printmsg("0 items");
}
}
static void
browse(char *ipath, char *ifilter)
{
static char path[PATH_MAX], oldpath[PATH_MAX], newpath[PATH_MAX];
static char lastdir[PATH_MAX];
static char fltr[LINE_MAX];
char *bin, *dir, *tmp, *run, *env;
struct stat sb;
regex_t re;
int r, fd;
enum action sel = SEL_RUNARG + 1;
xstrlcpy(path, ipath, sizeof(path));
xstrlcpy(lastdir, ipath, sizeof(lastdir));
xstrlcpy(fltr, ifilter, sizeof(fltr));
oldpath[0] = '\0';
newpath[0] = '\0';
begin:
if (sel == SEL_GOIN && S_ISDIR(sb.st_mode))
r = populate(path, NULL, fltr);
else
r = populate(path, oldpath, fltr);
if (r == -1) {
printwarn();
goto nochange;
}
for (;;) {
redraw(path);
nochange:
sel = nextsel(&run, &env);
switch (sel) {
case SEL_QUIT:
dentfree(dents);
return;
case SEL_BACK:
/* There is no going back */
if (strcmp(path, "/") == 0 ||
strcmp(path, ".") == 0 ||
strchr(path, '/') == NULL) {
printmsg("You are at /");
goto nochange;
}
dir = xdirname(path);
if (canopendir(dir) == 0) {
printwarn();
goto nochange;
}
/* Save history */
xstrlcpy(oldpath, path, sizeof(oldpath));
/* Save last working directory */
xstrlcpy(lastdir, path, sizeof(lastdir));
xstrlcpy(path, dir, sizeof(path));
/* Reset filter */
xstrlcpy(fltr, ifilter, sizeof(fltr));
goto begin;
case SEL_GOIN:
/* Cannot descend in empty directories */
if (ndents == 0)
goto nochange;
mkpath(path, dents[cur].name, newpath, sizeof(newpath));
DPRINTF_S(newpath);
/* Get path info */
fd = open(newpath, O_RDONLY | O_NONBLOCK);
if (fd == -1) {
printwarn();
goto nochange;
}
r = fstat(fd, &sb);
if (r == -1) {
printwarn();
close(fd);
goto nochange;
}
close(fd);
DPRINTF_U(sb.st_mode);
switch (sb.st_mode & S_IFMT) {
case S_IFDIR:
if (canopendir(newpath) == 0) {
printwarn();
goto nochange;
}
/* Save last working directory */
xstrlcpy(lastdir, path, sizeof(lastdir));
xstrlcpy(path, newpath, sizeof(path));
/* Reset filter */
xstrlcpy(fltr, ifilter, sizeof(fltr));
goto begin;
case S_IFREG:
{
static char cmd[MAX_CMD_LEN];
static char *runvi = "vi";
static int status;
/* If default mime opener is set, use it */
if (opener) {
snprintf(cmd, MAX_CMD_LEN,
"%s \"%s\" > /dev/null 2>&1",
opener, newpath);
status = system(cmd);
continue;
}
/* Try custom applications */
bin = openwith(newpath);
/* If custom app doesn't exist try fallback */
snprintf(cmd, MAX_CMD_LEN, "which \"%s\"", bin);
if (get_output(cmd, MAX_CMD_LEN) == NULL)
bin = NULL;
if (bin == NULL) {
/* If a custom handler application is
not set, open plain text files with
vi, then try fallback_opener */
snprintf(cmd, MAX_CMD_LEN,
"file \"%s\"", newpath);
if (get_output(cmd, MAX_CMD_LEN) == NULL)
goto nochange;
if (strstr(cmd, "ASCII text") != NULL)
bin = runvi;
else if (fallback_opener) {
snprintf(cmd, MAX_CMD_LEN,
"%s \"%s\" > \
/dev/null 2>&1",
fallback_opener,
newpath);
status = system(cmd);
continue;
} else {
status++; /* Dummy operation */
printmsg("No association");
goto nochange;
}
}
exitcurses();
spawn(bin, newpath, NULL, 0);
initcurses();
continue;
}
default:
printmsg("Unsupported file");
goto nochange;
}
case SEL_FLTR:
/* Read filter */
printprompt("filter: ");
tmp = readln();
if (tmp == NULL)
tmp = ifilter;
/* Check and report regex errors */
r = setfilter(&re, tmp);
if (r != 0)
goto nochange;
xstrlcpy(fltr, tmp, sizeof(fltr));
DPRINTF_S(fltr);
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_NEXT:
if (cur < ndents - 1)
cur++;
else if (ndents)
/* Roll over, set cursor to first entry */
cur = 0;
break;
case SEL_PREV:
if (cur > 0)
cur--;
else if (ndents)
/* Roll over, set cursor to last entry */
cur = ndents - 1;
break;
case SEL_PGDN:
if (cur < ndents - 1)
cur += MIN((LINES - 4) / 2, ndents - 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 = ndents - 1;
break;
case SEL_CD:
/* Read target dir */
printprompt("chdir: ");
tmp = readln();
if (tmp == NULL) {
clearprompt();
goto nochange;
}
if (tmp[0] == '~') {
char *home = getenv("HOME");
if (home)
snprintf(newpath, PATH_MAX,
"%s%s", home, tmp + 1);
else
mkpath(path, tmp, newpath, sizeof(newpath));
} else if (tmp[0] == '-' && tmp[1] == '\0')
xstrlcpy(newpath, lastdir, sizeof(newpath));
else
mkpath(path, tmp, newpath, sizeof(newpath));
if (canopendir(newpath) == 0) {
printwarn();
goto nochange;
}
/* Save last working directory */
xstrlcpy(lastdir, path, sizeof(lastdir));
xstrlcpy(path, newpath, sizeof(path));
/* Reset filter */
xstrlcpy(fltr, ifilter, sizeof(fltr));
DPRINTF_S(path);
goto begin;
case SEL_CDHOME:
tmp = getenv("HOME");
if (tmp == NULL) {
clearprompt();
goto nochange;
}
if (canopendir(tmp) == 0) {
printwarn();
goto nochange;
}
/* Save last working directory */
xstrlcpy(lastdir, path, sizeof(lastdir));
xstrlcpy(path, tmp, sizeof(path));
/* Reset filter */
xstrlcpy(fltr, ifilter, sizeof(fltr));
DPRINTF_S(path);
goto begin;
case SEL_LAST:
xstrlcpy(newpath, lastdir, sizeof(newpath));
xstrlcpy(lastdir, path, sizeof(lastdir));
xstrlcpy(path, newpath, sizeof(path));
DPRINTF_S(path);
goto begin;
case SEL_TOGGLEDOT:
showhidden ^= 1;
initfilter(showhidden, &ifilter);
xstrlcpy(fltr, ifilter, sizeof(fltr));
goto begin;
case SEL_DETAIL:
showdetail = !showdetail;
showdetail ? (printptr = &printent_long)
: (printptr = &printent);
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_STATS:
{
struct stat sb;
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
r = lstat(oldpath, &sb);
if (r == -1)
printerr(1, "lstat");
else
show_stats(oldpath, dents[cur].name, &sb);
goto begin;
}
case SEL_DFB:
if (!desktop_manager)
goto nochange;
exitcurses();
spawn(desktop_manager, path, path, 0);
initcurses();
goto nochange;
case SEL_FSIZE:
sizeorder = !sizeorder;
mtimeorder = 0;
bsizeorder = 0;
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_BSIZE:
bsizeorder = !bsizeorder;
if (bsizeorder) {
showdetail = 1;
printptr = &printent_long;
}
mtimeorder = 0;
sizeorder = 0;
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_MTIME:
mtimeorder = !mtimeorder;
sizeorder = 0;
bsizeorder = 0;
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_REDRAW:
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_COPY:
if (copier && ndents) {
char abspath[PATH_MAX];
if (strcmp(path, "/") == 0)
snprintf(abspath, PATH_MAX, "/%s",
dents[cur].name);
else
snprintf(abspath, PATH_MAX, "%s/%s",
path, dents[cur].name);
spawn(copier, abspath, NULL, 0);
printmsg(abspath);
} else if (!copier)
printmsg("NNN_COPIER is not set");
goto nochange;
case SEL_HELP:
show_help();
/* Save current */
if (ndents > 0)
mkpath(path, dents[cur].name, oldpath, sizeof(oldpath));
goto begin;
case SEL_RUN:
run = xgetenv(env, run);
exitcurses();
spawn(run, NULL, path, 1);
initcurses();
/* Repopulate as directory content may have changed */
goto begin;
case SEL_RUNARG:
run = xgetenv(env, run);
exitcurses();
spawn(run, dents[cur].name, path, 0);
initcurses();
break;
}
/* Screensaver */
if (idletimeout != 0 && idle == idletimeout) {
idle = 0;
exitcurses();
spawn(idlecmd, NULL, NULL, 0);
initcurses();
}
}
}
static void
usage(void)
{
fprintf(stderr, "usage: nnn [-d] [-v] [dir]\n");
exit(1);
}
int
main(int argc, char *argv[])
{
char cwd[PATH_MAX], *ipath;
char *ifilter;
int opt = 0;
/* Confirm we are in a terminal */
if (!isatty(0) || !isatty(1)) {
fprintf(stderr, "stdin or stdout is not a tty\n");
exit(1);
}
if (argc > 3)
usage();
while ((opt = getopt(argc, argv, "dv")) != -1) {
switch (opt) {
case 'd':
/* Open in detail mode, if set */
showdetail = 1;
printptr = &printent_long;
break;
case 'v':
fprintf(stderr, "%s\n", VERSION);
return 0;
default:
usage();
}
}
if (argc == optind) {
/* Start in the current directory */
ipath = getcwd(cwd, sizeof(cwd));
if (ipath == NULL)
ipath = "/";
} else {
ipath = realpath(argv[optind], cwd);
if (!ipath) {
fprintf(stderr, "%s: no such dir\n", argv[optind]);
exit(1);
}
}
open_max = max_openfds();
if (getuid() == 0)
showhidden = 1;
initfilter(showhidden, &ifilter);
/* Get the default desktop mime opener, if set */
opener = getenv("NNN_OPENER");
/* Get the fallback desktop mime opener, if set */
fallback_opener = getenv("NNN_FALLBACK_OPENER");
/* Get the desktop file browser, if set */
desktop_manager = getenv("NNN_DE_FILE_MANAGER");
/* Get the default copier, if set */
copier = getenv("NNN_COPIER");
signal(SIGINT, SIG_IGN);
/* Test initial path */
if (canopendir(ipath) == 0) {
fprintf(stderr, "%s: %s\n", ipath, strerror(errno));
exit(1);
}
/* Set locale before curses setup */
setlocale(LC_ALL, "");
initcurses();
browse(ipath, ifilter);
exitcurses();
exit(0);
}
Reference in New Issue View Git Blame Copy Permalink