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     if (rover.nfiles > HEIGHT) {
 381         SCROLL = MAX(MIN(SCROLL, ESEL), ESEL - HEIGHT + 1);
 382         SCROLL = MIN(SCROLL, rover.nfiles - HEIGHT);
 383     } else
 384         SCROLL = 0;
 385     marking = !strcmp(CWD, rover.marks.dirpath);
 386     for (i = 0, j = SCROLL; i < HEIGHT && j < rover.nfiles; i++, j++) {
 387         ishidden = ENAME(j)[0] == '.';
 388         isdir = S_ISDIR(EMODE(j));
 389         if (j == ESEL)
 390             wattr_on(rover.window, A_REVERSE, NULL);
 391         if (ISLINK(j))
 392             wcolor_set(rover.window, RVC_LINK, NULL);
 393         else if (ishidden)
 394             wcolor_set(rover.window, RVC_HIDDEN, NULL);
 395         else if (isdir)
 396             wcolor_set(rover.window, RVC_DIR, NULL);
 397         else
 398             wcolor_set(rover.window, RVC_FILE, NULL);
 399         if (!isdir) {
 400             char *suffix, *suffixes = "BKMGTPEZY";
 401             off_t human_size = ESIZE(j) * 10;
 402             int length = mbstowcs(NULL, ENAME(j), 0);
 403             for (suffix = suffixes; human_size >= 10240; suffix++)
 404                 human_size = (human_size + 512) / 1024;
 405             if (*suffix == 'B')
 406                 swprintf(WBUF, PATH_MAX, L"%s%*d %c", ENAME(j),
 407                          (int) (COLS - length - 6),
 408                          (int) human_size / 10, *suffix);
 409             else
 410                 swprintf(WBUF, PATH_MAX, L"%s%*d.%d %c", ENAME(j),
 411                          (int) (COLS - length - 8),
 412                          (int) human_size / 10, (int) human_size % 10, *suffix);
 413         } else
 414             mbstowcs(WBUF, ENAME(j), PATH_MAX);
 415         mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
 416         mvwaddnwstr(rover.window, i + 1, 2, WBUF, COLS - 4);
 417         if (marking && MARKED(j)) {
 418             wcolor_set(rover.window, RVC_MARKS, NULL);
 419             mvwaddch(rover.window, i + 1, 1, RVS_MARK);
 420         } else
 421             mvwaddch(rover.window, i + 1, 1, ' ');
 422         if (j == ESEL)
 423             wattr_off(rover.window, A_REVERSE, NULL);
 424     }
 425     for (; i < HEIGHT; i++)
 426         mvwhline(rover.window, i + 1, 1, ' ', COLS - 2);
 427     if (rover.nfiles > HEIGHT) {
 428         int center, height;
 429         center = (SCROLL + HEIGHT / 2) * HEIGHT / rover.nfiles;
 430         height = (HEIGHT-1) * HEIGHT / rover.nfiles;
 431         if (!height) height = 1;
 432         wcolor_set(rover.window, RVC_SCROLLBAR, NULL);
 433         mvwvline(rover.window, center-height/2+1, COLS-1, RVS_SCROLLBAR, height);
 434     }
 435     BUF1[0] = FLAGS & SHOW_FILES  ? 'F' : ' ';
 436     BUF1[1] = FLAGS & SHOW_DIRS   ? 'D' : ' ';
 437     BUF1[2] = FLAGS & SHOW_HIDDEN ? 'H' : ' ';
 438     if (!rover.nfiles)
 439         strcpy(BUF2, "0/0");
 440     else
 441         snprintf(BUF2, BUFLEN, "%d/%d", ESEL + 1, rover.nfiles);
 442     snprintf(BUF1+3, BUFLEN-3, "%12s", BUF2);
 443     color_set(RVC_STATUS, NULL);
 444     mvaddstr(LINES - 1, STATUSPOS, BUF1);
 445     wrefresh(rover.window);
 446 }
 447
 448 /* Show a message on the status bar. */
 449 static void
 450 message(Color color, char *fmt, ...)
 451 {
 452     int len, pos;
 453     va_list args;
 454
 455     va_start(args, fmt);
 456     vsnprintf(BUF1, MIN(BUFLEN, STATUSPOS), fmt, args);
 457     va_end(args);
 458     len = strlen(BUF1);
 459     pos = (STATUSPOS - len) / 2;
 460     attr_on(A_BOLD, NULL);
 461     color_set(color, NULL);
 462     mvaddstr(LINES - 1, pos, BUF1);
 463     color_set(DEFAULT, NULL);
 464     attr_off(A_BOLD, NULL);
 465 }
 466
 467 /* Clear message area, leaving only status info. */
 468 static void
 469 clear_message()
 470 {
 471     mvhline(LINES - 1, 0, ' ', STATUSPOS);
 472 }
 473
 474 /* Comparison used to sort listing entries. */
 475 static int
 476 rowcmp(const void *a, const void *b)
 477 {
 478     int isdir1, isdir2, cmpdir;
 479     const Row *r1 = a;
 480     const Row *r2 = b;
 481     isdir1 = S_ISDIR(r1->mode);
 482     isdir2 = S_ISDIR(r2->mode);
 483     cmpdir = isdir2 - isdir1;
 484     return cmpdir ? cmpdir : strcoll(r1->name, r2->name);
 485 }
 486
 487 /* Get all entries in current working directory. */
 488 static int
 489 ls(Row **rowsp, uint8_t flags)
 490 {
 491     DIR *dp;
 492     struct dirent *ep;
 493     struct stat statbuf;
 494     Row *rows;
 495     int i, n;
 496
 497     if(!(dp = opendir("."))) return -1;
 498     n = -2; /* We don't want the entries "." and "..". */
 499     while (readdir(dp)) n++;
 500     rewinddir(dp);
 501     rows = malloc(n * sizeof *rows);
 502     i = 0;
 503     while ((ep = readdir(dp))) {
 504         if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, ".."))
 505             continue;
 506         if (!(flags & SHOW_HIDDEN) && ep->d_name[0] == '.')
 507             continue;
 508         lstat(ep->d_name, &statbuf);
 509         rows[i].islink = S_ISLNK(statbuf.st_mode);
 510         stat(ep->d_name, &statbuf);
 511         if (S_ISDIR(statbuf.st_mode)) {
 512             if (flags & SHOW_DIRS) {
 513                 rows[i].name = malloc(strlen(ep->d_name) + 2);
 514                 strcpy(rows[i].name, ep->d_name);
 515                 strcat(rows[i].name, "/");
 516                 rows[i].mode = statbuf.st_mode;
 517                 i++;
 518             }
 519         } else if (flags & SHOW_FILES) {
 520             rows[i].name = malloc(strlen(ep->d_name) + 1);
 521             strcpy(rows[i].name, ep->d_name);
 522             rows[i].size = statbuf.st_size;
 523             rows[i].mode = statbuf.st_mode;
 524             i++;
 525         }
 526     }
 527     n = i; /* Ignore unused space in array caused by filters. */
 528     qsort(rows, n, sizeof (*rows), rowcmp);
 529     closedir(dp);
 530     *rowsp = rows;
 531     return n;
 532 }
 533
 534 static void
 535 free_rows(Row **rowsp, int nfiles)
 536 {
 537     int i;
 538
 539     for (i = 0; i < nfiles; i++)
 540         free((*rowsp)[i].name);
 541     free(*rowsp);
 542     *rowsp = NULL;
 543 }
 544
 545 /* Change working directory to the path in CWD. */
 546 static void
 547 cd(int reset)
 548 {
 549     int i, j;
 550
 551     message(CYAN, "Loading...");
 552     refresh();
 553     if (reset) ESEL = SCROLL = 0;
 554     chdir(CWD);
 555     if (rover.nfiles)
 556         free_rows(&rover.rows, rover.nfiles);
 557     rover.nfiles = ls(&rover.rows, FLAGS);
 558     if (!strcmp(CWD, rover.marks.dirpath)) {
 559         for (i = 0; i < rover.nfiles; i++) {
 560             for (j = 0; j < rover.marks.bulk; j++)
 561                 if (
 562                     rover.marks.entries[j] &&
 563                     !strcmp(rover.marks.entries[j], ENAME(i))
 564                 )
 565                     break;
 566             MARKED(i) = j < rover.marks.bulk;
 567         }
 568     } else
 569         for (i = 0; i < rover.nfiles; i++)
 570             MARKED(i) = 0;
 571     clear_message();
 572     update_view();
 573 }
 574
 575 /* Select a target entry, if it is present. */
 576 static void
 577 try_to_sel(const char *target)
 578 {
 579     ESEL = 0;
 580     if (!ISDIR(target))
 581         while ((ESEL+1) < rover.nfiles && S_ISDIR(EMODE(ESEL)))
 582             ESEL++;
 583     while ((ESEL+1) < rover.nfiles && strcoll(ENAME(ESEL), target) < 0)
 584         ESEL++;
 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(0);
 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             if (rover.nfiles > HEIGHT)
1028                 SCROLL = ESEL - HEIGHT / 2;
1029             update_view();
1030         } else if (!strcmp(key, RVK_HOME)) {
1031             strcpy(CWD, getenv("HOME"));
1032             if (CWD[strlen(CWD) - 1] != '/')
1033                 strcat(CWD, "/");
1034             cd(1);
1035         } else if (!strcmp(key, RVK_REFRESH)) {
1036             reload();
1037         } else if (!strcmp(key, RVK_SHELL)) {
1038             program = getenv("SHELL");
1039             if (program) {
1040                 ARGS[0] = program;
1041                 ARGS[1] = NULL;
1042                 spawn();
1043                 reload();
1044             }
1045         } else if (!strcmp(key, RVK_VIEW)) {
1046             if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1047             program = getenv("PAGER");
1048             if (program) {
1049                 ARGS[0] = program;
1050                 ARGS[1] = ENAME(ESEL);
1051                 ARGS[2] = NULL;
1052                 spawn();
1053             }
1054         } else if (!strcmp(key, RVK_EDIT)) {
1055             if (!rover.nfiles || S_ISDIR(EMODE(ESEL))) continue;
1056             program = getenv("EDITOR");
1057             if (program) {
1058                 ARGS[0] = program;
1059                 ARGS[1] = ENAME(ESEL);
1060                 ARGS[2] = NULL;
1061                 spawn();
1062                 cd(0);
1063             }
1064         } else if (!strcmp(key, RVK_SEARCH)) {
1065             int oldsel, oldscroll, length;
1066             if (!rover.nfiles) continue;
1067             oldsel = ESEL;
1068             oldscroll = SCROLL;
1069             start_line_edit("");
1070             update_input(RVP_SEARCH, RED);
1071             while ((edit_stat = get_line_edit()) == CONTINUE) {
1072                 int sel;
1073                 Color color = RED;
1074                 length = strlen(INPUT);
1075                 if (length) {
1076                     for (sel = 0; sel < rover.nfiles; sel++)
1077                         if (!strncmp(ENAME(sel), INPUT, length))
1078                             break;
1079                     if (sel < rover.nfiles) {
1080                         color = GREEN;
1081                         ESEL = sel;
1082                         if (rover.nfiles > HEIGHT) {
1083                             if (sel < 3)
1084                                 SCROLL = 0;
1085                             else if (sel - 3 > rover.nfiles - HEIGHT)
1086                                 SCROLL = rover.nfiles - HEIGHT;
1087                             else
1088                                 SCROLL = sel - 3;
1089                         }
1090                     }
1091                 } else {
1092                     ESEL = oldsel;
1093                     SCROLL = oldscroll;
1094                 }
1095                 update_view();
1096                 update_input(RVP_SEARCH, color);
1097             }
1098             if (edit_stat == CANCEL) {
1099                 ESEL = oldsel;
1100                 SCROLL = oldscroll;
1101             }
1102             clear_message();
1103             update_view();
1104         } else if (!strcmp(key, RVK_TG_FILES)) {
1105             FLAGS ^= SHOW_FILES;
1106             reload();
1107         } else if (!strcmp(key, RVK_TG_DIRS)) {
1108             FLAGS ^= SHOW_DIRS;
1109             reload();
1110         } else if (!strcmp(key, RVK_TG_HIDDEN)) {
1111             FLAGS ^= SHOW_HIDDEN;
1112             reload();
1113         } else if (!strcmp(key, RVK_NEW_FILE)) {
1114             int ok = 0;
1115             start_line_edit("");
1116             update_input(RVP_NEW_FILE, RED);
1117             while ((edit_stat = get_line_edit()) == CONTINUE) {
1118                 int length = strlen(INPUT);
1119                 ok = length;
1120                 for (i = 0; i < rover.nfiles; i++) {
1121                     if (
1122                         !strncmp(ENAME(i), INPUT, length) &&
1123                         (!strcmp(ENAME(i) + length, "") ||
1124                          !strcmp(ENAME(i) + length, "/"))
1125                     ) {
1126                         ok = 0;
1127                         break;
1128                     }
1129                 }
1130                 update_input(RVP_NEW_FILE, ok ? GREEN : RED);
1131             }
1132             clear_message();
1133             if (edit_stat == CONFIRM) {
1134                 if (ok) {
1135                     addfile(INPUT);
1136                     cd(1);
1137                     try_to_sel(INPUT);
1138                     update_view();
1139                 } else
1140                     message(RED, "\"%s\" already exists.", INPUT);
1141             }
1142         } else if (!strcmp(key, RVK_NEW_DIR)) {
1143             int ok = 0;
1144             start_line_edit("");
1145             update_input(RVP_NEW_DIR, RED);
1146             while ((edit_stat = get_line_edit()) == CONTINUE) {
1147                 int length = strlen(INPUT);
1148                 ok = length;
1149                 for (i = 0; i < rover.nfiles; i++) {
1150                     if (
1151                         !strncmp(ENAME(i), INPUT, length) &&
1152                         (!strcmp(ENAME(i) + length, "") ||
1153                          !strcmp(ENAME(i) + length, "/"))
1154                     ) {
1155                         ok = 0;
1156                         break;
1157                     }
1158                 }
1159                 update_input(RVP_NEW_DIR, ok ? GREEN : RED);
1160             }
1161             clear_message();
1162             if (edit_stat == CONFIRM) {
1163                 if (ok) {
1164                     adddir(INPUT);
1165                     cd(1);
1166                     strcat(INPUT, "/");
1167                     try_to_sel(INPUT);
1168                     update_view();
1169                 } else
1170                     message(RED, "\"%s\" already exists.", INPUT);
1171             }
1172         } else if (!strcmp(key, RVK_RENAME)) {
1173             int ok = 0;
1174             char *last;
1175             int isdir;
1176             strcpy(INPUT, ENAME(ESEL));
1177             last = INPUT + strlen(INPUT) - 1;
1178             if ((isdir = *last == '/'))
1179                 *last = '\0';
1180             start_line_edit(INPUT);
1181             update_input(RVP_RENAME, RED);
1182             while ((edit_stat = get_line_edit()) == CONTINUE) {
1183                 int length = strlen(INPUT);
1184                 ok = length;
1185                 for (i = 0; i < rover.nfiles; i++)
1186                     if (
1187                         !strncmp(ENAME(i), INPUT, length) &&
1188                         (!strcmp(ENAME(i) + length, "") ||
1189                          !strcmp(ENAME(i) + length, "/"))
1190                     ) {
1191                         ok = 0;
1192                         break;
1193                     }
1194                 update_input(RVP_RENAME, ok ? GREEN : RED);
1195             }
1196             clear_message();
1197             if (edit_stat == CONFIRM) {
1198                 if (isdir)
1199                     strcat(INPUT, "/");
1200                 if (ok) {
1201                     if (!rename(ENAME(ESEL), INPUT) && MARKED(ESEL)) {
1202                         del_mark(&rover.marks, ENAME(ESEL));
1203                         add_mark(&rover.marks, CWD, INPUT);
1204                     }
1205                     cd(1);
1206                     try_to_sel(INPUT);
1207                     update_view();
1208                 } else
1209                     message(RED, "\"%s\" already exists.", INPUT);
1210             }
1211         } else if (!strcmp(key, RVK_DELETE)) {
1212             if (rover.nfiles) {
1213                 message(YELLOW, "Delete \"%s\"? (Y to confirm)", ENAME(ESEL));
1214                 if (rover_getch() == 'Y') {
1215                     const char *name = ENAME(ESEL);
1216                     int ret = S_ISDIR(EMODE(ESEL)) ? deldir(name) : delfile(name);
1217                     reload();
1218                     if (ret)
1219                         message(RED, "Could not delete \"%s\".", ENAME(ESEL));
1220                 } else
1221                     clear_message();
1222             } else
1223                   message(RED, "No entry selected for deletion.");
1224         } else if (!strcmp(key, RVK_TG_MARK)) {
1225             if (MARKED(ESEL))
1226                 del_mark(&rover.marks, ENAME(ESEL));
1227             else
1228                 add_mark(&rover.marks, CWD, ENAME(ESEL));
1229             MARKED(ESEL) = !MARKED(ESEL);
1230             ESEL = (ESEL + 1) % rover.nfiles;
1231             update_view();
1232         } else if (!strcmp(key, RVK_INVMARK)) {
1233             for (i = 0; i < rover.nfiles; i++) {
1234                 if (MARKED(i))
1235                     del_mark(&rover.marks, ENAME(i));
1236                 else
1237                     add_mark(&rover.marks, CWD, ENAME(i));
1238                 MARKED(i) = !MARKED(i);
1239             }
1240             update_view();
1241         } else if (!strcmp(key, RVK_MARKALL)) {
1242             for (i = 0; i < rover.nfiles; i++)
1243                 if (!MARKED(i)) {
1244                     add_mark(&rover.marks, CWD, ENAME(i));
1245                     MARKED(i) = 1;
1246                 }
1247             update_view();
1248         } else if (!strcmp(key, RVK_MARK_DELETE)) {
1249             if (rover.marks.nentries) {
1250                 message(YELLOW, "Delete all marked entries? (Y to confirm)");
1251                 if (rover_getch() == 'Y')
1252                     process_marked(NULL, delfile, deldir, "Deleting", "Deleted");
1253                 else
1254                     clear_message();
1255             } else
1256                 message(RED, "No entries marked for deletion.");
1257         } else if (!strcmp(key, RVK_MARK_COPY)) {
1258             if (rover.marks.nentries)
1259                 process_marked(adddir, cpyfile, NULL, "Copying", "Copied");
1260             else
1261                 message(RED, "No entries marked for copying.");
1262         } else if (!strcmp(key, RVK_MARK_MOVE)) {
1263             if (rover.marks.nentries)
1264                 process_marked(adddir, movfile, deldir, "Moving", "Moved");
1265             else
1266                 message(RED, "No entries marked for moving.");
1267         }
1268     }
1269     if (rover.nfiles)
1270         free_rows(&rover.rows, rover.nfiles);
1271     free_marks(&rover.marks);
1272     delwin(rover.window);
1273     if (save_cwd_file != NULL) {
1274         fputs(CWD, save_cwd_file);
1275         fclose(save_cwd_file);
1276     }
1277     return 0;
1278 }