mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-15 10:17:20 +00:00
8a16b7a18f
Mainly focus on files that use BSD 3-Clause license. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. Special thanks to Wind River for providing access to "The Duke of Highlander" tool: an older (2014) run over FreeBSD tree was useful as a starting point.
439 lines
9.3 KiB
C
439 lines
9.3 KiB
C
/* $FreeBSD$ */
|
|
/* $KAME: advcap.c,v 1.11 2003/05/19 09:46:50 keiichi Exp $ */
|
|
|
|
/*-
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
* Copyright (c) 1983 The Regents of the University of California.
|
|
* 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, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. 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.
|
|
*/
|
|
|
|
/*
|
|
* remcap - routines for dealing with the remote host data base
|
|
*
|
|
* derived from termcap
|
|
*/
|
|
#include <sys/types.h>
|
|
#include <sys/uio.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <syslog.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include "pathnames.h"
|
|
|
|
#ifndef BUFSIZ
|
|
#define BUFSIZ 1024
|
|
#endif
|
|
#define MAXHOP 32 /* max number of tc= indirections */
|
|
|
|
#define tgetent agetent
|
|
#define tnchktc anchktc
|
|
#define tnamatch anamatch
|
|
#define tgetnum agetnum
|
|
#define tgetflag agetflag
|
|
#define tgetstr agetstr
|
|
|
|
#if 0
|
|
#define V_TERMCAP "REMOTE"
|
|
#define V_TERM "HOST"
|
|
#endif
|
|
|
|
/*
|
|
* 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 */
|
|
|
|
extern const char *conffile;
|
|
|
|
int tgetent(char *, char *);
|
|
int getent(char *, char *, const char *);
|
|
int tnchktc(void);
|
|
int tnamatch(char *);
|
|
static char *tskip(char *);
|
|
int64_t tgetnum(char *);
|
|
int tgetflag(char *);
|
|
char *tgetstr(char *, char **);
|
|
static char *tdecode(char *, char **);
|
|
|
|
/*
|
|
* Get an entry for terminal name in buffer bp,
|
|
* from the termcap file. Parse is very rudimentary;
|
|
* we just notice escaped newlines.
|
|
*/
|
|
int
|
|
tgetent(char *bp, char *name)
|
|
{
|
|
return (getent(bp, name, conffile));
|
|
}
|
|
|
|
int
|
|
getent(char *bp, char *name, const char *cfile)
|
|
{
|
|
int c;
|
|
int i = 0, cnt = 0;
|
|
char ibuf[BUFSIZ];
|
|
char *cp;
|
|
int tf;
|
|
|
|
tbuf = bp;
|
|
tf = 0;
|
|
/*
|
|
* 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 (cfile && *cfile)
|
|
tf = open(cfile, O_RDONLY);
|
|
|
|
if (tf < 0) {
|
|
syslog(LOG_INFO,
|
|
"<%s> open: %s", __func__, strerror(errno));
|
|
return (-2);
|
|
}
|
|
for (;;) {
|
|
cp = bp;
|
|
for (;;) {
|
|
if (i == cnt) {
|
|
cnt = read(tf, ibuf, BUFSIZ);
|
|
if (cnt <= 0) {
|
|
close(tf);
|
|
return (0);
|
|
}
|
|
i = 0;
|
|
}
|
|
c = ibuf[i++];
|
|
if (c == '\n') {
|
|
if (cp > bp && cp[-1] == '\\') {
|
|
cp--;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (cp >= bp + BUFSIZ - 1) {
|
|
write(STDERR_FILENO, "Remcap entry too long\n",
|
|
22);
|
|
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.
|
|
*/
|
|
int
|
|
tnchktc(void)
|
|
{
|
|
char *p, *q;
|
|
char tcname[16]; /* name of similar terminal */
|
|
char tcbuf[BUFSIZ];
|
|
char *holdtbuf = tbuf;
|
|
int l;
|
|
|
|
p = tbuf + strlen(tbuf) - 2; /* before the last colon */
|
|
while (*--p != ':')
|
|
if (p < tbuf) {
|
|
write(STDERR_FILENO, "Bad remcap entry\n", 18);
|
|
return (0);
|
|
}
|
|
p++;
|
|
/* p now points to beginning of last field */
|
|
if (p[0] != 't' || p[1] != 'c')
|
|
return (1);
|
|
strlcpy(tcname, p + 3, sizeof tcname);
|
|
q = tcname;
|
|
while (*q && *q != ':')
|
|
q++;
|
|
*q = 0;
|
|
if (++hopcount > MAXHOP) {
|
|
write(STDERR_FILENO, "Infinite tc= loop\n", 18);
|
|
return (0);
|
|
}
|
|
if (getent(tcbuf, tcname, conffile) != 1) {
|
|
return (0);
|
|
}
|
|
for (q = tcbuf; *q++ != ':'; )
|
|
;
|
|
l = p - holdtbuf + strlen(q);
|
|
if (l > BUFSIZ) {
|
|
write(STDERR_FILENO, "Remcap entry too long\n", 23);
|
|
q[BUFSIZ - (p-holdtbuf)] = 0;
|
|
}
|
|
strcpy(p, q);
|
|
tbuf = holdtbuf;
|
|
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.
|
|
*/
|
|
int
|
|
tnamatch(char *np)
|
|
{
|
|
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(char *bp)
|
|
{
|
|
int dquote;
|
|
|
|
dquote = 0;
|
|
while (*bp) {
|
|
switch (*bp) {
|
|
case ':':
|
|
if (!dquote)
|
|
goto breakbreak;
|
|
else
|
|
bp++;
|
|
break;
|
|
case '\\':
|
|
bp++;
|
|
if (isdigit(*bp)) {
|
|
while (isdigit(*bp++))
|
|
;
|
|
} else
|
|
bp++;
|
|
case '"':
|
|
dquote = (dquote ? 1 : 0);
|
|
bp++;
|
|
break;
|
|
default:
|
|
bp++;
|
|
break;
|
|
}
|
|
}
|
|
breakbreak:
|
|
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.
|
|
*/
|
|
int64_t
|
|
tgetnum(char *id)
|
|
{
|
|
int64_t i;
|
|
int base;
|
|
char *bp = tbuf;
|
|
|
|
for (;;) {
|
|
bp = tskip(bp);
|
|
if (*bp == 0)
|
|
return (-1);
|
|
if (strncmp(bp, id, strlen(id)) != 0)
|
|
continue;
|
|
bp += strlen(id);
|
|
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.
|
|
*/
|
|
int
|
|
tgetflag(char *id)
|
|
{
|
|
char *bp = tbuf;
|
|
|
|
for (;;) {
|
|
bp = tskip(bp);
|
|
if (!*bp)
|
|
return (0);
|
|
if (strncmp(bp, id, strlen(id)) == 0) {
|
|
bp += strlen(id);
|
|
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(char *id, char **area)
|
|
{
|
|
char *bp = tbuf;
|
|
|
|
for (;;) {
|
|
bp = tskip(bp);
|
|
if (!*bp)
|
|
return (0);
|
|
if (strncmp(bp, id, strlen(id)) != 0)
|
|
continue;
|
|
bp += strlen(id);
|
|
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(char *str, char **area)
|
|
{
|
|
char *cp;
|
|
int c;
|
|
const char *dp;
|
|
int i;
|
|
char term;
|
|
|
|
term = ':';
|
|
cp = *area;
|
|
again:
|
|
if (*str == '"') {
|
|
term = '"';
|
|
str++;
|
|
}
|
|
while ((c = *str++) && c != term) {
|
|
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;
|
|
}
|
|
if (c == term && term != ':') {
|
|
term = ':';
|
|
goto again;
|
|
}
|
|
*cp++ = 0;
|
|
str = *area;
|
|
*area = cp;
|
|
return (str);
|
|
}
|