nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright (c) 1998-2006 The TCPDUMP project
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that: (1) source code
6 * distributions retain the above copyright notice and this paragraph
7 * in its entirety, and (2) distributions including binary code include
8 * the above copyright notice and this paragraph in its entirety in
9 * the documentation or other materials provided with the distribution.
10 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
11 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
12 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
13 * FOR A PARTICULAR PURPOSE.
14 *
15 * Support for the IEEE Connectivity Fault Management Protocols as per 802.1ag.
16 *
17 * Original code by Hannes Gredler (hannes@juniper.net)
18 */
19  
20 #define NETDISSECT_REWORKED
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24  
25 #include <tcpdump-stdinc.h>
26  
27 #include <stdio.h>
28  
29 #include "interface.h"
30 #include "extract.h"
31 #include "ether.h"
32 #include "addrtoname.h"
33 #include "oui.h"
34 #include "af.h"
35  
36 struct cfm_common_header_t {
37 uint8_t mdlevel_version;
38 uint8_t opcode;
39 uint8_t flags;
40 uint8_t first_tlv_offset;
41 };
42  
43 #define CFM_VERSION 0
44 #define CFM_EXTRACT_VERSION(x) (((x)&0x1f))
45 #define CFM_EXTRACT_MD_LEVEL(x) (((x)&0xe0)>>5)
46  
47 #define CFM_OPCODE_CCM 1
48 #define CFM_OPCODE_LBR 2
49 #define CFM_OPCODE_LBM 3
50 #define CFM_OPCODE_LTR 4
51 #define CFM_OPCODE_LTM 5
52  
53 static const struct tok cfm_opcode_values[] = {
54 { CFM_OPCODE_CCM, "Continouity Check Message"},
55 { CFM_OPCODE_LBR, "Loopback Reply"},
56 { CFM_OPCODE_LBM, "Loopback Message"},
57 { CFM_OPCODE_LTR, "Linktrace Reply"},
58 { CFM_OPCODE_LTM, "Linktrace Message"},
59 { 0, NULL}
60 };
61  
62 /*
63 * Message Formats.
64 */
65 struct cfm_ccm_t {
66 uint8_t sequence[4];
67 uint8_t ma_epi[2];
68 uint8_t md_nameformat;
69 uint8_t md_namelength;
70 uint8_t md_name[46]; /* md name and short ma name */
71 uint8_t reserved_itu[16];
72 uint8_t reserved[6];
73 };
74  
75 /*
76 * Timer Bases for the CCM Interval field.
77 * Expressed in units of seconds.
78 */
79 const float ccm_interval_base[8] = {0, 0.003333, 0.01, 0.1, 1, 10, 60, 600};
80 #define CCM_INTERVAL_MIN_MULTIPLIER 3.25
81 #define CCM_INTERVAL_MAX_MULTIPLIER 3.5
82  
83 #define CFM_CCM_RDI_FLAG 0x80
84 #define CFM_EXTRACT_CCM_INTERVAL(x) (((x)&0x07))
85  
86 #define CFM_CCM_MD_FORMAT_8021 0
87 #define CFM_CCM_MD_FORMAT_NONE 1
88 #define CFM_CCM_MD_FORMAT_DNS 2
89 #define CFM_CCM_MD_FORMAT_MAC 3
90 #define CFM_CCM_MD_FORMAT_CHAR 4
91  
92 static const struct tok cfm_md_nameformat_values[] = {
93 { CFM_CCM_MD_FORMAT_8021, "IEEE 802.1"},
94 { CFM_CCM_MD_FORMAT_NONE, "No MD Name present"},
95 { CFM_CCM_MD_FORMAT_DNS, "DNS string"},
96 { CFM_CCM_MD_FORMAT_MAC, "MAC + 16Bit Integer"},
97 { CFM_CCM_MD_FORMAT_CHAR, "Character string"},
98 { 0, NULL}
99 };
100  
101 #define CFM_CCM_MA_FORMAT_8021 0
102 #define CFM_CCM_MA_FORMAT_VID 1
103 #define CFM_CCM_MA_FORMAT_CHAR 2
104 #define CFM_CCM_MA_FORMAT_INT 3
105 #define CFM_CCM_MA_FORMAT_VPN 4
106  
107 static const struct tok cfm_ma_nameformat_values[] = {
108 { CFM_CCM_MA_FORMAT_8021, "IEEE 802.1"},
109 { CFM_CCM_MA_FORMAT_VID, "Primary VID"},
110 { CFM_CCM_MA_FORMAT_CHAR, "Character string"},
111 { CFM_CCM_MA_FORMAT_INT, "16Bit Integer"},
112 { CFM_CCM_MA_FORMAT_VPN, "RFC2685 VPN-ID"},
113 { 0, NULL}
114 };
115  
116 struct cfm_lbm_t {
117 uint8_t transaction_id[4];
118 uint8_t reserved[4];
119 };
120  
121 struct cfm_ltm_t {
122 uint8_t transaction_id[4];
123 uint8_t egress_id[8];
124 uint8_t ttl;
125 uint8_t original_mac[ETHER_ADDR_LEN];
126 uint8_t target_mac[ETHER_ADDR_LEN];
127 uint8_t reserved[3];
128 };
129  
130 static const struct tok cfm_ltm_flag_values[] = {
131 { 0x80, "Use Forwarding-DB only"},
132 { 0, NULL}
133 };
134  
135 struct cfm_ltr_t {
136 uint8_t transaction_id[4];
137 uint8_t last_egress_id[8];
138 uint8_t next_egress_id[8];
139 uint8_t ttl;
140 uint8_t replay_action;
141 uint8_t reserved[6];
142 };
143  
144 static const struct tok cfm_ltr_flag_values[] = {
145 { 0x80, "UseFDB Only"},
146 { 0x40, "FwdYes"},
147 { 0x20, "Terminal MEP"},
148 { 0, NULL}
149 };
150  
151 static const struct tok cfm_ltr_replay_action_values[] = {
152 { 1, "Exact Match"},
153 { 2, "Filtering DB"},
154 { 3, "MIP CCM DB"},
155 { 0, NULL}
156 };
157  
158  
159 #define CFM_TLV_END 0
160 #define CFM_TLV_SENDER_ID 1
161 #define CFM_TLV_PORT_STATUS 2
162 #define CFM_TLV_INTERFACE_STATUS 3
163 #define CFM_TLV_DATA 4
164 #define CFM_TLV_REPLY_INGRESS 5
165 #define CFM_TLV_REPLY_EGRESS 6
166 #define CFM_TLV_PRIVATE 31
167  
168 static const struct tok cfm_tlv_values[] = {
169 { CFM_TLV_END, "End"},
170 { CFM_TLV_SENDER_ID, "Sender ID"},
171 { CFM_TLV_PORT_STATUS, "Port status"},
172 { CFM_TLV_INTERFACE_STATUS, "Interface status"},
173 { CFM_TLV_DATA, "Data"},
174 { CFM_TLV_REPLY_INGRESS, "Reply Ingress"},
175 { CFM_TLV_REPLY_EGRESS, "Reply Egress"},
176 { CFM_TLV_PRIVATE, "Organization Specific"},
177 { 0, NULL}
178 };
179  
180 /*
181 * TLVs
182 */
183  
184 struct cfm_tlv_header_t {
185 uint8_t type;
186 uint8_t length[2];
187 };
188  
189 /* FIXME define TLV formats */
190  
191 static const struct tok cfm_tlv_port_status_values[] = {
192 { 1, "Blocked"},
193 { 2, "Up"},
194 { 0, NULL}
195 };
196  
197 static const struct tok cfm_tlv_interface_status_values[] = {
198 { 1, "Up"},
199 { 2, "Down"},
200 { 3, "Testing"},
201 { 5, "Dormant"},
202 { 6, "not present"},
203 { 7, "lower Layer down"},
204 { 0, NULL}
205 };
206  
207 #define CFM_CHASSIS_ID_CHASSIS_COMPONENT 1
208 #define CFM_CHASSIS_ID_INTERFACE_ALIAS 2
209 #define CFM_CHASSIS_ID_PORT_COMPONENT 3
210 #define CFM_CHASSIS_ID_MAC_ADDRESS 4
211 #define CFM_CHASSIS_ID_NETWORK_ADDRESS 5
212 #define CFM_CHASSIS_ID_INTERFACE_NAME 6
213 #define CFM_CHASSIS_ID_LOCAL 7
214  
215 static const struct tok cfm_tlv_senderid_chassisid_values[] = {
216 { 0, "Reserved"},
217 { CFM_CHASSIS_ID_CHASSIS_COMPONENT, "Chassis component"},
218 { CFM_CHASSIS_ID_INTERFACE_ALIAS, "Interface alias"},
219 { CFM_CHASSIS_ID_PORT_COMPONENT, "Port component"},
220 { CFM_CHASSIS_ID_MAC_ADDRESS, "MAC address"},
221 { CFM_CHASSIS_ID_NETWORK_ADDRESS, "Network address"},
222 { CFM_CHASSIS_ID_INTERFACE_NAME, "Interface name"},
223 { CFM_CHASSIS_ID_LOCAL, "Locally assigned"},
224 { 0, NULL}
225 };
226  
227  
228 static int
229 cfm_mgmt_addr_print(netdissect_options *ndo,
230 register const u_char *tptr)
231 {
232 u_int mgmt_addr_type;
233 u_int hexdump = FALSE;
234  
235 /*
236 * Altough AFIs are tpically 2 octects wide,
237 * 802.1ab specifies that this field width
238 * is only once octet
239 */
240 mgmt_addr_type = *tptr;
241 ND_PRINT((ndo, "\n\t Management Address Type %s (%u)",
242 tok2str(af_values, "Unknown", mgmt_addr_type),
243 mgmt_addr_type));
244  
245 /*
246 * Resolve the passed in Address.
247 */
248 switch(mgmt_addr_type) {
249 case AFNUM_INET:
250 ND_PRINT((ndo, ", %s", ipaddr_string(ndo, tptr + 1)));
251 break;
252  
253 #ifdef INET6
254 case AFNUM_INET6:
255 ND_PRINT((ndo, ", %s", ip6addr_string(ndo, tptr + 1)));
256 break;
257 #endif
258  
259 default:
260 hexdump = TRUE;
261 break;
262 }
263  
264 return hexdump;
265 }
266  
267 /*
268 * The egress-ID string is a 16-Bit string plus a MAC address.
269 */
270 static const char *
271 cfm_egress_id_string(netdissect_options *ndo, register const u_char *tptr)
272 {
273 static char egress_id_buffer[80];
274  
275 snprintf(egress_id_buffer, sizeof(egress_id_buffer),
276 "MAC 0x%4x-%s",
277 EXTRACT_16BITS(tptr),
278 etheraddr_string(ndo, tptr+2));
279  
280 return egress_id_buffer;
281 }
282  
283 void
284 cfm_print(netdissect_options *ndo,
285 register const u_char *pptr, register u_int length)
286 {
287 const struct cfm_common_header_t *cfm_common_header;
288 const struct cfm_tlv_header_t *cfm_tlv_header;
289 const uint8_t *tptr, *tlv_ptr, *ma_name, *ma_nameformat, *ma_namelength;
290 u_int hexdump, tlen, cfm_tlv_len, cfm_tlv_type, ccm_interval;
291  
292  
293 union {
294 const struct cfm_ccm_t *cfm_ccm;
295 const struct cfm_lbm_t *cfm_lbm;
296 const struct cfm_ltm_t *cfm_ltm;
297 const struct cfm_ltr_t *cfm_ltr;
298 } msg_ptr;
299  
300 tptr=pptr;
301 cfm_common_header = (const struct cfm_common_header_t *)pptr;
302 ND_TCHECK(*cfm_common_header);
303  
304 /*
305 * Sanity checking of the header.
306 */
307 if (CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version) != CFM_VERSION) {
308 ND_PRINT((ndo, "CFMv%u not supported, length %u",
309 CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version), length));
310 return;
311 }
312  
313 ND_PRINT((ndo, "CFMv%u %s, MD Level %u, length %u",
314 CFM_EXTRACT_VERSION(cfm_common_header->mdlevel_version),
315 tok2str(cfm_opcode_values, "unknown (%u)", cfm_common_header->opcode),
316 CFM_EXTRACT_MD_LEVEL(cfm_common_header->mdlevel_version),
317 length));
318  
319 /*
320 * In non-verbose mode just print the opcode and md-level.
321 */
322 if (ndo->ndo_vflag < 1) {
323 return;
324 }
325  
326 ND_PRINT((ndo, "\n\tFirst TLV offset %u", cfm_common_header->first_tlv_offset));
327  
328 tptr += sizeof(const struct cfm_common_header_t);
329 tlen = length - sizeof(struct cfm_common_header_t);
330  
331 switch (cfm_common_header->opcode) {
332 case CFM_OPCODE_CCM:
333 msg_ptr.cfm_ccm = (const struct cfm_ccm_t *)tptr;
334  
335 ccm_interval = CFM_EXTRACT_CCM_INTERVAL(cfm_common_header->flags);
336 ND_PRINT((ndo, ", Flags [CCM Interval %u%s]",
337 ccm_interval,
338 cfm_common_header->flags & CFM_CCM_RDI_FLAG ?
339 ", RDI" : ""));
340  
341 /*
342 * Resolve the CCM interval field.
343 */
344 if (ccm_interval) {
345 ND_PRINT((ndo, "\n\t CCM Interval %.3fs"
346 ", min CCM Lifetime %.3fs, max CCM Lifetime %.3fs",
347 ccm_interval_base[ccm_interval],
348 ccm_interval_base[ccm_interval] * CCM_INTERVAL_MIN_MULTIPLIER,
349 ccm_interval_base[ccm_interval] * CCM_INTERVAL_MAX_MULTIPLIER));
350 }
351  
352 ND_PRINT((ndo, "\n\t Sequence Number 0x%08x, MA-End-Point-ID 0x%04x",
353 EXTRACT_32BITS(msg_ptr.cfm_ccm->sequence),
354 EXTRACT_16BITS(msg_ptr.cfm_ccm->ma_epi)));
355  
356  
357 /*
358 * Resolve the MD fields.
359 */
360 ND_PRINT((ndo, "\n\t MD Name Format %s (%u), MD Name length %u",
361 tok2str(cfm_md_nameformat_values, "Unknown",
362 msg_ptr.cfm_ccm->md_nameformat),
363 msg_ptr.cfm_ccm->md_nameformat,
364 msg_ptr.cfm_ccm->md_namelength));
365  
366 if (msg_ptr.cfm_ccm->md_nameformat != CFM_CCM_MD_FORMAT_NONE) {
367 ND_PRINT((ndo, "\n\t MD Name: "));
368 switch (msg_ptr.cfm_ccm->md_nameformat) {
369 case CFM_CCM_MD_FORMAT_DNS:
370 case CFM_CCM_MD_FORMAT_CHAR:
371 safeputs(ndo, msg_ptr.cfm_ccm->md_name, msg_ptr.cfm_ccm->md_namelength);
372 break;
373  
374 case CFM_CCM_MD_FORMAT_MAC:
375 ND_PRINT((ndo, "\n\t MAC %s", etheraddr_string(ndo,
376 msg_ptr.cfm_ccm->md_name)));
377 break;
378  
379 /* FIXME add printers for those MD formats - hexdump for now */
380 case CFM_CCM_MA_FORMAT_8021:
381 default:
382 print_unknown_data(ndo, msg_ptr.cfm_ccm->md_name, "\n\t ",
383 msg_ptr.cfm_ccm->md_namelength);
384 }
385 }
386  
387  
388 /*
389 * Resolve the MA fields.
390 */
391 ma_nameformat = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength;
392 ma_namelength = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength + 1;
393 ma_name = msg_ptr.cfm_ccm->md_name + msg_ptr.cfm_ccm->md_namelength + 2;
394  
395 ND_PRINT((ndo, "\n\t MA Name-Format %s (%u), MA name length %u",
396 tok2str(cfm_ma_nameformat_values, "Unknown",
397 *ma_nameformat),
398 *ma_nameformat,
399 *ma_namelength));
400  
401 ND_PRINT((ndo, "\n\t MA Name: "));
402 switch (*ma_nameformat) {
403 case CFM_CCM_MA_FORMAT_CHAR:
404 safeputs(ndo, ma_name, *ma_namelength);
405 break;
406  
407 /* FIXME add printers for those MA formats - hexdump for now */
408 case CFM_CCM_MA_FORMAT_8021:
409 case CFM_CCM_MA_FORMAT_VID:
410 case CFM_CCM_MA_FORMAT_INT:
411 case CFM_CCM_MA_FORMAT_VPN:
412 default:
413 print_unknown_data(ndo, ma_name, "\n\t ", *ma_namelength);
414 }
415 break;
416  
417 case CFM_OPCODE_LTM:
418 msg_ptr.cfm_ltm = (const struct cfm_ltm_t *)tptr;
419  
420 ND_PRINT((ndo, ", Flags [%s]",
421 bittok2str(cfm_ltm_flag_values, "none", cfm_common_header->flags)));
422  
423 ND_PRINT((ndo, "\n\t Transaction-ID 0x%08x, Egress-ID %s, ttl %u",
424 EXTRACT_32BITS(msg_ptr.cfm_ltm->transaction_id),
425 cfm_egress_id_string(ndo, msg_ptr.cfm_ltm->egress_id),
426 msg_ptr.cfm_ltm->ttl));
427  
428 ND_PRINT((ndo, "\n\t Original-MAC %s, Target-MAC %s",
429 etheraddr_string(ndo, msg_ptr.cfm_ltm->original_mac),
430 etheraddr_string(ndo, msg_ptr.cfm_ltm->target_mac)));
431 break;
432  
433 case CFM_OPCODE_LTR:
434 msg_ptr.cfm_ltr = (const struct cfm_ltr_t *)tptr;
435  
436 ND_PRINT((ndo, ", Flags [%s]",
437 bittok2str(cfm_ltr_flag_values, "none", cfm_common_header->flags)));
438  
439 ND_PRINT((ndo, "\n\t Transaction-ID 0x%08x, Last-Egress-ID %s",
440 EXTRACT_32BITS(msg_ptr.cfm_ltr->transaction_id),
441 cfm_egress_id_string(ndo, msg_ptr.cfm_ltr->last_egress_id)));
442  
443 ND_PRINT((ndo, "\n\t Next-Egress-ID %s, ttl %u",
444 cfm_egress_id_string(ndo, msg_ptr.cfm_ltr->next_egress_id),
445 msg_ptr.cfm_ltr->ttl));
446  
447 ND_PRINT((ndo, "\n\t Replay-Action %s (%u)",
448 tok2str(cfm_ltr_replay_action_values,
449 "Unknown",
450 msg_ptr.cfm_ltr->replay_action),
451 msg_ptr.cfm_ltr->replay_action));
452 break;
453  
454 /*
455 * No message decoder yet.
456 * Hexdump everything up until the start of the TLVs
457 */
458 case CFM_OPCODE_LBR:
459 case CFM_OPCODE_LBM:
460 default:
461 if (tlen > cfm_common_header->first_tlv_offset) {
462 print_unknown_data(ndo, tptr, "\n\t ",
463 tlen - cfm_common_header->first_tlv_offset);
464 }
465 break;
466 }
467  
468 /*
469 * Sanity check for not walking off.
470 */
471 if (tlen <= cfm_common_header->first_tlv_offset) {
472 return;
473 }
474  
475 tptr += cfm_common_header->first_tlv_offset;
476 tlen -= cfm_common_header->first_tlv_offset;
477  
478 while (tlen > 0) {
479 cfm_tlv_header = (const struct cfm_tlv_header_t *)tptr;
480  
481 /* Enough to read the tlv type ? */
482 ND_TCHECK2(*tptr, 1);
483 cfm_tlv_type=cfm_tlv_header->type;
484  
485 if (cfm_tlv_type != CFM_TLV_END) {
486 /* did we capture enough for fully decoding the object header ? */
487 ND_TCHECK2(*tptr, sizeof(struct cfm_tlv_header_t));
488 cfm_tlv_len=EXTRACT_16BITS(&cfm_tlv_header->length);
489 } else {
490 cfm_tlv_len = 0;
491 }
492  
493 ND_PRINT((ndo, "\n\t%s TLV (0x%02x), length %u",
494 tok2str(cfm_tlv_values, "Unknown", cfm_tlv_type),
495 cfm_tlv_type,
496 cfm_tlv_len));
497  
498 /* sanity check for not walking off and infinite loop check. */
499 if ((cfm_tlv_type != CFM_TLV_END) &&
500 ((cfm_tlv_len + sizeof(struct cfm_tlv_header_t) > tlen) ||
501 (!cfm_tlv_len))) {
502 print_unknown_data(ndo, tptr, "\n\t ", tlen);
503 return;
504 }
505  
506 tptr += sizeof(struct cfm_tlv_header_t);
507 tlen -= sizeof(struct cfm_tlv_header_t);
508 tlv_ptr = tptr;
509  
510 /* did we capture enough for fully decoding the object ? */
511 if (cfm_tlv_type != CFM_TLV_END) {
512 ND_TCHECK2(*tptr, cfm_tlv_len);
513 }
514 hexdump = FALSE;
515  
516 switch(cfm_tlv_type) {
517 case CFM_TLV_END:
518 /* we are done - bail out */
519 return;
520  
521 case CFM_TLV_PORT_STATUS:
522 ND_PRINT((ndo, ", Status: %s (%u)",
523 tok2str(cfm_tlv_port_status_values, "Unknown", *tptr),
524 *tptr));
525 break;
526  
527 case CFM_TLV_INTERFACE_STATUS:
528 ND_PRINT((ndo, ", Status: %s (%u)",
529 tok2str(cfm_tlv_interface_status_values, "Unknown", *tptr),
530 *tptr));
531 break;
532  
533 case CFM_TLV_PRIVATE:
534 ND_PRINT((ndo, ", Vendor: %s (%u), Sub-Type %u",
535 tok2str(oui_values,"Unknown", EXTRACT_24BITS(tptr)),
536 EXTRACT_24BITS(tptr),
537 *(tptr + 3)));
538 hexdump = TRUE;
539 break;
540  
541 case CFM_TLV_SENDER_ID:
542 {
543 u_int chassis_id_type, chassis_id_length;
544 u_int mgmt_addr_length;
545  
546 /*
547 * Check if there is a Chassis-ID.
548 */
549 chassis_id_length = *tptr;
550 if (chassis_id_length > tlen) {
551 hexdump = TRUE;
552 break;
553 }
554  
555 tptr++;
556 tlen--;
557  
558 if (chassis_id_length) {
559 chassis_id_type = *tptr;
560 ND_PRINT((ndo, "\n\t Chassis-ID Type %s (%u), Chassis-ID length %u",
561 tok2str(cfm_tlv_senderid_chassisid_values,
562 "Unknown",
563 chassis_id_type),
564 chassis_id_type,
565 chassis_id_length));
566  
567 switch (chassis_id_type) {
568 case CFM_CHASSIS_ID_MAC_ADDRESS:
569 ND_PRINT((ndo, "\n\t MAC %s", etheraddr_string(ndo, tptr + 1)));
570 break;
571  
572 case CFM_CHASSIS_ID_NETWORK_ADDRESS:
573 hexdump |= cfm_mgmt_addr_print(ndo, tptr);
574 break;
575  
576 case CFM_CHASSIS_ID_INTERFACE_NAME: /* fall through */
577 case CFM_CHASSIS_ID_INTERFACE_ALIAS:
578 case CFM_CHASSIS_ID_LOCAL:
579 case CFM_CHASSIS_ID_CHASSIS_COMPONENT:
580 case CFM_CHASSIS_ID_PORT_COMPONENT:
581 safeputs(ndo, tptr + 1, chassis_id_length);
582 break;
583  
584 default:
585 hexdump = TRUE;
586 break;
587 }
588 }
589  
590 tptr += chassis_id_length;
591 tlen -= chassis_id_length;
592  
593 /*
594 * Check if there is a Management Address.
595 */
596 mgmt_addr_length = *tptr;
597 if (mgmt_addr_length > tlen) {
598 hexdump = TRUE;
599 break;
600 }
601  
602 tptr++;
603 tlen--;
604  
605 if (mgmt_addr_length) {
606 hexdump |= cfm_mgmt_addr_print(ndo, tptr);
607 }
608  
609 tptr += mgmt_addr_length;
610 tlen -= mgmt_addr_length;
611  
612 }
613 break;
614  
615 /*
616 * FIXME those are the defined TLVs that lack a decoder
617 * you are welcome to contribute code ;-)
618 */
619  
620 case CFM_TLV_DATA:
621 case CFM_TLV_REPLY_INGRESS:
622 case CFM_TLV_REPLY_EGRESS:
623 default:
624 hexdump = TRUE;
625 break;
626 }
627 /* do we want to see an additional hexdump ? */
628 if (hexdump || ndo->ndo_vflag > 1)
629 print_unknown_data(ndo, tlv_ptr, "\n\t ", cfm_tlv_len);
630  
631 tptr+=cfm_tlv_len;
632 tlen-=cfm_tlv_len;
633 }
634 return;
635 trunc:
636 ND_PRINT((ndo, "\n\t\t packet exceeded snapshot"));
637 }