1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /* Copyright (c) 1979 Regents of the University of California */
33 /* Modified to: */
34 /* 1) remember the name of the first tc= parameter */
35 /* encountered during parsing. */
36 /* 2) handle multiple invocations of tgetent(). */
37 /* 3) tskip() is now available outside of the library. */
38 /* 4) remember $TERM name for error messages. */
39 /* 5) have a larger buffer. */
40 /* 6) really fix the bug that 5) got around. This fix by */
41 /* Marion Hakanson, orstcs!hakanson */
42
43
44 #include "otermcap.h"
45 #define MAXHOP 32 /* max number of tc= indirections */
46
47 #include <sys/types.h>
48 #include <sys/stat.h>
49 #include <fcntl.h>
50 #include <sys/uio.h>
51 #include <unistd.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <ctype.h>
56
57 #include <signal.h> /* use this file to determine if this is SVR4.0 system */
58 #ifdef SIGSTOP /* SVR4.0 and beyond */
59 #define E_TERMCAP "/usr/share/lib/termcap"
60 #else
61 #define E_TERMCAP "/etc/termcap"
62 #endif
63
64 /*
65 * termcap - routines for dealing with the terminal capability data base
66 *
67 * BUG: Should use a "last" pointer in tbuf, so that searching
68 * for capabilities alphabetically would not be a n**2/2
69 * process when large numbers of capabilities are given.
70 * Note: If we add a last pointer now we will screw up the
71 * tc capability. We really should compile termcap.
72 *
73 * Essentially all the work here is scanning and decoding escapes
74 * in string capabilities. We don't use stdio because the editor
75 * doesn't, and because living w/o it is not hard.
76 */
77
78 static char *tbuf;
79 static int hopcount; /* detect infinite loops in termcap, init 0 */
80 char *tskip(char *);
81 char *otgetstr(char *, char **);
82
83 /* Tony Hansen */
84 int TLHtcfound = 0;
85 char TLHtcname[16];
86 static char *termname;
87
88 static int _tgetent(char *, char *);
89 static int otnchktc(void);
90 static char *tdecode(char *, char **);
91 static int otnamatch(char *);
92 /*
93 * Get an entry for terminal name in buffer bp,
94 * from the termcap file. Parse is very rudimentary;
95 * we just notice escaped newlines.
96 */
97 int
otgetent(char * bp,char * name)98 otgetent(char *bp, char *name)
99 {
100 /* Tony Hansen */
101 int ret;
102 TLHtcfound = 0;
103 hopcount = 0;
104 termname = name;
105 ret = _tgetent(bp, name);
106 /*
107 * There is some sort of bug in the check way down below to prevent
108 * buffer overflow. I really don't want to track it down, so I
109 * upped the standard buffer size and check here to see if the created
110 * buffer is larger than the old buffer size.
111 */
112 if (strlen(bp) >= 1024)
113 (void) fprintf(stderr,
114 "tgetent(): TERM=%s: Termcap entry is too long.\n",
115 termname);
116 return (ret);
117 }
118
119 static int
_tgetent(char * bp,char * name)120 _tgetent(char *bp, char *name)
121 {
122 char *cp;
123 int c;
124 int i = 0, cnt = 0;
125 char ibuf[TBUFSIZE];
126 char *cp2;
127 int tf;
128
129 tbuf = bp;
130 tf = 0;
131 #ifndef V6
132 cp = getenv("TERMCAP");
133 /*
134 * TERMCAP can have one of two things in it. It can be the
135 * name of a file to use instead of /etc/termcap. In this
136 * case it better start with a "/". Or it can be an entry to
137 * use so we don't have to read the file. In this case it
138 * has to already have the newlines crunched out.
139 */
140 if (cp && *cp) {
141 if (*cp != '/') {
142 cp2 = getenv("TERM");
143 if (cp2 == (char *)0 || strcmp(name, cp2) == 0) {
144 (void) strcpy(bp, cp);
145 return (otnchktc());
146 } else {
147 tf = open(E_TERMCAP, 0);
148 }
149 } else
150 tf = open(cp, 0);
151 }
152 if (tf == 0)
153 tf = open(E_TERMCAP, 0);
154 #else
155 tf = open(E_TERMCAP, 0);
156 #endif
157 if (tf < 0)
158 return (-1);
159 for (; ; ) {
160 cp = bp;
161 for (; ; ) {
162 if (i == cnt) {
163 cnt = read(tf, ibuf, TBUFSIZE);
164 if (cnt <= 0) {
165 (void) close(tf);
166 return (0);
167 }
168 i = 0;
169 }
170 c = ibuf[i++];
171 if (c == '\n') {
172 if (cp > bp && cp[-1] == '\\') {
173 cp--;
174 continue;
175 }
176 break;
177 }
178 if (cp >= bp + TBUFSIZE) {
179 (void) fprintf(stderr, "tgetent(): TERM=%s: "
180 "Termcap entry too long\n", termname);
181 break;
182 } else
183 *cp++ = c;
184 }
185 *cp = 0;
186
187 /*
188 * The real work for the match.
189 */
190 if (otnamatch(name)) {
191 (void) close(tf);
192 return (otnchktc());
193 }
194 }
195 }
196
197 /*
198 * otnchktc: check the last entry, see if it's tc=xxx. If so,
199 * recursively find xxx and append that entry (minus the names)
200 * to take the place of the tc=xxx entry. This allows termcap
201 * entries to say "like an HP2621 but doesn't turn on the labels".
202 * Note that this works because of the left to right scan.
203 */
204 static int
otnchktc(void)205 otnchktc(void)
206 {
207 char *p, *q;
208 #define TERMNAMESIZE 16
209 char tcname[TERMNAMESIZE]; /* name of similar terminal */
210 char tcbuf[TBUFSIZE];
211 char *holdtbuf = tbuf;
212 int l;
213
214 p = tbuf + strlen(tbuf) - 2; /* before the last colon */
215 while (*--p != ':')
216 if (p < tbuf) {
217 (void) fprintf(stderr, "tnchktc(): TERM=%s: Bad "
218 "termcap entry\n", termname);
219 return (0);
220 }
221 p++;
222 /* p now points to beginning of last field */
223 if (p[0] != 't' || p[1] != 'c')
224 return (1);
225 (void) strncpy(tcname, p + 3, TERMNAMESIZE); /* TLH */
226 q = tcname;
227 while (*q && *q != ':')
228 q++;
229 *q = 0;
230 if (++hopcount > MAXHOP) {
231 (void) fprintf(stderr, "tnchktc(): TERM=%s: Infinite tc= "
232 "loop\n", termname);
233 return (0);
234 }
235 if (_tgetent(tcbuf, tcname) != 1)
236 return (0);
237 /* Tony Hansen */
238 TLHtcfound++;
239 (void) strcpy(TLHtcname, tcname);
240
241 for (q = tcbuf; *q != ':'; q++)
242 ;
243 l = p - holdtbuf + strlen(q);
244 if (l > TBUFSIZE) {
245 (void) fprintf(stderr, "tnchktc(): TERM=%s: Termcap entry "
246 "too long\n", termname);
247 q[TBUFSIZE - (p - holdtbuf)] = 0;
248 }
249 (void) strcpy(p, q + 1);
250 tbuf = holdtbuf;
251 return (1);
252 }
253
254 /*
255 * Tnamatch deals with name matching. The first field of the termcap
256 * entry is a sequence of names separated by |'s, so we compare
257 * against each such name. The normal : terminator after the last
258 * name (before the first field) stops us.
259 */
260 static int
otnamatch(char * np)261 otnamatch(char *np)
262 {
263 char *Np, *Bp;
264
265 Bp = tbuf;
266 if (*Bp == '#')
267 return (0);
268 for (;;) {
269 for (Np = np; *Np && *Bp == *Np; Bp++, Np++)
270 continue;
271 if (*Np == 0 && (*Bp == '|' || *Bp == ':' || *Bp == 0))
272 return (1);
273 while (*Bp && *Bp != ':' && *Bp != '|')
274 Bp++;
275 if (*Bp == 0 || *Bp == ':')
276 return (0);
277 Bp++;
278 }
279 }
280
281 /*
282 * Skip to the next field. Notice that this is very dumb, not
283 * knowing about \: escapes or any such. If necessary, :'s can be put
284 * into the termcap file in octal.
285 */
286 char *
tskip(char * bp)287 tskip(char *bp)
288 {
289
290 while (*bp && *bp != ':')
291 bp++;
292 if (*bp == ':')
293 bp++;
294 return (bp);
295 }
296
297 /*
298 * Return the (numeric) option id.
299 * Numeric options look like
300 * li#80
301 * i.e. the option string is separated from the numeric value by
302 * a # character. If the option is not found we return -1.
303 * Note that we handle octal numbers beginning with 0.
304 */
305 int
otgetnum(char * id)306 otgetnum(char *id)
307 {
308 int i, base;
309 char *bp = tbuf;
310
311 for (;;) {
312 bp = tskip(bp);
313 if (*bp == 0)
314 return (-1);
315 if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
316 continue;
317 if (*bp == '@')
318 return (-1);
319 if (*bp != '#')
320 continue;
321 bp++;
322 base = 10;
323 if (*bp == '0')
324 base = 8;
325 i = 0;
326 while (isdigit(*bp))
327 i *= base, i += *bp++ - '0';
328 return (i);
329 }
330 }
331
332 /*
333 * Handle a flag option.
334 * Flag options are given "naked", i.e. followed by a : or the end
335 * of the buffer. Return 1 if we find the option, or 0 if it is
336 * not given.
337 */
338 int
otgetflag(char * id)339 otgetflag(char *id)
340 {
341 char *bp = tbuf;
342
343 for (;;) {
344 bp = tskip(bp);
345 if (!*bp)
346 return (0);
347 if (*bp++ == id[0] && *bp != 0 && *bp++ == id[1]) {
348 if (!*bp || *bp == ':')
349 return (1);
350 else if (*bp == '@')
351 return (0);
352 }
353 }
354 }
355
356 /*
357 * Get a string valued option.
358 * These are given as
359 * cl=^Z
360 * Much decoding is done on the strings, and the strings are
361 * placed in area, which is a ref parameter which is updated.
362 * No checking on area overflow.
363 */
364 char *
otgetstr(char * id,char ** area)365 otgetstr(char *id, char **area)
366 {
367 char *bp = tbuf;
368
369 for (; ; ) {
370 bp = tskip(bp);
371 if (!*bp)
372 return (0);
373 if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
374 continue;
375 if (*bp == '@')
376 return (0);
377 if (*bp != '=')
378 continue;
379 bp++;
380 return (tdecode(bp, area));
381 }
382 }
383
384 /*
385 * Tdecode does the grung work to decode the
386 * string capability escapes.
387 */
388 static char *
tdecode(char * str,char ** area)389 tdecode(char *str, char **area)
390 {
391 char *cp;
392 int c;
393 char *dp;
394 int i;
395
396 cp = *area;
397 while ((c = *str++) != '\0' && c != ':') {
398 switch (c) {
399
400 case '^':
401 c = *str++ & 037;
402 break;
403
404 case '\\':
405 dp = "E\033^^\\\\::n\nr\rt\tb\bf\f";
406 c = *str++;
407 nextc:
408 if (*dp++ == c) {
409 c = *dp++;
410 break;
411 }
412 dp++;
413 if (*dp)
414 goto nextc;
415 if (isdigit(c)) {
416 c -= '0', i = 2;
417 do
418 c <<= 3, c |= *str++ - '0';
419 while (--i && isdigit(*str))
420 ;
421 }
422 break;
423 }
424 *cp++ = c;
425 }
426 *cp++ = 0;
427 str = *area;
428 *area = cp;
429 return (str);
430 }
431