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