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