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
eigrp_print(netdissect_options * ndo,register const u_char * pptr,register u_int len)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             memcpy(prefix,&tlv_ptr.eigrp_tlv_ip_int->destination,byte_length);
357 
358             ND_PRINT((ndo, "\n\t    IPv4 prefix: %15s/%u, nexthop: ",
359                    ipaddr_string(ndo, prefix),
360                    bit_length));
361             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->nexthop) == 0)
362                 ND_PRINT((ndo, "self"));
363             else
364                 ND_PRINT((ndo, "%s",ipaddr_string(ndo, &tlv_ptr.eigrp_tlv_ip_int->nexthop)));
365 
366             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
367                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->delay)/100),
368                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_int->bandwidth),
369                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_ip_int->mtu),
370                    tlv_ptr.eigrp_tlv_ip_int->hopcount,
371                    tlv_ptr.eigrp_tlv_ip_int->reliability,
372                    tlv_ptr.eigrp_tlv_ip_int->load));
373             break;
374 
375         case EIGRP_TLV_IP_EXT:
376             tlv_ptr.eigrp_tlv_ip_ext = (const struct eigrp_tlv_ip_ext_t *)tlv_tptr;
377             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_ip_ext)) {
378                 ND_PRINT((ndo, " (too short, < %u)",
379                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_ip_ext))));
380                 break;
381             }
382 
383             bit_length = tlv_ptr.eigrp_tlv_ip_ext->plen;
384             if (bit_length > 32) {
385                 ND_PRINT((ndo, "\n\t    illegal prefix length %u",bit_length));
386                 break;
387             }
388             byte_length = (bit_length + 7) / 8; /* variable length encoding */
389             memset(prefix, 0, 4);
390             memcpy(prefix,&tlv_ptr.eigrp_tlv_ip_ext->destination,byte_length);
391 
392             ND_PRINT((ndo, "\n\t    IPv4 prefix: %15s/%u, nexthop: ",
393                    ipaddr_string(ndo, prefix),
394                    bit_length));
395             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->nexthop) == 0)
396                 ND_PRINT((ndo, "self"));
397             else
398                 ND_PRINT((ndo, "%s",ipaddr_string(ndo, &tlv_ptr.eigrp_tlv_ip_ext->nexthop)));
399 
400             ND_PRINT((ndo, "\n\t      origin-router %s, origin-as %u, origin-proto %s, flags [0x%02x], tag 0x%08x, metric %u",
401                    ipaddr_string(ndo, tlv_ptr.eigrp_tlv_ip_ext->origin_router),
402                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->origin_as),
403                    tok2str(eigrp_ext_proto_id_values,"unknown",tlv_ptr.eigrp_tlv_ip_ext->proto_id),
404                    tlv_ptr.eigrp_tlv_ip_ext->flags,
405                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->tag),
406                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_ip_ext->metric)));
407 
408             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
409                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->delay)/100),
410                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_ip_ext->bandwidth),
411                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_ip_ext->mtu),
412                    tlv_ptr.eigrp_tlv_ip_ext->hopcount,
413                    tlv_ptr.eigrp_tlv_ip_ext->reliability,
414                    tlv_ptr.eigrp_tlv_ip_ext->load));
415             break;
416 
417         case EIGRP_TLV_AT_CABLE_SETUP:
418             tlv_ptr.eigrp_tlv_at_cable_setup = (const struct eigrp_tlv_at_cable_setup_t *)tlv_tptr;
419             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_cable_setup)) {
420                 ND_PRINT((ndo, " (too short, < %u)",
421                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_cable_setup))));
422                 break;
423             }
424 
425             ND_PRINT((ndo, "\n\t    Cable-range: %u-%u, Router-ID %u",
426                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->cable_start),
427                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->cable_end),
428                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_cable_setup->router_id)));
429             break;
430 
431         case EIGRP_TLV_AT_INT:
432             tlv_ptr.eigrp_tlv_at_int = (const struct eigrp_tlv_at_int_t *)tlv_tptr;
433             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_int)) {
434                 ND_PRINT((ndo, " (too short, < %u)",
435                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_int))));
436                 break;
437             }
438 
439             ND_PRINT((ndo, "\n\t     Cable-Range: %u-%u, nexthop: ",
440                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->cable_start),
441                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->cable_end)));
442 
443             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop) == 0)
444                 ND_PRINT((ndo, "self"));
445             else
446                 ND_PRINT((ndo, "%u.%u",
447                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop),
448                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_int->nexthop[2])));
449 
450             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
451                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->delay)/100),
452                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_int->bandwidth),
453                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_at_int->mtu),
454                    tlv_ptr.eigrp_tlv_at_int->hopcount,
455                    tlv_ptr.eigrp_tlv_at_int->reliability,
456                    tlv_ptr.eigrp_tlv_at_int->load));
457             break;
458 
459         case EIGRP_TLV_AT_EXT:
460             tlv_ptr.eigrp_tlv_at_ext = (const struct eigrp_tlv_at_ext_t *)tlv_tptr;
461             if (tlv_tlen < sizeof(*tlv_ptr.eigrp_tlv_at_ext)) {
462                 ND_PRINT((ndo, " (too short, < %u)",
463                     (u_int) (sizeof(struct eigrp_tlv_header) + sizeof(*tlv_ptr.eigrp_tlv_at_ext))));
464                 break;
465             }
466 
467             ND_PRINT((ndo, "\n\t     Cable-Range: %u-%u, nexthop: ",
468                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->cable_start),
469                    EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->cable_end)));
470 
471             if (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop) == 0)
472                 ND_PRINT((ndo, "self"));
473             else
474                 ND_PRINT((ndo, "%u.%u",
475                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop),
476                        EXTRACT_16BITS(&tlv_ptr.eigrp_tlv_at_ext->nexthop[2])));
477 
478             ND_PRINT((ndo, "\n\t      origin-router %u, origin-as %u, origin-proto %s, flags [0x%02x], tag 0x%08x, metric %u",
479                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->origin_router),
480                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->origin_as),
481                    tok2str(eigrp_ext_proto_id_values,"unknown",tlv_ptr.eigrp_tlv_at_ext->proto_id),
482                    tlv_ptr.eigrp_tlv_at_ext->flags,
483                    EXTRACT_32BITS(tlv_ptr.eigrp_tlv_at_ext->tag),
484                    EXTRACT_16BITS(tlv_ptr.eigrp_tlv_at_ext->metric)));
485 
486             ND_PRINT((ndo, "\n\t      delay %u ms, bandwidth %u Kbps, mtu %u, hop %u, reliability %u, load %u",
487                    (EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->delay)/100),
488                    EXTRACT_32BITS(&tlv_ptr.eigrp_tlv_at_ext->bandwidth),
489                    EXTRACT_24BITS(&tlv_ptr.eigrp_tlv_at_ext->mtu),
490                    tlv_ptr.eigrp_tlv_at_ext->hopcount,
491                    tlv_ptr.eigrp_tlv_at_ext->reliability,
492                    tlv_ptr.eigrp_tlv_at_ext->load));
493             break;
494 
495             /*
496              * FIXME those are the defined TLVs that lack a decoder
497              * you are welcome to contribute code ;-)
498              */
499 
500         case EIGRP_TLV_AUTH:
501         case EIGRP_TLV_SEQ:
502         case EIGRP_TLV_MCAST_SEQ:
503         case EIGRP_TLV_IPX_INT:
504         case EIGRP_TLV_IPX_EXT:
505 
506         default:
507             if (ndo->ndo_vflag <= 1)
508                 print_unknown_data(ndo,tlv_tptr,"\n\t    ",tlv_tlen);
509             break;
510         }
511         /* do we want to see an additionally hexdump ? */
512         if (ndo->ndo_vflag > 1)
513             print_unknown_data(ndo,tptr+sizeof(struct eigrp_tlv_header),"\n\t    ",
514                                eigrp_tlv_len-sizeof(struct eigrp_tlv_header));
515 
516         tptr+=eigrp_tlv_len;
517         tlen-=eigrp_tlv_len;
518     }
519     return;
520 trunc:
521     ND_PRINT((ndo, "\n\t\t packet exceeded snapshot"));
522 }
523