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;