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, bytes: 0, bits: 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, bytes: 1, bits: 0)) |
304 | return H323_ERROR_BOUND; |
305 | |
306 | len = *bs->cur++; |
307 | bs->cur += len; |
308 | if (nf_h323_error_boundary(bs, bytes: 0, bits: 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, bytes: 0, bits: 2)) |
332 | return H323_ERROR_BOUND; |
333 | len = get_bits(bs, b: 2) + 1; |
334 | BYTE_ALIGN(bs); |
335 | if (base && (f->attr & DECODE)) { /* timeToLive */ |
336 | unsigned int v = get_uint(bs, b: 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, bytes: 2, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: 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, bytes: 2, bits: 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, bytes: 2, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: f->sz)) |
422 | return H323_ERROR_BOUND; |
423 | len = get_bits(bs, b: f->sz) + f->lb; |
424 | |
425 | BYTE_ALIGN(bs); |
426 | INC_BITS(bs, (len << 2)); |
427 | |
428 | if (nf_h323_error_boundary(bs, bytes: 0, bits: 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, bytes: 1, bits: 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, bytes: 2, bits: 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, bytes: 0, bits: f->sz)) |
471 | return H323_ERROR_BOUND; |
472 | len = get_bits(bs, b: 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, bytes: 0, bits: 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, bytes: 1, bits: 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, bytes: 0, bits: f->sz)) |
502 | return H323_ERROR_BOUND; |
503 | len = get_bits(bs, b: 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, bytes: 0, bits: 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, bytes: 0, bits: 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, bytes: 0, bits: f->sz)) |
535 | return H323_ERROR_BOUND; |
536 | bmp = get_bitmap(bs, b: 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, bytes: 2, bits: 0)) |
556 | return H323_ERROR_BOUND; |
557 | len = get_len(bs); |
558 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 0, bits: 7)) |
588 | return H323_ERROR_BOUND; |
589 | bmp2_len = get_bits(bs, b: 7) + 1; |
590 | if (nf_h323_error_boundary(bs, bytes: 0, bits: bmp2_len)) |
591 | return H323_ERROR_BOUND; |
592 | bmp2 = get_bitmap(bs, b: 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, bytes: 2, bits: 0)) |
603 | return H323_ERROR_BOUND; |
604 | len = get_len(bs); |
605 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 2, bits: 0)) |
621 | return H323_ERROR_BOUND; |
622 | len = get_len(bs); |
623 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 1, bits: 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, bytes: 2, bits: 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, bytes: 2, bits: 0)) |
676 | return H323_ERROR_BOUND; |
677 | count = get_len(bs); |
678 | break; |
679 | default: |
680 | if (nf_h323_error_boundary(bs, bytes: 0, bits: f->sz)) |
681 | return H323_ERROR_BOUND; |
682 | count = get_bits(bs, b: 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, bytes: 2, bits: 0)) |
702 | return H323_ERROR_BOUND; |
703 | len = get_len(bs); |
704 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: 0, bits: 1)) |
755 | return H323_ERROR_BOUND; |
756 | if ((f->attr & EXT) && get_bit(bs)) { |
757 | ext = 1; |
758 | if (nf_h323_error_boundary(bs, bytes: 0, bits: 7)) |
759 | return H323_ERROR_BOUND; |
760 | type = get_bits(bs, b: 7) + f->lb; |
761 | } else { |
762 | ext = 0; |
763 | if (nf_h323_error_boundary(bs, bytes: 0, bits: f->sz)) |
764 | return H323_ERROR_BOUND; |
765 | type = get_bits(bs, b: 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, bytes: 2, bits: 0)) |
778 | return H323_ERROR_BOUND; |
779 | len = get_len(bs); |
780 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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, bytes: len, bits: 0)) |
796 | return H323_ERROR_BOUND; |
797 | len = get_len(bs); |
798 | if (nf_h323_error_boundary(bs, bytes: len, bits: 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: &bs, f: &ras_message, base: (char *) ras, level: 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: &bs, f: &h323_userinformation, base: (char *) uuie, level: 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: &bs, f: &multimediasystemcontrolmessage, |
868 | base: (char *) mscm, level: 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, beg: p, sz: len, |
922 | uuie: &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 | |