contrib/less/filename.c

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