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