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