自学教程：C++ tok2str函数代码示例

voidvtp_print (netdissect_options *ndo,           const u_char *pptr, u_int length){    int type, len, tlv_len, tlv_value;    const u_char *tptr;    const struct vtp_vlan_ *vtp_vlan;    if (length < VTP_HEADER_LEN)        goto trunc;    tptr = pptr;    if (!ND_TTEST2(*tptr, VTP_HEADER_LEN))	goto trunc;    type = *(tptr+1);    ND_PRINT((ndo, "VTPv%u, Message %s (0x%02x), length %u",	   *tptr,	   tok2str(vtp_message_type_values,"Unknown message type", type),	   *(tptr+1),	   length));    /* In non-verbose mode, just print version and message type */    if (ndo->ndo_vflag < 1) {        return;    }    /* verbose mode print all fields */    ND_PRINT((ndo, "/n/tDomain name: %s, %s: %u",	   (tptr+4),	   tok2str(vtp_header_values,"Unknown",*(tptr+1)),	   *(tptr+2)));    tptr += VTP_HEADER_LEN;    switch (type) {    case VTP_SUMMARY_ADV:	/*	 *  SUMMARY ADVERTISEMENT	 *	 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |     Version   |     Code      |    Followers  |    MmgtD Len  |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                    Management Domain Name                     |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                    Configuration revision number              |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                  Updater Identity IP address                  |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                    Update Timestamp (12 bytes)                |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                        MD5 digest (16 bytes)                  |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *	 */	ND_PRINT((ndo, "/n/t  Config Rev %x, Updater %s",	       EXTRACT_32BITS(tptr),	       ipaddr_string(tptr+4)));	tptr += 8;	ND_PRINT((ndo, ", Timestamp 0x%08x 0x%08x 0x%08x",	       EXTRACT_32BITS(tptr),	       EXTRACT_32BITS(tptr + 4),	       EXTRACT_32BITS(tptr + 8)));	tptr += VTP_UPDATE_TIMESTAMP_LEN;	ND_PRINT((ndo, ", MD5 digest: %08x%08x%08x%08x",	       EXTRACT_32BITS(tptr),	       EXTRACT_32BITS(tptr + 4),	       EXTRACT_32BITS(tptr + 8),	       EXTRACT_32BITS(tptr + 12)));	tptr += VTP_MD5_DIGEST_LEN;	break;    case VTP_SUBSET_ADV:	/*	 *  SUBSET ADVERTISEMENT	 *	 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |     Version   |     Code      |   Seq number  |    MmgtD Len  |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                    Management Domain Name                     |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                    Configuration revision number              |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                         VLAN info field 1                     |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                         ................                      |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *  |                         VLAN info field N                     |	 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	 *	 */	ND_PRINT((ndo, ", Config Rev %x", EXTRACT_32BITS(tptr)));//.........这里部分代码省略.........

voiddtp_print (netdissect_options *ndo, const u_char *pptr, u_int length){    int type, len;    const u_char *tptr;    if (length < DTP_HEADER_LEN)        goto trunc;    tptr = pptr;    ND_TCHECK2(*tptr, DTP_HEADER_LEN);    ND_PRINT((ndo, "DTPv%u, length %u",           (*tptr),           length));    /*     * In non-verbose mode, just print version.     */    if (ndo->ndo_vflag < 1) {	return;    }    tptr += DTP_HEADER_LEN;    while (tptr < (pptr+length)) {        ND_TCHECK2(*tptr, 4);	type = EXTRACT_16BITS(tptr);        len  = EXTRACT_16BITS(tptr+2);        /* infinite loop check */        if (type == 0 || len == 0) {            return;        }        ND_PRINT((ndo, "/n/t%s (0x%04x) TLV, length %u",               tok2str(dtp_tlv_values, "Unknown", type),               type, len));        switch (type) {	case DTP_DOMAIN_TLV:		ND_PRINT((ndo, ", %s", tptr+4));		break;	case DTP_STATUS_TLV:	case DTP_DTP_TYPE_TLV:                ND_PRINT((ndo, ", 0x%x", *(tptr+4)));                break;	case DTP_NEIGHBOR_TLV:                ND_PRINT((ndo, ", %s", etheraddr_string(ndo, tptr+4)));                break;        default:            break;        }        tptr += len;    }    return; trunc:    ND_PRINT((ndo, "[|dtp]"));}

static voidprint_attr_string(netdissect_options *ndo,                  register u_char *data, u_int length, u_short attr_code){   register u_int i;   ND_TCHECK2(data[0],length);   switch(attr_code)   {      case TUNNEL_PASS:           if (length < 3)           {              ND_PRINT((ndo, "%s", tstr));              return;           }           if (*data && (*data <=0x1F) )              ND_PRINT((ndo, "Tag[%u] ", *data));           else              ND_PRINT((ndo, "Tag[Unused] "));           data++;           length--;           ND_PRINT((ndo, "Salt %u ", EXTRACT_16BITS(data)));           data+=2;           length-=2;        break;      case TUNNEL_CLIENT_END:      case TUNNEL_SERVER_END:      case TUNNEL_PRIV_GROUP:      case TUNNEL_ASSIGN_ID:      case TUNNEL_CLIENT_AUTH:      case TUNNEL_SERVER_AUTH:           if (*data <= 0x1F)           {              if (length < 1)              {                 ND_PRINT((ndo, "%s", tstr));                 return;              }              if (*data)                ND_PRINT((ndo, "Tag[%u] ", *data));              else                ND_PRINT((ndo, "Tag[Unused] "));              data++;              length--;           }        break;      case EGRESS_VLAN_NAME:           ND_PRINT((ndo, "%s (0x%02x) ",                  tok2str(rfc4675_tagged,"Unknown tag",*data),                  *data));           data++;           length--;        break;   }   for (i=0; *data && i < length ; i++, data++)       ND_PRINT((ndo, "%c", (*data < 32 || *data > 128) ? '.' : *data));   return;   trunc:      ND_PRINT((ndo, "%s", tstr));}

u_intjuniper_es_print(const struct pcap_pkthdr *h, register const u_char *p){        struct juniper_l2info_t l2info;        struct juniper_ipsec_header {            u_int8_t sa_index[2];            u_int8_t ttl;            u_int8_t type;            u_int8_t spi[4];            u_int8_t src_ip[4];            u_int8_t dst_ip[4];        };        u_int rewrite_len,es_type_bundle;        const struct juniper_ipsec_header *ih;        l2info.pictype = DLT_JUNIPER_ES;        if(juniper_parse_header(p, h, &l2info) == 0)            return l2info.header_len;        p+=l2info.header_len;        ih = (struct juniper_ipsec_header *)p;        switch (ih->type) {        case JUNIPER_IPSEC_O_ESP_ENCRYPT_ESP_AUTHEN_TYPE:        case JUNIPER_IPSEC_O_ESP_ENCRYPT_AH_AUTHEN_TYPE:            rewrite_len = 0;            es_type_bundle = 1;            break;        case JUNIPER_IPSEC_O_ESP_AUTHENTICATION_TYPE:        case JUNIPER_IPSEC_O_AH_AUTHENTICATION_TYPE:        case JUNIPER_IPSEC_O_ESP_ENCRYPTION_TYPE:            rewrite_len = 16;            es_type_bundle = 0;        default:            printf("ES Invalid type %u, length %u",                   ih->type,                   l2info.length);            return l2info.header_len;        }        l2info.length-=rewrite_len;        p+=rewrite_len;        if (eflag) {            if (!es_type_bundle) {                printf("ES SA, index %u, ttl %u type %s (%u), spi %u, Tunnel %s > %s, length %u/n",                        EXTRACT_16BITS(&ih->sa_index),                       ih->ttl,                        tok2str(juniper_ipsec_type_values,"Unknown",ih->type),                       ih->type,                       EXTRACT_32BITS(&ih->spi),                       ipaddr_string(EXTRACT_32BITS(&ih->src_ip)),                       ipaddr_string(EXTRACT_32BITS(&ih->dst_ip)),                       l2info.length);            } else {                printf("ES SA, index %u, ttl %u type %s (%u), length %u/n",                        EXTRACT_16BITS(&ih->sa_index),                       ih->ttl,                        tok2str(juniper_ipsec_type_values,"Unknown",ih->type),                       ih->type,                       l2info.length);            }        }        ip_print(gndo, p, l2info.length);        return l2info.header_len;}

static voidkrb4_print(const u_char *cp){	register const struct krb *kp;	u_char type;	u_short len;#define PRINT		if ((cp = c_print(cp, snapend)) == NULL) goto trunc/*  True if struct krb is little endian */#define IS_LENDIAN(kp)	(((kp)->type & 0x01) != 0)#define KTOHSP(kp, cp)	(IS_LENDIAN(kp) ? EXTRACT_LE_16BITS(cp) : EXTRACT_16BITS(cp))	kp = (struct krb *)cp;	if ((&kp->type) >= snapend) {		fputs(tstr, stdout);		return;	}	type = kp->type & (0xFF << 1);	printf(" %s %s: ",	    IS_LENDIAN(kp) ? "le" : "be", tok2str(type2str, NULL, type));	switch (type) {	case AUTH_MSG_KDC_REQUEST:		if ((cp = krb4_print_hdr(cp)) == NULL)			return;		cp += 4;	/* ctime */		TCHECK(*cp);		printf(" %dmin ", *cp++ * 5);		PRINT;		putchar('.');		PRINT;		break;	case AUTH_MSG_APPL_REQUEST:		cp += 2;		TCHECK(*cp);		printf("v%d ", *cp++);		PRINT;		TCHECK(*cp);		printf(" (%d)", *cp++);		TCHECK(*cp);		printf(" (%d)", *cp);		break;	case AUTH_MSG_KDC_REPLY:		if ((cp = krb4_print_hdr(cp)) == NULL)			return;		cp += 10;	/* timestamp + n + exp + kvno */		TCHECK2(*cp, sizeof(short));		len = KTOHSP(kp, cp);		printf(" (%d)", len);		break;	case AUTH_MSG_ERR_REPLY:		if ((cp = krb4_print_hdr(cp)) == NULL)			return;		cp += 4; 	  /* timestamp */		TCHECK2(*cp, sizeof(short));		printf(" %s ", tok2str(kerr2str, NULL, KTOHSP(kp, cp)));		cp += 4;		PRINT;		break;	default:		fputs("(unknown)", stdout);		break;	}	return;trunc:	fputs(tstr, stdout);}

/* * Sub-TLVs consume the "extra data" of Babel TLVs (see Section 4.3 of RFC6126), * their encoding is similar to the encoding of TLVs, but the type namespace is * different: * * o Type 0 stands for Pad1 sub-TLV with the same encoding as the Pad1 TLV. * o Type 1 stands for PadN sub-TLV with the same encoding as the PadN TLV. * o Type 2 stands for Diversity sub-TLV, which propagates diversity routing *   data. Its body is a variable-length sequence of 8-bit unsigned integers, *   each representing per-hop number of interferring radio channel for the *   prefix. Channel 0 is invalid and must not be used in the sub-TLV, channel *   255 interferes with any other channel. * o Type 3 stands for Timestamp sub-TLV, used to compute RTT between *   neighbours. In the case of a Hello TLV, the body stores a 32-bits *   timestamp, while in the case of a IHU TLV, two 32-bits timestamps are *   stored. * * Sub-TLV types 0 and 1 are valid for any TLV type, whether sub-TLV type 2 is * only valid for TLV type 8 (Update). Note that within an Update TLV a missing * Diversity sub-TLV is not the same as a Diversity sub-TLV with an empty body. * The former would mean a lack of any claims about the interference, and the * latter would state that interference is definitely absent. * A type 3 sub-TLV is valid both for Hello and IHU TLVs, though the exact * semantic of the sub-TLV is different in each case. */static voidsubtlvs_print(netdissect_options *ndo,              const u_char *cp, const u_char *ep, const uint8_t tlv_type){    uint8_t subtype, sublen;    const char *sep;    uint32_t t1, t2;    while (cp < ep) {        subtype = *cp++;        if(subtype == MESSAGE_SUB_PAD1) {            ND_PRINT((ndo, " sub-pad1"));            continue;        }        if(cp == ep)            goto corrupt;        sublen = *cp++;        if(cp + sublen > ep)            goto corrupt;        switch(subtype) {        case MESSAGE_SUB_PADN:            ND_PRINT((ndo, " sub-padn"));            cp += sublen;            break;        case MESSAGE_SUB_DIVERSITY:            ND_PRINT((ndo, " sub-diversity"));            if (sublen == 0) {                ND_PRINT((ndo, " empty"));                break;            }            sep = " ";            while(sublen--) {                ND_PRINT((ndo, "%s%s", sep, tok2str(diversity_str, "%u", *cp++)));                sep = "-";            }            if(tlv_type != MESSAGE_UPDATE &&               tlv_type != MESSAGE_UPDATE_SRC_SPECIFIC)                ND_PRINT((ndo, " (bogus)"));            break;        case MESSAGE_SUB_TIMESTAMP:            ND_PRINT((ndo, " sub-timestamp"));            if(tlv_type == MESSAGE_HELLO) {                if(sublen < 4)                    goto corrupt;                t1 = EXTRACT_32BITS(cp);                ND_PRINT((ndo, " %s", format_timestamp(t1)));            } else if(tlv_type == MESSAGE_IHU) {                if(sublen < 8)                    goto corrupt;                t1 = EXTRACT_32BITS(cp);                ND_PRINT((ndo, " %s", format_timestamp(t1)));                t2 = EXTRACT_32BITS(cp + 4);                ND_PRINT((ndo, "|%s", format_timestamp(t2)));            } else                ND_PRINT((ndo, " (bogus)"));            cp += sublen;            break;        default:            ND_PRINT((ndo, " sub-unknown-0x%02x", subtype));            cp += sublen;        } /* switch */    } /* while */    return; corrupt:    ND_PRINT((ndo, " (corrupt)"));}

/* * Print a single PDU. */static voidrpki_rtr_pdu_print (const u_char *tptr, u_int indent){    const rpki_rtr_pdu *pdu_header;    u_int pdu_type, pdu_len, hexdump;    const u_char *msg;    pdu_header = (rpki_rtr_pdu *)tptr;    pdu_type = pdu_header->pdu_type;    pdu_len = EXTRACT_32BITS(pdu_header->length);    hexdump = FALSE;    printf("%sRPKI-RTRv%u, %s PDU (%u), length: %u",	   indent_string(8),	   pdu_header->version,	   tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),	   pdu_type, pdu_len);    switch (pdu_type) {	/*	 * The following PDUs share the message format.	 */    case RPKI_RTR_SERIAL_NOTIFY_PDU:    case RPKI_RTR_SERIAL_QUERY_PDU:    case RPKI_RTR_END_OF_DATA_PDU:        msg = (const u_char *)(pdu_header + 1);	printf("%sCache-Nonce: 0x%04x, Serial: %u",	       indent_string(indent+2),	       EXTRACT_16BITS(pdu_header->u.cache_nonce),	       EXTRACT_32BITS(msg));	break;	/*	 * The following PDUs share the message format.	 */    case RPKI_RTR_RESET_QUERY_PDU:    case RPKI_RTR_CACHE_RESET_PDU:	/*	 * Zero payload PDUs.	 */	break;    case RPKI_RTR_CACHE_RESPONSE_PDU:	printf("%sCache-Nonce: 0x%04x",	       indent_string(indent+2),	       EXTRACT_16BITS(pdu_header->u.cache_nonce));	break;    case RPKI_RTR_IPV4_PREFIX_PDU:	{	    rpki_rtr_pdu_ipv4_prefix *pdu;	    pdu = (rpki_rtr_pdu_ipv4_prefix *)tptr;	    printf("%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",		   indent_string(indent+2),		   ipaddr_string(pdu->prefix),		   pdu->prefix_length, pdu->max_length,		   EXTRACT_32BITS(pdu->as), pdu->flags);	}	break;#ifdef INET6    case RPKI_RTR_IPV6_PREFIX_PDU:	{	    rpki_rtr_pdu_ipv6_prefix *pdu;	    pdu = (rpki_rtr_pdu_ipv6_prefix *)tptr;	    printf("%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",		   indent_string(indent+2),		   ip6addr_string(pdu->prefix),		   pdu->prefix_length, pdu->max_length,		   EXTRACT_32BITS(pdu->as), pdu->flags);	}	break;#endif    case RPKI_RTR_ERROR_REPORT_PDU:	{	    rpki_rtr_pdu_error_report *pdu;	    u_int encapsulated_pdu_length, text_length, tlen, error_code;	    u_char buf[80];	    pdu = (rpki_rtr_pdu_error_report *)tptr;	    encapsulated_pdu_length = EXTRACT_32BITS(pdu->encapsulated_pdu_length);	    tlen = pdu_len;	    error_code = EXTRACT_16BITS(pdu->pdu_header.u.error_code);	    printf("%sError code: %s (%u), Encapsulated PDU length: %u",		   indent_string(indent+2),		   tok2str(rpki_rtr_error_codes, "Unknown", error_code),		   error_code, encapsulated_pdu_length);	    tptr += sizeof(*pdu);	    tlen -= sizeof(*pdu);//.........这里部分代码省略.........

static intpdatacnt_print(netdissect_options *ndo,               register const u_char * pptr, register u_int len,               u_int16_t IDcnt, u_int16_t op_msk, int indent){	u_int i;	u_int32_t id;	char *ib = indent_pr(indent, 0);	if ((op_msk & B_APPND) && ndo->ndo_vflag >= 3) {		ND_PRINT((ndo, "%sTABLE APPEND/n", ib));	}	for (i = 0; i < IDcnt; i++) {		ND_TCHECK2(*pptr, 4);		if (len < 4)			goto trunc;		id = EXTRACT_32BITS(pptr);		if (ndo->ndo_vflag >= 3)			ND_PRINT((ndo, "%sID#%02u: %d/n", ib, i + 1, id));		len -= 4;		pptr += 4;	}	if ((op_msk & B_TRNG) || (op_msk & B_KEYIN)) {		if (op_msk & B_TRNG) {			u_int32_t starti, endi;			if (len < PTH_DESC_SIZE) {				ND_PRINT((ndo, "pathlength %d with key/range too short %d/n",				       len, PTH_DESC_SIZE));				return -1;			}			pptr += sizeof(struct forces_tlv);			len -= sizeof(struct forces_tlv);			starti = EXTRACT_32BITS(pptr);			pptr += 4;			len -= 4;			endi = EXTRACT_32BITS(pptr);			pptr += 4;			len -= 4;			if (ndo->ndo_vflag >= 3)				ND_PRINT((ndo, "%sTable range: [%d,%d]/n", ib, starti, endi));		}		if (op_msk & B_KEYIN) {			struct forces_tlv *keytlv;			u_int16_t tll;			if (len < PTH_DESC_SIZE) {				ND_PRINT((ndo, "pathlength %d with key/range too short %d/n",				       len, PTH_DESC_SIZE));				return -1;			}			/* skip keyid */			pptr += 4;			len -= 4;			keytlv = (struct forces_tlv *)pptr;			/* skip header */			pptr += sizeof(struct forces_tlv);			len -= sizeof(struct forces_tlv);			/* skip key content */			tll = EXTRACT_16BITS(&keytlv->length);			if (tll < TLV_HDRL) {				ND_PRINT((ndo, "key content length %u < %u/n",					tll, TLV_HDRL));				return -1;			}			tll -= TLV_HDRL;			if (len < tll) {				ND_PRINT((ndo, "key content too short/n"));				return -1;			}			pptr += tll;			len -= tll;		}	}	if (len) {		const struct forces_tlv *pdtlv = (struct forces_tlv *)pptr;		u_int16_t type;		u_int16_t tll;		int pad = 0;		u_int aln;		u_int invtlv;		ND_TCHECK(*pdtlv);		type = EXTRACT_16BITS(&pdtlv->type);		invtlv = tlv_valid(pdtlv, len);		if (invtlv) {			ND_PRINT((ndo, "%s Outstanding bytes %d for TLV type 0x%x TLV len %d/n",			          tok2str(ForCES_TLV_err, NULL, invtlv), len, type,			          EXTRACT_16BITS(&pdtlv->length)));			goto pd_err;		}//.........这里部分代码省略.........

intether_encap_print(u_short ether_type, const u_char *p,    u_int length, u_int caplen, u_short *extracted_ether_type){ recurse:   *extracted_ether_type = ether_type;   switch (ether_type) {/*   case ETHERTYPE_DN:      decnet_print(p, length, caplen);      return (1);   case ETHERTYPE_ATALK:      if (ArgusParser->vflag)         sprintf(&ArgusBuf[strlen(ArgusBuf)],"et1 ");      atalk_print(p, length);      return (1);   case ETHERTYPE_AARP:      aarp_print(p, length);      return (1);   case ETHERTYPE_IPX:      sprintf(&ArgusBuf[strlen(ArgusBuf)],"(NOV-ETHII) ");      ipx_print(p, length);      return (1);   case ETHERTYPE_8021Q:           if (ArgusParser->eflag)          sprintf(&ArgusBuf[strlen(ArgusBuf)],"vlan %u, p %u%s, ",            ntohs(*(u_int16_t *)p) & 0xfff,            ntohs(*(u_int16_t *)p) >> 13,            (ntohs(*(u_int16_t *)p) & 0x1000) ? ", CFI" : "");      ether_type = ntohs(*(u_int16_t *)(p + 2));      p += 4;      length -= 4;      caplen -= 4;      if (ether_type > ETHERMTU) {              if (ArgusParser->eflag)                 sprintf(&ArgusBuf[strlen(ArgusBuf)],"ethertype %s, ",                   tok2str(ethertype_values,"0x%04x", ether_type));         goto recurse;      }      *extracted_ether_type = 0;      if (llc_print(p, length, caplen, p - 18, p - 12,          extracted_ether_type) == 0) {            ether_hdr_print(p - 18, length + 4);      }      if (!suppress_default_print)              default_print(p - 18, caplen + 4);      return (1);*/        case ETHERTYPE_JUMBO:                ether_type = ntohs(*(u_int16_t *)(p));                p += 2;                length -= 2;                      caplen -= 2;                if (ether_type > ETHERMTU) {                    if (ArgusParser->eflag)                        sprintf(&ArgusBuf[strlen(ArgusBuf)],"ethertype %s, ",                               tok2str(ethertype_values,"0x%04x", ether_type));                    goto recurse;                }                *extracted_ether_type = 0;/*                if (llc_print(p, length, caplen, p - 16, p - 10,                              extracted_ether_type) == 0) {                    ether_hdr_print(p - 16, length + 2);                }                if (!suppress_default_print)                    default_print(p - 16, caplen + 2);*/                return (1);        case ETHERTYPE_ISO:                isoclns_print(p+1, length-1, length-1);                return(1);/*   case ETHERTYPE_PPPOED:   case ETHERTYPE_PPPOES:      pppoe_print(p, length);      return (1);   case ETHERTYPE_EAPOL:           eap_print(gndo, p, length);      return (1);   case ETHERTYPE_PPP:      if (length) {         sprintf(&ArgusBuf[strlen(ArgusBuf)],": ");         ppp_print(p, length);//.........这里部分代码省略.........

voidtcp_print(netdissect_options *ndo,          const u_char *bp, u_int length,          const u_char *bp2, int fragmented){        const struct tcphdr *tp;        const struct ip *ip;        u_char flags;        u_int hlen;        char ch;        uint16_t sport, dport, win, urp;        uint32_t seq, ack, thseq, thack;        u_int utoval;        uint16_t magic;        int rev;        const struct ip6_hdr *ip6;        ndo->ndo_protocol = "tcp";        tp = (const struct tcphdr *)bp;        ip = (const struct ip *)bp2;        if (IP_V(ip) == 6)                ip6 = (const struct ip6_hdr *)bp2;        else                ip6 = NULL;        ch = '/0';        if (!ND_TTEST_2(tp->th_dport)) {                if (ip6) {                        ND_PRINT("%s > %s:",                                 ip6addr_string(ndo, ip6->ip6_src),                                 ip6addr_string(ndo, ip6->ip6_dst));                } else {                        ND_PRINT("%s > %s:",                                 ipaddr_string(ndo, ip->ip_src),                                 ipaddr_string(ndo, ip->ip_dst));                }                nd_print_trunc(ndo);                return;        }        sport = GET_BE_U_2(tp->th_sport);        dport = GET_BE_U_2(tp->th_dport);        if (ip6) {                if (GET_U_1(ip6->ip6_nxt) == IPPROTO_TCP) {                        ND_PRINT("%s.%s > %s.%s: ",                                 ip6addr_string(ndo, ip6->ip6_src),                                 tcpport_string(ndo, sport),                                 ip6addr_string(ndo, ip6->ip6_dst),                                 tcpport_string(ndo, dport));                } else {                        ND_PRINT("%s > %s: ",                                 tcpport_string(ndo, sport), tcpport_string(ndo, dport));                }        } else {                if (GET_U_1(ip->ip_p) == IPPROTO_TCP) {                        ND_PRINT("%s.%s > %s.%s: ",                                 ipaddr_string(ndo, ip->ip_src),                                 tcpport_string(ndo, sport),                                 ipaddr_string(ndo, ip->ip_dst),                                 tcpport_string(ndo, dport));                } else {                        ND_PRINT("%s > %s: ",                                 tcpport_string(ndo, sport), tcpport_string(ndo, dport));                }        }        ND_TCHECK_SIZE(tp);        hlen = TH_OFF(tp) * 4;        if (hlen < sizeof(*tp)) {                ND_PRINT(" tcp %u [bad hdr length %u - too short, < %lu]",                         length - hlen, hlen, (unsigned long)sizeof(*tp));                return;        }        seq = GET_BE_U_4(tp->th_seq);        ack = GET_BE_U_4(tp->th_ack);        win = GET_BE_U_2(tp->th_win);        urp = GET_BE_U_2(tp->th_urp);        if (ndo->ndo_qflag) {                ND_PRINT("tcp %u", length - hlen);                if (hlen > length) {                        ND_PRINT(" [bad hdr length %u - too long, > %u]",                                 hlen, length);                }                return;        }        flags = GET_U_1(tp->th_flags);        ND_PRINT("Flags [%s]", bittok2str_nosep(tcp_flag_values, "none", flags));        if (!ndo->ndo_Sflag && (flags & TH_ACK)) {                /*                 * Find (or record) the initial sequence numbers for                 * this conversation.  (we pick an arbitrary                 * collating order so there's only one entry for                 * both directions).                 *///.........这里部分代码省略.........

voidmldv2_report_print(const u_char *bp, u_int len){	struct icmp6_hdr *icp = (struct icmp6_hdr *) bp;	u_int group, nsrcs, ngroups;	u_int i, j;	if (len < MLDV2_REPORT_MINLEN) {		printf(" [invalid len %d]", len);		return;	}	TCHECK(icp->icmp6_data16[1]);	ngroups = ntohs(icp->icmp6_data16[1]);	printf(", %d group record(s)", ngroups);	if (vflag > 0) {		/* Print the group records */		group = MLDV2_REPORT_GROUP0;		for (i = 0; i < ngroups; i++) {			/* type(1) + auxlen(1) + numsrc(2) + grp(16) */			if (len < group + MLDV2_REPORT_MINGRPLEN) {				printf(" [invalid number of groups]");				return;			}			TCHECK2(bp[group + MLDV2_RGROUP_MADDR],			    sizeof(struct in6_addr));			printf(" [gaddr %s",			    ip6addr_string(&bp[group + MLDV2_RGROUP_MADDR]));			printf(" %s", tok2str(mldv2report2str,			    " [v2-report-#%d]", bp[group]));			nsrcs = (bp[group + MLDV2_RGROUP_NSRCS] << 8) +			    bp[group + MLDV2_RGROUP_NSRCS + 1];			/* Check the number of sources and print them */			if (len < group + MLDV2_REPORT_MINGRPLEN +				    (nsrcs * sizeof(struct in6_addr))) {				printf(" [invalid number of sources %d]", nsrcs);				return;			}			if (vflag == 1)				printf(", %d source(s)", nsrcs);			else {				/* Print the sources */				(void)printf(" {");				for (j = 0; j < nsrcs; j++) {					TCHECK2(bp[group +					    MLDV2_REPORT_MINGRPLEN +					    j * sizeof(struct in6_addr)],					    sizeof(struct in6_addr));					printf(" %s", ip6addr_string(&bp[group +					    MLDV2_REPORT_MINGRPLEN + j *					    sizeof(struct in6_addr)]));				}				(void)printf(" }");			}			/* Next group record */			group += MLDV2_REPORT_MINGRPLEN + nsrcs *			    sizeof(struct in6_addr);			printf("]");		}	}	return;trunc:	(void)printf("[|icmp6]");	return;}

static voidatmarp_print(netdissect_options *ndo,	     const u_char *bp, u_int length, u_int caplen){	const struct atmarp_pkthdr *ap;	u_short pro, hrd, op;	ap = (const struct atmarp_pkthdr *)bp;	ND_TCHECK(*ap);	hrd = ATMHRD(ap);	pro = ATMPRO(ap);	op = ATMOP(ap);	if (!ND_TTEST2(*aar_tpa(ap), ATMTPROTO_LEN(ap))) {		ND_PRINT((ndo, "[|ARP]"));		ND_DEFAULTPRINT((const u_char *)ap, length);		return;	}        if (!ndo->ndo_eflag) {            ND_PRINT((ndo, "ARP, "));        }	if ((pro != ETHERTYPE_IP && pro != ETHERTYPE_TRAIL) ||	    ATMSPROTO_LEN(ap) != 4 ||            ATMTPROTO_LEN(ap) != 4 ||            ndo->ndo_vflag) {                ND_PRINT((ndo, "%s, %s (len %u/%u)",                          tok2str(arphrd_values, "Unknown Hardware (%u)", hrd),                          tok2str(ethertype_values, "Unknown Protocol (0x%04x)", pro),                          ATMSPROTO_LEN(ap),                          ATMTPROTO_LEN(ap)));                /* don't know know about the address formats */                if (!ndo->ndo_vflag) {                    goto out;                }	}        /* print operation */        printf("%s%s ",               ndo->ndo_vflag ? ", " : "",                tok2str(arpop_values, "Unknown (%u)", op));	switch (op) {	case ARPOP_REQUEST:		ND_PRINT((ndo, "who-has %s", ipaddr_string(ATMTPA(ap))));		if (ATMTHRD_LEN(ap) != 0) {			ND_PRINT((ndo, " ("));			atmarp_addr_print(ndo, ATMTHA(ap), ATMTHRD_LEN(ap),			    ATMTSA(ap), ATMTSLN(ap));			ND_PRINT((ndo, ")"));		}		ND_PRINT((ndo, "tell %s", ipaddr_string(ATMSPA(ap))));		break;	case ARPOP_REPLY:		ND_PRINT((ndo, "%s is-at ", ipaddr_string(ATMSPA(ap))));		atmarp_addr_print(ndo, ATMSHA(ap), ATMSHRD_LEN(ap), ATMSSA(ap),                                  ATMSSLN(ap));		break;	case ARPOP_INVREQUEST:		ND_PRINT((ndo, "who-is "));		atmarp_addr_print(ndo, ATMTHA(ap), ATMTHRD_LEN(ap), ATMTSA(ap),		    ATMTSLN(ap));		ND_PRINT((ndo, " tell "));		atmarp_addr_print(ndo, ATMSHA(ap), ATMSHRD_LEN(ap), ATMSSA(ap),		    ATMSSLN(ap));		break;	case ARPOP_INVREPLY:		atmarp_addr_print(ndo, ATMSHA(ap), ATMSHRD_LEN(ap), ATMSSA(ap),		    ATMSSLN(ap));		ND_PRINT((ndo, "at %s", ipaddr_string(ATMSPA(ap))));		break;	case ARPOP_NAK:		ND_PRINT((ndo, "for %s", ipaddr_string(ATMSPA(ap))));		break;	default:		ND_DEFAULTPRINT((const u_char *)ap, caplen);		return;	} out:        ND_PRINT((ndo, ", length %u", length));        return;trunc:	ND_PRINT((ndo, "[|ARP]"));}

/* * Print trivial file transfer program requests */voidtftp_print(register const u_char *bp, u_int length){	register const struct tftphdr *tp;	register const char *cp;	register const u_char *p;	register int opcode, i;	static char tstr[] = " [|tftp]";	tp = (const struct tftphdr *)bp;	/* Print length */	printf(" %d", length);	/* Print tftp request type */	TCHECK(tp->th_opcode);	opcode = EXTRACT_16BITS(&tp->th_opcode);	cp = tok2str(op2str, "tftp-#%d", opcode);	printf(" %s", cp);	/* Bail if bogus opcode */	if (*cp == 't')		return;	switch (opcode) {	case RRQ:	case WRQ:	case OACK:		/*		 * XXX Not all arpa/tftp.h's specify th_stuff as any		 * array; use address of th_block instead		 */#ifdef notdef		p = (u_char *)tp->th_stuff;#else		p = (u_char *)&tp->th_block;#endif		putchar(' ');		/* Print filename or first option */		if (opcode != OACK)			putchar('"');		i = fn_print(p, snapend);		if (opcode != OACK)			putchar('"');		/* Print the mode (RRQ and WRQ only) and any options */		while ((p = (const u_char *)strchr((const char *)p, '/0')) != NULL) {			if (length <= (u_int)(p - (const u_char *)&tp->th_block))				break;			p++;			if (*p != '/0') {				putchar(' ');				fn_print(p, snapend);			}		}				if (i)			goto trunc;		break;	case ACK:	case DATA:		TCHECK(tp->th_block);		printf(" block %d", EXTRACT_16BITS(&tp->th_block));		break;	case ERROR:		/* Print error code string */		TCHECK(tp->th_code);		printf(" %s /"", tok2str(err2str, "tftp-err-#%d /"",				       EXTRACT_16BITS(&tp->th_code)));		/* Print error message string */		i = fn_print((const u_char *)tp->th_data, snapend);		putchar('"');		if (i)			goto trunc;		break;	default:		/* We shouldn't get here */		printf("(unknown #%d)", opcode);		break;	}	return;trunc:	fputs(tstr, stdout);	return;}

voidarp_print(netdissect_options *ndo,	  const u_char *bp, u_int length, u_int caplen){	const struct arp_pkthdr *ap;	u_short pro, hrd, op, linkaddr;	ap = (const struct arp_pkthdr *)bp;	ND_TCHECK(*ap);	hrd = HRD(ap);	pro = PRO(ap);	op = OP(ap);                /* if its ATM then call the ATM ARP printer           for Frame-relay ARP most of the fields           are similar to Ethernet so overload the Ethernet Printer           and set the linkaddr type for linkaddr_string() accordingly */        switch(hrd) {        case ARPHRD_ATM2225:            atmarp_print(ndo, bp, length, caplen);            return;        case ARPHRD_FRELAY:            linkaddr = LINKADDR_FRELAY;            break;        default:            linkaddr = LINKADDR_ETHER;            break;	}	if (!ND_TTEST2(*ar_tpa(ap), PROTO_LEN(ap))) {		ND_PRINT((ndo, "[|ARP]"));		ND_DEFAULTPRINT((const u_char *)ap, length);		return;	}        if (!ndo->ndo_eflag) {            ND_PRINT((ndo, "ARP, "));        }        /* print hardware type/len and proto type/len */        if ((pro != ETHERTYPE_IP && pro != ETHERTYPE_TRAIL) ||	    PROTO_LEN(ap) != 4 ||            HRD_LEN(ap) == 0 ||            ndo->ndo_vflag) {            ND_PRINT((ndo, "%s (len %u), %s (len %u)",                      tok2str(arphrd_values, "Unknown Hardware (%u)", hrd),                      HRD_LEN(ap),                      tok2str(ethertype_values, "Unknown Protocol (0x%04x)", pro),                      PROTO_LEN(ap)));            /* don't know know about the address formats */            if (!ndo->ndo_vflag) {                goto out;            }	}        /* print operation */        printf("%s%s ",               ndo->ndo_vflag ? ", " : "",                tok2str(arpop_values, "Unknown (%u)", op));	switch (op) {	case ARPOP_REQUEST:		ND_PRINT((ndo, "who-has %s", ipaddr_string(TPA(ap))));		if (memcmp((const char *)ezero, (const char *)THA(ap), HRD_LEN(ap)) != 0)			ND_PRINT((ndo, " (%s)",				  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap))));		ND_PRINT((ndo, " tell %s", ipaddr_string(SPA(ap))));		break;	case ARPOP_REPLY:		ND_PRINT((ndo, "%s is-at %s",                          ipaddr_string(SPA(ap)),                          linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));		break;	case ARPOP_REVREQUEST:		ND_PRINT((ndo, "who-is %s tell %s",			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),			  linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));		break;	case ARPOP_REVREPLY:		ND_PRINT((ndo, "%s at %s",			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),			  ipaddr_string(TPA(ap))));		break;	case ARPOP_INVREQUEST:		ND_PRINT((ndo, "who-is %s tell %s",			  linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)),			  linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap))));		break;	case ARPOP_INVREPLY:		ND_PRINT((ndo,"%s at %s",//.........这里部分代码省略.........

static intjuniper_parse_header (const u_char *p, const struct pcap_pkthdr *h, struct juniper_l2info_t *l2info) {    struct juniper_cookie_table_t *lp = juniper_cookie_table;    u_int idx, offset;#ifdef DLT_JUNIPER_ATM2    u_int32_t control_word;#endif    l2info->header_len = 0;    l2info->cookie_len = 0;    l2info->proto = 0;    l2info->length = h->len;    l2info->caplen = h->caplen;    l2info->direction = p[3]&JUNIPER_BPF_PKT_IN;        TCHECK2(p[0],4);    if (EXTRACT_24BITS(p) != JUNIPER_MGC_NUMBER) { /* magic number found ? */        printf("no magic-number found!");        return 0;    }     if (eflag) /* print direction */        printf("%3s ",tok2str(juniper_direction_values,"---",l2info->direction));    /* extensions present ?  - calculate how much bytes to skip */    if ((p[3] & JUNIPER_BPF_EXT ) == JUNIPER_BPF_EXT ) {        offset = 6 + EXTRACT_16BITS(p+4);        if (eflag>1)            printf("ext-len %u, ",EXTRACT_16BITS(p+4));    } else        offset = 4;    if ((p[3] & JUNIPER_BPF_NO_L2 ) == JUNIPER_BPF_NO_L2 ) {                    if (eflag)            printf("no-L2-hdr, ");        /* there is no link-layer present -         * perform the v4/v6 heuristics         * to figure out what it is         */        TCHECK2(p[offset+4],1);        if(ip_heuristic_guess(p+offset+4,l2info->length-(offset+4)) == 0)            printf("no IP-hdr found!");        l2info->header_len=offset+4;        return 0; /* stop parsing the output further */            }    l2info->header_len = offset;    p+=l2info->header_len;    l2info->length -= l2info->header_len;    l2info->caplen -= l2info->header_len;    /* search through the cookie table and copy values matching for our PIC type */    while (lp->s != NULL) {        if (lp->pictype == l2info->pictype) {            l2info->cookie_len += lp->cookie_len;            switch (p[0]) {            case LS_COOKIE_ID:                l2info->cookie_type = LS_COOKIE_ID;                l2info->cookie_len += 2;                break;            case AS_COOKIE_ID:                l2info->cookie_type = AS_COOKIE_ID;                l2info->cookie_len = 8;                break;                        default:                l2info->bundle = l2info->cookie[0];                break;            }#ifdef DLT_JUNIPER_MFR            /* MFR child links don't carry cookies */            if (l2info->pictype == DLT_JUNIPER_MFR &&                (p[0] & MFR_BE_MASK) == MFR_BE_MASK) {                l2info->cookie_len = 0;            }#endif            l2info->header_len += l2info->cookie_len;            l2info->length -= l2info->cookie_len;            l2info->caplen -= l2info->cookie_len;            if (eflag)                printf("%s-PIC, cookie-len %u",                       lp->s,                       l2info->cookie_len);            if (l2info->cookie_len > 0) {                TCHECK2(p[0],l2info->cookie_len);                if (eflag)                    printf(", cookie 0x");                for (idx = 0; idx < l2info->cookie_len; idx++) {//.........这里部分代码省略.........

static intldp_tlv_print(netdissect_options *ndo,              const u_char *tptr,              u_short msg_tlen){    struct ldp_tlv_header {        nd_uint16_t type;        nd_uint16_t length;    };    const struct ldp_tlv_header *ldp_tlv_header;    u_short tlv_type,tlv_len,tlv_tlen,af,ft_flags;    u_char fec_type;    u_int ui,vc_info_len, vc_info_tlv_type, vc_info_tlv_len,idx;    char buf[100];    int i;    ldp_tlv_header = (const struct ldp_tlv_header *)tptr;    ND_TCHECK_SIZE(ldp_tlv_header);    tlv_len=EXTRACT_BE_U_2(ldp_tlv_header->length);    if (tlv_len + 4 > msg_tlen) {        ND_PRINT("/n/t/t TLV contents go past end of message");        return 0;    }    tlv_tlen=tlv_len;    tlv_type=LDP_MASK_TLV_TYPE(EXTRACT_BE_U_2(ldp_tlv_header->type));    /* FIXME vendor private / experimental check */    ND_PRINT("/n/t    %s TLV (0x%04x), length: %u, Flags: [%s and %s forward if unknown]",           tok2str(ldp_tlv_values,                   "Unknown",                   tlv_type),           tlv_type,           tlv_len,           LDP_MASK_U_BIT(EXTRACT_BE_U_2(ldp_tlv_header->type)) ? "continue processing" : "ignore",           LDP_MASK_F_BIT(EXTRACT_BE_U_2(ldp_tlv_header->type)) ? "do" : "don't");    tptr+=sizeof(struct ldp_tlv_header);    switch(tlv_type) {    case LDP_TLV_COMMON_HELLO:        TLV_TCHECK(4);        ND_PRINT("/n/t      Hold Time: %us, Flags: [%s Hello%s]",               EXTRACT_BE_U_2(tptr),               (EXTRACT_BE_U_2(tptr + 2)&0x8000) ? "Targeted" : "Link",               (EXTRACT_BE_U_2(tptr + 2)&0x4000) ? ", Request for targeted Hellos" : "");        break;    case LDP_TLV_IPV4_TRANSPORT_ADDR:        TLV_TCHECK(4);        ND_PRINT("/n/t      IPv4 Transport Address: %s", ipaddr_string(ndo, tptr));        break;    case LDP_TLV_IPV6_TRANSPORT_ADDR:        TLV_TCHECK(16);        ND_PRINT("/n/t      IPv6 Transport Address: %s", ip6addr_string(ndo, tptr));        break;    case LDP_TLV_CONFIG_SEQ_NUMBER:        TLV_TCHECK(4);        ND_PRINT("/n/t      Sequence Number: %u", EXTRACT_BE_U_4(tptr));        break;    case LDP_TLV_ADDRESS_LIST:        TLV_TCHECK(LDP_TLV_ADDRESS_LIST_AFNUM_LEN);	af = EXTRACT_BE_U_2(tptr);	tptr+=LDP_TLV_ADDRESS_LIST_AFNUM_LEN;        tlv_tlen -= LDP_TLV_ADDRESS_LIST_AFNUM_LEN;	ND_PRINT("/n/t      Address Family: %s, addresses",               tok2str(af_values, "Unknown (%u)", af));        switch (af) {        case AFNUM_INET:	    while(tlv_tlen >= sizeof(struct in_addr)) {		ND_TCHECK_LEN(tptr, sizeof(struct in_addr));		ND_PRINT(" %s", ipaddr_string(ndo, tptr));		tlv_tlen-=sizeof(struct in_addr);		tptr+=sizeof(struct in_addr);	    }            break;        case AFNUM_INET6:	    while(tlv_tlen >= sizeof(struct in6_addr)) {		ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));		ND_PRINT(" %s", ip6addr_string(ndo, tptr));		tlv_tlen-=sizeof(struct in6_addr);		tptr+=sizeof(struct in6_addr);	    }            break;        default:            /* unknown AF */            break;        }	break;    case LDP_TLV_COMMON_SESSION:	TLV_TCHECK(8);	ND_PRINT("/n/t      Version: %u, Keepalive: %us, Flags: [Downstream %s, Loop Detection %s]",	       EXTRACT_BE_U_2(tptr), EXTRACT_BE_U_2(tptr + 2),	       (EXTRACT_BE_U_2(tptr + 6)&0x8000) ? "On Demand" : "Unsolicited",	       (EXTRACT_BE_U_2(tptr + 6)&0x4000) ? "Enabled" : "Disabled"	       );	break;//.........这里部分代码省略.........

static intldp_pdu_print(netdissect_options *ndo,              const u_char *pptr){    const struct ldp_common_header *ldp_com_header;    const struct ldp_msg_header *ldp_msg_header;    const u_char *tptr,*msg_tptr;    u_short tlen;    u_short pdu_len,msg_len,msg_type,msg_tlen;    int hexdump,processed;    ldp_com_header = (const struct ldp_common_header *)pptr;    ND_TCHECK_SIZE(ldp_com_header);    /*     * Sanity checking of the header.     */    if (EXTRACT_BE_U_2(ldp_com_header->version) != LDP_VERSION) {	ND_PRINT("%sLDP version %u packet not supported",               (ndo->ndo_vflag < 1) ? "" : "/n/t",               EXTRACT_BE_U_2(ldp_com_header->version));	return 0;    }    pdu_len = EXTRACT_BE_U_2(ldp_com_header->pdu_length);    if (pdu_len < sizeof(struct ldp_common_header)-4) {        /* length too short */        ND_PRINT("%sLDP, pdu-length: %u (too short, < %u)",               (ndo->ndo_vflag < 1) ? "" : "/n/t",               pdu_len,               (u_int)(sizeof(struct ldp_common_header)-4));        return 0;    }    /* print the LSR-ID, label-space & length */    ND_PRINT("%sLDP, Label-Space-ID: %s:%u, pdu-length: %u",           (ndo->ndo_vflag < 1) ? "" : "/n/t",           ipaddr_string(ndo, &ldp_com_header->lsr_id),           EXTRACT_BE_U_2(ldp_com_header->label_space),           pdu_len);    /* bail out if non-verbose */    if (ndo->ndo_vflag < 1)        return 0;    /* ok they seem to want to know everything - lets fully decode it */    tptr = pptr + sizeof(struct ldp_common_header);    tlen = pdu_len - (sizeof(struct ldp_common_header)-4);	/* Type & Length fields not included */    while(tlen>0) {        /* did we capture enough for fully decoding the msg header ? */        ND_TCHECK_LEN(tptr, sizeof(struct ldp_msg_header));        ldp_msg_header = (const struct ldp_msg_header *)tptr;        msg_len=EXTRACT_BE_U_2(ldp_msg_header->length);        msg_type=LDP_MASK_MSG_TYPE(EXTRACT_BE_U_2(ldp_msg_header->type));        if (msg_len < sizeof(struct ldp_msg_header)-4) {            /* length too short */            /* FIXME vendor private / experimental check */            ND_PRINT("/n/t  %s Message (0x%04x), length: %u (too short, < %u)",                   tok2str(ldp_msg_values,                           "Unknown",                           msg_type),                   msg_type,                   msg_len,                   (u_int)(sizeof(struct ldp_msg_header)-4));            return 0;        }        /* FIXME vendor private / experimental check */        ND_PRINT("/n/t  %s Message (0x%04x), length: %u, Message ID: 0x%08x, Flags: [%s if unknown]",               tok2str(ldp_msg_values,                       "Unknown",                       msg_type),               msg_type,               msg_len,               EXTRACT_BE_U_4(ldp_msg_header->id),               LDP_MASK_U_BIT(EXTRACT_BE_U_2(ldp_msg_header->type)) ? "continue processing" : "ignore");        msg_tptr=tptr+sizeof(struct ldp_msg_header);        msg_tlen=msg_len-(sizeof(struct ldp_msg_header)-4); /* Type & Length fields not included */        /* did we capture enough for fully decoding the message ? */        ND_TCHECK_LEN(tptr, msg_len);        hexdump=FALSE;        switch(msg_type) {        case LDP_MSG_NOTIF:        case LDP_MSG_HELLO:        case LDP_MSG_INIT:        case LDP_MSG_KEEPALIVE:        case LDP_MSG_ADDRESS:        case LDP_MSG_LABEL_MAPPING:        case LDP_MSG_ADDRESS_WITHDRAW:        case LDP_MSG_LABEL_WITHDRAW:            while(msg_tlen >= 4) {                processed = ldp_tlv_print(ndo, msg_tptr, msg_tlen);                if (processed == 0)//.........这里部分代码省略.........

/* print a reply */static const u_char *ns_rprint(register const u_char *cp, register const u_char *bp){	register u_int i;	register u_short typ, len;	register const u_char *rp;	if (vflag) {		putchar(' ');		cp = ns_nprint(cp, bp);	} else		cp = ns_nskip(cp, bp);	if (cp + 10 > snapend)		return (snapend);	/* print the type/qtype and class (if it's not IN) */	typ = *cp++ << 8;	typ |= *cp++;	i = *cp++ << 8;	i |= *cp++;	if (i != C_IN)		printf(" %s", tok2str(class2str, "(Class %d)", i));	/* ignore ttl */	cp += 4;	len = *cp++ << 8;	len |= *cp++;	rp = cp + len;	printf(" %s", tok2str(type2str, "Type%d", typ));	switch (typ) {	case T_A:		printf(" %s", ipaddr_string(cp));		break;	case T_NS:	case T_CNAME:	case T_PTR:		putchar(' ');		(void)ns_nprint(cp, bp);		break;	case T_MX:		putchar(' ');		(void)ns_nprint(cp + 2, bp);		printf(" %d", EXTRACT_16BITS(cp));		break;	case T_TXT:		putchar(' ');		(void)ns_cprint(cp, bp);		break;	case T_UNSPECA:		/* One long string */	        printf(" %.*s", len, cp);		break;	}	return (rp);		/* XXX This isn't always right */}

voidlwapp_control_print(netdissect_options *ndo,                    const u_char *pptr, u_int len, int has_ap_ident){    const struct lwapp_transport_header *lwapp_trans_header;    const struct lwapp_control_header *lwapp_control_header;    const u_char *tptr;    int  tlen;    int  msg_tlen;    tptr=pptr;    if (has_ap_ident) {        /* check if enough bytes for AP identity */        ND_TCHECK2(*tptr, 6);        lwapp_trans_header = (const struct lwapp_transport_header *)(pptr+6);    } else {        lwapp_trans_header = (const struct lwapp_transport_header *)pptr;    }    ND_TCHECK(*lwapp_trans_header);    /*     * Sanity checking of the header.     */    if (LWAPP_EXTRACT_VERSION(lwapp_trans_header->version) != LWAPP_VERSION) {	ND_PRINT((ndo, "LWAPP version %u packet not supported",               LWAPP_EXTRACT_VERSION(lwapp_trans_header->version)));	return;    }    /* non-verbose */    if (ndo->ndo_vflag < 1) {        ND_PRINT((ndo, "LWAPPv%u, %s frame, Flags [%s], length %u",               LWAPP_EXTRACT_VERSION(lwapp_trans_header->version),               LWAPP_EXTRACT_CONTROL_BIT(lwapp_trans_header->version) ? "Control" : "Data",               bittok2str(lwapp_header_bits_values,"none",(lwapp_trans_header->version)&0x07),               len));        return;    }    /* ok they seem to want to know everything - lets fully decode it */    tlen=EXTRACT_16BITS(lwapp_trans_header->length);    ND_PRINT((ndo, "LWAPPv%u, %s frame, Radio-id %u, Flags [%s], Frag-id %u, length %u",           LWAPP_EXTRACT_VERSION(lwapp_trans_header->version),           LWAPP_EXTRACT_CONTROL_BIT(lwapp_trans_header->version) ? "Control" : "Data",           LWAPP_EXTRACT_RID(lwapp_trans_header->version),           bittok2str(lwapp_header_bits_values,"none",(lwapp_trans_header->version)&0x07),	   lwapp_trans_header->frag_id,	   tlen));    if (has_ap_ident) {        ND_PRINT((ndo, "/n/tAP identity: %s", etheraddr_string(ndo, tptr)));        tptr+=sizeof(const struct lwapp_transport_header)+6;    } else {        tptr+=sizeof(const struct lwapp_transport_header);    }    while(tlen>0) {        /* did we capture enough for fully decoding the object header ? */        ND_TCHECK2(*tptr, sizeof(struct lwapp_control_header));        lwapp_control_header = (const struct lwapp_control_header *)tptr;	msg_tlen = EXTRACT_16BITS(lwapp_control_header->len);	/* print message header */        ND_PRINT((ndo, "/n/t  Msg type: %s (%u), Seqnum: %u, Msg len: %d, Session: 0x%08x",               tok2str(lwapp_msg_type_values,"Unknown",lwapp_control_header->msg_type),               lwapp_control_header->msg_type,               lwapp_control_header->seq_num,               msg_tlen,               EXTRACT_32BITS(lwapp_control_header->session_id)));        /* did we capture enough for fully decoding the message */        ND_TCHECK2(*tptr, msg_tlen);	/* XXX - Decode sub messages for each message */        switch(lwapp_control_header->msg_type) {        case LWAPP_MSGTYPE_DISCOVERY_REQUEST:        case LWAPP_MSGTYPE_DISCOVERY_RESPONSE:        case LWAPP_MSGTYPE_JOIN_REQUEST:        case LWAPP_MSGTYPE_JOIN_RESPONSE:        case LWAPP_MSGTYPE_JOIN_ACK:        case LWAPP_MSGTYPE_JOIN_CONFIRM:        case LWAPP_MSGTYPE_CONFIGURE_REQUEST:        case LWAPP_MSGTYPE_CONFIGURE_RESPONSE:        case LWAPP_MSGTYPE_CONF_UPDATE_REQUEST:        case LWAPP_MSGTYPE_CONF_UPDATE_RESPONSE:        case LWAPP_MSGTYPE_WTP_EVENT_REQUEST:        case LWAPP_MSGTYPE_WTP_EVENT_RESPONSE:        case LWAPP_MSGTYPE_CHANGE_STATE_EVENT_REQUEST:        case LWAPP_MSGTYPE_CHANGE_STATE_EVENT_RESPONSE:        case LWAPP_MSGTYPE_ECHO_REQUEST:        case LWAPP_MSGTYPE_ECHO_RESPONSE:        case LWAPP_MSGTYPE_IMAGE_DATA_REQUEST:        case LWAPP_MSGTYPE_IMAGE_DATA_RESPONSE:        case LWAPP_MSGTYPE_RESET_REQUEST:        case LWAPP_MSGTYPE_RESET_RESPONSE:        case LWAPP_MSGTYPE_KEY_UPDATE_REQUEST://.........这里部分代码省略.........

static voidprint_attr_num(netdissect_options *ndo,               register u_char *data, u_int length, u_short attr_code){   uint32_t timeout;   if (length != 4)   {       ND_PRINT((ndo, "ERROR: length %u != 4", length));       return;   }   ND_TCHECK2(data[0],4);                          /* This attribute has standard values */   if (attr_type[attr_code].siz_subtypes)   {      static const char **table;      uint32_t data_value;      table = attr_type[attr_code].subtypes;      if ( (attr_code == TUNNEL_TYPE) || (attr_code == TUNNEL_MEDIUM) )      {         if (!*data)            ND_PRINT((ndo, "Tag[Unused] "));         else            ND_PRINT((ndo, "Tag[%d] ", *data));         data++;         data_value = EXTRACT_24BITS(data);      }      else      {         data_value = EXTRACT_32BITS(data);      }      if ( data_value <= (uint32_t)(attr_type[attr_code].siz_subtypes - 1 +            attr_type[attr_code].first_subtype) &&	   data_value >= attr_type[attr_code].first_subtype )         ND_PRINT((ndo, "%s", table[data_value]));      else         ND_PRINT((ndo, "#%u", data_value));   }   else   {      switch(attr_code) /* Be aware of special cases... */      {        case FRM_IPX:             if (EXTRACT_32BITS( data) == 0xFFFFFFFE )                ND_PRINT((ndo, "NAS Select"));             else                ND_PRINT((ndo, "%d", EXTRACT_32BITS(data)));          break;        case SESSION_TIMEOUT:        case IDLE_TIMEOUT:        case ACCT_DELAY:        case ACCT_SESSION_TIME:        case ACCT_INT_INTERVAL:             timeout = EXTRACT_32BITS( data);             if ( timeout < 60 )                ND_PRINT((ndo,  "%02d secs", timeout));             else             {                if ( timeout < 3600 )                   ND_PRINT((ndo,  "%02d:%02d min",                          timeout / 60, timeout % 60));                else                   ND_PRINT((ndo, "%02d:%02d:%02d hours",                          timeout / 3600, (timeout % 3600) / 60,                          timeout % 60));             }          break;        case FRM_ATALK_LINK:             if (EXTRACT_32BITS(data) )                ND_PRINT((ndo, "%d", EXTRACT_32BITS(data)));             else                ND_PRINT((ndo, "Unnumbered"));          break;        case FRM_ATALK_NETWORK:             if (EXTRACT_32BITS(data) )                ND_PRINT((ndo, "%d", EXTRACT_32BITS(data)));             else                ND_PRINT((ndo, "NAS assigned"));          break;        case TUNNEL_PREFERENCE:            if (*data)               ND_PRINT((ndo, "Tag[%d] ", *data));            else               ND_PRINT((ndo, "Tag[Unused] "));            data++;            ND_PRINT((ndo, "%d", EXTRACT_24BITS(data)));          break;        case EGRESS_VLAN_ID:            ND_PRINT((ndo, "%s (0x%02x) ",                   tok2str(rfc4675_tagged,"Unknown tag",*data),                   *data));            data++;            ND_PRINT((ndo, "%d", EXTRACT_24BITS(data)));//.........这里部分代码省略.........

voideigrp_print(register const u_char *pptr, register u_int len) {    const struct eigrp_common_header *eigrp_com_header;    const struct eigrp_tlv_header *eigrp_tlv_header;    const u_char *tptr,*tlv_tptr;    u_int tlen,eigrp_tlv_len,eigrp_tlv_type,tlv_tlen, byte_length, bit_length;    u_int8_t prefix[4];    union {        const struct eigrp_tlv_general_parm_t *eigrp_tlv_general_parm;        const struct eigrp_tlv_sw_version_t *eigrp_tlv_sw_version;        const struct eigrp_tlv_ip_int_t *eigrp_tlv_ip_int;        const struct eigrp_tlv_ip_ext_t *eigrp_tlv_ip_ext;        const struct eigrp_tlv_at_cable_setup_t *eigrp_tlv_at_cable_setup;        const struct eigrp_tlv_at_int_t *eigrp_tlv_at_int;        const struct eigrp_tlv_at_ext_t *eigrp_tlv_at_ext;    } tlv_ptr;    tptr=pptr;    eigrp_com_header = (const struct eigrp_common_header *)pptr;    TCHECK(*eigrp_com_header);    /*     * Sanity checking of the header.     */    if (eigrp_com_header->version != EIGRP_VERSION) {	printf("EIGRP version %u packet not supported",eigrp_com_header->version);	return;    }    /* in non-verbose mode just lets print the basic Message Type*/    if (vflag < 1) {        printf("EIGRP %s, length: %u",               tok2str(eigrp_opcode_values, "unknown (%u)",eigrp_com_header->opcode),               len);        return;    }    /* ok they seem to want to know everything - lets fully decode it */    tlen=len-sizeof(struct eigrp_common_header);    /* FIXME print other header info */    printf("/n/tEIGRP v%u, opcode: %s (%u), chksum: 0x%04x, Flags: [%s]/n/tseq: 0x%08x, ack: 0x%08x, AS: %u, length: %u",           eigrp_com_header->version,           tok2str(eigrp_opcode_values, "unknown, type: %u",eigrp_com_header->opcode),           eigrp_com_header->opcode,           EXTRACT_16BITS(&eigrp_com_header->checksum),           tok2str(eigrp_common_header_flag_values,                   "none",                   EXTRACT_32BITS(&eigrp_com_header->flags)),           EXTRACT_32BITS(&eigrp_com_header->seq),           EXTRACT_32BITS(&eigrp_com_header->ack),           EXTRACT_32BITS(&eigrp_com_header->asn),           tlen);    tptr+=sizeof(const struct eigrp_common_header);    while(tlen>0) {        /* did we capture enough for fully decoding the object header ? */        TCHECK2(*tptr, sizeof(struct eigrp_tlv_header));        eigrp_tlv_header = (const struct eigrp_tlv_header *)tptr;        eigrp_tlv_len=EXTRACT_16BITS(&eigrp_tlv_header->length);        eigrp_tlv_type=EXTRACT_16BITS(&eigrp_tlv_header->type);        if (eigrp_tlv_len < sizeof(struct eigrp_tlv_header) ||            eigrp_tlv_len > tlen) {            print_unknown_data(tptr+sizeof(sizeof(struct eigrp_tlv_header)),"/n/t    ",tlen);            return;        }        printf("/n/t  %s TLV (0x%04x), length: %u",               tok2str(eigrp_tlv_values,                       "Unknown",                       eigrp_tlv_type),               eigrp_tlv_type,               eigrp_tlv_len);        tlv_tptr=tptr+sizeof(struct eigrp_tlv_header);        tlv_tlen=eigrp_tlv_len-sizeof(struct eigrp_tlv_header);        /* did we capture enough for fully decoding the object ? */        TCHECK2(*tptr, eigrp_tlv_len);        switch(eigrp_tlv_type) {        case EIGRP_TLV_GENERAL_PARM:            tlv_ptr.eigrp_tlv_general_parm = (const struct eigrp_tlv_general_parm_t *)tlv_tptr;            printf("/n/t    holdtime: %us, k1 %u, k2 %u, k3 %u, k4 %u, k5 %u",                   EXTRACT_16BITS(tlv_ptr.eigrp_tlv_general_parm->holdtime),                   tlv_ptr.eigrp_tlv_general_parm->k1,                   tlv_ptr.eigrp_tlv_general_parm->k2,                   tlv_ptr.eigrp_tlv_general_parm->k3,                   tlv_ptr.eigrp_tlv_general_parm->k4,                   tlv_ptr.eigrp_tlv_general_parm->k5);            break;//.........这里部分代码省略.........

voidicmp_print(const u_char *bp, u_int plen, const u_char *bp2, int fragmented){	char *cp;	const struct icmp *dp;        const struct icmp_ext_t *ext_dp;	const struct ip *ip;	const char *str, *fmt;	const struct ip *oip;	const struct udphdr *ouh;        const u_int8_t *obj_tptr;        u_int32_t raw_label;        const u_char *snapend_save;	const struct icmp_mpls_ext_object_header_t *icmp_mpls_ext_object_header;	u_int hlen, dport, mtu, obj_tlen, obj_class_num, obj_ctype;	char buf[MAXHOSTNAMELEN + 100];	struct cksum_vec vec[1];	dp = (struct icmp *)bp;        ext_dp = (struct icmp_ext_t *)bp;	ip = (struct ip *)bp2;	str = buf;	TCHECK(dp->icmp_code);	switch (dp->icmp_type) {	case ICMP_ECHO:	case ICMP_ECHOREPLY:		TCHECK(dp->icmp_seq);		(void)snprintf(buf, sizeof(buf), "echo %s, id %u, seq %u",                               dp->icmp_type == ICMP_ECHO ?                               "request" : "reply",                               EXTRACT_16BITS(&dp->icmp_id),                               EXTRACT_16BITS(&dp->icmp_seq));		break;	case ICMP_UNREACH:		TCHECK(dp->icmp_ip.ip_dst);		switch (dp->icmp_code) {		case ICMP_UNREACH_PROTOCOL:			TCHECK(dp->icmp_ip.ip_p);			(void)snprintf(buf, sizeof(buf),			    "%s protocol %d unreachable",			    ipaddr_string(&dp->icmp_ip.ip_dst),			    dp->icmp_ip.ip_p);			break;		case ICMP_UNREACH_PORT:			TCHECK(dp->icmp_ip.ip_p);			oip = &dp->icmp_ip;			hlen = IP_HL(oip) * 4;			ouh = (struct udphdr *)(((u_char *)oip) + hlen);			TCHECK(ouh->uh_dport);			dport = EXTRACT_16BITS(&ouh->uh_dport);			switch (oip->ip_p) {			case IPPROTO_TCP:				(void)snprintf(buf, sizeof(buf),					"%s tcp port %s unreachable",					ipaddr_string(&oip->ip_dst),					tcpport_string(dport));				break;			case IPPROTO_UDP:				(void)snprintf(buf, sizeof(buf),					"%s udp port %s unreachable",					ipaddr_string(&oip->ip_dst),					udpport_string(dport));				break;			default:				(void)snprintf(buf, sizeof(buf),					"%s protocol %d port %d unreachable",					ipaddr_string(&oip->ip_dst),					oip->ip_p, dport);				break;			}			break;		case ICMP_UNREACH_NEEDFRAG:		    {			register const struct mtu_discovery *mp;			mp = (struct mtu_discovery *)(u_char *)&dp->icmp_void;			mtu = EXTRACT_16BITS(&mp->nexthopmtu);			if (mtu) {				(void)snprintf(buf, sizeof(buf),				    "%s unreachable - need to frag (mtu %d)",				    ipaddr_string(&dp->icmp_ip.ip_dst), mtu);			} else {				(void)snprintf(buf, sizeof(buf),				    "%s unreachable - need to frag",				    ipaddr_string(&dp->icmp_ip.ip_dst));			}		    }			break;		default:			fmt = tok2str(unreach2str, "#%d %%s unreachable",			    dp->icmp_code);//.........这里部分代码省略.........

static intstp_print_mstp_bpdu(netdissect_options *ndo, const struct stp_bpdu_ *stp_bpdu,                    u_int length){    const u_char *ptr;    uint8_t	    bpdu_flags;    uint16_t	    v3len;    uint16_t	    len;    uint16_t	    msti;    u_int	    offset;    ptr = (const u_char *)stp_bpdu;    ND_TCHECK_1(stp_bpdu->flags);    bpdu_flags = EXTRACT_U_1(stp_bpdu->flags);    ND_PRINT(", CIST Flags [%s], length %u",           bittok2str(stp_bpdu_flag_values, "none", bpdu_flags), length);    /*     * in non-verbose mode just print the flags.     */    if (!ndo->ndo_vflag) {        return 1;    }    ND_PRINT("/n/tport-role %s, ",           tok2str(rstp_obj_port_role_values, "Unknown",                   RSTP_EXTRACT_PORT_ROLE(bpdu_flags)));    ND_TCHECK_4(stp_bpdu->root_path_cost);    ND_PRINT("CIST root-id %s, CIST ext-pathcost %u",           stp_print_bridge_id((const u_char *)&stp_bpdu->root_id),           EXTRACT_BE_U_4(stp_bpdu->root_path_cost));    ND_TCHECK_SIZE(&stp_bpdu->bridge_id);    ND_PRINT("/n/tCIST regional-root-id %s, ",           stp_print_bridge_id((const u_char *)&stp_bpdu->bridge_id));    ND_TCHECK_2(stp_bpdu->port_id);    ND_PRINT("CIST port-id %04x,", EXTRACT_BE_U_2(stp_bpdu->port_id));    ND_TCHECK_2(stp_bpdu->forward_delay);    ND_PRINT("/n/tmessage-age %.2fs, max-age %.2fs"           ", hello-time %.2fs, forwarding-delay %.2fs",           (float) EXTRACT_BE_U_2(stp_bpdu->message_age) / STP_TIME_BASE,           (float) EXTRACT_BE_U_2(stp_bpdu->max_age) / STP_TIME_BASE,           (float) EXTRACT_BE_U_2(stp_bpdu->hello_time) / STP_TIME_BASE,           (float) EXTRACT_BE_U_2(stp_bpdu->forward_delay) / STP_TIME_BASE);    ND_TCHECK_2(ptr + MST_BPDU_VER3_LEN_OFFSET);    ND_PRINT("/n/tv3len %u, ", EXTRACT_BE_U_2(ptr + MST_BPDU_VER3_LEN_OFFSET));    ND_TCHECK_4(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 12);    ND_PRINT("MCID Name ");    if (fn_printzp(ndo, ptr + MST_BPDU_CONFIG_NAME_OFFSET, 32, ndo->ndo_snapend))	goto trunc;    ND_PRINT(", rev %u,"            "/n/t/tdigest %08x%08x%08x%08x, ",	          EXTRACT_BE_U_2(ptr + MST_BPDU_CONFIG_NAME_OFFSET + 32),	          EXTRACT_BE_U_4(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET),	          EXTRACT_BE_U_4(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 4),	          EXTRACT_BE_U_4(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 8),	          EXTRACT_BE_U_4(ptr + MST_BPDU_CONFIG_DIGEST_OFFSET + 12));    ND_TCHECK_4(ptr + MST_BPDU_CIST_INT_PATH_COST_OFFSET);    ND_PRINT("CIST int-root-pathcost %u,",            EXTRACT_BE_U_4(ptr + MST_BPDU_CIST_INT_PATH_COST_OFFSET));    ND_TCHECK_BRIDGE_ID(ptr + MST_BPDU_CIST_BRIDGE_ID_OFFSET);    ND_PRINT("/n/tCIST bridge-id %s, ",           stp_print_bridge_id(ptr + MST_BPDU_CIST_BRIDGE_ID_OFFSET));    ND_TCHECK_1(ptr + MST_BPDU_CIST_REMAIN_HOPS_OFFSET);    ND_PRINT("CIST remaining-hops %u", EXTRACT_U_1(ptr + MST_BPDU_CIST_REMAIN_HOPS_OFFSET));    /* Dump all MSTI's */    ND_TCHECK_2(ptr + MST_BPDU_VER3_LEN_OFFSET);    v3len = EXTRACT_BE_U_2(ptr + MST_BPDU_VER3_LEN_OFFSET);    if (v3len > MST_BPDU_CONFIG_INFO_LENGTH) {        len = v3len - MST_BPDU_CONFIG_INFO_LENGTH;        offset = MST_BPDU_MSTI_OFFSET;        while (len >= MST_BPDU_MSTI_LENGTH) {            ND_TCHECK_LEN(ptr + offset, MST_BPDU_MSTI_LENGTH);            msti = EXTRACT_BE_U_2(ptr + offset + MST_BPDU_MSTI_ROOT_PRIO_OFFSET);            msti = msti & 0x0FFF;            ND_PRINT("/n/tMSTI %u, Flags [%s], port-role %s",                   msti, bittok2str(stp_bpdu_flag_values, "none", EXTRACT_U_1(ptr + offset)),                   tok2str(rstp_obj_port_role_values, "Unknown",                           RSTP_EXTRACT_PORT_ROLE(EXTRACT_U_1(ptr + offset))));            ND_PRINT("/n/t/tMSTI regional-root-id %s, pathcost %u",                   stp_print_bridge_id(ptr + offset +                                       MST_BPDU_MSTI_ROOT_PRIO_OFFSET),                   EXTRACT_BE_U_4(ptr + offset + MST_BPDU_MSTI_ROOT_PATH_COST_OFFSET));            ND_PRINT("/n/t/tMSTI bridge-prio %u, port-prio %u, hops %u",                   EXTRACT_U_1(ptr + offset + MST_BPDU_MSTI_BRIDGE_PRIO_OFFSET) >> 4,                   EXTRACT_U_1(ptr + offset + MST_BPDU_MSTI_PORT_PRIO_OFFSET) >> 4,                   EXTRACT_U_1(ptr + offset + MST_BPDU_MSTI_REMAIN_HOPS_OFFSET));            len -= MST_BPDU_MSTI_LENGTH;            offset += MST_BPDU_MSTI_LENGTH;//.........这里部分代码省略.........

voidgeneve_print(netdissect_options *ndo, const u_char *bp, u_int len){    uint8_t ver_opt;    u_int version;    uint8_t flags;    uint16_t prot;    uint32_t vni;    uint8_t reserved;    u_int opts_len;    ND_PRINT((ndo, "Geneve"));    ND_TCHECK2(*bp, 8);    ver_opt = *bp;    bp += 1;    len -= 1;    version = ver_opt >> VER_SHIFT;    if (version != 0) {        ND_PRINT((ndo, " ERROR: unknown-version %u", version));        return;    }    flags = *bp;    bp += 1;    len -= 1;    prot = EXTRACT_16BITS(bp);    bp += 2;    len -= 2;    vni = EXTRACT_24BITS(bp);    bp += 3;    len -= 3;    reserved = *bp;    bp += 1;    len -= 1;    ND_PRINT((ndo, ", Flags [%s]",              bittok2str_nosep(geneve_flag_values, "none", flags)));    ND_PRINT((ndo, ", vni 0x%x", vni));    if (reserved)        ND_PRINT((ndo, ", rsvd 0x%x", reserved));    if (ndo->ndo_eflag)        ND_PRINT((ndo, ", proto %s (0x%04x)",                  tok2str(ethertype_values, "unknown", prot), prot));    opts_len = (ver_opt & HDR_OPTS_LEN_MASK) * 4;    if (len < opts_len) {        ND_PRINT((ndo, " truncated-geneve - %u bytes missing",                  opts_len - len));        return;    }    ND_TCHECK2(*bp, opts_len);    if (opts_len > 0) {        ND_PRINT((ndo, ", options ["));        if (ndo->ndo_vflag)            geneve_opts_print(ndo, bp, opts_len);        else            ND_PRINT((ndo, "%u bytes", opts_len));        ND_PRINT((ndo, "]"));    }    bp += opts_len;    len -= opts_len;    if (ndo->ndo_vflag < 1)        ND_PRINT((ndo, ": "));    else        ND_PRINT((ndo, "/n/t"));    if (ethertype_print(ndo, prot, bp, len, len) == 0) {        if (prot == ETHERTYPE_TEB)            ether_print(ndo, bp, len, len, NULL, NULL);        else            ND_PRINT((ndo, "geneve-proto-0x%x", prot));    }    return;trunc:    ND_PRINT((ndo, " [|geneve]"));}

voidvrrp_print(netdissect_options *ndo,           register const u_char *bp, register u_int len,           register const u_char *bp2, int ttl){	int version, type, auth_type = VRRP_AUTH_NONE; /* keep compiler happy */	const char *type_s;	ND_TCHECK(bp[0]);	version = (bp[0] & 0xf0) >> 4;	type = bp[0] & 0x0f;	type_s = tok2str(type2str, "unknown type (%u)", type);	ND_PRINT((ndo, "VRRPv%u, %s", version, type_s));	if (ttl != 255)		ND_PRINT((ndo, ", (ttl %u)", ttl));	if (version < 2 || version > 3 || type != VRRP_TYPE_ADVERTISEMENT)		return;	ND_TCHECK(bp[2]);	ND_PRINT((ndo, ", vrid %u, prio %u", bp[1], bp[2]));	ND_TCHECK(bp[5]);	if (version == 2) {		auth_type = bp[4];		ND_PRINT((ndo, ", authtype %s", tok2str(auth2str, NULL, auth_type)));		ND_PRINT((ndo, ", intvl %us, length %u", bp[5], len));	} else { /* version == 3 */		uint16_t intvl = (bp[4] & 0x0f) << 8 | bp[5];		ND_PRINT((ndo, ", intvl %ucs, length %u", intvl, len));	}	if (ndo->ndo_vflag) {		int naddrs = bp[3];		int i;		char c;		if (version == 2 && ND_TTEST2(bp[0], len)) {			struct cksum_vec vec[1];			vec[0].ptr = bp;			vec[0].len = len;			if (in_cksum(vec, 1))				ND_PRINT((ndo, ", (bad vrrp cksum %x)",					EXTRACT_16BITS(&bp[6])));		}		if (version == 3 && ND_TTEST2(bp[0], len)) {			uint16_t cksum = nextproto4_cksum(ndo, (const struct ip *)bp2, bp,				len, len, IPPROTO_VRRP);			if (cksum)				ND_PRINT((ndo, ", (bad vrrp cksum %x)",					EXTRACT_16BITS(&bp[6])));		}		ND_PRINT((ndo, ", addrs"));		if (naddrs > 1)			ND_PRINT((ndo, "(%d)", naddrs));		ND_PRINT((ndo, ":"));		c = ' ';		bp += 8;		for (i = 0; i < naddrs; i++) {			ND_TCHECK(bp[3]);			ND_PRINT((ndo, "%c%s", c, ipaddr_string(ndo, bp)));			c = ',';			bp += 4;		}		if (version == 2 && auth_type == VRRP_AUTH_SIMPLE) { /* simple text password */			ND_TCHECK(bp[7]);			ND_PRINT((ndo, " auth /""));			if (fn_printn(ndo, bp, 8, ndo->ndo_snapend)) {				ND_PRINT((ndo, "/""));				goto trunc;			}			ND_PRINT((ndo, "/""));		}	}	return;trunc:	ND_PRINT((ndo, "[|vrrp]"));}