net/netfilter/nf_conntrack_h323_asn1.c

   1 /****************************************************************************
   2  * ip_conntrack_helper_h323_asn1.c - BER and PER decoding library for H.323
   3  *                                   conntrack/NAT module.
   4  *
   5  * Copyright (c) 2006 by Jing Min Zhao <zhaojingmin@users.sourceforge.net>
   6  *
   7  * This source code is licensed under General Public License version 2.
   8  *
   9  * See ip_conntrack_helper_h323_asn1.h for details.
  10  *
  11  ****************************************************************************/
  12
  13 #ifdef __KERNEL__
  14 #include <linux/kernel.h>
  15 #else
  16 #include <stdio.h>
  17 #endif
  18 #include <linux/netfilter/nf_conntrack_h323_asn1.h>
  19
  20 /* Trace Flag */
  21 #ifndef H323_TRACE
  22 #define H323_TRACE 0
  23 #endif
  24
  25 #if H323_TRACE
  26 #define TAB_SIZE 4
  27 #define IFTHEN(cond, act) if(cond){act;}
  28 #ifdef __KERNEL__
  29 #define PRINT printk
  30 #else
  31 #define PRINT printf
  32 #endif
  33 #define FNAME(name) name,
  34 #else
  35 #define IFTHEN(cond, act)
  36 #define PRINT(fmt, args...)
  37 #define FNAME(name)
  38 #endif
  39
  40 /* ASN.1 Types */
  41 #define NUL 0
  42 #define BOOL 1
  43 #define OID 2
  44 #define INT 3
  45 #define ENUM 4
  46 #define BITSTR 5
  47 #define NUMSTR 6
  48 #define NUMDGT 6
  49 #define TBCDSTR 6
  50 #define OCTSTR 7
  51 #define PRTSTR 7
  52 #define IA5STR 7
  53 #define GENSTR 7
  54 #define BMPSTR 8
  55 #define SEQ 9
  56 #define SET 9
  57 #define SEQOF 10
  58 #define SETOF 10
  59 #define CHOICE 11
  60
  61 /* Constraint Types */
  62 #define FIXD 0
  63 /* #define BITS 1-8 */
  64 #define BYTE 9
  65 #define WORD 10
  66 #define CONS 11
  67 #define SEMI 12
  68 #define UNCO 13
  69
  70 /* ASN.1 Type Attributes */
  71 #define SKIP 0
  72 #define STOP 1
  73 #define DECODE 2
  74 #define EXT 4
  75 #define OPEN 8
  76 #define OPT 16
  77
  78
  79 /* ASN.1 Field Structure */
  80 typedef struct field_t {
  81 #if H323_TRACE
  82         char *name;
  83 #endif
  84         unsigned char type;
  85         unsigned char sz;
  86         unsigned char lb;
  87         unsigned char ub;
  88         unsigned short attr;
  89         unsigned short offset;
  90         const struct field_t *fields;
  91 } field_t;
  92
  93 /* Bit Stream */
  94 typedef struct {
  95         unsigned char *buf;
  96         unsigned char *beg;
  97         unsigned char *end;
  98         unsigned char *cur;
  99         unsigned int bit;
 100 } bitstr_t;
 101
 102 /* Tool Functions */
 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);
 112
 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);
 126
 127 /* Decoder Functions Vector */
 128 typedef int (*decoder_t)(bitstr_t *, const struct field_t *, char *, int);
 129 static const decoder_t Decoders[] = {
 130         decode_nul,
 131         decode_bool,
 132         decode_oid,
 133         decode_int,
 134         decode_enum,
 135         decode_bitstr,
 136         decode_numstr,
 137         decode_octstr,
 138         decode_bmpstr,
 139         decode_seq,
 140         decode_seqof,
 141         decode_choice,
 142 };
 143
 144 /****************************************************************************
 145  * H.323 Types
 146  ****************************************************************************/
 147 #include "nf_conntrack_h323_types.c"
 148
 149 /****************************************************************************
 150  * Functions
 151  ****************************************************************************/
 152 /* Assume bs is aligned && v < 16384 */
 153 static unsigned int get_len(bitstr_t *bs)
 154 {
 155         unsigned int v;
 156
 157         v = *bs->cur++;
 158
 159         if (v & 0x80) {
 160                 v &= 0x3f;
 161                 v <<= 8;
 162                 v += *bs->cur++;
 163         }
 164
 165         return v;
 166 }
 167
 168 /****************************************************************************/
 169 static unsigned int get_bit(bitstr_t *bs)
 170 {
 171         unsigned int b = (*bs->cur) & (0x80 >> bs->bit);
 172
 173         INC_BIT(bs);
 174
 175         return b;
 176 }
 177
 178 /****************************************************************************/
 179 /* Assume b <= 8 */
 180 static unsigned int get_bits(bitstr_t *bs, unsigned int b)
 181 {
 182         unsigned int v, l;
 183
 184         v = (*bs->cur) & (0xffU >> bs->bit);
 185         l = b + bs->bit;
 186
 187         if (l < 8) {
 188                 v >>= 8 - l;
 189                 bs->bit = l;
 190         } else if (l == 8) {
 191                 bs->cur++;
 192                 bs->bit = 0;
 193         } else {                /* l > 8 */
 194
 195                 v <<= 8;
 196                 v += *(++bs->cur);
 197                 v >>= 16 - l;
 198                 bs->bit = l - 8;
 199         }
 200
 201         return v;
 202 }
 203
 204 /****************************************************************************/
 205 /* Assume b <= 32 */
 206 static unsigned int get_bitmap(bitstr_t *bs, unsigned int b)
 207 {
 208         unsigned int v, l, shift, bytes;
 209
 210         if (!b)
 211                 return 0;
 212
 213         l = bs->bit + b;
 214
 215         if (l < 8) {
 216                 v = (unsigned int)(*bs->cur) << (bs->bit + 24);
 217                 bs->bit = l;
 218         } else if (l == 8) {
 219                 v = (unsigned int)(*bs->cur++) << (bs->bit + 24);
 220                 bs->bit = 0;
 221         } else {
 222                 for (bytes = l >> 3, shift = 24, v = 0; bytes;
 223                      bytes--, shift -= 8)
 224                         v |= (unsigned int)(*bs->cur++) << shift;
 225
 226                 if (l < 32) {
 227                         v |= (unsigned int)(*bs->cur) << shift;
 228                         v <<= bs->bit;
 229                 } else if (l > 32) {
 230                         v <<= bs->bit;
 231                         v |= (*bs->cur) >> (8 - bs->bit);
 232                 }
 233
 234                 bs->bit = l & 0x7;
 235         }
 236
 237         v &= 0xffffffff << (32 - b);
 238
 239         return v;
 240 }
 241
 242 /****************************************************************************
 243  * Assume bs is aligned and sizeof(unsigned int) == 4
 244  ****************************************************************************/
 245 static unsigned int get_uint(bitstr_t *bs, int b)
 246 {
 247         unsigned int v = 0;
 248
 249         switch (b) {
 250         case 4:
 251                 v |= *bs->cur++;
 252                 v <<= 8;
 253         case 3:
 254                 v |= *bs->cur++;
 255                 v <<= 8;
 256         case 2:
 257                 v |= *bs->cur++;
 258                 v <<= 8;
 259         case 1:
 260                 v |= *bs->cur++;
 261                 break;
 262         }
 263         return v;
 264 }
 265
 266 /****************************************************************************/
 267 static int decode_nul(bitstr_t *bs, const struct field_t *f,
 268                       char *base, int level)
 269 {
 270         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 271
 272         return H323_ERROR_NONE;
 273 }
 274
 275 /****************************************************************************/
 276 static int decode_bool(bitstr_t *bs, const struct field_t *f,
 277                        char *base, int level)
 278 {
 279         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 280
 281         INC_BIT(bs);
 282
 283         CHECK_BOUND(bs, 0);
 284         return H323_ERROR_NONE;
 285 }
 286
 287 /****************************************************************************/
 288 static int decode_oid(bitstr_t *bs, const struct field_t *f,
 289                       char *base, int level)
 290 {
 291         int len;
 292
 293         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 294
 295         BYTE_ALIGN(bs);
 296         CHECK_BOUND(bs, 1);
 297         len = *bs->cur++;
 298         bs->cur += len;
 299
 300         CHECK_BOUND(bs, 0);
 301         return H323_ERROR_NONE;
 302 }
 303
 304 /****************************************************************************/
 305 static int decode_int(bitstr_t *bs, const struct field_t *f,
 306                       char *base, int level)
 307 {
 308         unsigned int len;
 309
 310         PRINT("%*.s%s", level * TAB_SIZE, " ", f->name);
 311
 312         switch (f->sz) {
 313         case BYTE:              /* Range == 256 */
 314                 BYTE_ALIGN(bs);
 315                 bs->cur++;
 316                 break;
 317         case WORD:              /* 257 <= Range <= 64K */
 318                 BYTE_ALIGN(bs);
 319                 bs->cur += 2;
 320                 break;
 321         case CONS:              /* 64K < Range < 4G */
 322                 len = get_bits(bs, 2) + 1;
 323                 BYTE_ALIGN(bs);
 324                 if (base && (f->attr & DECODE)) {       /* timeToLive */
 325                         unsigned int v = get_uint(bs, len) + f->lb;
 326                         PRINT(" = %u", v);
 327                         *((unsigned int *)(base + f->offset)) = v;
 328                 }
 329                 bs->cur += len;
 330                 break;
 331         case UNCO:
 332                 BYTE_ALIGN(bs);
 333                 CHECK_BOUND(bs, 2);
 334                 len = get_len(bs);
 335                 bs->cur += len;
 336                 break;
 337         default:                /* 2 <= Range <= 255 */
 338                 INC_BITS(bs, f->sz);
 339                 break;
 340         }
 341
 342         PRINT("\n");
 343
 344         CHECK_BOUND(bs, 0);
 345         return H323_ERROR_NONE;
 346 }
 347
 348 /****************************************************************************/
 349 static int decode_enum(bitstr_t *bs, const struct field_t *f,
 350                        char *base, int level)
 351 {
 352         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 353
 354         if ((f->attr & EXT) && get_bit(bs)) {
 355                 INC_BITS(bs, 7);
 356         } else {
 357                 INC_BITS(bs, f->sz);
 358         }
 359
 360         CHECK_BOUND(bs, 0);
 361         return H323_ERROR_NONE;
 362 }
 363
 364 /****************************************************************************/
 365 static int decode_bitstr(bitstr_t *bs, const struct field_t *f,
 366                          char *base, int level)
 367 {
 368         unsigned int len;
 369
 370         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 371
 372         BYTE_ALIGN(bs);
 373         switch (f->sz) {
 374         case FIXD:              /* fixed length > 16 */
 375                 len = f->lb;
 376                 break;
 377         case WORD:              /* 2-byte length */
 378                 CHECK_BOUND(bs, 2);
 379                 len = (*bs->cur++) << 8;
 380                 len += (*bs->cur++) + f->lb;
 381                 break;
 382         case SEMI:
 383                 CHECK_BOUND(bs, 2);
 384                 len = get_len(bs);
 385                 break;
 386         default:
 387                 len = 0;
 388                 break;
 389         }
 390
 391         bs->cur += len >> 3;
 392         bs->bit = len & 7;
 393
 394         CHECK_BOUND(bs, 0);
 395         return H323_ERROR_NONE;
 396 }
 397
 398 /****************************************************************************/
 399 static int decode_numstr(bitstr_t *bs, const struct field_t *f,
 400                          char *base, int level)
 401 {
 402         unsigned int len;
 403
 404         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 405
 406         /* 2 <= Range <= 255 */
 407         len = get_bits(bs, f->sz) + f->lb;
 408
 409         BYTE_ALIGN(bs);
 410         INC_BITS(bs, (len << 2));
 411
 412         CHECK_BOUND(bs, 0);
 413         return H323_ERROR_NONE;
 414 }
 415
 416 /****************************************************************************/
 417 static int decode_octstr(bitstr_t *bs, const struct field_t *f,
 418                          char *base, int level)
 419 {
 420         unsigned int len;
 421
 422         PRINT("%*.s%s", level * TAB_SIZE, " ", f->name);
 423
 424         switch (f->sz) {
 425         case FIXD:              /* Range == 1 */
 426                 if (f->lb > 2) {
 427                         BYTE_ALIGN(bs);
 428                         if (base && (f->attr & DECODE)) {
 429                                 /* The IP Address */
 430                                 IFTHEN(f->lb == 4,
 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)) =
 436                                     bs->cur - bs->buf;
 437                         }
 438                 }
 439                 len = f->lb;
 440                 break;
 441         case BYTE:              /* Range == 256 */
 442                 BYTE_ALIGN(bs);
 443                 CHECK_BOUND(bs, 1);
 444                 len = (*bs->cur++) + f->lb;
 445                 break;
 446         case SEMI:
 447                 BYTE_ALIGN(bs);
 448                 CHECK_BOUND(bs, 2);
 449                 len = get_len(bs) + f->lb;
 450                 break;
 451         default:                /* 2 <= Range <= 255 */
 452                 len = get_bits(bs, f->sz) + f->lb;
 453                 BYTE_ALIGN(bs);
 454                 break;
 455         }
 456
 457         bs->cur += len;
 458
 459         PRINT("\n");
 460
 461         CHECK_BOUND(bs, 0);
 462         return H323_ERROR_NONE;
 463 }
 464
 465 /****************************************************************************/
 466 static int decode_bmpstr(bitstr_t *bs, const struct field_t *f,
 467                          char *base, int level)
 468 {
 469         unsigned int len;
 470
 471         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 472
 473         switch (f->sz) {
 474         case BYTE:              /* Range == 256 */
 475                 BYTE_ALIGN(bs);
 476                 CHECK_BOUND(bs, 1);
 477                 len = (*bs->cur++) + f->lb;
 478                 break;
 479         default:                /* 2 <= Range <= 255 */
 480                 len = get_bits(bs, f->sz) + f->lb;
 481                 BYTE_ALIGN(bs);
 482                 break;
 483         }
 484
 485         bs->cur += len << 1;
 486
 487         CHECK_BOUND(bs, 0);
 488         return H323_ERROR_NONE;
 489 }
 490
 491 /****************************************************************************/
 492 static int decode_seq(bitstr_t *bs, const struct field_t *f,
 493                       char *base, int level)
 494 {
 495         unsigned int ext, bmp, i, opt, len = 0, bmp2, bmp2_len;
 496         int err;
 497         const struct field_t *son;
 498         unsigned char *beg = NULL;
 499
 500         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 501
 502         /* Decode? */
 503         base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
 504
 505         /* Extensible? */
 506         ext = (f->attr & EXT) ? get_bit(bs) : 0;
 507
 508         /* Get fields bitmap */
 509         bmp = get_bitmap(bs, f->sz);
 510         if (base)
 511                 *(unsigned int *)base = bmp;
 512
 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, " ",
 517                               son->name);
 518                         return H323_ERROR_STOP;
 519                 }
 520
 521                 if (son->attr & OPT) {  /* Optional component */
 522                         if (!((0x80000000U >> (opt++)) & bmp))  /* Not exist */
 523                                 continue;
 524                 }
 525
 526                 /* Decode */
 527                 if (son->attr & OPEN) { /* Open field */
 528                         CHECK_BOUND(bs, 2);
 529                         len = get_len(bs);
 530                         CHECK_BOUND(bs, len);
 531                         if (!base || !(son->attr & DECODE)) {
 532                                 PRINT("%*.s%s\n", (level + 1) * TAB_SIZE,
 533                                       " ", son->name);
 534                                 bs->cur += len;
 535                                 continue;
 536                         }
 537                         beg = bs->cur;
 538
 539                         /* Decode */
 540                         if ((err = (Decoders[son->type]) (bs, son, base,
 541                                                           level + 1)) <
 542                             H323_ERROR_NONE)
 543                                 return err;
 544
 545                         bs->cur = beg + len;
 546                         bs->bit = 0;
 547                 } else if ((err = (Decoders[son->type]) (bs, son, base,
 548                                                          level + 1)) <
 549                            H323_ERROR_NONE)
 550                         return err;
 551         }
 552
 553         /* No extension? */
 554         if (!ext)
 555                 return H323_ERROR_NONE;
 556
 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;
 562         if (base)
 563                 *(unsigned int *)base = bmp;
 564         BYTE_ALIGN(bs);
 565
 566         /* Decode the extension components */
 567         for (opt = 0; opt < bmp2_len; opt++, i++, son++) {
 568                 /* Check Range */
 569                 if (i >= f->ub) {       /* Newer Version? */
 570                         CHECK_BOUND(bs, 2);
 571                         len = get_len(bs);
 572                         CHECK_BOUND(bs, len);
 573                         bs->cur += len;
 574                         continue;
 575                 }
 576
 577                 if (son->attr & STOP) {
 578                         PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
 579                               son->name);
 580                         return H323_ERROR_STOP;
 581                 }
 582
 583                 if (!((0x80000000 >> opt) & bmp2))      /* Not present */
 584                         continue;
 585
 586                 CHECK_BOUND(bs, 2);
 587                 len = get_len(bs);
 588                 CHECK_BOUND(bs, len);
 589                 if (!base || !(son->attr & DECODE)) {
 590                         PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
 591                               son->name);
 592                         bs->cur += len;
 593                         continue;
 594                 }
 595                 beg = bs->cur;
 596
 597                 if ((err = (Decoders[son->type]) (bs, son, base,
 598                                                   level + 1)) <
 599                     H323_ERROR_NONE)
 600                         return err;
 601
 602                 bs->cur = beg + len;
 603                 bs->bit = 0;
 604         }
 605         return H323_ERROR_NONE;
 606 }
 607
 608 /****************************************************************************/
 609 static int decode_seqof(bitstr_t *bs, const struct field_t *f,
 610                         char *base, int level)
 611 {
 612         unsigned int count, effective_count = 0, i, len = 0;
 613         int err;
 614         const struct field_t *son;
 615         unsigned char *beg = NULL;
 616
 617         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 618
 619         /* Decode? */
 620         base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
 621
 622         /* Decode item count */
 623         switch (f->sz) {
 624         case BYTE:
 625                 BYTE_ALIGN(bs);
 626                 CHECK_BOUND(bs, 1);
 627                 count = *bs->cur++;
 628                 break;
 629         case WORD:
 630                 BYTE_ALIGN(bs);
 631                 CHECK_BOUND(bs, 2);
 632                 count = *bs->cur++;
 633                 count <<= 8;
 634                 count += *bs->cur++;
 635                 break;
 636         case SEMI:
 637                 BYTE_ALIGN(bs);
 638                 CHECK_BOUND(bs, 2);
 639                 count = get_len(bs);
 640                 break;
 641         default:
 642                 count = get_bits(bs, f->sz);
 643                 break;
 644         }
 645         count += f->lb;
 646
 647         /* Write Count */
 648         if (base) {
 649                 effective_count = count > f->ub ? f->ub : count;
 650                 *(unsigned int *)base = effective_count;
 651                 base += sizeof(unsigned int);
 652         }
 653
 654         /* Decode nested field */
 655         son = f->fields;
 656         if (base)
 657                 base -= son->offset;
 658         for (i = 0; i < count; i++) {
 659                 if (son->attr & OPEN) {
 660                         BYTE_ALIGN(bs);
 661                         len = get_len(bs);
 662                         CHECK_BOUND(bs, len);
 663                         if (!base || !(son->attr & DECODE)) {
 664                                 PRINT("%*.s%s\n", (level + 1) * TAB_SIZE,
 665                                       " ", son->name);
 666                                 bs->cur += len;
 667                                 continue;
 668                         }
 669                         beg = bs->cur;
 670
 671                         if ((err = (Decoders[son->type]) (bs, son,
 672                                                           i <
 673                                                           effective_count ?
 674                                                           base : NULL,
 675                                                           level + 1)) <
 676                             H323_ERROR_NONE)
 677                                 return err;
 678
 679                         bs->cur = beg + len;
 680                         bs->bit = 0;
 681                 } else
 682                         if ((err = (Decoders[son->type]) (bs, son,
 683                                                           i <
 684                                                           effective_count ?
 685                                                           base : NULL,
 686                                                           level + 1)) <
 687                             H323_ERROR_NONE)
 688                                 return err;
 689
 690                 if (base)
 691                         base += son->offset;
 692         }
 693
 694         return H323_ERROR_NONE;
 695 }
 696
 697
 698 /****************************************************************************/
 699 static int decode_choice(bitstr_t *bs, const struct field_t *f,
 700                          char *base, int level)
 701 {
 702         unsigned int type, ext, len = 0;
 703         int err;
 704         const struct field_t *son;
 705         unsigned char *beg = NULL;
 706
 707         PRINT("%*.s%s\n", level * TAB_SIZE, " ", f->name);
 708
 709         /* Decode? */
 710         base = (base && (f->attr & DECODE)) ? base + f->offset : NULL;
 711
 712         /* Decode the choice index number */
 713         if ((f->attr & EXT) && get_bit(bs)) {
 714                 ext = 1;
 715                 type = get_bits(bs, 7) + f->lb;
 716         } else {
 717                 ext = 0;
 718                 type = get_bits(bs, f->sz);
 719                 if (type >= f->lb)
 720                         return H323_ERROR_RANGE;
 721         }
 722
 723         /* Write Type */
 724         if (base)
 725                 *(unsigned int *)base = type;
 726
 727         /* Check Range */
 728         if (type >= f->ub) {    /* Newer version? */
 729                 BYTE_ALIGN(bs);
 730                 len = get_len(bs);
 731                 CHECK_BOUND(bs, len);
 732                 bs->cur += len;
 733                 return H323_ERROR_NONE;
 734         }
 735
 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;
 741         }
 742
 743         if (ext || (son->attr & OPEN)) {
 744                 BYTE_ALIGN(bs);
 745                 len = get_len(bs);
 746                 CHECK_BOUND(bs, len);
 747                 if (!base || !(son->attr & DECODE)) {
 748                         PRINT("%*.s%s\n", (level + 1) * TAB_SIZE, " ",
 749                               son->name);
 750                         bs->cur += len;
 751                         return H323_ERROR_NONE;
 752                 }
 753                 beg = bs->cur;
 754
 755                 if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) <
 756                     H323_ERROR_NONE)
 757                         return err;
 758
 759                 bs->cur = beg + len;
 760                 bs->bit = 0;
 761         } else if ((err = (Decoders[son->type]) (bs, son, base, level + 1)) <
 762                    H323_ERROR_NONE)
 763                 return err;
 764
 765         return H323_ERROR_NONE;
 766 }
 767
 768 /****************************************************************************/
 769 int DecodeRasMessage(unsigned char *buf, size_t sz, RasMessage *ras)
 770 {
 771         static const struct field_t ras_message = {
 772                 FNAME("RasMessage") CHOICE, 5, 24, 32, DECODE | EXT,
 773                 0, _RasMessage
 774         };
 775         bitstr_t bs;
 776
 777         bs.buf = bs.beg = bs.cur = buf;
 778         bs.end = buf + sz;
 779         bs.bit = 0;
 780
 781         return decode_choice(&bs, &ras_message, (char *) ras, 0);
 782 }
 783
 784 /****************************************************************************/
 785 static int DecodeH323_UserInformation(unsigned char *buf, unsigned char *beg,
 786                                       size_t sz, H323_UserInformation *uuie)
 787 {
 788         static const struct field_t h323_userinformation = {
 789                 FNAME("H323-UserInformation") SEQ, 1, 2, 2, DECODE | EXT,
 790                 0, _H323_UserInformation
 791         };
 792         bitstr_t bs;
 793
 794         bs.buf = buf;
 795         bs.beg = bs.cur = beg;
 796         bs.end = beg + sz;
 797         bs.bit = 0;
 798
 799         return decode_seq(&bs, &h323_userinformation, (char *) uuie, 0);
 800 }
 801
 802 /****************************************************************************/
 803 int DecodeMultimediaSystemControlMessage(unsigned char *buf, size_t sz,
 804                                          MultimediaSystemControlMessage *
 805                                          mscm)
 806 {
 807         static const struct field_t multimediasystemcontrolmessage = {
 808                 FNAME("MultimediaSystemControlMessage") CHOICE, 2, 4, 4,
 809                 DECODE | EXT, 0, _MultimediaSystemControlMessage
 810         };
 811         bitstr_t bs;
 812
 813         bs.buf = bs.beg = bs.cur = buf;
 814         bs.end = buf + sz;
 815         bs.bit = 0;
 816
 817         return decode_choice(&bs, &multimediasystemcontrolmessage,
 818                              (char *) mscm, 0);
 819 }
 820
 821 /****************************************************************************/
 822 int DecodeQ931(unsigned char *buf, size_t sz, Q931 *q931)
 823 {
 824         unsigned char *p = buf;
 825         int len;
 826
 827         if (!p || sz < 1)
 828                 return H323_ERROR_BOUND;
 829
 830         /* Protocol Discriminator */
 831         if (*p != 0x08) {
 832                 PRINT("Unknown Protocol Discriminator\n");
 833                 return H323_ERROR_RANGE;
 834         }
 835         p++;
 836         sz--;
 837
 838         /* CallReferenceValue */
 839         if (sz < 1)
 840                 return H323_ERROR_BOUND;
 841         len = *p++;
 842         sz--;
 843         if (sz < len)
 844                 return H323_ERROR_BOUND;
 845         p += len;
 846         sz -= len;
 847
 848         /* Message Type */
 849         if (sz < 1)
 850                 return H323_ERROR_BOUND;
 851         q931->MessageType = *p++;
 852         PRINT("MessageType = %02X\n", q931->MessageType);
 853         if (*p & 0x80) {
 854                 p++;
 855                 sz--;
 856         }
 857
 858         /* Decode Information Elements */
 859         while (sz > 0) {
 860                 if (*p == 0x7e) {       /* UserUserIE */
 861                         if (sz < 3)
 862                                 break;
 863                         p++;
 864                         len = *p++ << 8;
 865                         len |= *p++;
 866                         sz -= 3;
 867                         if (sz < len)
 868                                 break;
 869                         p++;
 870                         len--;
 871                         return DecodeH323_UserInformation(buf, p, len,
 872                                                           &q931->UUIE);
 873                 }
 874                 p++;
 875                 sz--;
 876                 if (sz < 1)
 877                         break;
 878                 len = *p++;
 879                 if (sz < len)
 880                         break;
 881                 p += len;
 882                 sz -= len;
 883         }
 884
 885         PRINT("Q.931 UUIE not found\n");
 886
 887         return H323_ERROR_BOUND;
 888 }