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

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)));//.........这里部分代码省略.........

static voidpptp_conn_speed_print(const u_int32_t *conn_speed){	printf(" CONN_SPEED(%u)", EXTRACT_32BITS(conn_speed));}

static voidpptp_phy_chan_id_print(const u_int32_t *phy_chan_id){	printf(" PHY_CHAN_ID(%u)", EXTRACT_32BITS(phy_chan_id));}

static int dccp_print_option(netdissect_options *ndo, const u_char *option, u_int hlen){	uint8_t optlen, i;	ND_TCHECK(*option);	if (*option >= 32) {		ND_TCHECK(*(option+1));		optlen = *(option +1);		if (optlen < 2) {			if (*option >= 128)				ND_PRINT((ndo, "CCID option %u optlen too short", *option));			else				ND_PRINT((ndo, "%s optlen too short",					  tok2str(dccp_option_values, "Option %u", *option)));			return 0;		}	} else		optlen = 1;	if (hlen < optlen) {		if (*option >= 128)			ND_PRINT((ndo, "CCID option %u optlen goes past header length",				  *option));		else			ND_PRINT((ndo, "%s optlen goes past header length",				  tok2str(dccp_option_values, "Option %u", *option)));		return 0;	}	ND_TCHECK2(*option, optlen);	if (*option >= 128) {		ND_PRINT((ndo, "CCID option %d", *option));		switch (optlen) {			case 4:				ND_PRINT((ndo, " %u", EXTRACT_16BITS(option + 2)));				break;			case 6:				ND_PRINT((ndo, " %u", EXTRACT_32BITS(option + 2)));				break;			default:				break;		}	} else {		ND_PRINT((ndo, "%s", tok2str(dccp_option_values, "Option %u", *option)));		switch (*option) {		case 32:		case 33:		case 34:		case 35:			if (optlen < 3) {				ND_PRINT((ndo, " optlen too short"));				return optlen;			}			if (*(option + 2) < 10){				ND_PRINT((ndo, " %s", dccp_feature_nums[*(option + 2)]));				for (i = 0; i < optlen - 3; i++)					ND_PRINT((ndo, " %d", *(option + 3 + i)));			}			break;		case 36:			if (optlen > 2) {				ND_PRINT((ndo, " 0x"));				for (i = 0; i < optlen - 2; i++)					ND_PRINT((ndo, "%02x", *(option + 2 + i)));			}			break;		case 37:			for (i = 0; i < optlen - 2; i++)				ND_PRINT((ndo, " %d", *(option + 2 + i)));			break;		case 38:			if (optlen > 2) {				ND_PRINT((ndo, " 0x"));				for (i = 0; i < optlen - 2; i++)					ND_PRINT((ndo, "%02x", *(option + 2 + i)));			}			break;		case 39:			if (optlen > 2) {				ND_PRINT((ndo, " 0x"));				for (i = 0; i < optlen - 2; i++)					ND_PRINT((ndo, "%02x", *(option + 2 + i)));			}			break;		case 40:			if (optlen > 2) {				ND_PRINT((ndo, " 0x"));				for (i = 0; i < optlen - 2; i++)					ND_PRINT((ndo, "%02x", *(option + 2 + i)));			}			break;		case 41:			if (optlen == 4)				ND_PRINT((ndo, " %u", EXTRACT_32BITS(option + 2)));			else				ND_PRINT((ndo, " optlen != 4"));			break;		case 42:			if (optlen == 4)//.........这里部分代码省略.........

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;            }//.........这里部分代码省略.........

/* * This is the top level routine of the printer.  'p' points * to the LLC/SNAP header of the packet, 'h->ts' is the timestamp, * 'h->len' is the length of the packet off the wire, and 'h->caplen' * is the number of bytes actually captured. */u_intatm_if_print(const struct pcap_pkthdr *h, const u_char *p){	u_int caplen = h->caplen;	u_int length = h->len;	u_int32_t llchdr;	u_int hdrlen = 0;	if (caplen < 8) {		printf("[|atm]");		return (caplen);	}        /* Cisco Style NLPID ? */        if (*p == LLC_UI) {            if (eflag)                printf("CNLPID ");            isoclns_print(p+1, length-1, caplen-1);            return hdrlen;        }	/*	 * Extract the presumed LLC header into a variable, for quick	 * testing.	 * Then check for a header that's neither a header for a SNAP	 * packet nor an RFC 2684 routed NLPID-formatted PDU nor	 * an 802.2-but-no-SNAP IP packet.	 */	llchdr = EXTRACT_24BITS(p);	if (llchdr != LLC_UI_HDR(LLCSAP_SNAP) &&	    llchdr != LLC_UI_HDR(LLCSAP_ISONS) &&	    llchdr != LLC_UI_HDR(LLCSAP_IP)) {		/*		 * XXX - assume 802.6 MAC header from Fore driver.		 *		 * Unfortunately, the above list doesn't check for		 * all known SAPs, doesn't check for headers where		 * the source and destination SAP aren't the same,		 * and doesn't check for non-UI frames.  It also		 * runs the risk of an 802.6 MAC header that happens		 * to begin with one of those values being		 * incorrectly treated as an 802.2 header.		 *		 * So is that Fore driver still around?  And, if so,		 * is it still putting 802.6 MAC headers on ATM		 * packets?  If so, could it be changed to use a		 * new DLT_IEEE802_6 value if we added it?		 */		if (eflag)			printf("%08x%08x %08x%08x ",			       EXTRACT_32BITS(p),			       EXTRACT_32BITS(p+4),			       EXTRACT_32BITS(p+8),			       EXTRACT_32BITS(p+12));		p += 20;		length -= 20;		caplen -= 20;		hdrlen += 20;	}	atm_llc_print(p, length, caplen);	return (hdrlen);}

/* * Print a single link state advertisement.  If truncated return 1, else 0. */static intospf6_print_lsa(register const struct lsa6 *lsap){	register const u_char *ls_end, *ls_opt;	register const struct rlalink6 *rlp;#if 0	register const struct tos_metric *tosp;#endif	register const rtrid_t *ap;#if 0	register const struct aslametric *almp;	register const struct mcla *mcp;#endif	register const struct llsa *llsap;	register const struct lsa6_prefix *lsapp;#if 0	register const u_int32_t *lp;#endif	register u_int prefixes;	register int bytelen, length, lsa_length;	u_int32_t flags32;        u_int8_t *tptr;	if (ospf6_print_lshdr(&lsap->ls_hdr))		return (1);	TCHECK(lsap->ls_hdr.ls_length);        length = EXTRACT_16BITS(&lsap->ls_hdr.ls_length);        lsa_length = length - sizeof(struct lsa6_hdr);	ls_end = (u_char *)lsap + length;        tptr = (u_int8_t *)lsap+sizeof(struct lsa6_hdr);	switch (EXTRACT_16BITS(&lsap->ls_hdr.ls_type)) {	case LS_TYPE_ROUTER | LS_SCOPE_AREA:		TCHECK(lsap->lsa_un.un_rla.rla_options);                printf("/n/t      Options [%s]",                       bittok2str(ospf6_option_values, "none",                                  EXTRACT_32BITS(&lsap->lsa_un.un_rla.rla_options)));		TCHECK(lsap->lsa_un.un_rla.rla_flags);                printf(", RLA-Flags [%s]",                       bittok2str(ospf6_rla_flag_values, "none",                                  lsap->lsa_un.un_rla.rla_flags));		TCHECK(lsap->lsa_un.un_rla.rla_link);		rlp = lsap->lsa_un.un_rla.rla_link;		while (rlp + 1 <= (struct rlalink6 *)ls_end) {			TCHECK(*rlp);			switch (rlp->link_type) {			case RLA_TYPE_VIRTUAL:				printf("/n/t      Virtual Link: Neighbor Router-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",                                       ipaddr_string(&rlp->link_nrtid),                                       ipaddr_string(&rlp->link_nifid),                                       ipaddr_string(&rlp->link_ifid));                                 break;			case RLA_TYPE_ROUTER:				printf("/n/t      Neighbor Router-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",                                       ipaddr_string(&rlp->link_nrtid),                                       ipaddr_string(&rlp->link_nifid),                                       ipaddr_string(&rlp->link_ifid)); 				break;			case RLA_TYPE_TRANSIT:				printf("/n/t      Neighbor Network-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",				    ipaddr_string(&rlp->link_nrtid),				    ipaddr_string(&rlp->link_nifid),				    ipaddr_string(&rlp->link_ifid));				break;			default:				printf("/n/t      Unknown Router Links Type 0x%02x",				    rlp->link_type);				return (0);			}			printf(", metric %d", EXTRACT_16BITS(&rlp->link_metric));			rlp++;		}		break;	case LS_TYPE_NETWORK | LS_SCOPE_AREA:		TCHECK(lsap->lsa_un.un_nla.nla_options);                printf("/n/t      Options [%s]",                       bittok2str(ospf6_option_values, "none",                                  EXTRACT_32BITS(&lsap->lsa_un.un_nla.nla_options)));		printf("/n/t      Connected Routers:");		ap = lsap->lsa_un.un_nla.nla_router;		while ((u_char *)ap < ls_end) {			TCHECK(*ap);			printf("/n/t/t%s", ipaddr_string(ap));			++ap;		}		break;//.........这里部分代码省略.........

voidnfsreq_print_noaddr(register const u_char *bp, u_int length,    register const u_char *bp2){	register const struct sunrpc_msg *rp;	register const u_int32_t *dp;	nfs_type type;	int v3;	u_int32_t proc;	u_int32_t access_flags;	struct nfsv3_sattr sa3;	nfserr = 0;		/* assume no error */	rp = (const struct sunrpc_msg *)bp;	if (!xid_map_enter(rp, bp2))	/* record proc number for later on */		goto trunc;	v3 = (EXTRACT_32BITS(&rp->rm_call.cb_vers) == NFS_VER3);	proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);	if (!v3 && proc < NFS_NPROCS)		proc =  nfsv3_procid[proc];	switch (proc) {	case NFSPROC_NOOP:		printf(" nop");		return;	case NFSPROC_NULL:		printf(" null");		return;	case NFSPROC_GETATTR:		printf(" getattr");		if ((dp = parsereq(rp, length)) != NULL &&		    parsefh(dp, v3) != NULL)			return;		break;	case NFSPROC_SETATTR:		printf(" setattr");		if ((dp = parsereq(rp, length)) != NULL &&		    parsefh(dp, v3) != NULL)			return;		break;	case NFSPROC_LOOKUP:		printf(" lookup");		if ((dp = parsereq(rp, length)) != NULL &&		    parsefhn(dp, v3) != NULL)			return;		break;	case NFSPROC_ACCESS:		printf(" access");		if ((dp = parsereq(rp, length)) != NULL &&		    (dp = parsefh(dp, v3)) != NULL) {			TCHECK(dp[0]);			access_flags = EXTRACT_32BITS(&dp[0]);			if (access_flags & ~NFSV3ACCESS_FULL) {				/* NFSV3ACCESS definitions aren't up to date */				printf(" %04x", access_flags);			} else if ((access_flags & NFSV3ACCESS_FULL) == NFSV3ACCESS_FULL) {				printf(" NFS_ACCESS_FULL");			} else {				char separator = ' ';				if (access_flags & NFSV3ACCESS_READ) {					printf(" NFS_ACCESS_READ");					separator = '|';				}				if (access_flags & NFSV3ACCESS_LOOKUP) {					printf("%cNFS_ACCESS_LOOKUP", separator);					separator = '|';				}				if (access_flags & NFSV3ACCESS_MODIFY) {					printf("%cNFS_ACCESS_MODIFY", separator);					separator = '|';				}				if (access_flags & NFSV3ACCESS_EXTEND) {					printf("%cNFS_ACCESS_EXTEND", separator);					separator = '|';				}				if (access_flags & NFSV3ACCESS_DELETE) {					printf("%cNFS_ACCESS_DELETE", separator);					separator = '|';				}				if (access_flags & NFSV3ACCESS_EXECUTE)					printf("%cNFS_ACCESS_EXECUTE", separator);			}			return;		}		break;	case NFSPROC_READLINK:		printf(" readlink");		if ((dp = parsereq(rp, length)) != NULL &&		    parsefh(dp, v3) != NULL)			return;		break;//.........这里部分代码省略.........

/* * 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("%sSession ID: 0x%04x, Serial: %u",               indent_string(indent+2),               EXTRACT_16BITS(pdu_header->u.session_id),               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("%sSession ID: 0x%04x",               indent_string(indent+2),               EXTRACT_16BITS(pdu_header->u.session_id));        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 const u_int32_t *parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3){	TCHECK(dp[0]);	sa3->sa_modeset = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_modeset) {		TCHECK(dp[0]);		sa3->sa_mode = EXTRACT_32BITS(dp);		dp++;	}	TCHECK(dp[0]);	sa3->sa_uidset = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_uidset) {		TCHECK(dp[0]);		sa3->sa_uid = EXTRACT_32BITS(dp);		dp++;	}	TCHECK(dp[0]);	sa3->sa_gidset = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_gidset) {		TCHECK(dp[0]);		sa3->sa_gid = EXTRACT_32BITS(dp);		dp++;	}	TCHECK(dp[0]);	sa3->sa_sizeset = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_sizeset) {		TCHECK(dp[0]);		sa3->sa_size = EXTRACT_32BITS(dp);		dp++;	}	TCHECK(dp[0]);	sa3->sa_atimetype = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) {		TCHECK(dp[1]);		sa3->sa_atime.nfsv3_sec = EXTRACT_32BITS(dp);		dp++;		sa3->sa_atime.nfsv3_nsec = EXTRACT_32BITS(dp);		dp++;	}	TCHECK(dp[0]);	sa3->sa_mtimetype = EXTRACT_32BITS(dp);	dp++;	if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) {		TCHECK(dp[1]);		sa3->sa_mtime.nfsv3_sec = EXTRACT_32BITS(dp);		dp++;		sa3->sa_mtime.nfsv3_nsec = EXTRACT_32BITS(dp);		dp++;	}	return dp;trunc:	return NULL;}

voidnfsreply_print_noaddr(register const u_char *bp, u_int length,	       register const u_char *bp2){	register const struct sunrpc_msg *rp;	u_int32_t proc, vers, reply_stat;	enum sunrpc_reject_stat rstat;	u_int32_t rlow;	u_int32_t rhigh;	enum sunrpc_auth_stat rwhy;	nfserr = 0;		/* assume no error */	rp = (const struct sunrpc_msg *)bp;	TCHECK(rp->rm_reply.rp_stat);	reply_stat = EXTRACT_32BITS(&rp->rm_reply.rp_stat);	switch (reply_stat) {	case SUNRPC_MSG_ACCEPTED:		(void)printf("reply ok %u", length);		if (xid_map_find(rp, bp2, &proc, &vers) >= 0)			interp_reply(rp, proc, vers, length);		break;	case SUNRPC_MSG_DENIED:		(void)printf("reply ERR %u: ", length);		TCHECK(rp->rm_reply.rp_reject.rj_stat);		rstat = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_stat);		switch (rstat) {		case SUNRPC_RPC_MISMATCH:			TCHECK(rp->rm_reply.rp_reject.rj_vers.high);			rlow = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.low);			rhigh = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.high);			(void)printf("RPC Version mismatch (%u-%u)",			    rlow, rhigh);			break;		case SUNRPC_AUTH_ERROR:			TCHECK(rp->rm_reply.rp_reject.rj_why);			rwhy = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_why);			(void)printf("Auth ");			switch (rwhy) {			case SUNRPC_AUTH_OK:				(void)printf("OK");				break;			case SUNRPC_AUTH_BADCRED:				(void)printf("Bogus Credentials (seal broken)");				break;			case SUNRPC_AUTH_REJECTEDCRED:				(void)printf("Rejected Credentials (client should begin new session)");				break;			case SUNRPC_AUTH_BADVERF:				(void)printf("Bogus Verifier (seal broken)");				break;			case SUNRPC_AUTH_REJECTEDVERF:				(void)printf("Verifier expired or was replayed");				break;			case SUNRPC_AUTH_TOOWEAK:				(void)printf("Credentials are too weak");				break;			case SUNRPC_AUTH_INVALIDRESP:				(void)printf("Bogus response verifier");				break;			case SUNRPC_AUTH_FAILED:				(void)printf("Unknown failure");				break;			default:				(void)printf("Invalid failure code %u",				    (unsigned int)rwhy);				break;			}			break;		default:			(void)printf("Unknown reason for rejecting rpc message %u",			    (unsigned int)rstat);			break;		}		break;	default:		(void)printf("reply Unknown rpc response code=%u %u",		    reply_stat, length);		break;	}	return;trunc:	if (!nfserr)		printf("%s", tstr);//.........这里部分代码省略.........

static voidinterp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length){	register const u_int32_t *dp;	register int v3;	int er;	v3 = (vers == NFS_VER3);	if (!v3 && proc < NFS_NPROCS)		proc = nfsv3_procid[proc];	switch (proc) {	case NFSPROC_NOOP:		printf(" nop");		return;	case NFSPROC_NULL:		printf(" null");		return;	case NFSPROC_GETATTR:		printf(" getattr");		dp = parserep(rp, length);		if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)			return;		break;	case NFSPROC_SETATTR:		printf(" setattr");		if (!(dp = parserep(rp, length)))			return;		if (v3) {			if (parsewccres(dp, vflag))				return;		} else {			if (parseattrstat(dp, !qflag, 0) != 0)				return;		}		break;	case NFSPROC_LOOKUP:		printf(" lookup");		if (!(dp = parserep(rp, length)))			break;		if (v3) {			if (!(dp = parsestatus(dp, &er)))				break;			if (er) {				if (vflag > 1) {					printf(" post dattr:");					dp = parse_post_op_attr(dp, vflag);				}			} else {				if (!(dp = parsefh(dp, v3)))					break;				if ((dp = parse_post_op_attr(dp, vflag)) &&				    vflag > 1) {					printf(" post dattr:");					dp = parse_post_op_attr(dp, vflag);				}			}			if (dp)				return;		} else {			if (parsediropres(dp) != 0)				return;		}		break;	case NFSPROC_ACCESS:		printf(" access");		if (!(dp = parserep(rp, length)))			break;		if (!(dp = parsestatus(dp, &er)))			break;		if (vflag)			printf(" attr:");		if (!(dp = parse_post_op_attr(dp, vflag)))			break;		if (!er)			printf(" c %04x", EXTRACT_32BITS(&dp[0]));		return;	case NFSPROC_READLINK:		printf(" readlink");		dp = parserep(rp, length);		if (dp != NULL && parselinkres(dp, v3) != 0)			return;		break;	case NFSPROC_READ:		printf(" read");		if (!(dp = parserep(rp, length)))			break;		if (v3) {			if (!(dp = parsestatus(dp, &er)))				break;			if (!(dp = parse_post_op_attr(dp, vflag)))//.........这里部分代码省略.........

static const u_int32_t *parsefattr(const u_int32_t *dp, int verbose, int v3){	const struct nfs_fattr *fap;	fap = (const struct nfs_fattr *)dp;	TCHECK(fap->fa_gid);	if (verbose) {		printf(" %s %o ids %d/%d",		    tok2str(type2str, "unk-ft %d ",		    EXTRACT_32BITS(&fap->fa_type)),		    EXTRACT_32BITS(&fap->fa_mode),		    EXTRACT_32BITS(&fap->fa_uid),		    EXTRACT_32BITS(&fap->fa_gid));		if (v3) {			TCHECK(fap->fa3_size);			printf(" sz %" PRIu64,				EXTRACT_64BITS((u_int32_t *)&fap->fa3_size));		} else {			TCHECK(fap->fa2_size);			printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size));		}	}	/* print lots more stuff */	if (verbose > 1) {		if (v3) {			TCHECK(fap->fa3_ctime);			printf(" nlink %d rdev %d/%d",			       EXTRACT_32BITS(&fap->fa_nlink),			       EXTRACT_32BITS(&fap->fa3_rdev.specdata1),			       EXTRACT_32BITS(&fap->fa3_rdev.specdata2));			printf(" fsid %" PRIx64,				EXTRACT_64BITS((u_int32_t *)&fap->fa3_fsid));			printf(" fileid %" PRIx64,				EXTRACT_64BITS((u_int32_t *)&fap->fa3_fileid));			printf(" a/m/ctime %u.%06u",			       EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),			       EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec));			printf(" %u.%06u",			       EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_sec),			       EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_nsec));			printf(" %u.%06u",			       EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_sec),			       EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_nsec));		} else {			TCHECK(fap->fa2_ctime);			printf(" nlink %d rdev %x fsid %x nodeid %x a/m/ctime",			       EXTRACT_32BITS(&fap->fa_nlink),			       EXTRACT_32BITS(&fap->fa2_rdev),			       EXTRACT_32BITS(&fap->fa2_fsid),			       EXTRACT_32BITS(&fap->fa2_fileid));			printf(" %u.%06u",			       EXTRACT_32BITS(&fap->fa2_atime.nfsv2_sec),			       EXTRACT_32BITS(&fap->fa2_atime.nfsv2_usec));			printf(" %u.%06u",			       EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_sec),			       EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_usec));			printf(" %u.%06u",			       EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_sec),			       EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec));		}	}	return ((const u_int32_t *)((unsigned char *)dp +		(v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));trunc:	return (NULL);}

/* * Return a pointer to the beginning of the actual results. * If the packet was truncated, return 0. */static const u_int32_t *parserep(register const struct sunrpc_msg *rp, register u_int length){	register const u_int32_t *dp;	u_int len;	enum sunrpc_accept_stat astat;	/*	 * Portability note:	 * Here we find the address of the ar_verf credentials.	 * Originally, this calculation was	 *	dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf	 * On the wire, the rp_acpt field starts immediately after	 * the (32 bit) rp_stat field.  However, rp_acpt (which is a	 * "struct accepted_reply") contains a "struct opaque_auth",	 * whose internal representation contains a pointer, so on a	 * 64-bit machine the compiler inserts 32 bits of padding	 * before rp->rm_reply.rp_acpt.ar_verf.  So, we cannot use	 * the internal representation to parse the on-the-wire	 * representation.  Instead, we skip past the rp_stat field,	 * which is an "enum" and so occupies one 32-bit word.	 */	dp = ((const u_int32_t *)&rp->rm_reply) + 1;	TCHECK(dp[1]);	len = EXTRACT_32BITS(&dp[1]);	if (len >= length)		return (NULL);	/*	 * skip past the ar_verf credentials.	 */	dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t);	TCHECK2(dp[0], 0);	/*	 * now we can check the ar_stat field	 */	astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp);	switch (astat) {	case SUNRPC_SUCCESS:		break;	case SUNRPC_PROG_UNAVAIL:		printf(" PROG_UNAVAIL");		nfserr = 1;		/* suppress trunc string */		return (NULL);	case SUNRPC_PROG_MISMATCH:		printf(" PROG_MISMATCH");		nfserr = 1;		/* suppress trunc string */		return (NULL);	case SUNRPC_PROC_UNAVAIL:		printf(" PROC_UNAVAIL");		nfserr = 1;		/* suppress trunc string */		return (NULL);	case SUNRPC_GARBAGE_ARGS:		printf(" GARBAGE_ARGS");		nfserr = 1;		/* suppress trunc string */		return (NULL);	case SUNRPC_SYSTEM_ERR:		printf(" SYSTEM_ERR");		nfserr = 1;		/* suppress trunc string */		return (NULL);	default:		printf(" ar_stat %d", astat);		nfserr = 1;		/* suppress trunc string */		return (NULL);	}	/* successful return */	TCHECK2(*dp, sizeof(astat));	return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));trunc:	return (0);}

//.........这里部分代码省略.........#endif#ifdef DLT_JUNIPER_MLFR    case DLT_JUNIPER_MLFR:        switch (l2info->cookie_type) {        case LS_COOKIE_ID:            l2info->bundle = l2info->cookie[1];            l2info->proto = EXTRACT_16BITS(p);                    l2info->header_len += 2;            l2info->length -= 2;            l2info->caplen -= 2;            break;        case AS_COOKIE_ID:            l2info->bundle = (EXTRACT_16BITS(&l2info->cookie[6])>>3)&0xfff;            l2info->proto = (l2info->cookie[5])&JUNIPER_LSQ_L3_PROTO_MASK;            break;        default:            l2info->bundle = l2info->cookie[0];            l2info->header_len += 2;            l2info->length -= 2;            l2info->caplen -= 2;            break;        }        break;#endif#ifdef DLT_JUNIPER_MFR    case DLT_JUNIPER_MFR:        switch (l2info->cookie_type) {        case LS_COOKIE_ID:            l2info->bundle = l2info->cookie[1];            l2info->proto = EXTRACT_16BITS(p);                    l2info->header_len += 2;            l2info->length -= 2;            l2info->caplen -= 2;            break;        case AS_COOKIE_ID:            l2info->bundle = (EXTRACT_16BITS(&l2info->cookie[6])>>3)&0xfff;            l2info->proto = (l2info->cookie[5])&JUNIPER_LSQ_L3_PROTO_MASK;            break;        default:            l2info->bundle = l2info->cookie[0];            break;        }        break;#endif#ifdef DLT_JUNIPER_ATM2    case DLT_JUNIPER_ATM2:        TCHECK2(p[0],4);                if (l2info->cookie[7] & ATM2_PKT_TYPE_MASK) {            control_word = EXTRACT_32BITS(p);                        switch(control_word) {            case 0:             case 0x08000000:             case 0x08380000:                 l2info->header_len += 4;                break;            default:                break;            }                        if (eflag)                printf("control-word 0x%08x ", control_word);        }        break;#endif#ifdef DLT_JUNIPER_ATM1    case DLT_JUNIPER_ATM1:        break;#endif#ifdef DLT_JUNIPER_PPP    case DLT_JUNIPER_PPP:        break;#endif#ifdef DLT_JUNIPER_CHDLC    case DLT_JUNIPER_CHDLC:        break;#endif#ifdef DLT_JUNIPER_ETHER    case DLT_JUNIPER_ETHER:        break;#endif#ifdef DLT_JUNIPER_FRELAY    case DLT_JUNIPER_FRELAY:        break;#endif    default:        printf("Unknown Juniper DLT_ type %u: ", l2info->pictype);        break;    }        if (eflag > 1)        printf("hlen %u, proto 0x%04x, ",l2info->header_len,l2info->proto);    return 1;  trunc:    printf("[|juniper_hdr], length %u",h->len);    return 0;}

//.........这里部分代码省略.........                metric = EXTRACT_16BITS(message + 10);                printf("%s%s%s %s metric %u seqno %u interval %s",                       (message[3] & 0x80) ? "/prefix": "",                       (message[3] & 0x40) ? "/id" : "",                       (message[3] & 0x3f) ? "/unknown" : "",                       format_prefix(prefix, plen),                       metric, seqno, format_interval_update(interval));                if(message[3] & 0x80) {                    if(message[2] == 1)                        memcpy(v4_prefix, prefix, 16);                    else                        memcpy(v6_prefix, prefix, 16);                }                /* extra data? */                if((u_int)rc < len - 10)                    subtlvs_print(message + 12 + rc, message + 2 + len, type);            }        }            break;        case MESSAGE_REQUEST: {            if(!vflag)                printf(" request");            else {                int rc;                u_char prefix[16], plen;                printf("/n/tRequest ");                if(len < 2) goto corrupt;                plen = message[3] + (message[2] == 1 ? 96 : 0);                rc = network_prefix(message[2], message[3], 0,                                    message + 4, NULL, len - 2, prefix);                if(rc < 0) goto corrupt;                plen = message[3] + (message[2] == 1 ? 96 : 0);                printf("for %s",                       message[2] == 0 ? "any" : format_prefix(prefix, plen));            }        }            break;        case MESSAGE_MH_REQUEST : {            if(!vflag)                printf(" mh-request");            else {                int rc;                u_short seqno;                u_char prefix[16], plen;                printf("/n/tMH-Request ");                if(len < 14) goto corrupt;                seqno = EXTRACT_16BITS(message + 4);                rc = network_prefix(message[2], message[3], 0,                                    message + 16, NULL, len - 14, prefix);                if(rc < 0) goto corrupt;                plen = message[3] + (message[2] == 1 ? 96 : 0);                printf("(%u hops) for %s seqno %u id %s",                       message[6], format_prefix(prefix, plen),                       seqno, format_id(message + 8));            }        }            break;        case MESSAGE_TSPC :            if(!vflag)                printf(" tspc");            else {                printf("/n/tTS/PC ");                if(len < 6) goto corrupt;                printf("timestamp %u packetcounter %u", EXTRACT_32BITS (message + 4),                       EXTRACT_16BITS(message + 2));            }            break;        case MESSAGE_HMAC : {            if(!vflag)                printf(" hmac");            else {                unsigned j;                printf("/n/tHMAC ");                if(len < 18) goto corrupt;                printf("key-id %u digest-%u ", EXTRACT_16BITS(message + 2), len - 2);                for (j = 0; j < len - 2; j++)                    printf ("%02X", message[4 + j]);            }        }            break;        default:            if(!vflag)                printf(" unknown");            else                printf("/n/tUnknown message type %d", type);        }        i += len + 2;    }    return; trunc:    printf(" [|babel]");    return; corrupt:    printf(" (corrupt)");    return;}

static voidchdlc_slarp_print(netdissect_options *ndo, const u_char *cp, u_int length){	const struct cisco_slarp *slarp;        u_int sec,min,hrs,days;	ND_PRINT((ndo, "SLARP (length: %u), ",length));	if (length < SLARP_MIN_LEN)		goto trunc;	slarp = (const struct cisco_slarp *)cp;	ND_TCHECK2(*slarp, SLARP_MIN_LEN);	switch (EXTRACT_32BITS(&slarp->code)) {	case SLARP_REQUEST:		ND_PRINT((ndo, "request"));		/*		 * At least according to William "Chops" Westfield's		 * message in		 *		 *	http://www.nethelp.no/net/cisco-hdlc.txt		 *		 * the address and mask aren't used in requests -		 * they're just zero.		 */		break;	case SLARP_REPLY:		ND_PRINT((ndo, "reply %s/%s",			ipaddr_string(ndo, &slarp->un.addr.addr),			ipaddr_string(ndo, &slarp->un.addr.mask)));		break;	case SLARP_KEEPALIVE:		ND_PRINT((ndo, "keepalive: mineseen=0x%08x, yourseen=0x%08x, reliability=0x%04x",                       EXTRACT_32BITS(&slarp->un.keep.myseq),                       EXTRACT_32BITS(&slarp->un.keep.yourseq),                       EXTRACT_16BITS(&slarp->un.keep.rel)));                if (length >= SLARP_MAX_LEN) { /* uptime-stamp is optional */                        cp += SLARP_MIN_LEN;                        ND_TCHECK2(*cp, 4);                        sec = EXTRACT_32BITS(cp) / 1000;                        min = sec / 60; sec -= min * 60;                        hrs = min / 60; min -= hrs * 60;                        days = hrs / 24; hrs -= days * 24;                        ND_PRINT((ndo, ", link uptime=%ud%uh%um%us",days,hrs,min,sec));                }		break;	default:		ND_PRINT((ndo, "0x%02x unknown", EXTRACT_32BITS(&slarp->code)));                if (ndo->ndo_vflag <= 1)                    print_unknown_data(ndo,cp+4,"/n/t",length-4);		break;	}	if (SLARP_MAX_LEN < length && ndo->ndo_vflag)		ND_PRINT((ndo, ", (trailing junk: %d bytes)", length - SLARP_MAX_LEN));        if (ndo->ndo_vflag > 1)            print_unknown_data(ndo,cp+4,"/n/t",length-4);	return;trunc:	ND_PRINT((ndo, "[|slarp]"));}

//.........这里部分代码省略.........		(void)strncpy(cp, " lifetime ", sizeof(buf) - (cp - buf));		cp = buf + strlen(buf);		lifetime = EXTRACT_16BITS(&ihp->ird_lifetime);		if (lifetime < 60) {			(void)snprintf(cp, sizeof(buf) - (cp - buf), "%u",			    lifetime);		} else if (lifetime < 60 * 60) {			(void)snprintf(cp, sizeof(buf) - (cp - buf), "%u:%02u",			    lifetime / 60, lifetime % 60);		} else {			(void)snprintf(cp, sizeof(buf) - (cp - buf),			    "%u:%02u:%02u",			    lifetime / 3600,			    (lifetime % 3600) / 60,			    lifetime % 60);		}		cp = buf + strlen(buf);		num = ihp->ird_addrnum;		(void)snprintf(cp, sizeof(buf) - (cp - buf), " %d:", num);		cp = buf + strlen(buf);		size = ihp->ird_addrsiz;		if (size != 2) {			(void)snprintf(cp, sizeof(buf) - (cp - buf),			    " [size %d]", size);			break;		}		idp = (struct id_rdiscovery *)&dp->icmp_data;		while (num-- > 0) {			TCHECK(*idp);			(void)snprintf(cp, sizeof(buf) - (cp - buf), " {%s %u}",			    ipaddr_string(&idp->ird_addr),			    EXTRACT_32BITS(&idp->ird_pref));			cp = buf + strlen(buf);			++idp;		}	    }		break;	case ICMP_TIMXCEED:		TCHECK(dp->icmp_ip.ip_dst);		switch (dp->icmp_code) {		case ICMP_TIMXCEED_INTRANS:			str = "time exceeded in-transit";			break;		case ICMP_TIMXCEED_REASS:			str = "ip reassembly time exceeded";			break;		default:			(void)snprintf(buf, sizeof(buf), "time exceeded-#%d",			    dp->icmp_code);			break;		}		break;	case ICMP_PARAMPROB:		if (dp->icmp_code)			(void)snprintf(buf, sizeof(buf),			    "parameter problem - code %d", dp->icmp_code);		else {			TCHECK(dp->icmp_pptr);			(void)snprintf(buf, sizeof(buf),

voideigrp_print(netdissect_options *ndo, 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;    uint8_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;    ND_TCHECK(*eigrp_com_header);    /*     * Sanity checking of the header.     */    if (eigrp_com_header->version != EIGRP_VERSION) {	ND_PRINT((ndo, "EIGRP version %u packet not supported",eigrp_com_header->version));	return;    }    /* in non-verbose mode just lets print the basic Message Type*/    if (ndo->ndo_vflag < 1) {        ND_PRINT((ndo, "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 */    if (len < sizeof(struct eigrp_common_header)) {        ND_PRINT((ndo, "EIGRP %s, length: %u (too short, < %u)",               tok2str(eigrp_opcode_values, "unknown (%u)",eigrp_com_header->opcode),               len, (u_int) sizeof(struct eigrp_common_header)));        return;    }    tlen=len-sizeof(struct eigrp_common_header);    /* FIXME print other header info */    ND_PRINT((ndo, "/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 ? */        ND_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(ndo,tptr+sizeof(struct eigrp_tlv_header),"/n/t    ",tlen);            return;        }        ND_PRINT((ndo, "/n/t  %s TLV (0x%04x), length: %u",               tok2str(eigrp_tlv_values,                       "Unknown",                       eigrp_tlv_type),               eigrp_tlv_type,               eigrp_tlv_len));        if (eigrp_tlv_len < sizeof(struct eigrp_tlv_header)) {                ND_PRINT((ndo, " (too short, < %u)",                        (u_int) sizeof(struct eigrp_tlv_header)));                break;        }        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 ? */        ND_TCHECK2(*tptr, eigrp_tlv_len);        switch(eigrp_tlv_type) {//.........这里部分代码省略.........

voidahcp_print(netdissect_options *ndo, const u_char *cp, const u_int len){    const u_char *ep = cp + len;    uint8_t version;    ND_PRINT((ndo, "AHCP"));    if (len < 2)        goto invalid;    /* Magic */    ND_TCHECK2(*cp, 1);    if (*cp != AHCP_MAGIC_NUMBER)        goto invalid;    cp += 1;    /* Version */    ND_TCHECK2(*cp, 1);    version = *cp;    cp += 1;    switch (version) {    case AHCP_VERSION_1: {        ND_PRINT((ndo, " Version 1"));        if (len < AHCP1_HEADER_FIX_LEN)            goto invalid;        if (!ndo->ndo_vflag) {            ND_TCHECK2(*cp, AHCP1_HEADER_FIX_LEN - 2);            cp += AHCP1_HEADER_FIX_LEN - 2;        } else {            /* Hopcount */            ND_TCHECK2(*cp, 1);            ND_PRINT((ndo, "/n/tHopcount %u", *cp));            cp += 1;            /* Original Hopcount */            ND_TCHECK2(*cp, 1);            ND_PRINT((ndo, ", Original Hopcount %u", *cp));            cp += 1;            /* Nonce */            ND_TCHECK2(*cp, 4);            ND_PRINT((ndo, ", Nonce 0x%08x", EXTRACT_32BITS(cp)));            cp += 4;            /* Source Id */            ND_TCHECK2(*cp, 8);            ND_PRINT((ndo, ", Source Id %s", linkaddr_string(ndo, cp, 0, 8)));            cp += 8;            /* Destination Id */            ND_TCHECK2(*cp, 8);            ND_PRINT((ndo, ", Destination Id %s", linkaddr_string(ndo, cp, 0, 8)));            cp += 8;        }        /* Body */        ahcp1_body_print(ndo, cp, ep);        break;    }    default:        ND_PRINT((ndo, " Version %u (unknown)", version));        break;    }    return;invalid:    ND_PRINT((ndo, "%s", istr));    ND_TCHECK2(*cp, ep - cp);    return;trunc:    ND_PRINT((ndo, "%s", tstr));}

static intospf6_decode_v3(register const struct ospf6hdr *op,    register const u_char *dataend){	register const rtrid_t *ap;	register const struct lsr6 *lsrp;	register const struct lsa6_hdr *lshp;	register const struct lsa6 *lsap;	register int i;	switch (op->ospf6_type) {	case OSPF_TYPE_HELLO:                printf("/n/tOptions [%s]",                       bittok2str(ospf6_option_values, "none",                                  EXTRACT_32BITS(&op->ospf6_hello.hello_options)));                TCHECK(op->ospf6_hello.hello_deadint);                printf("/n/t  Hello Timer %us, Dead Timer %us, Interface-ID %s, Priority %u",                       EXTRACT_16BITS(&op->ospf6_hello.hello_helloint),                       EXTRACT_16BITS(&op->ospf6_hello.hello_deadint),                       ipaddr_string(&op->ospf6_hello.hello_ifid),                       op->ospf6_hello.hello_priority);		TCHECK(op->ospf6_hello.hello_dr);		if (op->ospf6_hello.hello_dr != 0)			printf("/n/t  Designated Router %s",			    ipaddr_string(&op->ospf6_hello.hello_dr));		TCHECK(op->ospf6_hello.hello_bdr);		if (op->ospf6_hello.hello_bdr != 0)			printf(", Backup Designated Router %s",			    ipaddr_string(&op->ospf6_hello.hello_bdr));		if (vflag) {			printf("/n/t  Neighbor List:");			ap = op->ospf6_hello.hello_neighbor;			while ((u_char *)ap < dataend) {				TCHECK(*ap);				printf("/n/t    %s", ipaddr_string(ap));				++ap;			}		}		break;	/* HELLO */	case OSPF_TYPE_DD:		TCHECK(op->ospf6_db.db_options);                printf("/n/tOptions [%s]",                       bittok2str(ospf6_option_values, "none",                                  EXTRACT_32BITS(&op->ospf6_db.db_options)));		TCHECK(op->ospf6_db.db_flags);                printf(", DD Flags [%s]",                       bittok2str(ospf6_dd_flag_values,"none",op->ospf6_db.db_flags));		TCHECK(op->ospf6_db.db_seq);		printf(", MTU %u, DD-Sequence 0x%08x",                       EXTRACT_16BITS(&op->ospf6_db.db_mtu),                       EXTRACT_32BITS(&op->ospf6_db.db_seq));                /* Print all the LS adv's */                lshp = op->ospf6_db.db_lshdr;                while (!ospf6_print_lshdr(lshp)) {                    ++lshp;                }		break;	case OSPF_TYPE_LS_REQ:		if (vflag) {			lsrp = op->ospf6_lsr;			while ((u_char *)lsrp < dataend) {				TCHECK(*lsrp);                                printf("/n/t  Advertising Router %s",                                       ipaddr_string(&lsrp->ls_router));				ospf6_print_ls_type(EXTRACT_16BITS(&lsrp->ls_type),                                                    &lsrp->ls_stateid);				++lsrp;			}		}		break;	case OSPF_TYPE_LS_UPDATE:		if (vflag) {			lsap = op->ospf6_lsu.lsu_lsa;			TCHECK(op->ospf6_lsu.lsu_count);			i = EXTRACT_32BITS(&op->ospf6_lsu.lsu_count);			while (i--) {				if (ospf6_print_lsa(lsap))					goto trunc;				lsap = (struct lsa6 *)((u_char *)lsap +				    EXTRACT_16BITS(&lsap->ls_hdr.ls_length));			}		}		break;	case OSPF_TYPE_LS_ACK:		if (vflag) {			lshp = op->ospf6_lsa.lsa_lshdr;			while (!ospf6_print_lshdr(lshp)) {				++lshp;			}//.........这里部分代码省略.........

//.........这里部分代码省略.........                     pgm->pgm_gsid[2],		     pgm->pgm_gsid[3],                     pgm->pgm_gsid[4],                     pgm->pgm_gsid[5]);	switch (pgm->pgm_type) {	case PGM_SPM: {	    struct pgm_spm *spm;	    spm = (struct pgm_spm *)(pgm + 1);	    TCHECK(*spm);	    switch (EXTRACT_16BITS(&spm->pgms_nla_afi)) {	    case AFI_IP:		addr_size = sizeof(struct in_addr);		nla_af = AF_INET;		break;#ifdef INET6	    case AFI_IP6:		addr_size = sizeof(struct in6_addr);		nla_af = AF_INET6;		break;#endif	    default:		goto trunc;		break;	    }	    bp = (u_char *) (spm + 1);	    TCHECK2(*bp, addr_size);	    nla = bp;	    bp += addr_size;	    inet_ntop(nla_af, nla, nla_buf, sizeof(nla_buf));	    (void)printf("SPM seq %u trail %u lead %u nla %s",			 EXTRACT_32BITS(&spm->pgms_seq),                         EXTRACT_32BITS(&spm->pgms_trailseq),			 EXTRACT_32BITS(&spm->pgms_leadseq),                         nla_buf);	    break;	}	case PGM_POLL: {	    struct pgm_poll *poll;	    poll = (struct pgm_poll *)(pgm + 1);	    TCHECK(*poll);	    (void)printf("POLL seq %u round %u",			 EXTRACT_32BITS(&poll->pgmp_seq),                         EXTRACT_16BITS(&poll->pgmp_round));	    bp = (u_char *) (poll + 1);	    break;	}	case PGM_POLR: {	    struct pgm_polr *polr;	    u_int32_t ivl, rnd, mask;	    polr = (struct pgm_polr *)(pgm + 1);	    TCHECK(*polr);	    switch (EXTRACT_16BITS(&polr->pgmp_nla_afi)) {	    case AFI_IP:		addr_size = sizeof(struct in_addr);		nla_af = AF_INET;		break;#ifdef INET6	    case AFI_IP6:		addr_size = sizeof(struct in6_addr);

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(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);//.........这里部分代码省略.........

/* * Print a single link state advertisement.  If truncated return 1, else 0. */static intospf6_print_lsa(netdissect_options *ndo,                register const struct lsa6 *lsap, const u_char *dataend){	register const struct rlalink6 *rlp;#if 0	register const struct tos_metric *tosp;#endif	register const rtrid_t *ap;#if 0	register const struct aslametric *almp;	register const struct mcla *mcp;#endif	register const struct llsa *llsap;	register const struct lsa6_prefix *lsapp;#if 0	register const uint32_t *lp;#endif	register u_int prefixes;	register int bytelen;	register u_int length, lsa_length;	uint32_t flags32;	const uint8_t *tptr;	if (ospf6_print_lshdr(ndo, &lsap->ls_hdr, dataend))		return (1);	ND_TCHECK(lsap->ls_hdr.ls_length);        length = EXTRACT_16BITS(&lsap->ls_hdr.ls_length);	/*	 * The LSA length includes the length of the header;	 * it must have a value that's at least that length.	 * If it does, find the length of what follows the	 * header.	 */        if (length < sizeof(struct lsa6_hdr) || (const u_char *)lsap + length > dataend)        	return (1);        lsa_length = length - sizeof(struct lsa6_hdr);        tptr = (const uint8_t *)lsap+sizeof(struct lsa6_hdr);	switch (EXTRACT_16BITS(&lsap->ls_hdr.ls_type)) {	case LS_TYPE_ROUTER | LS_SCOPE_AREA:		if (lsa_length < sizeof (lsap->lsa_un.un_rla.rla_options))			return (1);		lsa_length -= sizeof (lsap->lsa_un.un_rla.rla_options);		ND_TCHECK(lsap->lsa_un.un_rla.rla_options);		ND_PRINT((ndo, "/n/t      Options [%s]",		          bittok2str(ospf6_option_values, "none",		          EXTRACT_32BITS(&lsap->lsa_un.un_rla.rla_options))));		ND_PRINT((ndo, ", RLA-Flags [%s]",		          bittok2str(ospf6_rla_flag_values, "none",		          lsap->lsa_un.un_rla.rla_flags)));		rlp = lsap->lsa_un.un_rla.rla_link;		while (lsa_length != 0) {			if (lsa_length < sizeof (*rlp))				return (1);			lsa_length -= sizeof (*rlp);			ND_TCHECK(*rlp);			switch (rlp->link_type) {			case RLA_TYPE_VIRTUAL:				ND_PRINT((ndo, "/n/t      Virtual Link: Neighbor Router-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",                                       ipaddr_string(ndo, &rlp->link_nrtid),                                       ipaddr_string(ndo, &rlp->link_nifid),                                       ipaddr_string(ndo, &rlp->link_ifid)));                                break;			case RLA_TYPE_ROUTER:				ND_PRINT((ndo, "/n/t      Neighbor Router-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",                                       ipaddr_string(ndo, &rlp->link_nrtid),                                       ipaddr_string(ndo, &rlp->link_nifid),                                       ipaddr_string(ndo, &rlp->link_ifid)));				break;			case RLA_TYPE_TRANSIT:				ND_PRINT((ndo, "/n/t      Neighbor Network-ID %s"                                       "/n/t      Neighbor Interface-ID %s, Interface %s",				    ipaddr_string(ndo, &rlp->link_nrtid),				    ipaddr_string(ndo, &rlp->link_nifid),				    ipaddr_string(ndo, &rlp->link_ifid)));				break;			default:				ND_PRINT((ndo, "/n/t      Unknown Router Links Type 0x%02x",				    rlp->link_type));				return (0);			}			ND_PRINT((ndo, ", metric %d", EXTRACT_16BITS(&rlp->link_metric)));			rlp++;		}		break;	case LS_TYPE_NETWORK | LS_SCOPE_AREA:		if (lsa_length < sizeof (lsap->lsa_un.un_nla.nla_options))//.........这里部分代码省略.........

static intospf6_decode_v3(netdissect_options *ndo,                register const struct ospf6hdr *op,                register const u_char *dataend){	register const rtrid_t *ap;	register const struct lsr6 *lsrp;	register const struct lsa6_hdr *lshp;	register const struct lsa6 *lsap;	register int i;	switch (op->ospf6_type) {	case OSPF_TYPE_HELLO: {		register const struct hello6 *hellop = (const struct hello6 *)((const uint8_t *)op + OSPF6HDR_LEN);		ND_PRINT((ndo, "/n/tOptions [%s]",		          bittok2str(ospf6_option_values, "none",		          EXTRACT_32BITS(&hellop->hello_options))));		ND_TCHECK(hellop->hello_deadint);		ND_PRINT((ndo, "/n/t  Hello Timer %us, Dead Timer %us, Interface-ID %s, Priority %u",		          EXTRACT_16BITS(&hellop->hello_helloint),		          EXTRACT_16BITS(&hellop->hello_deadint),		          ipaddr_string(ndo, &hellop->hello_ifid),		          hellop->hello_priority));		ND_TCHECK(hellop->hello_dr);		if (EXTRACT_32BITS(&hellop->hello_dr) != 0)			ND_PRINT((ndo, "/n/t  Designated Router %s",			    ipaddr_string(ndo, &hellop->hello_dr)));		ND_TCHECK(hellop->hello_bdr);		if (EXTRACT_32BITS(&hellop->hello_bdr) != 0)			ND_PRINT((ndo, ", Backup Designated Router %s",			    ipaddr_string(ndo, &hellop->hello_bdr)));		if (ndo->ndo_vflag > 1) {			ND_PRINT((ndo, "/n/t  Neighbor List:"));			ap = hellop->hello_neighbor;			while ((const u_char *)ap < dataend) {				ND_TCHECK(*ap);				ND_PRINT((ndo, "/n/t    %s", ipaddr_string(ndo, ap)));				++ap;			}		}		break;	/* HELLO */	}	case OSPF_TYPE_DD: {		register const struct dd6 *ddp = (const struct dd6 *)((const uint8_t *)op + OSPF6HDR_LEN);		ND_TCHECK(ddp->db_options);		ND_PRINT((ndo, "/n/tOptions [%s]",		          bittok2str(ospf6_option_values, "none",		          EXTRACT_32BITS(&ddp->db_options))));		ND_TCHECK(ddp->db_flags);		ND_PRINT((ndo, ", DD Flags [%s]",		          bittok2str(ospf6_dd_flag_values,"none",ddp->db_flags)));		ND_TCHECK(ddp->db_seq);		ND_PRINT((ndo, ", MTU %u, DD-Sequence 0x%08x",                       EXTRACT_16BITS(&ddp->db_mtu),                       EXTRACT_32BITS(&ddp->db_seq)));		if (ndo->ndo_vflag > 1) {			/* Print all the LS adv's */			lshp = ddp->db_lshdr;			while ((const u_char *)lshp < dataend) {				if (ospf6_print_lshdr(ndo, lshp++, dataend))					goto trunc;			}		}		break;	}	case OSPF_TYPE_LS_REQ:		if (ndo->ndo_vflag > 1) {			lsrp = (const struct lsr6 *)((const uint8_t *)op + OSPF6HDR_LEN);			while ((const u_char *)lsrp < dataend) {				ND_TCHECK(*lsrp);				ND_PRINT((ndo, "/n/t  Advertising Router %s",				          ipaddr_string(ndo, &lsrp->ls_router)));				ospf6_print_ls_type(ndo, EXTRACT_16BITS(&lsrp->ls_type),                                                    &lsrp->ls_stateid);				++lsrp;			}		}		break;	case OSPF_TYPE_LS_UPDATE:		if (ndo->ndo_vflag > 1) {			register const struct lsu6 *lsup = (const struct lsu6 *)((const uint8_t *)op + OSPF6HDR_LEN);			ND_TCHECK(lsup->lsu_count);			i = EXTRACT_32BITS(&lsup->lsu_count);			lsap = lsup->lsu_lsa;			while ((const u_char *)lsap < dataend && i--) {				if (ospf6_print_lsa(ndo, lsap, dataend))					goto trunc;				lsap = (const struct lsa6 *)((const u_char *)lsap +				    EXTRACT_16BITS(&lsap->ls_hdr.ls_length));			}//.........这里部分代码省略.........

static voidpptp_id_print(const u_int32_t *id){	printf(" ID(%u)", EXTRACT_32BITS(id));}

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;}

//.........这里部分代码省略.........		ND_PRINT((ndo, "CCVal %d, CsCov %d, ", DCCPH_CCVAL(dh), DCCPH_CSCOV(dh)));	}	/* checksum calculation */	if (ndo->ndo_vflag && ND_TTEST2(bp[0], len)) {		u_int16_t sum = 0, dccp_sum;		dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);		ND_PRINT((ndo, "cksum 0x%04x ", dccp_sum));		if (IP_V(ip) == 4)			sum = dccp_cksum(ndo, ip, dh, len);#ifdef INET6		else if (IP_V(ip) == 6)			sum = dccp6_cksum(ip6, dh, len);#endif		if (sum != 0)			ND_PRINT((ndo, "(incorrect -> 0x%04x), ",in_cksum_shouldbe(dccp_sum, sum)));		else			ND_PRINT((ndo, "(correct), "));	}	switch (DCCPH_TYPE(dh)) {	case DCCP_PKT_REQUEST: {		struct dccp_hdr_request *dhr =			(struct dccp_hdr_request *)(bp + fixed_hdrlen);		fixed_hdrlen += 4;		if (len < fixed_hdrlen) {			ND_PRINT((ndo, "truncated-dccp request - %u bytes missing!",				     len - fixed_hdrlen));			return;		}		ND_TCHECK(*dhr);		ND_PRINT((ndo, "request (service=%d) ",			     EXTRACT_32BITS(&dhr->dccph_req_service)));		break;	}	case DCCP_PKT_RESPONSE: {		struct dccp_hdr_response *dhr =			(struct dccp_hdr_response *)(bp + fixed_hdrlen);		fixed_hdrlen += 12;		if (len < fixed_hdrlen) {			ND_PRINT((ndo, "truncated-dccp response - %u bytes missing!",				     len - fixed_hdrlen));			return;		}		ND_TCHECK(*dhr);		ND_PRINT((ndo, "response (service=%d) ",			     EXTRACT_32BITS(&dhr->dccph_resp_service)));		break;	}	case DCCP_PKT_DATA:		ND_PRINT((ndo, "data "));		break;	case DCCP_PKT_ACK: {		fixed_hdrlen += 8;		if (len < fixed_hdrlen) {			ND_PRINT((ndo, "truncated-dccp ack - %u bytes missing!",				     len - fixed_hdrlen));			return;		}		ND_PRINT((ndo, "ack "));		break;	}	case DCCP_PKT_DATAACK: {		fixed_hdrlen += 8;		if (len < fixed_hdrlen) {

static voidatp_print(netdissect_options *ndo,          register const struct atATP *ap, u_int length){	char c;	uint32_t data;	if ((const u_char *)(ap + 1) > ndo->ndo_snapend) {		/* Just bail if we don't have the whole chunk. */		ND_PRINT((ndo, "%s", tstr));		return;	}	if (length < sizeof(*ap)) {		ND_PRINT((ndo, " [|atp %u]", length));		return;	}	length -= sizeof(*ap);	switch (ap->control & 0xc0) {	case atpReqCode:		ND_PRINT((ndo, " atp-req%s %d",			     ap->control & atpXO? " " : "*",			     EXTRACT_16BITS(&ap->transID)));		atp_bitmap_print(ndo, ap->bitmap);		if (length != 0)			ND_PRINT((ndo, " [len=%u]", length));		switch (ap->control & (atpEOM|atpSTS)) {		case atpEOM:			ND_PRINT((ndo, " [EOM]"));			break;		case atpSTS:			ND_PRINT((ndo, " [STS]"));			break;		case atpEOM|atpSTS:			ND_PRINT((ndo, " [EOM,STS]"));			break;		}		break;	case atpRspCode:		ND_PRINT((ndo, " atp-resp%s%d:%d (%u)",			     ap->control & atpEOM? "*" : " ",			     EXTRACT_16BITS(&ap->transID), ap->bitmap, length));		switch (ap->control & (atpXO|atpSTS)) {		case atpXO:			ND_PRINT((ndo, " [XO]"));			break;		case atpSTS:			ND_PRINT((ndo, " [STS]"));			break;		case atpXO|atpSTS:			ND_PRINT((ndo, " [XO,STS]"));			break;		}		break;	case atpRelCode:		ND_PRINT((ndo, " atp-rel  %d", EXTRACT_16BITS(&ap->transID)));		atp_bitmap_print(ndo, ap->bitmap);		/* length should be zero */		if (length)			ND_PRINT((ndo, " [len=%u]", length));		/* there shouldn't be any control flags */		if (ap->control & (atpXO|atpEOM|atpSTS)) {			c = '[';			if (ap->control & atpXO) {				ND_PRINT((ndo, "%cXO", c));				c = ',';			}			if (ap->control & atpEOM) {				ND_PRINT((ndo, "%cEOM", c));				c = ',';			}			if (ap->control & atpSTS) {				ND_PRINT((ndo, "%cSTS", c));				c = ',';			}			ND_PRINT((ndo, "]"));		}		break;	default:		ND_PRINT((ndo, " atp-0x%x  %d (%u)", ap->control,			     EXTRACT_16BITS(&ap->transID), length));		break;	}	data = EXTRACT_32BITS(&ap->userData);	if (data != 0)		ND_PRINT((ndo, " 0x%x", data));}