Correctly check for various values of the ICMP type field.

[tcpdump] / print-slow.c

diff --git a/print-slow.c b/print-slow.c
index 7a8770824276242209aefb107a3d74f41aaa9c57..eaf94ed9bbbccdc92d7cf2eb608eb5358eb0337c 100644 (file)
--- a/print-slow.c
+++ b/print-slow.c
@@ -20,7 +20,7 @@
 
 #ifndef lint
 static const char rcsid[] _U_ =
 
 #ifndef lint
 static const char rcsid[] _U_ =

-    "@(#) $Header: /tcpdump/master/tcpdump/print-slow.c,v 1.2 2006-02-16 16:42:44 hannes Exp $";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-slow.c,v 1.8 2006-10-12 05:44:33 hannes Exp $";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H


@@ -37,6 +37,7 @@ static const char rcsid[] _U_ =
 #include "extract.h"
 #include "addrtoname.h"
 #include "ether.h"
 #include "extract.h"
 #include "addrtoname.h"
 #include "ether.h"

+#include "oui.h"

 
 struct slow_common_header_t {
     u_int8_t proto_subtype;
 
 struct slow_common_header_t {
     u_int8_t proto_subtype;


@@ -85,6 +86,108 @@ static const struct tok slow_oam_code_values[] = {
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 

+struct slow_oam_info_t {
+    u_int8_t info_type;
+    u_int8_t info_length;
+    u_int8_t oam_version;
+    u_int8_t revision[2];
+    u_int8_t state;
+    u_int8_t oam_config;
+    u_int8_t oam_pdu_config[2];
+    u_int8_t oui[3];
+    u_int8_t vendor_private[4];
+};
+
+#define SLOW_OAM_INFO_TYPE_END_OF_TLV 0x00
+#define SLOW_OAM_INFO_TYPE_LOCAL 0x01
+#define SLOW_OAM_INFO_TYPE_REMOTE 0x02
+#define SLOW_OAM_INFO_TYPE_ORG_SPECIFIC 0xfe
+
+static const struct tok slow_oam_info_type_values[] = {
+    { SLOW_OAM_INFO_TYPE_END_OF_TLV, "End of TLV marker" },
+    { SLOW_OAM_INFO_TYPE_LOCAL, "Local" },
+    { SLOW_OAM_INFO_TYPE_REMOTE, "Remote" },
+    { SLOW_OAM_INFO_TYPE_ORG_SPECIFIC, "Organization specific" },
+    { 0, NULL}
+};
+
+#define OAM_INFO_TYPE_PARSER_MASK 0x3
+static const struct tok slow_oam_info_type_state_parser_values[] = {
+    { 0x00, "forwarding" },
+    { 0x01, "looping back" },
+    { 0x02, "discarding" },
+    { 0x03, "reserved" },
+    { 0, NULL}
+};
+
+#define OAM_INFO_TYPE_MUX_MASK 0x4
+static const struct tok slow_oam_info_type_state_mux_values[] = {
+    { 0x00, "forwarding" },
+    { 0x04, "discarding" },
+    { 0, NULL}
+};
+
+static const struct tok slow_oam_info_type_oam_config_values[] = {
+    { 0x01, "Active" },
+    { 0x02, "Unidirectional" },
+    { 0x04, "Remote-Loopback" },
+    { 0x08, "Link-Events" },
+    { 0x10, "Variable-Retrieval" },
+    { 0, NULL}
+};
+
+/* 11 Bits */
+#define OAM_INFO_TYPE_PDU_SIZE_MASK 0x7ff
+
+#define SLOW_OAM_LINK_EVENT_END_OF_TLV 0x00
+#define SLOW_OAM_LINK_EVENT_ERR_SYM_PER 0x01
+#define SLOW_OAM_LINK_EVENT_ERR_FRM 0x02
+#define SLOW_OAM_LINK_EVENT_ERR_FRM_PER 0x03
+#define SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM 0x04
+#define SLOW_OAM_LINK_EVENT_ORG_SPECIFIC 0xfe
+
+static const struct tok slow_oam_link_event_values[] = {
+    { SLOW_OAM_LINK_EVENT_END_OF_TLV, "End of TLV marker" },
+    { SLOW_OAM_LINK_EVENT_ERR_SYM_PER, "Errored Symbol Period Event" },
+    { SLOW_OAM_LINK_EVENT_ERR_FRM, "Errored Frame Event" },
+    { SLOW_OAM_LINK_EVENT_ERR_FRM_PER, "Errored Frame Period Event" },
+    { SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM, "Errored Frame Seconds Summary Event" },
+    { SLOW_OAM_LINK_EVENT_ORG_SPECIFIC, "Organization specific" },
+    { 0, NULL}
+};
+
+struct slow_oam_link_event_t {
+    u_int8_t event_type;
+    u_int8_t event_length;
+    u_int8_t time_stamp[2];
+    u_int8_t window[8];
+    u_int8_t threshold[8];
+    u_int8_t errors[8];
+    u_int8_t errors_running_total[8];
+    u_int8_t event_running_total[4];
+};
+
+struct slow_oam_variablerequest_t {
+    u_int8_t branch;
+    u_int8_t leaf[2];
+};
+
+struct slow_oam_variableresponse_t {
+    u_int8_t branch;
+    u_int8_t leaf[2];
+    u_int8_t length;
+};
+
+struct slow_oam_loopbackctrl_t {
+    u_int8_t command;
+};
+
+static const struct tok slow_oam_loopbackctrl_cmd_values[] = {
+    { 0x01, "Enable OAM Remote Loopback" },
+    { 0x02, "Disable OAM Remote Loopback" },
+    { 0, NULL}
+};
+

 struct tlv_header_t {
     u_int8_t type;
     u_int8_t length;
 struct tlv_header_t {
     u_int8_t type;
     u_int8_t length;


@@ -352,27 +455,201 @@ trunc:
 
 void slow_oam_print(register const u_char *tptr, register u_int tlen) {
 
 
 void slow_oam_print(register const u_char *tptr, register u_int tlen) {
 

+    u_int hexdump;
+

     struct slow_oam_common_header_t {
         u_int8_t flags[2];
         u_int8_t code;
     };
     struct slow_oam_common_header_t {
         u_int8_t flags[2];
         u_int8_t code;
     };

-    const struct slow_oam_common_header_t *slow_oam_common_header;
+
+    struct slow_oam_tlv_header_t {
+        u_int8_t type;
+        u_int8_t length;
+    };
+
+    union {
+        const struct slow_oam_common_header_t *slow_oam_common_header;
+        const struct slow_oam_tlv_header_t *slow_oam_tlv_header;
+    } ptr;
+
+    union {
+       const struct slow_oam_info_t *slow_oam_info;
+        const struct slow_oam_link_event_t *slow_oam_link_event;
+        const struct slow_oam_variablerequest_t *slow_oam_variablerequest;
+        const struct slow_oam_variableresponse_t *slow_oam_variableresponse;
+        const struct slow_oam_loopbackctrl_t *slow_oam_loopbackctrl;
+    } tlv;

     
     

-    slow_oam_common_header = (struct slow_oam_common_header_t *)tptr;
+    ptr.slow_oam_common_header = (struct slow_oam_common_header_t *)tptr;
+    tptr += sizeof(struct slow_oam_common_header_t);
+    tlen -= sizeof(struct slow_oam_common_header_t);

 
 

-    printf("Flags [ %s ], Code %s",
+    printf("\n\tCode %s OAM PDU, Flags [%s]",
+           tok2str(slow_oam_code_values, "Unknown (%u)", ptr.slow_oam_common_header->code),

            bittok2str(slow_oam_flag_values,
                       "none",
            bittok2str(slow_oam_flag_values,
                       "none",

-                      EXTRACT_16BITS(&slow_oam_common_header->flags)),
-           tok2str(slow_oam_code_values, "Unknown (%u)", slow_oam_common_header->code));
+                      EXTRACT_16BITS(&ptr.slow_oam_common_header->flags)));

 
 

-    switch (slow_oam_common_header->code) {
-        /* FIXME no codes yet known - just hexdump for now */
+    switch (ptr.slow_oam_common_header->code) {

     case SLOW_OAM_CODE_INFO:
     case SLOW_OAM_CODE_INFO:

+        while (tlen > 0) {
+            ptr.slow_oam_tlv_header = (const struct slow_oam_tlv_header_t *)tptr;
+            printf("\n\t  %s Information Type (%u), length %u",
+                   tok2str(slow_oam_info_type_values, "Reserved",
+                           ptr.slow_oam_tlv_header->type),
+                   ptr.slow_oam_tlv_header->type,
+                   ptr.slow_oam_tlv_header->length);
+
+            hexdump = FALSE;
+            switch (ptr.slow_oam_tlv_header->type) {
+            case SLOW_OAM_INFO_TYPE_END_OF_TLV:
+                if (ptr.slow_oam_tlv_header->length != 0) {
+                    printf("\n\t    ERROR: illegal length - should be 0");
+                }
+                return;
+                
+            case SLOW_OAM_INFO_TYPE_LOCAL: /* identical format - fall through */
+            case SLOW_OAM_INFO_TYPE_REMOTE:
+                tlv.slow_oam_info = (const struct slow_oam_info_t *)tptr;
+                
+                if (tlv.slow_oam_info->info_length !=
+                    sizeof(struct slow_oam_info_t)) {
+                    printf("\n\t    ERROR: illegal length - should be %lu",
+                           (unsigned long) sizeof(struct slow_oam_info_t));
+                    return;
+                }
+
+                printf("\n\t    OAM-Version %u, Revision %u",
+                       tlv.slow_oam_info->oam_version,
+                       EXTRACT_16BITS(&tlv.slow_oam_info->revision));
+
+                printf("\n\t    State-Parser-Action %s, State-MUX-Action %s",
+                       tok2str(slow_oam_info_type_state_parser_values, "Reserved",
+                               tlv.slow_oam_info->state & OAM_INFO_TYPE_PARSER_MASK),
+                       tok2str(slow_oam_info_type_state_mux_values, "Reserved",
+                               tlv.slow_oam_info->state & OAM_INFO_TYPE_MUX_MASK));
+                printf("\n\t    OAM-Config Flags [%s], OAM-PDU-Config max-PDU size %u",
+                       bittok2str(slow_oam_info_type_oam_config_values, "none",
+                                  tlv.slow_oam_info->oam_config),
+                       EXTRACT_16BITS(&tlv.slow_oam_info->oam_pdu_config) &
+                       OAM_INFO_TYPE_PDU_SIZE_MASK);
+                printf("\n\t    OUI %s (0x%06x), Vendor-Private 0x%08x",
+                       tok2str(oui_values, "Unknown",
+                               EXTRACT_24BITS(&tlv.slow_oam_info->oui)),
+                       EXTRACT_24BITS(&tlv.slow_oam_info->oui),
+                       EXTRACT_32BITS(&tlv.slow_oam_info->vendor_private));
+                break;
+                
+            case SLOW_OAM_INFO_TYPE_ORG_SPECIFIC:
+                hexdump = TRUE;
+                break;
+                
+            default:
+                hexdump = TRUE;
+                break;
+            }
+
+            /* infinite loop check */
+            if (!ptr.slow_oam_tlv_header->length) {
+                return;
+            }
+
+            /* do we also want to see a hex dump ? */
+            if (vflag > 1 || hexdump==TRUE) {
+                print_unknown_data(tptr,"\n\t  ",
+                                   ptr.slow_oam_tlv_header->length);
+            }
+
+            tlen -= ptr.slow_oam_tlv_header->length;
+            tptr += ptr.slow_oam_tlv_header->length;
+        }
+        break;
+

     case SLOW_OAM_CODE_EVENT_NOTIF:
     case SLOW_OAM_CODE_EVENT_NOTIF:

+        while (tlen > 0) {
+            ptr.slow_oam_tlv_header = (const struct slow_oam_tlv_header_t *)tptr;
+            printf("\n\t  %s Link Event Type (%u), length %u",
+                   tok2str(slow_oam_link_event_values, "Reserved",
+                           ptr.slow_oam_tlv_header->type),
+                   ptr.slow_oam_tlv_header->type,
+                   ptr.slow_oam_tlv_header->length);
+
+            hexdump = FALSE;
+            switch (ptr.slow_oam_tlv_header->type) {
+            case SLOW_OAM_LINK_EVENT_END_OF_TLV:
+                if (ptr.slow_oam_tlv_header->length != 0) {
+                    printf("\n\t    ERROR: illegal length - should be 0");
+                }
+                return;
+                
+            case SLOW_OAM_LINK_EVENT_ERR_SYM_PER: /* identical format - fall through */
+            case SLOW_OAM_LINK_EVENT_ERR_FRM:
+            case SLOW_OAM_LINK_EVENT_ERR_FRM_PER:
+            case SLOW_OAM_LINK_EVENT_ERR_FRM_SUMM:
+                tlv.slow_oam_link_event = (const struct slow_oam_link_event_t *)tptr;
+                
+                if (tlv.slow_oam_link_event->event_length !=
+                    sizeof(struct slow_oam_link_event_t)) {
+                    printf("\n\t    ERROR: illegal length - should be %lu",
+                           (unsigned long) sizeof(struct slow_oam_link_event_t));
+                    return;
+                }
+
+                printf("\n\t    Timestamp %u ms, Errored Window %" PRIu64
+                       "\n\t    Errored Threshold %" PRIu64
+                       "\n\t    Errors %" PRIu64
+                       "\n\t    Error Running Total %" PRIu64
+                       "\n\t    Event Running Total %u",
+                       EXTRACT_16BITS(&tlv.slow_oam_link_event->time_stamp)*100,
+                       EXTRACT_64BITS(&tlv.slow_oam_link_event->window),
+                       EXTRACT_64BITS(&tlv.slow_oam_link_event->threshold),
+                       EXTRACT_64BITS(&tlv.slow_oam_link_event->errors),
+                       EXTRACT_64BITS(&tlv.slow_oam_link_event->errors_running_total),
+                       EXTRACT_32BITS(&tlv.slow_oam_link_event->event_running_total));
+                break;
+                
+            case SLOW_OAM_LINK_EVENT_ORG_SPECIFIC:
+                hexdump = TRUE;
+                break;
+                
+            default:
+                hexdump = TRUE;
+                break;
+            }
+
+            /* infinite loop check */
+            if (!ptr.slow_oam_tlv_header->length) {
+                return;
+            }
+
+            /* do we also want to see a hex dump ? */
+            if (vflag > 1 || hexdump==TRUE) {
+                print_unknown_data(tptr,"\n\t  ",
+                                   ptr.slow_oam_tlv_header->length);
+            }
+
+            tlen -= ptr.slow_oam_tlv_header->length;
+            tptr += ptr.slow_oam_tlv_header->length;
+        }
+        break;
+ 
+    case SLOW_OAM_CODE_LOOPBACK_CTRL:
+        tlv.slow_oam_loopbackctrl = (const struct slow_oam_loopbackctrl_t *)tptr;
+        printf("\n\t  Command %s (%u)",
+               tok2str(slow_oam_loopbackctrl_cmd_values,
+                       "Unknown",
+                       tlv.slow_oam_loopbackctrl->command),
+               tlv.slow_oam_loopbackctrl->command);
+               tptr ++;
+               tlen --;
+        break;
+
+        /*
+         * FIXME those are the defined codes that lack a decoder
+         * you are welcome to contribute code ;-)
+         */

     case SLOW_OAM_CODE_VAR_REQUEST:
     case SLOW_OAM_CODE_VAR_RESPONSE:
     case SLOW_OAM_CODE_VAR_REQUEST:
     case SLOW_OAM_CODE_VAR_RESPONSE:

-    case SLOW_OAM_CODE_LOOPBACK_CTRL:

     case SLOW_OAM_CODE_PRIVATE:
     default:
         if (vflag <= 1) {
     case SLOW_OAM_CODE_PRIVATE:
     default:
         if (vflag <= 1) {


@@ -380,10 +657,5 @@ void slow_oam_print(register const u_char *tptr, register u_int tlen) {
         }
         break;
     }
         }
         break;
     }

-    /* do we want to see an additional hexdump ? */
-    if (vflag > 1) {
-        print_unknown_data(tptr,"\n\t  ", tlen);
-    }
-

     return;
 }
     return;
 }