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, bytes: 0, bits: 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, bytes: 1, bits: 0))
304 return H323_ERROR_BOUND;
305
306 len = *bs->cur++;
307 bs->cur += len;
308 if (nf_h323_error_boundary(bs, bytes: 0, bits: 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, bytes: 0, bits: 2))
332 return H323_ERROR_BOUND;
333 len = get_bits(bs, b: 2) + 1;
334 BYTE_ALIGN(bs);
335 if (base && (f->attr & DECODE)) { /* timeToLive */
336 unsigned int v = get_uint(bs, b: 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, bytes: 2, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: 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, bytes: 2, bits: 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, bytes: 2, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: f->sz))
422 return H323_ERROR_BOUND;
423 len = get_bits(bs, b: f->sz) + f->lb;
424
425 BYTE_ALIGN(bs);
426 INC_BITS(bs, (len << 2));
427
428 if (nf_h323_error_boundary(bs, bytes: 0, bits: 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, bytes: 1, bits: 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, bytes: 2, bits: 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, bytes: 0, bits: f->sz))
471 return H323_ERROR_BOUND;
472 len = get_bits(bs, b: 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, bytes: 0, bits: 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, bytes: 1, bits: 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, bytes: 0, bits: f->sz))
502 return H323_ERROR_BOUND;
503 len = get_bits(bs, b: 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, bytes: 0, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: f->sz))
535 return H323_ERROR_BOUND;
536 if (f->sz > 32)
537 return H323_ERROR_RANGE;
538 bmp = get_bitmap(bs, b: 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, bytes: 2, bits: 0))
558 return H323_ERROR_BOUND;
559 len = get_len(bs);
560 if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 0, bits: 7))
590 return H323_ERROR_BOUND;
591 bmp2_len = get_bits(bs, b: 7) + 1;
592 if (nf_h323_error_boundary(bs, bytes: 0, bits: bmp2_len))
593 return H323_ERROR_BOUND;
594 if (bmp2_len > 32)
595 return H323_ERROR_RANGE;
596 bmp2 = get_bitmap(bs, b: 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, bytes: 2, bits: 0))
607 return H323_ERROR_BOUND;
608 len = get_len(bs);
609 if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 2, bits: 0))
625 return H323_ERROR_BOUND;
626 len = get_len(bs);
627 if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 1, bits: 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, bytes: 2, bits: 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, bytes: 2, bits: 0))
680 return H323_ERROR_BOUND;
681 count = get_len(bs);
682 break;
683 default:
684 if (nf_h323_error_boundary(bs, bytes: 0, bits: f->sz))
685 return H323_ERROR_BOUND;
686 count = get_bits(bs, b: 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, bytes: 2, bits: 0))
706 return H323_ERROR_BOUND;
707 len = get_len(bs);
708 if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 0, bits: 1))
759 return H323_ERROR_BOUND;
760 if ((f->attr & EXT) && get_bit(bs)) {
761 ext = 1;
762 if (nf_h323_error_boundary(bs, bytes: 0, bits: 7))
763 return H323_ERROR_BOUND;
764 type = get_bits(bs, b: 7) + f->lb;
765 } else {
766 ext = 0;
767 if (nf_h323_error_boundary(bs, bytes: 0, bits: f->sz))
768 return H323_ERROR_BOUND;
769 type = get_bits(bs, b: 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, bytes: 2, bits: 0))
782 return H323_ERROR_BOUND;
783 len = get_len(bs);
784 if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: len, bits: 0))
800 return H323_ERROR_BOUND;
801 len = get_len(bs);
802 if (nf_h323_error_boundary(bs, bytes: len, bits: 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: &bs, f: &ras_message, base: (char *) ras, level: 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: &bs, f: &h323_userinformation, base: (char *) uuie, level: 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: &bs, f: &multimediasystemcontrolmessage,
872 base: (char *) mscm, level: 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, beg: p, sz: len,
926 uuie: &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

source code of linux/net/netfilter/nf_conntrack_h323_asn1.c