1 /* 2 * Copyright (C) 1984-2015 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11 #include "less.h" 12 #if HAVE_STAT 13 #include <sys/stat.h> 14 #endif 15 16 public int fd0 = 0; 17 18 extern int new_file; 19 extern int errmsgs; 20 extern int cbufs; 21 extern char *every_first_cmd; 22 extern int any_display; 23 extern int force_open; 24 extern int is_tty; 25 extern int sigs; 26 extern IFILE curr_ifile; 27 extern IFILE old_ifile; 28 extern struct scrpos initial_scrpos; 29 extern void constant *ml_examine; 30 #if SPACES_IN_FILENAMES 31 extern char openquote; 32 extern char closequote; 33 #endif 34 35 #if LOGFILE 36 extern int logfile; 37 extern int force_logfile; 38 extern char *namelogfile; 39 #endif 40 41 #if HAVE_STAT_INO 42 public dev_t curr_dev; 43 public ino_t curr_ino; 44 #endif 45 46 char *curr_altfilename = NULL; 47 static void *curr_altpipe; 48 49 50 /* 51 * Textlist functions deal with a list of words separated by spaces. 52 * init_textlist sets up a textlist structure. 53 * forw_textlist uses that structure to iterate thru the list of 54 * words, returning each one as a standard null-terminated string. 55 * back_textlist does the same, but runs thru the list backwards. 56 */ 57 public void 58 init_textlist(tlist, str) 59 struct textlist *tlist; 60 char *str; 61 { 62 char *s; 63 #if SPACES_IN_FILENAMES 64 int meta_quoted = 0; 65 int delim_quoted = 0; 66 char *esc = get_meta_escape(); 67 int esclen = (int) strlen(esc); 68 #endif 69 70 tlist->string = skipsp(str); 71 tlist->endstring = tlist->string + strlen(tlist->string); 72 for (s = str; s < tlist->endstring; s++) 73 { 74 #if SPACES_IN_FILENAMES 75 if (meta_quoted) 76 { 77 meta_quoted = 0; 78 } else if (esclen > 0 && s + esclen < tlist->endstring && 79 strncmp(s, esc, esclen) == 0) 80 { 81 meta_quoted = 1; 82 s += esclen - 1; 83 } else if (delim_quoted) 84 { 85 if (*s == closequote) 86 delim_quoted = 0; 87 } else /* (!delim_quoted) */ 88 { 89 if (*s == openquote) 90 delim_quoted = 1; 91 else if (*s == ' ') 92 *s = '\0'; 93 } 94 #else 95 if (*s == ' ') 96 *s = '\0'; 97 #endif 98 } 99 } 100 101 public char * 102 forw_textlist(tlist, prev) 103 struct textlist *tlist; 104 char *prev; 105 { 106 char *s; 107 108 /* 109 * prev == NULL means return the first word in the list. 110 * Otherwise, return the word after "prev". 111 */ 112 if (prev == NULL) 113 s = tlist->string; 114 else 115 s = prev + strlen(prev); 116 if (s >= tlist->endstring) 117 return (NULL); 118 while (*s == '\0') 119 s++; 120 if (s >= tlist->endstring) 121 return (NULL); 122 return (s); 123 } 124 125 public char * 126 back_textlist(tlist, prev) 127 struct textlist *tlist; 128 char *prev; 129 { 130 char *s; 131 132 /* 133 * prev == NULL means return the last word in the list. 134 * Otherwise, return the word before "prev". 135 */ 136 if (prev == NULL) 137 s = tlist->endstring; 138 else if (prev <= tlist->string) 139 return (NULL); 140 else 141 s = prev - 1; 142 while (*s == '\0') 143 s--; 144 if (s <= tlist->string) 145 return (NULL); 146 while (s[-1] != '\0' && s > tlist->string) 147 s--; 148 return (s); 149 } 150 151 /* 152 * Close the current input file. 153 */ 154 static void 155 close_file() 156 { 157 struct scrpos scrpos; 158 159 if (curr_ifile == NULL_IFILE) 160 return; 161 162 /* 163 * Save the current position so that we can return to 164 * the same position if we edit this file again. 165 */ 166 get_scrpos(&scrpos); 167 if (scrpos.pos != NULL_POSITION) 168 { 169 store_pos(curr_ifile, &scrpos); 170 lastmark(); 171 } 172 /* 173 * Close the file descriptor, unless it is a pipe. 174 */ 175 ch_close(); 176 /* 177 * If we opened a file using an alternate name, 178 * do special stuff to close it. 179 */ 180 if (curr_altfilename != NULL) 181 { 182 close_altfile(curr_altfilename, get_filename(curr_ifile), 183 curr_altpipe); 184 free(curr_altfilename); 185 curr_altfilename = NULL; 186 } 187 curr_ifile = NULL_IFILE; 188 #if HAVE_STAT_INO 189 curr_ino = curr_dev = 0; 190 #endif 191 } 192 193 /* 194 * Edit a new file (given its name). 195 * Filename == "-" means standard input. 196 * Filename == NULL means just close the current file. 197 */ 198 public int 199 edit(filename) 200 char *filename; 201 { 202 if (filename == NULL) 203 return (edit_ifile(NULL_IFILE)); 204 return (edit_ifile(get_ifile(filename, curr_ifile))); 205 } 206 207 /* 208 * Edit a new file (given its IFILE). 209 * ifile == NULL means just close the current file. 210 */ 211 public int 212 edit_ifile(ifile) 213 IFILE ifile; 214 { 215 int f; 216 int answer; 217 int no_display; 218 int chflags; 219 char *filename; 220 char *open_filename; 221 char *qopen_filename; 222 char *alt_filename; 223 void *alt_pipe; 224 IFILE was_curr_ifile; 225 PARG parg; 226 227 if (ifile == curr_ifile) 228 { 229 /* 230 * Already have the correct file open. 231 */ 232 return (0); 233 } 234 235 /* 236 * We must close the currently open file now. 237 * This is necessary to make the open_altfile/close_altfile pairs 238 * nest properly (or rather to avoid nesting at all). 239 * {{ Some stupid implementations of popen() mess up if you do: 240 * fA = popen("A"); fB = popen("B"); pclose(fA); pclose(fB); }} 241 */ 242 #if LOGFILE 243 end_logfile(); 244 #endif 245 was_curr_ifile = save_curr_ifile(); 246 if (curr_ifile != NULL_IFILE) 247 { 248 chflags = ch_getflags(); 249 close_file(); 250 if ((chflags & CH_HELPFILE) && held_ifile(was_curr_ifile) <= 1) 251 { 252 /* 253 * Don't keep the help file in the ifile list. 254 */ 255 del_ifile(was_curr_ifile); 256 was_curr_ifile = old_ifile; 257 } 258 } 259 260 if (ifile == NULL_IFILE) 261 { 262 /* 263 * No new file to open. 264 * (Don't set old_ifile, because if you call edit_ifile(NULL), 265 * you're supposed to have saved curr_ifile yourself, 266 * and you'll restore it if necessary.) 267 */ 268 unsave_ifile(was_curr_ifile); 269 return (0); 270 } 271 272 filename = save(get_filename(ifile)); 273 /* 274 * See if LESSOPEN specifies an "alternate" file to open. 275 */ 276 alt_pipe = NULL; 277 alt_filename = open_altfile(filename, &f, &alt_pipe); 278 open_filename = (alt_filename != NULL) ? alt_filename : filename; 279 qopen_filename = shell_unquote(open_filename); 280 281 chflags = 0; 282 if (alt_pipe != NULL) 283 { 284 /* 285 * The alternate "file" is actually a pipe. 286 * f has already been set to the file descriptor of the pipe 287 * in the call to open_altfile above. 288 * Keep the file descriptor open because it was opened 289 * via popen(), and pclose() wants to close it. 290 */ 291 chflags |= CH_POPENED; 292 } else if (strcmp(open_filename, "-") == 0) 293 { 294 /* 295 * Use standard input. 296 * Keep the file descriptor open because we can't reopen it. 297 */ 298 f = fd0; 299 chflags |= CH_KEEPOPEN; 300 /* 301 * Must switch stdin to BINARY mode. 302 */ 303 SET_BINARY(f); 304 #if MSDOS_COMPILER==DJGPPC 305 /* 306 * Setting stdin to binary by default causes 307 * Ctrl-C to not raise SIGINT. We must undo 308 * that side-effect. 309 */ 310 __djgpp_set_ctrl_c(1); 311 #endif 312 } else if (strcmp(open_filename, FAKE_EMPTYFILE) == 0) 313 { 314 f = -1; 315 chflags |= CH_NODATA; 316 } else if (strcmp(open_filename, FAKE_HELPFILE) == 0) 317 { 318 f = -1; 319 chflags |= CH_HELPFILE; 320 } else if ((parg.p_string = bad_file(open_filename)) != NULL) 321 { 322 /* 323 * It looks like a bad file. Don't try to open it. 324 */ 325 error("%s", &parg); 326 free(parg.p_string); 327 err1: 328 if (alt_filename != NULL) 329 { 330 close_altfile(alt_filename, filename, alt_pipe); 331 free(alt_filename); 332 } 333 del_ifile(ifile); 334 free(qopen_filename); 335 free(filename); 336 /* 337 * Re-open the current file. 338 */ 339 if (was_curr_ifile == ifile) 340 { 341 /* 342 * Whoops. The "current" ifile is the one we just deleted. 343 * Just give up. 344 */ 345 quit(QUIT_ERROR); 346 } 347 reedit_ifile(was_curr_ifile); 348 return (1); 349 } else if ((f = open(qopen_filename, OPEN_READ)) < 0) 350 { 351 /* 352 * Got an error trying to open it. 353 */ 354 parg.p_string = errno_message(filename); 355 error("%s", &parg); 356 free(parg.p_string); 357 goto err1; 358 } else 359 { 360 chflags |= CH_CANSEEK; 361 if (!force_open && !opened(ifile) && bin_file(f)) 362 { 363 /* 364 * Looks like a binary file. 365 * Ask user if we should proceed. 366 */ 367 parg.p_string = filename; 368 answer = query("\"%s\" may be a binary file. See it anyway? ", 369 &parg); 370 if (answer != 'y' && answer != 'Y') 371 { 372 close(f); 373 goto err1; 374 } 375 } 376 } 377 378 /* 379 * Get the new ifile. 380 * Get the saved position for the file. 381 */ 382 if (was_curr_ifile != NULL_IFILE) 383 { 384 old_ifile = was_curr_ifile; 385 unsave_ifile(was_curr_ifile); 386 } 387 curr_ifile = ifile; 388 curr_altfilename = alt_filename; 389 curr_altpipe = alt_pipe; 390 set_open(curr_ifile); /* File has been opened */ 391 get_pos(curr_ifile, &initial_scrpos); 392 new_file = TRUE; 393 ch_init(f, chflags); 394 395 if (!(chflags & CH_HELPFILE)) 396 { 397 #if LOGFILE 398 if (namelogfile != NULL && is_tty) 399 use_logfile(namelogfile); 400 #endif 401 #if HAVE_STAT_INO 402 /* Remember the i-number and device of the opened file. */ 403 { 404 struct stat statbuf; 405 int r = stat(qopen_filename, &statbuf); 406 if (r == 0) 407 { 408 curr_ino = statbuf.st_ino; 409 curr_dev = statbuf.st_dev; 410 } 411 } 412 #endif 413 if (every_first_cmd != NULL) 414 { 415 ungetcc(CHAR_END_COMMAND); 416 ungetsc(every_first_cmd); 417 } 418 } 419 420 free(qopen_filename); 421 no_display = !any_display; 422 flush(); 423 any_display = TRUE; 424 425 if (is_tty) 426 { 427 /* 428 * Output is to a real tty. 429 */ 430 431 /* 432 * Indicate there is nothing displayed yet. 433 */ 434 pos_clear(); 435 clr_linenum(); 436 #if HILITE_SEARCH 437 clr_hilite(); 438 #endif 439 if (strcmp(filename, FAKE_HELPFILE) && strcmp(filename, FAKE_EMPTYFILE)) 440 cmd_addhist(ml_examine, filename, 1); 441 if (no_display && errmsgs > 0) 442 { 443 /* 444 * We displayed some messages on error output 445 * (file descriptor 2; see error() function). 446 * Before erasing the screen contents, 447 * display the file name and wait for a keystroke. 448 */ 449 parg.p_string = filename; 450 error("%s", &parg); 451 } 452 } 453 free(filename); 454 return (0); 455 } 456 457 /* 458 * Edit a space-separated list of files. 459 * For each filename in the list, enter it into the ifile list. 460 * Then edit the first one. 461 */ 462 public int 463 edit_list(filelist) 464 char *filelist; 465 { 466 IFILE save_ifile; 467 char *good_filename; 468 char *filename; 469 char *gfilelist; 470 char *gfilename; 471 struct textlist tl_files; 472 struct textlist tl_gfiles; 473 474 save_ifile = save_curr_ifile(); 475 good_filename = NULL; 476 477 /* 478 * Run thru each filename in the list. 479 * Try to glob the filename. 480 * If it doesn't expand, just try to open the filename. 481 * If it does expand, try to open each name in that list. 482 */ 483 init_textlist(&tl_files, filelist); 484 filename = NULL; 485 while ((filename = forw_textlist(&tl_files, filename)) != NULL) 486 { 487 gfilelist = lglob(filename); 488 init_textlist(&tl_gfiles, gfilelist); 489 gfilename = NULL; 490 while ((gfilename = forw_textlist(&tl_gfiles, gfilename)) != NULL) 491 { 492 if (edit(gfilename) == 0 && good_filename == NULL) 493 good_filename = get_filename(curr_ifile); 494 } 495 free(gfilelist); 496 } 497 /* 498 * Edit the first valid filename in the list. 499 */ 500 if (good_filename == NULL) 501 { 502 unsave_ifile(save_ifile); 503 return (1); 504 } 505 if (get_ifile(good_filename, curr_ifile) == curr_ifile) 506 { 507 /* 508 * Trying to edit the current file; don't reopen it. 509 */ 510 unsave_ifile(save_ifile); 511 return (0); 512 } 513 reedit_ifile(save_ifile); 514 return (edit(good_filename)); 515 } 516 517 /* 518 * Edit the first file in the command line (ifile) list. 519 */ 520 public int 521 edit_first() 522 { 523 curr_ifile = NULL_IFILE; 524 return (edit_next(1)); 525 } 526 527 /* 528 * Edit the last file in the command line (ifile) list. 529 */ 530 public int 531 edit_last() 532 { 533 curr_ifile = NULL_IFILE; 534 return (edit_prev(1)); 535 } 536 537 538 /* 539 * Edit the n-th next or previous file in the command line (ifile) list. 540 */ 541 static int 542 edit_istep(h, n, dir) 543 IFILE h; 544 int n; 545 int dir; 546 { 547 IFILE next; 548 549 /* 550 * Skip n filenames, then try to edit each filename. 551 */ 552 for (;;) 553 { 554 next = (dir > 0) ? next_ifile(h) : prev_ifile(h); 555 if (--n < 0) 556 { 557 if (edit_ifile(h) == 0) 558 break; 559 } 560 if (next == NULL_IFILE) 561 { 562 /* 563 * Reached end of the ifile list. 564 */ 565 return (1); 566 } 567 if (ABORT_SIGS()) 568 { 569 /* 570 * Interrupt breaks out, if we're in a long 571 * list of files that can't be opened. 572 */ 573 return (1); 574 } 575 h = next; 576 } 577 /* 578 * Found a file that we can edit. 579 */ 580 return (0); 581 } 582 583 static int 584 edit_inext(h, n) 585 IFILE h; 586 int n; 587 { 588 return (edit_istep(h, n, +1)); 589 } 590 591 public int 592 edit_next(n) 593 int n; 594 { 595 return edit_istep(curr_ifile, n, +1); 596 } 597 598 static int 599 edit_iprev(h, n) 600 IFILE h; 601 int n; 602 { 603 return (edit_istep(h, n, -1)); 604 } 605 606 public int 607 edit_prev(n) 608 int n; 609 { 610 return edit_istep(curr_ifile, n, -1); 611 } 612 613 /* 614 * Edit a specific file in the command line (ifile) list. 615 */ 616 public int 617 edit_index(n) 618 int n; 619 { 620 IFILE h; 621 622 h = NULL_IFILE; 623 do 624 { 625 if ((h = next_ifile(h)) == NULL_IFILE) 626 { 627 /* 628 * Reached end of the list without finding it. 629 */ 630 return (1); 631 } 632 } while (get_index(h) != n); 633 634 return (edit_ifile(h)); 635 } 636 637 public IFILE 638 save_curr_ifile() 639 { 640 if (curr_ifile != NULL_IFILE) 641 hold_ifile(curr_ifile, 1); 642 return (curr_ifile); 643 } 644 645 public void 646 unsave_ifile(save_ifile) 647 IFILE save_ifile; 648 { 649 if (save_ifile != NULL_IFILE) 650 hold_ifile(save_ifile, -1); 651 } 652 653 /* 654 * Reedit the ifile which was previously open. 655 */ 656 public void 657 reedit_ifile(save_ifile) 658 IFILE save_ifile; 659 { 660 IFILE next; 661 IFILE prev; 662 663 /* 664 * Try to reopen the ifile. 665 * Note that opening it may fail (maybe the file was removed), 666 * in which case the ifile will be deleted from the list. 667 * So save the next and prev ifiles first. 668 */ 669 unsave_ifile(save_ifile); 670 next = next_ifile(save_ifile); 671 prev = prev_ifile(save_ifile); 672 if (edit_ifile(save_ifile) == 0) 673 return; 674 /* 675 * If can't reopen it, open the next input file in the list. 676 */ 677 if (next != NULL_IFILE && edit_inext(next, 0) == 0) 678 return; 679 /* 680 * If can't open THAT one, open the previous input file in the list. 681 */ 682 if (prev != NULL_IFILE && edit_iprev(prev, 0) == 0) 683 return; 684 /* 685 * If can't even open that, we're stuck. Just quit. 686 */ 687 quit(QUIT_ERROR); 688 } 689 690 public void 691 reopen_curr_ifile() 692 { 693 IFILE save_ifile = save_curr_ifile(); 694 close_file(); 695 reedit_ifile(save_ifile); 696 } 697 698 /* 699 * Edit standard input. 700 */ 701 public int 702 edit_stdin() 703 { 704 if (isatty(fd0)) 705 { 706 error("Missing filename (\"less --help\" for help)", NULL_PARG); 707 quit(QUIT_OK); 708 } 709 return (edit("-")); 710 } 711 712 /* 713 * Copy a file directly to standard output. 714 * Used if standard output is not a tty. 715 */ 716 public void 717 cat_file() 718 { 719 register int c; 720 721 while ((c = ch_forw_get()) != EOI) 722 putchr(c); 723 flush(); 724 } 725 726 #if LOGFILE 727 728 /* 729 * If the user asked for a log file and our input file 730 * is standard input, create the log file. 731 * We take care not to blindly overwrite an existing file. 732 */ 733 public void 734 use_logfile(filename) 735 char *filename; 736 { 737 register int exists; 738 register int answer; 739 PARG parg; 740 741 if (ch_getflags() & CH_CANSEEK) 742 /* 743 * Can't currently use a log file on a file that can seek. 744 */ 745 return; 746 747 /* 748 * {{ We could use access() here. }} 749 */ 750 filename = shell_unquote(filename); 751 exists = open(filename, OPEN_READ); 752 if (exists >= 0) 753 close(exists); 754 exists = (exists >= 0); 755 756 /* 757 * Decide whether to overwrite the log file or append to it. 758 * If it doesn't exist we "overwrite" it. 759 */ 760 if (!exists || force_logfile) 761 { 762 /* 763 * Overwrite (or create) the log file. 764 */ 765 answer = 'O'; 766 } else 767 { 768 /* 769 * Ask user what to do. 770 */ 771 parg.p_string = filename; 772 answer = query("Warning: \"%s\" exists; Overwrite, Append or Don't log? ", &parg); 773 } 774 775 loop: 776 switch (answer) 777 { 778 case 'O': case 'o': 779 /* 780 * Overwrite: create the file. 781 */ 782 logfile = creat(filename, 0644); 783 break; 784 case 'A': case 'a': 785 /* 786 * Append: open the file and seek to the end. 787 */ 788 logfile = open(filename, OPEN_APPEND); 789 if (lseek(logfile, (off_t)0, SEEK_END) == BAD_LSEEK) 790 { 791 close(logfile); 792 logfile = -1; 793 } 794 break; 795 case 'D': case 'd': 796 /* 797 * Don't do anything. 798 */ 799 free(filename); 800 return; 801 case 'q': 802 quit(QUIT_OK); 803 /*NOTREACHED*/ 804 default: 805 /* 806 * Eh? 807 */ 808 answer = query("Overwrite, Append, or Don't log? (Type \"O\", \"A\", \"D\" or \"q\") ", NULL_PARG); 809 goto loop; 810 } 811 812 if (logfile < 0) 813 { 814 /* 815 * Error in opening logfile. 816 */ 817 parg.p_string = filename; 818 error("Cannot write to \"%s\"", &parg); 819 free(filename); 820 return; 821 } 822 free(filename); 823 SET_BINARY(logfile); 824 } 825 826 #endif 827