1 /* 2 * Copyright (C) 1984-2002 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 /* 13 * Routines to mess around with filenames (and files). 14 * Much of this is very OS dependent. 15 */ 16 17 #include "less.h" 18 #include "lglob.h" 19 #if MSDOS_COMPILER 20 #include <dos.h> 21 #if MSDOS_COMPILER==WIN32C && !defined(_MSC_VER) 22 #include <dir.h> 23 #endif 24 #if MSDOS_COMPILER==DJGPPC 25 #include <glob.h> 26 #include <dir.h> 27 #define _MAX_PATH PATH_MAX 28 #endif 29 #endif 30 #ifdef _OSK 31 #include <rbf.h> 32 #ifndef _OSK_MWC32 33 #include <modes.h> 34 #endif 35 #endif 36 #if OS2 37 #include <signal.h> 38 #endif 39 40 #if HAVE_STAT 41 #include <sys/stat.h> 42 #ifndef S_ISDIR 43 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) 44 #endif 45 #ifndef S_ISREG 46 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) 47 #endif 48 #endif 49 50 51 extern int force_open; 52 extern int secure; 53 extern int use_lessopen; 54 extern IFILE curr_ifile; 55 extern IFILE old_ifile; 56 #if SPACES_IN_FILENAMES 57 extern char openquote; 58 extern char closequote; 59 #endif 60 61 /* 62 * Remove quotes around a filename. 63 */ 64 public char * 65 shell_unquote(str) 66 char *str; 67 { 68 char *name; 69 char *p; 70 71 name = p = (char *) ecalloc(strlen(str)+1, sizeof(char)); 72 if (*str == openquote) 73 { 74 str++; 75 while (*str != '\0') 76 { 77 if (*str == closequote) 78 { 79 if (str[1] != closequote) 80 break; 81 str++; 82 } 83 *p++ = *str++; 84 } 85 } else 86 { 87 char *esc = get_meta_escape(); 88 int esclen = strlen(esc); 89 while (*str != '\0') 90 { 91 if (esclen > 0 && strncmp(str, esc, esclen) == 0) 92 str += esclen; 93 *p++ = *str++; 94 } 95 } 96 *p = '\0'; 97 return (name); 98 } 99 100 /* 101 * Get the shell's escape character. 102 */ 103 public char * 104 get_meta_escape() 105 { 106 char *s; 107 108 s = lgetenv("LESSMETAESCAPE"); 109 if (s == NULL) 110 s = DEF_METAESCAPE; 111 return (s); 112 } 113 114 /* 115 * Get the characters which the shell considers to be "metacharacters". 116 */ 117 static char * 118 metachars() 119 { 120 static char *mchars = NULL; 121 122 if (mchars == NULL) 123 { 124 mchars = lgetenv("LESSMETACHARS"); 125 if (mchars == NULL) 126 mchars = DEF_METACHARS; 127 } 128 return (mchars); 129 } 130 131 /* 132 * Is this a shell metacharacter? 133 */ 134 static int 135 metachar(c) 136 char c; 137 { 138 return (strchr(metachars(), c) != NULL); 139 } 140 141 /* 142 * Insert a backslash before each metacharacter in a string. 143 */ 144 public char * 145 shell_quote(s) 146 char *s; 147 { 148 char *p; 149 char *newstr; 150 int len; 151 char *esc = get_meta_escape(); 152 int esclen = strlen(esc); 153 int use_quotes = 0; 154 int have_quotes = 0; 155 156 /* 157 * Determine how big a string we need to allocate. 158 */ 159 len = 1; /* Trailing null byte */ 160 for (p = s; *p != '\0'; p++) 161 { 162 len++; 163 if (*p == openquote || *p == closequote) 164 have_quotes = 1; 165 if (metachar(*p)) 166 { 167 if (esclen == 0) 168 { 169 /* 170 * We've got a metachar, but this shell 171 * doesn't support escape chars. Use quotes. 172 */ 173 use_quotes = 1; 174 } else 175 { 176 /* 177 * Allow space for the escape char. 178 */ 179 len += esclen; 180 } 181 } 182 } 183 if (use_quotes) 184 { 185 if (have_quotes) 186 /* 187 * We can't quote a string that contains quotes. 188 */ 189 return (NULL); 190 len = strlen(s) + 3; 191 } 192 /* 193 * Allocate and construct the new string. 194 */ 195 newstr = p = (char *) ecalloc(len, sizeof(char)); 196 if (use_quotes) 197 { 198 sprintf(newstr, "%c%s%c", openquote, s, closequote); 199 } else 200 { 201 while (*s != '\0') 202 { 203 if (metachar(*s)) 204 { 205 /* 206 * Add the escape char. 207 */ 208 strcpy(p, esc); 209 p += esclen; 210 } 211 *p++ = *s++; 212 } 213 *p = '\0'; 214 } 215 return (newstr); 216 } 217 218 /* 219 * Return a pathname that points to a specified file in a specified directory. 220 * Return NULL if the file does not exist in the directory. 221 */ 222 static char * 223 dirfile(dirname, filename) 224 char *dirname; 225 char *filename; 226 { 227 char *pathname; 228 char *qpathname; 229 int f; 230 231 if (dirname == NULL || *dirname == '\0') 232 return (NULL); 233 /* 234 * Construct the full pathname. 235 */ 236 pathname = (char *) calloc(strlen(dirname) + strlen(filename) + 2, 237 sizeof(char)); 238 if (pathname == NULL) 239 return (NULL); 240 sprintf(pathname, "%s%s%s", dirname, PATHNAME_SEP, filename); 241 /* 242 * Make sure the file exists. 243 */ 244 qpathname = shell_unquote(pathname); 245 f = open(qpathname, OPEN_READ); 246 if (f < 0) 247 { 248 free(pathname); 249 pathname = NULL; 250 } else 251 { 252 close(f); 253 } 254 free(qpathname); 255 return (pathname); 256 } 257 258 /* 259 * Return the full pathname of the given file in the "home directory". 260 */ 261 public char * 262 homefile(filename) 263 char *filename; 264 { 265 register char *pathname; 266 267 /* 268 * Try $HOME/filename. 269 */ 270 pathname = dirfile(lgetenv("HOME"), filename); 271 if (pathname != NULL) 272 return (pathname); 273 #if OS2 274 /* 275 * Try $INIT/filename. 276 */ 277 pathname = dirfile(lgetenv("INIT"), filename); 278 if (pathname != NULL) 279 return (pathname); 280 #endif 281 #if MSDOS_COMPILER || OS2 282 /* 283 * Look for the file anywhere on search path. 284 */ 285 pathname = (char *) calloc(_MAX_PATH, sizeof(char)); 286 #if MSDOS_COMPILER==DJGPPC 287 { 288 char *res = searchpath(filename); 289 if (res == 0) 290 *pathname = '\0'; 291 else 292 strcpy(pathname, res); 293 } 294 #else 295 _searchenv(filename, "PATH", pathname); 296 #endif 297 if (*pathname != '\0') 298 return (pathname); 299 free(pathname); 300 #endif 301 return (NULL); 302 } 303 304 /* 305 * Expand a string, substituting any "%" with the current filename, 306 * and any "#" with the previous filename. 307 * But a string of N "%"s is just replaced with N-1 "%"s. 308 * Likewise for a string of N "#"s. 309 * {{ This is a lot of work just to support % and #. }} 310 */ 311 public char * 312 fexpand(s) 313 char *s; 314 { 315 register char *fr, *to; 316 register int n; 317 register char *e; 318 IFILE ifile; 319 320 #define fchar_ifile(c) \ 321 ((c) == '%' ? curr_ifile : \ 322 (c) == '#' ? old_ifile : NULL_IFILE) 323 324 /* 325 * Make one pass to see how big a buffer we 326 * need to allocate for the expanded string. 327 */ 328 n = 0; 329 for (fr = s; *fr != '\0'; fr++) 330 { 331 switch (*fr) 332 { 333 case '%': 334 case '#': 335 if (fr > s && fr[-1] == *fr) 336 { 337 /* 338 * Second (or later) char in a string 339 * of identical chars. Treat as normal. 340 */ 341 n++; 342 } else if (fr[1] != *fr) 343 { 344 /* 345 * Single char (not repeated). Treat specially. 346 */ 347 ifile = fchar_ifile(*fr); 348 if (ifile == NULL_IFILE) 349 n++; 350 else 351 n += strlen(get_filename(ifile)); 352 } 353 /* 354 * Else it is the first char in a string of 355 * identical chars. Just discard it. 356 */ 357 break; 358 default: 359 n++; 360 break; 361 } 362 } 363 364 e = (char *) ecalloc(n+1, sizeof(char)); 365 366 /* 367 * Now copy the string, expanding any "%" or "#". 368 */ 369 to = e; 370 for (fr = s; *fr != '\0'; fr++) 371 { 372 switch (*fr) 373 { 374 case '%': 375 case '#': 376 if (fr > s && fr[-1] == *fr) 377 { 378 *to++ = *fr; 379 } else if (fr[1] != *fr) 380 { 381 ifile = fchar_ifile(*fr); 382 if (ifile == NULL_IFILE) 383 *to++ = *fr; 384 else 385 { 386 strcpy(to, get_filename(ifile)); 387 to += strlen(to); 388 } 389 } 390 break; 391 default: 392 *to++ = *fr; 393 break; 394 } 395 } 396 *to = '\0'; 397 return (e); 398 } 399 400 #if TAB_COMPLETE_FILENAME 401 402 /* 403 * Return a blank-separated list of filenames which "complete" 404 * the given string. 405 */ 406 public char * 407 fcomplete(s) 408 char *s; 409 { 410 char *fpat; 411 char *qs; 412 413 if (secure) 414 return (NULL); 415 /* 416 * Complete the filename "s" by globbing "s*". 417 */ 418 #if MSDOS_COMPILER && (MSDOS_COMPILER == MSOFTC || MSDOS_COMPILER == BORLANDC) 419 /* 420 * But in DOS, we have to glob "s*.*". 421 * But if the final component of the filename already has 422 * a dot in it, just do "s*". 423 * (Thus, "FILE" is globbed as "FILE*.*", 424 * but "FILE.A" is globbed as "FILE.A*"). 425 */ 426 { 427 char *slash; 428 for (slash = s+strlen(s)-1; slash > s; slash--) 429 if (*slash == *PATHNAME_SEP || *slash == '/') 430 break; 431 fpat = (char *) ecalloc(strlen(s)+4, sizeof(char)); 432 if (strchr(slash, '.') == NULL) 433 sprintf(fpat, "%s*.*", s); 434 else 435 sprintf(fpat, "%s*", s); 436 } 437 #else 438 fpat = (char *) ecalloc(strlen(s)+2, sizeof(char)); 439 sprintf(fpat, "%s*", s); 440 #endif 441 qs = lglob(fpat); 442 s = shell_unquote(qs); 443 if (strcmp(s,fpat) == 0) 444 { 445 /* 446 * The filename didn't expand. 447 */ 448 free(qs); 449 qs = NULL; 450 } 451 free(s); 452 free(fpat); 453 return (qs); 454 } 455 #endif 456 457 /* 458 * Try to determine if a file is "binary". 459 * This is just a guess, and we need not try too hard to make it accurate. 460 */ 461 public int 462 bin_file(f) 463 int f; 464 { 465 int i; 466 int n; 467 unsigned char data[64]; 468 469 if (!seekable(f)) 470 return (0); 471 if (lseek(f, (off_t)0, 0) == BAD_LSEEK) 472 return (0); 473 n = read(f, data, sizeof(data)); 474 for (i = 0; i < n; i++) 475 if (binary_char(data[i])) 476 return (1); 477 return (0); 478 } 479 480 /* 481 * Try to determine the size of a file by seeking to the end. 482 */ 483 static POSITION 484 seek_filesize(f) 485 int f; 486 { 487 off_t spos; 488 489 spos = lseek(f, (off_t)0, 2); 490 if (spos == BAD_LSEEK) 491 return (NULL_POSITION); 492 return ((POSITION) spos); 493 } 494 495 /* 496 * Read a string from a file. 497 * Return a pointer to the string in memory. 498 */ 499 static char * 500 readfd(fd) 501 FILE *fd; 502 { 503 int len; 504 int ch; 505 char *buf; 506 char *p; 507 508 /* 509 * Make a guess about how many chars in the string 510 * and allocate a buffer to hold it. 511 */ 512 len = 100; 513 buf = (char *) ecalloc(len, sizeof(char)); 514 for (p = buf; ; p++) 515 { 516 if ((ch = getc(fd)) == '\n' || ch == EOF) 517 break; 518 if (p - buf >= len-1) 519 { 520 /* 521 * The string is too big to fit in the buffer we have. 522 * Allocate a new buffer, twice as big. 523 */ 524 len *= 2; 525 *p = '\0'; 526 p = (char *) ecalloc(len, sizeof(char)); 527 strcpy(p, buf); 528 free(buf); 529 buf = p; 530 p = buf + strlen(buf); 531 } 532 *p = ch; 533 } 534 *p = '\0'; 535 return (buf); 536 } 537 538 539 540 #if HAVE_POPEN 541 542 FILE *popen(); 543 544 /* 545 * Execute a shell command. 546 * Return a pointer to a pipe connected to the shell command's standard output. 547 */ 548 static FILE * 549 shellcmd(cmd) 550 char *cmd; 551 { 552 FILE *fd; 553 554 #if HAVE_SHELL 555 char *shell; 556 557 shell = lgetenv("SHELL"); 558 if (shell != NULL && *shell != '\0') 559 { 560 char *scmd; 561 char *esccmd; 562 563 /* 564 * Read the output of <$SHELL -c cmd>. 565 * Escape any metacharacters in the command. 566 */ 567 esccmd = shell_quote(cmd); 568 if (esccmd == NULL) 569 { 570 fd = popen(cmd, "r"); 571 } else 572 { 573 scmd = (char *) ecalloc(strlen(shell) + strlen(esccmd) + 5, 574 sizeof(char)); 575 sprintf(scmd, "%s %s %s", shell, shell_coption(), esccmd); 576 free(esccmd); 577 fd = popen(scmd, "r"); 578 free(scmd); 579 } 580 } else 581 #endif 582 { 583 fd = popen(cmd, "r"); 584 } 585 /* 586 * Redirection in `popen' might have messed with the 587 * standard devices. Restore binary input mode. 588 */ 589 SET_BINARY(0); 590 return (fd); 591 } 592 593 #endif /* HAVE_POPEN */ 594 595 596 /* 597 * Expand a filename, doing any system-specific metacharacter substitutions. 598 */ 599 public char * 600 lglob(filename) 601 char *filename; 602 { 603 char *gfilename; 604 char *ofilename; 605 606 ofilename = fexpand(filename); 607 if (secure) 608 return (ofilename); 609 filename = shell_unquote(ofilename); 610 611 #ifdef DECL_GLOB_LIST 612 { 613 /* 614 * The globbing function returns a list of names. 615 */ 616 int length; 617 char *p; 618 char *qfilename; 619 DECL_GLOB_LIST(list) 620 621 GLOB_LIST(filename, list); 622 if (GLOB_LIST_FAILED(list)) 623 { 624 free(filename); 625 return (ofilename); 626 } 627 length = 1; /* Room for trailing null byte */ 628 for (SCAN_GLOB_LIST(list, p)) 629 { 630 INIT_GLOB_LIST(list, p); 631 qfilename = shell_quote(p); 632 if (qfilename != NULL) 633 { 634 length += strlen(qfilename) + 1; 635 free(qfilename); 636 } 637 } 638 gfilename = (char *) ecalloc(length, sizeof(char)); 639 for (SCAN_GLOB_LIST(list, p)) 640 { 641 INIT_GLOB_LIST(list, p); 642 qfilename = shell_quote(p); 643 if (qfilename != NULL) 644 { 645 sprintf(gfilename + strlen(gfilename), "%s ", qfilename); 646 free(qfilename); 647 } 648 } 649 /* 650 * Overwrite the final trailing space with a null terminator. 651 */ 652 *--p = '\0'; 653 GLOB_LIST_DONE(list); 654 } 655 #else 656 #ifdef DECL_GLOB_NAME 657 { 658 /* 659 * The globbing function returns a single name, and 660 * is called multiple times to walk thru all names. 661 */ 662 register char *p; 663 register int len; 664 register int n; 665 char *pathname; 666 char *qpathname; 667 DECL_GLOB_NAME(fnd,drive,dir,fname,ext,handle) 668 669 GLOB_FIRST_NAME(filename, &fnd, handle); 670 if (GLOB_FIRST_FAILED(handle)) 671 { 672 free(filename); 673 return (ofilename); 674 } 675 676 _splitpath(filename, drive, dir, fname, ext); 677 len = 100; 678 gfilename = (char *) ecalloc(len, sizeof(char)); 679 p = gfilename; 680 do { 681 n = strlen(drive) + strlen(dir) + strlen(fnd.GLOB_NAME) + 1; 682 pathname = (char *) ecalloc(n, sizeof(char)); 683 sprintf(pathname, "%s%s%s", drive, dir, fnd.GLOB_NAME); 684 qpathname = shell_quote(pathname); 685 free(pathname); 686 if (qpathname != NULL) 687 { 688 n = strlen(qpathname); 689 while (p - gfilename + n + 2 >= len) 690 { 691 /* 692 * No room in current buffer. 693 * Allocate a bigger one. 694 */ 695 len *= 2; 696 *p = '\0'; 697 p = (char *) ecalloc(len, sizeof(char)); 698 strcpy(p, gfilename); 699 free(gfilename); 700 gfilename = p; 701 p = gfilename + strlen(gfilename); 702 } 703 strcpy(p, qpathname); 704 free(qpathname); 705 p += n; 706 *p++ = ' '; 707 } 708 } while (GLOB_NEXT_NAME(handle, &fnd) == 0); 709 710 /* 711 * Overwrite the final trailing space with a null terminator. 712 */ 713 *--p = '\0'; 714 GLOB_NAME_DONE(handle); 715 } 716 #else 717 #if HAVE_POPEN 718 { 719 /* 720 * We get the shell to glob the filename for us by passing 721 * an "echo" command to the shell and reading its output. 722 */ 723 FILE *fd; 724 char *s; 725 char *lessecho; 726 char *cmd; 727 char *esc; 728 729 esc = get_meta_escape(); 730 if (strlen(esc) == 0) 731 esc = "-"; 732 esc = shell_quote(esc); 733 if (esc == NULL) 734 { 735 free(filename); 736 return (ofilename); 737 } 738 lessecho = lgetenv("LESSECHO"); 739 if (lessecho == NULL || *lessecho == '\0') 740 lessecho = "lessecho"; 741 /* 742 * Invoke lessecho, and read its output (a globbed list of filenames). 743 */ 744 cmd = (char *) ecalloc(strlen(lessecho) + strlen(ofilename) + (7*strlen(metachars())) + 24, sizeof(char)); 745 sprintf(cmd, "%s -p0x%x -d0x%x -e%s ", lessecho, openquote, closequote, esc); 746 free(esc); 747 for (s = metachars(); *s != '\0'; s++) 748 sprintf(cmd + strlen(cmd), "-n0x%x ", *s); 749 sprintf(cmd + strlen(cmd), "-- %s", ofilename); 750 fd = shellcmd(cmd); 751 free(cmd); 752 if (fd == NULL) 753 { 754 /* 755 * Cannot create the pipe. 756 * Just return the original (fexpanded) filename. 757 */ 758 free(filename); 759 return (ofilename); 760 } 761 gfilename = readfd(fd); 762 pclose(fd); 763 if (*gfilename == '\0') 764 { 765 free(gfilename); 766 free(filename); 767 return (ofilename); 768 } 769 } 770 #else 771 /* 772 * No globbing functions at all. Just use the fexpanded filename. 773 */ 774 gfilename = save(filename); 775 #endif 776 #endif 777 #endif 778 free(filename); 779 free(ofilename); 780 return (gfilename); 781 } 782 783 /* 784 * See if we should open a "replacement file" 785 * instead of the file we're about to open. 786 */ 787 public char * 788 open_altfile(filename, pf, pfd) 789 char *filename; 790 int *pf; 791 void **pfd; 792 { 793 #if !HAVE_POPEN 794 return (NULL); 795 #else 796 char *lessopen; 797 char *cmd; 798 FILE *fd; 799 #if HAVE_FILENO 800 int returnfd = 0; 801 #endif 802 803 if (!use_lessopen || secure) 804 return (NULL); 805 ch_ungetchar(-1); 806 if ((lessopen = lgetenv("LESSOPEN")) == NULL) 807 return (NULL); 808 if (strcmp(filename, "-") == 0) 809 return (NULL); 810 if (*lessopen == '|') 811 { 812 /* 813 * If LESSOPEN starts with a |, it indicates 814 * a "pipe preprocessor". 815 */ 816 #if HAVE_FILENO 817 lessopen++; 818 returnfd = 1; 819 #else 820 error("LESSOPEN pipe is not supported", NULL_PARG); 821 return (NULL); 822 #endif 823 } 824 825 cmd = (char *) ecalloc(strlen(lessopen) + strlen(filename) + 2, 826 sizeof(char)); 827 sprintf(cmd, lessopen, filename); 828 fd = shellcmd(cmd); 829 free(cmd); 830 if (fd == NULL) 831 { 832 /* 833 * Cannot create the pipe. 834 */ 835 return (NULL); 836 } 837 #if HAVE_FILENO 838 if (returnfd) 839 { 840 int f; 841 char c; 842 843 /* 844 * Read one char to see if the pipe will produce any data. 845 * If it does, push the char back on the pipe. 846 */ 847 f = fileno(fd); 848 SET_BINARY(f); 849 if (read(f, &c, 1) != 1) 850 { 851 /* 852 * Pipe is empty. This means there is no alt file. 853 */ 854 pclose(fd); 855 return (NULL); 856 } 857 ch_ungetchar(c); 858 *pfd = (void *) fd; 859 *pf = f; 860 return (save("-")); 861 } 862 #endif 863 cmd = readfd(fd); 864 pclose(fd); 865 if (*cmd == '\0') 866 /* 867 * Pipe is empty. This means there is no alt file. 868 */ 869 return (NULL); 870 return (cmd); 871 #endif /* HAVE_POPEN */ 872 } 873 874 /* 875 * Close a replacement file. 876 */ 877 public void 878 close_altfile(altfilename, filename, pipefd) 879 char *altfilename; 880 char *filename; 881 void *pipefd; 882 { 883 #if HAVE_POPEN 884 char *lessclose; 885 FILE *fd; 886 char *cmd; 887 888 if (secure) 889 return; 890 if (pipefd != NULL) 891 { 892 #if OS2 893 /* 894 * The pclose function of OS/2 emx sometimes fails. 895 * Send SIGINT to the piped process before closing it. 896 */ 897 kill(((FILE*)pipefd)->_pid, SIGINT); 898 #endif 899 pclose((FILE*) pipefd); 900 } 901 if ((lessclose = lgetenv("LESSCLOSE")) == NULL) 902 return; 903 cmd = (char *) ecalloc(strlen(lessclose) + strlen(filename) + 904 strlen(altfilename) + 2, sizeof(char)); 905 sprintf(cmd, lessclose, filename, altfilename); 906 fd = shellcmd(cmd); 907 free(cmd); 908 if (fd != NULL) 909 pclose(fd); 910 #endif 911 } 912 913 /* 914 * Is the specified file a directory? 915 */ 916 public int 917 is_dir(filename) 918 char *filename; 919 { 920 int isdir = 0; 921 922 filename = shell_unquote(filename); 923 #if HAVE_STAT 924 { 925 int r; 926 struct stat statbuf; 927 928 r = stat(filename, &statbuf); 929 isdir = (r >= 0 && S_ISDIR(statbuf.st_mode)); 930 } 931 #else 932 #ifdef _OSK 933 { 934 register int f; 935 936 f = open(filename, S_IREAD | S_IFDIR); 937 if (f >= 0) 938 close(f); 939 isdir = (f >= 0); 940 } 941 #endif 942 #endif 943 free(filename); 944 return (isdir); 945 } 946 947 /* 948 * Returns NULL if the file can be opened and 949 * is an ordinary file, otherwise an error message 950 * (if it cannot be opened or is a directory, etc.) 951 */ 952 public char * 953 bad_file(filename) 954 char *filename; 955 { 956 register char *m = NULL; 957 958 filename = shell_unquote(filename); 959 if (is_dir(filename)) 960 { 961 static char is_a_dir[] = " is a directory"; 962 963 m = (char *) ecalloc(strlen(filename) + sizeof(is_a_dir), 964 sizeof(char)); 965 strcpy(m, filename); 966 strcat(m, is_a_dir); 967 } else 968 { 969 #if HAVE_STAT 970 int r; 971 struct stat statbuf; 972 973 r = stat(filename, &statbuf); 974 if (r < 0) 975 { 976 m = errno_message(filename); 977 } else if (force_open) 978 { 979 m = NULL; 980 } else if (!S_ISREG(statbuf.st_mode)) 981 { 982 static char not_reg[] = " is not a regular file (use -f to see it)"; 983 m = (char *) ecalloc(strlen(filename) + sizeof(not_reg), 984 sizeof(char)); 985 strcpy(m, filename); 986 strcat(m, not_reg); 987 } 988 #endif 989 } 990 free(filename); 991 return (m); 992 } 993 994 /* 995 * Return the size of a file, as cheaply as possible. 996 * In Unix, we can stat the file. 997 */ 998 public POSITION 999 filesize(f) 1000 int f; 1001 { 1002 #if HAVE_STAT 1003 struct stat statbuf; 1004 1005 if (fstat(f, &statbuf) >= 0) 1006 return ((POSITION) statbuf.st_size); 1007 #else 1008 #ifdef _OSK 1009 long size; 1010 1011 if ((size = (long) _gs_size(f)) >= 0) 1012 return ((POSITION) size); 1013 #endif 1014 #endif 1015 return (seek_filesize(f)); 1016 } 1017 1018 /* 1019 * 1020 */ 1021 public char * 1022 shell_coption() 1023 { 1024 return ("-c"); 1025 } 1026