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