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++;
853 PRINT("MessageType = %02X\n", q931->MessageType);
859 /* Decode Information Elements */
861 if (*p == 0x7e) { /* UserUserIE */
872 return DecodeH323_UserInformation(buf, p, len,
886 PRINT("Q.931 UUIE not found\n");
888 return H323_ERROR_BOUND;