nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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 "slow protocols" LACP, MARKER as per 802.3ad
16 * OAM as per 802.3ah
17 *
18 * Original code by Hannes Gredler (hannes@juniper.net)
19 */
20  
21 #define NETDISSECT_REWORKED
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25  
26 #include <tcpdump-stdinc.h>
27  
28 #include "interface.h"
29 #include "extract.h"
30 #include "addrtoname.h"
31 #include "ether.h"
32 #include "oui.h"
33  
34 struct slow_common_header_t {
35 uint8_t proto_subtype;
36 uint8_t version;
37 };
38  
39 #define SLOW_PROTO_LACP 1
40 #define SLOW_PROTO_MARKER 2
41 #define SLOW_PROTO_OAM 3
42  
43 #define LACP_VERSION 1
44 #define MARKER_VERSION 1
45  
46 static const struct tok slow_proto_values[] = {
47 { SLOW_PROTO_LACP, "LACP" },
48 { SLOW_PROTO_MARKER, "MARKER" },
49 { SLOW_PROTO_OAM, "OAM" },
50 { 0, NULL}
51 };
52  
53 static const struct tok slow_oam_flag_values[] = {
54 { 0x0001, "Link Fault" },
55 { 0x0002, "Dying Gasp" },
56 { 0x0004, "Critical Event" },
57 { 0x0008, "Local Evaluating" },
58 { 0x0010, "Local Stable" },
59 { 0x0020, "Remote Evaluating" },
60 { 0x0040, "Remote Stable" },
61 { 0, NULL}
62 };
63  
64 #define SLOW_OAM_CODE_INFO 0x00
65 #define SLOW_OAM_CODE_EVENT_NOTIF 0x01
66 #define SLOW_OAM_CODE_VAR_REQUEST 0x02
67 #define SLOW_OAM_CODE_VAR_RESPONSE 0x03
68 #define SLOW_OAM_CODE_LOOPBACK_CTRL 0x04
69 #define SLOW_OAM_CODE_PRIVATE 0xfe
70  
71 static const struct tok slow_oam_code_values[] = {
72 { SLOW_OAM_CODE_INFO, "Information" },
73 { SLOW_OAM_CODE_EVENT_NOTIF, "Event Notification" },
74 { SLOW_OAM_CODE_VAR_REQUEST, "Variable Request" },
75 { SLOW_OAM_CODE_VAR_RESPONSE, "Variable Response" },
76 { SLOW_OAM_CODE_LOOPBACK_CTRL, "Loopback Control" },
77 { SLOW_OAM_CODE_PRIVATE, "Vendor Private" },
78 { 0, NULL}
79 };
80  
81 struct slow_oam_info_t {
82 uint8_t info_type;
83 uint8_t info_length;
84 uint8_t oam_version;
85 uint8_t revision[2];
86 uint8_t state;
87 uint8_t oam_config;
88 uint8_t oam_pdu_config[2];
89 uint8_t oui[3];
90 uint8_t vendor_private[4];
91 };
92  
93 #define SLOW_OAM_INFO_TYPE_END_OF_TLV 0x00
94 #define SLOW_OAM_INFO_TYPE_LOCAL 0x01
95 #define SLOW_OAM_INFO_TYPE_REMOTE 0x02
96 #define SLOW_OAM_INFO_TYPE_ORG_SPECIFIC 0xfe
97  
98 static const struct tok slow_oam_info_type_values[] = {
99 { SLOW_OAM_INFO_TYPE_END_OF_TLV, "End of TLV marker" },
100 { SLOW_OAM_INFO_TYPE_LOCAL, "Local" },
101 { SLOW_OAM_INFO_TYPE_REMOTE, "Remote" },
102 { SLOW_OAM_INFO_TYPE_ORG_SPECIFIC, "Organization specific" },
103 { 0, NULL}
104 };
105  
106 #define OAM_INFO_TYPE_PARSER_MASK 0x3
107 static const struct tok slow_oam_info_type_state_parser_values[] = {
108 { 0x00, "forwarding" },
109 { 0x01, "looping back" },
110 { 0x02, "discarding" },
111 { 0x03, "reserved" },
112 { 0, NULL}
113 };
114  
115 #define OAM_INFO_TYPE_MUX_MASK 0x4
116 static const struct tok slow_oam_info_type_state_mux_values[] = {
117 { 0x00, "forwarding" },
118 { 0x04, "discarding" },
119 { 0, NULL}
120 };
121  
122 static const struct tok slow_oam_info_type_oam_config_values[] = {
123 { 0x01, "Active" },
124 { 0x02, "Unidirectional" },
125 { 0x04, "Remote-Loopback" },
126 { 0x08, "Link-Events" },
127 { 0x10, "Variable-Retrieval" },
128 { 0, NULL}
129 };
130  
131 /* 11 Bits */
132 #define OAM_INFO_TYPE_PDU_SIZE_MASK 0x7ff
133  
134 #define SLOW_OAM_LINK_EVENT_END_OF_TLV 0x00
135 #define SLOW_OAM_LINK_EVENT_ERR_SYM_PER 0x01
136 #define SLOW_OAM_LINK_EVENT_ERR_FRM 0x02
137 #define SLOW_OAM_LINK_EVENT_ERR_FRM_PER 0x03
138 #define SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM 0x04
139 #define SLOW_OAM_LINK_EVENT_ORG_SPECIFIC 0xfe
140  
141 static const struct tok slow_oam_link_event_values[] = {
142 { SLOW_OAM_LINK_EVENT_END_OF_TLV, "End of TLV marker" },
143 { SLOW_OAM_LINK_EVENT_ERR_SYM_PER, "Errored Symbol Period Event" },
144 { SLOW_OAM_LINK_EVENT_ERR_FRM, "Errored Frame Event" },
145 { SLOW_OAM_LINK_EVENT_ERR_FRM_PER, "Errored Frame Period Event" },
146 { SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM, "Errored Frame Seconds Summary Event" },
147 { SLOW_OAM_LINK_EVENT_ORG_SPECIFIC, "Organization specific" },
148 { 0, NULL}
149 };
150  
151 struct slow_oam_link_event_t {
152 uint8_t event_type;
153 uint8_t event_length;
154 uint8_t time_stamp[2];
155 uint8_t window[8];
156 uint8_t threshold[8];
157 uint8_t errors[8];
158 uint8_t errors_running_total[8];
159 uint8_t event_running_total[4];
160 };
161  
162 struct slow_oam_variablerequest_t {
163 uint8_t branch;
164 uint8_t leaf[2];
165 };
166  
167 struct slow_oam_variableresponse_t {
168 uint8_t branch;
169 uint8_t leaf[2];
170 uint8_t length;
171 };
172  
173 struct slow_oam_loopbackctrl_t {
174 uint8_t command;
175 };
176  
177 static const struct tok slow_oam_loopbackctrl_cmd_values[] = {
178 { 0x01, "Enable OAM Remote Loopback" },
179 { 0x02, "Disable OAM Remote Loopback" },
180 { 0, NULL}
181 };
182  
183 struct tlv_header_t {
184 uint8_t type;
185 uint8_t length;
186 };
187  
188 #define LACP_TLV_TERMINATOR 0x00
189 #define LACP_TLV_ACTOR_INFO 0x01
190 #define LACP_TLV_PARTNER_INFO 0x02
191 #define LACP_TLV_COLLECTOR_INFO 0x03
192  
193 #define MARKER_TLV_TERMINATOR 0x00
194 #define MARKER_TLV_MARKER_INFO 0x01
195  
196 static const struct tok slow_tlv_values[] = {
197 { (SLOW_PROTO_LACP << 8) + LACP_TLV_TERMINATOR, "Terminator"},
198 { (SLOW_PROTO_LACP << 8) + LACP_TLV_ACTOR_INFO, "Actor Information"},
199 { (SLOW_PROTO_LACP << 8) + LACP_TLV_PARTNER_INFO, "Partner Information"},
200 { (SLOW_PROTO_LACP << 8) + LACP_TLV_COLLECTOR_INFO, "Collector Information"},
201  
202 { (SLOW_PROTO_MARKER << 8) + MARKER_TLV_TERMINATOR, "Terminator"},
203 { (SLOW_PROTO_MARKER << 8) + MARKER_TLV_MARKER_INFO, "Marker Information"},
204 { 0, NULL}
205 };
206  
207 struct lacp_tlv_actor_partner_info_t {
208 uint8_t sys_pri[2];
209 uint8_t sys[ETHER_ADDR_LEN];
210 uint8_t key[2];
211 uint8_t port_pri[2];
212 uint8_t port[2];
213 uint8_t state;
214 uint8_t pad[3];
215 };
216  
217 static const struct tok lacp_tlv_actor_partner_info_state_values[] = {
218 { 0x01, "Activity"},
219 { 0x02, "Timeout"},
220 { 0x04, "Aggregation"},
221 { 0x08, "Synchronization"},
222 { 0x10, "Collecting"},
223 { 0x20, "Distributing"},
224 { 0x40, "Default"},
225 { 0x80, "Expired"},
226 { 0, NULL}
227 };
228  
229 struct lacp_tlv_collector_info_t {
230 uint8_t max_delay[2];
231 uint8_t pad[12];
232 };
233  
234 struct marker_tlv_marker_info_t {
235 uint8_t req_port[2];
236 uint8_t req_sys[ETHER_ADDR_LEN];
237 uint8_t req_trans_id[4];
238 uint8_t pad[2];
239 };
240  
241 struct lacp_marker_tlv_terminator_t {
242 uint8_t pad[50];
243 };
244  
245 static void slow_marker_lacp_print(netdissect_options *, register const u_char *, register u_int);
246 static void slow_oam_print(netdissect_options *, register const u_char *, register u_int);
247  
248 const struct slow_common_header_t *slow_com_header;
249  
250 void
251 slow_print(netdissect_options *ndo,
252 register const u_char *pptr, register u_int len)
253 {
254 int print_version;
255  
256 slow_com_header = (const struct slow_common_header_t *)pptr;
257 ND_TCHECK(*slow_com_header);
258  
259 /*
260 * Sanity checking of the header.
261 */
262 switch (slow_com_header->proto_subtype) {
263 case SLOW_PROTO_LACP:
264 if (slow_com_header->version != LACP_VERSION) {
265 ND_PRINT((ndo, "LACP version %u packet not supported",slow_com_header->version));
266 return;
267 }
268 print_version = 1;
269 break;
270  
271 case SLOW_PROTO_MARKER:
272 if (slow_com_header->version != MARKER_VERSION) {
273 ND_PRINT((ndo, "MARKER version %u packet not supported",slow_com_header->version));
274 return;
275 }
276 print_version = 1;
277 break;
278  
279 case SLOW_PROTO_OAM: /* fall through */
280 print_version = 0;
281 break;
282  
283 default:
284 /* print basic information and exit */
285 print_version = -1;
286 break;
287 }
288  
289 if (print_version) {
290 ND_PRINT((ndo, "%sv%u, length %u",
291 tok2str(slow_proto_values, "unknown (%u)",slow_com_header->proto_subtype),
292 slow_com_header->version,
293 len));
294 } else {
295 /* some slow protos don't have a version number in the header */
296 ND_PRINT((ndo, "%s, length %u",
297 tok2str(slow_proto_values, "unknown (%u)",slow_com_header->proto_subtype),
298 len));
299 }
300  
301 /* unrecognized subtype */
302 if (print_version == -1) {
303 print_unknown_data(ndo, pptr, "\n\t", len);
304 return;
305 }
306  
307 if (!ndo->ndo_vflag)
308 return;
309  
310 switch (slow_com_header->proto_subtype) {
311 default: /* should not happen */
312 break;
313  
314 case SLOW_PROTO_OAM:
315 /* skip proto_subtype */
316 slow_oam_print(ndo, pptr+1, len-1);
317 break;
318  
319 case SLOW_PROTO_LACP: /* LACP and MARKER share the same semantics */
320 case SLOW_PROTO_MARKER:
321 /* skip slow_common_header */
322 len -= sizeof(const struct slow_common_header_t);
323 pptr += sizeof(const struct slow_common_header_t);
324 slow_marker_lacp_print(ndo, pptr, len);
325 break;
326 }
327 return;
328  
329 trunc:
330 ND_PRINT((ndo, "\n\t\t packet exceeded snapshot"));
331 }
332  
333 static void
334 slow_marker_lacp_print(netdissect_options *ndo,
335 register const u_char *tptr, register u_int tlen)
336 {
337 const struct tlv_header_t *tlv_header;
338 const u_char *tlv_tptr;
339 u_int tlv_len, tlv_tlen;
340  
341 union {
342 const struct lacp_marker_tlv_terminator_t *lacp_marker_tlv_terminator;
343 const struct lacp_tlv_actor_partner_info_t *lacp_tlv_actor_partner_info;
344 const struct lacp_tlv_collector_info_t *lacp_tlv_collector_info;
345 const struct marker_tlv_marker_info_t *marker_tlv_marker_info;
346 } tlv_ptr;
347  
348 while(tlen>0) {
349 /* did we capture enough for fully decoding the tlv header ? */
350 ND_TCHECK2(*tptr, sizeof(struct tlv_header_t));
351 tlv_header = (const struct tlv_header_t *)tptr;
352 tlv_len = tlv_header->length;
353  
354 ND_PRINT((ndo, "\n\t%s TLV (0x%02x), length %u",
355 tok2str(slow_tlv_values,
356 "Unknown",
357 (slow_com_header->proto_subtype << 8) + tlv_header->type),
358 tlv_header->type,
359 tlv_len));
360  
361 if ((tlv_len < sizeof(struct tlv_header_t) ||
362 tlv_len > tlen) &&
363 tlv_header->type != LACP_TLV_TERMINATOR &&
364 tlv_header->type != MARKER_TLV_TERMINATOR) {
365 ND_PRINT((ndo, "\n\t-----trailing data-----"));
366 print_unknown_data(ndo, tptr+sizeof(struct tlv_header_t), "\n\t ", tlen);
367 return;
368 }
369  
370 tlv_tptr=tptr+sizeof(struct tlv_header_t);
371 tlv_tlen=tlv_len-sizeof(struct tlv_header_t);
372  
373 /* did we capture enough for fully decoding the tlv ? */
374 ND_TCHECK2(*tptr, tlv_len);
375  
376 switch((slow_com_header->proto_subtype << 8) + tlv_header->type) {
377  
378 /* those two TLVs have the same structure -> fall through */
379 case ((SLOW_PROTO_LACP << 8) + LACP_TLV_ACTOR_INFO):
380 case ((SLOW_PROTO_LACP << 8) + LACP_TLV_PARTNER_INFO):
381 tlv_ptr.lacp_tlv_actor_partner_info = (const struct lacp_tlv_actor_partner_info_t *)tlv_tptr;
382  
383 ND_PRINT((ndo, "\n\t System %s, System Priority %u, Key %u" \
384 ", Port %u, Port Priority %u\n\t State Flags [%s]",
385 etheraddr_string(ndo, tlv_ptr.lacp_tlv_actor_partner_info->sys),
386 EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->sys_pri),
387 EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->key),
388 EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->port),
389 EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->port_pri),
390 bittok2str(lacp_tlv_actor_partner_info_state_values,
391 "none",
392 tlv_ptr.lacp_tlv_actor_partner_info->state)));
393  
394 break;
395  
396 case ((SLOW_PROTO_LACP << 8) + LACP_TLV_COLLECTOR_INFO):
397 tlv_ptr.lacp_tlv_collector_info = (const struct lacp_tlv_collector_info_t *)tlv_tptr;
398  
399 ND_PRINT((ndo, "\n\t Max Delay %u",
400 EXTRACT_16BITS(tlv_ptr.lacp_tlv_collector_info->max_delay)));
401  
402 break;
403  
404 case ((SLOW_PROTO_MARKER << 8) + MARKER_TLV_MARKER_INFO):
405 tlv_ptr.marker_tlv_marker_info = (const struct marker_tlv_marker_info_t *)tlv_tptr;
406  
407 ND_PRINT((ndo, "\n\t Request System %s, Request Port %u, Request Transaction ID 0x%08x",
408 etheraddr_string(ndo, tlv_ptr.marker_tlv_marker_info->req_sys),
409 EXTRACT_16BITS(tlv_ptr.marker_tlv_marker_info->req_port),
410 EXTRACT_32BITS(tlv_ptr.marker_tlv_marker_info->req_trans_id)));
411  
412 break;
413  
414 /* those two TLVs have the same structure -> fall through */
415 case ((SLOW_PROTO_LACP << 8) + LACP_TLV_TERMINATOR):
416 case ((SLOW_PROTO_MARKER << 8) + LACP_TLV_TERMINATOR):
417 tlv_ptr.lacp_marker_tlv_terminator = (const struct lacp_marker_tlv_terminator_t *)tlv_tptr;
418 if (tlv_len == 0) {
419 tlv_len = sizeof(tlv_ptr.lacp_marker_tlv_terminator->pad) +
420 sizeof(struct tlv_header_t);
421 /* tell the user that we modified the length field */
422 if (ndo->ndo_vflag>1)
423 ND_PRINT((ndo, " (=%u)", tlv_len));
424 /* we have messed around with the length field - now we need to check
425 * again if there are enough bytes on the wire for the hexdump */
426 ND_TCHECK2(tlv_ptr.lacp_marker_tlv_terminator->pad[0],
427 sizeof(tlv_ptr.lacp_marker_tlv_terminator->pad));
428 }
429  
430 break;
431  
432 default:
433 if (ndo->ndo_vflag <= 1)
434 print_unknown_data(ndo, tlv_tptr, "\n\t ", tlv_tlen);
435 break;
436 }
437 /* do we want to see an additional hexdump ? */
438 if (ndo->ndo_vflag > 1) {
439 print_unknown_data(ndo, tptr+sizeof(struct tlv_header_t), "\n\t ",
440 tlv_len-sizeof(struct tlv_header_t));
441 }
442  
443 tptr+=tlv_len;
444 tlen-=tlv_len;
445 }
446 return;
447 trunc:
448 ND_PRINT((ndo, "\n\t\t packet exceeded snapshot"));
449 }
450  
451 static void
452 slow_oam_print(netdissect_options *ndo,
453 register const u_char *tptr, register u_int tlen)
454 {
455 u_int hexdump;
456  
457 struct slow_oam_common_header_t {
458 uint8_t flags[2];
459 uint8_t code;
460 };
461  
462 struct slow_oam_tlv_header_t {
463 uint8_t type;
464 uint8_t length;
465 };
466  
467 union {
468 const struct slow_oam_common_header_t *slow_oam_common_header;
469 const struct slow_oam_tlv_header_t *slow_oam_tlv_header;
470 } ptr;
471  
472 union {
473 const struct slow_oam_info_t *slow_oam_info;
474 const struct slow_oam_link_event_t *slow_oam_link_event;
475 const struct slow_oam_variablerequest_t *slow_oam_variablerequest;
476 const struct slow_oam_variableresponse_t *slow_oam_variableresponse;
477 const struct slow_oam_loopbackctrl_t *slow_oam_loopbackctrl;
478 } tlv;
479  
480 ptr.slow_oam_common_header = (struct slow_oam_common_header_t *)tptr;
481 tptr += sizeof(struct slow_oam_common_header_t);
482 tlen -= sizeof(struct slow_oam_common_header_t);
483  
484 ND_PRINT((ndo, "\n\tCode %s OAM PDU, Flags [%s]",
485 tok2str(slow_oam_code_values, "Unknown (%u)", ptr.slow_oam_common_header->code),
486 bittok2str(slow_oam_flag_values,
487 "none",
488 EXTRACT_16BITS(&ptr.slow_oam_common_header->flags))));
489  
490 switch (ptr.slow_oam_common_header->code) {
491 case SLOW_OAM_CODE_INFO:
492 while (tlen > 0) {
493 ptr.slow_oam_tlv_header = (const struct slow_oam_tlv_header_t *)tptr;
494 ND_PRINT((ndo, "\n\t %s Information Type (%u), length %u",
495 tok2str(slow_oam_info_type_values, "Reserved",
496 ptr.slow_oam_tlv_header->type),
497 ptr.slow_oam_tlv_header->type,
498 ptr.slow_oam_tlv_header->length));
499  
500 hexdump = FALSE;
501 switch (ptr.slow_oam_tlv_header->type) {
502 case SLOW_OAM_INFO_TYPE_END_OF_TLV:
503 if (ptr.slow_oam_tlv_header->length != 0) {
504 ND_PRINT((ndo, "\n\t ERROR: illegal length - should be 0"));
505 }
506 return;
507  
508 case SLOW_OAM_INFO_TYPE_LOCAL: /* identical format - fall through */
509 case SLOW_OAM_INFO_TYPE_REMOTE:
510 tlv.slow_oam_info = (const struct slow_oam_info_t *)tptr;
511  
512 if (tlv.slow_oam_info->info_length !=
513 sizeof(struct slow_oam_info_t)) {
514 ND_PRINT((ndo, "\n\t ERROR: illegal length - should be %lu",
515 (unsigned long) sizeof(struct slow_oam_info_t)));
516 return;
517 }
518  
519 ND_PRINT((ndo, "\n\t OAM-Version %u, Revision %u",
520 tlv.slow_oam_info->oam_version,
521 EXTRACT_16BITS(&tlv.slow_oam_info->revision)));
522  
523 ND_PRINT((ndo, "\n\t State-Parser-Action %s, State-MUX-Action %s",
524 tok2str(slow_oam_info_type_state_parser_values, "Reserved",
525 tlv.slow_oam_info->state & OAM_INFO_TYPE_PARSER_MASK),
526 tok2str(slow_oam_info_type_state_mux_values, "Reserved",
527 tlv.slow_oam_info->state & OAM_INFO_TYPE_MUX_MASK)));
528 ND_PRINT((ndo, "\n\t OAM-Config Flags [%s], OAM-PDU-Config max-PDU size %u",
529 bittok2str(slow_oam_info_type_oam_config_values, "none",
530 tlv.slow_oam_info->oam_config),
531 EXTRACT_16BITS(&tlv.slow_oam_info->oam_pdu_config) &
532 OAM_INFO_TYPE_PDU_SIZE_MASK));
533 ND_PRINT((ndo, "\n\t OUI %s (0x%06x), Vendor-Private 0x%08x",
534 tok2str(oui_values, "Unknown",
535 EXTRACT_24BITS(&tlv.slow_oam_info->oui)),
536 EXTRACT_24BITS(&tlv.slow_oam_info->oui),
537 EXTRACT_32BITS(&tlv.slow_oam_info->vendor_private)));
538 break;
539  
540 case SLOW_OAM_INFO_TYPE_ORG_SPECIFIC:
541 hexdump = TRUE;
542 break;
543  
544 default:
545 hexdump = TRUE;
546 break;
547 }
548  
549 /* infinite loop check */
550 if (!ptr.slow_oam_tlv_header->length) {
551 return;
552 }
553  
554 /* do we also want to see a hex dump ? */
555 if (ndo->ndo_vflag > 1 || hexdump==TRUE) {
556 print_unknown_data(ndo, tptr, "\n\t ",
557 ptr.slow_oam_tlv_header->length);
558 }
559  
560 tlen -= ptr.slow_oam_tlv_header->length;
561 tptr += ptr.slow_oam_tlv_header->length;
562 }
563 break;
564  
565 case SLOW_OAM_CODE_EVENT_NOTIF:
566 while (tlen > 0) {
567 ptr.slow_oam_tlv_header = (const struct slow_oam_tlv_header_t *)tptr;
568 ND_PRINT((ndo, "\n\t %s Link Event Type (%u), length %u",
569 tok2str(slow_oam_link_event_values, "Reserved",
570 ptr.slow_oam_tlv_header->type),
571 ptr.slow_oam_tlv_header->type,
572 ptr.slow_oam_tlv_header->length));
573  
574 hexdump = FALSE;
575 switch (ptr.slow_oam_tlv_header->type) {
576 case SLOW_OAM_LINK_EVENT_END_OF_TLV:
577 if (ptr.slow_oam_tlv_header->length != 0) {
578 ND_PRINT((ndo, "\n\t ERROR: illegal length - should be 0"));
579 }
580 return;
581  
582 case SLOW_OAM_LINK_EVENT_ERR_SYM_PER: /* identical format - fall through */
583 case SLOW_OAM_LINK_EVENT_ERR_FRM:
584 case SLOW_OAM_LINK_EVENT_ERR_FRM_PER:
585 case SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM:
586 tlv.slow_oam_link_event = (const struct slow_oam_link_event_t *)tptr;
587  
588 if (tlv.slow_oam_link_event->event_length !=
589 sizeof(struct slow_oam_link_event_t)) {
590 ND_PRINT((ndo, "\n\t ERROR: illegal length - should be %lu",
591 (unsigned long) sizeof(struct slow_oam_link_event_t)));
592 return;
593 }
594  
595 ND_PRINT((ndo, "\n\t Timestamp %u ms, Errored Window %" PRIu64
596 "\n\t Errored Threshold %" PRIu64
597 "\n\t Errors %" PRIu64
598 "\n\t Error Running Total %" PRIu64
599 "\n\t Event Running Total %u",
600 EXTRACT_16BITS(&tlv.slow_oam_link_event->time_stamp)*100,
601 EXTRACT_64BITS(&tlv.slow_oam_link_event->window),
602 EXTRACT_64BITS(&tlv.slow_oam_link_event->threshold),
603 EXTRACT_64BITS(&tlv.slow_oam_link_event->errors),
604 EXTRACT_64BITS(&tlv.slow_oam_link_event->errors_running_total),
605 EXTRACT_32BITS(&tlv.slow_oam_link_event->event_running_total)));
606 break;
607  
608 case SLOW_OAM_LINK_EVENT_ORG_SPECIFIC:
609 hexdump = TRUE;
610 break;
611  
612 default:
613 hexdump = TRUE;
614 break;
615 }
616  
617 /* infinite loop check */
618 if (!ptr.slow_oam_tlv_header->length) {
619 return;
620 }
621  
622 /* do we also want to see a hex dump ? */
623 if (ndo->ndo_vflag > 1 || hexdump==TRUE) {
624 print_unknown_data(ndo, tptr, "\n\t ",
625 ptr.slow_oam_tlv_header->length);
626 }
627  
628 tlen -= ptr.slow_oam_tlv_header->length;
629 tptr += ptr.slow_oam_tlv_header->length;
630 }
631 break;
632  
633 case SLOW_OAM_CODE_LOOPBACK_CTRL:
634 tlv.slow_oam_loopbackctrl = (const struct slow_oam_loopbackctrl_t *)tptr;
635 ND_PRINT((ndo, "\n\t Command %s (%u)",
636 tok2str(slow_oam_loopbackctrl_cmd_values,
637 "Unknown",
638 tlv.slow_oam_loopbackctrl->command),
639 tlv.slow_oam_loopbackctrl->command));
640 tptr ++;
641 tlen --;
642 break;
643  
644 /*
645 * FIXME those are the defined codes that lack a decoder
646 * you are welcome to contribute code ;-)
647 */
648 case SLOW_OAM_CODE_VAR_REQUEST:
649 case SLOW_OAM_CODE_VAR_RESPONSE:
650 case SLOW_OAM_CODE_PRIVATE:
651 default:
652 if (ndo->ndo_vflag <= 1) {
653 print_unknown_data(ndo, tptr, "\n\t ", tlen);
654 }
655 break;
656 }
657 return;
658 }