filename.c

/*
 * Copyright (c) 1984,1985,1989,1994,1995,1996  Mark Nudelman
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice in the documentation and/or other materials provided with 
 *    the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


/*
 * Routines to mess around with filenames (and files).
 * Much of this is very OS dependent.
 */

#include "less.h"
#if MSDOS_COMPILER
#include <dos.h>
#if MSDOS_COMPILER==WIN32C && !defined(_MSC_VER)
#include <dir.h>
#endif
#if MSDOS_COMPILER==DJGPPC
#include <glob.h>
#include <dir.h>
#include <limits.h>
#define _MAX_PATH	PATH_MAX
#endif
#endif
#ifdef _OSK
#include <rbf.h>
#ifndef _OSK_MWC32
#include <modes.h>
#endif
#endif

extern int force_open;
extern int secure;
extern IFILE curr_ifile;
extern IFILE old_ifile;

/*
 * Remove quotes around a filename.
 */
	public char *
unquote_file(str)
	char *str;
{
#if SPACES_IN_FILENAMES
	char *name;
	char *p;

	if (strchr(str, '"') == NULL)
		return (save(str));
	name = p = ecalloc(strlen(str)+1, sizeof(char));
	while (*str != '\0')
	{
		if (*str != '"')
			*p++ = *str;
		str++;
	}
	*p = '\0';
	return (name);
#else
	return (save(str));
#endif
}

/*
 * Return a pathname that points to a specified file in a specified directory.
 * Return NULL if the file does not exist in the directory.
 */
	static char *
dirfile(dirname, filename)
	char *dirname;
	char *filename;
{
	char *pathname;
	char *qpathname;
	int f;

	if (dirname == NULL || *dirname == '\0')
		return (NULL);
	/*
	 * Construct the full pathname.
	 */
	pathname = (char *) calloc(strlen(dirname) + strlen(filename) + 2, 
					sizeof(char));
	if (pathname == NULL)
		return (NULL);
	sprintf(pathname, "%s%s%s", dirname, PATHNAME_SEP, filename);
	/*
	 * Make sure the file exists.
	 */
	qpathname = unquote_file(pathname);
	f = open(qpathname, OPEN_READ);
	if (f < 0)
	{
		free(pathname);
		pathname = NULL;
	} else
	{
		close(f);
	}
	free(qpathname);
	return (pathname);
}

/*
 * Return the full pathname of the given file in the "home directory".
 */
	public char *
homefile(filename)
	char *filename;
{
	register char *pathname;

	/*
	 * Try $HOME/filename.
	 */
	pathname = dirfile(lgetenv("HOME"), filename);
	if (pathname != NULL)
		return (pathname);
#if OS2
	/*
	 * Try $INIT/filename.
	 */
	pathname = dirfile(lgetenv("INIT"), filename);
	if (pathname != NULL)
		return (pathname);
#endif
#if MSDOS_COMPILER || OS2
	/*
	 * Look for the file anywhere on search path.
	 */
	pathname = (char *) calloc(_MAX_PATH, sizeof(char));
#if MSDOS_COMPILER==DJGPPC
	{
		char *res = searchpath(filename);
		if (res == 0)
			*pathname = '\0';
		else
			strcpy(pathname, res);
	}
#else
  	_searchenv(filename, "PATH", pathname);
#endif
	if (*pathname != '\0')
		return (pathname);
	free(pathname);
#endif
	return (NULL);
}

/*
 * Expand a string, substituting any "%" with the current filename,
 * and any "#" with the previous filename.
 * But a string of N "%"s is just replaced with N-1 "%"s.
 * Likewise for a string of N "#"s.
 * {{ This is a lot of work just to support % and #. }}
 */
	public char *
fexpand(s)
	char *s;
{
	register char *fr, *to;
	register int n;
	register char *e;
	IFILE ifile;

#define	fchar_ifile(c) \
	((c) == '%' ? curr_ifile : \
	 (c) == '#' ? old_ifile : NULL_IFILE)

	/*
	 * Make one pass to see how big a buffer we 
	 * need to allocate for the expanded string.
	 */
	n = 0;
	for (fr = s;  *fr != '\0';  fr++)
	{
		switch (*fr)
		{
		case '%':
		case '#':
			if (fr > s && fr[-1] == *fr)
			{
				/*
				 * Second (or later) char in a string
				 * of identical chars.  Treat as normal.
				 */
				n++;
			} else if (fr[1] != *fr)
			{
				/*
				 * Single char (not repeated).  Treat specially.
				 */
				ifile = fchar_ifile(*fr);
				if (ifile == NULL_IFILE)
					n++;
				else
					n += strlen(get_filename(ifile));
			}
			/*
			 * Else it is the first char in a string of
			 * identical chars.  Just discard it.
			 */
			break;
		default:
			n++;
			break;
		}
	}

	e = (char *) ecalloc(n+1, sizeof(char));

	/*
	 * Now copy the string, expanding any "%" or "#".
	 */
	to = e;
	for (fr = s;  *fr != '\0';  fr++)
	{
		switch (*fr)
		{
		case '%':
		case '#':
			if (fr > s && fr[-1] == *fr)
			{
				*to++ = *fr;
			} else if (fr[1] != *fr)
			{
				ifile = fchar_ifile(*fr);
				if (ifile == NULL_IFILE)
					*to++ = *fr;
				else
				{
					strcpy(to, get_filename(ifile));
					to += strlen(to);
				}
			}
			break;
		default:
			*to++ = *fr;
			break;
		}
	}
	*to = '\0';
	return (e);
}

#if TAB_COMPLETE_FILENAME

/*
 * Return a blank-separated list of filenames which "complete"
 * the given string.
 */
	public char *
fcomplete(s)
	char *s;
{
	char *fpat;

	if (secure)
		return (NULL);
	/*
	 * Complete the filename "s" by globbing "s*".
	 */
#if MSDOS_COMPILER && MSDOS_COMPILER != WIN32C && MSDOS_COMPILER != DJGPPC
	/*
	 * But in DOS, we have to glob "s*.*".
	 * But if the final component of the filename already has
	 * a dot in it, just do "s*".  
	 * (Thus, "FILE" is globbed as "FILE*.*", 
	 *  but "FILE.A" is globbed as "FILE.A*").
	 */
	{
		char *slash;
		for (slash = s+strlen(s)-1;  slash > s;  slash--)
			if (*slash == *PATHNAME_SEP || *slash == '/')
				break;
		fpat = (char *) ecalloc(strlen(s)+4, sizeof(char));
		if (strchr(slash, '.') == NULL)
			sprintf(fpat, "%s*.*", s);
		else
			sprintf(fpat, "%s*", s);
	}
#else
	fpat = (char *) ecalloc(strlen(s)+2, sizeof(char));
	sprintf(fpat, "%s*", s);
#endif
	s = lglob(fpat);
	if (strcmp(s,fpat) == 0)
	{
		/*
		 * The filename didn't expand.
		 */
		free(s);
		s = NULL;
	}
	free(fpat);
	return (s);
}
#endif

/*
 * Try to determine if a file is "binary".
 * This is just a guess, and we need not try too hard to make it accurate.
 */
	public int
bin_file(f)
	int f;
{
	int i;
	int n;
	unsigned char data[64];

	if (!seekable(f))
		return (0);
	if (lseek(f, (off_t)0, 0) == BAD_LSEEK)
		return (0);
	n = read(f, data, sizeof(data));
	for (i = 0;  i < n;  i++)
		if (binary_char(data[i]))
			return (1);
	return (0);
}

/*
 * Try to determine the size of a file by seeking to the end.
 */
	static POSITION
seek_filesize(f)
	int f;
{
	off_t spos;

	spos = lseek(f, (off_t)0, 2);
	if (spos == BAD_LSEEK)
		return (NULL_POSITION);
	return ((POSITION) spos);
}

#if GLOB

FILE *popen();

/*
 * Read a string from a file.
 * Return a pointer to the string in memory.
 */
	static char *
readfd(fd)
	FILE *fd;
{
	int len;
	int ch;
	char *buf;
	char *p;
	
	/* 
	 * Make a guess about how many chars in the string
	 * and allocate a buffer to hold it.
	 */
	len = 100;
	buf = (char *) ecalloc(len, sizeof(char));
	for (p = buf;  ;  p++)
	{
		if ((ch = getc(fd)) == '\n' || ch == EOF)
			break;
		if (p - buf >= len-1)
		{
			/*
			 * The string is too big to fit in the buffer we have.
			 * Allocate a new buffer, twice as big.
			 */
			len *= 2;
			*p = '\0';
			p = (char *) ecalloc(len, sizeof(char));
			strcpy(p, buf);
			free(buf);
			buf = p;
			p = buf + strlen(buf);
		}
		*p = ch;
	}
	*p = '\0';
	return (buf);
}

/*
 * Execute a shell command.
 * Return a pointer to a pipe connected to the shell command's standard output.
 */
	static FILE *
shellcmd(cmd, s1, s2)
	char *cmd;
	char *s1;
	char *s2;
{
	char *scmd;
	char *shell;
	FILE *fd;
	int len;
	
	len = strlen(cmd) + 
		(s1 == NULL ? 0 : strlen(s1)) + 
		(s2 == NULL ? 0 : strlen(s2)) + 1;
	scmd = (char *) ecalloc(len, sizeof(char));
	sprintf(scmd, cmd, s1, s2);
#if HAVE_SHELL
	shell = lgetenv("SHELL");
	if (shell != NULL && *shell != '\0')
	{
		/*
		 * Read the output of <$SHELL -c "cmd">.
		 */
		char *scmd2;
		scmd2 = (char *) ecalloc(strlen(shell) + strlen(scmd) + 7,
					sizeof(char));
		sprintf(scmd2, "%s -c \"%s\"", shell, scmd);
		free(scmd);
		scmd = scmd2;
	}
#endif
	fd = popen(scmd, "r");
	free(scmd);
	return (fd);
}

/*
 * Expand a filename, doing any shell-level substitutions.
 */
	public char *
lglob(filename)
	char *filename;
{
	char *gfilename;

	filename = fexpand(filename);

	if (secure)
		return (filename);
#if OS2
{
	char **list;
	int cnt;
	int length;

	list = _fnexplode(filename);
	if (list == NULL)
		return (filename);
	length = 1; /* Room for trailing null byte */
	for (cnt = 0;  list[cnt] != NULL;  cnt++)
	{
	  	length += strlen(list[cnt]) + 1;
#if SPACES_IN_FILENAMES
		if (strchr(list[cnt], ' ') != NULL)
			length += 2; /* Allow for quotes */
#endif
	}
	gfilename = (char *) ecalloc(length, sizeof(char));
	for (cnt = 0;  list[cnt] != NULL;  cnt++)
	{
#if SPACES_IN_FILENAMES
		if (strchr(list[cnt], ' ') != NULL)
			sprintf(gfilename, "\"%s\" ", list[cnt]);
		else
#endif
		sprintf(gfilename, "%s ", list[cnt]);
	}
	_fnexplodefree(list);
}
#else
#if MSDOS_COMPILER==DJGPPC
{
	size_t cnt;
	size_t length;
	glob_t glob_results;
	char **p;

	glob(filename, GLOB_NOCHECK, 0, &glob_results);

	/* How much space do we need?  */
	for (p = glob_results.gl_pathv, cnt = glob_results.gl_pathc;
	     cnt > 0;  p++, cnt--)
	{
		length += strlen(*p) + 1;
#if SPACES_IN_FILENAMES
		if (strchr(*p, ' ') != NULL)
			length += 2; /* Allow for quotes */
#endif
	}

	/* Allocate the space and generate the list.  */
	gfilename = (char *) ecalloc(length, sizeof(char));
	for (p = glob_results.gl_pathv, cnt = glob_results.gl_pathc;
	     cnt > 0;  p++, cnt--)
	{
		strcat(gfilename, *p);
		if (cnt > 1)
			strcat(gfilename, " ");
#if SPACES_IN_FILENAMES
		if (strchr(*p, ' ') != NULL)
			sprintf(gfilename, "\"%s\" ", *p);
		else
#endif
		sprintf(gfilename, "%s ", *p);
	}

	free(filename);
	globfree(&glob_results);
}
#else
{
	FILE *fd;
	char *s;

	/*
	 * We get the shell to expand the filename for us by passing
	 * an "echo" command to the shell and reading its output.
	 */

	/*
	 * Certain characters will cause problems if passed to the shell,
	 * so we disallow them.
	 * {{ This presumes too much knowlege about the shell, but not
	 *    doing this can cause serious problems.  For example, do 
	 *    "!;TAB" when the first file in the dir is named "rm". }}
	 */
	for (s = filename;  *s != '\0';  s++)
	{
		if (*s == ';' || *s == '\'' || *s == '\"' || *s == '\\')
			return (filename);
	}

	s = lgetenv("LESSECHO");
	if (s == NULL || *s == '\0')
		s = "lessecho";
	fd = shellcmd("%s %s", s, filename);
	if (fd == NULL)
	{
		/*
		 * Cannot create the pipe.
		 * Just return the original (fexpanded) filename.
		 */
		return (filename);
	}
	gfilename = readfd(fd);
	pclose(fd);
	if (*gfilename == '\0')
	{
		free(gfilename);
		return (filename);
	}
	free(filename);
}
#endif
#endif
	return (gfilename);
}

/*
 * See if we should open a "replacement file" 
 * instead of the file we're about to open.
 */
	public char *
open_altfile(filename, pf, pfd)
	char *filename;
	int *pf;
	void **pfd;
{
	char *lessopen;
	char *gfilename;
	FILE *fd;
#if HAVE_FILENO
	int returnfd = 0;
#endif
	
	if (secure)
		return (NULL);
	ch_ungetchar(-1);
	if ((lessopen = lgetenv("LESSOPEN")) == NULL)
		return (NULL);
	if (strcmp(filename, "-") == 0)
		return (NULL);
	if (*lessopen == '|')
	{
		/*
		 * If LESSOPEN starts with a |, it indicates 
		 * a "pipe preprocessor".
		 */
#if HAVE_FILENO
		lessopen++;
		returnfd = 1;
#else
		error("LESSOPEN pipe is not supported", NULL_PARG);
		return (NULL);
#endif
	}
	fd = shellcmd(lessopen, filename, (char*)NULL);
	if (fd == NULL)
	{
		/*
		 * Cannot create the pipe.
		 */
		return (NULL);
	}
#if HAVE_FILENO
	if (returnfd)
	{
		int f;
		char c;

		/*
		 * Read one char to see if the pipe will produce any data.
		 * If it does, push the char back on the pipe.
		 */
		f = fileno(fd);
		if (read(f, &c, 1) != 1)
		{
			/*
			 * Pipe is empty.  This means there is no alt file.
			 */
			pclose(fd);
			return (NULL);
		}
		ch_ungetchar(c);
		*pfd = (void *) fd;
		*pf = f;
		return (save("-"));
	}
#endif
	gfilename = readfd(fd);
	pclose(fd);
	if (*gfilename == '\0')
		/*
		 * Pipe is empty.  This means there is no alt file.
		 */
		return (NULL);
	return (gfilename);
}

/*
 * Close a replacement file.
 */
	public void
close_altfile(altfilename, filename, pipefd)
	char *altfilename;
	char *filename;
	void *pipefd;
{
	char *lessclose;
	FILE *fd;
	
	if (secure)
		return;
	if (pipefd != NULL)
		pclose((FILE*) pipefd);
	if ((lessclose = lgetenv("LESSCLOSE")) == NULL)
	     	return;
	fd = shellcmd(lessclose, filename, altfilename);
	pclose(fd);
}
		
#else
#if MSDOS_COMPILER

/*
 * Define macros for the MS-DOS "find file" interfaces.
 */
#if MSDOS_COMPILER!=WIN32C

#define	FIND_FIRST(filename,fndp)	_dos_findfirst(filename, ~0, fndp)
#define	FIND_NEXT(handle,fndp)		_dos_findnext(fndp)
#define	FIND_CLOSE(handle)
#define	BAD_HANDLE(handle)		((handle) != 0)
#define	FND_NAME			name
#define	DECLARE_FIND(fnd,drive,dir,fname,ext,handle) \
					struct find_t fnd;	\
					char drive[_MAX_DRIVE];	\
					char dir[_MAX_DIR];	\
					char fname[_MAX_FNAME];	\
					char ext[_MAX_EXT];	\
					int handle;
#else
#ifdef _MSC_VER

#define	FIND_FIRST(filename,fndp)	_findfirst(filename, fndp)
#define	FIND_NEXT(handle,fndp)		_findnext(handle, fndp)
#define	FIND_CLOSE(handle)		_findclose(handle)
#define	BAD_HANDLE(handle)		((handle) == -1)
#define	FND_NAME			name
#define	DECLARE_FIND(fnd,drive,dir,fname,ext,handle) \
					struct _finddata_t fnd;	\
					char drive[_MAX_DRIVE];	\
					char dir[_MAX_DIR];	\
					char fname[_MAX_FNAME];	\
					char ext[_MAX_EXT];	\
					long handle;

#else /* Borland */

#define	FIND_FIRST(filename,fndp)	findfirst(filename, fndp, ~0)
#define	FIND_NEXT(handle,fndp)		findnext(fndp)
#define	FIND_CLOSE(handle)
#define	BAD_HANDLE(handle)		((handle) != 0)
#define	FND_NAME			ff_name
#define	DECLARE_FIND(fnd,drive,dir,fname,ext,handle) \
					struct ffblk fnd;	\
					char drive[MAXDRIVE];	\
					char dir[MAXDIR];	\
					char fname[MAXFILE];	\
					char ext[MAXEXT];	\
					int handle;

#endif
#endif
	
	public char *
lglob(filename)
	char *filename;
{
	register char *gfilename;
	register char *qfilename;
	register char *p;
	register int len;
	register int n;
#if SPACES_IN_FILENAMES
	register int spaces_in_file;
#endif
	DECLARE_FIND(fnd,drive,dir,fname,ext,handle)
	
	filename = fexpand(filename);

	if (secure)
		return (filename);

	qfilename = unquote_file(filename);
	handle = FIND_FIRST(qfilename, &fnd);
	if (BAD_HANDLE(handle))
	{
		free(qfilename);
		return (filename);
	}

	_splitpath(qfilename, drive, dir, fname, ext);
	len = 100;
	gfilename = (char *) ecalloc(len, sizeof(char));
	p = gfilename;
	do {
		n = strlen(drive) + strlen(dir) + strlen(fnd.FND_NAME);
#if SPACES_IN_FILENAMES
		spaces_in_file = 0;
		if (strchr(fnd.FND_NAME, ' ') != NULL ||
		    strchr(filename, ' ') != NULL)
		{
			spaces_in_file = 1;
			n += 2;
		}
#endif
		while (p - gfilename + n+2 >= len)
		{
			/*
			 * No room in current buffer.  Allocate a bigger one.
			 */
			len *= 2;
			*p = '\0';
			p = (char *) ecalloc(len, sizeof(char));
			strcpy(p, gfilename);
			free(gfilename);
			gfilename = p;
			p = gfilename + strlen(gfilename);
		}
#if SPACES_IN_FILENAMES
		if (spaces_in_file)
			sprintf(p, "\"%s%s%s\"", drive, dir, fnd.FND_NAME);
		else
#endif
		sprintf(p, "%s%s%s", drive, dir, fnd.FND_NAME);
		p += n;
		*p++ = ' ';
	} while (FIND_NEXT(handle, &fnd) == 0);

	/*
	 * Overwrite the final trailing space with a null terminator.
	 */
	*--p = '\0';
	FIND_CLOSE(handle);
	free(qfilename);
	return (gfilename);
}

	public char *
open_altfile(filename, pf, pfd)
	char *filename;
	int *pf;
	void **pfd;
{
	return (NULL);
}

	public void
close_altfile(altfilename, filename, pipefd)
	char *altfilename;
	char *filename;
	void *pipefd;
{
}
		
#else

	public char *
lglob(filename)
	char *filename;
{
	return (fexpand(filename));
}

	
	public char *
open_altfile(filename, pf, pfd)
	char *filename;
	int *pf;
	void **pfd;
{
     	return (NULL);
}

	public void
close_altfile(altfilename, filename, pipefd)
	char *altfilename;
	char *filename;
	void *pipefd;
{
}
		
#endif
#endif


#if HAVE_STAT

#include <sys/stat.h>
#ifndef S_ISDIR
#define	S_ISDIR(m)	(((m) & S_IFMT) == S_IFDIR)
#endif
#ifndef S_ISREG
#define	S_ISREG(m)	(((m) & S_IFMT) == S_IFREG)
#endif

/*
 * Returns NULL if the file can be opened and
 * is an ordinary file, otherwise an error message
 * (if it cannot be opened or is a directory, etc.)
 */
	public char *
bad_file(filename)
	char *filename;
{
	register char *m;
	int r;
	struct stat statbuf;

	m = unquote_file(filename);
	r = stat(m, &statbuf);
	free(m);
	if (r < 0)
		return (errno_message(filename));

	if (force_open)
		return (NULL);

	if (S_ISDIR(statbuf.st_mode))
	{
		static char is_dir[] = " is a directory";
		m = (char *) ecalloc(strlen(filename) + sizeof(is_dir), 
			sizeof(char));
		strcpy(m, filename);
		strcat(m, is_dir);
		return (m);
	}
	if (!S_ISREG(statbuf.st_mode))
	{
		static char not_reg[] = " is not a regular file";
		m = (char *) ecalloc(strlen(filename) + sizeof(not_reg), 
			sizeof(char));
		strcpy(m, filename);
		strcat(m, not_reg);
		return (m);
	}

	return (NULL);
}

/*
 * Return the size of a file, as cheaply as possible.
 * In Unix, we can stat the file.
 */
	public POSITION
filesize(f)
	int f;
{
	struct stat statbuf;

	if (fstat(f, &statbuf) < 0)
		/*
		 * Can't stat; try seeking to the end.
		 */
		return (seek_filesize(f));

	return ((POSITION) statbuf.st_size);
}

#else
#ifdef _OSK

	public char *
bad_file(filename)
	char *filename;
{
	register int f;
	register char *m;

	if ((f = open(filename, S_IREAD | S_IFDIR)) >= 0)
	{
		static char is_dir[] = " is a directory";
		close(f);
		if (force_open)
			return (NULL);
		m = (char *) ecalloc(strlen(filename) + sizeof(is_dir),
			sizeof(char));
		strcpy(m, filename);
		strcat(m, is_dir);
		return (m);
	}
	if ((f = open(filename, S_IREAD)) < 0)
		return (errno_message(filename));
	close(f);
	return (NULL);
}

	public POSITION
filesize(f)
	int f;
{
	long size;

	if ((size = (long)_gs_size(f)) < 0)
		/*
		 * Can't stat; try seeking to the end.
		 */
		return (seek_filesize(f));

	return ((POSITION) size);
}

#else

/*
 * If we have no way to find out, just say the file is good.
 */
	public char *
bad_file(filename)
	char *filename;
{
	return (NULL);
}

/*
 * We can find the file size by seeking.
 */
	public POSITION
filesize(f)
	int f;
{
	return (seek_filesize(f));
}

#endif
#endif