Page MenuHomeFreeBSD
Differential D34411 Diff 103491 contrib/mg/term.c

Changeset View

Standalone View

View Options

contrib/mg/term.c

  • This file was added.
/* $NetBSD: term.c,v 1.29 2018/10/08 20:44:34 roy Exp $ */
/*
* Copyright (c) 2009, 2010, 2011 The NetBSD Foundation, Inc.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Roy Marples.
*
* 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.
*
* 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.
*/
#include <sys/cdefs.h>
#include <sys/stat.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cdbr.h"
#include "term_private.h"
#include "terminfo_term.h"
#define _PATH_TERMINFO "/usr/share/misc/terminfo"
#ifndef __arraycount
#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
#endif
static char __ti_database[PATH_MAX];
const char *_ti_database;
/* From NetBSD sys/arch/hpc/stand/include/machine/endian.h */
uint16_t
le16dec(const void *buf)
{
const uint8_t *p = (const uint8_t *)buf;
return ((p[1] << 8) | p[0]);
}
/* From NetBSD sys/external/bsd/libnv/dist/nv_compat.h */
static uint32_t
le32dec(const void *buf)
{
uint8_t const *p = (uint8_t const *) buf;
return (((unsigned) p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
}
/* Include a generated list of pre-compiled terminfo descriptions. */
#include "compiled_terms.c"
static int
allocset(void *pp, int init, size_t nelem, size_t elemsize)
{
void **p = pp;
if (*p) {
memset(*p, init, nelem * elemsize);
return 0;
}
if ((*p = calloc(nelem, elemsize)) == NULL)
return -1;
if (init != 0)
memset(*p, init, nelem * elemsize);
return 0;
}
static int
_ti_readterm(TERMINAL *term, const char *cap, size_t caplen, int flags)
{
char ver;
uint16_t ind, num;
size_t len;
TERMUSERDEF *ud;
if (caplen == 0)
goto out;
ver = *cap++;
caplen--;
/* Only read version 1 structures */
if (ver != 1)
goto out;
if (allocset(&term->flags, 0, TIFLAGMAX+1, sizeof(*term->flags)) == -1)
return -1;
if (allocset(&term->nums, -1, TINUMMAX+1, sizeof(*term->nums)) == -1)
return -1;
if (allocset(&term->strs, 0, TISTRMAX+1, sizeof(*term->strs)) == -1)
return -1;
if (term->_arealen != caplen) {
term->_arealen = caplen;
term->_area = realloc(term->_area, term->_arealen);
if (term->_area == NULL)
return -1;
}
memcpy(term->_area, cap, term->_arealen);
cap = term->_area;
len = le16dec(cap);
cap += sizeof(uint16_t);
term->name = cap;
cap += len;
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len == 0)
term->_alias = NULL;
else {
term->_alias = cap;
cap += len;
}
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len == 0)
term->desc = NULL;
else {
term->desc = cap;
cap += len;
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
term->flags[ind] = *cap++;
if (flags == 0 && !VALID_BOOLEAN(term->flags[ind]))
term->flags[ind] = 0;
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
term->nums[ind] = (short)le16dec(cap);
if (flags == 0 && !VALID_NUMERIC(term->nums[ind]))
term->nums[ind] = ABSENT_NUMERIC;
cap += sizeof(uint16_t);
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
for (; num != 0; num--) {
ind = le16dec(cap);
cap += sizeof(uint16_t);
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len > 0)
term->strs[ind] = cap;
else if (flags == 0)
term->strs[ind] = ABSENT_STRING;
else
term->strs[ind] = CANCELLED_STRING;
cap += len;
}
}
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != 0) {
num = le16dec(cap);
cap += sizeof(uint16_t);
if (num != term->_nuserdefs) {
free(term->_userdefs);
term->_userdefs = NULL;
term->_nuserdefs = num;
}
if (allocset(&term->_userdefs, 0, term->_nuserdefs,
sizeof(*term->_userdefs)) == -1)
return -1;
for (num = 0; num < term->_nuserdefs; num++) {
ud = &term->_userdefs[num];
len = le16dec(cap);
cap += sizeof(uint16_t);
ud->id = cap;
cap += len;
ud->type = *cap++;
switch (ud->type) {
case 'f':
ud->flag = *cap++;
if (flags == 0 &&
!VALID_BOOLEAN(ud->flag))
ud->flag = 0;
ud->num = ABSENT_NUMERIC;
ud->str = ABSENT_STRING;
break;
case 'n':
ud->flag = ABSENT_BOOLEAN;
ud->num = (short)le16dec(cap);
if (flags == 0 &&
!VALID_NUMERIC(ud->num))
ud->num = ABSENT_NUMERIC;
ud->str = ABSENT_STRING;
cap += sizeof(uint16_t);
break;
case 's':
ud->flag = ABSENT_BOOLEAN;
ud->num = ABSENT_NUMERIC;
len = le16dec(cap);
cap += sizeof(uint16_t);
if (len > 0)
ud->str = cap;
else if (flags == 0)
ud->str = ABSENT_STRING;
else
ud->str = CANCELLED_STRING;
cap += len;
break;
default:
goto out;
}
}
} else {
term->_nuserdefs = 0;
if (term->_userdefs) {
free(term->_userdefs);
term->_userdefs = NULL;
}
}
return 1;
out:
errno = EINVAL;
return -1;
}
static int
_ti_checkname(const char *name, const char *termname, const char *termalias)
{
const char *alias, *s;
size_t len, l;
/* Check terminal name matches. */
if (strcmp(termname, name) == 0)
return 1;
/* Check terminal aliases match. */
if (termalias == NULL)
return 0;
len = strlen(name);
alias = termalias;
while (*alias != '\0') {
s = strchr(alias, '|');
if (s == NULL)
l = strlen(alias);
else
l = (size_t)(s - alias);
if (len == l && memcmp(alias, name, l) == 0)
return 1;
if (s == NULL)
break;
alias = s + 1;
}
/* No match. */
return 0;
}
static int
_ti_dbgetterm(TERMINAL *term, const char *path, const char *name, int flags)
{
struct cdbr *db;
const void *data;
const uint8_t *data8;
size_t len, klen;
int r;
r = snprintf(__ti_database, sizeof(__ti_database), "%s.cdb", path);
if (r < 0 || (size_t)r > sizeof(__ti_database)) {
db = NULL;
errno = ENOENT; /* To fall back to a non extension. */
} else
db = cdbr_open(__ti_database, CDBR_DEFAULT);
/* Target file *may* be a cdb file without the extension. */
if (db == NULL && errno == ENOENT) {
len = strlcpy(__ti_database, path, sizeof(__ti_database));
if (len < sizeof(__ti_database))
db = cdbr_open(__ti_database, CDBR_DEFAULT);
}
if (db == NULL)
return -1;
r = 0;
klen = strlen(name) + 1;
if (cdbr_find(db, name, klen, &data, &len) == -1)
goto out;
data8 = data;
if (len == 0)
goto out;
/* If the entry is an alias, load the indexed terminfo description. */
if (data8[0] == 2) {
if (cdbr_get(db, le32dec(data8 + 1), &data, &len))
goto out;
data8 = data;
}
r = _ti_readterm(term, data, len, flags);
/* Ensure that this is the right terminfo description. */
if (r == 1)
r = _ti_checkname(name, term->name, term->_alias);
/* Remember the database we read. */
if (r == 1)
_ti_database = __ti_database;
out:
cdbr_close(db);
return r;
}
static int
_ti_dbgettermp(TERMINAL *term, const char *path, const char *name, int flags)
{
const char *p;
char pathbuf[PATH_MAX];
size_t l;
int r, e;
e = -1;
r = 0;
do {
for (p = path; *path != '\0' && *path != ':'; path++)
continue;
l = (size_t)(path - p);
if (l != 0 && l + 1 < sizeof(pathbuf)) {
memcpy(pathbuf, p, l);
pathbuf[l] = '\0';
r = _ti_dbgetterm(term, pathbuf, name, flags);
if (r == 1)
return 1;
if (r == 0)
e = 0;
}
} while (*path++ == ':');
return e;
}
static int
_ti_findterm(TERMINAL *term, const char *name, int flags)
{
int r;
char *c, *e;
_ti_database = NULL;
r = 0;
if ((e = getenv("TERMINFO")) != NULL && *e != '\0') {
if (e[0] == '/')
return _ti_dbgetterm(term, e, name, flags);
}
c = NULL;
if (e == NULL && (c = getenv("TERMCAP")) != NULL) {
if (*c != '\0' && *c != '/') {
c = strdup(c);
if (c != NULL) {
e = captoinfo(c);
free(c);
}
}
}
if (e != NULL) {
TIC *tic;
if (c == NULL)
e = strdup(e); /* So we don't destroy env */
if (e == NULL)
tic = NULL;
else {
tic = _ti_compile(e, TIC_WARNING |
TIC_ALIAS | TIC_DESCRIPTION | TIC_EXTRA);
free(e);
}
if (tic != NULL &&
_ti_checkname(name, tic->name, tic->alias) == 1)
{
uint8_t *f;
ssize_t len;
len = _ti_flatten(&f, tic);
if (len != -1) {
r = _ti_readterm(term, (char *)f, (size_t)len,
flags);
free(f);
}
}
_ti_freetic(tic);
if (r == 1) {
if (c == NULL)
_ti_database = "$TERMINFO";
else
_ti_database = "$TERMCAP";
return r;
}
}
if ((e = getenv("TERMINFO_DIRS")) != NULL)
return _ti_dbgettermp(term, e, name, flags);
if ((e = getenv("HOME")) != NULL) {
char homepath[PATH_MAX];
if (snprintf(homepath, sizeof(homepath), "%s/.terminfo", e) > 0)
r = _ti_dbgetterm(term, homepath, name, flags);
}
if (r != 1)
r = _ti_dbgettermp(term, _PATH_TERMINFO, name, flags);
return r;
}
int
_ti_getterm(TERMINAL *term, const char *name, int flags)
{
int r;
size_t i;
const struct compiled_term *t;
r = _ti_findterm(term, name, flags);
if (r == 1)
return r;
for (i = 0; i < __arraycount(compiled_terms); i++) {
t = &compiled_terms[i];
if (strcmp(name, t->name) == 0) {
r = _ti_readterm(term, t->cap, t->caplen, flags);
break;
}
}
return r;
}