The Tcpdump Group git mirrors - tcpdump/blob - print-eigrp.c

   1 /*
   2  * Copyright (c) 1998-2004  Hannes Gredler <hannes@gredler.at>
   3  *      The TCPDUMP project
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code
   7  * distributions retain the above copyright notice and this paragraph
   8  * in its entirety, and (2) distributions including binary code include
   9  * the above copyright notice and this paragraph in its entirety in
  10  * the documentation or other materials provided with the distribution.
  11  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
  12  * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
  13  * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14  * FOR A PARTICULAR PURPOSE.
  15  */
  16
  17 /* \summary: Enhanced Interior Gateway Routing Protocol (EIGRP) printer */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include <netdissect-stdinc.h>
  24
  25 #include <string.h>
  26
  27 #include "netdissect.h"
  28 #include "extract.h"
  29 #include "addrtoname.h"
  30
  31 /*
  32  * packet format documented at
  33  * http://www.rhyshaden.com/eigrp.htm
  34  * RFC 7868
  35  */
  36
  37 struct eigrp_common_header {
  38     uint8_t version;
  39     uint8_t opcode;
  40     uint8_t checksum[2];
  41     uint8_t flags[4];
  42     uint8_t seq[4];
  43     uint8_t ack[4];
  44     uint8_t asn[4];
  45 };
  46
  47 #define EIGRP_VERSION                        2
  48
  49 #define EIGRP_OPCODE_UPDATE                  1
  50 #define EIGRP_OPCODE_QUERY                   3
  51 #define EIGRP_OPCODE_REPLY                   4
  52 #define EIGRP_OPCODE_HELLO                   5
  53 #define EIGRP_OPCODE_IPXSAP                  6
  54 #define EIGRP_OPCODE_PROBE                   7
  55
  56 static const struct tok eigrp_opcode_values[] = {
  57     { EIGRP_OPCODE_UPDATE, "Update" },
  58     { EIGRP_OPCODE_QUERY, "Query" },
  59     { EIGRP_OPCODE_REPLY, "Reply" },
  60     { EIGRP_OPCODE_HELLO, "Hello" },
  61     { EIGRP_OPCODE_IPXSAP, "IPX SAP" },
  62     { EIGRP_OPCODE_PROBE, "Probe" },
  63     { 0, NULL}
  64 };
  65
  66 static const struct tok eigrp_common_header_flag_values[] = {
  67     { 0x01, "Init" },
  68     { 0x02, "Conditionally Received" },
  69     { 0, NULL}
  70 };
  71
  72 struct eigrp_tlv_header {
  73     uint8_t type[2];
  74     uint8_t length[2];
  75 };
  76
  77 #define EIGRP_TLV_GENERAL_PARM   0x0001
  78 #define EIGRP_TLV_AUTH           0x0002
  79 #define EIGRP_TLV_SEQ            0x0003
  80 #define EIGRP_TLV_SW_VERSION     0x0004
  81 #define EIGRP_TLV_MCAST_SEQ      0x0005
  82 #define EIGRP_TLV_IP_INT         0x0102
  83 #define EIGRP_TLV_IP_EXT         0x0103
  84 #define EIGRP_TLV_AT_INT         0x0202
  85 #define EIGRP_TLV_AT_EXT         0x0203
  86 #define EIGRP_TLV_AT_CABLE_SETUP 0x0204
  87 #define EIGRP_TLV_IPX_INT        0x0302
  88 #define EIGRP_TLV_IPX_EXT        0x0303
  89
  90 static const struct tok eigrp_tlv_values[] = {
  91     { EIGRP_TLV_GENERAL_PARM, "General Parameters"},
  92     { EIGRP_TLV_AUTH, "Authentication"},
  93     { EIGRP_TLV_SEQ, "Sequence"},
  94     { EIGRP_TLV_SW_VERSION, "Software Version"},
  95     { EIGRP_TLV_MCAST_SEQ, "Next Multicast Sequence"},
  96     { EIGRP_TLV_IP_INT, "IP Internal routes"},
  97     { EIGRP_TLV_IP_EXT, "IP External routes"},
  98     { EIGRP_TLV_AT_INT, "AppleTalk Internal routes"},
  99     { EIGRP_TLV_AT_EXT, "AppleTalk External routes"},
 100     { EIGRP_TLV_AT_CABLE_SETUP, "AppleTalk Cable setup"},
 101     { EIGRP_TLV_IPX_INT, "IPX Internal routes"},
 102     { EIGRP_TLV_IPX_EXT, "IPX External routes"},
 103     { 0, NULL}
 104 };
 105
 106 struct eigrp_tlv_general_parm_t {
 107     uint8_t k1;
 108     uint8_t k2;
 109     uint8_t k3;
 110     uint8_t k4;
 111     uint8_t k5;
 112     uint8_t res;
 113     uint8_t holdtime[2];
 114 };
 115
 116 struct eigrp_tlv_sw_version_t {
 117     uint8_t ios_major;
 118     uint8_t ios_minor;
 119     uint8_t eigrp_major;
 120     uint8_t eigrp_minor;
 121 };
 122
 123 struct eigrp_tlv_ip_int_t {
 124     uint8_t nexthop[4];
 125     uint8_t delay[4];
 126     uint8_t bandwidth[4];
 127     uint8_t mtu[3];
 128     uint8_t hopcount;
 129     uint8_t reliability;
 130     uint8_t load;
 131     uint8_t reserved[2];
 132     uint8_t plen;
 133     uint8_t destination; /* variable length [1-4] bytes encoding */
 134 };
 135
 136 struct eigrp_tlv_ip_ext_t {
 137     uint8_t nexthop[4];
 138     uint8_t origin_router[4];
 139     uint8_t origin_as[4];
 140     uint8_t tag[4];
 141     uint8_t metric[4];
 142     uint8_t reserved[2];
 143     uint8_t proto_id;
 144     uint8_t flags;
 145     uint8_t delay[4];
 146     uint8_t bandwidth[4];
 147     uint8_t mtu[3];
 148     uint8_t hopcount;
 149     uint8_t reliability;
 150     uint8_t load;
 151     uint8_t reserved2[2];
 152     uint8_t plen;
 153     uint8_t destination; /* variable length [1-4] bytes encoding */
 154 };
 155
 156 struct eigrp_tlv_at_cable_setup_t {
 157     uint8_t cable_start[2];
 158     uint8_t cable_end[2];
 159     uint8_t router_id[4];
 160 };
 161
 162 struct eigrp_tlv_at_int_t {
 163     uint8_t nexthop[4];
 164     uint8_t delay[4];
 165     uint8_t bandwidth[4];
 166     uint8_t mtu[3];
 167     uint8_t hopcount;
 168     uint8_t reliability;
 169     uint8_t load;
 170     uint8_t reserved[2];
 171     uint8_t cable_start[2];
 172     uint8_t cable_end[2];
 173 };
 174
 175 struct eigrp_tlv_at_ext_t {
 176     uint8_t nexthop[4];
 177     uint8_t origin_router[4];
 178     uint8_t origin_as[4];
 179     uint8_t tag[4];
 180     uint8_t proto_id;
 181     uint8_t flags;
 182     uint8_t metric[2];
 183     uint8_t delay[4];
 184     uint8_t bandwidth[4];
 185     uint8_t mtu[3];
 186     uint8_t hopcount;
 187     uint8_t reliability;
 188     uint8_t load;
 189     uint8_t reserved2[2];
 190     uint8_t cable_start[2];
 191     uint8_t cable_end[2];
 192 };
 193
 194 static const struct tok eigrp_ext_proto_id_values[] = {
 195     { 0x01, "IGRP" },
 196     { 0x02, "EIGRP" },
 197     { 0x03, "Static" },
 198     { 0x04, "RIP" },
 199     { 0x05, "Hello" },
 200     { 0x06, "OSPF" },
 201     { 0x07, "IS-IS" },
 202     { 0x08, "EGP" },
 203     { 0x09, "BGP" },
 204     { 0x0a, "IDRP" },
 205     { 0x0b, "Connected" },
 206     { 0, NULL}
 207 };
 208
 209 void
 210 eigrp_print(netdissect_options *ndo, register const u_char *pptr, register u_int len)
 211 {
 212     const struct eigrp_common_header *eigrp_com_header;
 213     const struct eigrp_tlv_header *eigrp_tlv_header;
 214     const u_char *tptr,*tlv_tptr;
 215     u_int tlen,eigrp_tlv_len,eigrp_tlv_type,tlv_tlen, byte_length, bit_length;
 216     uint8_t prefix[4];
 217
 218     union {
 219         const struct eigrp_tlv_general_parm_t *eigrp_tlv_general_parm;
 220         const struct eigrp_tlv_sw_version_t *eigrp_tlv_sw_version;
 221         const struct eigrp_tlv_ip_int_t *eigrp_tlv_ip_int;
 222         const struct eigrp_tlv_ip_ext_t *eigrp_tlv_ip_ext;
 223         const struct eigrp_tlv_at_cable_setup_t *eigrp_tlv_at_cable_setup;
 224         const struct eigrp_tlv_at_int_t *eigrp_tlv_at_int;
 225         const struct eigrp_tlv_at_ext_t *eigrp_tlv_at_ext;
 226     } tlv_ptr;
 227
 228     tptr=pptr;
 229     eigrp_com_header = (const struct eigrp_common_header *)pptr;
 230     ND_TCHECK(*eigrp_com_header);
 231
 232     /*
 233      * Sanity checking of the header.
 234      */
 235     if (eigrp_com_header->version != EIGRP_VERSION) {
 236         ND_PRINT((ndo, "EIGRP version %u packet not supported",eigrp_com_header->version));
 237         return;
 238     }
 239
 240     /* in non-verbose mode just lets print the basic Message Type*/
 241     if (ndo->ndo_vflag < 1) {
 242         ND_PRINT((ndo, "EIGRP %s, length: %u",
 243                tok2str(eigrp_opcode_values, "unknown (%u)",eigrp_com_header->opcode),
 244                len));
 245         return;
 246     }
 247
 248     /* ok they seem to want to know everything - lets fully decode it */
 249
 250     if (len < sizeof(struct eigrp_common_header)) {
 251         ND_PRINT((ndo, "EIGRP %s, length: %u (too short, < %u)",
 252                tok2str(eigrp_opcode_values, "unknown (%u)",eigrp_com_header->opcode),
 253                len, (u_int) sizeof(struct eigrp_common_header)));
 254         return;
 255     }
 256     tlen=len-sizeof(struct eigrp_common_header);
 257
 258     /* FIXME print other header info */
 259     ND_PRINT((ndo, "\n\tEIGRP v%u, opcode: %s (%u), chksum: 0x%04x, Flags: [%s]\n\tseq: 0x%08x, ack: 0x%08x, AS: %u, length: %u",
 260            eigrp_com_header->version,
 261            tok2str(eigrp_opcode_values, "unknown, type: %u",eigrp_com_header->opcode),
 262            eigrp_com_header->opcode,
 263            EXTRACT_16BITS(&eigrp_com_header->checksum),
 264            tok2str(eigrp_common_header_flag_values,
 265                    "none",
 266                    EXTRACT_32BITS(&eigrp_com_header->flags)),
 267            EXTRACT_32BITS(&eigrp_com_header->seq),
 268            EXTRACT_32BITS(&eigrp_com_header->ack),
 269            EXTRACT_32BITS(&eigrp_com_header->asn),
 270            tlen));
 271
 272     tptr+=sizeof(const struct eigrp_common_header);
 273
 274     while(tlen>0) {
 275         /* did we capture enough for fully decoding the object header ? */
 276         ND_TCHECK2(*tptr, sizeof(struct eigrp_tlv_header));
 277
 278         eigrp_tlv_header = (const struct eigrp_tlv_header *)tptr;
 279         eigrp_tlv_len=EXTRACT_16BITS(&eigrp_tlv_header->length);
 280         eigrp_tlv_type=EXTRACT_16BITS(&eigrp_tlv_header->type);
 281
 282
 283         if (eigrp_tlv_len < sizeof(struct eigrp_tlv_header) ||
 284             eigrp_tlv_len > tlen) {
 285             print_unknown_data(ndo,tptr+sizeof(struct eigrp_tlv_header),"\n\t    ",tlen);
 286             return;
 287         }
 288
 289         ND_PRINT((ndo, "\n\t  %s TLV (0x%04x), length: %u",
 290                tok2str(eigrp_tlv_values,
 291                        "Unknown",
 292                        eigrp_tlv_type),
 293                eigrp_tlv_type,
 294                eigrp_tlv_len));
 295
 296         if (eigrp_tlv_len < sizeof(struct eigrp_tlv_header)) {
 297                 ND_PRINT((ndo, " (too short, < %u)",
 298                         (u_int) sizeof(struct eigrp_tlv_header)));
 299                 break;
 300         }
 301         tlv_tptr=tptr+sizeof(struct eigrp_tlv_header);
 302         tlv_tlen=eigrp_tlv_len-sizeof(struct eigrp_tlv_header);
 303
 304         /* did we capture enough for fully decoding the object ? */
 305         ND_TCHECK2(*tptr, eigrp_tlv_len);
 306
 307         switch(eigrp_tlv_type) {
 308
 309         case EIGRP_TLV_GENERAL_PARM:
 310             tlv_ptr.eigrp_tlv_general_parm = (const struct eigrp_tlv_general_parm_t *)tlv_tptr;
 311             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_general_parm)) {
 312                 ND_PRINT((ndo, " (too short, < %u)",
 313                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_general_parm))));
 314                 break;
 315             }
 316
 317             ND_PRINT((ndo, "\n\t    holdtime: %us, k1 %u, k2 %u, k3 %u, k4 %u, k5 %u",
 318                    EXTRACT_16BITS(tlv_ptr.eigrp_tlv_general_parm->holdtime),
 319                    tlv_ptr.eigrp_tlv_general_parm->k1,
 320                    tlv_ptr.eigrp_tlv_general_parm->k2,
 321                    tlv_ptr.eigrp_tlv_general_parm->k3,
 322                    tlv_ptr.eigrp_tlv_general_parm->k4,
 323                    tlv_ptr.eigrp_tlv_general_parm->k5));
 324             break;
 325
 326         case EIGRP_TLV_SW_VERSION:
 327             tlv_ptr.eigrp_tlv_sw_version = (const struct eigrp_tlv_sw_version_t *)tlv_tptr;
 328             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_sw_version)) {
 329                 ND_PRINT((ndo, " (too short, < %u)",
 330                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_sw_version))));
 331                 break;
 332             }
 333
 334             ND_PRINT((ndo, "\n\t    IOS version: %u.%u, EIGRP version %u.%u",
 335                    tlv_ptr.eigrp_tlv_sw_version->ios_major,
 336                    tlv_ptr.eigrp_tlv_sw_version->ios_minor,
 337                    tlv_ptr.eigrp_tlv_sw_version->eigrp_major,
 338                    tlv_ptr.eigrp_tlv_sw_version->eigrp_minor));
 339             break;
 340
 341         case EIGRP_TLV_IP_INT:
 342             tlv_ptr.eigrp_tlv_ip_int = (const struct eigrp_tlv_ip_int_t *)tlv_tptr;
 343             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_ip_int)) {
 344                 ND_PRINT((ndo, " (too short, < %u)",
 345                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_ip_int))));
 346                 break;
 347             }
 348
 349             bit_length = tlv_ptr.eigrp_tlv_ip_int->plen;
 350             if (bit_length > 32) {
 351                 ND_PRINT((ndo, "\n\t    illegal prefix length %u",bit_length));
 352                 break;
 353             }
 354             byte_length = (bit_length + 7) / 8; /* variable length encoding */
 355             memset(prefix, 0, 4);
 356             ND_TCHECK2(tlv_ptr.eigrp_tlv_ip_int->destination, byte_length);
 357             memcpy(prefix,&tlv_ptr.eigrp_tlv_ip_int->destination,byte_length);
 358
 359             ND_PRINT((ndo, "\n\t    IPv4 prefix: %15s/%u, nexthop: ",
 360                    ipaddr_string(ndo, prefix),
 361                    bit_length));
 362             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->nexthop) == 0)
 363                 ND_PRINT((ndo, "self"));
 364             else
 365                 ND_PRINT((ndo, "%s",ipaddr_string(ndo, &tlv_ptr.eigrp_tlv_ip_int->nexthop)));
 366
 367             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
 368                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->delay)/100),
 369                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->bandwidth),
 370                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_ip_int->mtu),
 371                    tlv_ptr.eigrp_tlv_ip_int->hopcount,
 372                    tlv_ptr.eigrp_tlv_ip_int->reliability,
 373                    tlv_ptr.eigrp_tlv_ip_int->load));
 374             break;
 375
 376         case EIGRP_TLV_IP_EXT:
 377             tlv_ptr.eigrp_tlv_ip_ext = (const struct eigrp_tlv_ip_ext_t *)tlv_tptr;
 378             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_ip_ext)) {
 379                 ND_PRINT((ndo, " (too short, < %u)",
 380                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_ip_ext))));
 381                 break;
 382             }
 383
 384             bit_length = tlv_ptr.eigrp_tlv_ip_ext->plen;
 385             if (bit_length > 32) {
 386                 ND_PRINT((ndo, "\n\t    illegal prefix length %u",bit_length));
 387                 break;
 388             }
 389             byte_length = (bit_length + 7) / 8; /* variable length encoding */
 390             memset(prefix, 0, 4);
 391             ND_TCHECK2(tlv_ptr.eigrp_tlv_ip_ext->destination, byte_length);
 392             memcpy(prefix,&tlv_ptr.eigrp_tlv_ip_ext->destination,byte_length);
 393
 394             ND_PRINT((ndo, "\n\t    IPv4 prefix: %15s/%u, nexthop: ",
 395                    ipaddr_string(ndo, prefix),
 396                    bit_length));
 397             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->nexthop) == 0)
 398                 ND_PRINT((ndo, "self"));
 399             else
 400                 ND_PRINT((ndo, "%s",ipaddr_string(ndo, &tlv_ptr.eigrp_tlv_ip_ext->nexthop)));
 401
 402             ND_PRINT((ndo, "\n\t      origin-router %s, origin-as %u, origin-proto %s, flags [0x%02x], tag 0x%08x, metric %u",
 403                    ipaddr_string(ndo, tlv_ptr.eigrp_tlv_ip_ext->origin_router),
 404                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->origin_as),
 405                    tok2str(eigrp_ext_proto_id_values,"unknown",tlv_ptr.eigrp_tlv_ip_ext->proto_id),
 406                    tlv_ptr.eigrp_tlv_ip_ext->flags,
 407                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->tag),
 408                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->metric)));
 409
 410             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
 411                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->delay)/100),
 412                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->bandwidth),
 413                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_ip_ext->mtu),
 414                    tlv_ptr.eigrp_tlv_ip_ext->hopcount,
 415                    tlv_ptr.eigrp_tlv_ip_ext->reliability,
 416                    tlv_ptr.eigrp_tlv_ip_ext->load));
 417             break;
 418
 419         case EIGRP_TLV_AT_CABLE_SETUP:
 420             tlv_ptr.eigrp_tlv_at_cable_setup = (const struct eigrp_tlv_at_cable_setup_t *)tlv_tptr;
 421             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_cable_setup)) {
 422                 ND_PRINT((ndo, " (too short, < %u)",
 423                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_cable_setup))));
 424                 break;
 425             }
 426
 427             ND_PRINT((ndo, "\n\t    Cable-range: %u-%u, Router-ID %u",
 428                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->cable_start),
 429                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->cable_end),
 430                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->router_id)));
 431             break;
 432
 433         case EIGRP_TLV_AT_INT:
 434             tlv_ptr.eigrp_tlv_at_int = (const struct eigrp_tlv_at_int_t *)tlv_tptr;
 435             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_int)) {
 436                 ND_PRINT((ndo, " (too short, < %u)",
 437                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_int))));
 438                 break;
 439             }
 440
 441             ND_PRINT((ndo, "\n\t     Cable-Range: %u-%u, nexthop: ",
 442                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->cable_start),
 443                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->cable_end)));
 444
 445             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop) == 0)
 446                 ND_PRINT((ndo, "self"));
 447             else
 448                 ND_PRINT((ndo, "%u.%u",
 449                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop),
 450                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop[2])));
 451
 452             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
 453                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->delay)/100),
 454                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->bandwidth),
 455                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_at_int->mtu),
 456                    tlv_ptr.eigrp_tlv_at_int->hopcount,
 457                    tlv_ptr.eigrp_tlv_at_int->reliability,
 458                    tlv_ptr.eigrp_tlv_at_int->load));
 459             break;
 460
 461         case EIGRP_TLV_AT_EXT:
 462             tlv_ptr.eigrp_tlv_at_ext = (const struct eigrp_tlv_at_ext_t *)tlv_tptr;
 463             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_ext)) {
 464                 ND_PRINT((ndo, " (too short, < %u)",
 465                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_ext))));
 466                 break;
 467             }
 468
 469             ND_PRINT((ndo, "\n\t     Cable-Range: %u-%u, nexthop: ",
 470                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->cable_start),
 471                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->cable_end)));
 472
 473             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop) == 0)
 474                 ND_PRINT((ndo, "self"));
 475             else
 476                 ND_PRINT((ndo, "%u.%u",
 477                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop),
 478                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop[2])));
 479
 480             ND_PRINT((ndo, "\n\t      origin-router %u, origin-as %u, origin-proto %s, flags [0x%02x], tag 0x%08x, metric %u",
 481                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->origin_router),
 482                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->origin_as),
 483                    tok2str(eigrp_ext_proto_id_values,"unknown",tlv_ptr.eigrp_tlv_at_ext->proto_id),
 484                    tlv_ptr.eigrp_tlv_at_ext->flags,
 485                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->tag),
 486                    EXTRACT_16BITS(tlv_ptr.eigrp_tlv_at_ext->metric)));
 487
 488             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
 489                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->delay)/100),
 490                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->bandwidth),
 491                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_at_ext->mtu),
 492                    tlv_ptr.eigrp_tlv_at_ext->hopcount,
 493                    tlv_ptr.eigrp_tlv_at_ext->reliability,
 494                    tlv_ptr.eigrp_tlv_at_ext->load));
 495             break;
 496
 497             /*
 498              * FIXME those are the defined TLVs that lack a decoder
 499              * you are welcome to contribute code ;-)
 500              */
 501
 502         case EIGRP_TLV_AUTH:
 503         case EIGRP_TLV_SEQ:
 504         case EIGRP_TLV_MCAST_SEQ:
 505         case EIGRP_TLV_IPX_INT:
 506         case EIGRP_TLV_IPX_EXT:
 507
 508         default:
 509             if (ndo->ndo_vflag <= 1)
 510                 print_unknown_data(ndo,tlv_tptr,"\n\t    ",tlv_tlen);
 511             break;
 512         }
 513         /* do we want to see an additionally hexdump ? */
 514         if (ndo->ndo_vflag > 1)
 515             print_unknown_data(ndo,tptr+sizeof(struct eigrp_tlv_header),"\n\t    ",
 516                                eigrp_tlv_len-sizeof(struct eigrp_tlv_header));
 517
 518         tptr+=eigrp_tlv_len;
 519         tlen-=eigrp_tlv_len;
 520     }
 521     return;
 522 trunc:
 523     ND_PRINT((ndo, "\n\t\t packet exceeded snapshot"));
 524 }