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

int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info,			  u32 *mode, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev;	struct vif_params vifparams;	enum nl80211_iftype type;	rdev = wiphy_to_rdev(wdev->wiphy);	switch (*mode) {	case IW_MODE_INFRA:		type = NL80211_IFTYPE_STATION;		break;	case IW_MODE_ADHOC:		type = NL80211_IFTYPE_ADHOC;		break;	case IW_MODE_REPEAT:		type = NL80211_IFTYPE_WDS;		break;	case IW_MODE_MONITOR:		type = NL80211_IFTYPE_MONITOR;		break;	default:		return -EINVAL;	}	if (type == wdev->iftype)		return 0;	memset(&vifparams, 0, sizeof(vifparams));	return cfg80211_change_iface(rdev, dev, type, NULL, &vifparams);}

void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,			  struct ieee80211_channel *channel, gfp_t gfp){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct cfg80211_event *ev;	unsigned long flags;	trace_cfg80211_ibss_joined(dev, bssid, channel);	if (WARN_ON(!channel))		return;	ev = kzalloc(sizeof(*ev), gfp);	if (!ev)		return;	ev->type = EVENT_IBSS_JOINED;	memcpy(ev->ij.bssid, bssid, ETH_ALEN);	ev->ij.channel = channel;	spin_lock_irqsave(&wdev->event_lock, flags);	list_add_tail(&ev->list, &wdev->event_list);	spin_unlock_irqrestore(&wdev->event_lock, flags);	queue_work(cfg80211_wq, &rdev->event_work);}

static void __cfg80211_clear_ibss(struct net_device *dev, bool nowext){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	int i;	ASSERT_WDEV_LOCK(wdev);	kzfree(wdev->connect_keys);	wdev->connect_keys = NULL;	rdev_set_qos_map(rdev, dev, NULL);	/*	 * Delete all the keys ... pairwise keys can't really	 * exist any more anyway, but default keys might.	 */	if (rdev->ops->del_key)		for (i = 0; i < 6; i++)			rdev_del_key(rdev, dev, i, false, NULL);	if (wdev->current_bss) {		cfg80211_unhold_bss(wdev->current_bss);		cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);	}	wdev->current_bss = NULL;	wdev->ssid_len = 0;	memset(&wdev->chandef, 0, sizeof(wdev->chandef));#ifdef CONFIG_CFG80211_WEXT	if (!nowext)		wdev->wext.ibss.ssid_len = 0;#endif	cfg80211_sched_dfs_chan_update(rdev);}

void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,				  enum nl80211_key_type key_type, int key_id,				  const u8 *tsc, gfp_t gfp){	struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);#ifdef CONFIG_CFG80211_WEXT	union iwreq_data wrqu;	char *buf = kmalloc(128, gfp);	if (buf) {		sprintf(buf, "MLME-MICHAELMICFAILURE.indication("			"keyid=%d %scast addr=%pM)", key_id,			key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",			addr);		memset(&wrqu, 0, sizeof(wrqu));		wrqu.data.length = strlen(buf);		wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);		kfree(buf);	}#endif	trace_cfg80211_michael_mic_failure(dev, addr, key_type, key_id, tsc);	nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);}

static int cfg80211_wext_giwtxpower(struct net_device *dev,				    struct iw_request_info *info,				    union iwreq_data *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	int err, val;	if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)		return -EINVAL;	if (data->txpower.flags & IW_TXPOW_RANGE)		return -EINVAL;	if (!rdev->ops->get_tx_power)		return -EOPNOTSUPP;	err = rdev_get_tx_power(rdev, wdev, &val);	if (err)		return err;	/* well... oh well */	data->txpower.fixed = 1;	data->txpower.disabled = rfkill_blocked(rdev->rfkill);	data->txpower.value = val;	data->txpower.flags = IW_TXPOW_DBM;	return 0;}

int cfg80211_wext_siwmlme(struct net_device *dev,			  struct iw_request_info *info,			  struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct iw_mlme *mlme = (struct iw_mlme *)extra;	struct cfg80211_registered_device *rdev;	int err;	if (!wdev)		return -EOPNOTSUPP;	rdev = wiphy_to_rdev(wdev->wiphy);	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	if (mlme->addr.sa_family != ARPHRD_ETHER)		return -EINVAL;	wdev_lock(wdev);	switch (mlme->cmd) {	case IW_MLME_DEAUTH:	case IW_MLME_DISASSOC:		err = cfg80211_disconnect(rdev, dev, mlme->reason_code, true);		break;	default:		err = -EOPNOTSUPP;		break;	}	wdev_unlock(wdev);	return err;}

static int cfg80211_wds_wext_siwap(struct net_device *dev,				   struct iw_request_info *info,				   struct sockaddr *addr, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	int err;	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_WDS))		return -EINVAL;	if (addr->sa_family != ARPHRD_ETHER)		return -EINVAL;	if (netif_running(dev))		return -EBUSY;	if (!rdev->ops->set_wds_peer)		return -EOPNOTSUPP;	err = rdev_set_wds_peer(rdev, dev, (u8 *)&addr->sa_data);	if (err)		return err;	memcpy(&wdev->wext.bssid, (u8 *) &addr->sa_data, ETH_ALEN);	return 0;}

static int cfg80211_wext_giwfreq(struct net_device *dev,				 struct iw_request_info *info,				 struct iw_freq *freq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct cfg80211_chan_def chandef;	int ret;	switch (wdev->iftype) {	case NL80211_IFTYPE_STATION:		return cfg80211_mgd_wext_giwfreq(dev, info, freq, extra);	case NL80211_IFTYPE_ADHOC:		return cfg80211_ibss_wext_giwfreq(dev, info, freq, extra);	case NL80211_IFTYPE_MONITOR:		if (!rdev->ops->get_channel)			return -EINVAL;		ret = rdev_get_channel(rdev, wdev, &chandef);		if (ret)			return ret;		freq->m = chandef.chan->center_freq;		freq->e = 6;		return 0;	default:		return -EINVAL;	}}

void cfg80211_rx_assoc_resp(struct net_device *dev, struct cfg80211_bss *bss,			    const u8 *buf, size_t len, int uapsd_queues){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct wiphy *wiphy = wdev->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;	u8 *ie = mgmt->u.assoc_resp.variable;	int ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);	u16 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);	trace_cfg80211_send_rx_assoc(dev, bss);	/*	 * This is a bit of a hack, we don't notify userspace of	 * a (re-)association reply if we tried to send a reassoc	 * and got a reject -- we only try again with an assoc	 * frame instead of reassoc.	 */	if (cfg80211_sme_rx_assoc_resp(wdev, status_code)) {		cfg80211_unhold_bss(bss_from_pub(bss));		cfg80211_put_bss(wiphy, bss);		return;	}	nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL, uapsd_queues);	/* update current_bss etc., consumes the bss reference */	__cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,				  status_code,				  status_code == WLAN_STATUS_SUCCESS, bss);}

static int cfg80211_wext_siwencode(struct net_device *dev,				   struct iw_request_info *info,				   struct iw_point *erq, char *keybuf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	int idx, err;	bool remove = false;	struct key_params params;	if (wdev->iftype != NL80211_IFTYPE_STATION &&	    wdev->iftype != NL80211_IFTYPE_ADHOC)		return -EOPNOTSUPP;	/* no use -- only MFP (set_default_mgmt_key) is optional */	if (!rdev->ops->del_key ||	    !rdev->ops->add_key ||	    !rdev->ops->set_default_key)		return -EOPNOTSUPP;	idx = erq->flags & IW_ENCODE_INDEX;	if (idx == 0) {		idx = wdev->wext.default_key;		if (idx < 0)			idx = 0;	} else if (idx < 1 || idx > 4)		return -EINVAL;	else		idx--;	if (erq->flags & IW_ENCODE_DISABLED)		remove = true;	else if (erq->length == 0) {		/* No key data - just set the default TX key index */		err = 0;		wdev_lock(wdev);		if (wdev->current_bss)			err = rdev_set_default_key(rdev, dev, idx, true,						   true);		if (!err)			wdev->wext.default_key = idx;		wdev_unlock(wdev);		return err;	}	memset(&params, 0, sizeof(params));	params.key = keybuf;	params.key_len = erq->length;	if (erq->length == 5)		params.cipher = WLAN_CIPHER_SUITE_WEP40;	else if (erq->length == 13)		params.cipher = WLAN_CIPHER_SUITE_WEP104;	else if (!remove)		return -EINVAL;	return cfg80211_set_encryption(rdev, dev, false, NULL, remove,				       wdev->wext.default_key == -1,				       idx, &params);}

static void cfg80211_process_auth(struct wireless_dev *wdev,				  const u8 *buf, size_t len){	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	nl80211_send_rx_auth(rdev, wdev->netdev, buf, len, GFP_KERNEL);	cfg80211_sme_rx_auth(wdev, buf, len);}

int cfg80211_ibss_wext_siwfreq(struct net_device *dev,			       struct iw_request_info *info,			       struct iw_freq *wextfreq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct ieee80211_channel *chan = NULL;	int err, freq;	/* call only for ibss! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))		return -EINVAL;	if (!rdev->ops->join_ibss)		return -EOPNOTSUPP;	freq = cfg80211_wext_freq(wextfreq);	if (freq < 0)		return freq;	if (freq) {		chan = ieee80211_get_channel(wdev->wiphy, freq);		if (!chan)			return -EINVAL;		if (chan->flags & IEEE80211_CHAN_NO_IR ||		    chan->flags & IEEE80211_CHAN_DISABLED)			return -EINVAL;	}	if (wdev->wext.ibss.chandef.chan == chan)		return 0;	wdev_lock(wdev);	err = 0;	if (wdev->ssid_len)		err = __cfg80211_leave_ibss(rdev, dev, true);	wdev_unlock(wdev);	if (err)		return err;	if (chan) {		cfg80211_chandef_create(&wdev->wext.ibss.chandef, chan,					NL80211_CHAN_NO_HT);		wdev->wext.ibss.channel_fixed = true;	} else {		/* cfg80211_ibss_wext_join will pick one if needed */		wdev->wext.ibss.channel_fixed = false;	}	wdev_lock(wdev);	err = cfg80211_ibss_wext_join(rdev, wdev);	wdev_unlock(wdev);	return err;}

int cfg80211_ibss_wext_siwap(struct net_device *dev,			     struct iw_request_info *info,			     struct sockaddr *ap_addr, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u8 *bssid = ap_addr->sa_data;	int err;	/* call only for ibss! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))		return -EINVAL;	if (!rdev->ops->join_ibss)		return -EOPNOTSUPP;	if (ap_addr->sa_family != ARPHRD_ETHER)		return -EINVAL;	/* automatic mode */	if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))		bssid = NULL;	if (bssid && !is_valid_ether_addr(bssid))		return -EINVAL;	/* both automatic */	if (!bssid && !wdev->wext.ibss.bssid)		return 0;	/* fixed already - and no change */	if (wdev->wext.ibss.bssid && bssid &&	    ether_addr_equal(bssid, wdev->wext.ibss.bssid))		return 0;	wdev_lock(wdev);	err = 0;	if (wdev->ssid_len)		err = __cfg80211_leave_ibss(rdev, dev, true);	wdev_unlock(wdev);	if (err)		return err;	if (bssid) {		memcpy(wdev->wext.bssid, bssid, ETH_ALEN);		wdev->wext.ibss.bssid = wdev->wext.bssid;	} else		wdev->wext.ibss.bssid = NULL;	wdev_lock(wdev);	err = cfg80211_ibss_wext_join(rdev, wdev);	wdev_unlock(wdev);	return err;}

int cfg80211_mgd_wext_siwessid(struct net_device *dev,			       struct iw_request_info *info,			       struct iw_point *data, char *ssid){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	size_t len = data->length;	int err;	/* call only for station! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))		return -EINVAL;	if (!data->flags)		len = 0;	/* iwconfig uses nul termination in SSID.. */	if (len > 0 && ssid[len - 1] == '/0')		len--;	wdev_lock(wdev);	err = 0;	if (wdev->conn) {		bool event = true;		if (wdev->wext.connect.ssid && len &&		    len == wdev->wext.connect.ssid_len &&		    memcmp(wdev->wext.connect.ssid, ssid, len) == 0)			goto out;		/* if SSID set now, we'll try to connect, avoid event */		if (len)			event = false;		err = cfg80211_disconnect(rdev, dev,					  WLAN_REASON_DEAUTH_LEAVING, event);		if (err)			goto out;	}	wdev->wext.prev_bssid_valid = false;	wdev->wext.connect.ssid = wdev->wext.ssid;	memcpy(wdev->wext.ssid, ssid, len);	wdev->wext.connect.ssid_len = len;	wdev->wext.connect.crypto.control_port = false;	wdev->wext.connect.crypto.control_port_ethertype =					cpu_to_be16(ETH_P_PAE);	err = cfg80211_mgd_wext_connect(rdev, wdev); out:	wdev_unlock(wdev);	return err;}

void cfg80211_auth_timeout(struct net_device *dev, const u8 *addr){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct wiphy *wiphy = wdev->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);	trace_cfg80211_send_auth_timeout(dev, addr);	nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);	cfg80211_sme_auth_timeout(wdev);}

static int cfg80211_wext_siwtxpower(struct net_device *dev,				    struct iw_request_info *info,				    union iwreq_data *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	enum nl80211_tx_power_setting type;	int dbm = 0;	if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)		return -EINVAL;	if (data->txpower.flags & IW_TXPOW_RANGE)		return -EINVAL;	if (!rdev->ops->set_tx_power)		return -EOPNOTSUPP;	/* only change when not disabling */	if (!data->txpower.disabled) {		rfkill_set_sw_state(rdev->rfkill, false);		if (data->txpower.fixed) {			/*			 * wext doesn't support negative values, see			 * below where it's for automatic			 */			if (data->txpower.value < 0)				return -EINVAL;			dbm = data->txpower.value;			type = NL80211_TX_POWER_FIXED;			/* TODO: do regulatory check! */		} else {			/*			 * Automatic power level setting, max being the value			 * passed in from userland.			 */			if (data->txpower.value < 0) {				type = NL80211_TX_POWER_AUTOMATIC;			} else {				dbm = data->txpower.value;				type = NL80211_TX_POWER_LIMITED;			}		}	} else {		rfkill_set_sw_state(rdev->rfkill, true);		schedule_work(&rdev->rfkill_sync);		return 0;	}	return rdev_set_tx_power(rdev, wdev, type, DBM_TO_MBM(dbm));}

static int cfg80211_wext_siwrate(struct net_device *dev,				 struct iw_request_info *info,				 struct iw_param *rate, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct cfg80211_bitrate_mask mask;	u32 fixed, maxrate;	struct ieee80211_supported_band *sband;	int band, ridx;	bool match = false;	if (!rdev->ops->set_bitrate_mask)		return -EOPNOTSUPP;	memset(&mask, 0, sizeof(mask));	fixed = 0;	maxrate = (u32)-1;	if (rate->value < 0) {		/* nothing */	} else if (rate->fixed) {		fixed = rate->value / 100000;	} else {		maxrate = rate->value / 100000;	}	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {		sband = wdev->wiphy->bands[band];		if (sband == NULL)			continue;		for (ridx = 0; ridx < sband->n_bitrates; ridx++) {			struct ieee80211_rate *srate = &sband->bitrates[ridx];			if (fixed == srate->bitrate) {				mask.control[band].legacy = 1 << ridx;				match = true;				break;			}			if (srate->bitrate <= maxrate) {				mask.control[band].legacy |= 1 << ridx;				match = true;			}		}	}	if (!match)		return -EINVAL;	return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);}

void cfg80211_assoc_timeout(struct net_device *dev, struct cfg80211_bss *bss){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct wiphy *wiphy = wdev->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);	trace_cfg80211_send_assoc_timeout(dev, bss->bssid);	nl80211_send_assoc_timeout(rdev, dev, bss->bssid, GFP_KERNEL);	cfg80211_sme_assoc_timeout(wdev);	cfg80211_unhold_bss(bss_from_pub(bss));	cfg80211_put_bss(wiphy, bss);}

int cfg80211_mgd_wext_siwap(struct net_device *dev,			    struct iw_request_info *info,			    struct sockaddr *ap_addr, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u8 *bssid = ap_addr->sa_data;	int err;	/* call only for station! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))		return -EINVAL;	if (ap_addr->sa_family != ARPHRD_ETHER)		return -EINVAL;	/* automatic mode */	if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))		bssid = NULL;	wdev_lock(wdev);	if (wdev->conn) {		err = 0;		/* both automatic */		if (!bssid && !wdev->wext.connect.bssid)			goto out;		/* fixed already - and no change */		if (wdev->wext.connect.bssid && bssid &&		    ether_addr_equal(bssid, wdev->wext.connect.bssid))			goto out;		err = cfg80211_disconnect(rdev, dev,					  WLAN_REASON_DEAUTH_LEAVING, false);		if (err)			goto out;	}	if (bssid) {		memcpy(wdev->wext.bssid, bssid, ETH_ALEN);		wdev->wext.connect.bssid = wdev->wext.bssid;	} else		wdev->wext.connect.bssid = NULL;	err = cfg80211_mgd_wext_connect(rdev, wdev); out:	wdev_unlock(wdev);	return err;}

int cfg80211_wext_siwgenie(struct net_device *dev,			   struct iw_request_info *info,			   struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u8 *ie = extra;	int ie_len = data->length, err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EOPNOTSUPP;	if (!ie_len)		ie = NULL;	wdev_lock(wdev);	/* no change */	err = 0;	if (wdev->wext.ie_len == ie_len &&	    memcmp(wdev->wext.ie, ie, ie_len) == 0)		goto out;	if (ie_len) {		ie = kmemdup(extra, ie_len, GFP_KERNEL);		if (!ie) {			err = -ENOMEM;			goto out;		}	} else		ie = NULL;	kfree(wdev->wext.ie);	wdev->wext.ie = ie;	wdev->wext.ie_len = ie_len;	if (wdev->conn) {		err = cfg80211_disconnect(rdev, dev,					  WLAN_REASON_DEAUTH_LEAVING, false);		if (err)			goto out;	}	/* userspace better not think we'll reconnect */	err = 0; out:	wdev_unlock(wdev);	return err;}

static int cfg80211_wext_siwpower(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_param *wrq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	bool ps = wdev->ps;	int timeout = wdev->ps_timeout;	int err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	if (!rdev->ops->set_power_mgmt)		return -EOPNOTSUPP;	if (wrq->disabled) {		ps = false;	} else {		switch (wrq->flags & IW_POWER_MODE) {		case IW_POWER_ON:       /* If not specified */		case IW_POWER_MODE:     /* If set all mask */		case IW_POWER_ALL_R:    /* If explicitely state all */			ps = true;			break;		default:                /* Otherwise we ignore */			return -EINVAL;		}		if (wrq->flags & ~(IW_POWER_MODE | IW_POWER_TIMEOUT))			return -EINVAL;		if (wrq->flags & IW_POWER_TIMEOUT)			timeout = wrq->value / 1000;	}	err = rdev_set_power_mgmt(rdev, dev, ps, timeout);	if (err)		return err;	wdev->ps = ps;	wdev->ps_timeout = timeout;	return 0;}

static void cfg80211_process_disassoc(struct wireless_dev *wdev,				      const u8 *buf, size_t len){	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;	const u8 *bssid = mgmt->bssid;	u16 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);	bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr);	nl80211_send_disassoc(rdev, wdev->netdev, buf, len, GFP_KERNEL);	if (WARN_ON(!wdev->current_bss ||		    !ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))		return;	__cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap);	cfg80211_sme_disassoc(wdev);}

static int cfg80211_wext_siwfreq(struct net_device *dev,				 struct iw_request_info *info,				 struct iw_freq *wextfreq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct cfg80211_chan_def chandef = {		.width = NL80211_CHAN_WIDTH_20_NOHT,	};	int freq;	switch (wdev->iftype) {	case NL80211_IFTYPE_STATION:		return cfg80211_mgd_wext_siwfreq(dev, info, wextfreq, extra);	case NL80211_IFTYPE_ADHOC:		return cfg80211_ibss_wext_siwfreq(dev, info, wextfreq, extra);	case NL80211_IFTYPE_MONITOR:		freq = cfg80211_wext_freq(wextfreq);		if (freq < 0)			return freq;		if (freq == 0)			return -EINVAL;		chandef.center_freq1 = freq;		chandef.chan = ieee80211_get_channel(&rdev->wiphy, freq);		if (!chandef.chan)			return -EINVAL;		return cfg80211_set_monitor_channel(rdev, &chandef);	case NL80211_IFTYPE_MESH_POINT:		freq = cfg80211_wext_freq(wextfreq);		if (freq < 0)			return freq;		if (freq == 0)			return -EINVAL;		chandef.center_freq1 = freq;		chandef.chan = ieee80211_get_channel(&rdev->wiphy, freq);		if (!chandef.chan)			return -EINVAL;		return cfg80211_set_mesh_channel(rdev, wdev, &chandef);	default:		return -EOPNOTSUPP;	}}

void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,			    struct ieee80211_channel *channel){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_bss *bss;#ifdef CONFIG_CFG80211_WEXT	union iwreq_data wrqu;#endif	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))		return;	if (!wdev->ssid_len)		return;	bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, NULL, 0,			       IEEE80211_BSS_TYPE_IBSS, IEEE80211_PRIVACY_ANY);	if (WARN_ON(!bss))		return;	if (wdev->current_bss) {		cfg80211_unhold_bss(wdev->current_bss);		cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);	}	cfg80211_hold_bss(bss_from_pub(bss));	wdev->current_bss = bss_from_pub(bss);	if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))		cfg80211_upload_connect_keys(wdev);	nl80211_send_ibss_bssid(wiphy_to_rdev(wdev->wiphy), dev, bssid,				GFP_KERNEL);#ifdef CONFIG_CFG80211_WEXT	memset(&wrqu, 0, sizeof(wrqu));	memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);	wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);#endif}

static int cfg80211_wext_siwpmksa(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	struct cfg80211_pmksa cfg_pmksa;	struct iw_pmksa *pmksa = (struct iw_pmksa *)extra;	memset(&cfg_pmksa, 0, sizeof(struct cfg80211_pmksa));	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	cfg_pmksa.bssid = pmksa->bssid.sa_data;	cfg_pmksa.pmkid = pmksa->pmkid;	switch (pmksa->cmd) {	case IW_PMKSA_ADD:		if (!rdev->ops->set_pmksa)			return -EOPNOTSUPP;		return rdev_set_pmksa(rdev, dev, &cfg_pmksa);	case IW_PMKSA_REMOVE:		if (!rdev->ops->del_pmksa)			return -EOPNOTSUPP;		return rdev_del_pmksa(rdev, dev, &cfg_pmksa);	case IW_PMKSA_FLUSH:		if (!rdev->ops->flush_pmksa)			return -EOPNOTSUPP;		return rdev_flush_pmksa(rdev, dev);	default:		return -EOPNOTSUPP;	}}

int cfg80211_ibss_wext_siwessid(struct net_device *dev,				struct iw_request_info *info,				struct iw_point *data, char *ssid){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	size_t len = data->length;	int err;	/* call only for ibss! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))		return -EINVAL;	if (!rdev->ops->join_ibss)		return -EOPNOTSUPP;	wdev_lock(wdev);	err = 0;	if (wdev->ssid_len)		err = __cfg80211_leave_ibss(rdev, dev, true);	wdev_unlock(wdev);	if (err)		return err;	/* iwconfig uses nul termination in SSID.. */	if (len > 0 && ssid[len - 1] == '/0')		len--;	memcpy(wdev->ssid, ssid, len);	wdev->wext.ibss.ssid = wdev->ssid;	wdev->wext.ibss.ssid_len = len;	wdev_lock(wdev);	err = cfg80211_ibss_wext_join(rdev, wdev);	wdev_unlock(wdev);	return err;}

int cfg80211_wext_siwrts(struct net_device *dev,			 struct iw_request_info *info,			 struct iw_param *rts, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u32 orts = wdev->wiphy->rts_threshold;	int err;	if (rts->disabled || !rts->fixed)		wdev->wiphy->rts_threshold = (u32) -1;	else if (rts->value < 0)		return -EINVAL;	else		wdev->wiphy->rts_threshold = rts->value;	err = rdev_set_wiphy_params(rdev, WIPHY_PARAM_RTS_THRESHOLD);	if (err)		wdev->wiphy->rts_threshold = orts;	return err;}

static int cfg80211_wext_siwretry(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_param *retry, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u32 changed = 0;	u8 olong = wdev->wiphy->retry_long;	u8 oshort = wdev->wiphy->retry_short;	int err;	if (retry->disabled || retry->value < 1 || retry->value > 255 ||	    (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)		return -EINVAL;	if (retry->flags & IW_RETRY_LONG) {		wdev->wiphy->retry_long = retry->value;		changed |= WIPHY_PARAM_RETRY_LONG;	} else if (retry->flags & IW_RETRY_SHORT) {		wdev->wiphy->retry_short = retry->value;		changed |= WIPHY_PARAM_RETRY_SHORT;	} else {		wdev->wiphy->retry_short = retry->value;		wdev->wiphy->retry_long = retry->value;		changed |= WIPHY_PARAM_RETRY_LONG;		changed |= WIPHY_PARAM_RETRY_SHORT;	}	if (!changed)		return 0;	err = rdev_set_wiphy_params(rdev, changed);	if (err) {		wdev->wiphy->retry_short = oshort;		wdev->wiphy->retry_long = olong;	}	return err;}

static int cfg80211_wext_giwrate(struct net_device *dev,				 struct iw_request_info *info,				 struct iw_param *rate, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	/* we are under RTNL - globally locked - so can use a static struct */	static struct station_info sinfo;	u8 addr[ETH_ALEN];	int err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EOPNOTSUPP;	if (!rdev->ops->get_station)		return -EOPNOTSUPP;	err = 0;	wdev_lock(wdev);	if (wdev->current_bss)		memcpy(addr, wdev->current_bss->pub.bssid, ETH_ALEN);	else		err = -EOPNOTSUPP;	wdev_unlock(wdev);	if (err)		return err;	err = rdev_get_station(rdev, dev, addr, &sinfo);	if (err)		return err;	if (!(sinfo.filled & BIT(NL80211_STA_INFO_TX_BITRATE)))		return -EOPNOTSUPP;	rate->value = 100000 * cfg80211_calculate_bitrate(&sinfo.txrate);	return 0;}

int cfg80211_wext_siwfrag(struct net_device *dev,			  struct iw_request_info *info,			  struct iw_param *frag, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);	u32 ofrag = wdev->wiphy->frag_threshold;	int err;	if (frag->disabled || !frag->fixed)		wdev->wiphy->frag_threshold = (u32) -1;	else if (frag->value < 256)		return -EINVAL;	else {		/* Fragment length must be even, so strip LSB. */		wdev->wiphy->frag_threshold = frag->value & ~0x1;	}	err = rdev_set_wiphy_params(rdev, WIPHY_PARAM_FRAG_THRESHOLD);	if (err)		wdev->wiphy->frag_threshold = ofrag;	return err;}