1 /****************************************************************************
2 * ip_conntrack_helper_h323_asn1.c - BER and PER decoding library for H.323
3 * conntrack/NAT module.
5 * Copyright (c) 2006 by Jing Min Zhao <zhaojingmin@users.sourceforge.net>
7 * This source code is licensed under General Public License version 2.
9 * See ip_conntrack_helper_h323_asn1.h for details.
11 ****************************************************************************/
14 #include <linux/kernel.h>
18 #include <linux/netfilter/nf_conntrack_h323_asn1.h>
27 #define IFTHEN(cond, act) if(cond){act;}
33 #define FNAME(name) name,
35 #define IFTHEN(cond, act)
36 #define PRINT(fmt, args...)
61 /* Constraint Types */
63 /* #define BITS 1-8 */
70 /* ASN.1 Type Attributes */
79 /* ASN.1 Field Structure */
80 typedef struct field_t
{
89 unsigned short offset
;
90 const struct field_t
*fields
;
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
);
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
);
127 /* Decoder Functions Vector */
128 typedef int (*decoder_t
)(bitstr_t
*, const struct field_t
*, char *, int);
129 static const decoder_t Decoders
[] = {
144 /****************************************************************************
146 ****************************************************************************/
147 #include "nf_conntrack_h323_types.c"
149 /****************************************************************************
151 ****************************************************************************/
152 /* Assume bs is aligned && v < 16384 */
153 static unsigned int get_len(bitstr_t
*bs
)
168 /****************************************************************************/
169 static unsigned int get_bit(bitstr_t
*bs
)
171 unsigned int b
= (*bs
->cur
) & (0x80 >> bs
->bit
);
178 /****************************************************************************/
180 static unsigned int get_bits(bitstr_t
*bs
, unsigned int b
)
184 v
= (*bs
->cur
) & (0xffU
>> bs
->bit
);
204 /****************************************************************************/
206 static unsigned int get_bitmap(bitstr_t
*bs
, unsigned int b
)
208 unsigned int v
, l
, shift
, bytes
;
216 v
= (unsigned int)(*bs
->cur
) << (bs
->bit
+ 24);
219 v
= (unsigned int)(*bs
->cur
++) << (bs
->bit
+ 24);
222 for (bytes
= l
>> 3, shift
= 24, v
= 0; bytes
;
224 v
|= (unsigned int)(*bs
->cur
++) << shift
;
227 v
|= (unsigned int)(*bs
->cur
) << shift
;
231 v
|= (*bs
->cur
) >> (8 - bs
->bit
);
237 v
&= 0xffffffff << (32 - b
);
242 /****************************************************************************
243 * Assume bs is aligned and sizeof(unsigned int) == 4
244 ****************************************************************************/
245 static unsigned int get_uint(bitstr_t
*bs
, int b
)
266 /****************************************************************************/
267 static int decode_nul(bitstr_t
*bs
, const struct field_t
*f
,
268 char *base
, int level
)
270 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
272 return H323_ERROR_NONE
;
275 /****************************************************************************/
276 static int decode_bool(bitstr_t
*bs
, const struct field_t
*f
,
277 char *base
, int level
)
279 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
284 return H323_ERROR_NONE
;
287 /****************************************************************************/
288 static int decode_oid(bitstr_t
*bs
, const struct field_t
*f
,
289 char *base
, int level
)
293 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
301 return H323_ERROR_NONE
;
304 /****************************************************************************/
305 static int decode_int(bitstr_t
*bs
, const struct field_t
*f
,
306 char *base
, int level
)
310 PRINT("%*.s%s", level
* TAB_SIZE
, " ", f
->name
);
313 case BYTE
: /* Range == 256 */
317 case WORD
: /* 257 <= Range <= 64K */
321 case CONS
: /* 64K < Range < 4G */
322 len
= get_bits(bs
, 2) + 1;
324 if (base
&& (f
->attr
& DECODE
)) { /* timeToLive */
325 unsigned int v
= get_uint(bs
, len
) + f
->lb
;
327 *((unsigned int *)(base
+ f
->offset
)) = v
;
337 default: /* 2 <= Range <= 255 */
345 return H323_ERROR_NONE
;
348 /****************************************************************************/
349 static int decode_enum(bitstr_t
*bs
, const struct field_t
*f
,
350 char *base
, int level
)
352 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
354 if ((f
->attr
& EXT
) && get_bit(bs
)) {
361 return H323_ERROR_NONE
;
364 /****************************************************************************/
365 static int decode_bitstr(bitstr_t
*bs
, const struct field_t
*f
,
366 char *base
, int level
)
370 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
374 case FIXD
: /* fixed length > 16 */
377 case WORD
: /* 2-byte length */
379 len
= (*bs
->cur
++) << 8;
380 len
+= (*bs
->cur
++) + f
->lb
;
395 return H323_ERROR_NONE
;
398 /****************************************************************************/
399 static int decode_numstr(bitstr_t
*bs
, const struct field_t
*f
,
400 char *base
, int level
)
404 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
406 /* 2 <= Range <= 255 */
407 len
= get_bits(bs
, f
->sz
) + f
->lb
;
410 INC_BITS(bs
, (len
<< 2));
413 return H323_ERROR_NONE
;
416 /****************************************************************************/
417 static int decode_octstr(bitstr_t
*bs
, const struct field_t
*f
,
418 char *base
, int level
)
422 PRINT("%*.s%s", level
* TAB_SIZE
, " ", f
->name
);
425 case FIXD
: /* Range == 1 */
428 if (base
&& (f
->attr
& DECODE
)) {
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
)) =
441 case BYTE
: /* Range == 256 */
444 len
= (*bs
->cur
++) + f
->lb
;
449 len
= get_len(bs
) + f
->lb
;
451 default: /* 2 <= Range <= 255 */
452 len
= get_bits(bs
, f
->sz
) + f
->lb
;
462 return H323_ERROR_NONE
;
465 /****************************************************************************/
466 static int decode_bmpstr(bitstr_t
*bs
, const struct field_t
*f
,
467 char *base
, int level
)
471 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
474 case BYTE
: /* Range == 256 */
477 len
= (*bs
->cur
++) + f
->lb
;
479 default: /* 2 <= Range <= 255 */
480 len
= get_bits(bs
, f
->sz
) + f
->lb
;
488 return H323_ERROR_NONE
;
491 /****************************************************************************/
492 static int decode_seq(bitstr_t
*bs
, const struct field_t
*f
,
493 char *base
, int level
)
495 unsigned int ext
, bmp
, i
, opt
, len
= 0, bmp2
, bmp2_len
;
497 const struct field_t
*son
;
498 unsigned char *beg
= NULL
;
500 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
503 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
506 ext
= (f
->attr
& EXT
) ? get_bit(bs
) : 0;
508 /* Get fields bitmap */
509 bmp
= get_bitmap(bs
, f
->sz
);
511 *(unsigned int *)base
= bmp
;
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
, " ",
518 return H323_ERROR_STOP
;
521 if (son
->attr
& OPT
) { /* Optional component */
522 if (!((0x80000000U
>> (opt
++)) & bmp
)) /* Not exist */
527 if (son
->attr
& OPEN
) { /* Open field */
530 CHECK_BOUND(bs
, len
);
531 if (!base
|| !(son
->attr
& DECODE
)) {
532 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
,
540 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
547 } else if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
555 return H323_ERROR_NONE
;
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
;
563 *(unsigned int *)base
= bmp
;
566 /* Decode the extension components */
567 for (opt
= 0; opt
< bmp2_len
; opt
++, i
++, son
++) {
569 if (i
>= f
->ub
) { /* Newer Version? */
572 CHECK_BOUND(bs
, len
);
577 if (son
->attr
& STOP
) {
578 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
580 return H323_ERROR_STOP
;
583 if (!((0x80000000 >> opt
) & bmp2
)) /* Not present */
588 CHECK_BOUND(bs
, len
);
589 if (!base
|| !(son
->attr
& DECODE
)) {
590 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
597 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
605 return H323_ERROR_NONE
;
608 /****************************************************************************/
609 static int decode_seqof(bitstr_t
*bs
, const struct field_t
*f
,
610 char *base
, int level
)
612 unsigned int count
, effective_count
= 0, i
, len
= 0;
614 const struct field_t
*son
;
615 unsigned char *beg
= NULL
;
617 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
620 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
622 /* Decode item count */
642 count
= get_bits(bs
, f
->sz
);
649 effective_count
= count
> f
->ub
? f
->ub
: count
;
650 *(unsigned int *)base
= effective_count
;
651 base
+= sizeof(unsigned int);
654 /* Decode nested field */
658 for (i
= 0; i
< count
; i
++) {
659 if (son
->attr
& OPEN
) {
662 CHECK_BOUND(bs
, len
);
663 if (!base
|| !(son
->attr
& DECODE
)) {
664 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
,
671 if ((err
= (Decoders
[son
->type
]) (bs
, son
,
682 if ((err
= (Decoders
[son
->type
]) (bs
, son
,
694 return H323_ERROR_NONE
;
698 /****************************************************************************/
699 static int decode_choice(bitstr_t
*bs
, const struct field_t
*f
,
700 char *base
, int level
)
702 unsigned int type
, ext
, len
= 0;
704 const struct field_t
*son
;
705 unsigned char *beg
= NULL
;
707 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
710 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
712 /* Decode the choice index number */
713 if ((f
->attr
& EXT
) && get_bit(bs
)) {
715 type
= get_bits(bs
, 7) + f
->lb
;
718 type
= get_bits(bs
, f
->sz
);
720 return H323_ERROR_RANGE
;
725 *(unsigned int *)base
= type
;
728 if (type
>= f
->ub
) { /* Newer version? */
731 CHECK_BOUND(bs
, len
);
733 return H323_ERROR_NONE
;
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
;
743 if (ext
|| (son
->attr
& OPEN
)) {
746 CHECK_BOUND(bs
, len
);
747 if (!base
|| !(son
->attr
& DECODE
)) {
748 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
751 return H323_ERROR_NONE
;
755 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
, level
+ 1)) <
761 } else if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
, level
+ 1)) <
765 return H323_ERROR_NONE
;
768 /****************************************************************************/
769 int DecodeRasMessage(unsigned char *buf
, size_t sz
, RasMessage
*ras
)
771 static const struct field_t ras_message
= {
772 FNAME("RasMessage") CHOICE
, 5, 24, 32, DECODE
| EXT
,
777 bs
.buf
= bs
.beg
= bs
.cur
= buf
;
781 return decode_choice(&bs
, &ras_message
, (char *) ras
, 0);
784 /****************************************************************************/
785 static int DecodeH323_UserInformation(unsigned char *buf
, unsigned char *beg
,
786 size_t sz
, H323_UserInformation
*uuie
)
788 static const struct field_t h323_userinformation
= {
789 FNAME("H323-UserInformation") SEQ
, 1, 2, 2, DECODE
| EXT
,
790 0, _H323_UserInformation
795 bs
.beg
= bs
.cur
= beg
;
799 return decode_seq(&bs
, &h323_userinformation
, (char *) uuie
, 0);
802 /****************************************************************************/
803 int DecodeMultimediaSystemControlMessage(unsigned char *buf
, size_t sz
,
804 MultimediaSystemControlMessage
*
807 static const struct field_t multimediasystemcontrolmessage
= {
808 FNAME("MultimediaSystemControlMessage") CHOICE
, 2, 4, 4,
809 DECODE
| EXT
, 0, _MultimediaSystemControlMessage
813 bs
.buf
= bs
.beg
= bs
.cur
= buf
;
817 return decode_choice(&bs
, &multimediasystemcontrolmessage
,
821 /****************************************************************************/
822 int DecodeQ931(unsigned char *buf
, size_t sz
, Q931
*q931
)
824 unsigned char *p
= buf
;
828 return H323_ERROR_BOUND
;
830 /* Protocol Discriminator */
832 PRINT("Unknown Protocol Discriminator\n");
833 return H323_ERROR_RANGE
;
838 /* CallReferenceValue */
840 return H323_ERROR_BOUND
;
844 return H323_ERROR_BOUND
;
850 return H323_ERROR_BOUND
;
851 q931
->MessageType
= *p
++;
852 PRINT("MessageType = %02X\n", q931
->MessageType
);
858 /* Decode Information Elements */
860 if (*p
== 0x7e) { /* UserUserIE */
871 return DecodeH323_UserInformation(buf
, p
, len
,
885 PRINT("Q.931 UUIE not found\n");
887 return H323_ERROR_BOUND
;