rover.c

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