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