contrib/less/filename.c

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