}	default:            if (vflag <= 1) {		    if (pptr < snapend)                             print_unknown_data(pptr,"\n\t  ",snapend-pptr);            }            return;	}        /* now walk the options */        while (li >= 2) {            u_int op, opli;            const u_int8_t *tptr;                        TCHECK2(*pptr, 2);            if (li < 2) {                printf(", bad opts/li");                return;            }            op = *pptr++;            opli = *pptr++;            li -= 2;            if (opli > li) {                printf(", opt (%d) too long", op);                return;            }            li -= opli;            tptr = pptr;                        printf("\n\t  %s Option #%u, length %u, value: ",                   tok2str(esis_option_values,"Unknown",op),                   op,                   opli);            switch (op) {            case ESIS_OPTION_ES_CONF_TIME:                TCHECK2(*pptr, 2);                printf("%us", EXTRACT_16BITS(tptr));                break;            case ESIS_OPTION_PROTOCOLS:                while (opli>0) {                    TCHECK(*pptr);                    printf("%s (0x%02x)",                           tok2str(nlpid_values,                                   "unknown",                                   *tptr),                           *tptr);                    if (opli>1) /* further NPLIDs ? - put comma */                        printf(", ");                    tptr++;                    opli--;                }                break;                /*                 * FIXME those are the defined Options that lack a decoder                 * you are welcome to contribute code ;-)                 */            case ESIS_OPTION_QOS_MAINTENANCE:            case ESIS_OPTION_SECURITY:            case ESIS_OPTION_PRIORITY:            case ESIS_OPTION_ADDRESS_MASK:            case ESIS_OPTION_SNPA_MASK:            default:                print_unknown_data(tptr,"\n\t  ",opli);                break;            }            if (vflag > 1)                print_unknown_data(pptr,"\n\t  ",opli);            pptr += opli;        }trunc:	return;}   /* shared routine for printing system, node and lsp-ids */static char *isis_print_id(const u_int8_t *cp, int id_len){    int i;    static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];    char *pos = id;    for (i = 1; i <= SYSTEM_ID_LEN; i++) {        snprintf(pos, sizeof(id) - (pos - id), "%02x", *cp++);	pos += strlen(pos);	if (i == 2 || i == 4)	    *pos++ = '.';	}    if (id_len >= NODE_ID_LEN) {        snprintf(pos, sizeof(id) - (pos - id), ".%02x", *cp++);	pos += strlen(pos);    }    if (id_len == LSP_ID_LEN)        snprintf(pos, sizeof(id) - (pos - id), "-%02x", *cp);    return (id);}/* print the 4-byte metric block which is common found in the old-style TLVs */static intisis_print_metric_block (const struct isis_metric_block *isis_metric_block){    printf(", Default Metric: %d, %s",           ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_default),           ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_default) ? "External" : "Internal");    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_delay))        printf("\n\t\t  Delay Metric: %d, %s",               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_delay),               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_delay) ? "External" : "Internal");    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_expense))        printf("\n\t\t  Expense Metric: %d, %s",               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_expense),               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_expense) ? "External" : "Internal");    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_error))        printf("\n\t\t  Error Metric: %d, %s",               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_error),               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_error) ? "External" : "Internal");    return(1); /* everything is ok */}static intisis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length){	int prefix_len;	const struct isis_tlv_ip_reach *tlv_ip_reach;	tlv_ip_reach = (const struct isis_tlv_ip_reach *)cp;	while (length > 0) {		if ((size_t)length < sizeof(*tlv_ip_reach)) {			printf("short IPv4 Reachability (%d vs %lu)",                               length,                               (unsigned long)sizeof(*tlv_ip_reach));			return (0);		}		if (!TTEST(*tlv_ip_reach))		    return (0);		prefix_len = mask2plen(EXTRACT_32BITS(tlv_ip_reach->mask));		if (prefix_len == -1)			printf("%sIPv4 prefix: %s mask %s",                               ident,			       ipaddr_string((tlv_ip_reach->prefix)),			       ipaddr_string((tlv_ip_reach->mask)));		else			printf("%sIPv4 prefix: %15s/%u",                               ident,			       ipaddr_string((tlv_ip_reach->prefix)),			       prefix_len);		printf(", Distribution: %s, Metric: %u, %s",                       ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->isis_metric_block.metric_default) ? "down" : "up",                       ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_default),                       ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_default) ? "External" : "Internal");		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_delay))                    printf("%s  Delay Metric: %u, %s",                           ident,                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_delay),                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_delay) ? "External" : "Internal");                		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_expense))                    printf("%s  Expense Metric: %u, %s",                           ident,                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_expense),                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_expense) ? "External" : "Internal");                		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_error))                    printf("%s  Error Metric: %u, %s",                           ident,                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_error),                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_error) ? "External" : "Internal");		length -= sizeof(struct isis_tlv_ip_reach);		tlv_ip_reach++;	}	return (1);}/* * this is the common IP-REACH subTLV decoder it is called * from various EXTD-IP REACH TLVs (135,235,236,237) */static intisis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {        /* first lets see if we know the subTLVs name*/	printf("%s%s subTLV #%u, length: %u",	       ident,               tok2str(isis_ext_ip_reach_subtlv_values,                       "unknown",                       subt),               subt,               subl);	if (!TTEST2(*tptr,subl))	    goto trunctlv;    switch(subt) {    case ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR: /* fall through */    case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32:        while (subl >= 4) {	    printf(", 0x%08x (=%u)",		   EXTRACT_32BITS(tptr),		   EXTRACT_32BITS(tptr));	    tptr+=4;	    subl-=4;	}	break;    case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:        while (subl >= 8) {	    printf(", 0x%08x%08x",		   EXTRACT_32BITS(tptr),		   EXTRACT_32BITS(tptr+4));	    tptr+=8;	    subl-=8;	}	break;    default:	if(!print_unknown_data(tptr,"\n\t\t    ",			       subl))	  return(0);	break;    }    return(1);	trunctlv:    printf("%spacket exceeded snapshot",ident);    return(0);}/* * this is the common IS-REACH subTLV decoder it is called * from isis_print_ext_is_reach() */static intisis_print_is_reach_subtlv (const u_int8_t *tptr,u_int subt,u_int subl,const char *ident) {        u_int te_class,priority_level,gmpls_switch_cap;        union { /* int to float conversion buffer for several subTLVs */            float f;             u_int32_t i;        } bw;        /* first lets see if we know the subTLVs name*/	printf("%s%s subTLV #%u, length: %u",	       ident,               tok2str(isis_ext_is_reach_subtlv_values,                       "unknown",                       subt),               subt,               subl);	if (!TTEST2(*tptr,subl))	    goto trunctlv;        switch(subt) {        case ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP:              case ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:        case ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:	    if (subl >= 4) {	      printf(", 0x%08x", EXTRACT_32BITS(tptr));	      if (subl == 8) /* rfc4205 */	        printf(", 0x%08x", EXTRACT_32BITS(tptr+4));	    }	    break;        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:            if (subl >= sizeof(struct in_addr))              printf(", %s", ipaddr_string(tptr));            break;        case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :	case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:              if (subl >= 4) {              bw.i = EXTRACT_32BITS(tptr);              printf(", %.3f Mbps", bw.f*8/1000000 );            }            break;        case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :            if (subl >= 32) {              for (te_class = 0; te_class < 8; te_class++) {                bw.i = EXTRACT_32BITS(tptr);                printf("%s  TE-Class %u: %.3f Mbps",                       ident,                       te_class,                       bw.f*8/1000000 );		tptr+=4;	      }            }            break;        case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS: /* fall through */        case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD:            printf("%sBandwidth Constraints Model ID: %s (%u)",                   ident,                   tok2str(diffserv_te_bc_values, "unknown", *tptr),                   *tptr);            tptr++;            /* decode BCs until the subTLV ends */            for (te_class = 0; te_class < (subl-1)/4; te_class++) {                bw.i = EXTRACT_32BITS(tptr);                printf("%s  Bandwidth constraint CT%u: %.3f Mbps",                       ident,                       te_class,                       bw.f*8/1000000 );		tptr+=4;            }            break;        case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:            if (subl >= 3)              printf(", %u", EXTRACT_24BITS(tptr));            break;        case ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE:            if (subl == 2) {               printf(", [ %s ] (0x%04x)",                      bittok2str(isis_subtlv_link_attribute_values,                                 "Unknown",                                 EXTRACT_16BITS(tptr)),                      EXTRACT_16BITS(tptr));            }            break;        case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:            if (subl >= 2) {              printf(", %s, Priority %u",		   bittok2str(gmpls_link_prot_values, "none", *tptr),                   *(tptr+1));            }            break;        case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:            if (subl >= 36) {              gmpls_switch_cap = *tptr;              printf("%s  Interface Switching Capability:%s",                   ident,                   tok2str(gmpls_switch_cap_values, "Unknown", gmpls_switch_cap));              printf(", LSP Encoding: %s",                   tok2str(gmpls_encoding_values, "Unknown", *(tptr+1)));	      tptr+=4;              printf("%s  Max LSP Bandwidth:",ident);              for (priority_level = 0; priority_level < 8; priority_level++) {                bw.i = EXTRACT_32BITS(tptr);                printf("%s    priority level %d: %.3f Mbps",                       ident,                       priority_level,                       bw.f*8/1000000 );		tptr+=4;              }              subl-=36;              switch (gmpls_switch_cap) {              case GMPLS_PSC1:              case GMPLS_PSC2:              case GMPLS_PSC3:              case GMPLS_PSC4:                bw.i = EXTRACT_32BITS(tptr);                printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);                printf("%s  Interface MTU: %u", ident, EXTRACT_16BITS(tptr+4));                break;              case GMPLS_TSC:                bw.i = EXTRACT_32BITS(tptr);                printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);                printf("%s  Indication %s", ident,                       tok2str(gmpls_switch_cap_tsc_indication_values, "Unknown (%u)", *(tptr+4)));                break;              default:                /* there is some optional stuff left to decode but this is as of yet                   not specified so just lets hexdump what is left */                if(subl>0){                  if(!print_unknown_data(tptr,"\n\t\t    ",                                         subl))                    return(0);                }              }            }            break;        default:            if(!print_unknown_data(tptr,"\n\t\t    ",				   subl))                return(0);            break;        }        return(1);