break;    }    return;trunc:    printf("\n\t\t packet exceeded snapshot");}void slow_marker_lacp_print(register const u_char *tptr, register u_int tlen) {    const struct tlv_header_t *tlv_header;    const u_char *tlv_tptr;    u_int tlv_len, tlv_tlen;    union {        const struct lacp_marker_tlv_terminator_t *lacp_marker_tlv_terminator;        const struct lacp_tlv_actor_partner_info_t *lacp_tlv_actor_partner_info;        const struct lacp_tlv_collector_info_t *lacp_tlv_collector_info;        const struct marker_tlv_marker_info_t *marker_tlv_marker_info;    } tlv_ptr;        while(tlen>0) {        /* did we capture enough for fully decoding the tlv header ? */        TCHECK2(*tptr, sizeof(struct tlv_header_t));        tlv_header = (const struct tlv_header_t *)tptr;        tlv_len = tlv_header->length;        printf("\n\t%s TLV (0x%02x), length %u",               tok2str(slow_tlv_values,                       "Unknown",                       (slow_com_header->proto_subtype << 8) + tlv_header->type),               tlv_header->type,               tlv_len);        if ((tlv_len < sizeof(struct tlv_header_t) ||            tlv_len > tlen) &&            tlv_header->type != LACP_TLV_TERMINATOR &&            tlv_header->type != MARKER_TLV_TERMINATOR) {            printf("\n\t-----trailing data-----");            print_unknown_data(tptr+sizeof(sizeof(struct tlv_header_t)),"\n\t  ",tlen);            return;        }        tlv_tptr=tptr+sizeof(struct tlv_header_t);        tlv_tlen=tlv_len-sizeof(struct tlv_header_t);        /* did we capture enough for fully decoding the tlv ? */        TCHECK2(*tptr, tlv_len);        switch((slow_com_header->proto_subtype << 8) + tlv_header->type) {            /* those two TLVs have the same structure -> fall through */        case ((SLOW_PROTO_LACP << 8) + LACP_TLV_ACTOR_INFO):        case ((SLOW_PROTO_LACP << 8) + LACP_TLV_PARTNER_INFO):            tlv_ptr.lacp_tlv_actor_partner_info = (const struct lacp_tlv_actor_partner_info_t *)tlv_tptr;            printf("\n\t  System %s, System Priority %u, Key %u" \                   ", Port %u, Port Priority %u\n\t  State Flags [%s]",                   etheraddr_string(tlv_ptr.lacp_tlv_actor_partner_info->sys),                   EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->sys_pri),                   EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->key),                   EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->port),                   EXTRACT_16BITS(tlv_ptr.lacp_tlv_actor_partner_info->port_pri),                   bittok2str(lacp_tlv_actor_partner_info_state_values,                              "none",                              tlv_ptr.lacp_tlv_actor_partner_info->state));            break;        case ((SLOW_PROTO_LACP << 8) + LACP_TLV_COLLECTOR_INFO):            tlv_ptr.lacp_tlv_collector_info = (const struct lacp_tlv_collector_info_t *)tlv_tptr;            printf("\n\t  Max Delay %u",                   EXTRACT_16BITS(tlv_ptr.lacp_tlv_collector_info->max_delay));            break;        case ((SLOW_PROTO_MARKER << 8) + MARKER_TLV_MARKER_INFO):            tlv_ptr.marker_tlv_marker_info = (const struct marker_tlv_marker_info_t *)tlv_tptr;            printf("\n\t  Request System %s, Request Port %u, Request Transaction ID 0x%08x",                   etheraddr_string(tlv_ptr.marker_tlv_marker_info->req_sys),                   EXTRACT_16BITS(tlv_ptr.marker_tlv_marker_info->req_port),                   EXTRACT_32BITS(tlv_ptr.marker_tlv_marker_info->req_trans_id));            break;            /* those two TLVs have the same structure -> fall through */        case ((SLOW_PROTO_LACP << 8) + LACP_TLV_TERMINATOR):        case ((SLOW_PROTO_MARKER << 8) + LACP_TLV_TERMINATOR):            tlv_ptr.lacp_marker_tlv_terminator = (const struct lacp_marker_tlv_terminator_t *)tlv_tptr;            if (tlv_len == 0) {                tlv_len = sizeof(tlv_ptr.lacp_marker_tlv_terminator->pad) +                    sizeof(struct tlv_header_t);                /* tell the user that we modified the length field  */                if (vflag>1)                    printf(" (=%u)",tlv_len);                /* we have messed around with the length field - now we need to check                 * again if there are enough bytes on the wire for the hexdump */                TCHECK2(tlv_ptr.lacp_marker_tlv_terminator->pad[0],                        sizeof(tlv_ptr.lacp_marker_tlv_terminator->pad));            }            break;        default:            if (vflag <= 1)                print_unknown_data(tlv_tptr,"\n\t  ",tlv_tlen);            break;        }        /* do we want to see an additional hexdump ? */        if (vflag > 1) {            print_unknown_data(tptr+sizeof(sizeof(struct tlv_header_t)),"\n\t  ",                               tlv_len-sizeof(struct tlv_header_t));        }        tptr+=tlv_len;        tlen-=tlv_len;    }    return;trunc:    printf("\n\t\t packet exceeded snapshot");}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_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;        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("\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",                      EXTRACT_16BITS(&ptr.slow_oam_common_header->flags)));    switch (ptr.slow_oam_common_header->code) {    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:        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_PRIVATE:    default:        if (vflag <= 1) {            print_unknown_data(tptr,"\n\t  ", tlen);        }        break;    }    return;}