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