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 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 get_len(bitstr_t
* bs
);
108 static unsigned get_bit(bitstr_t
* bs
);
109 static unsigned get_bits(bitstr_t
* bs
, unsigned b
);
110 static unsigned get_bitmap(bitstr_t
* bs
, unsigned b
);
111 static unsigned get_uint(bitstr_t
* bs
, int b
);
113 /* Decoder Functions */
114 static int decode_nul(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
115 static int decode_bool(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
116 static int decode_oid(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
117 static int decode_int(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
118 static int decode_enum(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
119 static int decode_bitstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
120 static int decode_numstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
121 static int decode_octstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
122 static int decode_bmpstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
123 static int decode_seq(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
124 static int decode_seqof(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
125 static int decode_choice(bitstr_t
* bs
, field_t
* f
, char *base
, int level
);
127 /* Decoder Functions Vector */
128 typedef int (*decoder_t
) (bitstr_t
*, field_t
*, char *, int);
129 static decoder_t Decoders
[] = {
144 /****************************************************************************
146 ****************************************************************************/
147 #include "nf_conntrack_h323_types.c"
149 /****************************************************************************
151 ****************************************************************************/
152 /* Assume bs is aligned && v < 16384 */
153 unsigned get_len(bitstr_t
* bs
)
168 /****************************************************************************/
169 unsigned get_bit(bitstr_t
* bs
)
171 unsigned b
= (*bs
->cur
) & (0x80 >> bs
->bit
);
178 /****************************************************************************/
180 unsigned get_bits(bitstr_t
* bs
, unsigned b
)
184 v
= (*bs
->cur
) & (0xffU
>> bs
->bit
);
204 /****************************************************************************/
206 unsigned get_bitmap(bitstr_t
* bs
, unsigned b
)
208 unsigned v
, l
, shift
, bytes
;
216 v
= (unsigned) (*bs
->cur
) << (bs
->bit
+ 24);
219 v
= (unsigned) (*bs
->cur
++) << (bs
->bit
+ 24);
222 for (bytes
= l
>> 3, shift
= 24, v
= 0; bytes
;
224 v
|= (unsigned) (*bs
->cur
++) << shift
;
227 v
|= (unsigned) (*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 unsigned get_uint(bitstr_t
* bs
, int b
)
266 /****************************************************************************/
267 int decode_nul(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
269 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
271 return H323_ERROR_NONE
;
274 /****************************************************************************/
275 int decode_bool(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
277 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
282 return H323_ERROR_NONE
;
285 /****************************************************************************/
286 int decode_oid(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
290 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
298 return H323_ERROR_NONE
;
301 /****************************************************************************/
302 int decode_int(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
306 PRINT("%*.s%s", level
* TAB_SIZE
, " ", f
->name
);
309 case BYTE
: /* Range == 256 */
313 case WORD
: /* 257 <= Range <= 64K */
317 case CONS
: /* 64K < Range < 4G */
318 len
= get_bits(bs
, 2) + 1;
320 if (base
&& (f
->attr
& DECODE
)) { /* timeToLive */
321 unsigned v
= get_uint(bs
, len
) + f
->lb
;
323 *((unsigned *) (base
+ f
->offset
)) = v
;
333 default: /* 2 <= Range <= 255 */
341 return H323_ERROR_NONE
;
344 /****************************************************************************/
345 int decode_enum(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
347 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
349 if ((f
->attr
& EXT
) && get_bit(bs
)) {
356 return H323_ERROR_NONE
;
359 /****************************************************************************/
360 int decode_bitstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
364 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
368 case FIXD
: /* fixed length > 16 */
371 case WORD
: /* 2-byte length */
373 len
= (*bs
->cur
++) << 8;
374 len
+= (*bs
->cur
++) + f
->lb
;
389 return H323_ERROR_NONE
;
392 /****************************************************************************/
393 int decode_numstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
397 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
399 /* 2 <= Range <= 255 */
400 len
= get_bits(bs
, f
->sz
) + f
->lb
;
403 INC_BITS(bs
, (len
<< 2));
406 return H323_ERROR_NONE
;
409 /****************************************************************************/
410 int decode_octstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
414 PRINT("%*.s%s", level
* TAB_SIZE
, " ", f
->name
);
417 case FIXD
: /* Range == 1 */
420 if (base
&& (f
->attr
& DECODE
)) {
423 PRINT(" = %d.%d.%d.%d:%d",
424 bs
->cur
[0], bs
->cur
[1],
425 bs
->cur
[2], bs
->cur
[3],
426 bs
->cur
[4] * 256 + bs
->cur
[5]));
427 *((unsigned *) (base
+ f
->offset
)) =
433 case BYTE
: /* Range == 256 */
436 len
= (*bs
->cur
++) + f
->lb
;
441 len
= get_len(bs
) + f
->lb
;
443 default: /* 2 <= Range <= 255 */
444 len
= get_bits(bs
, f
->sz
) + f
->lb
;
454 return H323_ERROR_NONE
;
457 /****************************************************************************/
458 int decode_bmpstr(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
462 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
465 case BYTE
: /* Range == 256 */
468 len
= (*bs
->cur
++) + f
->lb
;
470 default: /* 2 <= Range <= 255 */
471 len
= get_bits(bs
, f
->sz
) + f
->lb
;
479 return H323_ERROR_NONE
;
482 /****************************************************************************/
483 int decode_seq(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
485 unsigned ext
, bmp
, i
, opt
, len
= 0, bmp2
, bmp2_len
;
488 unsigned char *beg
= NULL
;
490 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
493 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
496 ext
= (f
->attr
& EXT
) ? get_bit(bs
) : 0;
498 /* Get fields bitmap */
499 bmp
= get_bitmap(bs
, f
->sz
);
501 *(unsigned *) base
= bmp
;
503 /* Decode the root components */
504 for (i
= opt
= 0, son
= f
->fields
; i
< f
->lb
; i
++, son
++) {
505 if (son
->attr
& STOP
) {
506 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
508 return H323_ERROR_STOP
;
511 if (son
->attr
& OPT
) { /* Optional component */
512 if (!((0x80000000U
>> (opt
++)) & bmp
)) /* Not exist */
517 if (son
->attr
& OPEN
) { /* Open field */
520 CHECK_BOUND(bs
, len
);
522 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
,
530 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
537 } else if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
545 return H323_ERROR_NONE
;
547 /* Get the extension bitmap */
548 bmp2_len
= get_bits(bs
, 7) + 1;
549 CHECK_BOUND(bs
, (bmp2_len
+ 7) >> 3);
550 bmp2
= get_bitmap(bs
, bmp2_len
);
551 bmp
|= bmp2
>> f
->sz
;
553 *(unsigned *) base
= bmp
;
556 /* Decode the extension components */
557 for (opt
= 0; opt
< bmp2_len
; opt
++, i
++, son
++) {
558 if (i
< f
->ub
&& son
->attr
& STOP
) {
559 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
561 return H323_ERROR_STOP
;
564 if (!((0x80000000 >> opt
) & bmp2
)) /* Not present */
568 if (i
>= f
->ub
) { /* Newer Version? */
571 CHECK_BOUND(bs
, len
);
578 CHECK_BOUND(bs
, len
);
579 if (!base
|| !(son
->attr
& DECODE
)) {
580 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
587 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
,
595 return H323_ERROR_NONE
;
598 /****************************************************************************/
599 int decode_seqof(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
601 unsigned count
, effective_count
= 0, i
, len
= 0;
604 unsigned char *beg
= NULL
;
606 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
609 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
611 /* Decode item count */
631 count
= get_bits(bs
, f
->sz
);
638 effective_count
= count
> f
->ub
? f
->ub
: count
;
639 *(unsigned *) base
= effective_count
;
640 base
+= sizeof(unsigned);
643 /* Decode nested field */
647 for (i
= 0; i
< count
; i
++) {
648 if (son
->attr
& OPEN
) {
651 CHECK_BOUND(bs
, len
);
652 if (!base
|| !(son
->attr
& DECODE
)) {
653 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
,
660 if ((err
= (Decoders
[son
->type
]) (bs
, son
,
671 if ((err
= (Decoders
[son
->type
]) (bs
, son
,
683 return H323_ERROR_NONE
;
687 /****************************************************************************/
688 int decode_choice(bitstr_t
* bs
, field_t
* f
, char *base
, int level
)
690 unsigned type
, ext
, len
= 0;
693 unsigned char *beg
= NULL
;
695 PRINT("%*.s%s\n", level
* TAB_SIZE
, " ", f
->name
);
698 base
= (base
&& (f
->attr
& DECODE
)) ? base
+ f
->offset
: NULL
;
700 /* Decode the choice index number */
701 if ((f
->attr
& EXT
) && get_bit(bs
)) {
703 type
= get_bits(bs
, 7) + f
->lb
;
706 type
= get_bits(bs
, f
->sz
);
711 *(unsigned *) base
= type
;
714 if (type
>= f
->ub
) { /* Newer version? */
717 CHECK_BOUND(bs
, len
);
719 return H323_ERROR_NONE
;
722 /* Transfer to son level */
723 son
= &f
->fields
[type
];
724 if (son
->attr
& STOP
) {
725 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ", son
->name
);
726 return H323_ERROR_STOP
;
729 if (ext
|| (son
->attr
& OPEN
)) {
732 CHECK_BOUND(bs
, len
);
733 if (!base
|| !(son
->attr
& DECODE
)) {
734 PRINT("%*.s%s\n", (level
+ 1) * TAB_SIZE
, " ",
737 return H323_ERROR_NONE
;
741 if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
, level
+ 1)) <
747 } else if ((err
= (Decoders
[son
->type
]) (bs
, son
, base
, level
+ 1)) <
751 return H323_ERROR_NONE
;
754 /****************************************************************************/
755 int DecodeRasMessage(unsigned char *buf
, size_t sz
, RasMessage
* ras
)
757 static field_t ras_message
= {
758 FNAME("RasMessage") CHOICE
, 5, 24, 32, DECODE
| EXT
,
763 bs
.buf
= bs
.beg
= bs
.cur
= buf
;
767 return decode_choice(&bs
, &ras_message
, (char *) ras
, 0);
770 /****************************************************************************/
771 static int DecodeH323_UserInformation(unsigned char *buf
, unsigned char *beg
,
772 size_t sz
, H323_UserInformation
* uuie
)
774 static field_t h323_userinformation
= {
775 FNAME("H323-UserInformation") SEQ
, 1, 2, 2, DECODE
| EXT
,
776 0, _H323_UserInformation
781 bs
.beg
= bs
.cur
= beg
;
785 return decode_seq(&bs
, &h323_userinformation
, (char *) uuie
, 0);
788 /****************************************************************************/
789 int DecodeMultimediaSystemControlMessage(unsigned char *buf
, size_t sz
,
790 MultimediaSystemControlMessage
*
793 static field_t multimediasystemcontrolmessage
= {
794 FNAME("MultimediaSystemControlMessage") CHOICE
, 2, 4, 4,
795 DECODE
| EXT
, 0, _MultimediaSystemControlMessage
799 bs
.buf
= bs
.beg
= bs
.cur
= buf
;
803 return decode_choice(&bs
, &multimediasystemcontrolmessage
,
807 /****************************************************************************/
808 int DecodeQ931(unsigned char *buf
, size_t sz
, Q931
* q931
)
810 unsigned char *p
= buf
;
814 return H323_ERROR_BOUND
;
816 /* Protocol Discriminator */
818 PRINT("Unknown Protocol Discriminator\n");
819 return H323_ERROR_RANGE
;
824 /* CallReferenceValue */
826 return H323_ERROR_BOUND
;
830 return H323_ERROR_BOUND
;
836 return H323_ERROR_BOUND
;
837 q931
->MessageType
= *p
++;
838 PRINT("MessageType = %02X\n", q931
->MessageType
);
844 /* Decode Information Elements */
846 if (*p
== 0x7e) { /* UserUserIE */
857 return DecodeH323_UserInformation(buf
, p
, len
,
871 PRINT("Q.931 UUIE not found\n");
873 return H323_ERROR_BOUND
;