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
cfm_mgmt_addr_print(netdissect_options * ndo,register const u_char * tptr)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 *
cfm_egress_id_string(netdissect_options * ndo,register const u_char * tptr)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
cfm_print(netdissect_options * ndo,register const u_char * pptr,register u_int length)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 }
638