xref: /titanic_41/usr/src/cmd/geniconvtbl/geniconvtbl.c (revision 85bb5f1d642e430b889478fb1200b511338085d7)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <strings.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <errno.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/mman.h>
37 #include <synch.h>
38 
39 #if defined(DEBUG)
40 #include <stdarg.h>
41 #endif /* !DEBUG */
42 
43 #include "iconv_tm.h"
44 #include "hash.h"
45 
46 
47 /*
48  * Debug
49  */
50 #if defined(DEBUG)
51 
52 static void	trace_init(void);
53 static void	trace_message(char *, ...);
54 
55 static char	trace_option[128];
56 
57 #define	TRACE(c)		(*(trace_option + (c & 0x007f)))
58 #define	TRACE_MESSAGE(c, args)	((TRACE(c))? trace_message args: (void)0)
59 
60 #else /* !DEBUG */
61 
62 #define	trace_init()
63 #define	TRACE()
64 #define	TRACE_MESSAGE(c, args)
65 
66 #endif /* !DEBUG */
67 
68 
69 /*
70  * ITM reference information
71  */
72 typedef struct _itm_ref {
73 	char		*name;		/* ITM file name */
74 	itm_hdr_t	*hdr;		/* address of ITM */
75 	size_t		len;		/* length of ITM */
76 } itm_ref_t;
77 
78 
79 /*
80  * struct _icv_state; to keep status
81  */
82 typedef struct _icv_state {
83 	struct _itm_ref	*itm;		/* reference to ITM */
84 	itm_hdr_t	*itm_hdr;	/* address of ITM */
85 	itm_tbl_hdr_t	*direc;		/* current direction */
86 	itm_place_t	default_action;	/* default action */
87 	itm_num_t	*regs;		/* register */
88 	itm_num_t	reg_num;	/* number of register */
89 #if defined(OP_DEPTH_MAX)
90 	int		op_depth;	/* depth of operation */
91 #endif /* OP_DEPTH_MAX */
92 } icv_state_t;
93 
94 
95 /*
96  * function prototype
97  */
98 void *	_icv_open(const char *);
99 void	_icv_close(icv_state_t *);
100 size_t	_icv_iconv(icv_state_t *, const unsigned char **,
101 		    size_t *, unsigned char **, size_t *);
102 
103 static size_t	map_i_f(itm_tbl_hdr_t *,
104 			const unsigned char **, size_t *,
105 			unsigned char **, size_t *, long);
106 static size_t	map_l_f(itm_tbl_hdr_t *,
107 			const unsigned char **, size_t *,
108 			unsigned char **, size_t *, long);
109 static size_t	map_h_l(itm_tbl_hdr_t *,
110 			const unsigned char **, size_t *,
111 			unsigned char **, size_t *, long);
112 static size_t	map_d_e_l(itm_tbl_hdr_t *,
113 			const unsigned char **, size_t *,
114 			unsigned char **, size_t *, long);
115 static size_t	eval_cond_tbl(icv_state_t *, itm_place_t,
116 			const unsigned char **, size_t *,
117 			size_t, itm_direc_t *);
118 static size_t	eval_op_tbl(icv_state_t *, itm_place_t,
119 			const unsigned char **, size_t *,
120 			unsigned char **, size_t *);
121 static size_t	eval_op(icv_state_t *, itm_place2_t,
122 			const unsigned char **, size_t *,
123 			unsigned char **, size_t *);
124 
125 static itm_num_t	eval_expr(icv_state_t *, itm_place_t,
126 				size_t, const unsigned char *, size_t);
127 
128 static void		itm_ref_free(int, void *, void *, void *, size_t);
129 static itm_ref_t	*itm_ref_inc(const char *);
130 static void		itm_ref_dec(itm_ref_t *);
131 
132 static void		op_init_default(icv_state_t *);
133 static void		op_reset_default(icv_state_t *);
134 static void		regs_init(icv_state_t *);
135 
136 
137 /*
138  * macro definition
139  */
140 
141 #define	ADDR(place)	((void *)(((char *)(ist->itm_hdr)) +\
142 				((itm_place2_t)(place.itm_ptr))))
143 #define	ADDR2(place2)	((void *)(((char *)(ist->itm_hdr)) +\
144 				((itm_place2_t)(place2))))
145 #define	DADDR(n)	(((n)->size <= (sizeof ((n)->place.itm_64d))) ?	\
146 				((unsigned char *)(&((n)->place.itm_64d))) :\
147 				((unsigned char *)(ADDR((n)->place))))
148 
149 #define	REG(n)		(*(ist->regs + (n)))
150 #define	DISCARD(c)	(((*inbuf) = (void *)((*inbuf) + (c))),\
151 			((*inbytesleft) -= (c)))
152 #define	GET(c)		((c) = **inbuf, (*inbuf)++, (*inbytesleft)--)
153 #define	PUT(c)		(**outbuf = (c), (*outbuf)++, (*outbytesleft)--)
154 
155 #define	RETVALERR	((size_t)(-1))
156 #define	RETVALDIR	((size_t)(-2))
157 #define	RETVALBRK	((size_t)(-3))
158 #define	RETVALRET	((size_t)(-4))
159 
160 #define	UPDATE_ARGS()	(*inbuf = ip, \
161 			 *inbytesleft = ileft, \
162 			 *outbuf = op, \
163 			 *outbytesleft = oleft)
164 
165 /*
166  * Open; called from iconv_open()
167  */
168 void *
_icv_open(const char * itm)169 _icv_open(const char	*itm)
170 {
171 	icv_state_t	*ist;
172 	itm_hdr_t	*hdr;
173 	itm_ref_t	*itm_ref;
174 	int		r;
175 
176 	/*
177 	 * for debug
178 	 */
179 	trace_init();
180 
181 	/*
182 	 * _icv_open() primaty task
183 	 */
184 	itm_ref = itm_ref_inc(itm);
185 	if (NULL == itm_ref) {
186 		return ((void *)(-1));
187 	}
188 
189 	if (NULL == (ist = malloc(sizeof (icv_state_t)))) {
190 		r = errno;
191 		itm_ref_dec(itm_ref);
192 		errno = r;
193 		return	(NULL);
194 	}
195 
196 	ist->itm = itm_ref;
197 	ist->itm_hdr = ist->itm->hdr;
198 	ist->reg_num = ist->itm->hdr->reg_num;
199 
200 	hdr =  ist->itm->hdr;
201 	ist->direc = ADDR(hdr->direc_init_tbl);
202 	ist->default_action.itm_64d = 0;
203 #if defined(OP_DEPTH_MAX)
204 	ist->op_depth = 0;
205 #endif /* OP_DEPTH_MAX */
206 
207 
208 	/*
209 	 * brief sanity check
210 	 */
211 	if (hdr->itm_size.itm_ptr <= hdr->direc_init_tbl.itm_ptr) {
212 		_icv_close(ist);
213 		errno = ELIBBAD;
214 		return ((void *)(-1));
215 	}
216 
217 
218 	/* allocate register region */
219 	if (hdr->reg_num <= 0) {
220 		ist->regs = NULL;
221 	} else {
222 		ist->regs = malloc((sizeof (itm_num_t)) * hdr->reg_num);
223 		if (NULL == ist->regs) {
224 			r = errno;
225 			_icv_close(ist);
226 			errno = r;
227 			return ((void *)(-1));
228 		}
229 		(void) memset(ist->regs, 0,
230 		    (sizeof (itm_num_t)) * hdr->reg_num);
231 	}
232 
233 
234 	/* evaluate init operation */
235 	if (0 != ist->itm_hdr->op_init_tbl.itm_ptr) {
236 		const unsigned char	*ip = NULL;
237 		size_t			ileft = 0;
238 		unsigned char		*op = NULL;
239 		size_t			oleft = 0;
240 		(void) eval_op_tbl(ist, ist->itm_hdr->op_init_tbl, &ip,
241 		    &ileft, &op, &oleft);
242 	} else {
243 		op_init_default(ist);
244 	}
245 
246 	return	(ist);
247 }
248 
249 
250 /*
251  * Close; called from iconv_close
252  */
253 void
_icv_close(icv_state_t * ist)254 _icv_close(icv_state_t		*ist)
255 {
256 	if (NULL == ist) {
257 		errno = EBADF;
258 		return;
259 	}
260 	itm_ref_dec(ist->itm);
261 	free(ist->regs);
262 	free(ist);
263 }
264 
265 
266 /*
267  * Actual conversion; called from iconv()
268  */
269 size_t
_icv_iconv(icv_state_t * ist,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft)270 _icv_iconv(
271 	icv_state_t		*ist,
272 	const unsigned char	**inbuf,
273 	size_t			*inbytesleft,
274 	unsigned char		**outbuf,
275 	size_t			*outbytesleft)
276 {
277 	size_t			retval;
278 	itm_hdr_t		*hdr;
279 	itm_type_t		type;
280 	const unsigned char	*ip;
281 	size_t			ileft;
282 	itm_place_t		action;
283 
284 	if (NULL == ist) {
285 		errno = EBADF;
286 		TRACE_MESSAGE('e', ("_icv_iconv: error=%d\n", errno));
287 		return ((size_t)(-1));
288 	}
289 	if (NULL == inbuf) {
290 		ip = NULL;
291 		inbuf = &ip;
292 	}
293 	if (NULL == inbytesleft) {
294 		ileft = 0;
295 		inbytesleft = &ileft;
296 	}
297 
298 	hdr = ist->itm_hdr;
299 
300 	retval = 0;
301 
302 	TRACE_MESSAGE('i', ("_icv_iconv(inbuf=%p inbytesleft=%ld "
303 	    "outbuf=%p outbytesleft=%ld)\n", (NULL == inbuf) ? 0 : *inbuf,
304 	    (NULL == inbytesleft) ? 0 : *inbytesleft,
305 	    (NULL == outbuf) ? 0 : *outbuf,
306 	    (NULL == outbytesleft) ? 0 : *outbytesleft));
307 
308 	/*
309 	 * If (NULL == inbuf || NULL == *inbuf) then this conversion is
310 	 * placed into initial state.
311 	 */
312 	if ((NULL == inbuf) || (NULL == *inbuf)) {
313 		if (0 != hdr->op_reset_tbl.itm_ptr) {
314 			ist->direc = ADDR(hdr->direc_init_tbl);
315 			retval = eval_op_tbl(ist, hdr->op_reset_tbl, inbuf,
316 			    inbytesleft, outbuf, outbytesleft);
317 			if ((size_t)(-1) == retval) {
318 				return	(retval);
319 			}
320 		} else {
321 			op_reset_default(ist);
322 		}
323 		return ((size_t)(0));
324 	}
325 
326 	if (ITM_TBL_MAP_INDEX_FIXED_1_1 == ist->direc->type) {
327 		itm_map_idx_fix_hdr_t	*map_hdr;
328 		char			*map;
329 		const unsigned char	*ip;
330 		size_t			ileft;
331 		unsigned char		*op;
332 		size_t			oleft;
333 
334 		map_hdr = (itm_map_idx_fix_hdr_t *)(ist->direc + 1);
335 		map = (char *)(map_hdr + 1);
336 
337 		if (1 == map_hdr->default_error) {
338 			retval = map_i_f(ist->direc, inbuf, inbytesleft,
339 			    outbuf, outbytesleft, 0);
340 			return	(retval);
341 		}
342 
343 		ip = *inbuf;
344 		ileft = *inbytesleft;
345 		op = *outbuf;
346 		oleft = *outbytesleft;
347 
348 		while (1 <= ileft) {
349 			if (oleft < 1) {
350 				UPDATE_ARGS();
351 				errno = E2BIG;
352 				TRACE_MESSAGE('e', ("_icv_iconv: error=%d\n",
353 				    errno));
354 				return ((size_t)-1);
355 			}
356 			*(op++) = *(map + *(ip++));
357 			ileft--;
358 			oleft--;
359 
360 		}
361 		UPDATE_ARGS();
362 		return (0);
363 	} else if (ITM_TBL_MAP_INDEX_FIXED == ist->direc->type) {
364 		retval = map_i_f(ist->direc, inbuf, inbytesleft,
365 		    outbuf, outbytesleft, 0);
366 		return	(retval);
367 	} else if (ITM_TBL_MAP_HASH == ist->direc->type) {
368 		retval = map_h_l(ist->direc, inbuf, inbytesleft,
369 		    outbuf, outbytesleft, 0);
370 		return	(retval);
371 	} else if (ITM_TBL_MAP_DENSE_ENC == ist->direc->type) {
372 		retval = map_d_e_l(ist->direc, inbuf, inbytesleft,
373 		    outbuf, outbytesleft, 0);
374 		return	(retval);
375 	} else if (ITM_TBL_MAP_LOOKUP == ist->direc->type) {
376 		retval = map_l_f(ist->direc, inbuf, inbytesleft,
377 		    outbuf, outbytesleft, 0);
378 		return	(retval);
379 	}
380 
381 #if defined(OP_DEPTH_MAX)
382 	ist->op_depth = 0;
383 #endif /* OP_DEPTH_MAX */
384 
385 
386 	/*
387 	 * Main loop; basically 1 loop per 1 output character
388 	 */
389 retry_cond_eval:
390 	while (0 < *inbytesleft) {
391 		itm_tbl_hdr_t	*direc_hdr;
392 		itm_direc_t	*direc;
393 		long		i;
394 
395 		direc_hdr = ist->direc;
396 		direc = (itm_direc_t *)(ist->direc + 1);
397 		for (i = 0; /* NULL */; i++, direc++) {
398 			if (i >= direc_hdr->number) {
399 				if (0 == ist->default_action.itm_ptr) {
400 					errno = EILSEQ;
401 					TRACE_MESSAGE('e',
402 					    ("_icv_iconv:error=%d\n", errno));
403 					return ((size_t)(-1));
404 				}
405 
406 
407 
408 				action = ist->default_action;
409 				type = ((itm_tbl_hdr_t *)(ADDR(action)))->type;
410 				TRACE_MESSAGE('E',
411 				    ("escape seq (default action=%6p, "
412 				    "type=%ld) executing\n",
413 				    action.itm_ptr, type));
414 			} else if (0 != direc->condition.itm_ptr) {
415 				retval = eval_cond_tbl(ist, direc->condition,
416 				    inbuf, inbytesleft, *outbytesleft, direc);
417 				if ((size_t)(0) == retval) {
418 					continue;
419 				} else if ((size_t)(-1) == retval) {
420 					return	(retval);
421 				} else if ((size_t)(2) == retval) {
422 					goto retry_cond_eval;
423 				}
424 				action = direc->action;
425 				type = ((itm_tbl_hdr_t *)(ADDR(action)))->type;
426 			} else {
427 				action = direc->action;
428 				type = ((itm_tbl_hdr_t *)(ADDR(action)))->type;
429 			}
430 
431 			TRACE_MESSAGE('a',
432 			    ("inbytesleft=%ld; type=%ld:action=%p\n",
433 			    *inbytesleft, type, action.itm_ptr));
434 			switch (ITM_TBL_MASK & type) {
435 			case ITM_TBL_OP:
436 				retval = eval_op_tbl(ist, action,
437 				    inbuf, inbytesleft, outbuf, outbytesleft);
438 				if ((size_t)(-1) == retval) {
439 					return	(retval);
440 				}
441 				break;
442 			case ITM_TBL_DIREC:
443 				ist->direc = ADDR(action);
444 				break;
445 			case ITM_TBL_MAP:
446 				switch (type) {
447 				case ITM_TBL_MAP_INDEX_FIXED_1_1:
448 				case ITM_TBL_MAP_INDEX_FIXED:
449 					retval = map_i_f(ADDR(action),
450 					    inbuf, inbytesleft,
451 					    outbuf, outbytesleft, 1);
452 					break;
453 				case ITM_TBL_MAP_HASH:
454 					retval = map_h_l(ADDR(action),
455 					    inbuf, inbytesleft,
456 					    outbuf, outbytesleft, 1);
457 					break;
458 				case ITM_TBL_MAP_DENSE_ENC:
459 					retval = map_d_e_l(ADDR(action),
460 					    inbuf, inbytesleft,
461 					    outbuf, outbytesleft, 1);
462 					break;
463 				case ITM_TBL_MAP_LOOKUP:
464 					retval = map_l_f(ADDR(action),
465 					    inbuf, inbytesleft,
466 					    outbuf, outbytesleft, 1);
467 					break;
468 				default:
469 					errno = ELIBBAD;
470 					TRACE_MESSAGE('e',
471 					    ("_icv_iconv:error=%d\n", errno));
472 					return ((size_t)(-1));
473 
474 				}
475 				if ((size_t)(-1) == retval) {
476 					return	(retval);
477 				}
478 				break;
479 			default:	/* never */
480 				errno = ELIBBAD;
481 				TRACE_MESSAGE('e',
482 				    ("_icv_iconv:error=%d\n", errno));
483 				return ((size_t)(-1));
484 			}
485 			break;
486 		}
487 	}
488 	return	(retval);
489 }
490 
491 
492 
493 /*
494  * map-indexed-fixed
495  */
496 static size_t
map_i_f(itm_tbl_hdr_t * tbl_hdr,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft,long once)497 map_i_f(
498 	itm_tbl_hdr_t		*tbl_hdr,
499 	const unsigned char	**inbuf,
500 	size_t			*inbytesleft,
501 	unsigned char		**outbuf,
502 	size_t			*outbytesleft,
503 	long			once)
504 {
505 	itm_map_idx_fix_hdr_t	*map_hdr;
506 	long			i;
507 	unsigned char		c;
508 	unsigned long		j;
509 	const unsigned char	*p;
510 
511 	TRACE_MESSAGE('i', ("map_i_f\n"));
512 
513 	map_hdr = (itm_map_idx_fix_hdr_t *)(tbl_hdr + 1);
514 
515 	do {
516 		if (*inbytesleft < map_hdr->source_len) {
517 			errno = EINVAL;
518 			TRACE_MESSAGE('e', ("map_i_f:error=%d\n", errno));
519 			return ((size_t)(-1));
520 		}
521 
522 		j = 0;
523 		for (i = 0; i < map_hdr->source_len; i++) {
524 			GET(c);
525 			j = ((j << 8) | c);
526 		}
527 
528 		if (((j < map_hdr->start.itm_ptr) ||
529 		    (map_hdr->end.itm_ptr < j)) &&
530 		    (0 < map_hdr->default_error)) {
531 			errno = EILSEQ;
532 			(*inbuf) = (void*) ((*inbuf) - map_hdr->source_len);
533 			(*inbytesleft) += map_hdr->source_len;
534 			TRACE_MESSAGE('e', ("map_i_f:error=%d\n", errno));
535 			return ((size_t)(-1));
536 		}
537 
538 		if (*outbytesleft < map_hdr->result_len) {
539 			errno = E2BIG;
540 			(*inbuf) = (void *)((*inbuf) - map_hdr->source_len);
541 			(*inbytesleft) += map_hdr->source_len;
542 			TRACE_MESSAGE('e', ("map_i_f:error=%d\n", errno));
543 			return ((size_t)(-1));
544 		}
545 
546 		if ((j < map_hdr->start.itm_ptr) ||
547 		    (map_hdr->end.itm_ptr < j)) {
548 			if (0 == map_hdr->default_error) {
549 				p = (((unsigned char *)(map_hdr + 1)) +
550 				    (map_hdr->result_len * (tbl_hdr->number)));
551 				for (i = 0; i < map_hdr->result_len; i++) {
552 					PUT(*(p + i));
553 				}
554 			} else {
555 				p = ((*inbuf) - map_hdr->source_len);
556 				for (i = 0; i < map_hdr->source_len; i++) {
557 					PUT(*(p + i));
558 				}
559 			}
560 		} else {
561 			char	*map_error;
562 			map_error = (((char *)(map_hdr + 1)) +
563 			    (map_hdr->result_len * (tbl_hdr->number)) +
564 			    (j - map_hdr->start.itm_ptr));
565 			if (0 == map_hdr->default_error) {
566 				map_error = (void *)
567 				    (map_error + map_hdr->result_len);
568 			}
569 			if (((1 == map_hdr->default_error) ||
570 			    (0 < map_hdr->error_num)) &&
571 			    (0 != *(map_error))) {
572 				errno = EILSEQ;
573 				(*inbuf) = (void *)
574 				    ((*inbuf) - map_hdr->source_len);
575 				(*inbytesleft) += map_hdr->source_len;
576 				TRACE_MESSAGE('e',
577 				    ("map_i_f:error=%d\n", errno));
578 				return ((size_t)(-1));
579 			}
580 			p = (((unsigned char *)(map_hdr + 1)) +
581 			    (map_hdr->result_len *
582 			    (j - map_hdr->start.itm_ptr)));
583 			for (i = 0; i < map_hdr->result_len; i++) {
584 				PUT(*(p + i));
585 			}
586 		}
587 	} while ((0 < *inbytesleft) && (0 == once));
588 
589 	return (size_t)(0);
590 }
591 
592 
593 /*
594  * map-lookup-fixed
595  */
596 static size_t
map_l_f(itm_tbl_hdr_t * tbl_hdr,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft,long once)597 map_l_f(
598 	itm_tbl_hdr_t	*tbl_hdr,
599 	const unsigned char	**inbuf,
600 	size_t		*inbytesleft,
601 	unsigned char	**outbuf,
602 	size_t		*outbytesleft,
603 	long		once)
604 {
605 	itm_map_lookup_hdr_t	*map_hdr;
606 	long			i;
607 	unsigned char		*map;
608 	const unsigned char	*p;
609 	long			high;
610 	long			mid;
611 	long			low;
612 	long			result;
613 	itm_size_t		pair_size;
614 
615 	TRACE_MESSAGE('i', ("map_l_f\n"));
616 
617 	map_hdr = (itm_map_lookup_hdr_t *)(tbl_hdr + 1);
618 	map = (unsigned char *)(map_hdr + 1);
619 	pair_size = map_hdr->source_len + 1 + map_hdr->result_len;
620 
621 	do {
622 		if (*inbytesleft < map_hdr->source_len) {
623 			errno = EINVAL;
624 			TRACE_MESSAGE('e', ("map_l_f:error=%d\n", errno));
625 			return ((size_t)(-1));
626 		}
627 
628 		for (low = 0, high = tbl_hdr->number; low < high; ) {
629 			mid = (low + high) / 2;
630 			p = map + (pair_size * mid);
631 			for (i = 0, result = 0; i < map_hdr->source_len;
632 			    i++, p++) {
633 				if (*(unsigned char *)(*inbuf + i) < *p) {
634 					result = -1;
635 					break;
636 				}
637 				if (*p < *(unsigned char *)(*inbuf + i)) {
638 					result = 1;
639 					break;
640 				}
641 			}
642 			if (result < 0) {
643 				high = mid;
644 			} else if (0 < result) {
645 				low = mid + 1;
646 			} else { /* 0 == result */
647 				break;
648 			}
649 		}
650 
651 		if (0 != result) {
652 			if (map_hdr->default_error < 0) {
653 				p = *inbuf;
654 			} else if (0 == map_hdr->default_error) {
655 				p = map + (pair_size * tbl_hdr->number) +
656 				    map_hdr->source_len + 1;
657 			} else if (0 < map_hdr->default_error) {
658 				errno = EILSEQ;
659 				TRACE_MESSAGE('e', ("map_l_f:error=%d\n",
660 				    errno));
661 				return ((size_t)(-1));
662 			}
663 		} else {
664 			if (0 != (*p)) {
665 				errno = EILSEQ;
666 				TRACE_MESSAGE('e', ("map_l_f:error=%d\n",
667 				    errno));
668 				return ((size_t)(-1));
669 			}
670 			p++;
671 		}
672 
673 		if (*outbytesleft < map_hdr->result_len) {
674 			errno = E2BIG;
675 			TRACE_MESSAGE('e', ("map_l_f:error=%d\n", errno));
676 			return ((size_t)(-1));
677 		}
678 		DISCARD(map_hdr->source_len);
679 
680 		for (i = 0; i < map_hdr->result_len; i++) {
681 			PUT(*(p + i));
682 		}
683 	} while ((0 < *inbytesleft) && (0 == once));
684 
685 	return ((size_t)(0));
686 }
687 
688 
689 /*
690  * map-hash-lookup
691  */
692 static size_t
map_h_l(itm_tbl_hdr_t * tbl_hdr,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft,long once)693 map_h_l(
694 	itm_tbl_hdr_t	*tbl_hdr,
695 	const unsigned char	**inbuf,
696 	size_t		*inbytesleft,
697 	unsigned char	**outbuf,
698 	size_t		*outbytesleft,
699 	long		once)
700 {
701 	itm_map_hash_hdr_t	*map_hdr;
702 	long			i;
703 	unsigned char	*map_error;
704 	unsigned char	*map_hash;
705 	unsigned char	*map_of;
706 	const unsigned char	*p;
707 	const unsigned char	*q;
708 	long			high;
709 	long			mid;
710 	long			low;
711 	long			result;
712 	itm_size_t		pair_size;
713 	itm_size_t		hash_value;
714 	itm_size_t		source_len;
715 	itm_size_t		result_len;
716 
717 	TRACE_MESSAGE('i', ("map_hash\n"));
718 
719 	map_hdr = (itm_map_hash_hdr_t *)(tbl_hdr + 1);
720 	map_error = (unsigned char *)(map_hdr + 1);
721 	map_hash = (map_error + map_hdr->hash_tbl_num);
722 	map_of = map_hash + map_hdr->hash_tbl_size;
723 	pair_size = map_hdr->source_len + 1 + map_hdr->result_len;
724 	source_len = map_hdr->source_len;
725 	result_len = map_hdr->result_len;
726 
727 	do {
728 		if (*inbytesleft < source_len) {
729 			errno = EINVAL;
730 			TRACE_MESSAGE('e', ("map_h_l:error=%d\n", errno));
731 			return ((size_t)(-1));
732 		}
733 
734 		result = 1;
735 		q = *inbuf;
736 		hash_value = hash((const char *)(q), source_len,
737 		    map_hdr->hash_tbl_num);
738 		p = map_hash + (pair_size * hash_value);
739 		if (1 == *(map_error + hash_value)) {
740 			for (i = 0, result = 0; i < source_len; i++) {
741 				if (*(q + i) != *(p++)) {
742 					result = -2;
743 					break;
744 				}
745 			}
746 			TRACE_MESSAGE('G',
747 			    ("(h=%d): find pair without conflict\n",
748 			    hash_value));
749 		} else if (0 == *(map_error + hash_value)) {
750 			TRACE_MESSAGE('G', ("(h=%d): No Pair\n", hash_value));
751 			result = -3;
752 		} else /* if (0 < *(map_error + hash_value)) */ {
753 			for (i = 0, result = 0; i < source_len; i++) {
754 				if (*(q + i) != *(p++)) {
755 					result = 1;
756 					break;
757 				}
758 			}
759 			if (0 < result) {
760 				for (low = 0, high = map_hdr->hash_of_num;
761 				    low < high; /* NOP */) {
762 					mid = (low + high) / 2;
763 					p = map_of + (pair_size * mid);
764 					for (i = 0, result = 0;
765 					    i < source_len;
766 					    i++, p++) {
767 						if (*(q + i) < *p) {
768 							result = -1;
769 							break;
770 						}
771 						if (*p < *(q + i)) {
772 							result = 1;
773 							break;
774 						}
775 					}
776 					if (result < 0) {
777 						high = mid;
778 					} else if (0 < result) {
779 						low = mid + 1;
780 					} else { /* 0 == result */
781 						TRACE_MESSAGE('G', ("(h=%d): "
782 						    "find data on out of "
783 						    "hashtable with CONFLICT\n",
784 						    hash_value));
785 						break;
786 					}
787 				}
788 			}
789 		}
790 		if (0 != result) {
791 			if (map_hdr->default_error < 0) {
792 				p = q;
793 			} else if (0 == map_hdr->default_error) {
794 				p = map_of + map_hdr->hash_of_size;
795 			} else if (0 < map_hdr->default_error) {
796 				TRACE_MESSAGE('G', ("(h=%d): NO PAIR\n",
797 				    hash_value));
798 				errno = EILSEQ;
799 				TRACE_MESSAGE('e',
800 				    ("map_h_l:error=%d\n", errno));
801 				return ((size_t)(-1));
802 			}
803 		} else {
804 			if (0 != (*p)) {
805 				errno = EILSEQ;
806 				TRACE_MESSAGE('G', ("	      : error pair\n"));
807 				TRACE_MESSAGE('e', ("map_l_f:error\n", errno));
808 				return ((size_t)(-1));
809 			}
810 			p++;
811 		}
812 
813 		if (*outbytesleft < result_len) {
814 			errno = E2BIG;
815 			TRACE_MESSAGE('e', ("map_h_l:error=%d\n", errno));
816 			return ((size_t)(-1));
817 		}
818 		DISCARD(source_len);
819 
820 		for (i = 0; i < result_len; i++) {
821 			PUT(*(p + i));
822 		}
823 	} while ((0 < *inbytesleft) && (0 == once));
824 
825 	return ((size_t)(0));
826 }
827 
828 
829 /*
830  * map-dense_encoding-lookup
831  */
832 static size_t
map_d_e_l(itm_tbl_hdr_t * tbl_hdr,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft,long once)833 map_d_e_l(
834 	itm_tbl_hdr_t		*tbl_hdr,
835 	const unsigned char	**inbuf,
836 	size_t			*inbytesleft,
837 	unsigned char		**outbuf,
838 	size_t			*outbytesleft,
839 	long			once)
840 {
841 	itm_map_dense_enc_hdr_t	*map_hdr;
842 	long			i;
843 	itm_num_t		j;
844 	const unsigned char	*p;
845 	unsigned char		*map_ptr;
846 	unsigned char		*map_error;
847 	unsigned char		*byte_seq_min;
848 	unsigned char		*byte_seq_max;
849 
850 	TRACE_MESSAGE('i', ("map_d_e_l\n"));
851 
852 	map_hdr = (itm_map_dense_enc_hdr_t *)(tbl_hdr + 1);
853 	map_ptr = ((unsigned char *)(map_hdr + 1) + map_hdr->source_len +
854 	    map_hdr->source_len);
855 	map_error = (map_ptr + (tbl_hdr->number * map_hdr->result_len));
856 	if (0 == map_hdr->default_error) {
857 		map_error = (void *)(map_error + map_hdr->result_len);
858 	}
859 	byte_seq_min = (unsigned char *)(map_hdr + 1);
860 	byte_seq_max = byte_seq_min + map_hdr->source_len;
861 
862 	do {
863 		if (*inbytesleft < map_hdr->source_len) {
864 			errno = EINVAL;
865 			TRACE_MESSAGE('e', ("map_d_e_l:error=%d\n", errno));
866 			return ((size_t)(-1));
867 		}
868 
869 		j = hash_dense_encoding(*inbuf, map_hdr->source_len,
870 		    byte_seq_min, byte_seq_max);
871 
872 		if (((j < 0) || (tbl_hdr->number < j)) &&
873 		    (0 < map_hdr->default_error)) {
874 			errno = EILSEQ;
875 			TRACE_MESSAGE('e', ("map_d_e_l:error=%d\n", errno));
876 			return ((size_t)(-1));
877 		}
878 
879 		if (*outbytesleft < map_hdr->result_len) {
880 			errno = E2BIG;
881 			TRACE_MESSAGE('e', ("map_d_e_l:error=%d\n", errno));
882 			return ((size_t)(-1));
883 		}
884 
885 		if ((j < 0) || (tbl_hdr->number < j)) {
886 			if (0 == map_hdr->default_error) {
887 				p = (map_ptr + (tbl_hdr->number *
888 				    map_hdr->result_len));
889 				for (i = 0; i < map_hdr->result_len; i++) {
890 					PUT(*(p + i));
891 				}
892 			} else {
893 				p = *inbuf;
894 				for (i = 0; i < map_hdr->source_len; i++) {
895 					PUT(*(p + i));
896 				}
897 			}
898 		} else {
899 			if ((1 == map_hdr->default_error) ||
900 			    (0 < map_hdr->error_num)) {
901 				if (0 != *(map_error + j)) {
902 					errno = EILSEQ;
903 					TRACE_MESSAGE('e',
904 					    ("map_d_e_l:error=%d\n", errno));
905 					return ((size_t)(-1));
906 				}
907 			}
908 			p = (map_ptr + (map_hdr->result_len * j));
909 			for (i = 0; i < map_hdr->result_len; i++) {
910 				PUT(*(p + i));
911 			}
912 		}
913 		DISCARD(map_hdr->source_len);
914 	} while ((0 < *inbytesleft) && (0 == once));
915 
916 	return ((size_t)(0));
917 }
918 
919 
920 
921 /*
922  * Evaluate condition table
923  *
924  */
925 static size_t
eval_cond_tbl(icv_state_t * ist,itm_place_t cond_place,const unsigned char ** inbuf,size_t * inbytesleft,size_t outbytesleft,itm_direc_t * direc)926 eval_cond_tbl(
927 	icv_state_t		*ist,
928 	itm_place_t		cond_place,
929 	const unsigned char	**inbuf,
930 	size_t			*inbytesleft,
931 	size_t			outbytesleft,
932 	itm_direc_t		*direc
933 )
934 {
935 	itm_tbl_hdr_t		*cond_hdr;
936 	itm_cond_t		*cond;
937 	long			i;
938 	long			j;
939 	long			k;
940 	size_t			retval;
941 	itm_tbl_hdr_t		*rth;
942 	itm_range_hdr_t		*rtsh;
943 	unsigned char		*p;
944 	itm_tbl_hdr_t		*eth;
945 	itm_escapeseq_hdr_t	*eh;
946 	itm_data_t		*d;
947 	const unsigned char	*ip;
948 	size_t			ileft;
949 
950 	retval = 0;
951 	ip =	*inbuf;
952 	ileft = *inbytesleft;
953 	cond_hdr = ADDR(cond_place);
954 	cond = (itm_cond_t *)(cond_hdr + 1);
955 	for (i = 0; i < cond_hdr->number; i++, cond++) {
956 		switch (cond->type) {
957 		case ITM_COND_BETWEEN:
958 			rth = ADDR(cond->operand.place);
959 			rtsh = (itm_range_hdr_t *)(rth + 1);
960 			if (ileft < rtsh->len) {
961 				errno = EINVAL;
962 				TRACE_MESSAGE('e', ("eval_cond_tbl:error=%d\n",
963 				    errno));
964 				retval = ((size_t)(-1));
965 				goto eval_cond_return;
966 			}
967 			p = (unsigned char *)(rtsh + 1);
968 			retval = 0;
969 			for (j = 0; j < rth->number;
970 			    j++,  p = (void *)(p + (2 * rtsh->len))) {
971 				retval = 1;
972 				for (k = 0; k < rtsh->len; k++) {
973 					if ((*(ip + k) < *(p + k)) ||
974 					    (*(p + rtsh->len + k) <
975 					    *(ip + k))) {
976 						retval = 0;
977 						break;
978 					}
979 				}
980 				if (1 == retval) {
981 					break;
982 				}
983 			}
984 			if (0 == retval) {
985 				TRACE_MESSAGE('b',
986 				    ("out of between (%p) len= rtsh=%ld\n",
987 				    *ip, rtsh->len));
988 				goto eval_cond_return;
989 			}
990 			break; /* continue */
991 		case ITM_COND_ESCAPESEQ:
992 			/*
993 			 * if escape sequence occur,
994 			 * change ist->default_action and return 2.
995 			 * never return 1.
996 			 */
997 			retval = 0;
998 			eth = ADDR(cond->operand.place);
999 			eh = (itm_escapeseq_hdr_t *)(eth + 1);
1000 			if (NULL == ist->default_action.itm_ptr) {
1001 				ist->default_action = direc->action;
1002 				TRACE_MESSAGE('E',
1003 				    ("escape seq (default action=%6p, "
1004 				    "type=%ld) set\n",
1005 				    direc->action.itm_ptr, ((itm_tbl_hdr_t *)
1006 				    (ADDR(direc->action)))->type));
1007 			}
1008 			retval = 0;
1009 			if (*inbytesleft < eh->len_min) {
1010 				break;
1011 			}
1012 			for (j = 0, d = (itm_data_t *)(eh + 1);
1013 			    j < eth->number;
1014 			    j++, d++) {
1015 				if (*inbytesleft < d->size) {
1016 					continue;
1017 				}
1018 				if (0 == memcmp(*inbuf, DADDR(d), d->size)) {
1019 					TRACE_MESSAGE('E',
1020 					    ("escape seq: discard=%ld chars\n",
1021 					    d->size));
1022 					TRACE_MESSAGE('E',
1023 					    ("escape seq (default "
1024 					    "action=%6p, type=%ld) set\n",
1025 					    direc->action.itm_ptr,
1026 					    ((itm_tbl_hdr_t *)
1027 					    (ADDR(direc->action)))->type));
1028 					ist->default_action = direc->action;
1029 					DISCARD(d->size);
1030 					retval = 2;
1031 					goto eval_cond_return;
1032 				}
1033 			}
1034 			if (0 == retval) {
1035 				goto eval_cond_return;
1036 			}
1037 			break; /* continue */
1038 		case ITM_COND_EXPR:
1039 			retval = eval_expr(ist, cond->operand.place,
1040 			    *inbytesleft, ip, outbytesleft);
1041 			if (0 == retval) {
1042 				goto eval_cond_return;
1043 			} else {
1044 				retval = 1;
1045 			}
1046 			break; /* continue */
1047 		default:
1048 			TRACE_MESSAGE('e', ("eval_cond_tbl:illegal cond=%d\n",
1049 			    cond->type));
1050 			retval = (size_t)-1;
1051 			goto eval_cond_return;
1052 		}
1053 	}
1054 
1055 eval_cond_return:
1056 	return (retval);
1057 }
1058 
1059 /*
1060  * Evaluate operation table
1061  *
1062  */
1063 static size_t
eval_op_tbl(icv_state_t * ist,itm_place_t op_tbl_place,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft)1064 eval_op_tbl(
1065 	icv_state_t	*ist,
1066 	itm_place_t	op_tbl_place,
1067 	const unsigned char	**inbuf,
1068 	size_t		*inbytesleft,
1069 	unsigned char	**outbuf,
1070 	size_t		*outbytesleft)
1071 {
1072 	itm_tbl_hdr_t	*op_hdr;
1073 	itm_op_t	*operation;
1074 	itm_place2_t	op_place;
1075 	size_t		retval;
1076 	long		i;
1077 
1078 	retval = 0;
1079 
1080 #if defined(OP_DEPTH_MAX)
1081 	if (OP_DEPTH_MAX <= ist->op_depth) {
1082 		errno = ELIBBAD;
1083 		TRACE_MESSAGE('e', ("eval_op_tbl:error=%d\n", errno));
1084 		return	(RETVALERR);
1085 	}
1086 	ist->op_depth += 1;
1087 #endif /* OP_DEPTH_MAX */
1088 
1089 	op_hdr = ADDR(op_tbl_place);
1090 	operation = (itm_op_t *)(op_hdr + 1);
1091 
1092 	op_place = op_tbl_place.itm_ptr + (sizeof (itm_tbl_hdr_t));
1093 	for (i = 0; i < op_hdr->number; i++, operation++,
1094 	    op_place += (sizeof (itm_op_t))) {
1095 		TRACE_MESSAGE('O', ("eval_op_tbl: %ld %p\n", i, op_place));
1096 		retval = eval_op(ist, op_place, inbuf, inbytesleft,
1097 		    outbuf, outbytesleft);
1098 		if (((long)(retval)) < 0) {
1099 #if defined(OP_DEPTH_MAX)
1100 			ist->op_depth -= 1;
1101 #endif /* OP_DEPTH_MAX */
1102 			switch (retval) {
1103 			case RETVALERR:
1104 				return	(retval);
1105 			case RETVALRET:
1106 				if (0 == op_hdr->name.itm_ptr) {
1107 					return	(RETVALRET);
1108 				} else {
1109 					return (0);
1110 				}
1111 			}
1112 		}
1113 	}
1114 #if defined(OP_DEPTH_MAX)
1115 	ist->op_depth -= 1;
1116 #endif /* OP_DEPTH_MAX */
1117 	return	(retval);
1118 }
1119 
1120 
1121 /*
1122  * Evaluate single operation
1123  *
1124  */
1125 static size_t
eval_op(icv_state_t * ist,itm_place2_t op_place,const unsigned char ** inbuf,size_t * inbytesleft,unsigned char ** outbuf,size_t * outbytesleft)1126 eval_op(
1127 	icv_state_t		*ist,
1128 	itm_place2_t		op_place,
1129 	const unsigned char	**inbuf,
1130 	size_t			*inbytesleft,
1131 	unsigned char		**outbuf,
1132 	size_t			*outbytesleft)
1133 {
1134 	size_t			retval;
1135 	itm_num_t		num;
1136 	itm_op_t		*operation;
1137 	itm_expr_t		*expr;
1138 	itm_num_t		c;
1139 	itm_num_t		i;
1140 	itm_size_t		z;
1141 	unsigned char		*p;
1142 	itm_expr_t		*expr0;
1143 	itm_tbl_hdr_t		*h;
1144 	itm_type_t		t;
1145 
1146 #define	EVAL_EXPR(n)							\
1147 	(expr0 = ADDR(operation->data.operand[(n)]),			\
1148 		(itm_num_t)((expr0->type == ITM_EXPR_INT) ?		\
1149 		expr0->data.itm_exnum :					\
1150 		((expr0->type == ITM_EXPR_REG) ?			\
1151 		REG(expr0->data.itm_exnum) :				\
1152 		((expr0->type == ITM_EXPR_IN_VECTOR_D) ?		\
1153 		((expr0->data.itm_exnum < 0) ?				\
1154 		(((-1) == expr0->data.itm_exnum) ? *inbytesleft : 0) :	\
1155 		((expr0->data.itm_exnum < *inbytesleft) ?		\
1156 		(*(uchar_t *)(*inbuf + expr0->data.itm_exnum)) : 0)):	\
1157 		eval_expr(ist, operation->data.operand[(n)],		\
1158 		*inbytesleft, *inbuf, *outbytesleft)))))
1159 
1160 	retval = 0;
1161 
1162 	operation = (itm_op_t *)ADDR2(op_place);
1163 
1164 	switch (operation->type) {
1165 	case ITM_OP_EXPR:
1166 		num = eval_expr(ist, operation->data.operand[0],
1167 		    *inbytesleft, *inbuf, *outbytesleft);
1168 		TRACE_MESSAGE('o', ("ITM_OP_EXPR: %ld\n", retval));
1169 		break;
1170 	case ITM_OP_ERROR:
1171 		num = eval_expr(ist, operation->data.operand[0],
1172 		    *inbytesleft, *inbuf, *outbytesleft);
1173 		errno = (int)num;
1174 		TRACE_MESSAGE('o', ("ITM_OP_ERROR: %ld\n", num));
1175 		retval = (size_t)(-1);
1176 		break;
1177 	case ITM_OP_ERROR_D:
1178 		errno = (int)operation->data.itm_opnum;
1179 		TRACE_MESSAGE('o', ("ITM_OP_ERROR_D: %d\n", errno));
1180 		retval = (size_t)(-1);
1181 		break;
1182 	case ITM_OP_OUT:
1183 		expr = ADDR(operation->data.operand[0]);
1184 		if ((*outbytesleft) == 0) {
1185 			errno = E2BIG;
1186 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1187 			return ((size_t)(-1));
1188 		}
1189 		c = eval_expr(ist, operation->data.operand[0],
1190 		    *inbytesleft, *inbuf, *outbytesleft);
1191 		PUT((uchar_t)c);
1192 		retval = *inbytesleft;
1193 		TRACE_MESSAGE('o', ("ITM_OP_OUT: %ld %ld\n", c, *inbytesleft));
1194 		break;
1195 	case ITM_OP_OUT_D:
1196 		expr = ADDR(operation->data.operand[0]);
1197 		if ((*outbytesleft) == 0) {
1198 			errno = E2BIG;
1199 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1200 			return ((size_t)(-1));
1201 		}
1202 		PUT(0xff & (expr->data.itm_exnum));
1203 		break;
1204 	case ITM_OP_OUT_S:
1205 		expr = ADDR(operation->data.operand[0]);
1206 		if ((*outbytesleft) == 0) {
1207 			errno = E2BIG;
1208 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1209 			return ((size_t)(-1));
1210 		}
1211 		z = expr->data.value.size;
1212 		if (*outbytesleft < z) {
1213 			errno = E2BIG;
1214 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1215 			return ((size_t)(-1));
1216 		}
1217 		p = DADDR(&(expr->data.value));
1218 		for (; 0 < z; --z, p++) {
1219 			PUT(*p);
1220 		}
1221 		break;
1222 	case ITM_OP_OUT_R:
1223 		expr = ADDR(operation->data.operand[0]);
1224 		if ((*outbytesleft) == 0) {
1225 			errno = E2BIG;
1226 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1227 			return ((size_t)(-1));
1228 		}
1229 		c = REG(expr->data.itm_exnum);
1230 		PUT((uchar_t)c);
1231 		break;
1232 	case ITM_OP_OUT_INVD:
1233 		expr = ADDR(operation->data.operand[0]);
1234 		if ((*outbytesleft) == 0) {
1235 			errno = E2BIG;
1236 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1237 			return ((size_t)(-1));
1238 		}
1239 		z = (((0 <= expr->data.itm_exnum) &&
1240 		    (expr->data.itm_exnum < *inbytesleft)) ?
1241 		    (*((unsigned char *)(*inbuf + expr->data.itm_exnum))) :
1242 		    (((-1) == expr->data.itm_exnum) ? *inbytesleft : 0));
1243 		PUT((uchar_t)z);
1244 		break;
1245 	case ITM_OP_DISCARD:
1246 #if defined(EVAL_EXPR)
1247 		num = EVAL_EXPR(0);
1248 #else /* !defined(EVAL_EXPR) */
1249 		num = eval_expr(ist, operation->data.operand[0],
1250 		    *inbytesleft, *inbuf, *outbytesleft);
1251 #endif /* defined(EVAL_EXPR) */
1252 		TRACE_MESSAGE('o', ("ITM_OP_DISCARD: %ld\n", num));
1253 #if defined(DISCARD)
1254 		DISCARD((num <= *inbytesleft) ? ((ulong_t)num) : *inbytesleft);
1255 #else /* defined(DISCARD) */
1256 		for (num = ((num <= *inbytesleft) ? num : *inbytesleft);
1257 		    0 < num; --num) {
1258 			GET(c);
1259 		}
1260 #endif /* defined(DISCARD) */
1261 		break;
1262 	case ITM_OP_DISCARD_D:
1263 		num = operation->data.itm_opnum;
1264 		TRACE_MESSAGE('o', ("ITM_OP_DISCARD_D: %ld\n", num));
1265 #if defined(DISCARD)
1266 		DISCARD((num <= *inbytesleft) ? num : *inbytesleft);
1267 #else /* defined(DISCARD) */
1268 		for (num = ((num <= *inbytesleft) ? num : *inbytesleft);
1269 		    0 < num; --num) {
1270 			GET(c);
1271 		}
1272 #endif /* defined(DISCARD) */
1273 		break;
1274 	case ITM_OP_IF:
1275 		c = eval_expr(ist, operation->data.operand[0],
1276 		    *inbytesleft, *inbuf, *outbytesleft);
1277 		TRACE_MESSAGE('o', ("ITM_OP_IF: %ld\n", c));
1278 		if (c) {
1279 			retval = eval_op_tbl(ist, operation->data.operand[1],
1280 			    inbuf, inbytesleft, outbuf, outbytesleft);
1281 		}
1282 		break;
1283 	case ITM_OP_IF_ELSE:
1284 		c = eval_expr(ist, operation->data.operand[0],
1285 		    *inbytesleft, *inbuf, *outbytesleft);
1286 		TRACE_MESSAGE('o', ("ITM_OP_IF_ELSE: %ld\n", c));
1287 		if (c) {
1288 			retval = eval_op_tbl(ist, operation->data.operand[1],
1289 			    inbuf, inbytesleft, outbuf, outbytesleft);
1290 		} else {
1291 			retval = eval_op_tbl(ist, operation->data.operand[2],
1292 			    inbuf, inbytesleft, outbuf, outbytesleft);
1293 		}
1294 		break;
1295 	case ITM_OP_DIRECTION:
1296 		TRACE_MESSAGE('o', ("ITM_OP_DIRECTION: %p\n",
1297 		    operation->data.operand[0].itm_ptr));
1298 		ist->direc = ADDR(operation->data.operand[0]);
1299 		return ((size_t)(-2));
1300 	case ITM_OP_MAP:
1301 		TRACE_MESSAGE('o', ("ITM_OP_MAP: %p\n",
1302 		    operation->data.operand[0].itm_ptr));
1303 		i = 0;
1304 		if (0 != operation->data.operand[1].itm_ptr) {
1305 #if defined(EVAL_EXPR)
1306 			i = EVAL_EXPR(1);
1307 #else /* !defined(EVAL_EXPR) */
1308 			i = eval_expr(ist, operation->data.operand[1],
1309 			    *inbytesleft, *inbuf, *outbytesleft);
1310 #endif /* defined(EVAL_EXPR) */
1311 			(*inbytesleft) -= i;
1312 			(*inbuf) += i;
1313 		}
1314 
1315 		/*
1316 		 * Based on what is the maptype, we call the corresponding
1317 		 * mapping function.
1318 		 */
1319 		h = ADDR(operation->data.operand[0]);
1320 		t = h->type;
1321 		switch (t) {
1322 		case ITM_TBL_MAP_INDEX_FIXED:
1323 		case ITM_TBL_MAP_INDEX_FIXED_1_1:
1324 			retval = map_i_f(h, inbuf, inbytesleft,
1325 			    outbuf, outbytesleft, 1);
1326 			break;
1327 		case ITM_TBL_MAP_HASH:
1328 			retval = map_h_l(h, inbuf, inbytesleft,
1329 			    outbuf, outbytesleft, 1);
1330 			break;
1331 		case ITM_TBL_MAP_DENSE_ENC:
1332 			retval = map_d_e_l(h, inbuf, inbytesleft,
1333 			    outbuf, outbytesleft, 1);
1334 			break;
1335 		case ITM_TBL_MAP_LOOKUP:
1336 			retval = map_l_f(h, inbuf, inbytesleft,
1337 			    outbuf, outbytesleft, 1);
1338 			break;
1339 		default:
1340 			/*
1341 			 * This should not be possible, but in case we
1342 			 * have an incorrect maptype, don't fall back to
1343 			 * map_i_f(). Instead, because it is an error, return
1344 			 * an error. See CR 6622765.
1345 			 */
1346 			errno = EBADF;
1347 			TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1348 			retval = (size_t)-1;
1349 			break;
1350 		}
1351 
1352 		if ((size_t)(-1) == retval) {
1353 			(*outbytesleft) += i;
1354 			(*outbuf) -= i;
1355 		}
1356 		break;
1357 	case ITM_OP_OPERATION:
1358 		TRACE_MESSAGE('o', ("ITM_OP_OPERATION: %p\n",
1359 		    operation->data.operand[0].itm_ptr));
1360 		retval = eval_op_tbl(ist, operation->data.operand[0],
1361 		    inbuf, inbytesleft, outbuf, outbytesleft);
1362 
1363 		break;
1364 	case ITM_OP_INIT:
1365 		TRACE_MESSAGE('o', ("ITM_OP_INIT: %p\n",
1366 		    ist->itm_hdr->op_init_tbl));
1367 		if (0 != ist->itm_hdr->op_init_tbl.itm_ptr) {
1368 			retval = eval_op_tbl(ist, ist->itm_hdr->op_init_tbl,
1369 			    inbuf, inbytesleft, outbuf, outbytesleft);
1370 		} else {
1371 			op_init_default(ist);
1372 			retval = (size_t)-2;
1373 		}
1374 		break;
1375 	case ITM_OP_RESET:
1376 		TRACE_MESSAGE('o', ("ITM_OP_RESET: %p\n",
1377 		    ist->itm_hdr->op_reset_tbl));
1378 		if (0 != ist->itm_hdr->op_reset_tbl.itm_ptr) {
1379 			retval = eval_op_tbl(ist, ist->itm_hdr->op_reset_tbl,
1380 			    inbuf, inbytesleft, outbuf, outbytesleft);
1381 		} else {
1382 			op_reset_default(ist);
1383 			retval = (size_t)-2;
1384 		}
1385 		break;
1386 	case ITM_OP_BREAK:
1387 		TRACE_MESSAGE('o', ("ITM_OP_BREAK\n"));
1388 		return	(RETVALBRK);
1389 	case ITM_OP_RETURN:
1390 		TRACE_MESSAGE('o', ("ITM_OP_RETURN\n"));
1391 		return	(RETVALRET);
1392 	case ITM_OP_PRINTCHR:
1393 		c = eval_expr(ist, operation->data.operand[0], *inbytesleft,
1394 		    *inbuf, *outbytesleft);
1395 		(void) fputc((uchar_t)c, stderr);
1396 		TRACE_MESSAGE('o', ("ITM_OP_PRINTCHR: %ld %ld\n",
1397 		    c, *inbytesleft));
1398 		break;
1399 	case ITM_OP_PRINTHD:
1400 		c = eval_expr(ist, operation->data.operand[0], *inbytesleft,
1401 		    *inbuf, *outbytesleft);
1402 		(void) fprintf(stderr, "%lx", c);
1403 		TRACE_MESSAGE('o', ("ITM_OP_PRINTHD: %ld %ld\n",
1404 		    c, *inbytesleft));
1405 		break;
1406 	case ITM_OP_PRINTINT:
1407 		c = eval_expr(ist, operation->data.operand[0], *inbytesleft,
1408 		    *inbuf, *outbytesleft);
1409 		(void) fprintf(stderr, "%ld", c);
1410 		TRACE_MESSAGE('o', ("ITM_OP_PRINTINT: %ld %ld\n",
1411 		    c, *inbytesleft));
1412 		break;
1413 	default: /* never */
1414 		errno = ELIBBAD;
1415 		TRACE_MESSAGE('e', ("eval_op:error=%d\n", errno));
1416 		return (size_t)(-1);
1417 	}
1418 	return	(retval);
1419 
1420 #undef EVAL_EXPR
1421 }
1422 
1423 
1424 /*
1425  * Evaluate expression
1426  */
1427 static itm_num_t
eval_expr(icv_state_t * ist,itm_place_t expr_place,size_t inbytesleft,const unsigned char * inbuf,size_t outbytesleft)1428 eval_expr(
1429 	icv_state_t		*ist,
1430 	itm_place_t		expr_place,
1431 	size_t			inbytesleft,
1432 	const unsigned char	*inbuf,
1433 	size_t			outbytesleft)
1434 {
1435 	itm_expr_t		*expr;
1436 	itm_expr_t		*expr_op;
1437 	itm_num_t		num;
1438 	unsigned char		*p;
1439 	long			i;
1440 	itm_expr_t		*expr0;
1441 	itm_num_t		num00;
1442 	itm_num_t		num01;
1443 
1444 #define	EVAL_EXPR_E(n) (eval_expr(ist, expr->data.operand[(n)],		\
1445 	inbytesleft, inbuf, outbytesleft))
1446 #define	EVAL_EXPR_D(n)	((itm_num_t)(expr->data.operand[(n)].itm_ptr))
1447 #define	EVAL_EXPR_R(n)	(REG((itm_num_t)(expr->data.operand[(n)].itm_ptr)))
1448 #define	EVAL_EXPR_INVD(n)						\
1449 	((num0 ## n) = ((itm_num_t)(expr->data.operand[(n)].itm_ptr)),	\
1450 		((num0 ## n) < 0) ?					\
1451 		(((-1) == (num0 ## n)) ? inbytesleft : 0) :		\
1452 		(((num0 ## n) < inbytesleft) ?				\
1453 		(*(unsigned char *)(inbuf + (num0 ## n))) : 0))
1454 #define	EVAL_EXPR(n)							\
1455 	(expr0 = ADDR(expr->data.operand[(n)]),				\
1456 		(itm_num_t)((expr0->type == ITM_EXPR_INT) ?		\
1457 		expr0->data.itm_exnum :					\
1458 		((expr0->type == ITM_EXPR_REG) ?			\
1459 		REG(expr0->data.itm_exnum) :				\
1460 		((expr0->type == ITM_EXPR_IN_VECTOR_D) ?		\
1461 		((expr0->data.itm_exnum < 0) ?				\
1462 		(((-1) == expr0->data.itm_exnum) ? inbytesleft : 0) :	\
1463 		((expr0->data.itm_exnum < inbytesleft) ?		\
1464 		(*(uchar_t *)(inbuf + expr0->data.itm_exnum)) : 0)) :	\
1465 		eval_expr(ist, expr->data.operand[(n)],			\
1466 		inbytesleft, inbuf, outbytesleft)))))
1467 
1468 #define	EVAL_OP_BIN_PROTO(op, name, name0, name1)			\
1469 	case ITM_EXPR_##name##_##name0##_##name1:			\
1470 		return (EVAL_EXPR_##name0(0) op EVAL_EXPR_##name1(1));
1471 
1472 #define	EVAL_OP_BIN1(op, name)					\
1473 		EVAL_OP_BIN_PROTO(op, name, E, E)		\
1474 		EVAL_OP_BIN_PROTO(op, name, E, D)		\
1475 		EVAL_OP_BIN_PROTO(op, name, E, R)		\
1476 		EVAL_OP_BIN_PROTO(op, name, E, INVD)
1477 
1478 #define	EVAL_OP_BIN2(op, name)					\
1479 		EVAL_OP_BIN_PROTO(op, name, D, E)		\
1480 		EVAL_OP_BIN_PROTO(op, name, D, D)		\
1481 		EVAL_OP_BIN_PROTO(op, name, D, R)		\
1482 		EVAL_OP_BIN_PROTO(op, name, D, INVD)
1483 
1484 #define	EVAL_OP_BIN3(op, name)					\
1485 		EVAL_OP_BIN_PROTO(op, name, R, E)		\
1486 		EVAL_OP_BIN_PROTO(op, name, R, D)		\
1487 		EVAL_OP_BIN_PROTO(op, name, R, R)		\
1488 		EVAL_OP_BIN_PROTO(op, name, R, INVD)
1489 
1490 #define	EVAL_OP_BIN4(op, name)					\
1491 		EVAL_OP_BIN_PROTO(op, name, INVD, E)		\
1492 		EVAL_OP_BIN_PROTO(op, name, INVD, D)		\
1493 		EVAL_OP_BIN_PROTO(op, name, INVD, R)		\
1494 		EVAL_OP_BIN_PROTO(op, name, INVD, INVD)
1495 
1496 #define	EVAL_OP_BIN_PROTECT_PROTO(op, name, name0, name1)	\
1497 	case ITM_EXPR_##name##_##name0##_##name1:		\
1498 		num = EVAL_EXPR_##name1(1);			\
1499 		if (0 != num) {					\
1500 			return (EVAL_EXPR_##name0(0) op num);	\
1501 		} else {					\
1502 			return (0);				\
1503 		}
1504 
1505 #define	EVAL_OP_BIN_PROTECT1(op, name)				\
1506 		EVAL_OP_BIN_PROTECT_PROTO(op, name, E, E)	\
1507 		EVAL_OP_BIN_PROTECT_PROTO(op, name, E, D)	\
1508 		EVAL_OP_BIN_PROTECT_PROTO(op, name, E, R)	\
1509 		EVAL_OP_BIN_PROTECT_PROTO(op, name, E, INVD)
1510 
1511 #define	EVAL_OP_BIN_PROTECT2(op, name)				\
1512 		EVAL_OP_BIN_PROTECT_PROTO(op, name, D, E)	\
1513 		EVAL_OP_BIN_PROTECT_PROTO(op, name, D, D)	\
1514 		EVAL_OP_BIN_PROTECT_PROTO(op, name, D, R)	\
1515 		EVAL_OP_BIN_PROTECT_PROTO(op, name, D, INVD)
1516 
1517 #define	EVAL_OP_BIN_PROTECT3(op, name)				\
1518 		EVAL_OP_BIN_PROTECT_PROTO(op, name, R, E)	\
1519 		EVAL_OP_BIN_PROTECT_PROTO(op, name, R, D)	\
1520 		EVAL_OP_BIN_PROTECT_PROTO(op, name, R, R)	\
1521 		EVAL_OP_BIN_PROTECT_PROTO(op, name, R, INVD)
1522 
1523 #define	EVAL_OP_BIN_PROTECT4(op, name)				\
1524 		EVAL_OP_BIN_PROTECT_PROTO(op, name, INVD, E)	\
1525 		EVAL_OP_BIN_PROTECT_PROTO(op, name, INVD, D)	\
1526 		EVAL_OP_BIN_PROTECT_PROTO(op, name, INVD, R)	\
1527 		EVAL_OP_BIN_PROTECT_PROTO(op, name, INVD, INVD)
1528 
1529 	expr = ADDR(expr_place);
1530 
1531 	switch (expr->type) {
1532 	case ITM_EXPR_NONE:		/* not used */
1533 		return (0);
1534 	case ITM_EXPR_NOP:		/* not used */
1535 		return (0);
1536 	case ITM_EXPR_NAME:		/* not used */
1537 		return (0);
1538 	case ITM_EXPR_INT:		/* integer */
1539 		return (expr->data.itm_exnum);
1540 	case ITM_EXPR_SEQ:		/* byte sequence */
1541 		if ((sizeof (itm_place_t)) < expr->data.value.size) {
1542 			p = (unsigned char *)ADDR(expr->data.value.place);
1543 		} else {
1544 			p = (unsigned char *)&(expr->data.value.place);
1545 		}
1546 		for (i = 0, num = 0; i < expr->data.value.size; i++, p++) {
1547 			num = ((num << 8) | *p);
1548 		}
1549 		return	(num);
1550 	case ITM_EXPR_REG:		/* register */
1551 		return (REG(expr->data.itm_exnum));
1552 	case ITM_EXPR_IN_VECTOR:	/* in[expr] */
1553 		num = EVAL_EXPR(0);
1554 		if ((0 <= num) && (num < inbytesleft)) {
1555 			return (*((unsigned char *)(inbuf + num)));
1556 		} else if ((-1) == num) {
1557 			return	(inbytesleft);
1558 		} else {
1559 			return (0);
1560 		}
1561 	case ITM_EXPR_IN_VECTOR_D:	/* in[DECIMAL] */
1562 		num = expr->data.itm_exnum;
1563 		if ((0 <= num) && (num < inbytesleft)) {
1564 			return (*((unsigned char *)(inbuf + num)));
1565 		} else if ((-1) == num) {
1566 			return	(inbytesleft);
1567 		} else {
1568 			return (0);
1569 		}
1570 	case ITM_EXPR_OUT:		/* out */
1571 		return	(outbytesleft);
1572 	case ITM_EXPR_TRUE:		/* true */
1573 		return (1);
1574 	case ITM_EXPR_FALSE:		/* false */
1575 		return (0);
1576 	case ITM_EXPR_UMINUS:		/* unary minus */
1577 		return ((-1) * EVAL_EXPR(0));
1578 #define	PLUS_FOR_CSTYLE_CLEAN +
1579 #define	MINUS_FOR_CSTYLE_CLEAN -
1580 #define	MUL_FOR_CSTYLE_CLEAN *
1581 #define	DIV_FOR_CSTYLE_CLEAN /
1582 #define	MOD_FOR_CSTYLE_CLEAN %
1583 #define	SHIFT_L_FOR_CSTYLE_CLEAN <<
1584 #define	SHIFT_R_FOR_CSTYLE_CLEAN >>
1585 #define	OR_FOR_CSTYLE_CLEAN |
1586 #define	XOR_FOR_CSTYLE_CLEAN ^
1587 #define	AND_FOR_CSTYLE_CLEAN &
1588 #define	EQ_FOR_CSTYLE_CLEAN ==
1589 #define	NE_FOR_CSTYLE_CLEAN !=
1590 #define	GT_FOR_CSTYLE_CLEAN >
1591 #define	GE_FOR_CSTYLE_CLEAN >=
1592 #define	LT_FOR_CSTYLE_CLEAN <
1593 #define	LE_FOR_CSTYLE_CLEAN <=
1594 	EVAL_OP_BIN1(PLUS_FOR_CSTYLE_CLEAN, PLUS)	/* A + B */
1595 	EVAL_OP_BIN2(PLUS_FOR_CSTYLE_CLEAN, PLUS)	/* A + B */
1596 	EVAL_OP_BIN3(PLUS_FOR_CSTYLE_CLEAN, PLUS)	/* A + B */
1597 	EVAL_OP_BIN4(PLUS_FOR_CSTYLE_CLEAN, PLUS)	/* A + B */
1598 
1599 	EVAL_OP_BIN1(MINUS_FOR_CSTYLE_CLEAN, MINUS)	/* A - B */
1600 	EVAL_OP_BIN2(MINUS_FOR_CSTYLE_CLEAN, MINUS)	/* A - B */
1601 	EVAL_OP_BIN3(MINUS_FOR_CSTYLE_CLEAN, MINUS)	/* A - B */
1602 	EVAL_OP_BIN4(MINUS_FOR_CSTYLE_CLEAN, MINUS)	/* A - B */
1603 
1604 	EVAL_OP_BIN1(MUL_FOR_CSTYLE_CLEAN, MUL)		/* A * B */
1605 	EVAL_OP_BIN2(MUL_FOR_CSTYLE_CLEAN, MUL)		/* A * B */
1606 	EVAL_OP_BIN3(MUL_FOR_CSTYLE_CLEAN, MUL)		/* A * B */
1607 	EVAL_OP_BIN4(MUL_FOR_CSTYLE_CLEAN, MUL)		/* A * B */
1608 
1609 	EVAL_OP_BIN_PROTECT1(DIV_FOR_CSTYLE_CLEAN, DIV)	/* A / B */
1610 	EVAL_OP_BIN_PROTECT2(DIV_FOR_CSTYLE_CLEAN, DIV)	/* A / B */
1611 	EVAL_OP_BIN_PROTECT3(DIV_FOR_CSTYLE_CLEAN, DIV)	/* A / B */
1612 	EVAL_OP_BIN_PROTECT4(DIV_FOR_CSTYLE_CLEAN, DIV)	/* A / B */
1613 
1614 	EVAL_OP_BIN_PROTECT1(MOD_FOR_CSTYLE_CLEAN, MOD)	/* A % B */
1615 	EVAL_OP_BIN_PROTECT2(MOD_FOR_CSTYLE_CLEAN, MOD)	/* A % B */
1616 	EVAL_OP_BIN_PROTECT3(MOD_FOR_CSTYLE_CLEAN, MOD)	/* A % B */
1617 	EVAL_OP_BIN_PROTECT4(MOD_FOR_CSTYLE_CLEAN, MOD)	/* A % B */
1618 
1619 	EVAL_OP_BIN1(SHIFT_L_FOR_CSTYLE_CLEAN, SHIFT_L)	/* A << B */
1620 	EVAL_OP_BIN2(SHIFT_L_FOR_CSTYLE_CLEAN, SHIFT_L)	/* A << B */
1621 	EVAL_OP_BIN3(SHIFT_L_FOR_CSTYLE_CLEAN, SHIFT_L)	/* A << B */
1622 	EVAL_OP_BIN4(SHIFT_L_FOR_CSTYLE_CLEAN, SHIFT_L)	/* A << B */
1623 
1624 	EVAL_OP_BIN1(SHIFT_R_FOR_CSTYLE_CLEAN, SHIFT_R)	/* A >> B */
1625 	EVAL_OP_BIN2(SHIFT_R_FOR_CSTYLE_CLEAN, SHIFT_R)	/* A >> B */
1626 	EVAL_OP_BIN3(SHIFT_R_FOR_CSTYLE_CLEAN, SHIFT_R)	/* A >> B */
1627 	EVAL_OP_BIN4(SHIFT_R_FOR_CSTYLE_CLEAN, SHIFT_R)	/* A >> B */
1628 
1629 	EVAL_OP_BIN1(OR_FOR_CSTYLE_CLEAN, OR)		/* A |	B */
1630 	EVAL_OP_BIN2(OR_FOR_CSTYLE_CLEAN, OR)		/* A |	B */
1631 	EVAL_OP_BIN3(OR_FOR_CSTYLE_CLEAN, OR)		/* A |	B */
1632 	EVAL_OP_BIN4(OR_FOR_CSTYLE_CLEAN, OR)		/* A |	B */
1633 
1634 	EVAL_OP_BIN1(XOR_FOR_CSTYLE_CLEAN, XOR)		/* A ^	B */
1635 	EVAL_OP_BIN2(XOR_FOR_CSTYLE_CLEAN, XOR)		/* A ^	B */
1636 	EVAL_OP_BIN3(XOR_FOR_CSTYLE_CLEAN, XOR)		/* A ^	B */
1637 	EVAL_OP_BIN4(XOR_FOR_CSTYLE_CLEAN, XOR)		/* A ^	B */
1638 
1639 	EVAL_OP_BIN1(AND_FOR_CSTYLE_CLEAN, AND)		/* A &	B */
1640 	EVAL_OP_BIN2(AND_FOR_CSTYLE_CLEAN, AND)		/* A &	B */
1641 	EVAL_OP_BIN3(AND_FOR_CSTYLE_CLEAN, AND)		/* A &	B */
1642 	EVAL_OP_BIN4(AND_FOR_CSTYLE_CLEAN, AND)		/* A &	B */
1643 
1644 	EVAL_OP_BIN1(EQ_FOR_CSTYLE_CLEAN, EQ)		/* A == B */
1645 	EVAL_OP_BIN2(EQ_FOR_CSTYLE_CLEAN, EQ)		/* A == B */
1646 	EVAL_OP_BIN3(EQ_FOR_CSTYLE_CLEAN, EQ)		/* A == B */
1647 	EVAL_OP_BIN4(EQ_FOR_CSTYLE_CLEAN, EQ)		/* A == B */
1648 
1649 	EVAL_OP_BIN1(NE_FOR_CSTYLE_CLEAN, NE)		/* A != B */
1650 	EVAL_OP_BIN2(NE_FOR_CSTYLE_CLEAN, NE)		/* A != B */
1651 	EVAL_OP_BIN3(NE_FOR_CSTYLE_CLEAN, NE)		/* A != B */
1652 	EVAL_OP_BIN4(NE_FOR_CSTYLE_CLEAN, NE)		/* A != B */
1653 
1654 	EVAL_OP_BIN1(GT_FOR_CSTYLE_CLEAN, GT)		/* A >	B */
1655 	EVAL_OP_BIN2(GT_FOR_CSTYLE_CLEAN, GT)		/* A >	B */
1656 	EVAL_OP_BIN3(GT_FOR_CSTYLE_CLEAN, GT)		/* A >	B */
1657 	EVAL_OP_BIN4(GT_FOR_CSTYLE_CLEAN, GT)		/* A >	B */
1658 
1659 	EVAL_OP_BIN1(GE_FOR_CSTYLE_CLEAN, GE)		/* A >= B */
1660 	EVAL_OP_BIN2(GE_FOR_CSTYLE_CLEAN, GE)		/* A >= B */
1661 	EVAL_OP_BIN3(GE_FOR_CSTYLE_CLEAN, GE)		/* A >= B */
1662 	EVAL_OP_BIN4(GE_FOR_CSTYLE_CLEAN, GE)		/* A >= B */
1663 
1664 	EVAL_OP_BIN1(LT_FOR_CSTYLE_CLEAN, LT)		/* A <	B */
1665 	EVAL_OP_BIN2(LT_FOR_CSTYLE_CLEAN, LT)		/* A <	B */
1666 	EVAL_OP_BIN3(LT_FOR_CSTYLE_CLEAN, LT)		/* A <	B */
1667 	EVAL_OP_BIN4(LT_FOR_CSTYLE_CLEAN, LT)		/* A <	B */
1668 
1669 	EVAL_OP_BIN1(LE_FOR_CSTYLE_CLEAN, LE)		/* A <= B */
1670 	EVAL_OP_BIN2(LE_FOR_CSTYLE_CLEAN, LE)		/* A <= B */
1671 	EVAL_OP_BIN3(LE_FOR_CSTYLE_CLEAN, LE)		/* A <= B */
1672 	EVAL_OP_BIN4(LE_FOR_CSTYLE_CLEAN, LE)		/* A <= B */
1673 
1674 	case ITM_EXPR_NOT:		/*   !A	  */
1675 		return (!(EVAL_EXPR(0)));
1676 	case ITM_EXPR_NEG:		/*   ~A	  */
1677 		return (~(EVAL_EXPR(0)));
1678 	case ITM_EXPR_LOR:		/* A || B */
1679 		if (0 != (num = EVAL_EXPR(0)))
1680 			return	(num);
1681 		if (0 != (num = EVAL_EXPR(1)))
1682 			return	(num);
1683 		return (0);
1684 	case ITM_EXPR_LAND:		/* A && B */
1685 		if (0 == EVAL_EXPR(0))
1686 			return (0);
1687 		if (0 == (num = EVAL_EXPR(1)))
1688 			return (0);
1689 		return	(num);
1690 	case ITM_EXPR_ASSIGN:		/* A  = B */
1691 		num = EVAL_EXPR(1);
1692 		if (expr->data.operand[0].itm_ptr < ist->itm_hdr->reg_num) {
1693 			return (*(ist->regs + expr->data.operand[0].itm_ptr)
1694 			    = num);
1695 		} else {
1696 			return (0);
1697 		}
1698 	case ITM_EXPR_IN_EQ:		/* in == A */
1699 		expr_op = ADDR(expr->data.operand[0]);
1700 		switch (expr_op->type) {
1701 		case ITM_EXPR_SEQ:
1702 			if (inbytesleft < expr_op->data.value.size) {
1703 				return (0);
1704 			}
1705 			p = DADDR(&(expr_op->data.value));
1706 			for (i = 0; i < expr_op->data.value.size; i++, p++) {
1707 				if (*p != *(inbuf + i)) {
1708 					return (0);
1709 				}
1710 			}
1711 			return (1);
1712 		default:
1713 			num = EVAL_EXPR(0);
1714 			return (num == *((unsigned char *)inbuf));
1715 		}
1716 	default:
1717 		break;
1718 	}
1719 
1720 	return (0);
1721 
1722 #undef EVAL_EXPR_E
1723 #undef EVAL_EXPR_D
1724 #undef EVAL_EXPR_R
1725 #undef EVAL_EXPR_INVD
1726 #undef EVAL_EXPR
1727 }
1728 
1729 
1730 /*
1731  * maintain ITM reference information
1732  */
1733 static void
itm_ref_free(int fd,void * ptr0,void * ptr1,void * ptr2,size_t len)1734 itm_ref_free(int fd, void *ptr0, void *ptr1, void *ptr2, size_t len)
1735 {
1736 	int	r;
1737 	r = errno;
1738 	if (0 <= fd) {
1739 		(void) close(fd);
1740 	}
1741 	free(ptr0);
1742 	free(ptr1);
1743 	if (0 < len) {
1744 		(void) munmap(ptr2, len);
1745 	}
1746 	errno = r;
1747 }
1748 
1749 static itm_ref_t *
itm_ref_inc(const char * itm)1750 itm_ref_inc(const char		*itm)
1751 {
1752 	itm_ref_t	*ref;
1753 	itm_hdr_t	*hdr;
1754 	struct stat	st;
1755 	int		fd;
1756 
1757 	fd = open(itm, O_RDONLY, 0);
1758 	if (fd == -1) {
1759 		itm_ref_free(-1, NULL, NULL, NULL, 0);
1760 		return	(NULL);
1761 	}
1762 
1763 	if (fstat(fd, &st) == -1) {
1764 		itm_ref_free(fd, NULL, NULL, NULL, 0);
1765 		return	(NULL);
1766 	}
1767 	hdr = (void *) mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
1768 	if (MAP_FAILED == hdr) {
1769 		itm_ref_free(fd, NULL, NULL, NULL, 0);
1770 		return	(NULL);
1771 	}
1772 
1773 	(void) close(fd);
1774 
1775 	ref = malloc(sizeof (itm_ref_t));
1776 	if (NULL == ref) {
1777 		itm_ref_free(-1, NULL, NULL, hdr, st.st_size);
1778 		return	(NULL);
1779 	}
1780 	ref->name = malloc(strlen(itm) + 1);
1781 	if (NULL == ref->name) {
1782 		itm_ref_free(-1, ref, NULL, hdr, st.st_size);
1783 		return	(NULL);
1784 	}
1785 	(void) strcpy(ref->name, itm);
1786 	ref->hdr = hdr;
1787 	ref->len = st.st_size;
1788 
1789 	if ((hdr->ident[0] != ITM_IDENT_0) ||
1790 	    (hdr->ident[1] != ITM_IDENT_1) ||
1791 	    (hdr->ident[2] != ITM_IDENT_2) ||
1792 	    (hdr->ident[3] != ITM_IDENT_3) ||
1793 	    (hdr->spec[0] != ITM_SPEC_0) ||
1794 	    (hdr->spec[1] != ITM_SPEC_1) ||
1795 	    (hdr->spec[2] != ITM_SPEC_2) ||
1796 #if defined(_LITTLE_ENDIAN)
1797 #if defined(_LP64)
1798 	    ((hdr->spec[3] != ITM_SPEC_3_32_LITTLE_ENDIAN) &&
1799 	    (hdr->spec[3] != ITM_SPEC_3_64_LITTLE_ENDIAN)) ||
1800 #else
1801 	    (hdr->spec[3] != ITM_SPEC_3_32_LITTLE_ENDIAN) ||
1802 #endif
1803 #else
1804 #if defined(_LP64)
1805 	    ((hdr->spec[3] != ITM_SPEC_3_32_BIG_ENDIAN) &&
1806 	    (hdr->spec[3] != ITM_SPEC_3_64_BIG_ENDIAN)) ||
1807 #else
1808 	    (hdr->spec[3] != ITM_SPEC_3_32_BIG_ENDIAN) ||
1809 #endif
1810 #endif
1811 	    (hdr->version[0] != ITM_VER_0) ||
1812 	    (hdr->version[1] != ITM_VER_1) ||
1813 	    (hdr->version[2] != ITM_VER_2) ||
1814 	    (hdr->version[3] != ITM_VER_3) ||
1815 	    (((size_t)(hdr->itm_size.itm_ptr)) != st.st_size)) {
1816 		itm_ref_free(-1, ref, ref->name, ref->hdr, ref->len);
1817 		errno = ELIBBAD;
1818 		TRACE_MESSAGE('e', ("itm_ref_inc:error=%d\n", errno));
1819 		return	(NULL);
1820 	}
1821 
1822 	return	(ref);
1823 }
1824 
1825 
1826 static void
itm_ref_dec(itm_ref_t * ref)1827 itm_ref_dec(itm_ref_t	*ref)
1828 {
1829 	(void) munmap((char *)(ref->hdr), ref->len);
1830 	free(ref->name);
1831 	free(ref);
1832 }
1833 
1834 
1835 static void
op_init_default(icv_state_t * ist)1836 op_init_default(icv_state_t	*ist)
1837 {
1838 	ist->direc = ADDR(ist->itm_hdr->direc_init_tbl);
1839 	regs_init(ist);
1840 }
1841 
1842 
1843 static void
op_reset_default(icv_state_t * ist)1844 op_reset_default(icv_state_t	*ist)
1845 {
1846 	ist->direc = ADDR(ist->itm_hdr->direc_init_tbl);
1847 	regs_init(ist);
1848 }
1849 
1850 
1851 static void
regs_init(icv_state_t * ist)1852 regs_init(icv_state_t	*ist)
1853 {
1854 	if (0 < ist->itm_hdr->reg_num) {
1855 		(void) memset(ist->regs, 0,
1856 		    (sizeof (itm_num_t)) * ist->itm_hdr->reg_num);
1857 	}
1858 }
1859 
1860 
1861 #if defined(DEBUG)
1862 static void
trace_init()1863 trace_init()
1864 {
1865 	char	*env_val;
1866 	char	*p;
1867 
1868 	env_val = getenv("ITM_INT_TRACE");
1869 	if (NULL == env_val)
1870 		return;
1871 
1872 	for (p = env_val; *p; p++) {
1873 		trace_option[(*p) & 0x007f] = 1;
1874 	}
1875 }
1876 
1877 static void
trace_message(char * format,...)1878 trace_message(char	*format, ...)
1879 {
1880 	va_list	ap;
1881 
1882 	va_start(ap, format);
1883 
1884 	(void) vfprintf(stderr, format, ap);
1885 
1886 	va_end(ap);
1887 }
1888 #endif /* DEBUG */
1889