1 /****************************************************************************
2  * ip_conntrack_helper_h323_asn1.c - BER and PER decoding library for H.323
3  * 			      	     conntrack/NAT module.
4  *
5  * Copyright (c) 2006 by Jing Min Zhao <zhaojingmin@users.sourceforge.net>
6  *
7  * This source code is licensed under General Public License version 2.
8  *
9  * See ip_conntrack_helper_h323_asn1.h for details.
10  *
11  ****************************************************************************/
12 
13 #ifdef __KERNEL__
14 #include <linux/kernel.h>
15 #else
16 #include <stdio.h>
17 #endif
18 #include <linux/netfilter/nf_conntrack_h323_asn1.h>
19 
20 /* Trace Flag */
21 #ifndef H323_TRACE
22 #define H323_TRACE 0
23 #endif
24 
25 #if H323_TRACE
26 #define TAB_SIZE 4
27 #define IFTHEN(cond, act) if(cond){act;}
28 #ifdef __KERNEL__
29 #define PRINT printk
30 #else
31 #define PRINT printf
32 #endif
33 #define FNAME(name) name,
34 #else
35 #define IFTHEN(cond, act)
36 #define PRINT(fmt, args...)
37 #define FNAME(name)
38 #endif
39 
40 /* ASN.1 Types */
41 #define NUL 0
42 #define BOOL 1
43 #define OID 2
44 #define INT 3
45 #define ENUM 4
46 #define BITSTR 5
47 #define NUMSTR 6
48 #define NUMDGT 6
49 #define TBCDSTR 6
50 #define OCTSTR 7
51 #define PRTSTR 7
52 #define IA5STR 7
53 #define GENSTR 7
54 #define BMPSTR 8
55 #define SEQ 9
56 #define SET 9
57 #define SEQOF 10
58 #define SETOF 10
59 #define CHOICE 11
60 
61 /* Constraint Types */
62 #define FIXD 0
63 /* #define BITS 1-8 */
64 #define BYTE 9
65 #define WORD 10
66 #define CONS 11
67 #define SEMI 12
68 #define UNCO 13
69 
70 /* ASN.1 Type Attributes */
71 #define SKIP 0
72 #define STOP 1
73 #define DECODE 2
74 #define EXT 4
75 #define OPEN 8
76 #define OPT 16
77 
78 
79 /* ASN.1 Field Structure */
80 typedef struct field_t {
81 #if H323_TRACE
82 	char *name;
83 #endif
84 	unsigned char type;
85 	unsigned char sz;
86 	unsigned char lb;
87 	unsigned char ub;
88 	unsigned short attr;
89 	unsigned short offset;
90 	const struct field_t *fields;
91 } field_t;
92 
93 /* Bit Stream */
94 typedef struct {
95 	unsigned char *buf;
96 	unsigned char *beg;
97 	unsigned char *end;
98 	unsigned char *cur;
99 	unsigned int bit;
100 } bitstr_t;
101 
102 /* Tool Functions */
103 #define INC_BIT(bs) if((++(bs)->bit)>7){(bs)->cur++;(bs)->bit=0;}
104 #define INC_BITS(bs,b) if(((bs)->bit+=(b))>7){(bs)->cur+=(bs)->bit>>3;(bs)->bit&=7;}
105 #define BYTE_ALIGN(bs) if((bs)->bit){(bs)->cur++;(bs)->bit=0;}
106 #define CHECK_BOUND(bs,n) if((bs)->cur+(n)>(bs)->end)return(H323_ERROR_BOUND)
107 static unsigned int get_len(bitstr_t *bs);
108 static unsigned int get_bit(bitstr_t *bs);
109 static unsigned int get_bits(bitstr_t *bs, unsigned int b);
110 static unsigned int get_bitmap(bitstr_t *bs, unsigned int b);
111 static unsigned int get_uint(bitstr_t *bs, int b);
112 
113 /* Decoder Functions */
114 static int decode_nul(bitstr_t *bs, const struct field_t *f, char *base, int level);
115 static int decode_bool(bitstr_t *bs, const struct field_t *f, char *base, int level);
116 static int decode_oid(bitstr_t *bs, const struct field_t *f, char *base, int level);
117 static int decode_int(bitstr_t *bs, const struct field_t *f, char *base, int level);
118 static int decode_enum(bitstr_t *bs, const struct field_t *f, char *base, int level);
119 static int decode_bitstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
120 static int decode_numstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
121 static int decode_octstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
122 static int decode_bmpstr(bitstr_t *bs, const struct field_t *f, char *base, int level);
123 static int decode_seq(bitstr_t *bs, const struct field_t *f, char *base, int level);
124 static int decode_seqof(bitstr_t *bs, const struct field_t *f, char *base, int level);
125 static int decode_choice(bitstr_t *bs, const struct field_t *f, char *base, int level);
126 
127 /* Decoder Functions Vector */
128 typedef int (*decoder_t)(bitstr_t *, const struct field_t *, char *, int);
129 static const decoder_t Decoders[] = {
130 	decode_nul,
131 	decode_bool,
132 	decode_oid,
133 	decode_int,
134 	decode_enum,
135 	decode_bitstr,
136 	decode_numstr,
137 	decode_octstr,
138 	decode_bmpstr,
139 	decode_seq,
140 	decode_seqof,
141 	decode_choice,
142 };
143 
144 /****************************************************************************
145  * H.323 Types
146  ****************************************************************************/
147 #include "nf_conntrack_h323_types.c"
148 
149 /****************************************************************************
150  * Functions
151  ****************************************************************************/
152 /* Assume bs is aligned && v < 16384 */
153 static unsigned int get_len(bitstr_t *bs)
154 {
155 	unsigned int v;
156 
157 	v = *bs->cur++;
158 
159 	if (v & 0x80) {
160 		v &= 0x3f;
161 		v <<= 8;
162 		v += *bs->cur++;
163 	}
164 
165 	return v;
166 }
167 
168 /****************************************************************************/
169 static unsigned int get_bit(bitstr_t *bs)
170 {
171 	unsigned int b = (*bs->cur) & (0x80 >> bs->bit);
172 
173 	INC_BIT(bs);
174 
175 	return b;
176 }
177 
178 /****************************************************************************/
179 /* Assume b <= 8 */
180 static unsigned int get_bits(bitstr_t *bs, unsigned int b)
181 {
182 	unsigned int v, l;
183 
184 	v = (*bs->cur) & (0xffU >> bs->bit);
185 	l = b + bs->bit;
186 
187 	if (l < 8) {
188 		v >>= 8 - l;
189 		bs->bit = l;
190 	} else if (l == 8) {
191 		bs->cur++;
192 		bs->bit = 0;
193 	} else {		/* l > 8 */
194 
195 		v <<= 8;
196 		v += *(++bs->cur);
197 		v >>= 16 - l;
198 		bs->bit = l - 8;
199 	}
200 
201 	return v;
202 }
203 
204 /****************************************************************************/
205 /* Assume b <= 32 */
206 static unsigned int get_bitmap(bitstr_t *bs, unsigned int b)
207 {
208 	unsigned int v, l, shift, bytes;
209 
210 	if (!b)
211 		return 0;
212 
213 	l = bs->bit + b;
214 
215 	if (l < 8) {
216 		v = (unsigned int)(*bs->cur) << (bs->bit + 24);
217 		bs->bit = l;
218 	} else if (l == 8) {
219 		v = (unsigned int)(*bs->cur++) << (bs->bit + 24);
220 		bs->bit = 0;
221 	} else {
222 		for (bytes = l >> 3, shift = 24, v = 0; bytes;
223 		     bytes--, shift -= 8)
224 			v |= (unsigned int)(*bs->cur++) << shift;
225 
226 		if (l < 32) {
227 			v |= (unsigned int)(*bs->cur) << shift;
228 			v <<= bs->bit;
229 		} else if (l > 32) {
230 			v <<= bs->bit;
231 			v |= (*bs->cur) >> (8 - bs->bit);
232 		}
233 
234 		bs->bit = l & 0x7;
235 	}
236 
237 	v &= 0xffffffff << (32 - b);
238 
239 	return v;
240 }
241 
242 /****************************************************************************
243  * Assume bs is aligned and sizeof(unsigned int) == 4
244  ****************************************************************************/
245 static unsigned int get_uint(bitstr_t *bs, int b)
246 {
247 	unsigned int v = 0;
248 
249 	switch (b) {
250 	case 4:
251 		v |= *bs->cur++;
252 		v <<= 8;
253 	case 3:
254 		v |= *bs->cur++;
255 		v <<= 8;
256 	case 2:
257 		v |= *bs->cur++;
258 		v <<= 8;
259 	case 1:
260 		v |= *bs->cur++;
261 		break;
262 	}
263 	return v;
264 }
265 
266 /****************************************************************************/
267 static int decode_nul(bitstr_t *bs, const struct field_t *f,
268                       char *base, int level)
269 {
270 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
271 
272 	return H323_ERROR_NONE;
273 }
274 
275 /****************************************************************************/
276 static int decode_bool(bitstr_t *bs, const struct field_t *f,
277                        char *base, int level)
278 {
279 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
280 
281 	INC_BIT(bs);
282 
283 	CHECK_BOUND(bs, 0);
284 	return H323_ERROR_NONE;
285 }
286 
287 /****************************************************************************/
288 static int decode_oid(bitstr_t *bs, const struct field_t *f,
289                       char *base, int level)
290 {
291 	int len;
292 
293 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
294 
295 	BYTE_ALIGN(bs);
296 	CHECK_BOUND(bs, 1);
297 	len = *bs->cur++;
298 	bs->cur += len;
299 
300 	CHECK_BOUND(bs, 0);
301 	return H323_ERROR_NONE;
302 }
303 
304 /****************************************************************************/
305 static int decode_int(bitstr_t *bs, const struct field_t *f,
306                       char *base, int level)
307 {
308 	unsigned int len;
309 
310 	PRINT("%*.s%s", level * TAB_SIZE, " ", f->name);
311 
312 	switch (f->sz) {
313 	case BYTE:		/* Range == 256 */
314 		BYTE_ALIGN(bs);
315 		bs->cur++;
316 		break;
317 	case WORD:		/* 257 <= Range <= 64K */
318 		BYTE_ALIGN(bs);
319 		bs->cur += 2;
320 		break;
321 	case CONS:		/* 64K < Range < 4G */
322 		len = get_bits(bs, 2) + 1;
323 		BYTE_ALIGN(bs);
324 		if (base && (f->attr & DECODE)) {	/* timeToLive */
325 			unsigned int v = get_uint(bs, len) + f->lb;
326 			PRINT(" = %u", v);
327 			*((unsigned int *)(base + f->offset)) = v;
328 		}
329 		bs->cur += len;
330 		break;
331 	case UNCO:
332 		BYTE_ALIGN(bs);
333 		CHECK_BOUND(bs, 2);
334 		len = get_len(bs);
335 		bs->cur += len;
336 		break;
337 	default:		/* 2 <= Range <= 255 */
338 		INC_BITS(bs, f->sz);
339 		break;
340 	}
341 
342 	PRINT("\n");
343 
344 	CHECK_BOUND(bs, 0);
345 	return H323_ERROR_NONE;
346 }
347 
348 /****************************************************************************/
349 static int decode_enum(bitstr_t *bs, const struct field_t *f,
350                        char *base, int level)
351 {
352 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
353 
354 	if ((f->attr & EXT) && get_bit(bs)) {
355 		INC_BITS(bs, 7);
356 	} else {
357 		INC_BITS(bs, f->sz);
358 	}
359 
360 	CHECK_BOUND(bs, 0);
361 	return H323_ERROR_NONE;
362 }
363 
364 /****************************************************************************/
365 static int decode_bitstr(bitstr_t *bs, const struct field_t *f,
366                          char *base, int level)
367 {
368 	unsigned int len;
369 
370 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
371 
372 	BYTE_ALIGN(bs);
373 	switch (f->sz) {
374 	case FIXD:		/* fixed length > 16 */
375 		len = f->lb;
376 		break;
377 	case WORD:		/* 2-byte length */
378 		CHECK_BOUND(bs, 2);
379 		len = (*bs->cur++) << 8;
380 		len += (*bs->cur++) + f->lb;
381 		break;
382 	case SEMI:
383 		CHECK_BOUND(bs, 2);
384 		len = get_len(bs);
385 		break;
386 	default:
387 		len = 0;
388 		break;
389 	}
390 
391 	bs->cur += len >> 3;
392 	bs->bit = len & 7;
393 
394 	CHECK_BOUND(bs, 0);
395 	return H323_ERROR_NONE;
396 }
397 
398 /****************************************************************************/
399 static int decode_numstr(bitstr_t *bs, const struct field_t *f,
400                          char *base, int level)
401 {
402 	unsigned int len;
403 
404 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
405 
406 	/* 2 <= Range <= 255 */
407 	len = get_bits(bs, f->sz) + f->lb;
408 
409 	BYTE_ALIGN(bs);
410 	INC_BITS(bs, (len << 2));
411 
412 	CHECK_BOUND(bs, 0);
413 	return H323_ERROR_NONE;
414 }
415 
416 /****************************************************************************/
417 static int decode_octstr(bitstr_t *bs, const struct field_t *f,
418                          char *base, int level)
419 {
420 	unsigned int len;
421 
422 	PRINT("%*.s%s", level * TAB_SIZE, " ", f->name);
423 
424 	switch (f->sz) {
425 	case FIXD:		/* Range == 1 */
426 		if (f->lb > 2) {
427 			BYTE_ALIGN(bs);
428 			if (base && (f->attr & DECODE)) {
429 				/* The IP Address */
430 				IFTHEN(f->lb == 4,
431 				       PRINT(" = %d.%d.%d.%d:%d",
432 					     bs->cur[0], bs->cur[1],
433 					     bs->cur[2], bs->cur[3],
434 					     bs->cur[4] * 256 + bs->cur[5]));
435 				*((unsigned int *)(base + f->offset)) =
436 				    bs->cur - bs->buf;
437 			}
438 		}
439 		len = f->lb;
440 		break;
441 	case BYTE:		/* Range == 256 */
442 		BYTE_ALIGN(bs);
443 		CHECK_BOUND(bs, 1);
444 		len = (*bs->cur++) + f->lb;
445 		break;
446 	case SEMI:
447 		BYTE_ALIGN(bs);
448 		CHECK_BOUND(bs, 2);
449 		len = get_len(bs) + f->lb;
450 		break;
451 	default:		/* 2 <= Range <= 255 */
452 		len = get_bits(bs, f->sz) + f->lb;
453 		BYTE_ALIGN(bs);
454 		break;
455 	}
456 
457 	bs->cur += len;
458 
459 	PRINT("\n");
460 
461 	CHECK_BOUND(bs, 0);
462 	return H323_ERROR_NONE;
463 }
464 
465 /****************************************************************************/
466 static int decode_bmpstr(bitstr_t *bs, const struct field_t *f,
467                          char *base, int level)
468 {
469 	unsigned int len;
470 
471 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
472 
473 	switch (f->sz) {
474 	case BYTE:		/* Range == 256 */
475 		BYTE_ALIGN(bs);
476 		CHECK_BOUND(bs, 1);
477 		len = (*bs->cur++) + f->lb;
478 		break;
479 	default:		/* 2 <= Range <= 255 */
480 		len = get_bits(bs, f->sz) + f->lb;
481 		BYTE_ALIGN(bs);
482 		break;
483 	}
484 
485 	bs->cur += len << 1;
486 
487 	CHECK_BOUND(bs, 0);
488 	return H323_ERROR_NONE;
489 }
490 
491 /****************************************************************************/
492 static int decode_seq(bitstr_t *bs, const struct field_t *f,
493                       char *base, int level)
494 {
495 	unsigned int ext, bmp, i, opt, len = 0, bmp2, bmp2_len;
496 	int err;
497 	const struct field_t *son;
498 	unsigned char *beg = NULL;
499 
500 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
501 
502 	/* Decode? */
503 	base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
504 
505 	/* Extensible? */
506 	ext = (f->attr & EXT) ? get_bit(bs) : 0;
507 
508 	/* Get fields bitmap */
509 	bmp = get_bitmap(bs, f->sz);
510 	if (base)
511 		*(unsigned int *)base = bmp;
512 
513 	/* Decode the root components */
514 	for (i = opt = 0, son = f->fields; i < f->lb; i++, son++) {
515 		if (son->attr & STOP) {
516 			PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
517 			      son->name);
518 			return H323_ERROR_STOP;
519 		}
520 
521 		if (son->attr & OPT) {	/* Optional component */
522 			if (!((0x80000000U >> (opt++)) & bmp))	/* Not exist */
523 				continue;
524 		}
525 
526 		/* Decode */
527 		if (son->attr & OPEN) {	/* Open field */
528 			CHECK_BOUND(bs, 2);
529 			len = get_len(bs);
530 			CHECK_BOUND(bs, len);
531 			if (!base || !(son->attr & DECODE)) {
532 				PRINT("%*.s%s\n", (level + 1) * TAB_SIZE,
533 				      " ", son->name);
534 				bs->cur += len;
535 				continue;
536 			}
537 			beg = bs->cur;
538 
539 			/* Decode */
540 			if ((err = (Decoders[son->type]) (bs, son, base,
541 							  level + 1)) <
542 			    H323_ERROR_NONE)
543 				return err;
544 
545 			bs->cur = beg + len;
546 			bs->bit = 0;
547 		} else if ((err = (Decoders[son->type]) (bs, son, base,
548 							 level + 1)) <
549 			   H323_ERROR_NONE)
550 			return err;
551 	}
552 
553 	/* No extension? */
554 	if (!ext)
555 		return H323_ERROR_NONE;
556 
557 	/* Get the extension bitmap */
558 	bmp2_len = get_bits(bs, 7) + 1;
559 	CHECK_BOUND(bs, (bmp2_len + 7) >> 3);
560 	bmp2 = get_bitmap(bs, bmp2_len);
561 	bmp |= bmp2 >> f->sz;
562 	if (base)
563 		*(unsigned int *)base = bmp;
564 	BYTE_ALIGN(bs);
565 
566 	/* Decode the extension components */
567 	for (opt = 0; opt < bmp2_len; opt++, i++, son++) {
568 		/* Check Range */
569 		if (i >= f->ub) {	/* Newer Version? */
570 			CHECK_BOUND(bs, 2);
571 			len = get_len(bs);
572 			CHECK_BOUND(bs, len);
573 			bs->cur += len;
574 			continue;
575 		}
576 
577 		if (son->attr & STOP) {
578 			PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
579 			      son->name);
580 			return H323_ERROR_STOP;
581 		}
582 
583 		if (!((0x80000000 >> opt) & bmp2))	/* Not present */
584 			continue;
585 
586 		CHECK_BOUND(bs, 2);
587 		len = get_len(bs);
588 		CHECK_BOUND(bs, len);
589 		if (!base || !(son->attr & DECODE)) {
590 			PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
591 			      son->name);
592 			bs->cur += len;
593 			continue;
594 		}
595 		beg = bs->cur;
596 
597 		if ((err = (Decoders[son->type]) (bs, son, base,
598 						  level + 1)) <
599 		    H323_ERROR_NONE)
600 			return err;
601 
602 		bs->cur = beg + len;
603 		bs->bit = 0;
604 	}
605 	return H323_ERROR_NONE;
606 }
607 
608 /****************************************************************************/
609 static int decode_seqof(bitstr_t *bs, const struct field_t *f,
610                         char *base, int level)
611 {
612 	unsigned int count, effective_count = 0, i, len = 0;
613 	int err;
614 	const struct field_t *son;
615 	unsigned char *beg = NULL;
616 
617 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
618 
619 	/* Decode? */
620 	base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
621 
622 	/* Decode item count */
623 	switch (f->sz) {
624 	case BYTE:
625 		BYTE_ALIGN(bs);
626 		CHECK_BOUND(bs, 1);
627 		count = *bs->cur++;
628 		break;
629 	case WORD:
630 		BYTE_ALIGN(bs);
631 		CHECK_BOUND(bs, 2);
632 		count = *bs->cur++;
633 		count <<= 8;
634 		count += *bs->cur++;
635 		break;
636 	case SEMI:
637 		BYTE_ALIGN(bs);
638 		CHECK_BOUND(bs, 2);
639 		count = get_len(bs);
640 		break;
641 	default:
642 		count = get_bits(bs, f->sz);
643 		break;
644 	}
645 	count += f->lb;
646 
647 	/* Write Count */
648 	if (base) {
649 		effective_count = count > f->ub ? f->ub : count;
650 		*(unsigned int *)base = effective_count;
651 		base += sizeof(unsigned int);
652 	}
653 
654 	/* Decode nested field */
655 	son = f->fields;
656 	if (base)
657 		base -= son->offset;
658 	for (i = 0; i < count; i++) {
659 		if (son->attr & OPEN) {
660 			BYTE_ALIGN(bs);
661 			len = get_len(bs);
662 			CHECK_BOUND(bs, len);
663 			if (!base || !(son->attr & DECODE)) {
664 				PRINT("%*.s%s\n", (level + 1) * TAB_SIZE,
665 				      " ", son->name);
666 				bs->cur += len;
667 				continue;
668 			}
669 			beg = bs->cur;
670 
671 			if ((err = (Decoders[son->type]) (bs, son,
672 							  i <
673 							  effective_count ?
674 							  base : NULL,
675 							  level + 1)) <
676 			    H323_ERROR_NONE)
677 				return err;
678 
679 			bs->cur = beg + len;
680 			bs->bit = 0;
681 		} else
682 			if ((err = (Decoders[son->type]) (bs, son,
683 							  i <
684 							  effective_count ?
685 							  base : NULL,
686 							  level + 1)) <
687 			    H323_ERROR_NONE)
688 				return err;
689 
690 		if (base)
691 			base += son->offset;
692 	}
693 
694 	return H323_ERROR_NONE;
695 }
696 
697 
698 /****************************************************************************/
699 static int decode_choice(bitstr_t *bs, const struct field_t *f,
700                          char *base, int level)
701 {
702 	unsigned int type, ext, len = 0;
703 	int err;
704 	const struct field_t *son;
705 	unsigned char *beg = NULL;
706 
707 	PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
708 
709 	/* Decode? */
710 	base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
711 
712 	/* Decode the choice index number */
713 	if ((f->attr & EXT) && get_bit(bs)) {
714 		ext = 1;
715 		type = get_bits(bs, 7) + f->lb;
716 	} else {
717 		ext = 0;
718 		type = get_bits(bs, f->sz);
719 		if (type >= f->lb)
720 			return H323_ERROR_RANGE;
721 	}
722 
723 	/* Write Type */
724 	if (base)
725 		*(unsigned int *)base = type;
726 
727 	/* Check Range */
728 	if (type >= f->ub) {	/* Newer version? */
729 		BYTE_ALIGN(bs);
730 		len = get_len(bs);
731 		CHECK_BOUND(bs, len);
732 		bs->cur += len;
733 		return H323_ERROR_NONE;
734 	}
735 
736 	/* Transfer to son level */
737 	son = &f->fields[type];
738 	if (son->attr & STOP) {
739 		PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ", son->name);
740 		return H323_ERROR_STOP;
741 	}
742 
743 	if (ext || (son->attr & OPEN)) {
744 		BYTE_ALIGN(bs);
745 		len = get_len(bs);
746 		CHECK_BOUND(bs, len);
747 		if (!base || !(son->attr & DECODE)) {
748 			PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
749 			      son->name);
750 			bs->cur += len;
751 			return H323_ERROR_NONE;
752 		}
753 		beg = bs->cur;
754 
755 		if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) <
756 		    H323_ERROR_NONE)
757 			return err;
758 
759 		bs->cur = beg + len;
760 		bs->bit = 0;
761 	} else if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) <
762 		   H323_ERROR_NONE)
763 		return err;
764 
765 	return H323_ERROR_NONE;
766 }
767 
768 /****************************************************************************/
769 int DecodeRasMessage(unsigned char *buf, size_t sz, RasMessage *ras)
770 {
771 	static const struct field_t ras_message = {
772 		FNAME("RasMessage") CHOICE, 5, 24, 32, DECODE | EXT,
773 		0, _RasMessage
774 	};
775 	bitstr_t bs;
776 
777 	bs.buf = bs.beg = bs.cur = buf;
778 	bs.end = buf + sz;
779 	bs.bit = 0;
780 
781 	return decode_choice(&bs, &ras_message, (char *) ras, 0);
782 }
783 
784 /****************************************************************************/
785 static int DecodeH323_UserInformation(unsigned char *buf, unsigned char *beg,
786 				      size_t sz, H323_UserInformation *uuie)
787 {
788 	static const struct field_t h323_userinformation = {
789 		FNAME("H323-UserInformation") SEQ, 1, 2, 2, DECODE | EXT,
790 		0, _H323_UserInformation
791 	};
792 	bitstr_t bs;
793 
794 	bs.buf = buf;
795 	bs.beg = bs.cur = beg;
796 	bs.end = beg + sz;
797 	bs.bit = 0;
798 
799 	return decode_seq(&bs, &h323_userinformation, (char *) uuie, 0);
800 }
801 
802 /****************************************************************************/
803 int DecodeMultimediaSystemControlMessage(unsigned char *buf, size_t sz,
804 					 MultimediaSystemControlMessage *
805 					 mscm)
806 {
807 	static const struct field_t multimediasystemcontrolmessage = {
808 		FNAME("MultimediaSystemControlMessage") CHOICE, 2, 4, 4,
809 		DECODE | EXT, 0, _MultimediaSystemControlMessage
810 	};
811 	bitstr_t bs;
812 
813 	bs.buf = bs.beg = bs.cur = buf;
814 	bs.end = buf + sz;
815 	bs.bit = 0;
816 
817 	return decode_choice(&bs, &multimediasystemcontrolmessage,
818 			     (char *) mscm, 0);
819 }
820 
821 /****************************************************************************/
822 int DecodeQ931(unsigned char *buf, size_t sz, Q931 *q931)
823 {
824 	unsigned char *p = buf;
825 	int len;
826 
827 	if (!p || sz < 1)
828 		return H323_ERROR_BOUND;
829 
830 	/* Protocol Discriminator */
831 	if (*p != 0x08) {
832 		PRINT("Unknown Protocol Discriminator\n");
833 		return H323_ERROR_RANGE;
834 	}
835 	p++;
836 	sz--;
837 
838 	/* CallReferenceValue */
839 	if (sz < 1)
840 		return H323_ERROR_BOUND;
841 	len = *p++;
842 	sz--;
843 	if (sz < len)
844 		return H323_ERROR_BOUND;
845 	p += len;
846 	sz -= len;
847 
848 	/* Message Type */
849 	if (sz < 1)
850 		return H323_ERROR_BOUND;
851 	q931->MessageType = *p++;
852 	PRINT("MessageType = %02X\n", q931->MessageType);
853 	if (*p & 0x80) {
854 		p++;
855 		sz--;
856 	}
857 
858 	/* Decode Information Elements */
859 	while (sz > 0) {
860 		if (*p == 0x7e) {	/* UserUserIE */
861 			if (sz < 3)
862 				break;
863 			p++;
864 			len = *p++ << 8;
865 			len |= *p++;
866 			sz -= 3;
867 			if (sz < len)
868 				break;
869 			p++;
870 			len--;
871 			return DecodeH323_UserInformation(buf, p, len,
872 							  &q931->UUIE);
873 		}
874 		p++;
875 		sz--;
876 		if (sz < 1)
877 			break;
878 		len = *p++;
879 		if (sz < len)
880 			break;
881 		p += len;
882 		sz -= len;
883 	}
884 
885 	PRINT("Q.931 UUIE not found\n");
886 
887 	return H323_ERROR_BOUND;
888 }
889