Deleted Added
sdiff udiff text old ( 89019 ) new ( 128345 )
full compact
filename.c (89019) filename.c (128345)
1/*
1/*
2 * Copyright (C) 1984-2000 Mark Nudelman
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

--- 34 unchanged lines hidden (view full) ---

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;
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

--- 34 unchanged lines hidden (view full) ---

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;
53extern IFILE curr_ifile;
54extern IFILE old_ifile;
55#if SPACES_IN_FILENAMES
56extern char openquote;
57extern char closequote;
58#endif
59
60/*
61 * Remove quotes around a filename.
62 */
63 public char *
54extern IFILE curr_ifile;
55extern IFILE old_ifile;
56#if SPACES_IN_FILENAMES
57extern char openquote;
58extern char closequote;
59#endif
60
61/*
62 * Remove quotes around a filename.
63 */
64 public char *
64unquote_file(str)
65shell_unquote(str)
65 char *str;
66{
66 char *str;
67{
67#if SPACES_IN_FILENAMES
68 char *name;
69 char *p;
70
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';
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';
78 return (name);
97 return (name);
79#else
80 return (save(str));
81#endif
82}
83
84/*
98}
99
100/*
101 * Get the shell's escape character.
102 */
103 public char *
104get_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 *
118metachars()
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
135metachar(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 *
145shell_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/*
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 *
89dirfile(dirname, filename)
90 char *dirname;
91 char *filename;
92{

--- 9 unchanged lines hidden (view full) ---

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 */
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 *
223dirfile(dirname, filename)
224 char *dirname;
225 char *filename;
226{

--- 9 unchanged lines hidden (view full) ---

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 */
110 qpathname = unquote_file(pathname);
244 qpathname = shell_unquote(pathname);
111 f = open(qpathname, OPEN_READ);
112 if (f < 0)
113 {
114 free(pathname);
115 pathname = NULL;
116 } else
117 {
118 close(f);

--- 150 unchanged lines hidden (view full) ---

269 * Return a blank-separated list of filenames which "complete"
270 * the given string.
271 */
272 public char *
273fcomplete(s)
274 char *s;
275{
276 char *fpat;
245 f = open(qpathname, OPEN_READ);
246 if (f < 0)
247 {
248 free(pathname);
249 pathname = NULL;
250 } else
251 {
252 close(f);

--- 150 unchanged lines hidden (view full) ---

403 * Return a blank-separated list of filenames which "complete"
404 * the given string.
405 */
406 public char *
407fcomplete(s)
408 char *s;
409{
410 char *fpat;
411 char *qs;
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 /*

--- 13 unchanged lines hidden (view full) ---

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
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 /*

--- 13 unchanged lines hidden (view full) ---

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
306 s = lglob(fpat);
441 qs = lglob(fpat);
442 s = shell_unquote(qs);
307 if (strcmp(s,fpat) == 0)
308 {
309 /*
310 * The filename didn't expand.
311 */
443 if (strcmp(s,fpat) == 0)
444 {
445 /*
446 * The filename didn't expand.
447 */
312 free(s);
313 s = NULL;
448 free(qs);
449 qs = NULL;
314 }
450 }
451 free(s);
315 free(fpat);
452 free(fpat);
316 return (s);
453 return (qs);
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

--- 68 unchanged lines hidden (view full) ---

393 p = buf + strlen(buf);
394 }
395 *p = ch;
396 }
397 *p = '\0';
398 return (buf);
399}
400
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

--- 68 unchanged lines hidden (view full) ---

530 p = buf + strlen(buf);
531 }
532 *p = ch;
533 }
534 *p = '\0';
535 return (buf);
536}
537
401#if HAVE_SHELL
402
538
403/*
404 * Get the shell's escape character.
405 */
406 static char *
407get_meta_escape()
408{
409 char *s;
410
539
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
421metachar(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 *
439esc_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 *
496esc_metachars(s)
497 char *s;
498{
499 return (save(s));
500}
501
502#endif /* HAVE_SHELL */
503
504
505#if HAVE_POPEN
506
507FILE *popen();
508
509/*
510 * Execute a shell command.
511 * Return a pointer to a pipe connected to the shell command's standard output.
512 */

--- 8 unchanged lines hidden (view full) ---

521
522 shell = lgetenv("SHELL");
523 if (shell != NULL && *shell != '\0')
524 {
525 char *scmd;
526 char *esccmd;
527
528 /*
540#if HAVE_POPEN
541
542FILE *popen();
543
544/*
545 * Execute a shell command.
546 * Return a pointer to a pipe connected to the shell command's standard output.
547 */

--- 8 unchanged lines hidden (view full) ---

556
557 shell = lgetenv("SHELL");
558 if (shell != NULL && *shell != '\0')
559 {
560 char *scmd;
561 char *esccmd;
562
563 /*
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.)
564 * Read the output of <$SHELL -c cmd>.
565 * Escape any metacharacters in the command.
533 */
566 */
534 if ((esccmd = esc_metachars(cmd)) == NULL)
567 esccmd = shell_quote(cmd);
568 if (esccmd == NULL)
535 {
569 {
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);
570 fd = popen(cmd, "r");
543 } else
544 {
571 } else
572 {
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));
573 scmd = (char *) ecalloc(strlen(shell) + strlen(esccmd) + 5,
574 sizeof(char));
551 sprintf(scmd, "%s -c %s", shell, esccmd);
575 sprintf(scmd, "%s %s %s", shell, shell_coption(), esccmd);
552 free(esccmd);
576 free(esccmd);
577 fd = popen(scmd, "r");
578 free(scmd);
553 }
579 }
554 fd = popen(scmd, "r");
555 free(scmd);
556 } else
557#endif
558 {
559 fd = popen(cmd, "r");
580 } else
581#endif
582 {
583 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 }
584 }
585 /*
586 * Redirection in `popen' might have messed with the
587 * standard devices. Restore binary input mode.
588 */
589 SET_BINARY(0);
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 *
576lglob(filename)
577 char *filename;
578{
579 char *gfilename;
580 char *ofilename;
581
582 ofilename = fexpand(filename);
583 if (secure)
584 return (ofilename);
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 *
600lglob(filename)
601 char *filename;
602{
603 char *gfilename;
604 char *ofilename;
605
606 ofilename = fexpand(filename);
607 if (secure)
608 return (ofilename);
585 filename = unquote_file(ofilename);
609 filename = shell_unquote(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;
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;
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);
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);
606 length += strlen(p) + 1;
607#if SPACES_IN_FILENAMES
608 if (strchr(p, ' ') != NULL)
609 length += 2; /* Allow for quotes */
610#endif
631 qfilename = shell_quote(p);
632 if (qfilename != NULL)
633 {
634 length += strlen(qfilename) + 1;
635 free(qfilename);
636 }
611 }
612 gfilename = (char *) ecalloc(length, sizeof(char));
613 for (SCAN_GLOB_LIST(list, p))
614 {
615 INIT_GLOB_LIST(list, p);
637 }
638 gfilename = (char *) ecalloc(length, sizeof(char));
639 for (SCAN_GLOB_LIST(list, p))
640 {
641 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);
642 qfilename = shell_quote(p);
643 if (qfilename != NULL)
644 {
645 sprintf(gfilename + strlen(gfilename), "%s ", qfilename);
646 free(qfilename);
647 }
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;
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;
640#if SPACES_IN_FILENAMES
641 register int spaces_in_file;
642#endif
665 char *pathname;
666 char *qpathname;
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;
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;
658#if SPACES_IN_FILENAMES
659 spaces_in_file = 0;
660 if (strchr(fnd.GLOB_NAME, ' ') != NULL ||
661 strchr(filename, ' ') != NULL)
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)
662 {
687 {
663 spaces_in_file = 1;
664 n += 2;
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++ = ' ';
665 }
707 }
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;
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;
707
728
708 lessecho = lgetenv("LESSECHO");
709 if (lessecho == NULL || *lessecho == '\0')
710 lessecho = "lessecho";
711 s = esc_metachars(filename);
712 if (s == NULL)
729 esc = get_meta_escape();
730 if (strlen(esc) == 0)
731 esc = "-";
732 esc = shell_quote(esc);
733 if (esc == NULL)
713 {
734 {
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 }
735 free(filename);
736 return (ofilename);
737 }
738 lessecho = lgetenv("LESSECHO");
739 if (lessecho == NULL || *lessecho == '\0')
740 lessecho = "lessecho";
723 /*
724 * Invoke lessecho, and read its output (a globbed list of filenames).
725 */
741 /*
742 * Invoke lessecho, and read its output (a globbed list of filenames).
743 */
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);
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);
729 fd = shellcmd(cmd);
750 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);

--- 30 unchanged lines hidden (view full) ---

769 char *filename;
770 int *pf;
771 void **pfd;
772{
773#if !HAVE_POPEN
774 return (NULL);
775#else
776 char *lessopen;
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);

--- 30 unchanged lines hidden (view full) ---

789 char *filename;
790 int *pf;
791 void **pfd;
792{
793#if !HAVE_POPEN
794 return (NULL);
795#else
796 char *lessopen;
777 char *gfilename;
778 char *cmd;
779 FILE *fd;
780#if HAVE_FILENO
781 int returnfd = 0;
782#endif
783
797 char *cmd;
798 FILE *fd;
799#if HAVE_FILENO
800 int returnfd = 0;
801#endif
802
784 if (secure)
803 if (!use_lessopen || 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 {

--- 5 unchanged lines hidden (view full) ---

798 lessopen++;
799 returnfd = 1;
800#else
801 error("LESSOPEN pipe is not supported", NULL_PARG);
802 return (NULL);
803#endif
804 }
805
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 {

--- 5 unchanged lines hidden (view full) ---

817 lessopen++;
818 returnfd = 1;
819#else
820 error("LESSOPEN pipe is not supported", NULL_PARG);
821 return (NULL);
822#endif
823 }
824
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,
825 cmd = (char *) ecalloc(strlen(lessopen) + strlen(filename) + 2,
815 sizeof(char));
826 sizeof(char));
816 sprintf(cmd, lessopen, gfilename);
827 sprintf(cmd, lessopen, filename);
817 fd = shellcmd(cmd);
828 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 }

--- 18 unchanged lines hidden (view full) ---

845 return (NULL);
846 }
847 ch_ungetchar(c);
848 *pfd = (void *) fd;
849 *pf = f;
850 return (save("-"));
851 }
852#endif
829 free(cmd);
830 if (fd == NULL)
831 {
832 /*
833 * Cannot create the pipe.
834 */
835 return (NULL);
836 }

--- 18 unchanged lines hidden (view full) ---

855 return (NULL);
856 }
857 ch_ungetchar(c);
858 *pfd = (void *) fd;
859 *pf = f;
860 return (save("-"));
861 }
862#endif
853 gfilename = readfd(fd);
863 cmd = readfd(fd);
854 pclose(fd);
864 pclose(fd);
855 if (*gfilename == '\0')
865 if (*cmd == '\0')
856 /*
857 * Pipe is empty. This means there is no alt file.
858 */
859 return (NULL);
866 /*
867 * Pipe is empty. This means there is no alt file.
868 */
869 return (NULL);
860 return (gfilename);
870 return (cmd);
861#endif /* HAVE_POPEN */
862}
863
864/*
865 * Close a replacement file.
866 */
867 public void
868close_altfile(altfilename, filename, pipefd)
869 char *altfilename;
870 char *filename;
871 void *pipefd;
872{
873#if HAVE_POPEN
874 char *lessclose;
871#endif /* HAVE_POPEN */
872}
873
874/*
875 * Close a replacement file.
876 */
877 public void
878close_altfile(altfilename, filename, pipefd)
879 char *altfilename;
880 char *filename;
881 void *pipefd;
882{
883#if HAVE_POPEN
884 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;
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;
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);
903 cmd = (char *) ecalloc(strlen(lessclose) + strlen(filename) +
904 strlen(altfilename) + 2, sizeof(char));
905 sprintf(cmd, lessclose, filename, altfilename);
909 fd = shellcmd(cmd);
906 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
922is_dir(filename)
923 char *filename;
924{
925 int isdir = 0;
926
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
917is_dir(filename)
918 char *filename;
919{
920 int isdir = 0;
921
927 filename = unquote_file(filename);
922 filename = shell_unquote(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}

--- 19 unchanged lines hidden (view full) ---

955 * (if it cannot be opened or is a directory, etc.)
956 */
957 public char *
958bad_file(filename)
959 char *filename;
960{
961 register char *m = NULL;
962
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}

--- 19 unchanged lines hidden (view full) ---

950 * (if it cannot be opened or is a directory, etc.)
951 */
952 public char *
953bad_file(filename)
954 char *filename;
955{
956 register char *m = NULL;
957
963 filename = unquote_file(filename);
958 filename = shell_unquote(filename);
964 if (is_dir(filename))
965 {
959 if (is_dir(filename))
960 {
966 static char is_dir[] = " is a directory";
961 static char is_a_dir[] = " is a directory";
967
962
968 m = (char *) ecalloc(strlen(filename) + sizeof(is_dir),
963 m = (char *) ecalloc(strlen(filename) + sizeof(is_a_dir),
969 sizeof(char));
970 strcpy(m, filename);
964 sizeof(char));
965 strcpy(m, filename);
971 strcat(m, is_dir);
966 strcat(m, is_a_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)

--- 35 unchanged lines hidden (view full) ---

1015
1016 if ((size = (long) _gs_size(f)) >= 0)
1017 return ((POSITION) size);
1018#endif
1019#endif
1020 return (seek_filesize(f));
1021}
1022
967 } else
968 {
969#if HAVE_STAT
970 int r;
971 struct stat statbuf;
972
973 r = stat(filename, &statbuf);
974 if (r < 0)

--- 35 unchanged lines hidden (view full) ---

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 *
1022shell_coption()
1023{
1024 return ("-c");
1025}