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