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