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