xref: /netbsd-src/lib/libterminfo/compile.c (revision deb6f0161a9109e7de9b519dc8dfb9478668dcdd) 
1 /* $NetBSD: compile.c,v 1.12 2017/05/04 09:46:30 roy Exp $ */
2 
3 /*
4  * Copyright (c) 2009, 2010, 2011 The NetBSD Foundation, Inc.
5  *
6  * This code is derived from software contributed to The NetBSD Foundation
7  * by Roy Marples.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 #if HAVE_NBTOOL_CONFIG_H
31 #include "nbtool_config.h"
32 #endif
33 
34 #include <sys/cdefs.h>
35 __RCSID("$NetBSD: compile.c,v 1.12 2017/05/04 09:46:30 roy Exp $");
36 
37 #if !HAVE_NBTOOL_CONFIG_H || HAVE_SYS_ENDIAN_H
38 #include <sys/endian.h>
39 #endif
40 
41 #include <assert.h>
42 #include <ctype.h>
43 #include <err.h>
44 #include <errno.h>
45 #include <limits.h>
46 #include <stdarg.h>
47 #include <stdlib.h>
48 #include <stdint.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <term_private.h>
52 #include <term.h>
53 
54 static void __printflike(2, 3)
55 dowarn(int flags, const char *fmt, ...)
56 {
57 	va_list va;
58 
59 	errno = EINVAL;
60 	if (flags & TIC_WARNING) {
61 		va_start(va, fmt);
62 		vwarnx(fmt, va);
63 		va_end(va);
64 	}
65 }
66 
67 char *
68 _ti_grow_tbuf(TBUF *tbuf, size_t len)
69 {
70 	char *buf;
71 	size_t l;
72 
73 	_DIAGASSERT(tbuf != NULL);
74 
75 	l = tbuf->bufpos + len;
76 	if (l > tbuf->buflen) {
77 		if (tbuf->buflen == 0)
78 			buf = malloc(l);
79 		else
80 			buf = realloc(tbuf->buf, l);
81 		if (buf == NULL)
82 			return NULL;
83 		tbuf->buf = buf;
84 		tbuf->buflen = l;
85 	}
86 	return tbuf->buf;
87 }
88 
89 char *
90 _ti_find_cap(TBUF *tbuf, char type, short ind)
91 {
92 	size_t n;
93 	uint16_t num;
94 	char *cap;
95 
96 	_DIAGASSERT(tbuf != NULL);
97 
98 	cap = tbuf->buf;
99 	for (n = tbuf->entries; n > 0; n--) {
100 		num = le16dec(cap);
101 		cap += sizeof(uint16_t);
102 		if ((short)num == ind)
103 			return cap;
104 		switch (type) {
105 		case 'f':
106 			cap++;
107 			break;
108 		case 'n':
109 			cap += sizeof(uint16_t);
110 			break;
111 		case 's':
112 			num = le16dec(cap);
113 			cap += sizeof(uint16_t);
114 			cap += num;
115 			break;
116 		}
117 	}
118 
119 	errno = ESRCH;
120 	return NULL;
121 }
122 
123 char *
124 _ti_find_extra(TBUF *tbuf, const char *code)
125 {
126 	size_t n;
127 	uint16_t num;
128 	char *cap;
129 
130 	_DIAGASSERT(tbuf != NULL);
131 	_DIAGASSERT(code != NULL);
132 
133 	cap = tbuf->buf;
134 	for (n = tbuf->entries; n > 0; n--) {
135 		num = le16dec(cap);
136 		cap += sizeof(uint16_t);
137 		if (strcmp(cap, code) == 0)
138 			return cap + num;
139 		cap += num;
140 		switch (*cap++) {
141 		case 'f':
142 			cap++;
143 			break;
144 		case 'n':
145 			cap += sizeof(uint16_t);
146 			break;
147 		case 's':
148 			num = le16dec(cap);
149 			cap += sizeof(uint16_t);
150 			cap += num;
151 			break;
152 		}
153 	}
154 
155 	errno = ESRCH;
156 	return NULL;
157 }
158 
159 size_t
160 _ti_store_extra(TIC *tic, int wrn, char *id, char type, char flag, short num,
161     char *str, size_t strl, int flags)
162 {
163 	size_t l;
164 
165 	_DIAGASSERT(tic != NULL);
166 
167 	if (strcmp(id, "use") != 0) {
168 		if (_ti_find_extra(&tic->extras, id) != NULL)
169 			return 0;
170 		if (!(flags & TIC_EXTRA)) {
171 			if (wrn != 0)
172 				dowarn(flags, "%s: %s: unknown capability",
173 				    tic->name, id);
174 			return 0;
175 		}
176 	}
177 
178 	l = strlen(id) + 1;
179 	if (l > UINT16_T_MAX) {
180 		dowarn(flags, "%s: %s: cap name is too long", tic->name, id);
181 		return 0;
182 	}
183 
184 	if (!_ti_grow_tbuf(&tic->extras,
185 		l + strl + (sizeof(uint16_t) * 2) + 1))
186 		return 0;
187 	le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)l);
188 	tic->extras.bufpos += sizeof(uint16_t);
189 	memcpy(tic->extras.buf + tic->extras.bufpos, id, l);
190 	tic->extras.bufpos += l;
191 	tic->extras.buf[tic->extras.bufpos++] = type;
192 	switch (type) {
193 	case 'f':
194 		tic->extras.buf[tic->extras.bufpos++] = flag;
195 		break;
196 	case 'n':
197 		le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)num);
198 		tic->extras.bufpos += sizeof(uint16_t);
199 		break;
200 	case 's':
201 		le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)strl);
202 		tic->extras.bufpos += sizeof(uint16_t);
203 		memcpy(tic->extras.buf + tic->extras.bufpos, str, strl);
204 		tic->extras.bufpos += strl;
205 		break;
206 	}
207 	tic->extras.entries++;
208 	return 1;
209 }
210 
211 ssize_t
212 _ti_flatten(uint8_t **buf, const TIC *tic)
213 {
214 	size_t buflen, len, alen, dlen;
215 	uint8_t *cap;
216 
217 	_DIAGASSERT(buf != NULL);
218 	_DIAGASSERT(tic != NULL);
219 
220 	len = strlen(tic->name) + 1;
221 	if (tic->alias == NULL)
222 		alen = 0;
223 	else
224 		alen = strlen(tic->alias) + 1;
225 	if (tic->desc == NULL)
226 		dlen = 0;
227 	else
228 		dlen = strlen(tic->desc) + 1;
229 	buflen = sizeof(char) +
230 	    sizeof(uint16_t) + len +
231 	    sizeof(uint16_t) + alen +
232 	    sizeof(uint16_t) + dlen +
233 	    (sizeof(uint16_t) * 2) + tic->flags.bufpos +
234 	    (sizeof(uint16_t) * 2) + tic->nums.bufpos +
235 	    (sizeof(uint16_t) * 2) + tic->strs.bufpos +
236 	    (sizeof(uint16_t) * 2) + tic->extras.bufpos;
237 	*buf = malloc(buflen);
238 	if (*buf == NULL)
239 		return -1;
240 
241 	cap = *buf;
242 	*cap++ = 1;
243 	le16enc(cap, (uint16_t)len);
244 	cap += sizeof(uint16_t);
245 	memcpy(cap, tic->name, len);
246 	cap += len;
247 
248 	le16enc(cap, (uint16_t)alen);
249 	cap += sizeof(uint16_t);
250 	if (tic->alias != NULL) {
251 		memcpy(cap, tic->alias, alen);
252 		cap += alen;
253 	}
254 	le16enc(cap, (uint16_t)dlen);
255 	cap += sizeof(uint16_t);
256 	if (tic->desc != NULL) {
257 		memcpy(cap, tic->desc, dlen);
258 		cap += dlen;
259 	}
260 
261 	if (tic->flags.entries == 0) {
262 		le16enc(cap, 0);
263 		cap += sizeof(uint16_t);
264 	} else {
265 		le16enc(cap, (uint16_t)(tic->flags.bufpos + sizeof(uint16_t)));
266 		cap += sizeof(uint16_t);
267 		le16enc(cap, (uint16_t)tic->flags.entries);
268 		cap += sizeof(uint16_t);
269 		memcpy(cap, tic->flags.buf, tic->flags.bufpos);
270 		cap += tic->flags.bufpos;
271 	}
272 
273 	if (tic->nums.entries == 0) {
274 		le16enc(cap, 0);
275 		cap += sizeof(uint16_t);
276 	} else {
277 		le16enc(cap, (uint16_t)(tic->nums.bufpos + sizeof(uint16_t)));
278 		cap += sizeof(uint16_t);
279 		le16enc(cap, (uint16_t)tic->nums.entries);
280 		cap += sizeof(uint16_t);
281 		memcpy(cap, tic->nums.buf, tic->nums.bufpos);
282 		cap += tic->nums.bufpos;
283 	}
284 
285 	if (tic->strs.entries == 0) {
286 		le16enc(cap, 0);
287 		cap += sizeof(uint16_t);
288 	} else {
289 		le16enc(cap, (uint16_t)(tic->strs.bufpos + sizeof(uint16_t)));
290 		cap += sizeof(uint16_t);
291 		le16enc(cap, (uint16_t)tic->strs.entries);
292 		cap += sizeof(uint16_t);
293 		memcpy(cap, tic->strs.buf, tic->strs.bufpos);
294 		cap += tic->strs.bufpos;
295 	}
296 
297 	if (tic->extras.entries == 0) {
298 		le16enc(cap, 0);
299 		cap += sizeof(uint16_t);
300 	} else {
301 		le16enc(cap, (uint16_t)(tic->extras.bufpos + sizeof(uint16_t)));
302 		cap += sizeof(uint16_t);
303 		le16enc(cap, (uint16_t)tic->extras.entries);
304 		cap += sizeof(uint16_t);
305 		memcpy(cap, tic->extras.buf, tic->extras.bufpos);
306 		cap += tic->extras.bufpos;
307 	}
308 
309 	return cap - *buf;
310 }
311 
312 static int
313 encode_string(const char *term, const char *cap, TBUF *tbuf, const char *str,
314     int flags)
315 {
316 	int slash, i, num;
317 	char ch, *p, *s, last;
318 
319 	if (_ti_grow_tbuf(tbuf, strlen(str) + 1) == NULL)
320 		return -1;
321 	p = s = tbuf->buf + tbuf->bufpos;
322 	slash = 0;
323 	last = '\0';
324 	/* Convert escape codes */
325 	while ((ch = *str++) != '\0') {
326 		if (ch == '\n') {
327 			/* Following a newline, strip leading whitespace from
328 			 * capability strings. */
329 			while (isspace((unsigned char)*str))
330 				str++;
331 			continue;
332 		}
333 		if (slash == 0 && ch == '\\') {
334 			slash = 1;
335 			continue;
336 		}
337 		if (slash == 0) {
338 			if (last != '%' && ch == '^') {
339 				ch = *str++;
340 				if (((unsigned char)ch) >= 128)
341 					dowarn(flags,
342 					    "%s: %s: illegal ^ character",
343 					    term, cap);
344 				if (ch == '\0')
345 					break;
346 				if (ch == '?')
347 					ch = '\177';
348 				else if ((ch &= 037) == 0)
349 					ch = (char)128;
350 			} else if (!isprint((unsigned char)ch))
351 				dowarn(flags,
352 				    "%s: %s: unprintable character",
353 				    term, cap);
354 			*p++ = ch;
355 			last = ch;
356 			continue;
357 		}
358 		slash = 0;
359 		if (ch >= '0' && ch <= '7') {
360 			num = ch - '0';
361 			for (i = 0; i < 2; i++) {
362 				if (*str < '0' || *str > '7') {
363 					if (isdigit((unsigned char)*str))
364 						dowarn(flags,
365 						    "%s: %s: non octal"
366 						    " digit", term, cap);
367 					else
368 						break;
369 				}
370 				num = num * 8 + *str++ - '0';
371 			}
372 			if (num == 0)
373 				num = 0200;
374 			*p++ = (char)num;
375 			continue;
376 		}
377 		switch (ch) {
378 		case 'a':
379 			*p++ = '\a';
380 			break;
381 		case 'b':
382 			*p++ = '\b';
383 			break;
384 		case 'e': /* FALLTHROUGH */
385 		case 'E':
386 			*p++ = '\033';
387 			break;
388 		case 'f':
389 			*p++ = '\014';
390 			break;
391 		case 'l': /* FALLTHROUGH */
392 		case 'n':
393 			*p++ = '\n';
394 			break;
395 		case 'r':
396 			*p++ = '\r';
397 			break;
398 		case 's':
399 			*p++ = ' ';
400 			break;
401 		case 't':
402 			*p++ = '\t';
403 			break;
404 		default:
405 			/* We should warn here */
406 		case '^':
407 		case ',':
408 		case ':':
409 		case '|':
410 			*p++ = ch;
411 			break;
412 		}
413 		last = ch;
414 	}
415 	*p++ = '\0';
416 	tbuf->bufpos += (size_t)(p - s);
417 	return 0;
418 }
419 
420 char *
421 _ti_get_token(char **cap, char sep)
422 {
423 	char esc, *token;
424 
425 	while (isspace((unsigned char)**cap))
426 		(*cap)++;
427 	if (**cap == '\0')
428 		return NULL;
429 
430 	/* We can't use stresep(3) as ^ we need two escape chars */
431 	esc = '\0';
432 	for (token = *cap;
433 	     **cap != '\0' && (esc != '\0' || **cap != sep);
434 	     (*cap)++)
435 	{
436 		if (esc == '\0') {
437 			if (**cap == '\\' || **cap == '^')
438 				esc = **cap;
439 		} else {
440 			/* termcap /E/ is valid */
441 			if (sep == ':' && esc == '\\' && **cap == 'E')
442 				esc = 'x';
443 			else
444 				esc = '\0';
445 		}
446 	}
447 
448 	if (**cap != '\0')
449 		*(*cap)++ = '\0';
450 
451 	return token;
452 }
453 
454 TIC *
455 _ti_compile(char *cap, int flags)
456 {
457 	char *token, *p, *e, *name, *desc, *alias;
458 	signed char flag;
459 	long cnum;
460 	short ind, num;
461 	size_t len;
462 	TBUF buf;
463 	TIC *tic;
464 
465 	_DIAGASSERT(cap != NULL);
466 
467 	name = _ti_get_token(&cap, ',');
468 	if (name == NULL) {
469 		dowarn(flags, "no seperator found: %s", cap);
470 		return NULL;
471 	}
472 	desc = strrchr(name, '|');
473 	if (desc != NULL)
474 		*desc++ = '\0';
475 	alias = strchr(name, '|');
476 	if (alias != NULL)
477 		*alias++ = '\0';
478 
479 	tic = calloc(sizeof(*tic), 1);
480 	if (tic == NULL)
481 		return NULL;
482 
483 	buf.buf = NULL;
484 	buf.buflen = 0;
485 
486 	tic->name = strdup(name);
487 	if (tic->name == NULL)
488 		goto error;
489 	if (alias != NULL && flags & TIC_ALIAS) {
490 		tic->alias = strdup(alias);
491 		if (tic->alias == NULL)
492 			goto error;
493 	}
494 	if (desc != NULL && flags & TIC_DESCRIPTION) {
495 		tic->desc = strdup(desc);
496 		if (tic->desc == NULL)
497 			goto error;
498 	}
499 
500 	for (token = _ti_get_token(&cap, ',');
501 	     token != NULL && *token != '\0';
502 	     token = _ti_get_token(&cap, ','))
503 	{
504 		/* Skip commented caps */
505 		if (!(flags & TIC_COMMENT) && token[0] == '.')
506 			continue;
507 
508 		/* Obsolete entries */
509 		if (token[0] == 'O' && token[1] == 'T') {
510 			if (!(flags & TIC_EXTRA))
511 				continue;
512 			token += 2;
513 		}
514 
515 		/* str cap */
516 		p = strchr(token, '=');
517 		if (p != NULL) {
518 			*p++ = '\0';
519 			/* Don't use the string if we already have it */
520 			ind = (short)_ti_strindex(token);
521 			if (ind != -1 &&
522 			    _ti_find_cap(&tic->strs, 's', ind) != NULL)
523 				continue;
524 
525 			/* Encode the string to our scratch buffer */
526 			buf.bufpos = 0;
527 			if (encode_string(tic->name, token,
528 				&buf, p, flags) == -1)
529 				goto error;
530 			if (buf.bufpos > UINT16_T_MAX) {
531 				dowarn(flags, "%s: %s: string is too long",
532 				    tic->name, token);
533 				continue;
534 			}
535 			if (!VALID_STRING(buf.buf)) {
536 				dowarn(flags, "%s: %s: invalid string",
537 				    tic->name, token);
538 				continue;
539 			}
540 
541 			if (ind == -1)
542 				_ti_store_extra(tic, 1, token, 's', -1, -2,
543 				    buf.buf, buf.bufpos, flags);
544 			else {
545 				if (!_ti_grow_tbuf(&tic->strs,
546 					(sizeof(uint16_t) * 2) + buf.bufpos))
547 					goto error;
548 				le16enc(tic->strs.buf + tic->strs.bufpos, (uint16_t)ind);
549 				tic->strs.bufpos += sizeof(uint16_t);
550 				le16enc(tic->strs.buf + tic->strs.bufpos,
551 				    (uint16_t)buf.bufpos);
552 				tic->strs.bufpos += sizeof(uint16_t);
553 				memcpy(tic->strs.buf + tic->strs.bufpos,
554 				    buf.buf, buf.bufpos);
555 				tic->strs.bufpos += buf.bufpos;
556 				tic->strs.entries++;
557 			}
558 			continue;
559 		}
560 
561 		/* num cap */
562 		p = strchr(token, '#');
563 		if (p != NULL) {
564 			*p++ = '\0';
565 			/* Don't use the number if we already have it */
566 			ind = (short)_ti_numindex(token);
567 			if (ind != -1 &&
568 			    _ti_find_cap(&tic->nums, 'n', ind) != NULL)
569 				continue;
570 
571 			cnum = strtol(p, &e, 0);
572 			if (*e != '\0') {
573 				dowarn(flags, "%s: %s: not a number",
574 				    tic->name, token);
575 				continue;
576 			}
577 			if (!VALID_NUMERIC(cnum)) {
578 				dowarn(flags, "%s: %s: number out of range",
579 				    tic->name, token);
580 				continue;
581 			}
582 			num = (short)cnum;
583 			if (ind == -1)
584 				_ti_store_extra(tic, 1, token, 'n', -1,
585 				    num, NULL, 0, flags);
586 			else {
587 				if (_ti_grow_tbuf(&tic->nums,
588 					sizeof(uint16_t) * 2) == NULL)
589 					goto error;
590 				le16enc(tic->nums.buf + tic->nums.bufpos,
591 				    (uint16_t)ind);
592 				tic->nums.bufpos += sizeof(uint16_t);
593 				le16enc(tic->nums.buf + tic->nums.bufpos,
594 				    (uint16_t)num);
595 				tic->nums.bufpos += sizeof(uint16_t);
596 				tic->nums.entries++;
597 			}
598 			continue;
599 		}
600 
601 		flag = 1;
602 		len = strlen(token) - 1;
603 		if (token[len] == '@') {
604 			flag = CANCELLED_BOOLEAN;
605 			token[len] = '\0';
606 		}
607 		ind = (short)_ti_flagindex(token);
608 		if (ind == -1 && flag == CANCELLED_BOOLEAN) {
609 			if ((ind = (short)_ti_numindex(token)) != -1) {
610 				if (_ti_find_cap(&tic->nums, 'n', ind) != NULL)
611 					continue;
612 				if (_ti_grow_tbuf(&tic->nums,
613 					sizeof(uint16_t) * 2) == NULL)
614 					goto error;
615 				le16enc(tic->nums.buf + tic->nums.bufpos,
616 				    (uint16_t)ind);
617 				tic->nums.bufpos += sizeof(uint16_t);
618 				le16enc(tic->nums.buf + tic->nums.bufpos,
619 				    (uint16_t)CANCELLED_NUMERIC);
620 				tic->nums.bufpos += sizeof(uint16_t);
621 				tic->nums.entries++;
622 				continue;
623 			} else if ((ind = (short)_ti_strindex(token)) != -1) {
624 				if (_ti_find_cap(&tic->strs, 's', ind) != NULL)
625 					continue;
626 				if (_ti_grow_tbuf(&tic->strs,
627 				    (sizeof(uint16_t) * 2) + 1) == NULL)
628 					goto error;
629 				le16enc(tic->strs.buf + tic->strs.bufpos, (uint16_t)ind);
630 				tic->strs.bufpos += sizeof(uint16_t);
631 				le16enc(tic->strs.buf + tic->strs.bufpos, 0);
632 				tic->strs.bufpos += sizeof(uint16_t);
633 				tic->strs.entries++;
634 				continue;
635 			}
636 		}
637 		if (ind == -1)
638 			_ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 0,
639 			    flags);
640 		else if (_ti_find_cap(&tic->flags, 'f', ind) == NULL) {
641 			if (_ti_grow_tbuf(&tic->flags, sizeof(uint16_t) + 1)
642 			    == NULL)
643 				goto error;
644 			le16enc(tic->flags.buf + tic->flags.bufpos,
645 			    (uint16_t)ind);
646 			tic->flags.bufpos += sizeof(uint16_t);
647 			tic->flags.buf[tic->flags.bufpos++] = flag;
648 			tic->flags.entries++;
649 		}
650 	}
651 
652 	free(buf.buf);
653 	return tic;
654 
655 error:
656 	free(buf.buf);
657 	_ti_freetic(tic);
658 	return NULL;
659 }
660 
661 void
662 _ti_freetic(TIC *tic)
663 {
664 
665 	if (tic != NULL) {
666 		free(tic->name);
667 		free(tic->alias);
668 		free(tic->desc);
669 		free(tic->extras.buf);
670 		free(tic->flags.buf);
671 		free(tic->nums.buf);
672 		free(tic->strs.buf);
673 		free(tic);
674 	}
675 }
676