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 } 889