]> The Tcpdump Group git mirrors - tcpdump/blob - print-forces.c
projects / tcpdump / blob


673aab9a248d5ae211caea2d8d57a8105c4e124d
[tcpdump] / print-forces.c
1 /*
2 * Redistribution and use in source and binary forms, with or without
3 * modification, are permitted provided that: (1) source code
4 * distributions retain the above copyright notice and this paragraph
5 * in its entirety, and (2) distributions including binary code include
6 * the above copyright notice and this paragraph in its entirety in
7 * the documentation or other materials provided with the distribution.
8 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
9 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
10 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
11 * FOR A PARTICULAR PURPOSE.
12 *
13 * Copyright (c) 2009 Mojatatu Networks, Inc
14 *
15 */
16
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #include <tcpdump-stdinc.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25
26 #include "interface.h"
27 #include "extract.h"
28
29 #include "forces.h"
30
31 #define RESLEN 4
32
33 int
34 prestlv_print(register const u_char * pptr, register u_int len,
35 u_int16_t op_msk _U_, int indent)
36 {
37 const struct forces_tlv *tlv = (struct forces_tlv *)pptr;
38 register const u_char *tdp = (u_char *) TLV_DATA(tlv);
39 struct res_val *r = (struct res_val *)tdp;
40 u_int dlen;
41
42 /*
43 * pdatacnt_print() has ensured that len (the TLV length)
44 * >= TLV_HDRL.
45 */
46 dlen = len - TLV_HDRL;
47 if (dlen != RESLEN) {
48 printf("illegal RESULT-TLV: %d bytes!\n", dlen);
49 return -1;
50 }
51
52 TCHECK(*r);
53 if (r->result >= 0x18 && r->result <= 0xFE) {
54 printf("illegal reserved result code: 0x%x!\n", r->result);
55 return -1;
56 }
57
58 if (vflag >= 3) {
59 char *ib = indent_pr(indent, 0);
60 printf("%s Result: %s (code 0x%x)\n", ib,
61 tok2str(ForCES_errs, NULL, r->result), r->result);
62 }
63 return 0;
64
65 trunc:
66 fputs("[|forces]", stdout);
67 return -1;
68 }
69
70 int
71 fdatatlv_print(register const u_char * pptr, register u_int len,
72 u_int16_t op_msk _U_, int indent)
73 {
74 const struct forces_tlv *tlv = (struct forces_tlv *)pptr;
75 u_int rlen;
76 register const u_char *tdp = (u_char *) TLV_DATA(tlv);
77 u_int16_t type;
78
79 /*
80 * pdatacnt_print() or pkeyitlv_print() has ensured that len
81 * (the TLV length) >= TLV_HDRL.
82 */
83 rlen = len - TLV_HDRL;
84 TCHECK(*tlv);
85 type = EXTRACT_16BITS(&tlv->type);
86 if (type != F_TLV_FULD) {
87 printf("Error: expecting FULLDATA!\n");
88 return -1;
89 }
90
91 if (vflag >= 3) {
92 char *ib = indent_pr(indent + 2, 1);
93 printf("%s[", &ib[1]);
94 hex_print_with_offset(ib, tdp, rlen, 0);
95 printf("\n%s]\n", &ib[1]);
96 }
97 return 0;
98
99 trunc:
100 fputs("[|forces]", stdout);
101 return -1;
102 }
103
104 int
105 sdatailv_print(register const u_char * pptr, register u_int len,
106 u_int16_t op_msk _U_, int indent)
107 {
108 u_int rlen;
109 const struct forces_ilv *ilv = (struct forces_ilv *)pptr;
110 int invilv;
111
112 if (len < ILV_HDRL) {
113 printf("Error: BAD SPARSEDATA-TLV!\n");
114 return -1;
115 }
116 rlen = len;
117 indent += 1;
118 while (rlen != 0) {
119 //printf("Jamal - outstanding length <%d>\n", rlen);
120 char *ib = indent_pr(indent, 1);
121 register const u_char *tdp = (u_char *) ILV_DATA(ilv);
122 TCHECK(*ilv);
123 invilv = ilv_valid(ilv, rlen);
124 if (invilv) {
125 printf("%s[", &ib[1]);
126 hex_print_with_offset(ib, tdp, rlen, 0);
127 printf("\n%s]\n", &ib[1]);
128 return -1;
129 }
130 if (vflag >= 3) {
131 int ilvl = EXTRACT_32BITS(&ilv->length);
132 printf("\n%s ILV: type %x length %d\n", &ib[1],
133 EXTRACT_32BITS(&ilv->type), ilvl);
134 hex_print_with_offset("\t\t[", tdp, ilvl-ILV_HDRL, 0);
135 }
136
137 ilv = GO_NXT_ILV(ilv, rlen);
138 }
139
140 return 0;
141
142 trunc:
143 fputs("[|forces]", stdout);
144 return -1;
145 }
146
147 int
148 sdatatlv_print(register const u_char * pptr, register u_int len,
149 u_int16_t op_msk, int indent)
150 {
151 const struct forces_tlv *tlv = (struct forces_tlv *)pptr;
152 u_int rlen;
153 register const u_char *tdp = (u_char *) TLV_DATA(tlv);
154 u_int16_t type;
155
156 /*
157 * pdatacnt_print() has ensured that len (the TLV length)
158 * >= TLV_HDRL.
159 */
160 rlen = len - TLV_HDRL;
161 TCHECK(*tlv);
162 type = EXTRACT_16BITS(&tlv->type);
163 if (type != F_TLV_SPAD) {
164 printf("Error: expecting SPARSEDATA!\n");
165 return -1;
166 }
167
168 return sdatailv_print(tdp, rlen, op_msk, indent);
169
170 trunc:
171 fputs("[|forces]", stdout);
172 return -1;
173 }
174
175 int
176 pkeyitlv_print(register const u_char * pptr, register u_int len,
177 u_int16_t op_msk, int indent)
178 {
179 const struct forces_tlv *tlv = (struct forces_tlv *)pptr;
180 register const u_char *tdp = (u_char *) TLV_DATA(tlv);
181 register const u_char *dp = tdp + 4;
182 const struct forces_tlv *kdtlv = (struct forces_tlv *)dp;
183 u_int32_t id;
184 char *ib = indent_pr(indent, 0);
185 u_int16_t type, tll;
186 int invtlv;
187
188 TCHECK(*tdp);
189 id = EXTRACT_32BITS(tdp);
190 printf("%sKeyinfo: Key 0x%x\n", ib, id);
191 TCHECK(*kdtlv);
192 type = EXTRACT_16BITS(&kdtlv->type);
193 invtlv = tlv_valid(kdtlv, len);
194
195 if (invtlv) {
196 printf("%s TLV type 0x%x len %d\n",
197 tok2str(ForCES_TLV_err, NULL, invtlv), type,
198 EXTRACT_16BITS(&kdtlv->length));
199 return -1;
200 }
201 /*
202 * At this point, tlv_valid() has ensured that the TLV
203 * length is large enough but not too large (it doesn't
204 * go past the end of the containing TLV).
205 */
206 tll = EXTRACT_16BITS(&kdtlv->length);
207 dp = (u_char *) TLV_DATA(kdtlv);
208 return fdatatlv_print(dp, tll, op_msk, indent);
209
210 trunc:
211 fputs("[|forces]", stdout);
212 return -1;
213 }
214
215 int
216 pdatacnt_print(register const u_char * pptr, register u_int len,
217 u_int16_t IDcnt, u_int16_t op_msk, int indent)
218 {
219 u_int i;
220 u_int32_t id;
221 char *ib = indent_pr(indent, 0);
222
223 for (i = 0; i < IDcnt; i++) {
224 TCHECK2(*pptr, 4);
225 if (len < 4)
226 goto trunc;
227 id = EXTRACT_32BITS(pptr);
228 if (vflag >= 3)
229 printf("%s ID#%02u: %d\n", ib, i + 1, id);
230 len -= 4;
231 pptr += 4;
232 }
233 if (len) {
234 const struct forces_tlv *pdtlv = (struct forces_tlv *)pptr;
235 u_int16_t type;
236 u_int16_t tll;
237 int pad = 0;
238 u_int aln;
239 int invtlv;
240
241 TCHECK(*pdtlv);
242 type = EXTRACT_16BITS(&pdtlv->type);
243 invtlv = tlv_valid(pdtlv, len);
244 if (invtlv) {
245 printf
246 ("%s Outstanding bytes %d for TLV type 0x%x TLV len %d\n",
247 tok2str(ForCES_TLV_err, NULL, invtlv), len, type,
248 EXTRACT_16BITS(&pdtlv->length));
249 goto pd_err;
250 }
251 /*
252 * At this point, tlv_valid() has ensured that the TLV
253 * length is large enough but not too large (it doesn't
254 * go past the end of the containing TLV).
255 */
256 tll = EXTRACT_16BITS(&pdtlv->length) - TLV_HDRL;
257 aln = F_ALN_LEN(EXTRACT_16BITS(&pdtlv->length));
258 if (aln > EXTRACT_16BITS(&pdtlv->length)) {
259 if (aln > len) {
260 printf
261 ("Invalid padded pathdata TLV type 0x%x len %d missing %d pad bytes\n",
262 type, EXTRACT_16BITS(&pdtlv->length), aln - len);
263 } else {
264 pad = aln - EXTRACT_16BITS(&pdtlv->length);
265 }
266 }
267 if (pd_valid(type)) {
268 const struct pdata_ops *ops = get_forces_pd(type);
269
270 if (vflag >= 3 && ops->v != F_TLV_PDAT) {
271 if (pad)
272 printf
273 ("%s %s (Length %d DataLen %d pad %d Bytes)\n",
274 ib, ops->s, EXTRACT_16BITS(&pdtlv->length),
275 tll, pad);
276 else
277 printf
278 ("%s %s (Length %d DataLen %d Bytes)\n",
279 ib, ops->s, EXTRACT_16BITS(&pdtlv->length),
280 tll);
281 }
282
283 chk_op_type(type, op_msk, ops->op_msk);
284
285 if (ops->print((const u_char *)pdtlv,
286 tll + pad + TLV_HDRL, op_msk,
287 indent + 2) == -1)
288 return -1;
289 len -= (TLV_HDRL + pad + tll);
290 } else {
291 printf("Invalid path data content type 0x%x len %d\n",
292 type, EXTRACT_16BITS(&pdtlv->length));
293 pd_err:
294 if (EXTRACT_16BITS(&pdtlv->length)) {
295 hex_print_with_offset("Bad Data val\n\t [",
296 pptr, len, 0);
297 printf("]\n");
298
299 return -1;
300 }
301 }
302 }
303 return len;
304
305 trunc:
306 fputs("[|forces]", stdout);
307 return -1;
308 }
309
310 int
311 pdata_print(register const u_char * pptr, register u_int len,
312 u_int16_t op_msk, int indent)
313 {
314 const struct pathdata_h *pdh = (struct pathdata_h *)pptr;
315 char *ib = indent_pr(indent, 0);
316 u_int minsize = 0;
317 int more_pd = 0;
318 u_int16_t idcnt = 0;
319
320 TCHECK(*pdh);
321 if (len < sizeof(struct pathdata_h))
322 goto trunc;
323 if (vflag >= 3) {
324 printf("\n%sPathdata: Flags 0x%x ID count %d\n",
325 ib, EXTRACT_16BITS(&pdh->pflags), EXTRACT_16BITS(&pdh->pIDcnt));
326 }
327
328 if (EXTRACT_16BITS(&pdh->pflags) & F_SELKEY) {
329 op_msk |= B_KEYIN;
330 }
331 pptr += sizeof(struct pathdata_h);
332 len -= sizeof(struct pathdata_h);
333 idcnt = EXTRACT_16BITS(&pdh->pIDcnt);
334 minsize = idcnt * 4;
335 if (len < minsize) {
336 printf("\t\t\ttruncated IDs expected %uB got %uB\n", minsize,
337 len);
338 hex_print_with_offset("\t\t\tID Data[", pptr, len, 0);
339 printf("]\n");
340 return -1;
341 }
342 more_pd = pdatacnt_print(pptr, len, idcnt, op_msk, indent);
343 if (more_pd > 0) {
344 int consumed = len - more_pd;
345 pptr += consumed;
346 len = more_pd;
347 /* XXX: Argh, recurse some more */
348 return recpdoptlv_print(pptr, len, op_msk, indent+1);
349 } else
350 return 0;
351
352 trunc:
353 fputs("[|forces]", stdout);
354 return -1;
355 }
356
357 int
358 genoptlv_print(register const u_char * pptr, register u_int len,
359 u_int16_t op_msk, int indent)
360 {
361 const struct forces_tlv *pdtlv = (struct forces_tlv *)pptr;
362 u_int16_t type;
363 int tll;
364 int invtlv;
365 char *ib = indent_pr(indent, 0);
366
367 TCHECK(*pdtlv);
368 type = EXTRACT_16BITS(&pdtlv->type);
369 tll = EXTRACT_16BITS(&pdtlv->length) - TLV_HDRL;
370 invtlv = tlv_valid(pdtlv, len);
371 printf("genoptlvprint - %s TLV type 0x%x len %d\n",
372 tok2str(ForCES_TLV, NULL, type), type, EXTRACT_16BITS(&pdtlv->length));
373 if (!invtlv) {
374 /*
375 * At this point, tlv_valid() has ensured that the TLV
376 * length is large enough but not too large (it doesn't
377 * go past the end of the containing TLV).
378 */
379 register const u_char *dp = (u_char *) TLV_DATA(pdtlv);
380 if (!ttlv_valid(type)) {
381 printf("%s TLV type 0x%x len %d\n",
382 tok2str(ForCES_TLV_err, NULL, invtlv), type,
383 EXTRACT_16BITS(&pdtlv->length));
384 return -1;
385 }
386 if (vflag >= 3)
387 printf("%s%s, length %d (data length %d Bytes)",
388 ib, tok2str(ForCES_TLV, NULL, type),
389 EXTRACT_16BITS(&pdtlv->length), tll);
390
391 return pdata_print(dp, tll, op_msk, indent + 1);
392 } else {
393 printf("\t\t\tInvalid ForCES TLV type=%x", type);
394 return -1;
395 }
396
397 trunc:
398 fputs("[|forces]", stdout);
399 return -1;
400 }
401
402 int
403 recpdoptlv_print(register const u_char * pptr, register u_int len,
404 u_int16_t op_msk, int indent)
405 {
406 const struct forces_tlv *pdtlv = (struct forces_tlv *)pptr;
407 int tll;
408 int invtlv;
409 u_int16_t type;
410 register const u_char *dp;
411 char *ib;
412
413 while (len != 0) {
414 TCHECK(*pdtlv);
415 invtlv = tlv_valid(pdtlv, len);
416 if (invtlv) {
417 break;
418 }
419
420 /*
421 * At this point, tlv_valid() has ensured that the TLV
422 * length is large enough but not too large (it doesn't
423 * go past the end of the containing TLV).
424 */
425 ib = indent_pr(indent, 0);
426 type = EXTRACT_16BITS(&pdtlv->type);
427 dp = (u_char *) TLV_DATA(pdtlv);
428 tll = EXTRACT_16BITS(&pdtlv->length) - TLV_HDRL;
429
430 if (vflag >= 3)
431 printf
432 ("%s%s, length %d (data encapsulated %d Bytes)",
433 ib, tok2str(ForCES_TLV, NULL, type),
434 EXTRACT_16BITS(&pdtlv->length),
435 EXTRACT_16BITS(&pdtlv->length) - TLV_HDRL);
436
437 if (pdata_print(dp, tll, op_msk, indent + 1) == -1)
438 return -1;
439 pdtlv = GO_NXT_TLV(pdtlv, len);
440 }
441
442 if (len) {
443 printf
444 ("\n\t\tMessy PATHDATA TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
445 EXTRACT_16BITS(&pdtlv->type), len - EXTRACT_16BITS(&pdtlv->length));
446 return -1;
447 }
448
449 return 0;
450
451 trunc:
452 fputs("[|forces]", stdout);
453 return -1;
454 }
455
456 int
457 invoptlv_print(register const u_char * pptr, register u_int len,
458 u_int16_t op_msk _U_, int indent)
459 {
460 char *ib = indent_pr(indent, 1);
461
462 if (vflag >= 3) {
463 printf("%sData[", &ib[1]);
464 hex_print_with_offset(ib, pptr, len, 0);
465 printf("%s]\n", ib);
466 }
467 return -1;
468 }
469
470 int otlv_print(const struct forces_tlv *otlv, u_int16_t op_msk _U_, int indent)
471 {
472 int rc = 0;
473 register const u_char *dp = (u_char *) TLV_DATA(otlv);
474 u_int16_t type;
475 int tll;
476 char *ib = indent_pr(indent, 0);
477 const struct optlv_h *ops;
478
479 /*
480 * lfbselect_print() has ensured that EXTRACT_16BITS(&otlv->length)
481 * >= TLV_HDRL.
482 */
483 TCHECK(*otlv);
484 type = EXTRACT_16BITS(&otlv->type);
485 tll = EXTRACT_16BITS(&otlv->length) - TLV_HDRL;
486 ops = get_forces_optlv_h(type);
487 if (vflag >= 3) {
488 printf("%sOper TLV %s(0x%x) length %d\n", ib, ops->s, type,
489 EXTRACT_16BITS(&otlv->length));
490 }
491 /* empty TLVs like COMMIT and TRCOMMIT are empty, we stop here .. */
492 if (!ops->flags & ZERO_TTLV) {
493 if (tll != 0) /* instead of "if (tll)" - for readability .. */
494 printf("%s: Illegal - MUST be empty\n", ops->s);
495 return rc;
496 }
497 /* rest of ops must at least have 12B {pathinfo} */
498 if (tll < OP_MIN_SIZ) {
499 printf("\t\tOper TLV %s(0x%x) length %d\n", ops->s, type,
500 EXTRACT_16BITS(&otlv->length));
501 printf("\t\tTruncated data size %d minimum required %d\n", tll,
502 OP_MIN_SIZ);
503 return invoptlv_print(dp, tll, ops->op_msk, indent);
504
505 }
506
507 rc = ops->print(dp, tll, ops->op_msk, indent + 1);
508 return rc;
509
510 trunc:
511 fputs("[|forces]", stdout);
512 return -1;
513 }
514
515 #define ASTDLN 4
516 #define ASTMCD 255
517 int
518 asttlv_print(register const u_char * pptr, register u_int len,
519 u_int16_t op_msk _U_, int indent)
520 {
521 u_int32_t rescode;
522 u_int dlen;
523 char *ib = indent_pr(indent, 0);
524
525 /*
526 * forces_type_print() has ensured that len (the TLV length)
527 * >= TLV_HDRL.
528 */
529 dlen = len - TLV_HDRL;
530 if (dlen != ASTDLN) {
531 printf("illegal ASTresult-TLV: %d bytes!\n", dlen);
532 return -1;
533 }
534 TCHECK2(*pptr, 4);
535 rescode = EXTRACT_32BITS(pptr);
536 if (rescode > ASTMCD) {
537 printf("illegal ASTresult result code: %d!\n", rescode);
538 return -1;
539 }
540
541 if (vflag >= 3) {
542 printf("Teardown reason:\n%s", ib);
543 switch (rescode) {
544 case 0:
545 printf("Normal Teardown");
546 break;
547 case 1:
548 printf("Loss of Heartbeats");
549 break;
550 case 2:
551 printf("Out of bandwidth");
552 break;
553 case 3:
554 printf("Out of Memory");
555 break;
556 case 4:
557 printf("Application Crash");
558 break;
559 default:
560 printf("Unknown Teardown reason");
561 break;
562 }
563 printf("(%x)\n%s", rescode, ib);
564 }
565 return 0;
566
567 trunc:
568 fputs("[|forces]", stdout);
569 return -1;
570 }
571
572 #define ASRDLN 4
573 #define ASRMCD 3
574 int
575 asrtlv_print(register const u_char * pptr, register u_int len,
576 u_int16_t op_msk _U_, int indent)
577 {
578 u_int32_t rescode;
579 u_int dlen;
580 char *ib = indent_pr(indent, 0);
581
582 /*
583 * forces_type_print() has ensured that len (the TLV length)
584 * >= TLV_HDRL.
585 */
586 dlen = len - TLV_HDRL;
587 if (dlen != ASRDLN) { /* id, instance, oper tlv */
588 printf("illegal ASRresult-TLV: %d bytes!\n", dlen);
589 return -1;
590 }
591 TCHECK2(*pptr, 4);
592 rescode = EXTRACT_32BITS(pptr);
593
594 if (rescode > ASRMCD) {
595 printf("illegal ASRresult result code: %d!\n", rescode);
596 return -1;
597 }
598
599 if (vflag >= 3) {
600 printf("\n%s", ib);
601 switch (rescode) {
602 case 0:
603 printf("Success ");
604 break;
605 case 1:
606 printf("FE ID invalid ");
607 break;
608 case 2:
609 printf("permission denied ");
610 break;
611 default:
612 printf("Unknown ");
613 break;
614 }
615 printf("(%x)\n%s", rescode, ib);
616 }
617 return 0;
618
619 trunc:
620 fputs("[|forces]", stdout);
621 return -1;
622 }
623
624 /*
625 * XXX - not used.
626 */
627 int
628 gentltlv_print(register const u_char * pptr _U_, register u_int len,
629 u_int16_t op_msk _U_, int indent _U_)
630 {
631 u_int dlen = len - TLV_HDRL;
632
633 if (dlen < 4) { /* at least 32 bits must exist */
634 printf("truncated TLV: %d bytes missing! ", 4 - dlen);
635 return -1;
636 }
637 return 0;
638 }
639
640 #define RD_MIN 8
641
642 int
643 print_metailv(register const u_char * pptr, register u_int len,
644 u_int16_t op_msk _U_, int indent)
645 {
646 u_int rlen;
647 u_int plen;
648 char *ib = indent_pr(indent, 0);
649 /* XXX: check header length */
650 const struct forces_ilv *ilv = (struct forces_ilv *)pptr;
651
652 /*
653 * print_metatlv() has ensured that len (what remains in the
654 * ILV) >= ILV_HDRL.
655 */
656 rlen = EXTRACT_32BITS(&ilv->length) - ILV_HDRL;
657 TCHECK(*ilv);
658 printf("%sMetaID 0x%x length %d\n", ib, EXTRACT_32BITS(&ilv->type),
659 EXTRACT_32BITS(&ilv->length));
660 if (vflag >= 3) {
661 hex_print_with_offset("\t\t[", ILV_DATA(ilv), rlen, 0);
662 printf(" ]\n");
663 }
664 return 0;
665
666 trunc:
667 fputs("[|forces]", stdout);
668 return -1;
669 }
670
671 int
672 print_metatlv(register const u_char * pptr, register u_int len,
673 u_int16_t op_msk _U_, int indent)
674 {
675 u_int dlen;
676 char *ib = indent_pr(indent, 0);
677 u_int rlen;
678 const struct forces_ilv *ilv = (struct forces_ilv *)pptr;
679 int invilv;
680
681 /*
682 * redirect_print() has ensured that len (what remains in the
683 * TLV) >= TLV_HDRL.
684 */
685 dlen = len - TLV_HDRL;
686 rlen = dlen;
687 printf("\n%s METADATA length %d \n", ib, rlen);
688 while (rlen != 0) {
689 TCHECK(*ilv);
690 invilv = ilv_valid(ilv, rlen);
691 if (invilv) {
692 break;
693 }
694
695 /*
696 * At this point, ilv_valid() has ensured that the ILV
697 * length is large enough but not too large (it doesn't
698 * go past the end of the containing TLV).
699 */
700 print_metailv((u_char *) ilv, rlen, 0, indent + 1);
701 ilv = GO_NXT_ILV(ilv, rlen);
702 }
703
704 return 0;
705
706 trunc:
707 fputs("[|forces]", stdout);
708 return -1;
709 }
710
711
712 int
713 print_reddata(register const u_char * pptr, register u_int len,
714 u_int16_t op_msk _U_, int indent _U_)
715 {
716 u_int dlen;
717 char *ib = indent_pr(indent, 0);
718 u_int rlen;
719 const struct forces_ilv *ilv = (struct forces_ilv *)pptr;
720 int invilv;
721
722 dlen = len - TLV_HDRL;
723 rlen = dlen;
724 printf("\n%s Redirect Data length %d \n", ib, rlen);
725
726 if (vflag >= 3) {
727 printf("\t\t[");
728 hex_print_with_offset("\n\t\t", pptr, rlen, 0);
729 printf("\n\t\t]");
730 }
731
732 return 0;
733 }
734
735 int
736 redirect_print(register const u_char * pptr, register u_int len,
737 u_int16_t op_msk _U_, int indent)
738 {
739 const struct forces_tlv *tlv = (struct forces_tlv *)pptr;
740 u_int dlen;
741 u_int rlen;
742 int invtlv;
743
744 /*
745 * forces_type_print() has ensured that len (the TLV length)
746 * >= TLV_HDRL.
747 */
748 dlen = len - TLV_HDRL;
749 if (dlen <= RD_MIN) {
750 printf("\n\t\ttruncated Redirect TLV: %d bytes missing! ",
751 RD_MIN - dlen);
752 return -1;
753 }
754
755 rlen = dlen;
756 indent += 1;
757 while (rlen != 0) {
758 TCHECK(*tlv);
759 invtlv = tlv_valid(tlv, rlen);
760 if (invtlv) {
761 printf("Bad Redirect data\n");
762 break;
763 }
764
765 /*
766 * At this point, tlv_valid() has ensured that the TLV
767 * length is large enough but not too large (it doesn't
768 * go past the end of the containing TLV).
769 */
770 if (EXTRACT_16BITS(&tlv->type) == F_TLV_METD) {
771 print_metatlv((u_char *) TLV_DATA(tlv),
772 EXTRACT_16BITS(&tlv->length), 0, indent);
773 } else if ((EXTRACT_16BITS(&tlv->type) == F_TLV_REDD)) {
774 print_reddata((u_char *) TLV_DATA(tlv),
775 EXTRACT_16BITS(&tlv->length), 0, indent);
776 } else {
777 printf("Unknown REDIRECT TLV 0x%x len %d\n",
778 EXTRACT_16BITS(&tlv->type),
779 EXTRACT_16BITS(&tlv->length));
780 }
781
782 tlv = GO_NXT_TLV(tlv, rlen);
783 }
784
785 if (rlen) {
786 printf
787 ("\n\t\tMessy Redirect TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
788 EXTRACT_16BITS(&tlv->type),
789 rlen - EXTRACT_16BITS(&tlv->length));
790 return -1;
791 }
792
793 return 0;
794
795 trunc:
796 fputs("[|forces]", stdout);
797 return -1;
798 }
799
800 #define OP_OFF 8
801 #define OP_MIN 12
802
803 int
804 lfbselect_print(register const u_char * pptr, register u_int len,
805 u_int16_t op_msk, int indent)
806 {
807 const struct forces_lfbsh *lfbs;
808 const struct forces_tlv *otlv;
809 char *ib = indent_pr(indent, 0);
810 u_int dlen;
811 u_int rlen;
812 int invtlv;
813
814 /*
815 * forces_type_print() has ensured that len (the TLV length)
816 * >= TLV_HDRL.
817 */
818 dlen = len - TLV_HDRL;
819 if (dlen <= OP_MIN) { /* id, instance, oper tlv header .. */
820 printf("\n\t\ttruncated lfb selector: %d bytes missing! ",
821 OP_MIN - dlen);
822 return -1;
823 }
824
825 /*
826 * At this point, we know that dlen > OP_MIN; OP_OFF < OP_MIN, so
827 * we also know that it's > OP_OFF.
828 */
829 rlen = dlen - OP_OFF;
830
831 lfbs = (const struct forces_lfbsh *)pptr;
832 TCHECK(*lfbs);
833 if (vflag >= 3) {
834 printf("\n%s%s(Classid %x) instance %x\n",
835 ib, tok2str(ForCES_LFBs, NULL, EXTRACT_32BITS(&lfbs->class)),
836 EXTRACT_32BITS(&lfbs->class),
837 EXTRACT_32BITS(&lfbs->instance));
838 }
839
840 otlv = (struct forces_tlv *)(lfbs + 1);
841
842 indent += 1;
843 while (rlen != 0) {
844 TCHECK(*otlv);
845 invtlv = tlv_valid(otlv, rlen);
846 if (invtlv)
847 break;
848
849 /*
850 * At this point, tlv_valid() has ensured that the TLV
851 * length is large enough but not too large (it doesn't
852 * go past the end of the containing TLV).
853 */
854 if (op_valid(EXTRACT_16BITS(&otlv->type), op_msk)) {
855 otlv_print(otlv, 0, indent);
856 } else {
857 if (vflag < 3)
858 printf("\n");
859 printf
860 ("\t\tINValid oper-TLV type 0x%x length %d for this ForCES message\n",
861 EXTRACT_16BITS(&otlv->type), EXTRACT_16BITS(&otlv->length));
862 invoptlv_print((u_char *)otlv, rlen, 0, indent);
863 }
864 otlv = GO_NXT_TLV(otlv, rlen);
865 }
866
867 if (rlen) {
868 printf
869 ("\n\t\tMessy oper TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
870 EXTRACT_16BITS(&otlv->type), rlen - EXTRACT_16BITS(&otlv->length));
871 return -1;
872 }
873
874 return 0;
875
876 trunc:
877 fputs("[|forces]", stdout);
878 return -1;
879 }
880
881 int
882 forces_type_print(register const u_char * pptr, const struct forcesh *fhdr _U_,
883 register u_int mlen, const struct tom_h *tops)
884 {
885 const struct forces_tlv *tltlv;
886 u_int rlen;
887 int invtlv;
888 int rc = 0;
889 int ttlv = 0;
890
891 /*
892 * forces_print() has already checked that mlen >= ForCES_HDRL
893 * by calling ForCES_HLN_VALID().
894 */
895 rlen = mlen - ForCES_HDRL;
896
897 if (rlen > TLV_HLN) {
898 if (tops->flags & ZERO_TTLV) {
899 printf("<0x%x>Illegal Top level TLV!\n", tops->flags);
900 return -1;
901 }
902 } else {
903 if (tops->flags & ZERO_MORE_TTLV)
904 return 0;
905 if (tops->flags & ONE_MORE_TTLV) {
906 printf("\tTop level TLV Data missing!\n");
907 return -1;
908 }
909 }
910
911 if (tops->flags & ZERO_TTLV) {
912 return 0;
913 }
914
915 ttlv = tops->flags >> 4;
916 tltlv = GET_TOP_TLV(pptr);
917
918 /*XXX: 15 top level tlvs will probably be fine
919 You are nuts if you send more ;-> */
920 while (rlen != 0) {
921 TCHECK(*tltlv);
922 invtlv = tlv_valid(tltlv, rlen);
923 if (invtlv)
924 break;
925
926 /*
927 * At this point, tlv_valid() has ensured that the TLV
928 * length is large enough but not too large (it doesn't
929 * go past the end of the packet).
930 */
931 if (!ttlv_valid(EXTRACT_16BITS(&tltlv->type))) {
932 printf("\n\tInvalid ForCES Top TLV type=0x%x",
933 EXTRACT_16BITS(&tltlv->type));
934 return -1;
935 }
936
937 if (vflag >= 3)
938 printf("\t%s, length %d (data length %d Bytes)",
939 tok2str(ForCES_TLV, NULL, EXTRACT_16BITS(&tltlv->type)),
940 EXTRACT_16BITS(&tltlv->length),
941 EXTRACT_16BITS(&tltlv->length) - TLV_HDRL);
942
943 rc = tops->print((u_char *) TLV_DATA(tltlv),
944 EXTRACT_16BITS(&tltlv->length), tops->op_msk, 9);
945 if (rc < 0) {
946 return -1;
947 }
948 tltlv = GO_NXT_TLV(tltlv, rlen);
949 ttlv--;
950 if (ttlv <= 0)
951 break;
952 }
953 /*
954 * XXX - if ttlv != 0, does that mean that the packet was too
955 * short, and didn't have *enough* TLVs in it?
956 */
957 if (rlen) {
958 printf("\tMess TopTLV header: min %u, total %d advertised %d ",
959 TLV_HDRL, rlen, EXTRACT_16BITS(&tltlv->length));
960 return -1;
961 }
962
963 return 0;
964
965 trunc:
966 fputs("[|forces]", stdout);
967 return -1;
968 }
969
970 void forces_print(register const u_char * pptr, register u_int len)
971 {
972 const struct forcesh *fhdr;
973 u_int mlen;
974 u_int32_t flg_raw;
975 const struct tom_h *tops;
976 int rc = 0;
977
978 fhdr = (const struct forcesh *)pptr;
979 TCHECK(*fhdr);
980 if (!tom_valid(fhdr->fm_tom)) {
981 printf("Invalid ForCES message type %d\n", fhdr->fm_tom);
982 goto error;
983 }
984
985 mlen = ForCES_BLN(fhdr);
986
987 tops = get_forces_tom(fhdr->fm_tom);
988 if (tops->v == TOM_RSVD) {
989 printf("\n\tUnknown ForCES message type=0x%x", fhdr->fm_tom);
990 goto error;
991 }
992
993 printf("\n\tForCES %s ", tops->s);
994 if (!ForCES_HLN_VALID(mlen, len)) {
995 printf
996 ("Illegal ForCES pkt len - min %u, total recvd %d, advertised %d ",
997 ForCES_HDRL, len, ForCES_BLN(fhdr));
998 goto error;
999 }
1000
1001 TCHECK2(*(pptr + 20), 4);
1002 flg_raw = EXTRACT_32BITS(pptr + 20);
1003 if (vflag >= 1) {
1004 printf("\n\tForCES Version %d len %uB flags 0x%08x ",
1005 ForCES_V(fhdr), mlen, flg_raw);
1006 printf("\n\tSrcID 0x%x(%s) DstID 0x%x(%s) Correlator 0x%" PRIx64,
1007 ForCES_SID(fhdr), ForCES_node(ForCES_SID(fhdr)),
1008 ForCES_DID(fhdr), ForCES_node(ForCES_DID(fhdr)),
1009 EXTRACT_64BITS(fhdr->fm_cor));
1010
1011 }
1012 if (vflag >= 2) {
1013 printf
1014 ("\n\tForCES flags:\n\t %s(0x%x), prio=%d, %s(0x%x),\n\t %s(0x%x), %s(0x%x)\n",
1015 ForCES_ACKp(ForCES_ACK(fhdr)), ForCES_ACK(fhdr),
1016 ForCES_PRI(fhdr),
1017 ForCES_EMp(ForCES_EM(fhdr)), ForCES_EM(fhdr),
1018 ForCES_ATp(ForCES_AT(fhdr)), ForCES_AT(fhdr),
1019 ForCES_TPp(ForCES_TP(fhdr)), ForCES_TP(fhdr));
1020 printf
1021 ("\t Extra flags: rsv(b5-7) 0x%x rsv(b13-31) 0x%x\n",
1022 ForCES_RS1(fhdr), ForCES_RS2(fhdr));
1023 }
1024 rc = forces_type_print(pptr, fhdr, mlen, tops);
1025 if (rc < 0) {
1026 error:
1027 hex_print_with_offset("\n\t[", pptr, len, 0);
1028 printf("\n\t]");
1029 return;
1030 }
1031
1032 if (vflag >= 4) {
1033 printf("\n\t Raw ForCES message\n\t [");
1034 hex_print_with_offset("\n\t ", pptr, len, 0);
1035 printf("\n\t ]");
1036 }
1037 printf("\n");
1038 return;
1039
1040 trunc:
1041 fputs("[|forces]", stdout);
1042 }
[mirror] the TCPdump network dissector