const u_int8_t **dstp){	if (vflag) {		if (FC_MORE_DATA(fc))			printf("More Data ");		if (FC_MORE_FLAG(fc))			printf("More Fragments ");		if (FC_POWER_MGMT(fc))			printf("Pwr Mgmt ");		if (FC_RETRY(fc))			printf("Retry ");		if (FC_ORDER(fc))			printf("Strictly Ordered ");		if (FC_WEP(fc))			printf("WEP Encrypted ");		if (FC_TYPE(fc) != T_CTRL || FC_SUBTYPE(fc) != CTRL_PS_POLL)			printf("%dus ",			    EXTRACT_LE_16BITS(			        &((const struct mgmt_header_t *)p)->duration));	}	switch (FC_TYPE(fc)) {	case T_MGMT:		mgmt_header_print(p, srcp, dstp);		break;	case T_CTRL:		ctrl_header_print(fc, p, srcp, dstp);		break;	case T_DATA:		data_header_print(fc, p, srcp, dstp);		break;	default:		printf("(header) unknown IEEE802.11 frame type (%d)",		    FC_TYPE(fc));		*srcp = NULL;		*dstp = NULL;		break;	}}#ifndef roundup2#define	roundup2(x, y)	(((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */#endifstatic u_intieee802_11_print(const u_char *p, u_int length, u_int caplen, int pad){	u_int16_t fc;	u_int hdrlen;	const u_int8_t *src, *dst;	u_short extracted_ethertype;	if (caplen < IEEE802_11_FC_LEN) {		printf("[|802.11]");		return caplen;	}	fc = EXTRACT_LE_16BITS(p);	hdrlen = extract_header_length(fc);	if (pad)		hdrlen = roundup2(hdrlen, 4);	if (caplen < hdrlen) {		printf("[|802.11]");		return hdrlen;	}	ieee_802_11_hdr_print(fc, p, &src, &dst);	/*	 * Go past the 802.11 header.	 */	length -= hdrlen;	caplen -= hdrlen;	p += hdrlen;	switch (FC_TYPE(fc)) {	case T_MGMT:		if (!mgmt_body_print(fc,		    (const struct mgmt_header_t *)(p - hdrlen), p)) {			printf("[|802.11]");			return hdrlen;		}		break;	case T_CTRL:		if (!ctrl_body_print(fc, p - hdrlen)) {			printf("[|802.11]");			return hdrlen;		}		break;	case T_DATA:		if (DATA_FRAME_IS_NULL(FC_SUBTYPE(fc)))			return hdrlen;	/* no-data frame */		/* There may be a problem w/ AP not having this bit set */		if (FC_WEP(fc)) {			if (!wep_print(p)) {				printf("[|802.11]");				return hdrlen;			}		} else if (llc_print(p, length, caplen, dst, src,		    &extracted_ethertype) == 0) {			/*			 * Some kinds of LLC packet we cannot			 * handle intelligently			 */			if (!eflag)				ieee_802_11_hdr_print(fc, p - hdrlen, NULL,				    NULL);			if (extracted_ethertype)				printf("(LLC %s) ",				    etherproto_string(				        htons(extracted_ethertype)));			if (!suppress_default_print)				default_print(p, caplen);		}		break;	default:		printf("unknown 802.11 frame type (%d)", FC_TYPE(fc));		break;	}	return hdrlen;}/* * This is the top level routine of the printer.  'p' points * to the 802.11 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_intieee802_11_if_print(const struct pcap_pkthdr *h, const u_char *p){	return ieee802_11_print(p, h->len, h->caplen, 0);}static intprint_radiotap_field(struct cpack_state *s, u_int32_t bit, int *pad){	union {		int8_t		i8;		u_int8_t	u8;		int16_t		i16;		u_int16_t	u16;		u_int32_t	u32;		u_int64_t	u64;	} u, u2;	int rc;	switch (bit) {	case IEEE80211_RADIOTAP_FLAGS:		rc = cpack_uint8(s, &u.u8);		if (u.u8 & IEEE80211_RADIOTAP_F_DATAPAD)			*pad = 1;		break;	case IEEE80211_RADIOTAP_RATE:	case IEEE80211_RADIOTAP_DB_ANTSIGNAL:	case IEEE80211_RADIOTAP_DB_ANTNOISE:	case IEEE80211_RADIOTAP_ANTENNA:		rc = cpack_uint8(s, &u.u8);		break;	case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:	case IEEE80211_RADIOTAP_DBM_ANTNOISE:		rc = cpack_int8(s, &u.i8);		break;	case IEEE80211_RADIOTAP_CHANNEL:		rc = cpack_uint16(s, &u.u16);		if (rc != 0)			break;		rc = cpack_uint16(s, &u2.u16);		break;	case IEEE80211_RADIOTAP_FHSS:	case IEEE80211_RADIOTAP_LOCK_QUALITY:	case IEEE80211_RADIOTAP_TX_ATTENUATION:		rc = cpack_uint16(s, &u.u16);		break;	case IEEE80211_RADIOTAP_DB_TX_ATTENUATION:		rc = cpack_uint8(s, &u.u8);		break;	case IEEE80211_RADIOTAP_DBM_TX_POWER:		rc = cpack_int8(s, &u.i8);		break;	case IEEE80211_RADIOTAP_TSFT:		rc = cpack_uint64(s, &u.u64);		break;	default:		/* this bit indicates a field whose		 * size we do not know, so we cannot		 * proceed.		 */		printf("[0x%08x] ", bit);		return -1;	}	if (rc != 0) {		printf("[|802.11]");		return rc;	}	switch (bit) {	case IEEE80211_RADIOTAP_CHANNEL:		printf("%u MHz ", u.u16);		if (u2.u16 != 0)			printf("(0x%04x) ", u2.u16);		break;	case IEEE80211_RADIOTAP_FHSS:		printf("fhset %d fhpat %d ", u.u16 & 0xff, (u.u16 >> 8) & 0xff);		break;	case IEEE80211_RADIOTAP_RATE:		PRINT_RATE("", u.u8, " Mb/s ");		break;	case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:		printf("%ddB signal ", u.i8);		break;	case IEEE80211_RADIOTAP_DBM_ANTNOISE:		printf("%ddB noise ", u.i8);		break;	case IEEE80211_RADIOTAP_DB_ANTSIGNAL:		printf("%ddB signal ", u.u8);		break;	case IEEE80211_RADIOTAP_DB_ANTNOISE:		printf("%ddB noise ", u.u8);		break;	case IEEE80211_RADIOTAP_LOCK_QUALITY:		printf("%u sq ", u.u16);		break;	case IEEE80211_RADIOTAP_TX_ATTENUATION:		printf("%d tx power ", -(int)u.u16);		break;	case IEEE80211_RADIOTAP_DB_TX_ATTENUATION:		printf("%ddB tx power ", -(int)u.u8);		break;	case IEEE80211_RADIOTAP_DBM_TX_POWER:		printf("%ddBm tx power ", u.i8);		break;	case IEEE80211_RADIOTAP_FLAGS:		if (u.u8 & IEEE80211_RADIOTAP_F_CFP)			printf("cfp ");		if (u.u8 & IEEE80211_RADIOTAP_F_SHORTPRE)			printf("short preamble ");		if (u.u8 & IEEE80211_RADIOTAP_F_WEP)			printf("wep ");		if (u.u8 & IEEE80211_RADIOTAP_F_FRAG)			printf("fragmented ");		if (u.u8 & IEEE80211_RADIOTAP_F_BADFCS)			printf("bad-fcs ");		break;	case IEEE80211_RADIOTAP_ANTENNA:		printf("antenna %d ", u.u8);		break;	case IEEE80211_RADIOTAP_TSFT:		printf("%" PRIu64 "us tsft ", u.u64);		break;	}	return 0;}static u_intieee802_11_radio_print(const u_char *p, u_int length, u_int caplen){#define	BITNO_32(x) (((x) >> 16) ? 16 + BITNO_16((x) >> 16) : BITNO_16((x)))#define	BITNO_16(x) (((x) >> 8) ? 8 + BITNO_8((x) >> 8) : BITNO_8((x)))#define	BITNO_8(x) (((x) >> 4) ? 4 + BITNO_4((x) >> 4) : BITNO_4((x)))#define	BITNO_4(x) (((x) >> 2) ? 2 + BITNO_2((x) >> 2) : BITNO_2((x)))#define	BITNO_2(x) (((x) & 2) ? 1 : 0)#define	BIT(n)	(1 << n)#define	IS_EXTENDED(__p)	\	    (EXTRACT_LE_32BITS(__p) & BIT(IEEE80211_RADIOTAP_EXT)) != 0	struct cpack_state cpacker;	struct ieee80211_radiotap_header *hdr;	u_int32_t present, next_present;	u_int32_t *presentp, *last_presentp;	enum ieee80211_radiotap_type bit;	int bit0;	const u_char *iter;	u_int len;	int pad;	if (caplen < sizeof(*hdr)) {		printf("[|802.11]");		return caplen;	}	hdr = (struct ieee80211_radiotap_header *)p;	len = EXTRACT_LE_16BITS(&hdr->it_len);	if (caplen < len) {		printf("[|802.11]");		return caplen;	}	for (last_presentp = &hdr->it_present;	     IS_EXTENDED(last_presentp) &&	     (u_char*)(last_presentp + 1) <= p + len;	     last_presentp++);	/* are there more bitmap extensions than bytes in header? */	if (IS_EXTENDED(last_presentp)) {		printf("[|802.11]");		return caplen;	}	iter = (u_char*)(last_presentp + 1);	if (cpack_init(&cpacker, (u_int8_t*)iter, len - (iter - p)) != 0) {		/* XXX */		printf("[|802.11]");		return caplen;	}	/* Assume no Atheros padding between 802.11 header and body */	pad = 0;	for (bit0 = 0, presentp = &hdr->it_present; presentp <= last_presentp;	     presentp++, bit0 += 32) {		for (present = EXTRACT_LE_32BITS(presentp); present;		     present = next_present) {			/* clear the least significant bit that is set */			next_present = present & (present - 1);			/* extract the least significant bit that is set */			bit = (enum ieee80211_radiotap_type)			    (bit0 + BITNO_32(present ^ next_present));			if (print_radiotap_field(&cpacker, bit, &pad) != 0)				goto out;		}	}out:	return len + ieee802_11_print(p + len, length - len, caplen - len, pad);#undef BITNO_32#undef BITNO_16#undef BITNO_8#undef BITNO_4#undef BITNO_2#undef BIT}static u_intieee802_11_avs_radio_print(const u_char *p, u_int length, u_int caplen){	u_int32_t caphdr_len;	if (caplen < 8) {		printf("[|802.11]");		return caplen;	}	caphdr_len = EXTRACT_32BITS(p + 4);	if (caphdr_len < 8) {		/*		 * Yow!  The capture header length is claimed not		 * to be large enough to include even the version		 * cookie or capture header length!		 */		printf("[|802.11]");		return caplen;	}	if (caplen < caphdr_len) {		printf("[|802.11]");		return caplen;	}	return caphdr_len + ieee802_11_print(p + caphdr_len,	    length - caphdr_len, caplen - caphdr_len, 0);}#define PRISM_HDR_LEN		144#define WLANCAP_MAGIC_COOKIE_BASE 0x80211000#define WLANCAP_MAGIC_COOKIE_V1	0x80211001#define WLANCAP_MAGIC_COOKIE_V2	0x80211002/* * For DLT_PRISM_HEADER; like DLT_IEEE802_11, but with an extra header, * containing information such as radio information, which we * currently ignore. * * If, however, the packet begins with WLANCAP_MAGIC_COOKIE_V1 or * WLANCAP_MAGIC_COOKIE_V2, it's really DLT_IEEE802_11_RADIO_AVS * (currently, on Linux, there's no ARPHRD_ type for * DLT_IEEE802_11_RADIO_AVS, as there is a ARPHRD_IEEE80211_PRISM * for DLT_PRISM_HEADER, so ARPHRD_IEEE80211_PRISM is used for * the AVS header, and the first 4 bytes of the header are used to * indicate whether it's a Prism header or an AVS header). */u_intprism_if_print(const struct pcap_pkthdr *h, const u_char *p){	u_int caplen = h->caplen;	u_int length = h->len;	u_int32_t msgcode;	if (caplen < 4) {		printf("[|802.11]");		return caplen;	}	msgcode = EXTRACT_32BITS(p);	if (msgcode == WLANCAP_MAGIC_COOKIE_V1 ||	    msgcode == WLANCAP_MAGIC_COOKIE_V2)		return ieee802_11_avs_radio_print(p, length, caplen);	if (caplen < PRISM_HDR_LEN) {		printf("[|802.11]");		return caplen;	}	return PRISM_HDR_LEN + ieee802_11_print(p + PRISM_HDR_LEN,	    length - PRISM_HDR_LEN, caplen - PRISM_HDR_LEN, 0);}/* * For DLT_IEEE802_11_RADIO; like DLT_IEEE802_11, but with an extra * header, containing information such as radio information. */u_intieee802_11_radio_if_print(const struct pcap_pkthdr *h, const u_char *p){	return ieee802_11_radio_print(p, h->len, h->caplen);}/* * For DLT_IEEE802_11_RADIO_AVS; like DLT_IEEE802_11, but with an * extra header, containing information such as radio information, * which we currently ignore. */u_intieee802_11_radio_avs_if_print(const struct pcap_pkthdr *h, const u_char *p){	return ieee802_11_avs_radio_print(p, h->len, h->caplen);}