/net/netfilter/nf_conntrack_h323_asn1.c

https://bitbucket.org/abioy/linux · C · 888 lines · 681 code · 130 blank · 77 comment · 97 complexity · cc19e763792595e5ee06d52a7744e223 MD5 · raw file

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