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