cex.c (32356B)
1 #include <sys/stat.h> 2 #include <sys/param.h> 3 #include <ctype.h> 4 #include <unistd.h> 5 #include <stdlib.h> 6 #include <libgen.h> 7 #include <string.h> 8 #include <time.h> 9 #include <langinfo.h> 10 #include <pwd.h> 11 #include <grp.h> 12 #include <dirent.h> 13 #include <errno.h> 14 #include <curses.h> 15 16 #include "config.h" 17 18 #define ctrl(x) ((x) & 0x1f) 19 20 typedef enum {OTHER, LEFT, RIGHT, UP, DOWN} Direction; 21 typedef enum {CURRENT, PARENT, CHILD} WinType; 22 typedef enum {COPY, REMOVE, MOVE} SelAction; 23 24 typedef struct _win_file { 25 char d_name[256]; 26 unsigned char d_type; 27 bool selected; 28 } WinFile; 29 30 typedef struct _dir_win { 31 WinType wintype; 32 WINDOW *window; 33 WinFile *winfiles; 34 char path[PATH_MAX]; 35 char *message; 36 int maxx; 37 int maxy; 38 int startpr; 39 int highlight; 40 int filecount; 41 bool holdupdate; 42 bool usehighlight; 43 } DirWin; 44 45 static void init_dirwins(void); 46 static void init_screen(void); 47 static void resize(void); 48 static void start(void); 49 static void wpath(const char *filename); 50 static void reset_flags(void); 51 static void set_startpr(DirWin *dirwin); 52 static void set_win_files(DirWin *dirwin); 53 static void set_win_message(DirWin *dirwin, char *message); 54 static void print_win(DirWin *dirwin); 55 static void update_child_win(void); 56 static void print_top_title(void); 57 static void print_bot_title(void); 58 static void print_content(void); 59 static void show_file_mime(void); 60 static void select_file(const char *path); 61 static void exe_selection(SelAction action, const char *askn); 62 static void clear_selected(void); 63 static void clear_search(void); 64 static void combo_key(int keypress); 65 static void combo_go(int keypress); 66 static void combo_inf(int keypress); 67 static void combo_open(int keypress); 68 static void combo_make(int keypress); 69 static void change_dir(const char *chdname, Direction direction, bool abspath); 70 static void change_parent_dir(Direction direction); 71 static void open_child(bool exec); 72 static void open_nohup_xdg(void); 73 static void search(void); 74 static void move_top(DirWin *dirwin); 75 static void move_bot(DirWin *dirwin); 76 static void move_page_up(DirWin *dirwin); 77 static void move_page_down(DirWin *dirwin); 78 static void move_up(DirWin *dirwin); 79 static void move_down(DirWin *dirwin); 80 static void next_search(void); 81 static void prev_search(void); 82 static void free_dirwin(DirWin *dirwin); 83 static void run_command(size_t size, const char *fmt, ...); 84 static void clean(void); 85 static void fatal(const char *fmt, ...); 86 static bool is_dir(DirWin *dirwin, size_t index); 87 static bool is_selected(DirWin *dirwin, size_t count); 88 static bool remove_selected(const char *sel); 89 static bool prompt_confirm(size_t size, const char *fmt, ...); 90 static int compare_file(const void *a, const void *b); 91 static int get_mime(char *buf, size_t bufsize, const char *path); 92 static int get_mime_default(char *buf, size_t bufsize, const char *mime); 93 static int read_command(char *buf, size_t bufsize, const char *cmd); 94 static int make_file(const char *path); 95 static int make_dir(const char *path); 96 static int make_mod(void); 97 static void make_access(void); 98 static void make_open_default(void); 99 static void make_mime_default(const char *mime, const char *app); 100 static int rm_file(const char *fname); 101 static int rename_file(const char *fname); 102 static char *prompt_answer(char *buf, size_t size, const char *question); 103 static char *cpstr(char *dest, const char *src); 104 static char *get_file_info(char *buf, const char *filepath); 105 static char *get_fullpath(char *buf, DirWin *dirwin, size_t index); 106 static char *get_dirname(char *buf, const char *path); 107 static char *replace_home(char *buf, const char *path); 108 109 static DirWin curwin, parwin, childwin; 110 static char *userhome, *username, *editor, **selected, searchq[SEARCHLEN]; 111 static int maxy, maxx; 112 static size_t selc, searchc; 113 static bool print_bot, hide = DEFAULT_HIDE; 114 115 int 116 main(int argc, char **argv) 117 { 118 struct passwd userinf; 119 char filename[PATH_MAX]; 120 int opt; 121 bool writepath = FALSE; 122 123 while ((opt = getopt(argc, argv, "f:")) != -1) { 124 switch (opt) { 125 case 'f': 126 cpstr(filename, optarg); 127 writepath = TRUE; 128 break; 129 default: 130 fatal("Unknown option: %c\n", optopt); 131 break; 132 } 133 } 134 135 editor = getenv("EDITOR"); 136 137 userinf = *getpwuid(getuid()); 138 username = strdup(userinf.pw_name); 139 userhome = strdup(userinf.pw_dir); 140 141 init_dirwins(); 142 init_screen(); 143 144 start(); 145 146 if (writepath) 147 wpath(filename); 148 149 clean(); 150 } 151 152 void 153 init_dirwins(void) 154 { 155 curwin.wintype = CURRENT; 156 parwin.wintype = PARENT; 157 childwin.wintype = CHILD; 158 159 reset_flags(); 160 161 childwin.highlight = 0; 162 163 if (getcwd(curwin.path, PATH_MAX) == NULL) 164 fatal("getcwd() error"); 165 166 get_dirname(parwin.path, curwin.path); 167 168 set_win_files(&curwin); 169 set_win_files(&parwin); 170 171 if (curwin.winfiles != NULL && curwin.winfiles[0].d_type == DT_DIR) { 172 cpstr(childwin.path, curwin.path); 173 update_child_win(); 174 } 175 } 176 177 void 178 init_screen(void) 179 { 180 initscr(); 181 noecho(); 182 start_color(); 183 use_default_colors(); 184 keypad(stdscr, TRUE); 185 curs_set(0); 186 187 clear(); 188 cbreak(); 189 190 init_pair(COLOR_BLACK, COLOR_BLACK, -1); 191 init_pair(COLOR_RED, COLOR_RED, -1); 192 init_pair(COLOR_GREEN,COLOR_GREEN, -1); 193 init_pair(COLOR_YELLOW, COLOR_YELLOW, -1); 194 init_pair(COLOR_BLUE, COLOR_BLUE, -1); 195 init_pair(COLOR_MAGENTA, COLOR_MAGENTA, -1); 196 init_pair(COLOR_CYAN, COLOR_CYAN, -1); 197 init_pair(COLOR_WHITE, COLOR_WHITE, -1); 198 199 curwin.highlight = 0; 200 curwin.startpr = 0; 201 202 parwin.highlight = 0; 203 parwin.startpr = 0; 204 205 childwin.highlight = 0; 206 childwin.startpr = 0; 207 208 resize(); 209 210 print_top_title(); 211 print_bot_title(); 212 213 print_win(&parwin); 214 print_win(&curwin); 215 print_win(&childwin); 216 } 217 218 void 219 resize(void) 220 { 221 int startx; 222 223 getmaxyx(stdscr, maxy, maxx); 224 225 parwin.maxy = maxy-BORDER_SPACE_SIZE; 226 parwin.maxx = maxx/4-BORDER_SPACE_SIZE > 0 ? maxx/4-BORDER_SPACE_SIZE : 1; 227 startx = maxx > BORDER_SPACE_SIZE ? BORDER_SPACE_SIZE : 0; 228 parwin.window = newwin(parwin.maxy, parwin.maxx, BORDER_SPACE_SIZE, startx); 229 230 curwin.maxy = maxy-BORDER_SPACE_SIZE; 231 curwin.maxx = maxx/4-BORDER_SPACE_SIZE > 0 ? maxx/4-BORDER_SPACE_SIZE : 1; 232 startx = maxx > curwin.maxx+BORDER_SPACE_SIZE*2 ? curwin.maxx+BORDER_SPACE_SIZE*2 : 0; 233 curwin.window = newwin(curwin.maxy, curwin.maxx, BORDER_SPACE_SIZE, startx); 234 235 childwin.maxy = maxy-BORDER_SPACE_SIZE; 236 childwin.maxx = maxx/2-BORDER_SPACE_SIZE > 0 ? maxx/2-BORDER_SPACE_SIZE : 1; 237 startx = maxx > childwin.maxx+BORDER_SPACE_SIZE*2 ? childwin.maxx+BORDER_SPACE_SIZE*2 : 0; 238 childwin.window = newwin(childwin.maxy, childwin.maxx, BORDER_SPACE_SIZE, startx); 239 240 clear(); 241 refresh(); 242 243 update_child_win(); 244 } 245 246 void 247 start(void) 248 { 249 int c; 250 char chdname[PATH_MAX]; 251 252 while ((c = getch()) != KEY_QUIT) { 253 move(1, 1); 254 clrtoeol(); 255 reset_flags(); 256 switch (c) { 257 case KEY_UP: 258 case KEY_VUP: 259 move_up(&curwin); 260 update_child_win(); 261 break; 262 case KEY_DOWN: 263 case KEY_VDOWN: 264 move_down(&curwin); 265 update_child_win(); 266 break; 267 case KEY_VPUP: 268 if (is_dir(&parwin, MAX(parwin.highlight-1, 0))) 269 change_parent_dir(UP); 270 break; 271 case KEY_VPDOWN: 272 if (is_dir(&parwin, MIN(parwin.highlight+1, parwin.filecount-1))) 273 change_parent_dir(DOWN); 274 break; 275 case KEY_PPAGE: 276 case ctrl('u'): 277 move_page_up(&curwin); 278 update_child_win(); 279 break; 280 case KEY_NPAGE: 281 case ctrl('d'): 282 move_page_down(&curwin); 283 update_child_win(); 284 break; 285 case KEY_BOT: 286 move_bot(&curwin); 287 update_child_win(); 288 break; 289 case 10: 290 case KEY_VRIGHT: 291 case KEY_VRIGHT_ABS: 292 if (is_dir(&curwin, curwin.highlight)) 293 change_dir(get_fullpath(chdname, &curwin, curwin.highlight), 294 RIGHT, c == KEY_VRIGHT_ABS); 295 else 296 open_child(FALSE); 297 break; 298 case KEY_LEFT: 299 case KEY_VLEFT: 300 change_dir(get_dirname(chdname, curwin.path), LEFT, FALSE); 301 break; 302 case KEY_SEARCH: 303 search(); 304 update_child_win(); 305 break; 306 case KEY_NEXT_SEARCH: 307 next_search(); 308 update_child_win(); 309 break; 310 case KEY_PREV_SEARCH: 311 prev_search(); 312 update_child_win(); 313 break; 314 case KEY_SEL_FILE: 315 select_file(get_fullpath(chdname, &curwin, curwin.highlight)); 316 set_win_files(&curwin); 317 update_child_win(); 318 break; 319 case KEY_CLEAR_SEL: 320 clear_selected(); 321 set_win_files(&curwin); 322 set_win_files(&parwin); 323 update_child_win(); 324 break; 325 case KEY_CLEAR_SEARCH: 326 clear_search(); 327 set_win_files(&curwin); 328 break; 329 case KEY_CP_SEL: 330 exe_selection(COPY, NULL); 331 break; 332 case KEY_RM_SEL: 333 exe_selection(REMOVE, "Remove"); 334 break; 335 case KEY_MV_SEL: 336 exe_selection(MOVE, "Move"); 337 break; 338 case KEY_RM_FILE: 339 rm_file(curwin.winfiles[curwin.highlight].d_name); 340 set_win_files(&curwin); 341 update_child_win(); 342 break; 343 case KEY_RENAME_FILE: 344 rename_file(curwin.winfiles[curwin.highlight].d_name); 345 set_win_files(&curwin); 346 update_child_win(); 347 break; 348 case KEY_HIDE: 349 hide = hide ? FALSE : TRUE; 350 curwin.highlight = 0; 351 curwin.startpr = 0; 352 set_win_files(&curwin); 353 set_win_files(&parwin); 354 update_child_win(); 355 break; 356 case KEY_COMBO_GO: 357 case KEY_COMBO_INF: 358 case KEY_COMBO_OPEN: 359 case KEY_COMBO_MAKE: 360 combo_key(c); 361 break; 362 case KEY_RESIZE: 363 resize(); 364 break; 365 default: 366 break; 367 } 368 369 print_top_title(); 370 if (print_bot) 371 print_bot_title(); 372 print_win(&parwin); 373 print_win(&curwin); 374 print_win(&childwin); 375 } 376 } 377 378 void 379 wpath(const char *filename) 380 { 381 FILE *fptr; 382 383 if ((fptr = fopen(filename, "w")) == NULL) 384 fatal("Error opening file \"%s\"\n", filename); 385 fprintf(fptr, "%s\n", curwin.path); 386 fclose(fptr); 387 } 388 389 void 390 reset_flags(void) 391 { 392 parwin.usehighlight = FALSE; 393 curwin.usehighlight = TRUE; 394 childwin.usehighlight = TRUE; 395 396 parwin.holdupdate = FALSE; 397 curwin.holdupdate = FALSE; 398 childwin.holdupdate = FALSE; 399 400 print_bot = TRUE; 401 } 402 403 void 404 set_startpr(DirWin *dirwin) 405 { 406 if (dirwin->winfiles == NULL) { 407 dirwin->startpr = 0; 408 return; 409 } 410 411 dirwin->startpr = MAX(dirwin->highlight - dirwin->maxy/2, 0); 412 } 413 414 void 415 set_win_files(DirWin *dirwin) 416 { 417 struct dirent *ent; 418 size_t count = 0; 419 DIR *dir; 420 421 free_dirwin(dirwin); 422 423 if (dirwin->wintype == PARENT && strcmp(curwin.path, "/") == 0) 424 return; 425 426 if ((dir = opendir(dirwin->path)) == NULL) { 427 switch (errno) { 428 case EACCES: 429 set_win_message(dirwin, "No permission."); 430 return; 431 default: 432 fatal("Could not open directory: %s", dirwin->path); 433 } 434 } 435 436 if ((dirwin->winfiles = (WinFile*) malloc(sizeof(WinFile))) == NULL) 437 fatal("Fatal: failed to malloc.\n"); 438 439 while ((ent = readdir(dir)) != NULL) { 440 if (strcmp(ent->d_name, ".") == 0 441 || strcmp(ent->d_name, "..") == 0 442 || (hide && ent->d_name[0] == '.')) 443 continue; 444 if ((dirwin->winfiles = (WinFile*) realloc(dirwin->winfiles, (count+1)*(sizeof(WinFile)))) == NULL) 445 fatal("Fatal: failed to realloc.\n"); 446 cpstr(dirwin->winfiles[count].d_name, ent->d_name); 447 dirwin->winfiles[count].d_type = ent->d_type; 448 dirwin->winfiles[count].selected = is_selected(dirwin, count); 449 (count)++; 450 } 451 closedir(dir); 452 453 dirwin->filecount = count; 454 455 if (count == 0) 456 set_win_message(dirwin, "empty"); 457 else 458 qsort(dirwin->winfiles, count, sizeof(WinFile), compare_file); 459 } 460 461 bool 462 is_selected(DirWin *dirwin, size_t index) 463 { 464 char buf[PATH_MAX]; 465 466 if (selc == 0 || selected == NULL) 467 return FALSE; 468 469 get_fullpath(buf, dirwin, index); 470 471 for (size_t i = 0; i < selc; i++) { 472 if (strcmp(buf, selected[i]) == 0) 473 return TRUE; 474 } 475 476 return FALSE; 477 } 478 479 bool 480 remove_selected(const char *sel) 481 { 482 bool res = FALSE; 483 484 if (selc == 0) 485 return res; 486 487 for (size_t i = 0; i < selc; i++) { 488 if (strcmp(selected[i], sel) == 0) { 489 free(selected[i]); 490 selected[i] = selected[selc-1]; 491 res = TRUE; 492 break; 493 } 494 } 495 496 if (!res) 497 return res; 498 499 if (--(selc) == 0) { 500 free(selected); 501 selected = NULL; 502 } else if ((selected = (char**) realloc(selected, selc * sizeof(char *))) == NULL) 503 fatal("Fatal: failed to realloc.\n"); 504 505 return res; 506 } 507 508 void 509 set_win_message(DirWin *dirwin, char *message) 510 { 511 free_dirwin(dirwin); 512 dirwin->message = message; 513 } 514 515 void 516 print_win(DirWin *dirwin) 517 { 518 if (dirwin->holdupdate) 519 return; 520 521 size_t cplen, size = dirwin->maxx; 522 char *subs, name[size+1], sbuf[size+1], pathbuf[PATH_MAX]; 523 int sindex, y = 0, x = 1; 524 525 wclear(dirwin->window); 526 527 set_startpr(dirwin); 528 529 if (dirwin->message != NULL) { 530 if (dirwin->wintype == CURRENT) { 531 wattron(dirwin->window, A_REVERSE); 532 mvwaddstr(dirwin->window, y, x, dirwin->message); 533 wattroff(dirwin->window, A_REVERSE); 534 } else { 535 wattron(dirwin->window, COLOR_PAIR(CHILDWIN_MESSAGE_COLOR)); 536 mvwaddstr(dirwin->window, y, x, dirwin->message); 537 wattroff(dirwin->window, COLOR_PAIR(CHILDWIN_MESSAGE_COLOR)); 538 } 539 } else if (dirwin->winfiles != NULL) { 540 while (!dirwin->usehighlight) { 541 for (size_t i = 0; i < dirwin->filecount; ++i) { 542 memcpy(name, dirwin->winfiles[i].d_name, size); 543 name[size] = '\0'; 544 if (strcmp(basename(curwin.path), dirwin->winfiles[i].d_name) == 0) { 545 dirwin->usehighlight = TRUE; 546 dirwin->highlight = i; 547 set_startpr(dirwin); 548 break; 549 } 550 } 551 break; 552 } 553 for (size_t i = dirwin->startpr; i < dirwin->filecount; ++i) { 554 mvwaddch(dirwin->window, y, x-1, ' '); 555 if (dirwin->winfiles[i].selected) { 556 wattron(dirwin->window, COLOR_PAIR(MARK_SELECTED_COLOR)); 557 mvwaddch(dirwin->window, y, x-1, '|'); 558 wattroff(dirwin->window, COLOR_PAIR(MARK_SELECTED_COLOR)); 559 } 560 memcpy(name, dirwin->winfiles[i].d_name, size); 561 name[size-1] = '\0'; 562 if (dirwin->usehighlight && dirwin->highlight == i) { 563 wattron(dirwin->window, A_REVERSE); 564 mvwaddstr(dirwin->window, y, x, name); 565 wattroff(dirwin->window, A_REVERSE); 566 } else if (dirwin->winfiles[i].d_type == DT_DIR) { 567 wattron(dirwin->window, COLOR_PAIR(DIR_COLOR)); 568 wattron(dirwin->window, A_BOLD); 569 mvwaddstr(dirwin->window, y, x, name); 570 wattroff(dirwin->window, COLOR_PAIR(DIR_COLOR)); 571 wattroff(dirwin->window, A_BOLD); 572 } else if (dirwin->winfiles[i].d_type == DT_LNK) { 573 if (access(get_fullpath(pathbuf, dirwin, i), F_OK) == 0) { 574 wattron(dirwin->window, COLOR_PAIR(LN_COLOR)); 575 mvwaddstr(dirwin->window, y, x, name); 576 wattroff(dirwin->window, COLOR_PAIR(LN_COLOR)); 577 } else { 578 wattron(dirwin->window, COLOR_PAIR(INVALID_LN_COLOR)); 579 mvwaddstr(dirwin->window, y, x, name); 580 wattroff(dirwin->window, COLOR_PAIR(INVALID_LN_COLOR)); 581 } 582 } else 583 mvwaddstr(dirwin->window, y, x, name); 584 if (dirwin->wintype == CURRENT && searchc > 0 585 && ((subs = strstr(name, searchq)) != NULL)) { 586 sindex = (int) (subs - name); 587 wattron(dirwin->window, COLOR_PAIR(SEARCH_MATCH_COLOR)); 588 if (dirwin->usehighlight && dirwin->highlight == i) 589 wattron(dirwin->window, A_REVERSE); 590 cplen = strlen(searchq); 591 memcpy(sbuf, name + sindex, cplen); 592 sbuf[cplen] = '\0'; 593 mvwaddstr(dirwin->window, y, x+sindex, sbuf); 594 wattroff(dirwin->window, COLOR_PAIR(SEARCH_MATCH_COLOR)); 595 if (dirwin->usehighlight && dirwin->highlight == i) 596 wattroff(dirwin->window, A_REVERSE); 597 } 598 y++; 599 } 600 } 601 wrefresh(dirwin->window); 602 } 603 604 void 605 update_child_win(void) 606 { 607 char pathbuf[PATH_MAX]; 608 609 if (curwin.filecount <= 0) { 610 free_dirwin(&childwin); 611 return; 612 } 613 614 get_fullpath(childwin.path, &curwin, curwin.highlight); 615 616 switch (curwin.winfiles[curwin.highlight].d_type) { 617 case DT_LNK: 618 if (access(get_fullpath(pathbuf, &curwin, curwin.highlight), F_OK) != 0) { 619 set_win_message(&childwin, "Link no longer exists."); 620 break; 621 } 622 if (is_dir(&curwin, curwin.highlight)) 623 goto dir; 624 else 625 goto reg; 626 case DT_DIR: 627 dir: 628 set_win_files(&childwin); 629 break; 630 case DT_REG: 631 reg: 632 print_content(); 633 break; 634 default: 635 free_dirwin(&childwin); 636 break; 637 } 638 } 639 640 void 641 print_top_title(void) 642 { 643 move(0, 0); 644 clrtoeol(); 645 attron(COLOR_PAIR(TOP_TITLE_COLOR)); 646 printw("%s:%s/%s", username, curwin.path, curwin.winfiles[curwin.highlight].d_name); 647 attroff(COLOR_PAIR(TOP_TITLE_COLOR)); 648 } 649 650 void 651 print_bot_title(void) 652 { 653 char pathbuf[PATH_MAX], fileinf[maxx]; 654 655 get_fullpath(pathbuf, &curwin, curwin.highlight); 656 memcpy(fileinf, get_file_info(fileinf, pathbuf), maxx); 657 fileinf[maxx] = '\0'; 658 659 move(maxy-1, 0); 660 clrtoeol(); 661 662 attron(COLOR_PAIR(BOT_TITLE_COUNT_COLOR)); 663 printw("(%d/%d) ", curwin.filecount == 0 ? 0 : curwin.highlight+1, curwin.filecount); 664 attroff(COLOR_PAIR(BOT_TITLE_COUNT_COLOR)); 665 666 attron(COLOR_PAIR(BOT_TITLE_INFO_COLOR)); 667 addstr(fileinf); 668 attroff(COLOR_PAIR(BOT_TITLE_INFO_COLOR)); 669 } 670 671 char * 672 get_file_info(char *buf, const char *filepath) 673 { 674 struct stat statbuf; 675 struct passwd *usr; 676 struct tm *tm; 677 struct group *grp; 678 char mods[11], datestr[256], modfill = '-'; 679 680 if ((stat(filepath, &statbuf)) != 0) { 681 switch (errno) { 682 case EACCES: 683 buf = "No permission."; 684 break; 685 default: 686 buf = "Retrieving filestats failed."; 687 break; 688 } 689 return buf; 690 } 691 692 if ((usr = getpwuid(statbuf.st_uid)) == NULL) { 693 buf = "Retrieving username failed."; 694 return buf; 695 } 696 if ((grp = getgrgid(statbuf.st_gid)) == NULL) { 697 buf = "Retrieving groupname failed."; 698 return buf; 699 } 700 701 mods[0] = S_ISDIR(statbuf.st_mode) ? 'd' : modfill; 702 mods[1] = statbuf.st_mode & S_IRUSR ? 'r' : modfill; 703 mods[2] = statbuf.st_mode & S_IWUSR ? 'w' : modfill; 704 mods[3] = statbuf.st_mode & S_IXUSR ? 'x' : modfill; 705 mods[4] = statbuf.st_mode & S_IRGRP ? 'r' : modfill; 706 mods[5] = statbuf.st_mode & S_IWGRP ? 'w' : modfill; 707 mods[6] = statbuf.st_mode & S_IXGRP ? 'x' : modfill; 708 mods[7] = statbuf.st_mode & S_IROTH ? 'r' : modfill; 709 mods[8] = statbuf.st_mode & S_IWOTH ? 'w' : modfill; 710 mods[9] = statbuf.st_mode & S_IXOTH ? 'x' : modfill; 711 mods[10] = '\0'; 712 713 tm = localtime(&statbuf.st_mtime); 714 strftime(datestr, sizeof(datestr), nl_langinfo(D_T_FMT), tm); 715 716 sprintf(buf, "%10.10s %s %s %9jd %s", 717 mods, 718 usr->pw_name, 719 grp->gr_name, 720 (intmax_t)statbuf.st_size, 721 datestr); 722 723 return buf; 724 } 725 726 void 727 print_content(void) 728 { 729 FILE *fp = NULL; 730 size_t size = childwin.maxx; 731 char str[size+1], buf[PATH_MAX]; 732 int y = 0, x = 0; 733 734 werase(childwin.window); 735 free_dirwin(&childwin); 736 737 if ((fp = fopen(get_fullpath(buf, &curwin, curwin.highlight), "r")) == NULL) { 738 switch (errno) { 739 case EACCES: 740 set_win_message(&childwin, "No permission."); 741 return; 742 default: 743 fatal("Error opening file \"%s\"\n", buf); 744 } 745 } 746 747 childwin.holdupdate = TRUE; 748 749 while (fgets(str, size, fp) != NULL && y <= childwin.maxy) { 750 mvwaddstr(childwin.window, y, x, str); 751 y++; 752 } 753 754 fclose(fp); 755 wrefresh(childwin.window); 756 } 757 758 void 759 show_file_mime(void) 760 { 761 int appsize = 256; 762 char mimebuf[MIME_MAX], appbuf[appsize], buf[MIME_MAX+appsize]; 763 764 if (get_mime(mimebuf, MIME_MAX, curwin.winfiles[curwin.highlight].d_name) != 0) 765 cpstr(mimebuf, "Can't retrieve mime."); 766 767 if (get_mime_default(appbuf, appsize, mimebuf) != 0) 768 cpstr(appbuf, "Can't retrieve default for mime."); 769 770 snprintf(buf, MIME_MAX+appsize, "%s: %s", mimebuf, appbuf); 771 772 move(1, 1); 773 clrtoeol(); 774 addstr(buf); 775 } 776 777 void 778 combo_key(int keypress) 779 { 780 int c; 781 782 move(maxy-1, maxx-1); 783 clrtoeol(); 784 addch(keypress); 785 786 halfdelay(10); 787 788 while ((c = getch()) != ERR) { 789 switch (keypress) { 790 case KEY_COMBO_GO: 791 combo_go(c); 792 break; 793 case KEY_COMBO_INF: 794 combo_inf(c); 795 break; 796 case KEY_COMBO_OPEN: 797 combo_open(c); 798 break; 799 case KEY_COMBO_MAKE: 800 combo_make(c); 801 break; 802 default: 803 break; 804 } 805 break; 806 } 807 808 cbreak(); 809 move(maxy-1, maxx-1); 810 clrtoeol(); 811 } 812 813 void 814 combo_go(int key) 815 { 816 char pathbuf[PATH_MAX]; 817 818 switch (key) { 819 case KEY_COMBO_GO_TOP: 820 move_top(&curwin); 821 update_child_win(); 822 break; 823 case KEY_COMBO_GO_HOME: 824 change_dir(userhome, OTHER, FALSE); 825 break; 826 case KEY_COMBO_GO_ACCESS: 827 change_dir(replace_home(pathbuf, LN_ACCESS_DIR), OTHER, FALSE); 828 break; 829 default: 830 break; 831 } 832 } 833 834 void 835 combo_inf(int key) 836 { 837 switch (key) { 838 case KEY_COMBO_INF_OPEN: 839 show_file_mime(); 840 break; 841 default: 842 break; 843 } 844 } 845 846 void 847 combo_open(int key) 848 { 849 char chdname[PATH_MAX]; 850 851 switch (key) { 852 case KEY_COMBO_OPEN_NOHUP_XDG: 853 if (is_dir(&curwin, curwin.highlight)) 854 change_dir(get_fullpath(chdname, &curwin, curwin.highlight), RIGHT, FALSE); 855 else 856 open_nohup_xdg(); 857 break; 858 case KEY_COMBO_OPEN_EXEC: 859 if (is_dir(&curwin, curwin.highlight)) 860 change_dir(get_fullpath(chdname, &curwin, curwin.highlight), RIGHT, FALSE); 861 else 862 open_child(TRUE); 863 break; 864 default: 865 break; 866 } 867 } 868 869 void 870 combo_make(int key) 871 { 872 switch (key) { 873 case KEY_COMBO_MAKE_FILE: 874 make_file(curwin.path); 875 set_win_files(&curwin); 876 update_child_win(); 877 break; 878 case KEY_COMBO_MAKE_DIR: 879 make_dir(curwin.path); 880 set_win_files(&curwin); 881 update_child_win(); 882 break; 883 case KEY_COMBO_MAKE_MOD: 884 make_mod(); 885 break; 886 case KEY_COMBO_MAKE_ACCESS: 887 make_access(); 888 break; 889 case KEY_COMBO_MAKE_OPEN_DEFAULT: 890 make_open_default(); 891 break; 892 default: 893 break; 894 } 895 } 896 897 void 898 change_dir(const char *chdname, Direction direction, bool abspath) 899 { 900 if (chdir(chdname) != 0) 901 return; 902 903 if (!abspath) 904 cpstr(curwin.path, chdname); 905 else if (getcwd(curwin.path, PATH_MAX) == NULL) 906 fatal("getcwd() error"); 907 908 switch (direction) { 909 case RIGHT: 910 curwin.highlight = 0; 911 break; 912 case LEFT: 913 curwin.highlight = parwin.highlight; 914 break; 915 default: 916 curwin.highlight = 0; 917 break; 918 919 } 920 921 set_win_files(&curwin); 922 923 get_dirname(parwin.path, curwin.path); 924 set_win_files(&parwin); 925 926 update_child_win(); 927 } 928 929 void 930 change_parent_dir(Direction direction) 931 { 932 char pp[PATH_MAX]; 933 934 switch (direction) { 935 case UP: 936 move_up(&parwin); 937 break; 938 case DOWN: 939 move_down(&parwin); 940 break; 941 default: 942 return; 943 } 944 945 parwin.usehighlight = TRUE; 946 curwin.highlight = 0; 947 change_dir(get_fullpath(pp, &parwin, parwin.highlight), direction, FALSE); 948 } 949 950 void 951 open_child(bool exec) 952 { 953 sigset_t set; 954 char mime[MIME_MAX], mimedefault[MIME_APP_MAX], pathbuf[PATH_MAX]; 955 bool istext; 956 957 if (curwin.message != NULL) 958 return; 959 960 if (!exec) { 961 if (get_mime(mime, MIME_MAX, curwin.winfiles[curwin.highlight].d_name) != 0) { 962 move(1, 1); 963 clrtoeol(); 964 printw("Can\'t open %s", curwin.winfiles[curwin.highlight].d_name); 965 return; 966 } 967 968 istext = strncmp(mime, "text/", 5) == 0; 969 970 if (!istext && get_mime_default(mimedefault, MIME_APP_MAX, mime) != 0) { 971 move(1, 1); 972 clrtoeol(); 973 printw("Can\'t open for mime %s", mime); 974 return; 975 } 976 } 977 978 endwin(); 979 980 if (sigemptyset (&set) == -1) 981 fatal("Sigemptyset failed."); 982 if (sigaddset(&set, SIGWINCH) == -1) 983 fatal("Sigaddset failed."); 984 if (sigprocmask(SIG_BLOCK, &set, NULL) != 0) 985 fatal("Blocking sigprocmask failed."); 986 987 if (exec) 988 run_command(PATH_MAX + 4, "\"./%s\"", curwin.winfiles[curwin.highlight].d_name); 989 else 990 run_command(PATH_MAX + 12, "%s \"%s\"", istext ? editor : "xdg-open", 991 get_fullpath(pathbuf, &curwin, curwin.highlight)); 992 993 if (sigprocmask(SIG_UNBLOCK, &set, NULL) != 0) 994 fatal("Unblocking sigprocmask failed."); 995 996 clear(); 997 noecho(); 998 cbreak(); 999 1000 refresh(); 1001 wrefresh(parwin.window); 1002 wrefresh(curwin.window); 1003 wrefresh(childwin.window); 1004 update_child_win(); 1005 } 1006 1007 void 1008 open_nohup_xdg(void) 1009 { 1010 char *cmdfmt = "nohup xdg-open \"%s\" > /dev/null 2>&1 &"; 1011 size_t size = PATH_MAX + strlen(cmdfmt); 1012 1013 run_command(size, cmdfmt, curwin.winfiles[curwin.highlight].d_name); 1014 } 1015 1016 void 1017 search(void) 1018 { 1019 int c, y, x; 1020 1021 clear_search(); 1022 1023 move(maxy-1, 0); 1024 clrtoeol(); 1025 1026 attron(COLOR_PAIR(PROMPT_COLOR)); 1027 addstr("Search name? "); 1028 attroff(COLOR_PAIR(PROMPT_COLOR)); 1029 1030 echo(); 1031 curs_set(1); 1032 1033 getyx(stdscr, y, x); 1034 1035 while ((c = mvwgetch(stdscr, y, x)) != 10) { 1036 switch (c) { 1037 case KEY_BACKSPACE: 1038 if (searchc > 0) { 1039 searchq[--(searchc)] = '\0'; 1040 move(y, --x); 1041 clrtoeol(); 1042 } 1043 break; 1044 default: 1045 if (searchc < SEARCHLEN) { 1046 searchq[(searchc)++] = c; 1047 move(y, ++x); 1048 } 1049 break; 1050 } 1051 print_win(&curwin); 1052 } 1053 noecho(); 1054 curs_set(0); 1055 } 1056 1057 void 1058 move_top(DirWin *dirwin) 1059 { 1060 dirwin->highlight = 0; 1061 } 1062 1063 void 1064 move_bot(DirWin *dirwin) 1065 { 1066 dirwin->highlight = MAX(dirwin->filecount-1, 0); 1067 } 1068 1069 void 1070 move_page_up(DirWin *dirwin) 1071 { 1072 dirwin->highlight = MAX(dirwin->highlight - dirwin->maxy/2, 0); 1073 } 1074 1075 void 1076 move_page_down(DirWin *dirwin) 1077 { 1078 dirwin->highlight = MIN(dirwin->highlight + dirwin->maxy/2, 1079 MAX(dirwin->filecount-1, 0)); 1080 } 1081 1082 void 1083 move_up(DirWin *dirwin) 1084 { 1085 if (dirwin->highlight > 0) 1086 dirwin->highlight--; 1087 } 1088 1089 void 1090 move_down(DirWin *dirwin) 1091 { 1092 if (dirwin->highlight < dirwin->filecount-1) 1093 dirwin->highlight++; 1094 } 1095 1096 void 1097 next_search(void) 1098 { 1099 if (searchc == 0) 1100 return; 1101 1102 for (size_t i = curwin.highlight; i < MAX(curwin.filecount-1, 0); i++) { 1103 if ((strstr(curwin.winfiles[i+1].d_name, searchq) != NULL)) { 1104 curwin.highlight = i+1; 1105 return; 1106 } 1107 } 1108 } 1109 1110 void 1111 prev_search(void) 1112 { 1113 if (searchc == 0) 1114 return; 1115 1116 for (size_t i = curwin.highlight; i > 0; i--) { 1117 if ((strstr(curwin.winfiles[i-1].d_name, searchq) != NULL)) { 1118 curwin.highlight = i-1; 1119 return; 1120 } 1121 } 1122 } 1123 1124 void 1125 free_dirwin(DirWin *dirwin) 1126 { 1127 free(dirwin->winfiles); 1128 dirwin->filecount = 0; 1129 dirwin->winfiles = NULL; 1130 dirwin->message = NULL; 1131 } 1132 1133 void 1134 clean(void) 1135 { 1136 wclear(curwin.window); 1137 wclear(parwin.window); 1138 wclear(childwin.window); 1139 1140 free(username); 1141 free(userhome); 1142 1143 clear(); 1144 1145 delwin(parwin.window); 1146 delwin(curwin.window); 1147 delwin(childwin.window); 1148 delwin(stdscr); 1149 1150 free_dirwin(&curwin); 1151 free_dirwin(&parwin); 1152 free_dirwin(&childwin); 1153 1154 clear_selected(); 1155 1156 endwin(); 1157 } 1158 1159 void 1160 fatal(const char *fmt, ...) 1161 { 1162 va_list ap; 1163 1164 va_start(ap, fmt); 1165 vfprintf(stderr, fmt, ap); 1166 va_end(ap); 1167 1168 clean(); 1169 1170 exit(EXIT_FAILURE); 1171 } 1172 1173 bool 1174 is_dir(DirWin *dirwin, size_t index) 1175 { 1176 struct stat statbuf; 1177 char linkpath[PATH_MAX], abspath[PATH_MAX]; 1178 1179 if (dirwin->filecount <= 0) 1180 return FALSE; 1181 1182 if (dirwin->winfiles[index].d_type == DT_DIR) 1183 return TRUE; 1184 1185 get_fullpath(linkpath, dirwin, index); 1186 1187 if (dirwin->winfiles[index].d_type == DT_LNK) 1188 return (lstat(realpath(linkpath, abspath), &statbuf) >= 0) && S_ISDIR(statbuf.st_mode); 1189 1190 return FALSE; 1191 } 1192 1193 char * 1194 prompt_answer(char *buf, size_t size, const char *question) 1195 { 1196 move(maxy-1, 0); 1197 clrtoeol(); 1198 1199 attron(COLOR_PAIR(PROMPT_COLOR)); 1200 addstr(question); 1201 attroff(COLOR_PAIR(PROMPT_COLOR)); 1202 1203 echo(); 1204 curs_set(1); 1205 getnstr(buf, size); 1206 noecho(); 1207 curs_set(0); 1208 1209 return buf; 1210 } 1211 1212 bool 1213 prompt_confirm(size_t size, const char *fmt, ...) 1214 { 1215 char response[1], question[size]; 1216 va_list ap; 1217 1218 va_start(ap, fmt); 1219 vsnprintf(question, size, fmt, ap); 1220 va_end(ap); 1221 1222 prompt_answer(response, 1, question); 1223 1224 return strcasecmp(response, "y") == 0; 1225 } 1226 1227 int 1228 compare_file(const void *a, const void *b) 1229 { 1230 int typecompare; 1231 const WinFile *ma = a; 1232 const WinFile *mb = b; 1233 1234 if ((typecompare = ma->d_type - mb->d_type) == 0) 1235 return strcmp(ma->d_name, mb->d_name); 1236 1237 return typecompare; 1238 } 1239 1240 int 1241 get_mime(char *buf, size_t bufsize, const char *path) 1242 { 1243 char *cmdfmt = "xdg-mime query filetype \"%s\""; 1244 size_t size = PATH_MAX + strlen(cmdfmt); 1245 char cmd[size]; 1246 1247 snprintf(cmd, size, cmdfmt, path); 1248 1249 return read_command(buf, bufsize, cmd); 1250 } 1251 1252 int 1253 get_mime_default(char *buf, size_t bufsize, const char *mime) 1254 { 1255 char *cmdfmt = "xdg-mime query default \"%s\""; 1256 size_t cmdsize = MIME_MAX + strlen(cmdfmt); 1257 char cmd[cmdsize]; 1258 1259 snprintf(cmd, cmdsize, cmdfmt, mime); 1260 1261 return read_command(buf, bufsize, cmd); 1262 } 1263 1264 int 1265 read_command(char *buf, size_t bufsize, const char *cmd) 1266 { 1267 FILE *file; 1268 1269 if ((file = popen(cmd, "r")) == NULL) { 1270 buf = NULL; 1271 return 1; 1272 } 1273 1274 if (fgets(buf, bufsize, file) == NULL) { 1275 buf = NULL; 1276 pclose(file); 1277 return 2; 1278 } 1279 1280 buf[strlen(buf)-1] = '\0'; 1281 1282 pclose(file); 1283 1284 return 0; 1285 } 1286 1287 void 1288 run_command(size_t size, const char *fmt, ...) 1289 { 1290 va_list ap; 1291 char cmd[size]; 1292 1293 va_start(ap, fmt); 1294 vsnprintf(cmd, size, fmt, ap); 1295 va_end(ap); 1296 1297 system(cmd); 1298 } 1299 1300 int 1301 make_dir(const char *path) 1302 { 1303 char name[PATH_MAX]; 1304 1305 prompt_answer(name, PATH_MAX, "Name of directory? "); 1306 return mkdir(name, 0755); 1307 } 1308 1309 int 1310 make_file(const char *path) 1311 { 1312 FILE *fptr; 1313 char name[PATH_MAX]; 1314 1315 prompt_answer(name, PATH_MAX, "Name of file? "); 1316 1317 if (strlen(name) > 0) { 1318 if ((fptr = fopen(name, "w")) == NULL) 1319 fatal("Error opening file \"%s\"\n", name); 1320 fclose(fptr); 1321 } 1322 } 1323 1324 int 1325 rm_file(const char *fname) 1326 { 1327 char *msg, *rmdirfmt = "rm -rf \"%s\"", *pfmt = "Remove %s? (y/N) "; 1328 int res = 0; 1329 size_t cmdsize = PATH_MAX + strlen(rmdirfmt), psize = strlen(pfmt) + strlen(fname); 1330 1331 if (prompt_confirm(psize, pfmt, fname)) { 1332 if (is_dir(&curwin, curwin.highlight)) 1333 run_command(cmdsize, rmdirfmt, fname); 1334 else 1335 res = remove(fname); 1336 curwin.highlight = MAX(curwin.highlight-1, 0); 1337 } 1338 1339 if (res != 0) { 1340 switch (errno) { 1341 case EACCES: 1342 msg = "No permission."; 1343 break; 1344 case EEXIST: 1345 case ENOTEMPTY: 1346 msg = "Directory is not empty."; 1347 break; 1348 default: 1349 msg = "Could not remove file."; 1350 break; 1351 } 1352 move(maxy-1, 0); 1353 clrtoeol(); 1354 addstr(msg); 1355 print_bot = FALSE; 1356 } 1357 1358 return res; 1359 } 1360 1361 int 1362 rename_file(const char *fname) 1363 { 1364 char name[PATH_MAX]; 1365 1366 prompt_answer(name, PATH_MAX, "New name? "); 1367 1368 if (strlen(name) > 0) 1369 return rename(fname, name); 1370 1371 return 0; 1372 } 1373 1374 int 1375 make_mod(void) 1376 { 1377 char name[3]; 1378 bool isvalid; 1379 1380 prompt_answer(name, 3, "File mods (numeric)? "); 1381 1382 if (strlen(name) == 3) { 1383 isvalid = TRUE; 1384 for (size_t i = 0; i < 3; i++) { 1385 if (!isdigit(name[i])) 1386 isvalid = FALSE; 1387 } 1388 if (isvalid) 1389 chmod(curwin.winfiles[curwin.highlight].d_name, strtol(name, NULL, 8)); 1390 else 1391 return -1; 1392 } 1393 1394 return 0; 1395 } 1396 1397 void 1398 make_access(void) 1399 { 1400 char pathbuf[PATH_MAX], *cmdfmt = "ln -s \"%s\" \"%s\"", *pfmt = "Make access \"%s\"? (y/N) "; 1401 size_t cmdsize = PATH_MAX + strlen(cmdfmt), psize = strlen(pfmt) + PATH_MAX; 1402 1403 if (prompt_confirm(psize, pfmt, curwin.winfiles[curwin.highlight].d_name)) 1404 run_command(cmdsize, cmdfmt, get_fullpath(pathbuf, &curwin, curwin.highlight), LN_ACCESS_DIR); 1405 } 1406 1407 void 1408 make_open_default(void) 1409 { 1410 int appsize = 256, qsize = MIME_MAX+25; 1411 char mime[MIME_MAX], question[qsize], app[appsize]; 1412 1413 if (get_mime(mime, MIME_MAX, curwin.winfiles[curwin.highlight].d_name) != 0) 1414 cpstr(mime, "Can't retrieve mime."); 1415 1416 snprintf(question, qsize, "Application for mime %s?", mime); 1417 1418 prompt_answer(app, appsize, question); 1419 1420 if (strlen(app) > 0) 1421 make_mime_default(mime, app); 1422 } 1423 1424 void 1425 make_mime_default(const char *mime, const char *app) 1426 { 1427 char *cmdfmt = "xdg-mime default \"%s\" \"%s\""; 1428 size_t cmdsize = MIME_MAX + 256 + strlen(cmdfmt); 1429 1430 run_command(cmdsize, cmdfmt, app, mime); 1431 } 1432 1433 void 1434 exe_selection(SelAction action, const char *askn) 1435 { 1436 char *pfmt = "%s selection (%d files) ? (y/N) "; 1437 size_t cmdsize = PATH_MAX*2 + 20; 1438 1439 if (selected == NULL || selc == 0) 1440 return; 1441 1442 if (askn != NULL && !prompt_confirm(strlen(pfmt) + strlen(askn) + 5, pfmt, askn, selc)) 1443 return; 1444 1445 switch (action) { 1446 case COPY: 1447 for (size_t i = 0; i <selc; i++) 1448 run_command(cmdsize, "cp -rf \"%s\" \"%s\"", selected[i], curwin.path); 1449 break; 1450 case REMOVE: 1451 for (size_t i = 0; i <selc; i++) 1452 run_command(cmdsize, "rm -rf \"%s\"", selected[i]); 1453 break; 1454 case MOVE: 1455 for (size_t i = 0; i <selc; i++) 1456 run_command(cmdsize, "mv \"%s\" \"%s\"", selected[i], curwin.path); 1457 break; 1458 default: 1459 break; 1460 } 1461 1462 clear_selected(); 1463 curwin.highlight = 0; 1464 set_win_files(&curwin); 1465 set_win_files(&parwin); 1466 update_child_win(); 1467 } 1468 1469 void 1470 select_file(const char *path) 1471 { 1472 if (selc == 0 && ((selected = (char**) malloc(sizeof(char *)))) == NULL) 1473 fatal("Fatal: failed to malloc selected.\n"); 1474 1475 if (remove_selected(path)) 1476 return; 1477 1478 if ((selected = (char**) realloc(selected, (selc+1) * sizeof(char *))) == NULL) 1479 fatal("Fatal: failed to realloc.\n"); 1480 1481 selected[selc] = strdup(path); 1482 (selc)++; 1483 } 1484 1485 void 1486 clear_selected(void) 1487 { 1488 for (size_t i = 0; i < selc; i++) 1489 free(selected[i]); 1490 1491 free(selected); 1492 selected = NULL; 1493 selc = 0; 1494 } 1495 1496 void 1497 clear_search(void) 1498 { 1499 for (size_t i = 0; i < SEARCHLEN; i++) 1500 searchq[i] = '\0'; 1501 searchc = 0; 1502 } 1503 1504 char * 1505 cpstr(char *dest, const char *src) 1506 { 1507 size_t cplen = strlen(src); 1508 memcpy(dest, src, cplen); 1509 dest[cplen] = '\0'; 1510 return dest; 1511 } 1512 1513 char * 1514 get_fullpath(char *buf, DirWin *dirwin, size_t index) 1515 { 1516 index = MIN(index, dirwin->filecount-1); 1517 index = MAX(index, 0); 1518 1519 if (strcmp(dirwin->path, "/") == 0) 1520 snprintf(buf, PATH_MAX, "/%s", dirwin->winfiles[index].d_name); 1521 else 1522 snprintf(buf, PATH_MAX, "%s/%s", dirwin->path, dirwin->winfiles[index].d_name); 1523 1524 return buf; 1525 } 1526 1527 char * 1528 replace_home(char *buf, const char *path) 1529 { 1530 char *envv = "$HOME"; 1531 1532 if ((strstr(path, envv) != NULL)) { 1533 cpstr(buf, userhome); 1534 strcat(buf, path + strlen(envv)); 1535 } 1536 return buf; 1537 } 1538 1539 char * 1540 get_dirname(char *buf, const char *path) 1541 { 1542 cpstr(buf, path); 1543 dirname(buf); 1544 return buf; 1545 }