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

/* * Indicate whether there are frames queued for a station in power-save mode. */static intieee80211_set_tim(struct ieee80211_node *ni, int set){	struct ieee80211vap *vap = ni->ni_vap;	struct ieee80211com *ic = ni->ni_ic;	uint16_t aid;	int changed;	KASSERT(vap->iv_opmode == IEEE80211_M_HOSTAP ||		vap->iv_opmode == IEEE80211_M_IBSS,		("operating mode %u", vap->iv_opmode));	aid = IEEE80211_AID(ni->ni_associd);	KASSERT(aid < vap->iv_max_aid,		("bogus aid %u, max %u", aid, vap->iv_max_aid));	IEEE80211_LOCK(ic);	changed = (set != (isset(vap->iv_tim_bitmap, aid) != 0));	if (changed) {		if (set) {			setbit(vap->iv_tim_bitmap, aid);			vap->iv_ps_pending++;		} else {			clrbit(vap->iv_tim_bitmap, aid);			vap->iv_ps_pending--;		}		/* NB: we know vap is in RUN state so no need to check */		vap->iv_update_beacon(vap, IEEE80211_BEACON_TIM);	}	IEEE80211_UNLOCK(ic);	return changed;}

/* * Start a scan unless one is already going. */intieee80211_start_scan(struct ieee80211vap *vap, int flags,	u_int duration, u_int mindwell, u_int maxdwell,	u_int nssid, const struct ieee80211_scan_ssid ssids[]){	struct ieee80211com *ic = vap->iv_ic;	const struct ieee80211_scanner *scan;	int result;	scan = ieee80211_scanner_get(vap->iv_opmode);	if (scan == NULL) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: no scanner support for %s mode/n",		    __func__, ieee80211_opmode_name[vap->iv_opmode]);		/* XXX stat */		return 0;	}	IEEE80211_LOCK(ic);	result = start_scan_locked(scan, vap, flags, duration,	    mindwell, maxdwell, nssid, ssids);	IEEE80211_UNLOCK(ic);	return result;}

voidieee80211_scan_detach(struct ieee80211com *ic){	struct ieee80211_scan_state *ss = ic->ic_scan;	if (ss != NULL) {		IEEE80211_LOCK(ic);		SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT;		scan_signal(ss);		IEEE80211_UNLOCK(ic);		ieee80211_draintask(ic, &SCAN_PRIVATE(ss)->ss_scan_task);		callout_drain(&SCAN_PRIVATE(ss)->ss_scan_timer);		KASSERT((ic->ic_flags & IEEE80211_F_SCAN) == 0,		    ("scan still running"));		if (ss->ss_ops != NULL) {			ss->ss_ops->scan_detach(ss);			ss->ss_ops = NULL;		}		ic->ic_scan = NULL;		free(SCAN_PRIVATE(ss), M_80211_SCAN);	}	#if defined(__ANTARES__)	ieee80211_scan_sta_uninit();#endif}

static voidcancel_scan(struct ieee80211vap *vap, int any, const char *func){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	IEEE80211_LOCK(ic);	if ((ic->ic_flags & IEEE80211_F_SCAN) &&	    (any || ss->ss_vap == vap) &&	    (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: cancel %s scan/n", func,		    ss->ss_flags & IEEE80211_SCAN_ACTIVE ?			"active" : "passive");		/* clear bg scan NOPICK */		ss->ss_flags &= ~IEEE80211_SCAN_NOPICK;		/* mark cancel request and wake up the scan task */		scan_signal_locked(ss, ISCAN_CANCEL);	} else {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: called; F_SCAN=%d, vap=%s, CANCEL=%d/n",			func,			!! (ic->ic_flags & IEEE80211_F_SCAN),			(ss->ss_vap == vap ? "match" : "nomatch"),			!! (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL));	}	IEEE80211_UNLOCK(ic);}

/*  * Tear down vap state and reclaim the ifnet. * The driver is assumed to have prepared for * this; e.g. by turning off interrupts for the * underlying device. */voidieee80211_vap_detach(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ifnet *ifp = vap->iv_ifp;	IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s parent %s/n",	    __func__, ieee80211_opmode_name[vap->iv_opmode],	    ic->ic_ifp->if_xname);	/* NB: bpfdetach is called by ether_ifdetach and claims all taps */	ether_ifdetach(ifp);	ieee80211_stop(vap);	/*	 * Flush any deferred vap tasks.	 */	ieee80211_draintask(ic, &vap->iv_nstate_task);	ieee80211_draintask(ic, &vap->iv_swbmiss_task);	/* XXX band-aid until ifnet handles this for us */	taskqueue_drain(taskqueue_swi, &ifp->if_linktask);	IEEE80211_LOCK(ic);	KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running"));	TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next);	ieee80211_syncflag_locked(ic, IEEE80211_F_WME);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP);#endif	ieee80211_syncflag_locked(ic, IEEE80211_F_PCF);	ieee80211_syncflag_locked(ic, IEEE80211_F_BURST);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);	/* NB: this handles the bpfdetach done below */	ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF);	ieee80211_syncifflag_locked(ic, IFF_PROMISC);	ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);	IEEE80211_UNLOCK(ic);	ifmedia_removeall(&vap->iv_media);	ieee80211_radiotap_vdetach(vap);	ieee80211_regdomain_vdetach(vap);	ieee80211_scan_vdetach(vap);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_superg_vdetach(vap);#endif	ieee80211_ht_vdetach(vap);	/* NB: must be before ieee80211_node_vdetach */	ieee80211_proto_vdetach(vap);	ieee80211_crypto_vdetach(vap);	ieee80211_power_vdetach(vap);	ieee80211_node_vdetach(vap);	ieee80211_sysctl_vdetach(vap);	if_free(ifp);}

/* * Activate a vap.  State should have been prepared with a * call to ieee80211_vap_setup and by the driver.  On return * from this call the vap is ready for use. */intieee80211_vap_attach(struct ieee80211vap *vap,	ifm_change_cb_t media_change, ifm_stat_cb_t media_stat){	struct ifnet *ifp = vap->iv_ifp;	struct ieee80211com *ic = vap->iv_ic;	struct ifmediareq imr;	int maxrate;	IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE,	    "%s: %s parent %s flags 0x%x flags_ext 0x%x/n",	    __func__, ieee80211_opmode_name[vap->iv_opmode],	    ic->ic_ifp->if_xname, vap->iv_flags, vap->iv_flags_ext);	/*	 * Do late attach work that cannot happen until after	 * the driver has had a chance to override defaults.	 */	ieee80211_node_latevattach(vap);	ieee80211_power_latevattach(vap);	maxrate = ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps,	    vap->iv_opmode == IEEE80211_M_STA, media_change, media_stat);	ieee80211_media_status(ifp, &imr);	/* NB: strip explicit mode; we're actually in autoselect */	ifmedia_set(&vap->iv_media,	    imr.ifm_active &~ (IFM_MMASK | IFM_IEEE80211_TURBO));	if (maxrate)		ifp->if_baudrate = IF_Mbps(maxrate);	ether_ifattach(ifp, vap->iv_myaddr);	if (vap->iv_opmode == IEEE80211_M_MONITOR) {		/* NB: disallow transmit */		ifp->if_transmit = null_transmit;		ifp->if_output = null_output;	} else {		/* hook output method setup by ether_ifattach */		vap->iv_output = ifp->if_output;		ifp->if_output = ieee80211_output;	}	/* NB: if_mtu set by ether_ifattach to ETHERMTU */	IEEE80211_LOCK(ic);	TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next);	ieee80211_syncflag_locked(ic, IEEE80211_F_WME);#ifdef IEEE80211_SUPPORT_SUPERG	ieee80211_syncflag_locked(ic, IEEE80211_F_TURBOP);#endif	ieee80211_syncflag_locked(ic, IEEE80211_F_PCF);	ieee80211_syncflag_locked(ic, IEEE80211_F_BURST);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_HT);	ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);	ieee80211_syncifflag_locked(ic, IFF_PROMISC);	ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);	IEEE80211_UNLOCK(ic);	return 1;}

/* * Handle mindwell requirements completed; initiate a channel * change to the next channel asap. */static voidscan_mindwell(struct ieee80211_scan_state *ss){	struct ieee80211com *ic = ss->ss_ic;	IEEE80211_LOCK(ic);	scan_signal(ss);	IEEE80211_UNLOCK(ic);}

/** * This function provides control to simulate Radar event * * @param  *  SYSCTL_HANDLER_ARGS Standard arguments of the Linux sysctl handler  * * @returns  *  0 on success, or corresponding negative error code on failure */static intieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS){	struct ieee80211com *ic  = ctl->extra1;		IEEE80211_LOCK(ic);	ieee80211_dfs_notify_radar(ic, ic->ic_curchan);	IEEE80211_UNLOCK(ic); 	return 0;}

static voidscan_signal(struct ieee80211_scan_state *ss, int iflags){	struct ieee80211com *ic = ss->ss_ic;	IEEE80211_UNLOCK_ASSERT(ic);	IEEE80211_LOCK(ic);	scan_signal_locked(ss, iflags);	IEEE80211_UNLOCK(ic);}

/* * Public access to scan_next for drivers that manage * scanning themselves (e.g. for firmware-based devices). */voidieee80211_scan_next(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	/* wake up the scan task */	IEEE80211_LOCK(ic);	scan_signal(ss);	IEEE80211_UNLOCK(ic);}

/* * Public access to scan_next for drivers that are not able to scan single * channels (e.g. for firmware-based devices). */voidieee80211_scan_done(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss;	IEEE80211_LOCK(ic);	ss = ic->ic_scan;	ss->ss_next = ss->ss_last; /* all channels are complete */	scan_signal(ss);	IEEE80211_UNLOCK(ic);}

/* * Scan curchan.  If this is an active scan and the channel * is not marked passive then send probe request frame(s). * Arrange for the channel change after maxdwell ticks. */static voidscan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell){	struct ieee80211vap *vap  = ss->ss_vap;	IEEE80211_LOCK(vap->iv_ic);	if (ss->ss_flags & IEEE80211_SCAN_ACTIVE)		ieee80211_probe_curchan(vap, 0);	callout_reset(&SCAN_PRIVATE(ss)->ss_scan_timer,	    maxdwell, scan_signal, ss);	IEEE80211_UNLOCK(vap->iv_ic);}

/* * Check the scan cache for an ap/channel to use; if that * fails then kick off a new scan. */intieee80211_check_scan(struct ieee80211vap *vap, int flags,	u_int duration, u_int mindwell, u_int maxdwell,	u_int nssid, const struct ieee80211_scan_ssid ssids[]){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	const struct ieee80211_scanner *scan;	int result;	scan = ieee80211_scanner_get(vap->iv_opmode);	if (scan == NULL) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: no scanner support for %s mode/n",		    __func__, vap->iv_opmode);		/* XXX stat */		return 0;	}	/*	 * Check if there's a list of scan candidates already.	 * XXX want more than the ap we're currently associated with	 */	IEEE80211_LOCK(ic);	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,	    "%s: %s scan, %s%s%s%s%s/n"	    , __func__	    , flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"	    , flags & IEEE80211_SCAN_FLUSH ? "flush" : "append"	    , flags & IEEE80211_SCAN_NOPICK ? ", nopick" : ""	    , flags & IEEE80211_SCAN_NOJOIN ? ", nojoin" : ""	    , flags & IEEE80211_SCAN_PICK1ST ? ", pick1st" : ""	    , flags & IEEE80211_SCAN_ONCE ? ", once" : ""	);	if (ss->ss_ops != scan) {		/* XXX re-use cache contents? e.g. adhoc<->sta */		flags |= IEEE80211_SCAN_FLUSH;	}	/*	 * XXX TODO: separate things out a bit better.	 */	ieee80211_scan_update_locked(vap, scan);	result = ic->ic_scan_methods->sc_check_scan(scan, vap, flags, duration,	    mindwell, maxdwell, nssid, ssids);	IEEE80211_UNLOCK(ic);	return (result);}

voidieee80211_syncflag_ext(struct ieee80211vap *vap, int flag){	struct ieee80211com *ic = vap->iv_ic;	IEEE80211_LOCK(ic);	if (flag < 0) {		flag = -flag;		vap->iv_flags_ext &= ~flag;	} else		vap->iv_flags_ext |= flag;	ieee80211_syncflag_ext_locked(ic, flag);	IEEE80211_UNLOCK(ic);}

static intieee80211_sysctl_radar(SYSCTL_HANDLER_ARGS){	struct ieee80211com *ic = arg1;	int t = 0, error;	error = sysctl_handle_int(oidp, &t, 0, req);	if (error || !req->newptr)		return error;	IEEE80211_LOCK(ic);	ieee80211_dfs_notify_radar(ic, ic->ic_curchan);	IEEE80211_UNLOCK(ic);	return 0;}

static voidscan_start(void *arg, int pending){#define	ISCAN_REP	(ISCAN_MINDWELL | ISCAN_DISCARD)	struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg;	struct scan_state *ss_priv = SCAN_PRIVATE(ss);	struct ieee80211vap *vap = ss->ss_vap;	struct ieee80211com *ic = ss->ss_ic;	IEEE80211_LOCK(ic);	if (vap == NULL || (ic->ic_flags & IEEE80211_F_SCAN) == 0 ||	    (ss_priv->ss_iflags & ISCAN_ABORT)) {		/* Cancelled before we started */		scan_done(ss, 0);		return;	}	if (ss->ss_next == ss->ss_last) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,			"%s: no channels to scan/n", __func__);		scan_done(ss, 1);		return;	}	if (vap->iv_opmode == IEEE80211_M_STA &&	    vap->iv_state == IEEE80211_S_RUN) {		if ((vap->iv_bss->ni_flags & IEEE80211_NODE_PWR_MGT) == 0) {			/* Enable station power save mode */			vap->iv_sta_ps(vap, 1);			/* Wait until null data frame will be ACK'ed */			mtx_sleep(vap, IEEE80211_LOCK_OBJ(ic), PCATCH,			    "sta_ps", msecs_to_ticks(10));			if (ss_priv->ss_iflags & ISCAN_ABORT) {				scan_done(ss, 0);				return;			}		}	}	ss_priv->ss_scanend = ticks + ss_priv->ss_duration;	/* XXX scan state can change! Re-validate scan state! */	IEEE80211_UNLOCK(ic);	ic->ic_scan_start(ic);		/* notify driver */	scan_curchan_task(ss, 0);}

/* * Manually stop a scan that is currently running. * Provided for drivers that are not able to scan single channels * (e.g. for firmware-based devices). */voidieee80211_scan_done(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss;	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: called/n", __func__);	IEEE80211_LOCK(ic);	ss = ic->ic_scan;	ss->ss_next = ss->ss_last; /* all channels are complete */	ic->ic_scan_methods->sc_scan_done(vap);	IEEE80211_UNLOCK(ic);}

/* * Scan curchan.  If this is an active scan and the channel * is not marked passive then send probe request frame(s). * Arrange for the channel change after maxdwell ticks. */static voidscan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell){	struct ieee80211vap *vap  = ss->ss_vap;	struct ieee80211com *ic = ss->ss_ic;	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,	    "%s: calling; maxdwell=%lu/n",	    __func__,	    maxdwell);	IEEE80211_LOCK(ic);	if (ss->ss_flags & IEEE80211_SCAN_ACTIVE)		ieee80211_probe_curchan(vap, 0);	taskqueue_enqueue_timeout(ic->ic_tq,	    &SCAN_PRIVATE(ss)->ss_scan_curchan, maxdwell);	IEEE80211_UNLOCK(ic);}

/* * Start a scan unless one is already going. * * Called without the comlock held; grab the comlock as appropriate. */static intieee80211_swscan_start_scan(const struct ieee80211_scanner *scan,    struct ieee80211vap *vap, int flags,    u_int duration, u_int mindwell, u_int maxdwell,    u_int nssid, const struct ieee80211_scan_ssid ssids[]){	struct ieee80211com *ic = vap->iv_ic;	int result;	IEEE80211_UNLOCK_ASSERT(ic);	IEEE80211_LOCK(ic);	result = ieee80211_swscan_start_scan_locked(scan, vap, flags, duration,	    mindwell, maxdwell, nssid, ssids);	IEEE80211_UNLOCK(ic);	return result;}

voidieee80211_scan_vdetach(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss;	IEEE80211_LOCK(ic);	ss = ic->ic_scan;	ic->ic_scan_methods->sc_vdetach(vap);	if (ss != NULL && ss->ss_vap == vap) {		if (ss->ss_ops != NULL) {			ss->ss_ops->scan_detach(ss);			ss->ss_ops = NULL;		}		ss->ss_vap = NULL;	}	IEEE80211_UNLOCK(ic);}

voidieee80211_scan_vdetach(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss;	IEEE80211_LOCK(ic);	ss = ic->ic_scan;	if (ss != NULL && ss->ss_vap == vap) {		if (ic->ic_flags & IEEE80211_F_SCAN) {			SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT;			scan_signal(ss);		}		if (ss->ss_ops != NULL) {			ss->ss_ops->scan_detach(ss);			ss->ss_ops = NULL;		}		ss->ss_vap = NULL;	}	IEEE80211_UNLOCK(ic);}

/* * Cancel any scan currently going on. */voidieee80211_cancel_anyscan(struct ieee80211vap *vap){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	IEEE80211_LOCK(ic);	if ((ic->ic_flags & IEEE80211_F_SCAN) &&	    (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: cancel %s scan/n", __func__,		    ss->ss_flags & IEEE80211_SCAN_ACTIVE ?			"active" : "passive");		/* clear bg scan NOPICK and mark cancel request */		ss->ss_flags &= ~IEEE80211_SCAN_NOPICK;		SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_CANCEL;		/* wake up the scan task */		scan_signal(ss);	}	IEEE80211_UNLOCK(ic);}

/* * Handle being notified that we have data available for us in a TIM/ATIM. * * This may schedule a transition from _SLEEP -> _RUN if it's appropriate. * * In STA mode, we may have put to sleep during scan and need to be dragged * back out of powersave mode. */voidieee80211_sta_tim_notify(struct ieee80211vap *vap, int set){	struct ieee80211com *ic = vap->iv_ic;	/*	 * Schedule the driver state change.  It'll happen at some point soon.	 * Since the hardware shouldn't know that we're running just yet	 * (and thus tell the peer that we're awake before we actually wake	 * up said hardware), we leave the actual node state transition	 * up to the transition to RUN.	 *	 * XXX TODO: verify that the transition to RUN will wake up the	 * BSS node!	 */	IEEE80211_LOCK(vap->iv_ic);	if (set == 1 && vap->iv_state == IEEE80211_S_SLEEP) {		ieee80211_new_state_locked(vap, IEEE80211_S_RUN, 0);		IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER,		    "%s: TIM=%d; wakeup/n", __func__, set);	} else if ((set == 1) && (ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN)) {		/*		 * XXX only do this if we're in RUN state?		 */		IEEE80211_DPRINTF(vap, IEEE80211_MSG_POWER,		    "%s: wake up from bgscan vap sleep/n",		    __func__);		/*		 * We may be in BGSCAN mode - this means the VAP is is in STA		 * mode powersave.  If it is, we need to wake it up so we		 * can process outbound traffic.		 */		vap->iv_sta_ps(vap, 0);	}	IEEE80211_UNLOCK(vap->iv_ic);}

/* * Process a received frame.  The node associated with the sender * should be supplied.  If nothing was found in the node table then * the caller is assumed to supply a reference to ic_bss instead. * The RSSI and a timestamp are also supplied.  The RSSI data is used * during AP scanning to select a AP to associate with; it can have * any units so long as values have consistent units and higher values * mean ``better signal''.  The receive timestamp is currently not used * by the 802.11 layer. */intieee80211_input(ieee80211com_t *ic, mblk_t *mp, struct ieee80211_node *in,    int32_t rssi, uint32_t rstamp){	struct ieee80211_frame *wh;	struct ieee80211_key *key;	uint8_t *bssid;	int hdrspace;	int len;	uint16_t rxseq;	uint8_t dir;	uint8_t type;	uint8_t subtype;	uint8_t tid;	uint8_t qos;	if (mp->b_flag & M_AMPDU) {		/*		 * Fastpath for A-MPDU reorder q resubmission.  Frames		 * w/ M_AMPDU marked have already passed through here		 * but were received out of order and been held on the		 * reorder queue.  When resubmitted they are marked		 * with the M_AMPDU flag and we can bypass most of the		 * normal processing.		 */		IEEE80211_LOCK(ic);		wh = (struct ieee80211_frame *)mp->b_rptr;		type = IEEE80211_FC0_TYPE_DATA;		dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;		subtype = IEEE80211_FC0_SUBTYPE_QOS;		hdrspace = ieee80211_hdrspace(ic, wh);	/* optimize */		/* clear driver/net80211 flags before passing up */		mp->b_flag &= ~M_AMPDU;		goto resubmit_ampdu;	}	ASSERT(in != NULL);	in->in_inact = in->in_inact_reload;	type = (uint8_t)-1;		/* undefined */	len = MBLKL(mp);	if (len < sizeof (struct ieee80211_frame_min)) {		ieee80211_dbg(IEEE80211_MSG_ANY, "ieee80211_input: "		    "too short (1): len %u", len);		goto out;	}	/*	 * Bit of a cheat here, we use a pointer for a 3-address	 * frame format but don't reference fields past outside	 * ieee80211_frame_min w/o first validating the data is	 * present.	 */	wh = (struct ieee80211_frame *)mp->b_rptr;	if ((wh->i_fc[0] & IEEE80211_FC0_VERSION_MASK) !=	    IEEE80211_FC0_VERSION_0) {		ieee80211_dbg(IEEE80211_MSG_ANY, "ieee80211_input: "		    "discard pkt with wrong version %x", wh->i_fc[0]);		goto out;	}	dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;	type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;	subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;	IEEE80211_LOCK(ic);	if (!(ic->ic_flags & IEEE80211_F_SCAN)) {		switch (ic->ic_opmode) {		case IEEE80211_M_STA:			bssid = wh->i_addr2;			if (!IEEE80211_ADDR_EQ(bssid, in->in_bssid))				goto out_exit_mutex;			break;		case IEEE80211_M_IBSS:		case IEEE80211_M_AHDEMO:			if (dir != IEEE80211_FC1_DIR_NODS) {				bssid = wh->i_addr1;			} else if (type == IEEE80211_FC0_TYPE_CTL) {				bssid = wh->i_addr1;			} else {				if (len < sizeof (struct ieee80211_frame)) {					ieee80211_dbg(IEEE80211_MSG_ANY,					    "ieee80211_input: too short(2):"					    "len %u/n", len);					goto out_exit_mutex;				}				bssid = wh->i_addr3;			}			if (type != IEEE80211_FC0_TYPE_DATA)				break;			/*			 * Data frame, validate the bssid.//.........这里部分代码省略.........

/* * Restart a previous scan.  If the previous scan completed * then we start again using the existing channel list. */static intieee80211_swscan_bg_scan(const struct ieee80211_scanner *scan,    struct ieee80211vap *vap, int flags){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	/* XXX assert unlocked? */	// IEEE80211_UNLOCK_ASSERT(ic);	IEEE80211_LOCK(ic);	if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) {		u_int duration;		/*		 * Go off-channel for a fixed interval that is large		 * enough to catch most ap's but short enough that		 * we can return on-channel before our listen interval		 * expires.		 */		duration = IEEE80211_SCAN_OFFCHANNEL;		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: %s scan, ticks %u duration %u/n", __func__,		    ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive",		    ticks, duration);		ieee80211_scan_update_locked(vap, scan);		if (ss->ss_ops != NULL) {			ss->ss_vap = vap;			/*			 * A background scan does not select a new sta; it			 * just refreshes the scan cache.  Also, indicate			 * the scan logic should follow the beacon schedule:			 * we go off-channel and scan for a while, then			 * return to the bss channel to receive a beacon,			 * then go off-channel again.  All during this time			 * we notify the ap we're in power save mode.  When			 * the scan is complete we leave power save mode.			 * If any beacon indicates there are frames pending			 * for us then we drop out of power save mode			 * (and background scan) automatically by way of the			 * usual sta power save logic.			 */			ss->ss_flags |= IEEE80211_SCAN_NOPICK				     |  IEEE80211_SCAN_BGSCAN				     |  flags				     ;			/* if previous scan completed, restart */			if (ss->ss_next >= ss->ss_last) {				if (ss->ss_flags & IEEE80211_SCAN_ACTIVE)					vap->iv_stats.is_scan_active++;				else					vap->iv_stats.is_scan_passive++;				/*				 * NB: beware of the scan cache being flushed;				 *     if the channel list is empty use the				 *     scan_start method to populate it.				 */				ss->ss_next = 0;				if (ss->ss_last != 0)					ss->ss_ops->scan_restart(ss, vap);				else {					ss->ss_ops->scan_start(ss, vap);#ifdef IEEE80211_DEBUG					if (ieee80211_msg_scan(vap))						ieee80211_scan_dump(ss);#endif /* IEEE80211_DEBUG */				}			}			ieee80211_swscan_set_scan_duration(vap, duration);			ss->ss_maxdwell = duration;			ic->ic_flags |= IEEE80211_F_SCAN;			ic->ic_flags_ext |= IEEE80211_FEXT_BGSCAN;			ieee80211_runtask(ic,			    &SCAN_PRIVATE(ss)->ss_scan_start);		} else {			/* XXX msg+stat */		}	} else {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: %s scan already in progress/n", __func__,		    ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive");	}	IEEE80211_UNLOCK(ic);	/* NB: racey, does it matter? */	return (ic->ic_flags & IEEE80211_F_SCAN);}

static voidscan_task(void *arg, int pending){#define	ISCAN_REP	(ISCAN_MINDWELL | ISCAN_DISCARD)	struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg;	struct ieee80211vap *vap = ss->ss_vap;	struct ieee80211com *ic = ss->ss_ic;	struct ieee80211_channel *chan;	unsigned long maxdwell, scanend;	int scandone = 0;	IEEE80211_LOCK(ic);	if (vap == NULL || (ic->ic_flags & IEEE80211_F_SCAN) == 0 ||	    (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)) {		/* Cancelled before we started */		goto done;	}	if (ss->ss_next == ss->ss_last) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,			"%s: no channels to scan/n", __func__);		goto done;	}	if (vap->iv_opmode == IEEE80211_M_STA &&	    vap->iv_state == IEEE80211_S_RUN) {		if ((vap->iv_bss->ni_flags & IEEE80211_NODE_PWR_MGT) == 0) {			/* Enable station power save mode */			ieee80211_sta_pwrsave(vap, 1);			/*			 * Use an 1ms delay so the null data frame has a chance			 * to go out.			 * XXX Should use M_TXCB mechanism to eliminate this.			 */			cv_timedwait(&SCAN_PRIVATE(ss)->ss_scan_cv,			    IEEE80211_LOCK_OBJ(ic), hz / 1000);			if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)				goto done;		}	}	scanend = ticks + SCAN_PRIVATE(ss)->ss_duration;	IEEE80211_UNLOCK(ic);	ic->ic_scan_start(ic);		/* notify driver */	IEEE80211_LOCK(ic);	for (;;) {		scandone = (ss->ss_next >= ss->ss_last) ||		    (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) != 0;		if (scandone || (ss->ss_flags & IEEE80211_SCAN_GOTPICK) ||		    (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT) ||		     time_after(ticks + ss->ss_mindwell, scanend))			break;		chan = ss->ss_chans[ss->ss_next++];		/*		 * Watch for truncation due to the scan end time.		 */		if (time_after(ticks + ss->ss_maxdwell, scanend))			maxdwell = scanend - ticks;		else			maxdwell = ss->ss_maxdwell;		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: chan %3d%c -> %3d%c [%s, dwell min %lums max %lums]/n",		    __func__,		    ieee80211_chan2ieee(ic, ic->ic_curchan),		        channel_type(ic->ic_curchan),		    ieee80211_chan2ieee(ic, chan), channel_type(chan),		    (ss->ss_flags & IEEE80211_SCAN_ACTIVE) &&			(chan->ic_flags & IEEE80211_CHAN_PASSIVE) == 0 ?			"active" : "passive",		    ticks_to_msecs(ss->ss_mindwell), ticks_to_msecs(maxdwell));		/*		 * Potentially change channel and phy mode.		 */		ic->ic_curchan = chan;		ic->ic_rt = ieee80211_get_ratetable(chan);		IEEE80211_UNLOCK(ic);		/*		 * Perform the channel change and scan unlocked so the driver		 * may sleep. Once set_channel returns the hardware has		 * completed the channel change.		 */		ic->ic_set_channel(ic);		ieee80211_radiotap_chan_change(ic);		/*		 * Scan curchan.  Drivers for "intelligent hardware"		 * override ic_scan_curchan to tell the device to do		 * the work.  Otherwise we manage the work outselves;		 * sending a probe request (as needed), and arming the		 * timeout to switch channels after maxdwell ticks.		 *		 * scan_curchan should only pause for the time required to		 * prepare/initiate the hardware for the scan (if at all), the		 * below condvar is used to sleep for the channels dwell time		 * and allows it to be signalled for abort.//.........这里部分代码省略.........

/* * Check the scan cache for an ap/channel to use; if that * fails then kick off a new scan. */intieee80211_check_scan(struct ieee80211vap *vap, int flags,	u_int duration, u_int mindwell, u_int maxdwell,	u_int nssid, const struct ieee80211_scan_ssid ssids[]){	struct ieee80211com *ic = vap->iv_ic;	struct ieee80211_scan_state *ss = ic->ic_scan;	const struct ieee80211_scanner *scan;	int result;	scan = ieee80211_scanner_get(vap->iv_opmode);	if (scan == NULL) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: no scanner support for %s mode/n",		    __func__, vap->iv_opmode);		/* XXX stat */		return 0;	}	/*	 * Check if there's a list of scan candidates already.	 * XXX want more than the ap we're currently associated with	 */	IEEE80211_LOCK(ic);	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,	    "%s: %s scan, %s%s%s%s%s/n"	    , __func__	    , flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive"	    , flags & IEEE80211_SCAN_FLUSH ? "flush" : "append"	    , flags & IEEE80211_SCAN_NOPICK ? ", nopick" : ""	    , flags & IEEE80211_SCAN_NOJOIN ? ", nojoin" : ""	    , flags & IEEE80211_SCAN_PICK1ST ? ", pick1st" : ""	    , flags & IEEE80211_SCAN_ONCE ? ", once" : ""	);	if (ss->ss_ops != scan) {		/* XXX re-use cache contents? e.g. adhoc<->sta */		flags |= IEEE80211_SCAN_FLUSH;	}	scan_update_locked(vap, scan);	if (ss->ss_ops != NULL) {		/* XXX verify ss_ops matches vap->iv_opmode */		if ((flags & IEEE80211_SCAN_NOSSID) == 0) {			/*			 * Update the ssid list and mark flags so if			 * we call start_scan it doesn't duplicate work.			 */			copy_ssid(vap, ss, nssid, ssids);			flags |= IEEE80211_SCAN_NOSSID;		}		if ((ic->ic_flags & IEEE80211_F_SCAN) == 0 &&		    (flags & IEEE80211_SCAN_FLUSH) == 0 &&		    time_before(ticks, ic->ic_lastscan + vap->iv_scanvalid)) {			/*			 * We're not currently scanning and the cache is			 * deemed hot enough to consult.  Lock out others			 * by marking IEEE80211_F_SCAN while we decide if			 * something is already in the scan cache we can			 * use.  Also discard any frames that might come			 * in while temporarily marked as scanning.			 */			SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_DISCARD;			ic->ic_flags |= IEEE80211_F_SCAN;			/* NB: need to use supplied flags in check */			ss->ss_flags = flags & 0xff;			result = ss->ss_ops->scan_end(ss, vap);			ic->ic_flags &= ~IEEE80211_F_SCAN;			SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_DISCARD;			if (result) {				ieee80211_notify_scan_done(vap);				IEEE80211_UNLOCK(ic);				return 1;			}		}	}	result = start_scan_locked(scan, vap, flags, duration,	    mindwell, maxdwell, nssid, ssids);	IEEE80211_UNLOCK(ic);	return result;}

static voidscan_curchan_task(void *arg, int pending){	struct ieee80211_scan_state *ss = arg;	struct scan_state *ss_priv = SCAN_PRIVATE(ss);	struct ieee80211com *ic = ss->ss_ic;	struct ieee80211_channel *chan;	unsigned long maxdwell;	int scandone;	IEEE80211_LOCK(ic);end:	scandone = (ss->ss_next >= ss->ss_last) ||	    (ss_priv->ss_iflags & ISCAN_CANCEL) != 0;	IEEE80211_DPRINTF(ss->ss_vap, IEEE80211_MSG_SCAN,	    "%s: loop start; scandone=%d/n",	    __func__,	    scandone);	if (scandone || (ss->ss_flags & IEEE80211_SCAN_GOTPICK) ||	    (ss_priv->ss_iflags & ISCAN_ABORT) ||	     ieee80211_time_after(ticks + ss->ss_mindwell, ss_priv->ss_scanend)) {		ss_priv->ss_iflags &= ~ISCAN_RUNNING;		scan_end(ss, scandone);		return;	} else		ss_priv->ss_iflags |= ISCAN_RUNNING;	chan = ss->ss_chans[ss->ss_next++];	/*	 * Watch for truncation due to the scan end time.	 */	if (ieee80211_time_after(ticks + ss->ss_maxdwell, ss_priv->ss_scanend))		maxdwell = ss_priv->ss_scanend - ticks;	else		maxdwell = ss->ss_maxdwell;	IEEE80211_DPRINTF(ss->ss_vap, IEEE80211_MSG_SCAN,	    "%s: chan %3d%c -> %3d%c [%s, dwell min %lums max %lums]/n",	    __func__,	    ieee80211_chan2ieee(ic, ic->ic_curchan),	    ieee80211_channel_type_char(ic->ic_curchan),	    ieee80211_chan2ieee(ic, chan),	    ieee80211_channel_type_char(chan),	    (ss->ss_flags & IEEE80211_SCAN_ACTIVE) &&		(chan->ic_flags & IEEE80211_CHAN_PASSIVE) == 0 ?		"active" : "passive",	    ticks_to_msecs(ss->ss_mindwell), ticks_to_msecs(maxdwell));	/*	 * Potentially change channel and phy mode.	 */	ic->ic_curchan = chan;	ic->ic_rt = ieee80211_get_ratetable(chan);	IEEE80211_UNLOCK(ic);	/*	 * Perform the channel change and scan unlocked so the driver	 * may sleep. Once set_channel returns the hardware has	 * completed the channel change.	 */	ic->ic_set_channel(ic);	ieee80211_radiotap_chan_change(ic);	/*	 * Scan curchan.  Drivers for "intelligent hardware"	 * override ic_scan_curchan to tell the device to do	 * the work.  Otherwise we manage the work ourselves;	 * sending a probe request (as needed), and arming the	 * timeout to switch channels after maxdwell ticks.	 *	 * scan_curchan should only pause for the time required to	 * prepare/initiate the hardware for the scan (if at all).	 */	ic->ic_scan_curchan(ss, maxdwell);	IEEE80211_LOCK(ic);	/* XXX scan state can change! Re-validate scan state! */	ss_priv->ss_chanmindwell = ticks + ss->ss_mindwell;	/* clear mindwell lock and initial channel change flush */	ss_priv->ss_iflags &= ~ISCAN_REP;	if (ss_priv->ss_iflags & (ISCAN_CANCEL|ISCAN_ABORT)) {		taskqueue_cancel_timeout(ic->ic_tq, &ss_priv->ss_scan_curchan,		    NULL);		goto end;	}	IEEE80211_DPRINTF(ss->ss_vap, IEEE80211_MSG_SCAN, "%s: waiting/n",	    __func__);	IEEE80211_UNLOCK(ic);}

static voidscan_end(struct ieee80211_scan_state *ss, int scandone){	struct scan_state *ss_priv = SCAN_PRIVATE(ss);	struct ieee80211vap *vap = ss->ss_vap;	struct ieee80211com *ic = ss->ss_ic;	IEEE80211_LOCK_ASSERT(ic);	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN, "%s: out/n", __func__);	if (ss_priv->ss_iflags & ISCAN_ABORT) {		scan_done(ss, scandone);		return;	}	IEEE80211_UNLOCK(ic);	ic->ic_scan_end(ic);		/* notify driver */	IEEE80211_LOCK(ic);	/* XXX scan state can change! Re-validate scan state! */	/*	 * Since a cancellation may have occurred during one of the	 * driver calls (whilst unlocked), update scandone.	 */	if (scandone == 0 && (ss_priv->ss_iflags & ISCAN_CANCEL) != 0) {		/* XXX printf? */		if_printf(vap->iv_ifp,		    "%s: OOPS! scan cancelled during driver call (1)!/n",		    __func__);		scandone = 1;	}	/*	 * Record scan complete time.  Note that we also do	 * this when canceled so any background scan will	 * not be restarted for a while.	 */	if (scandone)		ic->ic_lastscan = ticks;	/* return to the bss channel */	if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&	    ic->ic_curchan != ic->ic_bsschan) {		ieee80211_setupcurchan(ic, ic->ic_bsschan);		IEEE80211_UNLOCK(ic);		ic->ic_set_channel(ic);		ieee80211_radiotap_chan_change(ic);		IEEE80211_LOCK(ic);	}	/* clear internal flags and any indication of a pick */	ss_priv->ss_iflags &= ~ISCAN_REP;	ss->ss_flags &= ~IEEE80211_SCAN_GOTPICK;	/*	 * If not canceled and scan completed, do post-processing.	 * If the callback function returns 0, then it wants to	 * continue/restart scanning.  Unfortunately we needed to	 * notify the driver to end the scan above to avoid having	 * rx frames alter the scan candidate list.	 */	if ((ss_priv->ss_iflags & ISCAN_CANCEL) == 0 &&	    !ss->ss_ops->scan_end(ss, vap) &&	    (ss->ss_flags & IEEE80211_SCAN_ONCE) == 0 &&	    ieee80211_time_before(ticks + ss->ss_mindwell, ss_priv->ss_scanend)) {		IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,		    "%s: done, restart "		    "[ticks %u, dwell min %lu scanend %lu]/n",		    __func__,		    ticks, ss->ss_mindwell, ss_priv->ss_scanend);		ss->ss_next = 0;	/* reset to beginning */		if (ss->ss_flags & IEEE80211_SCAN_ACTIVE)			vap->iv_stats.is_scan_active++;		else			vap->iv_stats.is_scan_passive++;		ss->ss_ops->scan_restart(ss, vap);	/* XXX? */		ieee80211_runtask(ic, &ss_priv->ss_scan_start);		IEEE80211_UNLOCK(ic);		return;	}	/* past here, scandone is ``true'' if not in bg mode */	if ((ss->ss_flags & IEEE80211_SCAN_BGSCAN) == 0)		scandone = 1;	IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,	    "%s: %s, [ticks %u, dwell min %lu scanend %lu]/n",	    __func__, scandone ? "done" : "stopped",	    ticks, ss->ss_mindwell, ss_priv->ss_scanend);	/*	 * Since a cancellation may have occurred during one of the	 * driver calls (whilst unlocked), update scandone.	 */	if (scandone == 0 && (ss_priv->ss_iflags & ISCAN_CANCEL) != 0) {		/* XXX printf? */		if_printf(vap->iv_ifp,		    "%s: OOPS! scan cancelled during driver call (2)!/n",		    __func__);		scandone = 1;//.........这里部分代码省略.........

/* * Update the dynamic parts of a beacon frame based on the current state. */intieee80211_beacon_update(struct ieee80211_node *ni,	struct ieee80211_beacon_offsets *bo, struct sk_buff *skb, int mcast){	struct ieee80211vap *vap = ni->ni_vap;	struct ieee80211com *ic = ni->ni_ic;	int len_changed = 0;	u_int16_t capinfo;	IEEE80211_LOCK(ic);	if ((ic->ic_flags & IEEE80211_F_DOTH) &&	    (vap->iv_flags & IEEE80211_F_CHANSWITCH) &&	    (vap->iv_chanchange_count == ic->ic_chanchange_tbtt)) {		u_int8_t *frm;		struct ieee80211_channel *c;		vap->iv_chanchange_count = 0;		IEEE80211_DPRINTF(vap, IEEE80211_MSG_DOTH,			"%s: reinit beacon/n", __func__);		/* 		 * NB: ic_bsschan is in the DSPARMS beacon IE, so must set this		 *     prior to the beacon re-init, below.		 */		c = ieee80211_doth_findchan(vap, ic->ic_chanchange_chan);		if (c == NULL) {			IEEE80211_DPRINTF(vap, IEEE80211_MSG_DOTH,				"%s: find channel failure/n", __func__);			IEEE80211_UNLOCK(ic);			return 0;		}		ic->ic_bsschan = c;		skb_pull(skb, sizeof(struct ieee80211_frame));		skb_trim(skb, 0);		frm = skb->data;		skb_put(skb, ieee80211_beacon_init(ni, bo, frm) - frm); 		skb_push(skb, sizeof(struct ieee80211_frame));		vap->iv_flags &= ~IEEE80211_F_CHANSWITCH;		ic->ic_flags &= ~IEEE80211_F_CHANSWITCH;		/* NB: only for the first VAP to get here */		if (ic->ic_curchan != c) {			ic->ic_curchan = c;			ic->ic_set_channel(ic);		}		len_changed = 1;	}	/* XXX faster to recalculate entirely or just changes? */	if (vap->iv_opmode == IEEE80211_M_IBSS)		capinfo = IEEE80211_CAPINFO_IBSS;	else		capinfo = IEEE80211_CAPINFO_ESS;	if (vap->iv_flags & IEEE80211_F_PRIVACY)		capinfo |= IEEE80211_CAPINFO_PRIVACY;	if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&	    IEEE80211_IS_CHAN_2GHZ(ic->ic_bsschan))		capinfo |= IEEE80211_CAPINFO_SHORT_PREAMBLE;	if (ic->ic_flags & IEEE80211_F_SHSLOT)		capinfo |= IEEE80211_CAPINFO_SHORT_SLOTTIME;	if (ic->ic_flags & IEEE80211_F_DOTH)		capinfo |= IEEE80211_CAPINFO_SPECTRUM_MGMT;	*bo->bo_caps = htole16(capinfo);	if (vap->iv_flags & IEEE80211_F_WME) {		struct ieee80211_wme_state *wme = &ic->ic_wme;		/*		 * Check for aggressive mode change.  When there is		 * significant high priority traffic in the BSS		 * throttle back BE traffic by using conservative		 * parameters.  Otherwise BE uses aggressive params		 * to optimize performance of legacy/non-QoS traffic.		 */		if (wme->wme_flags & WME_F_AGGRMODE) {			if (wme->wme_hipri_traffic >			    wme->wme_hipri_switch_thresh) {				IEEE80211_NOTE(vap, IEEE80211_MSG_WME, ni,					"%s: traffic %u, disable aggressive mode",					__func__, wme->wme_hipri_traffic);				wme->wme_flags &= ~WME_F_AGGRMODE;				ieee80211_wme_updateparams_locked(vap);				wme->wme_hipri_traffic =					wme->wme_hipri_switch_hysteresis;			} else				wme->wme_hipri_traffic = 0;		} else {			if (wme->wme_hipri_traffic <=			    wme->wme_hipri_switch_thresh) {				IEEE80211_NOTE(vap, IEEE80211_MSG_WME, ni,					"%s: traffic %u, enable aggressive mode",//.........这里部分代码省略.........