1 #define _XOPEN_SOURCE       700
2 #define _XOPEN_SOURCE_EXTENDED
3 #define _FILE_OFFSET_BITS   64
4 
5 #include <stdlib.h>
6 #include <stdint.h>
7 #include <ctype.h>
8 #include <wchar.h>
9 #include <wctype.h>
10 #include <string.h>
11 #include <sys/types.h>  /* pid_t, ... */
12 #include <stdio.h>
13 #include <limits.h>     /* PATH_MAX */
14 #include <locale.h>     /* setlocale(), LC_ALL */
15 #include <unistd.h>     /* chdir(), getcwd(), read(), close(), ... */
16 #include <dirent.h>     /* DIR, struct dirent, opendir(), ... */
17 #include <libgen.h>
18 #include <sys/stat.h>
19 #include <fcntl.h>      /* open() */
20 #include <sys/wait.h>   /* waitpid() */
21 #include <signal.h>     /* struct sigaction, sigaction() */
22 #include <errno.h>
23 #include <stdarg.h>
24 #include <curses.h>
25 
26 #include "config.h"
27 
28 /*  This signal is not defined by POSIX, but should be
29    present on all systems that have resizable terminals. */
30 #ifndef SIGWINCH
31 #define SIGWINCH  28
32 #endif
33 
34 /* String buffers. */
35 #define BUFLEN  PATH_MAX
36 static char BUF1[BUFLEN];
37 static char BUF2[BUFLEN];
38 static char INPUT[BUFLEN];
39 static wchar_t WBUF[BUFLEN];
40 
41 /* Listing view parameters. */
42 #define HEIGHT      (LINES-4)
43 #define STATUSPOS   (COLS-16)
44 
45 /* Listing view flags. */
46 #define SHOW_FILES      0x01u
47 #define SHOW_DIRS       0x02u
48 #define SHOW_HIDDEN     0x04u
49 
50 /* Marks parameters. */
51 #define BULK_INIT   5
52 #define BULK_THRESH 256
53 
54 /* Information associated to each entry in listing. */
55 typedef struct Row {
56     char *name;
57     off_t size;
58     mode_t mode;
59     int islink;
60     int marked;
61 } Row;
62 
63 /* Dynamic array of marked entries. */
64 typedef struct Marks {
65     char dirpath[PATH_MAX];
66     int bulk;
67     int nentries;
68     char **entries;
69 } Marks;
70 
71 /* Line editing state. */
72 typedef struct Edit {
73     wchar_t buffer[BUFLEN+1];
74     int left, right;
75 } Edit;
76 
77 /* Each tab only stores the following information. */
78 typedef struct Tab {
79     int scroll;
80     int esel;
81     uint8_t flags;
82     char cwd[PATH_MAX];
83 } Tab;
84 
85 typedef struct Prog {
86     off_t partial;
87     off_t total;
88     const char *msg;
89 } Prog;
90 
91 /* Global state. */
92 static struct Rover {
93     int tab;
94     int nfiles;
95     Row *rows;
96     WINDOW *window;
97     Marks marks;
98     Edit edit;
99     int edit_scroll;
100     volatile sig_atomic_t pending_winch;
101     Prog prog;
102     Tab tabs[10];
103 } rover;
104 
105 /* Macros for accessing global state. */
106 #define ENAME(I)    rover.rows[I].name
107 #define ESIZE(I)    rover.rows[I].size
108 #define EMODE(I)    rover.rows[I].mode
109 #define ISLINK(I)   rover.rows[I].islink
110 #define MARKED(I)   rover.rows[I].marked
111 #define SCROLL      rover.tabs[rover.tab].scroll
112 #define ESEL        rover.tabs[rover.tab].esel
113 #define FLAGS       rover.tabs[rover.tab].flags
114 #define CWD         rover.tabs[rover.tab].cwd
115 
116 /* Helpers. */
117 #define MIN(A, B)   ((A) < (B) ? (A) : (B))
118 #define MAX(A, B)   ((A) > (B) ? (A) : (B))
119 #define ISDIR(E)    (strchr((E), '/') != NULL)
120 
121 /* Line Editing Macros. */
122 #define EDIT_FULL(E)       ((E).left == (E).right)
123 #define EDIT_CAN_LEFT(E)   ((E).left)
124 #define EDIT_CAN_RIGHT(E)  ((E).right < BUFLEN-1)
125 #define EDIT_LEFT(E)       (E).buffer[(E).right--] = (E).buffer[--(E).left]
126 #define EDIT_RIGHT(E)      (E).buffer[(E).left++] = (E).buffer[++(E).right]
127 #define EDIT_INSERT(E, C)  (E).buffer[(E).left++] = (C)
128 #define EDIT_BACKSPACE(E)  (E).left--
129 #define EDIT_DELETE(E)     (E).right++
130 #define EDIT_CLEAR(E)      do { (E).left = 0; (E).right = BUFLEN-1; } while(0)
131 
132 typedef enum EditStat {CONTINUE, CONFIRM, CANCEL} EditStat;
133 typedef enum Color {DEFAULT, RED, GREEN, YELLOW, BLUE, CYAN, MAGENTA, WHITE, BLACK} Color;
134 typedef int (*PROCESS)(const char *path);
135 
136 static void
137 init_marks(Marks *marks)
138 {
139     strcpy(marks->dirpath, "");
140     marks->bulk = BULK_INIT;
141     marks->nentries = 0;
142     marks->entries = calloc(marks->bulk, sizeof *marks->entries);
143 }
144 
145 /* Unmark all entries. */
146 static void
147 mark_none(Marks *marks)
148 {
149     int i;
150 
151     strcpy(marks->dirpath, "");
152     for (i = 0; i < marks->bulk && marks->nentries; i++)
153         if (marks->entries[i]) {
154             free(marks->entries[i]);
155             marks->entries[i] = NULL;
156             marks->nentries--;
157         }
158     if (marks->bulk > BULK_THRESH) {
159         /* Reset bulk to free some memory. */
160         free(marks->entries);
161         marks->bulk = BULK_INIT;
162         marks->entries = calloc(marks->bulk, sizeof *marks->entries);
163     }
164 }
165 
166 static void
167 add_mark(Marks *marks, char *dirpath, char *entry)
168 {
169     int i;
170 
171     if (!strcmp(marks->dirpath, dirpath)) {
172         /* Append mark to directory. */
173         if (marks->nentries == marks->bulk) {
174             /* Expand bulk to accomodate new entry. */
175             int extra = marks->bulk / 2;
176             marks->bulk += extra; /* bulk *= 1.5; */
177             marks->entries = realloc(marks->entries,
178                                      marks->bulk * sizeof *marks->entries);
179             memset(&marks->entries[marks->nentries], 0,
180                    extra * sizeof *marks->entries);
181             i = marks->nentries;
182         } else {
183             /* Search for empty slot (there must be one). */
184             for (i = 0; i < marks->bulk; i++)
185                 if (!marks->entries[i])
186                     break;
187         }
188     } else {
189         /* Directory changed. Discard old marks. */
190         mark_none(marks);
191         strcpy(marks->dirpath, dirpath);
192         i = 0;
193     }
194     marks->entries[i] = malloc(strlen(entry) + 1);
195     strcpy(marks->entries[i], entry);
196     marks->nentries++;
197 }
198 
199 static void
200 del_mark(Marks *marks, char *entry)
201 {
202     int i;
203 
204     if (marks->nentries > 1) {
205         for (i = 0; i < marks->bulk; i++)
206             if (marks->entries[i] && !strcmp(marks->entries[i], entry))
207                 break;
208         free(marks->entries[i]);
209         marks->entries[i] = NULL;
210         marks->nentries--;
211     } else
212         mark_none(marks);
213 }
214 
215 static void
216 free_marks(Marks *marks)
217 {
218     int i;
219 
220     for (i = 0; i < marks->bulk && marks->nentries; i++)
221         if (marks->entries[i]) {
222             free(marks->entries[i]);
223             marks->nentries--;
224         }
225     free(marks->entries);
226 }
227 
228 static void
229 handle_winch(int sig)
230 {
231     rover.pending_winch = 1;
232 }
233 
234 static void
235 enable_handlers()
236 {
237     struct sigaction sa;
238 
239     memset(&sa, 0, sizeof (struct sigaction));
240     sa.sa_handler = handle_winch;
241     sigaction(SIGWINCH, &sa, NULL);
242 }
243 
244 static void
245 disable_handlers()
246 {
247     struct sigaction sa;
248 
249     memset(&sa, 0, sizeof (struct sigaction));
250     sa.sa_handler = SIG_DFL;
251     sigaction(SIGWINCH, &sa, NULL);
252 }
253 
254 static void update_view();
255 
256 /* Handle any signals received since last call. */
257 static void
258 sync_signals()
259 {
260     if (rover.pending_winch) {
261         /* SIGWINCH received: resize application accordingly. */
262         delwin(rover.window);
263         endwin();
264         refresh();
265         clear();
266         rover.window = subwin(stdscr, LINES - 2, COLS, 1, 0);
267         if (HEIGHT < rover.nfiles && SCROLL + HEIGHT > rover.nfiles)
268             SCROLL = ESEL - HEIGHT;
269         update_view();
270         rover.pending_winch = 0;
271     }
272 }
273 
274 /* This function must be used in place of getch().
275    It handles signals while waiting for user input. */
276 static int
277 rover_getch()
278 {
279     int ch;
280 
281     while ((ch = getch()) == ERR)
282         sync_signals();
283     return ch;
284 }
285 
286 /* This function must be used in place of get_wch().
287    It handles signals while waiting for user input. */
288 static int
289 rover_get_wch(wint_t *wch)
290 {
291     wint_t ret;
292 
293     while ((ret = get_wch(wch)) == (wint_t) ERR)
294         sync_signals();
295     return ret;
296 }
297 
298 /* Do a fork-exec to external program (e.g. $EDITOR). */
299 static void
300 spawn(char **args)
301 {
302     pid_t pid;
303     int status;
304 
305     setenv("RVSEL", rover.nfiles ? ENAME(ESEL) : "", 1);
306     pid = fork();
307     if (pid > 0) {
308         /* fork() succeeded. */
309         disable_handlers();
310         endwin();
311         waitpid(pid, &status, 0);
312         enable_handlers();
313         kill(getpid(), SIGWINCH);
314     } else if (pid == 0) {
315         /* Child process. */
316         execvp(args[0], args);
317     }
318 }
319 
320 static void
321 shell_escaped_cat(char *buf, char *str, size_t n)
322 {
323     char *p = buf + strlen(buf);
324     *p++ = '\'';
325     for (n--; n; n--, str++) {
326         switch (*str) {
327         case '\'':
328             if (n < 4)
329                 goto done;
330             strcpy(p, "'\\''");
331             n -= 4;
332             p += 4;
333             break;
334         case '\0':
335             goto done;
336         default:
337             *p = *str;
338             p++;
339         }
340     }
341 done:
342     strncat(p, "'", n);
343 }
344 
345 static int
346 open_with_env(const char *env, char *path)
347 {
348     char *program = getenv(env);
349     if (program) {
350 #ifdef RV_SHELL
351         strncpy(BUF1, program, BUFLEN - 1);
352         strncat(BUF1, " ", BUFLEN - strlen(program) - 1);
353         shell_escaped_cat(BUF1, path, BUFLEN - strlen(program) - 2);
354         spawn((char *[]) {RV_SHELL, "-c", BUF1, NULL});
355 #else
356         spawn((char *[]) {program, path, NULL});
357 #endif
358         return 1;
359     }
360     return 0;
361 }
362 
363 /* Curses setup. */
364 static void
365 init_term()
366 {
367     setlocale(LC_ALL, "");
368     initscr();
369     cbreak(); /* Get one character at a time. */
370     timeout(100); /* For getch(). */
371     noecho();
372     nonl(); /* No NL->CR/NL on output. */
373     intrflush(stdscr, FALSE);
374     keypad(stdscr, TRUE);
375     curs_set(FALSE); /* Hide blinking cursor. */
376     if (has_colors()) {
377         short bg;
378         start_color();
379 #ifdef NCURSES_EXT_FUNCS
380         use_default_colors();
381         bg = -1;
382 #else
383         bg = COLOR_BLACK;
384 #endif
385         init_pair(RED, COLOR_RED, bg);
386         init_pair(GREEN, COLOR_GREEN, bg);
387         init_pair(YELLOW, COLOR_YELLOW, bg);
388         init_pair(BLUE, COLOR_BLUE, bg);
389         init_pair(CYAN, COLOR_CYAN, bg);
390         init_pair(MAGENTA, COLOR_MAGENTA, bg);
391         init_pair(WHITE, COLOR_WHITE, bg);
392         init_pair(BLACK, COLOR_BLACK, bg);
393     }
394     atexit((void (*)(void)) endwin);
395     enable_handlers();
396 }
397 
398 /* Update the listing view. */
399 static void
400 update_view()
401 {
402     int i, j;
403     int numsize;
404     int ishidden;
405     int marking;
406 
407     mvhline(0, 0, ' ', COLS);
408     attr_on(A_BOLD, NULL);
409     color_set(RVC_TABNUM, NULL);
410     mvaddch(0, COLS - 2, rover.tab + '0');
411     attr_off(A_BOLD, NULL);
412     if (rover.marks.nentries) {
413         numsize = snprintf(BUF1, BUFLEN, "%d", rover.marks.nentries);
414         color_set(RVC_MARKS, NULL);
415         mvaddstr(0, COLS - 3 - numsize, BUF1);
416     } else
417         numsize = -1;
418     color_set(RVC_CWD, NULL);
419     mbstowcs(WBUF, CWD, PATH_MAX);
420     mvaddnwstr(0, 0, WBUF, COLS - 4 - numsize);
421     wcolor_set(rover.window, RVC_BORDER, NULL);
422     wborder(rover.window, 0, 0, 0, 0, 0, 0, 0, 0);
423     ESEL = MAX(MIN(ESEL, rover.nfiles - 1), 0);
424     /* Selection might not be visible, due to cursor wrapping or window
425        shrinking. In that case, the scroll must be moved to make it visible. */
426     if (rover.nfiles > HEIGHT) {
427         SCROLL = MAX(MIN(SCROLL, ESEL), ESEL - HEIGHT + 1);
428         SCROLL = MIN(MAX(SCROLL, 0), rover.nfiles - HEIGHT);
429     } else
430         SCROLL = 0;
431     marking = !strcmp(CWD, rover.marks.dirpath);
432     for (i = 0, j = SCROLL; i < HEIGHT && j < rover.nfiles; i++, j++) {
433         ishidden = ENAME(j)[0] == '.';
434         if (j == ESEL)
435             wattr_on(rover.window, A_REVERSE, NULL);
436         if (ISLINK(j))
437             wcolor_set(rover.window, RVC_LINK, NULL);
438         else if (ishidden)
439             wcolor_set(rover.window, RVC_HIDDEN, NULL);
440         else if (S_ISREG(EMODE(j))) {
441             if (EMODE(j) & (S_IXUSR | S_IXGRP | S_IXOTH))
442                 wcolor_set(rover.window, RVC_EXEC, NULL);
443             else
444                 wcolor_set(rover.window, RVC_REG, NULL);
445         } else if (S_ISDIR(EMODE(j)))
446             wcolor_set(rover.window, RVC_DIR, NULL);
447         else if (S_ISCHR(EMODE(j)))
448             wcolor_set(rover.window, RVC_CHR, NULL);
449         else if (S_ISBLK(EMODE(j)))
450             wcolor_set(rover.window, RVC_BLK, NULL);
451         else if (S_ISFIFO(EMODE(j)))
452             wcolor_set(rover.window, RVC_FIFO, NULL);
453         else if (S_ISSOCK(EMODE(j)))
454             wcolor_set(rover.window, RVC_SOCK, NULL);
455         if (S_ISDIR(EMODE(j))) {
456             mbstowcs(WBUF, ENAME(j), PATH_MAX);
457             if (ISLINK(j))
458                 wcscat(WBUF, L"/");
459         } else {
460             char *suffix, *suffixes = "BKMGTPEZY";
461             off_t human_size = ESIZE(j) * 10;
462             int length = mbstowcs(NULL, ENAME(j), 0);
463             for (suffix = suffixes; human_size >= 10240; suffix++)
464                 human_size = (human_size + 512) / 1024;
465             if (*suffix == 'B')
466                 swprintf(WBUF, PATH_MAX, L"%s%*d %c", ENAME(j),
467                          (int) (COLS - length - 6),
468                          (int) human_size / 10, *suffix);
469             else
470                 swprintf(WBUF, PATH_MAX, L"%s%*d.%d %c", ENAME(j),
471                          (int) (COLS - length - 8),
472                          (int) human_size / 10, (int) human_size % 10, *suffix);
473         }
474         mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
475         mvwaddnwstr(rover.window, i + 1, 2, WBUF, COLS - 4);
476         if (marking && MARKED(j)) {
477             wcolor_set(rover.window, RVC_MARKS, NULL);
478             mvwaddch(rover.window, i + 1, 1, RVS_MARK);
479         } else
480             mvwaddch(rover.window, i + 1, 1, ' ');
481         if (j == ESEL)
482             wattr_off(rover.window, A_REVERSE, NULL);
483     }
484     for (; i < HEIGHT; i++)
485         mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
486     if (rover.nfiles > HEIGHT) {
487         int center, height;
488         center = (SCROLL + HEIGHT / 2) * HEIGHT / rover.nfiles;
489         height = (HEIGHT-1) * HEIGHT / rover.nfiles;
490         if (!height) height = 1;
491         wcolor_set(rover.window, RVC_SCROLLBAR, NULL);
492         mvwvline(rover.window, center-height/2+1, COLS-1, RVS_SCROLLBAR, height);
493     }
494     BUF1[0] = FLAGS & SHOW_FILES  ? 'F' : ' ';
495     BUF1[1] = FLAGS & SHOW_DIRS   ? 'D' : ' ';
496     BUF1[2] = FLAGS & SHOW_HIDDEN ? 'H' : ' ';
497     if (!rover.nfiles)
498         strcpy(BUF2, "0/0");
499     else
500         snprintf(BUF2, BUFLEN, "%d/%d", ESEL + 1, rover.nfiles);
501     snprintf(BUF1+3, BUFLEN-3, "%12s", BUF2);
502     color_set(RVC_STATUS, NULL);
503     mvaddstr(LINES - 1, STATUSPOS, BUF1);
504     wrefresh(rover.window);
505 }
506 
507 /* Show a message on the status bar. */
508 static void
509 message(Color color, char *fmt, ...)
510 {
511     int len, pos;
512     va_list args;
513 
514     va_start(args, fmt);
515     vsnprintf(BUF1, MIN(BUFLEN, STATUSPOS), fmt, args);
516     va_end(args);
517     len = strlen(BUF1);
518     pos = (STATUSPOS - len) / 2;
519     attr_on(A_BOLD, NULL);
520     color_set(color, NULL);
521     mvaddstr(LINES - 1, pos, BUF1);
522     color_set(DEFAULT, NULL);
523     attr_off(A_BOLD, NULL);
524 }
525 
526 /* Clear message area, leaving only status info. */
527 static void
528 clear_message()
529 {
530     mvhline(LINES - 1, 0, ' ', STATUSPOS);
531 }
532 
533 /* Comparison used to sort listing entries. */
534 static int
535 rowcmp(const void *a, const void *b)
536 {
537     int isdir1, isdir2, cmpdir;
538     const Row *r1 = a;
539     const Row *r2 = b;
540     isdir1 = S_ISDIR(r1->mode);
541     isdir2 = S_ISDIR(r2->mode);
542     cmpdir = isdir2 - isdir1;
543     return cmpdir ? cmpdir : strcoll(r1->name, r2->name);
544 }
545 
546 /* Get all entries in current working directory. */
547 static int
548 ls(Row **rowsp, uint8_t flags)
549 {
550     DIR *dp;
551     struct dirent *ep;
552     struct stat statbuf;
553     Row *rows;
554     int i, n;
555 
556     if(!(dp = opendir("."))) return -1;
557     n = -2; /* We don't want the entries "." and "..". */
558     while (readdir(dp)) n++;
559     rewinddir(dp);
560     rows = malloc(n * sizeof *rows);
561     i = 0;
562     while ((ep = readdir(dp))) {
563         if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
564             continue;
565         if (!(flags & SHOW_HIDDEN) && ep->d_name[0] == '.')
566             continue;
567         lstat(ep->d_name, &statbuf);
568         rows[i].islink = S_ISLNK(statbuf.st_mode);
569         stat(ep->d_name, &statbuf);
570         if (S_ISDIR(statbuf.st_mode)) {
571             if (flags & SHOW_DIRS) {
572                 rows[i].name = malloc(strlen(ep->d_name) + 2);
573                 strcpy(rows[i].name, ep->d_name);
574                 if (!rows[i].islink)
575                     strcat(rows[i].name, "/");
576                 rows[i].mode = statbuf.st_mode;
577                 i++;
578             }
579         } else if (flags & SHOW_FILES) {
580             rows[i].name = malloc(strlen(ep->d_name) + 1);
581             strcpy(rows[i].name, ep->d_name);
582             rows[i].size = statbuf.st_size;
583             rows[i].mode = statbuf.st_mode;
584             i++;
585         }
586     }
587     n = i; /* Ignore unused space in array caused by filters. */
588     qsort(rows, n, sizeof (*rows), rowcmp);
589     closedir(dp);
590     *rowsp = rows;
591     return n;
592 }
593 
594 static void
595 free_rows(Row **rowsp, int nfiles)
596 {
597     int i;
598 
599     for (i = 0; i < nfiles; i++)
600         free((*rowsp)[i].name);
601     free(*rowsp);
602     *rowsp = NULL;
603 }
604 
605 /* Change working directory to the path in CWD. */
606 static void
607 cd(int reset)
608 {
609     int i, j;
610 
611     message(CYAN, "Loading...");
612     refresh();
613     if (reset) ESEL = SCROLL = 0;
614     chdir(CWD);
615     if (rover.nfiles)
616         free_rows(&rover.rows, rover.nfiles);
617     rover.nfiles = ls(&rover.rows, FLAGS);
618     if (!strcmp(CWD, rover.marks.dirpath)) {
619         for (i = 0; i < rover.nfiles; i++) {
620             for (j = 0; j < rover.marks.bulk; j++)
621                 if (
622                     rover.marks.entries[j] &&
623                     !strcmp(rover.marks.entries[j], ENAME(i))
624                 )
625                     break;
626             MARKED(i) = j < rover.marks.bulk;
627         }
628     } else
629         for (i = 0; i < rover.nfiles; i++)
630             MARKED(i) = 0;
631     clear_message();
632     update_view();
633 }
634 
635 /* Select a target entry, if it is present. */
636 static void
637 try_to_sel(const char *target)
638 {
639     ESEL = 0;
640     if (!ISDIR(target))
641         while ((ESEL+1) < rover.nfiles && S_ISDIR(EMODE(ESEL)))
642             ESEL++;
643     while ((ESEL+1) < rover.nfiles && strcoll(ENAME(ESEL), target) < 0)
644         ESEL++;
645 }
646 
647 /* Reload CWD, but try to keep selection. */
648 static void
649 reload()
650 {
651     if (rover.nfiles) {
652         strcpy(INPUT, ENAME(ESEL));
653         cd(0);
654         try_to_sel(INPUT);
655         update_view();
656     } else
657         cd(1);
658 }
659 
660 static off_t
661 count_dir(const char *path)
662 {
663     DIR *dp;
664     struct dirent *ep;
665     struct stat statbuf;
666     char subpath[PATH_MAX];
667     off_t total;
668 
669     if(!(dp = opendir(path))) return 0;
670     total = 0;
671     while ((ep = readdir(dp))) {
672         if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
673             continue;
674         snprintf(subpath, PATH_MAX, "%s%s", path, ep->d_name);
675         lstat(subpath, &statbuf);
676         if (S_ISDIR(statbuf.st_mode)) {
677             strcat(subpath, "/");
678             total += count_dir(subpath);
679         } else
680             total += statbuf.st_size;
681     }
682     closedir(dp);
683     return total;
684 }
685 
686 static off_t
687 count_marked()
688 {
689     int i;
690     char *entry;
691     off_t total;
692     struct stat statbuf;
693 
694     total = 0;
695     chdir(rover.marks.dirpath);
696     for (i = 0; i < rover.marks.bulk; i++) {
697         entry = rover.marks.entries[i];
698         if (entry) {
699             if (ISDIR(entry)) {
700                 total += count_dir(entry);
701             } else {
702                 lstat(entry, &statbuf);
703                 total += statbuf.st_size;
704             }
705         }
706     }
707     chdir(CWD);
708     return total;
709 }
710 
711 /* Recursively process a source directory using CWD as destination root.
712    For each node (i.e. directory), do the following:
713     1. call pre(destination);
714     2. call proc() on every child leaf (i.e. files);
715     3. recurse into every child node;
716     4. call pos(source).
717    E.g. to move directory /src/ (and all its contents) inside /dst/:
718     strcpy(CWD, "/dst/");
719     process_dir(adddir, movfile, deldir, "/src/"); */
720 static int
721 process_dir(PROCESS pre, PROCESS proc, PROCESS pos, const char *path)
722 {
723     int ret;
724     DIR *dp;
725     struct dirent *ep;
726     struct stat statbuf;
727     char subpath[PATH_MAX];
728 
729     ret = 0;
730     if (pre) {
731         char dstpath[PATH_MAX];
732         strcpy(dstpath, CWD);
733         strcat(dstpath, path + strlen(rover.marks.dirpath));
734         ret |= pre(dstpath);
735     }
736     if(!(dp = opendir(path))) return -1;
737     while ((ep = readdir(dp))) {
738         if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
739             continue;
740         snprintf(subpath, PATH_MAX, "%s%s", path, ep->d_name);
741         lstat(subpath, &statbuf);
742         if (S_ISDIR(statbuf.st_mode)) {
743             strcat(subpath, "/");
744             ret |= process_dir(pre, proc, pos, subpath);
745         } else
746             ret |= proc(subpath);
747     }
748     closedir(dp);
749     if (pos) ret |= pos(path);
750     return ret;
751 }
752 
753 /* Process all marked entries using CWD as destination root.
754    All marked entries that are directories will be recursively processed.
755    See process_dir() for details on the parameters. */
756 static void
757 process_marked(PROCESS pre, PROCESS proc, PROCESS pos,
758                const char *msg_doing, const char *msg_done)
759 {
760     int i, ret;
761     char *entry;
762     char path[PATH_MAX];
763 
764     clear_message();
765     message(CYAN, "%s...", msg_doing);
766     refresh();
767     rover.prog = (Prog) {0, count_marked(), msg_doing};
768     for (i = 0; i < rover.marks.bulk; i++) {
769         entry = rover.marks.entries[i];
770         if (entry) {
771             ret = 0;
772             snprintf(path, PATH_MAX, "%s%s", rover.marks.dirpath, entry);
773             if (ISDIR(entry)) {
774                 if (!strncmp(path, CWD, strlen(path)))
775                     ret = -1;
776                 else
777                     ret = process_dir(pre, proc, pos, path);
778             } else
779                 ret = proc(path);
780             if (!ret) {
781                 del_mark(&rover.marks, entry);
782                 reload();
783             }
784         }
785     }
786     rover.prog.total = 0;
787     reload();
788     if (!rover.marks.nentries)
789         message(GREEN, "%s all marked entries.", msg_done);
790     else
791         message(RED, "Some errors occured while %s.", msg_doing);
792     RV_ALERT();
793 }
794 
795 static void
796 update_progress(off_t delta)
797 {
798     int percent;
799 
800     if (!rover.prog.total) return;
801     rover.prog.partial += delta;
802     percent = (int) (rover.prog.partial * 100 / rover.prog.total);
803     message(CYAN, "%s...%d%%", rover.prog.msg, percent);
804     refresh();
805 }
806 
807 /* Wrappers for file operations. */
808 static int delfile(const char *path) {
809     int ret;
810     struct stat st;
811 
812     ret = lstat(path, &st);
813     if (ret < 0) return ret;
814     update_progress(st.st_size);
815     return unlink(path);
816 }
817 static PROCESS deldir = rmdir;
818 static int addfile(const char *path) {
819     /* Using creat(2) because mknod(2) doesn't seem to be portable. */
820     int ret;
821 
822     ret = creat(path, 0644);
823     if (ret < 0) return ret;
824     return close(ret);
825 }
826 static int cpyfile(const char *srcpath) {
827     int src, dst, ret;
828     size_t size;
829     struct stat st;
830     char buf[BUFSIZ];
831     char dstpath[PATH_MAX];
832 
833     strcpy(dstpath, CWD);
834     strcat(dstpath, srcpath + strlen(rover.marks.dirpath));
835     ret = lstat(srcpath, &st);
836     if (ret < 0) return ret;
837     if (S_ISLNK(st.st_mode)) {
838         ret = readlink(srcpath, BUF1, BUFLEN-1);
839         if (ret < 0) return ret;
840         BUF1[ret] = '\0';
841         ret = symlink(BUF1, dstpath);
842     } else {
843         ret = src = open(srcpath, O_RDONLY);
844         if (ret < 0) return ret;
845         ret = dst = creat(dstpath, st.st_mode);
846         if (ret < 0) return ret;
847         while ((size = read(src, buf, BUFSIZ)) > 0) {
848             write(dst, buf, size);
849             update_progress(size);
850             sync_signals();
851         }
852         close(src);
853         close(dst);
854         ret = 0;
855     }
856     return ret;
857 }
858 static int adddir(const char *path) {
859     int ret;
860     struct stat st;
861 
862     ret = stat(CWD, &st);
863     if (ret < 0) return ret;
864     return mkdir(path, st.st_mode);
865 }
866 static int movfile(const char *srcpath) {
867     int ret;
868     struct stat st;
869     char dstpath[PATH_MAX];
870 
871     strcpy(dstpath, CWD);
872     strcat(dstpath, srcpath + strlen(rover.marks.dirpath));
873     ret = rename(srcpath, dstpath);
874     if (ret == 0) {
875         ret = lstat(dstpath, &st);
876         if (ret < 0) return ret;
877         update_progress(st.st_size);
878     } else if (errno == EXDEV) {
879         ret = cpyfile(srcpath);
880         if (ret < 0) return ret;
881         ret = unlink(srcpath);
882     }
883     return ret;
884 }
885 
886 static void
887 start_line_edit(const char *init_input)
888 {
889     curs_set(TRUE);
890     strncpy(INPUT, init_input, BUFLEN);
891     rover.edit.left = mbstowcs(rover.edit.buffer, init_input, BUFLEN);
892     rover.edit.right = BUFLEN - 1;
893     rover.edit.buffer[BUFLEN] = L'\0';
894     rover.edit_scroll = 0;
895 }
896 
897 /* Read input and change editing state accordingly. */
898 static EditStat
899 get_line_edit()
900 {
901     wchar_t eraser, killer, wch;
902     int ret, length;
903 
904     ret = rover_get_wch((wint_t *) &wch);
905     erasewchar(&eraser);
906     killwchar(&killer);
907     if (ret == KEY_CODE_YES) {
908         if (wch == KEY_ENTER) {
909             curs_set(FALSE);
910             return CONFIRM;
911         } else if (wch == KEY_LEFT) {
912             if (EDIT_CAN_LEFT(rover.edit)) EDIT_LEFT(rover.edit);
913         } else if (wch == KEY_RIGHT) {
914             if (EDIT_CAN_RIGHT(rover.edit)) EDIT_RIGHT(rover.edit);
915         } else if (wch == KEY_UP) {
916             while (EDIT_CAN_LEFT(rover.edit)) EDIT_LEFT(rover.edit);
917         } else if (wch == KEY_DOWN) {
918             while (EDIT_CAN_RIGHT(rover.edit)) EDIT_RIGHT(rover.edit);
919         } else if (wch == KEY_BACKSPACE) {
920             if (EDIT_CAN_LEFT(rover.edit)) EDIT_BACKSPACE(rover.edit);
921         } else if (wch == KEY_DC) {
922             if (EDIT_CAN_RIGHT(rover.edit)) EDIT_DELETE(rover.edit);
923         }
924     } else {
925         if (wch == L'\r' || wch == L'\n') {
926             curs_set(FALSE);
927             return CONFIRM;
928         } else if (wch == L'\t') {
929             curs_set(FALSE);
930             return CANCEL;
931         } else if (wch == eraser) {
932             if (EDIT_CAN_LEFT(rover.edit)) EDIT_BACKSPACE(rover.edit);
933         } else if (wch == killer) {
934             EDIT_CLEAR(rover.edit);
935             clear_message();
936         } else if (iswprint(wch)) {
937             if (!EDIT_FULL(rover.edit)) EDIT_INSERT(rover.edit, wch);
938         }
939     }
940     /* Encode edit contents in INPUT. */
941     rover.edit.buffer[rover.edit.left] = L'\0';
942     length = wcstombs(INPUT, rover.edit.buffer, BUFLEN);
943     wcstombs(&INPUT[length], &rover.edit.buffer[rover.edit.right+1],
944              BUFLEN-length);
945     return CONTINUE;
946 }
947 
948 /* Update line input on the screen. */
949 static void
950 update_input(const char *prompt, Color color)
951 {
952     int plen, ilen, maxlen;
953 
954     plen = strlen(prompt);
955     ilen = mbstowcs(NULL, INPUT, 0);
956     maxlen = STATUSPOS - plen - 2;
957     if (ilen - rover.edit_scroll < maxlen)
958         rover.edit_scroll = MAX(ilen - maxlen, 0);
959     else if (rover.edit.left > rover.edit_scroll + maxlen - 1)
960         rover.edit_scroll = rover.edit.left - maxlen;
961     else if (rover.edit.left < rover.edit_scroll)
962         rover.edit_scroll = MAX(rover.edit.left - maxlen, 0);
963     color_set(RVC_PROMPT, NULL);
964     mvaddstr(LINES - 1, 0, prompt);
965     color_set(color, NULL);
966     mbstowcs(WBUF, INPUT, COLS);
967     mvaddnwstr(LINES - 1, plen, &WBUF[rover.edit_scroll], maxlen);
968     mvaddch(LINES - 1, plen + MIN(ilen - rover.edit_scroll, maxlen + 1), ' ');
969     color_set(DEFAULT, NULL);
970     if (rover.edit_scroll)
971         mvaddch(LINES - 1, plen - 1, '<');
972     if (ilen > rover.edit_scroll + maxlen)
973         mvaddch(LINES - 1, plen + maxlen, '>');
974     move(LINES - 1, plen + rover.edit.left - rover.edit_scroll);
975 }
976 
977 int
978 main(int argc, char *argv[])
979 {
980     int i, ch;
981     char *program;
982     char *entry;
983     const char *key;
984     DIR *d;
985     EditStat edit_stat;
986     FILE *save_cwd_file = NULL;
987     FILE *save_marks_file = NULL;
988 
989     if (argc >= 2) {
990         if (!strcmp(argv[1], "-v") || !strcmp(argv[1], "--version")) {
991             printf("rover %s\n", RV_VERSION);
992             return 0;
993         } else if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
994             printf(
995                 "Usage: rover [OPTIONS] [DIR [DIR [...]]]\n"
996                 "       Browse current directory or the ones specified.\n\n"
997                 "  or:  rover -h|--help\n"
998                 "       Print this help message and exit.\n\n"
999                 "  or:  rover -v|--version\n"
1000                 "       Print program version and exit.\n\n"
1001                 "See rover(1) for more information.\n"
1002                 "Rover homepage: <https://github.com/lecram/rover>.\n"
1003             );
1004             return 0;
1005         } else if (!strcmp(argv[1], "-d") || !strcmp(argv[1], "--save-cwd")) {
1006             if (argc > 2) {
1007                 save_cwd_file = fopen(argv[2], "w");
1008                 argc -= 2; argv += 2;
1009             } else {
1010                 fprintf(stderr, "error: missing argument to %s\n", argv[1]);
1011                 return 1;
1012             }
1013         } else if (!strcmp(argv[1], "-m") || !strcmp(argv[1], "--save-marks")) {
1014             if (argc > 2) {
1015                 save_marks_file = fopen(argv[2], "a");
1016                 argc -= 2; argv += 2;
1017             } else {
1018                 fprintf(stderr, "error: missing argument to %s\n", argv[1]);
1019                 return 1;
1020             }
1021         }
1022     }
1023     init_term();
1024     rover.nfiles = 0;
1025     for (i = 0; i < 10; i++) {
1026         rover.tabs[i].esel = rover.tabs[i].scroll = 0;
1027         rover.tabs[i].flags = SHOW_FILES | SHOW_DIRS;
1028     }
1029     strcpy(rover.tabs[0].cwd, getenv("HOME"));
1030     for (i = 1; i < argc && i < 10; i++) {
1031         if ((d = opendir(argv[i]))) {
1032             realpath(argv[i], rover.tabs[i].cwd);
1033             closedir(d);
1034         } else
1035             strcpy(rover.tabs[i].cwd, rover.tabs[0].cwd);
1036     }
1037     getcwd(rover.tabs[i].cwd, PATH_MAX);
1038     for (i++; i < 10; i++)
1039         strcpy(rover.tabs[i].cwd, rover.tabs[i-1].cwd);
1040     for (i = 0; i < 10; i++)
1041         if (rover.tabs[i].cwd[strlen(rover.tabs[i].cwd) - 1] != '/')
1042             strcat(rover.tabs[i].cwd, "/");
1043     rover.tab = 1;
1044     rover.window = subwin(stdscr, LINES - 2, COLS, 1, 0);
1045     init_marks(&rover.marks);
1046     cd(1);
1047     while (1) {
1048         ch = rover_getch();
1049         key = keyname(ch);
1050         clear_message();
1051         if (!strcmp(key, RVK_QUIT)) break;
1052         else if (ch >= '0' && ch <= '9') {
1053             rover.tab = ch - '0';
1054             cd(0);
1055         } else if (!strcmp(key, RVK_HELP)) {
1056             spawn((char *[]) {"man", "rover", NULL});
1057         } else if (!strcmp(key, RVK_DOWN)) {
1058             if (!rover.nfiles) continue;
1059             ESEL = MIN(ESEL + 1, rover.nfiles - 1);
1060             update_view();
1061         } else if (!strcmp(key, RVK_UP)) {
1062             if (!rover.nfiles) continue;
1063             ESEL = MAX(ESEL - 1, 0);
1064             update_view();
1065         } else if (!strcmp(key, RVK_JUMP_DOWN)) {
1066             if (!rover.nfiles) continue;
1067             ESEL = MIN(ESEL + RV_JUMP, rover.nfiles - 1);
1068             if (rover.nfiles > HEIGHT)
1069                 SCROLL = MIN(SCROLL + RV_JUMP, rover.nfiles - HEIGHT);
1070             update_view();
1071         } else if (!strcmp(key, RVK_JUMP_UP)) {
1072             if (!rover.nfiles) continue;
1073             ESEL = MAX(ESEL - RV_JUMP, 0);
1074             SCROLL = MAX(SCROLL - RV_JUMP, 0);
1075             update_view();
1076         } else if (!strcmp(key, RVK_JUMP_TOP)) {
1077             if (!rover.nfiles) continue;
1078             ESEL = 0;
1079             update_view();
1080         } else if (!strcmp(key, RVK_JUMP_BOTTOM)) {
1081             if (!rover.nfiles) continue;
1082             ESEL = rover.nfiles - 1;
1083             update_view();
1084         } else if (!strcmp(key, RVK_CD_DOWN)) {
1085             if (!rover.nfiles || !S_ISDIR(EMODE(ESEL))) continue;
1086             if (chdir(ENAME(ESEL)) == -1) {
1087                 message(RED, "Cannot access \"%s\".", ENAME(ESEL));
1088                 continue;
1089             }
1090             strcat(CWD, ENAME(ESEL));
1091             cd(1);
1092         } else if (!strcmp(key, RVK_CD_UP)) {
1093             char *dirname, first;
1094             if (!strcmp(CWD, "/")) continue;
1095             CWD[strlen(CWD) - 1] = '\0';
1096             dirname = strrchr(CWD, '/') + 1;
1097             first = dirname[0];
1098             dirname[0] = '\0';
1099             cd(1);
1100             dirname[0] = first;
1101             dirname[strlen(dirname)] = '/';
1102             try_to_sel(dirname);
1103             dirname[0] = '\0';
1104             if (rover.nfiles > HEIGHT)
1105                 SCROLL = ESEL - HEIGHT / 2;
1106             update_view();
1107         } else if (!strcmp(key, RVK_HOME)) {
1108             strcpy(CWD, getenv("HOME"));
1109             if (CWD[strlen(CWD) - 1] != '/')
1110                 strcat(CWD, "/");
1111             cd(1);
1112         } else if (!strcmp(key, RVK_TARGET)) {
1113             char *bname, first;
1114             int is_dir = S_ISDIR(EMODE(ESEL));
1115             ssize_t len = readlink(ENAME(ESEL), BUF1, BUFLEN-1);
1116             if (len == -1) continue;
1117             BUF1[len] = '\0';
1118             if (access(BUF1, F_OK) == -1) {
1119                 char *msg;
1120                 switch (errno) {
1121                 case EACCES:
1122                     msg = "Cannot access \"%s\".";
1123                     break;
1124                 case ENOENT:
1125                     msg = "\"%s\" does not exist.";
1126                     break;
1127                 default:
1128                     msg = "Cannot navigate to \"%s\".";
1129                 }
1130                 strcpy(BUF2, BUF1); /* message() uses BUF1. */
1131                 message(RED, msg, BUF2);
1132                 continue;
1133             }
1134             realpath(BUF1, CWD);
1135             len = strlen(CWD);
1136             if (CWD[len - 1] == '/')
1137                 CWD[len - 1] = '\0';
1138             bname = strrchr(CWD, '/') + 1;
1139             first = *bname;
1140             *bname = '\0';
1141             cd(1);
1142             *bname = first;
1143             if (is_dir)
1144                 strcat(CWD, "/");
1145             try_to_sel(bname);
1146             *bname = '\0';
1147             update_view();
1148         } else if (!strcmp(key, RVK_REFRESH)) {
1149             reload();
1150         } else if (!strcmp(key, RVK_SHELL)) {
1151             program = getenv("SHELL");
1152             if (program) {
1153 #ifdef RV_SHELL
1154                 spawn((char *[]) {RV_SHELL, "-c", program, NULL});
1155 #else
1156                 spawn((char *[]) {program, NULL});
1157 #endif
1158                 reload();
1159             }
1160         } else if (!strcmp(key, RVK_VIEW)) {
1161             if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1162             if (open_with_env("PAGER", ENAME(ESEL)))
1163                 cd(0);
1164         } else if (!strcmp(key, RVK_EDIT)) {
1165             if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1166             if (open_with_env("EDITOR", ENAME(ESEL)))
1167                 cd(0);
1168         } else if (!strcmp(key, RVK_OPEN)) {
1169             if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1170             if (open_with_env("ROVER_OPEN", ENAME(ESEL)))
1171                 cd(0);
1172         } else if (!strcmp(key, RVK_SEARCH)) {
1173             int oldsel, oldscroll, length;
1174             if (!rover.nfiles) continue;
1175             oldsel = ESEL;
1176             oldscroll = SCROLL;
1177             start_line_edit("");
1178             update_input(RVP_SEARCH, RED);
1179             while ((edit_stat = get_line_edit()) == CONTINUE) {
1180                 int sel;
1181                 Color color = RED;
1182                 length = strlen(INPUT);
1183                 if (length) {
1184                     for (sel = 0; sel < rover.nfiles; sel++)
1185                         if (!strncmp(ENAME(sel), INPUT, length))
1186                             break;
1187                     if (sel < rover.nfiles) {
1188                         color = GREEN;
1189                         ESEL = sel;
1190                         if (rover.nfiles > HEIGHT) {
1191                             if (sel < 3)
1192                                 SCROLL = 0;
1193                             else if (sel - 3 > rover.nfiles - HEIGHT)
1194                                 SCROLL = rover.nfiles - HEIGHT;
1195                             else
1196                                 SCROLL = sel - 3;
1197                         }
1198                     }
1199                 } else {
1200                     ESEL = oldsel;
1201                     SCROLL = oldscroll;
1202                 }
1203                 update_view();
1204                 update_input(RVP_SEARCH, color);
1205             }
1206             if (edit_stat == CANCEL) {
1207                 ESEL = oldsel;
1208                 SCROLL = oldscroll;
1209             }
1210             clear_message();
1211             update_view();
1212         } else if (!strcmp(key, RVK_TG_FILES)) {
1213             FLAGS ^= SHOW_FILES;
1214             reload();
1215         } else if (!strcmp(key, RVK_TG_DIRS)) {
1216             FLAGS ^= SHOW_DIRS;
1217             reload();
1218         } else if (!strcmp(key, RVK_TG_HIDDEN)) {
1219             FLAGS ^= SHOW_HIDDEN;
1220             reload();
1221         } else if (!strcmp(key, RVK_NEW_FILE)) {
1222             int ok = 0;
1223             start_line_edit("");
1224             update_input(RVP_NEW_FILE, RED);
1225             while ((edit_stat = get_line_edit()) == CONTINUE) {
1226                 int length = strlen(INPUT);
1227                 ok = length;
1228                 for (i = 0; i < rover.nfiles; i++) {
1229                     if (
1230                         !strncmp(ENAME(i), INPUT, length) &&
1231                         (!strcmp(ENAME(i) + length, "") ||
1232                          !strcmp(ENAME(i) + length, "/"))
1233                     ) {
1234                         ok = 0;
1235                         break;
1236                     }
1237                 }
1238                 update_input(RVP_NEW_FILE, ok ? GREEN : RED);
1239             }
1240             clear_message();
1241             if (edit_stat == CONFIRM) {
1242                 if (ok) {
1243                     if (addfile(INPUT) == 0) {
1244                         cd(1);
1245                         try_to_sel(INPUT);
1246                         update_view();
1247                     } else
1248                         message(RED, "Could not create \"%s\".", INPUT);
1249                 } else
1250                     message(RED, "\"%s\" already exists.", INPUT);
1251             }
1252         } else if (!strcmp(key, RVK_NEW_DIR)) {
1253             int ok = 0;
1254             start_line_edit("");
1255             update_input(RVP_NEW_DIR, RED);
1256             while ((edit_stat = get_line_edit()) == CONTINUE) {
1257                 int length = strlen(INPUT);
1258                 ok = length;
1259                 for (i = 0; i < rover.nfiles; i++) {
1260                     if (
1261                         !strncmp(ENAME(i), INPUT, length) &&
1262                         (!strcmp(ENAME(i) + length, "") ||
1263                          !strcmp(ENAME(i) + length, "/"))
1264                     ) {
1265                         ok = 0;
1266                         break;
1267                     }
1268                 }
1269                 update_input(RVP_NEW_DIR, ok ? GREEN : RED);
1270             }
1271             clear_message();
1272             if (edit_stat == CONFIRM) {
1273                 if (ok) {
1274                     if (adddir(INPUT) == 0) {
1275                         cd(1);
1276                         strcat(INPUT, "/");
1277                         try_to_sel(INPUT);
1278                         update_view();
1279                     } else
1280                         message(RED, "Could not create \"%s/\".", INPUT);
1281                 } else
1282                     message(RED, "\"%s\" already exists.", INPUT);
1283             }
1284         } else if (!strcmp(key, RVK_RENAME)) {
1285             int ok = 0;
1286             char *last;
1287             int isdir;
1288             strcpy(INPUT, ENAME(ESEL));
1289             last = INPUT + strlen(INPUT) - 1;
1290             if ((isdir = *last == '/'))
1291                 *last = '\0';
1292             start_line_edit(INPUT);
1293             update_input(RVP_RENAME, RED);
1294             while ((edit_stat = get_line_edit()) == CONTINUE) {
1295                 int length = strlen(INPUT);
1296                 ok = length;
1297                 for (i = 0; i < rover.nfiles; i++)
1298                     if (
1299                         !strncmp(ENAME(i), INPUT, length) &&
1300                         (!strcmp(ENAME(i) + length, "") ||
1301                          !strcmp(ENAME(i) + length, "/"))
1302                     ) {
1303                         ok = 0;
1304                         break;
1305                     }
1306                 update_input(RVP_RENAME, ok ? GREEN : RED);
1307             }
1308             clear_message();
1309             if (edit_stat == CONFIRM) {
1310                 if (isdir)
1311                     strcat(INPUT, "/");
1312                 if (ok) {
1313                     if (!rename(ENAME(ESEL), INPUT) && MARKED(ESEL)) {
1314                         del_mark(&rover.marks, ENAME(ESEL));
1315                         add_mark(&rover.marks, CWD, INPUT);
1316                     }
1317                     cd(1);
1318                     try_to_sel(INPUT);
1319                     update_view();
1320                 } else
1321                     message(RED, "\"%s\" already exists.", INPUT);
1322             }
1323         } else if (!strcmp(key, RVK_DELETE)) {
1324             if (rover.nfiles) {
1325                 message(YELLOW, "Delete \"%s\"? (Y/n)", ENAME(ESEL));
1326                 if (rover_getch() == 'Y') {
1327                     const char *name = ENAME(ESEL);
1328                     int ret = ISDIR(ENAME(ESEL)) ? deldir(name) : delfile(name);
1329                     reload();
1330                     if (ret)
1331                         message(RED, "Could not delete \"%s\".", ENAME(ESEL));
1332                 } else
1333                     clear_message();
1334             } else
1335                   message(RED, "No entry selected for deletion.");
1336         } else if (!strcmp(key, RVK_TG_MARK)) {
1337             if (MARKED(ESEL))
1338                 del_mark(&rover.marks, ENAME(ESEL));
1339             else
1340                 add_mark(&rover.marks, CWD, ENAME(ESEL));
1341             MARKED(ESEL) = !MARKED(ESEL);
1342             ESEL = (ESEL + 1) % rover.nfiles;
1343             update_view();
1344         } else if (!strcmp(key, RVK_INVMARK)) {
1345             for (i = 0; i < rover.nfiles; i++) {
1346                 if (MARKED(i))
1347                     del_mark(&rover.marks, ENAME(i));
1348                 else
1349                     add_mark(&rover.marks, CWD, ENAME(i));
1350                 MARKED(i) = !MARKED(i);
1351             }
1352             update_view();
1353         } else if (!strcmp(key, RVK_MARKALL)) {
1354             for (i = 0; i < rover.nfiles; i++)
1355                 if (!MARKED(i)) {
1356                     add_mark(&rover.marks, CWD, ENAME(i));
1357                     MARKED(i) = 1;
1358                 }
1359             update_view();
1360         } else if (!strcmp(key, RVK_MARK_DELETE)) {
1361             if (rover.marks.nentries) {
1362                 message(YELLOW, "Delete all marked entries? (Y/n)");
1363                 if (rover_getch() == 'Y')
1364                     process_marked(NULL, delfile, deldir, "Deleting", "Deleted");
1365                 else
1366                     clear_message();
1367             } else
1368                 message(RED, "No entries marked for deletion.");
1369         } else if (!strcmp(key, RVK_MARK_COPY)) {
1370             if (rover.marks.nentries)
1371                 process_marked(adddir, cpyfile, NULL, "Copying", "Copied");
1372             else
1373                 message(RED, "No entries marked for copying.");
1374         } else if (!strcmp(key, RVK_MARK_MOVE)) {
1375             if (rover.marks.nentries)
1376                 process_marked(adddir, movfile, deldir, "Moving", "Moved");
1377             else
1378                 message(RED, "No entries marked for moving.");
1379         }
1380     }
1381     if (rover.nfiles)
1382         free_rows(&rover.rows, rover.nfiles);
1383     delwin(rover.window);
1384     if (save_cwd_file != NULL) {
1385         fputs(CWD, save_cwd_file);
1386         fclose(save_cwd_file);
1387     }
1388     if (save_marks_file != NULL) {
1389         for (i = 0; i < rover.marks.bulk; i++) {
1390             entry = rover.marks.entries[i];
1391             if (entry)
1392                 fprintf(save_marks_file, "%s%s\n", rover.marks.dirpath, entry);
1393         }
1394         fclose(save_marks_file);
1395     }
1396     free_marks(&rover.marks);
1397     return 0;
1398 }