Subversion Repositories planix.SVN

/*

 * Copyright (c) 1980 The Regents of the University of California.

 * All rights reserved.

 *

 * Copyright (c) 2019 The PLANIX Project

 * All right 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, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.

 */

#include <stdio.h>

#define	BUFSIZE		1024

#define MAXHOP		32	/* max number of tc= indirections */

#define	PBUFSIZE		512	/* max length of filename path */

#define	PVECSIZ		32	/* max number of names in path */

#include <ctype.h>

#include <stdlib.h>

#include "pathnames.h"

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

int tnamatch();

int tnchktc();

int tfindent();

/*

 * termcap - routines for dealing with the terminal capability data base

 *

 * BUG:		Should use a "last" pointer in tbuf, so that searching

 *		for capabilities alphabetically would not be a n**2/2

 *		process when large numbers of capabilities are given.

 * Note:	If we add a last pointer now we will screw up the

 *		tc capability. We really should compile termcap.

 *

 * Essentially all the work here is scanning and decoding escapes

 * in string capabilities.  We don't use stdio because the editor

 * doesn't, and because living w/o it is not hard.

 */

static	char *tbuf;

static	int hopcount;	/* detect infinite loops in termcap, init 0 */

static	char pathbuf[PBUFSIZE];		/* holds raw path of filenames */

static	char *pathvec[PVECSIZ];		/* to point to names in pathbuf */

static	char **pvec;			/* holds usable tail of path vector */

static	char *tdecode ();

static	char *tskip ();

/*

 * Get an entry for terminal name in buffer bp from the termcap file.

 */

tgetent(bp, name)

	char *bp, *name;

{

	register char *p;

	register char *cp;

	register int c;

	char /* *term,*/ *home, *termpath;

	char **fname = pathvec;

	pvec = pathvec;

	tbuf = bp;

	p = pathbuf;

	cp = getenv("TERMCAP");

	/*

	 * TERMCAP can have one of two things in it. It can be the

	 * name of a file to use instead of /etc/termcap. In this

	 * case it better start with a "/". Or it can be an entry to

	 * use so we don't have to read the file. In this case it

	 * has to already have the newlines crunched out.  If TERMCAP

	 * does not hold a file name then a path of names is searched

	 * instead.  The path is found in the TERMPATH variable, or

	 * becomes "$HOME/.termcap /etc/termcap" if no TERMPATH exists.

	 */

	if (!cp || *cp != '/') {	/* no TERMCAP or it holds an entry */

		if ( (termpath = getenv("TERMPATH")) )

			strncpy(pathbuf, termpath, PBUFSIZE);

		else {

			if ( (home = getenv("HOME")) ) {	/* set up default */

				p += strlen(home);	/* path, looking in */

				strcpy(pathbuf, home);	/* $HOME first */

				*p++ = '/';

			}	/* if no $HOME look in current directory */

			strncpy(p, _PATH_DEF, PBUFSIZE - (p - pathbuf));

		}

	}

	else				/* user-defined name in TERMCAP */

		strncpy(pathbuf, cp, PBUFSIZE);	/* still can be tokenized */

	*fname++ = pathbuf;	/* tokenize path into vector of names */

	while (*++p)

		if (*p == ' ' || *p == ':') {

			*p = '\0';

			while (*++p)

				if (*p != ' ' && *p != ':')

					break;

			if (*p == '\0')

				break;

			*fname++ = p;

			if (fname >= pathvec + PVECSIZ) {

				fname--;

				break;

			}

		}

	*fname = (char *) 0;			/* mark end of vector */

	if (cp && *cp && *cp != '/') {

		tbuf = cp;

		c = tnamatch(name);

		tbuf = bp;

		if (c) {

			strcpy(bp,cp);

			return (tnchktc());

		}

	}

	return (tfindent(bp, name));	/* find terminal entry in path */

}

/*

 * tfindent - reads through the list of files in pathvec as if they were one

 * continuous file searching for terminal entries along the way.  It will

 * participate in indirect recursion if the call to tnchktc() finds a tc=

 * field, which is only searched for in the current file and files ocurring

 * after it in pathvec.  The usable part of this vector is kept in the global

 * variable pvec.  Terminal entries may not be broken across files.  Parse is

 * very rudimentary; we just notice escaped newlines.

 */

tfindent(bp, name)

	char *bp, *name;

{

	register char *cp;

	register int c;

	register int i, cnt;

	char ibuf[BUFSIZE];

	int opencnt = 0;

	int tf;

	tbuf = bp;

nextfile:

	i = cnt = 0;

	while (*pvec && (tf = open(*pvec, 0)) < 0)

		pvec++;

	if (!*pvec)

		return (opencnt ? 0 : -1);

	opencnt++;

	for (;;) {

		cp = bp;

		for (;;) {

			if (i == cnt) {

				cnt = read(tf, ibuf, BUFSIZE);

				if (cnt <= 0) {

					close(tf);

					pvec++;

					goto nextfile;

				}

				i = 0;

			}

			c = ibuf[i++];

			if (c == '\n') {

				if (cp > bp && cp[-1] == '\\'){

					cp--;

					continue;

				}

				break;

			}

			if (cp >= bp+BUFSIZE) {

				fprintf(stderr,"Termcap entry too long\n");

				break;

			} else

				*cp++ = c;

		}

		*cp = 0;

		/*

		 * The real work for the match.

		 */

		if (tnamatch(name)) {

			close(tf);

			return(tnchktc());

		}

	}

}

/*

 * tnchktc: check the last entry, see if it's tc=xxx. If so,

 * recursively find xxx and append that entry (minus the names)

 * to take the place of the tc=xxx entry. This allows termcap

 * entries to say "like an HP2621 but doesn't turn on the labels".

 * Note that this works because of the left to right scan.

 */

tnchktc()

{

	register char *p, *q;

	char tcname[16];	/* name of similar terminal */

	char tcbuf[BUFSIZE];

	char *holdtbuf = tbuf;

	int l;

	p = tbuf + strlen(tbuf) - 2;	/* before the last colon */

	while (*--p != ':')

		if (p<tbuf) {

			fprintf(stderr, "Bad termcap entry\n");

			return (0);

		}

	p++;

	/* p now points to beginning of last field */

	if (p[0] != 't' || p[1] != 'c')

		return(1);

	strcpy(tcname,p+3);

	q = tcname;

	while (*q && *q != ':')

		q++;

	*q = 0;

	if (++hopcount > MAXHOP) {

		fprintf(stderr, "Infinite tc= loop\n");

		return (0);

	}

	if (tfindent(tcbuf, tcname) != 1) {

		hopcount = 0;		/* unwind recursion */

		return(0);

	}

	for (q=tcbuf; *q != ':'; q++)

		;

	l = p - holdtbuf + strlen(q);

	if (l > BUFSIZE) {

		fprintf(stderr, "Termcap entry too long!\n");

		q[BUFSIZE - (p-tbuf)] = 0;

	}

	strcpy(p, q+1);

	tbuf = holdtbuf;

	hopcount = 0;			/* unwind recursion */

	return(1);

}

/*

 * Tnamatch deals with name matching.  The first field of the termcap

 * entry is a sequence of names separated by |'s, so we compare

 * against each such name.  The normal : terminator after the last

 * name (before the first field) stops us.

 */

tnamatch(np)

	char *np;

{

	register char *Np, *Bp;

	Bp = tbuf;

	if (*Bp == '#')

		return(0);

	for (;;) {

		for (Np = np; *Np && *Bp == *Np; Bp++, Np++)

			continue;

		if (*Np == 0 && (*Bp == '|' || *Bp == ':' || *Bp == 0))

			return (1);

		while (*Bp && *Bp != ':' && *Bp != '|')

			Bp++;

		if (*Bp == 0 || *Bp == ':')

			return (0);

		Bp++;

	}

}

/*

 * Skip to the next field.  Notice that this is very dumb, not

 * knowing about \: escapes or any such.  If necessary, :'s can be put

 * into the termcap file in octal.

 */

static char *

tskip(bp)

	register char *bp;

{

	while (*bp && *bp != ':')

		bp++;

	if (*bp == ':')

		bp++;

	return (bp);

}

/*

 * Return the (numeric) option id.

 * Numeric options look like

 *	li#80

 * i.e. the option string is separated from the numeric value by

 * a # character.  If the option is not found we return -1.

 * Note that we handle octal numbers beginning with 0.

 */

tgetnum(id)

	char *id;

{

	register int i, base;

	register char *bp = tbuf;

	for (;;) {

		bp = tskip(bp);

		if (*bp == 0)

			return (-1);

		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])

			continue;

		if (*bp == '@')

			return(-1);

		if (*bp != '#')

			continue;

		bp++;

		base = 10;

		if (*bp == '0')

			base = 8;

		i = 0;

		while (isdigit(*bp))

			i *= base, i += *bp++ - '0';

		return (i);

	}

}

/*

 * Handle a flag option.

 * Flag options are given "naked", i.e. followed by a : or the end

 * of the buffer.  Return 1 if we find the option, or 0 if it is

 * not given.

 */

tgetflag(id)

	char *id;

{

	register char *bp = tbuf;

	for (;;) {

		bp = tskip(bp);

		if (!*bp)

			return (0);

		if (*bp++ == id[0] && *bp != 0 && *bp++ == id[1]) {

			if (!*bp || *bp == ':')

				return (1);

			else if (*bp == '@')

				return(0);

		}

	}

}

/*

 * Get a string valued option.

 * These are given as

 *	cl=^Z

 * Much decoding is done on the strings, and the strings are

 * placed in area, which is a ref parameter which is updated.

 * No checking on area overflow.

 */

char *

tgetstr(id, area)

	char *id, **area;

{

	register char *bp = tbuf;

	for (;;) {

		bp = tskip(bp);

		if (!*bp)

			return (0);

		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])

			continue;

		if (*bp == '@')

			return(0);

		if (*bp != '=')

			continue;

		bp++;

		return (tdecode(bp, area));

	}

}

/*

 * Tdecode does the grung work to decode the

 * string capability escapes.

 */

static char *

tdecode(str, area)

	register char *str;

	char **area;

{

	register char *cp;

	register int c;

	register char *dp;

	int i;

	cp = *area;

	while ((c = *str++) && c != ':') {

		switch (c) {

		case '^':

			c = *str++ & 037;

			break;

		case '\\':

			dp = "E\033^^\\\\::n\nr\rt\tb\bf\f";

			c = *str++;

nextc:

			if (*dp++ == c) {

				c = *dp++;

				break;

			}

			dp++;

			if (*dp)

				goto nextc;

			if (isdigit(c)) {

				c -= '0', i = 2;

				do

					c <<= 3, c |= *str++ - '0';

				while (--i && isdigit(*str));

			}

			break;

		}

		*cp++ = c;

	}

	*cp++ = 0;

	str = *area;

	*area = cp;

	return (str);

}