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

/* some MLME handling for userspace SME */int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 struct ieee80211_channel *chan,			 enum nl80211_auth_type auth_type,			 const u8 *bssid,			 const u8 *ssid, int ssid_len,			 const u8 *ie, int ie_len,			 const u8 *key, int key_len, int key_idx){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_auth_request req;	int err;	ASSERT_WDEV_LOCK(wdev);	if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)		if (!key || !key_len || key_idx < 0 || key_idx > 4)			return -EINVAL;	if (wdev->current_bss &&	    ether_addr_equal(bssid, wdev->current_bss->pub.bssid))		return -EALREADY;	memset(&req, 0, sizeof(req));	req.ie = ie;	req.ie_len = ie_len;	req.auth_type = auth_type;	req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,				   WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);	req.key = key;	req.key_len = key_len;	req.key_idx = key_idx;	if (!req.bss)		return -ENOENT;	err = cfg80211_can_use_chan(rdev, wdev, req.bss->channel,				    CHAN_MODE_SHARED);	if (err)		goto out;	err = rdev->ops->auth(&rdev->wiphy, dev, &req);out:	cfg80211_put_bss(req.bss);	return err;}

int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,			      struct wireless_dev *wdev){	struct cfg80211_cached_keys *ck = NULL;	const u8 *prev_bssid = NULL;	int err, i;	ASSERT_RDEV_LOCK(rdev);	ASSERT_WDEV_LOCK(wdev);	if (!netif_running(wdev->netdev))		return 0;	wdev->wext.connect.ie = wdev->wext.ie;	wdev->wext.connect.ie_len = wdev->wext.ie_len;	/* Use default background scan period */	wdev->wext.connect.bg_scan_period = -1;	if (wdev->wext.keys) {		wdev->wext.keys->def = wdev->wext.default_key;		wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key;		if (wdev->wext.default_key != -1)			wdev->wext.connect.privacy = true;	}	if (!wdev->wext.connect.ssid_len)		return 0;	if (wdev->wext.keys) {		ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);		if (!ck)			return -ENOMEM;		for (i = 0; i < 6; i++)			ck->params[i].key = ck->data[i];	}	if (wdev->wext.prev_bssid_valid)		prev_bssid = wdev->wext.prev_bssid;	err = __cfg80211_connect(rdev, wdev->netdev,				 &wdev->wext.connect, ck, prev_bssid);	if (err)		kfree(ck);	return err;}

void cfg80211_tx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct ieee80211_mgmt *mgmt = (void *)buf;	ASSERT_WDEV_LOCK(wdev);	trace_cfg80211_tx_mlme_mgmt(dev, buf, len);	if (WARN_ON(len < 2))		return;	if (ieee80211_is_deauth(mgmt->frame_control))		cfg80211_process_deauth(wdev, buf, len);	else		cfg80211_process_disassoc(wdev, buf, len);}

void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,			struct net_device *dev){	struct wireless_dev *wdev = dev->ieee80211_ptr;	u8 bssid[ETH_ALEN];	ASSERT_WDEV_LOCK(wdev);	if (!rdev->ops->deauth)		return;	if (!wdev->current_bss)		return;	memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN);	cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0,			     WLAN_REASON_DEAUTH_LEAVING, false);}

/* some MLME handling for userspace SME */int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,		       struct net_device *dev,		       struct ieee80211_channel *chan,		       enum nl80211_auth_type auth_type,		       const u8 *bssid,		       const u8 *ssid, int ssid_len,		       const u8 *ie, int ie_len,		       const u8 *key, int key_len, int key_idx,		       const u8 *auth_data, int auth_data_len){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_auth_request req = {		.ie = ie,		.ie_len = ie_len,		.auth_data = auth_data,		.auth_data_len = auth_data_len,		.auth_type = auth_type,		.key = key,		.key_len = key_len,		.key_idx = key_idx,	};	int err;	ASSERT_WDEV_LOCK(wdev);	if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)		if (!key || !key_len || key_idx < 0 || key_idx > 3)			return -EINVAL;	if (wdev->current_bss &&	    ether_addr_equal(bssid, wdev->current_bss->pub.bssid))		return -EALREADY;	req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,				   IEEE80211_BSS_TYPE_ESS,				   IEEE80211_PRIVACY_ANY);	if (!req.bss)		return -ENOENT;	err = rdev_auth(rdev, dev, &req);	cfg80211_put_bss(&rdev->wiphy, req.bss);	return err;}

int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,			  struct net_device *dev, bool nowext){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	ASSERT_WDEV_LOCK(wdev);	if (!wdev->ssid_len)		return -ENOLINK;	err = rdev_leave_ibss(rdev, dev);	if (err)		return err;	__cfg80211_clear_ibss(dev, nowext);	return 0;}

int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,			   struct net_device *dev, const u8 *bssid,			   const u8 *ie, int ie_len, u16 reason,			   bool local_state_change){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_deauth_request req = {		.bssid = bssid,		.reason_code = reason,		.ie = ie,		.ie_len = ie_len,		.local_state_change = local_state_change,	};	ASSERT_WDEV_LOCK(wdev);	if (local_state_change && (!wdev->current_bss ||	    !ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))		return 0;	return rdev_deauth(rdev, dev, &req);}

static int __cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,				 struct net_device *dev){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	ASSERT_WDEV_LOCK(wdev);	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)		return -EOPNOTSUPP;	if (!rdev->ops->leave_mesh)		return -EOPNOTSUPP;	if (!wdev->mesh_id_len)		return -ENOTCONN;	err = rdev->ops->leave_mesh(&rdev->wiphy, dev);	if (!err)		wdev->mesh_id_len = 0;	return err;}

void __cfg80211_send_deauth(struct net_device *dev,				   const u8 *buf, size_t len){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct wiphy *wiphy = wdev->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;	const u8 *bssid = mgmt->bssid;	bool was_current = false;	trace___cfg80211_send_deauth(dev);	ASSERT_WDEV_LOCK(wdev);	if (wdev->current_bss &&	    ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) {		cfg80211_unhold_bss(wdev->current_bss);		cfg80211_put_bss(wiphy, &wdev->current_bss->pub);		wdev->current_bss = NULL;		was_current = true;	}	nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);	if (wdev->sme_state == CFG80211_SME_CONNECTED && was_current) {		u16 reason_code;		bool from_ap;		reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);		from_ap = !ether_addr_equal(mgmt->sa, dev->dev_addr);		__cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);	} else if (wdev->sme_state == CFG80211_SME_CONNECTING) {		__cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,					  WLAN_STATUS_UNSPECIFIED_FAILURE,					  false, NULL);	}}

int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 const struct mesh_setup *setup,			 const struct mesh_config *conf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);	ASSERT_WDEV_LOCK(wdev);	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)		return -EOPNOTSUPP;	if (!(rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&	      setup->is_secure)		return -EOPNOTSUPP;	if (wdev->mesh_id_len)		return -EALREADY;	if (!setup->mesh_id_len)		return -EINVAL;	if (!rdev->ops->join_mesh)		return -EOPNOTSUPP;	err = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, setup);	if (!err) {		memcpy(wdev->ssid, setup->mesh_id, setup->mesh_id_len);		wdev->mesh_id_len = setup->mesh_id_len;	}	return err;}

int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,			struct net_device *dev,			struct ieee80211_channel *chan,			const u8 *bssid,			const u8 *ssid, int ssid_len,			struct cfg80211_assoc_request *req){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	ASSERT_WDEV_LOCK(wdev);	if (wdev->current_bss &&	    (!req->prev_bssid || !ether_addr_equal(wdev->current_bss->pub.bssid,						   req->prev_bssid)))		return -EALREADY;	cfg80211_oper_and_ht_capa(&req->ht_capa_mask,				  rdev->wiphy.ht_capa_mod_mask);	cfg80211_oper_and_vht_capa(&req->vht_capa_mask,				   rdev->wiphy.vht_capa_mod_mask);	req->bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,				    IEEE80211_BSS_TYPE_ESS,				    IEEE80211_PRIVACY_ANY);	if (!req->bss)		return -ENOENT;	err = rdev_assoc(rdev, dev, req);	if (!err)		cfg80211_hold_bss(bss_from_pub(req->bss));	else		cfg80211_put_bss(&rdev->wiphy, req->bss);	return err;}

int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 struct cfg80211_ibss_params *params,			 struct cfg80211_cached_keys *connkeys){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct ieee80211_channel *chan;	int err;	ASSERT_WDEV_LOCK(wdev);	chan = rdev_fixed_channel(rdev, wdev);	if (chan && chan != params->channel)		return -EBUSY;	if (wdev->ssid_len)		return -EALREADY;	if (WARN_ON(wdev->connect_keys))		kfree(wdev->connect_keys);	wdev->connect_keys = connkeys;#ifdef CONFIG_CFG80211_WEXT	wdev->wext.ibss.channel = params->channel;#endif	err = rdev->ops->join_ibss(&rdev->wiphy, dev, params);	if (err) {		wdev->connect_keys = NULL;		return err;	}	memcpy(wdev->ssid, params->ssid, params->ssid_len);	wdev->ssid_len = params->ssid_len;	return 0;}

int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 struct mesh_setup *setup,			 const struct mesh_config *conf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);	ASSERT_WDEV_LOCK(wdev);	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)		return -EOPNOTSUPP;	if (!(rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&	      setup->is_secure)		return -EOPNOTSUPP;	if (wdev->mesh_id_len)		return -EALREADY;	if (!setup->mesh_id_len)		return -EINVAL;	if (!rdev->ops->join_mesh)		return -EOPNOTSUPP;	if (!setup->chandef.chan) {		/* if no channel explicitly given, use preset channel */		setup->chandef = wdev->preset_chandef;	}	if (!setup->chandef.chan) {		/* if we don't have that either, use the first usable channel */		enum nl80211_band band;		for (band = 0; band < NUM_NL80211_BANDS; band++) {			struct ieee80211_supported_band *sband;			struct ieee80211_channel *chan;			int i;			sband = rdev->wiphy.bands[band];			if (!sband)				continue;			for (i = 0; i < sband->n_channels; i++) {				chan = &sband->channels[i];				if (chan->flags & (IEEE80211_CHAN_NO_IR |						   IEEE80211_CHAN_DISABLED |						   IEEE80211_CHAN_RADAR))					continue;				setup->chandef.chan = chan;				break;			}			if (setup->chandef.chan)				break;		}		/* no usable channel ... */		if (!setup->chandef.chan)			return -EINVAL;		setup->chandef.width = NL80211_CHAN_WIDTH_20_NOHT;		setup->chandef.center_freq1 = setup->chandef.chan->center_freq;	}	/*	 * check if basic rates are available otherwise use mandatory rates as	 * basic rates	 */	if (!setup->basic_rates) {		enum nl80211_bss_scan_width scan_width;		struct ieee80211_supported_band *sband =				rdev->wiphy.bands[setup->chandef.chan->band];		scan_width = cfg80211_chandef_to_scan_width(&setup->chandef);		setup->basic_rates = ieee80211_mandatory_rates(sband,							       scan_width);	}	if (!cfg80211_reg_can_beacon(&rdev->wiphy, &setup->chandef,				     NL80211_IFTYPE_MESH_POINT))		return -EINVAL;	err = rdev_join_mesh(rdev, dev, conf, setup);	if (!err) {		memcpy(wdev->ssid, setup->mesh_id, setup->mesh_id_len);		wdev->mesh_id_len = setup->mesh_id_len;		wdev->chandef = setup->chandef;	}	return err;}

int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,			 struct net_device *dev,			 struct mesh_setup *setup,			 const struct mesh_config *conf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	int err;	BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != IEEE80211_MAX_MESH_ID_LEN);	ASSERT_WDEV_LOCK(wdev);	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)		return -EOPNOTSUPP;	if (!(rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&	      setup->is_secure)		return -EOPNOTSUPP;	if (wdev->mesh_id_len)		return -EALREADY;	if (!setup->mesh_id_len)		return -EINVAL;	if (!rdev->ops->join_mesh)		return -EOPNOTSUPP;	if (!setup->chandef.chan) {		/* if no channel explicitly given, use preset channel */		setup->chandef = wdev->preset_chandef;	}	if (!setup->chandef.chan) {		/* if we don't have that either, use the first usable channel */		enum nl80211_band band;		for (band = 0; band < NUM_NL80211_BANDS; band++) {			struct ieee80211_supported_band *sband;			struct ieee80211_channel *chan;			int i;			sband = rdev->wiphy.bands[band];			if (!sband)				continue;			for (i = 0; i < sband->n_channels; i++) {				chan = &sband->channels[i];				if (chan->flags & (IEEE80211_CHAN_NO_IR |						   IEEE80211_CHAN_DISABLED |						   IEEE80211_CHAN_RADAR))					continue;				setup->chandef.chan = chan;				break;			}			if (setup->chandef.chan)				break;		}		/* no usable channel ... */		if (!setup->chandef.chan)			return -EINVAL;		setup->chandef.width = NL80211_CHAN_WIDTH_20_NOHT;		setup->chandef.center_freq1 = setup->chandef.chan->center_freq;	}	/*	 * check if basic rates are available otherwise use mandatory rates as	 * basic rates	 */	if (!setup->basic_rates) {		enum nl80211_bss_scan_width scan_width;		struct ieee80211_supported_band *sband =				rdev->wiphy.bands[setup->chandef.chan->band];		if (setup->chandef.chan->band == NL80211_BAND_2GHZ) {			int i;			/*			 * Older versions selected the mandatory rates for			 * 2.4 GHz as well, but were broken in that only			 * 1 Mbps was regarded as a mandatory rate. Keep			 * using just 1 Mbps as the default basic rate for			 * mesh to be interoperable with older versions.			 */			for (i = 0; i < sband->n_bitrates; i++) {				if (sband->bitrates[i].bitrate == 10) {					setup->basic_rates = BIT(i);					break;				}			}		} else {			scan_width = cfg80211_chandef_to_scan_width(&setup->chandef);			setup->basic_rates = ieee80211_mandatory_rates(sband,								       scan_width);		}	}//.........这里部分代码省略.........

voidcfg80211_get_chan_state(struct wireless_dev *wdev,		        struct ieee80211_channel **chan,		        enum cfg80211_chan_mode *chanmode){	*chan = NULL;	*chanmode = CHAN_MODE_UNDEFINED;	ASSERT_WDEV_LOCK(wdev);	if (wdev->netdev && !netif_running(wdev->netdev))		return;	switch (wdev->iftype) {	case NL80211_IFTYPE_ADHOC:		if (wdev->current_bss) {			*chan = wdev->current_bss->pub.channel;			*chanmode = wdev->ibss_fixed				  ? CHAN_MODE_SHARED				  : CHAN_MODE_EXCLUSIVE;			return;		}	case NL80211_IFTYPE_STATION:	case NL80211_IFTYPE_P2P_CLIENT:		if (wdev->current_bss) {			*chan = wdev->current_bss->pub.channel;			*chanmode = CHAN_MODE_SHARED;			return;		}		break;	case NL80211_IFTYPE_AP:	case NL80211_IFTYPE_P2P_GO:		if (wdev->cac_started) {			*chan = wdev->channel;			*chanmode = CHAN_MODE_SHARED;		} else if (wdev->beacon_interval) {			*chan = wdev->channel;			*chanmode = CHAN_MODE_SHARED;		}		return;	case NL80211_IFTYPE_MESH_POINT:		if (wdev->mesh_id_len) {			*chan = wdev->channel;			*chanmode = CHAN_MODE_SHARED;		}		return;	case NL80211_IFTYPE_MONITOR:	case NL80211_IFTYPE_AP_VLAN:	case NL80211_IFTYPE_WDS:		/* these interface types don't really have a channel */		return;	case NL80211_IFTYPE_P2P_DEVICE:		if (wdev->wiphy->features &				NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)			*chanmode = CHAN_MODE_EXCLUSIVE;		return;	case NL80211_IFTYPE_UNSPECIFIED:	case NUM_NL80211_IFTYPES:		WARN_ON(1);	}	return;}

int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,                         struct net_device *dev,                         struct cfg80211_ibss_params *params,                         struct cfg80211_cached_keys *connkeys){    struct wireless_dev *wdev = dev->ieee80211_ptr;    int err;    ASSERT_WDEV_LOCK(wdev);    if (wdev->ssid_len)        return -EALREADY;    if (!params->basic_rates) {        /*        * If no rates were explicitly configured,        * use the mandatory rate set for 11b or        * 11a for maximum compatibility.        */        struct ieee80211_supported_band *sband =                rdev->wiphy.bands[params->chandef.chan->band];        int j;        u32 flag = params->chandef.chan->band == IEEE80211_BAND_5GHZ ?                   IEEE80211_RATE_MANDATORY_A :                   IEEE80211_RATE_MANDATORY_B;        for (j = 0; j < sband->n_bitrates; j++) {            if (sband->bitrates[j].flags & flag)                params->basic_rates |= BIT(j);        }    }    if (WARN_ON(wdev->connect_keys))        kfree(wdev->connect_keys);    wdev->connect_keys = connkeys;    wdev->ibss_fixed = params->channel_fixed;#ifdef CONFIG_CFG80211_WEXT    wdev->wext.ibss.chandef = params->chandef;#endif    wdev->sme_state = CFG80211_SME_CONNECTING;    err = cfg80211_can_use_chan(rdev, wdev, params->chandef.chan,                                params->channel_fixed                                ? CHAN_MODE_SHARED                                : CHAN_MODE_EXCLUSIVE);    if (err) {        wdev->connect_keys = NULL;        return err;    }    err = rdev_join_ibss(rdev, dev, params);    if (err) {        wdev->connect_keys = NULL;        wdev->sme_state = CFG80211_SME_IDLE;        return err;    }    memcpy(wdev->ssid, params->ssid, params->ssid_len);    wdev->ssid_len = params->ssid_len;    return 0;}

int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,                          struct net_device *dev,                          struct ieee80211_channel *chan,                          const u8 *bssid, const u8 *prev_bssid,                          const u8 *ssid, int ssid_len,                          const u8 *ie, int ie_len, bool use_mfp,                          struct cfg80211_crypto_settings *crypt,                          u32 assoc_flags, struct ieee80211_ht_cap *ht_capa,                          struct ieee80211_ht_cap *ht_capa_mask){    struct wireless_dev *wdev = dev->ieee80211_ptr;    struct cfg80211_assoc_request req;    int err;    bool was_connected = false;    ASSERT_WDEV_LOCK(wdev);    memset(&req, 0, sizeof(req));    if (wdev->current_bss && prev_bssid &&            ether_addr_equal(wdev->current_bss->pub.bssid, prev_bssid)) {        /*         * Trying to reassociate: Allow this to proceed and let the old         * association to be dropped when the new one is completed.         */        if (wdev->sme_state == CFG80211_SME_CONNECTED) {            was_connected = true;            wdev->sme_state = CFG80211_SME_CONNECTING;        }    } else if (wdev->current_bss)        return -EALREADY;    req.ie = ie;    req.ie_len = ie_len;    memcpy(&req.crypto, crypt, sizeof(req.crypto));    req.use_mfp = use_mfp;    req.prev_bssid = prev_bssid;    req.flags = assoc_flags;    if (ht_capa)        memcpy(&req.ht_capa, ht_capa, sizeof(req.ht_capa));    if (ht_capa_mask)        memcpy(&req.ht_capa_mask, ht_capa_mask,               sizeof(req.ht_capa_mask));    cfg80211_oper_and_ht_capa(&req.ht_capa_mask,                              rdev->wiphy.ht_capa_mod_mask);    req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,                               WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);    if (!req.bss) {        if (was_connected)            wdev->sme_state = CFG80211_SME_CONNECTED;        return -ENOENT;    }    err = rdev->ops->assoc(&rdev->wiphy, dev, &req);    if (err) {        if (was_connected)            wdev->sme_state = CFG80211_SME_CONNECTED;        cfg80211_put_bss(req.bss);    }    return err;}

int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,			    struct wireless_dev *wdev){	struct cfg80211_cached_keys *ck = NULL;	enum nl80211_band band;	int i, err;	ASSERT_WDEV_LOCK(wdev);	if (!wdev->wext.ibss.beacon_interval)		wdev->wext.ibss.beacon_interval = 100;	/* try to find an IBSS channel if none requested ... */	if (!wdev->wext.ibss.chandef.chan) {		struct ieee80211_channel *new_chan = NULL;		for (band = 0; band < NUM_NL80211_BANDS; band++) {			struct ieee80211_supported_band *sband;			struct ieee80211_channel *chan;			sband = rdev->wiphy.bands[band];			if (!sband)				continue;			for (i = 0; i < sband->n_channels; i++) {				chan = &sband->channels[i];				if (chan->flags & IEEE80211_CHAN_NO_IR)					continue;				if (chan->flags & IEEE80211_CHAN_DISABLED)					continue;				new_chan = chan;				break;			}			if (new_chan)				break;		}		if (!new_chan)			return -EINVAL;		cfg80211_chandef_create(&wdev->wext.ibss.chandef, new_chan,					NL80211_CHAN_NO_HT);	}	/* don't join -- SSID is not there */	if (!wdev->wext.ibss.ssid_len)		return 0;	if (!netif_running(wdev->netdev))		return 0;	if (wdev->wext.keys)		wdev->wext.keys->def = wdev->wext.default_key;	wdev->wext.ibss.privacy = wdev->wext.default_key != -1;	if (wdev->wext.keys && wdev->wext.keys->def != -1) {		ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);		if (!ck)			return -ENOMEM;		for (i = 0; i < CFG80211_MAX_WEP_KEYS; i++)			ck->params[i].key = ck->data[i];	}	err = __cfg80211_join_ibss(rdev, wdev->netdev,				   &wdev->wext.ibss, ck);	if (err)		kfree(ck);	return err;}