mirror of
https://github.com/torvalds/linux.git
synced 2024-11-23 12:42:02 +00:00
replace net_device arguments with ieee80211_{local,sub_if_data} as appropriate
This patch replaces net_device arguments to mac80211 internal functions
with ieee80211_{local,sub_if_data} as appropriate.
It also does the same for many 802.11s mesh functions, and changes the
mesh path table to be indexed on sub_if_data rather than net_device.
If the mesh part needs to be a separate patch let me know, but since
mesh uses a lot of mac80211 functions which were being converted anyway,
the changes go hand-in-hand somewhat.
This patch probably does not convert all the functions which could be
converted, but it is a large chunk and followup patches will be
provided.
Signed-off-by: Jasper Bryant-Greene <jasper@amiton.co.nz>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Jasper Bryant-Greene
John W. Linville
parent
fef1643bf0
commit
f698d856f6
@ -66,13 +66,16 @@ static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
|
||||
static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex)
|
||||
{
|
||||
struct net_device *dev;
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
|
||||
/* we're under RTNL */
|
||||
dev = __dev_get_by_index(&init_net, ifindex);
|
||||
if (!dev)
|
||||
return -ENODEV;
|
||||
|
||||
ieee80211_if_remove(dev);
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
ieee80211_if_remove(sdata);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -842,13 +845,13 @@ static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
err = mesh_path_add(dst, dev);
|
||||
err = mesh_path_add(dst, sdata);
|
||||
if (err) {
|
||||
rcu_read_unlock();
|
||||
return err;
|
||||
}
|
||||
|
||||
mpath = mesh_path_lookup(dst, dev);
|
||||
mpath = mesh_path_lookup(dst, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return -ENXIO;
|
||||
@ -862,10 +865,12 @@ static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
|
||||
static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
|
||||
u8 *dst)
|
||||
{
|
||||
if (dst)
|
||||
return mesh_path_del(dst, dev);
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
mesh_path_flush(dev);
|
||||
if (dst)
|
||||
return mesh_path_del(dst, sdata);
|
||||
|
||||
mesh_path_flush(sdata);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -897,7 +902,7 @@ static int ieee80211_change_mpath(struct wiphy *wiphy,
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
mpath = mesh_path_lookup(dst, dev);
|
||||
mpath = mesh_path_lookup(dst, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return -ENOENT;
|
||||
@ -965,7 +970,7 @@ static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
|
||||
return -ENOTSUPP;
|
||||
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(dst, dev);
|
||||
mpath = mesh_path_lookup(dst, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return -ENOENT;
|
||||
@ -993,7 +998,7 @@ static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
|
||||
return -ENOTSUPP;
|
||||
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup_by_idx(idx, dev);
|
||||
mpath = mesh_path_lookup_by_idx(idx, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return -ENOENT;
|
||||
|
||||
@ -201,7 +201,7 @@ static ssize_t sta_agg_status_write(struct file *file,
|
||||
tid_num = tid_num - 100;
|
||||
if (tid_static_rx[tid_num] == 1) {
|
||||
strcpy(state, "off ");
|
||||
ieee80211_sta_stop_rx_ba_session(dev, da, tid_num, 0,
|
||||
ieee80211_sta_stop_rx_ba_session(sta->sdata, da, tid_num, 0,
|
||||
WLAN_REASON_QSTA_REQUIRE_SETUP);
|
||||
sta->ampdu_mlme.tid_state_rx[tid_num] |=
|
||||
HT_AGG_STATE_DEBUGFS_CTL;
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
* mac80211 - events
|
||||
*/
|
||||
|
||||
#include <linux/netdevice.h>
|
||||
#include <net/iw_handler.h>
|
||||
#include "ieee80211_i.h"
|
||||
|
||||
@ -17,7 +16,7 @@
|
||||
* (in the variable hdr) must be long enough to extract the TKIP
|
||||
* fields like TSC
|
||||
*/
|
||||
void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx,
|
||||
void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
|
||||
struct ieee80211_hdr *hdr)
|
||||
{
|
||||
union iwreq_data wrqu;
|
||||
@ -32,7 +31,7 @@ void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx,
|
||||
print_mac(mac, hdr->addr2));
|
||||
memset(&wrqu, 0, sizeof(wrqu));
|
||||
wrqu.data.length = strlen(buf);
|
||||
wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
|
||||
wireless_send_event(sdata->dev, IWEVCUSTOM, &wrqu, buf);
|
||||
kfree(buf);
|
||||
}
|
||||
|
||||
|
||||
@ -851,65 +851,65 @@ u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
|
||||
|
||||
/* ieee80211_ioctl.c */
|
||||
extern const struct iw_handler_def ieee80211_iw_handler_def;
|
||||
int ieee80211_set_freq(struct net_device *dev, int freq);
|
||||
int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freq);
|
||||
|
||||
/* ieee80211_sta.c */
|
||||
void ieee80211_sta_timer(unsigned long data);
|
||||
void ieee80211_sta_work(struct work_struct *work);
|
||||
void ieee80211_sta_scan_work(struct work_struct *work);
|
||||
void ieee80211_sta_rx_mgmt(struct net_device *dev, struct sk_buff *skb,
|
||||
void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
|
||||
struct ieee80211_rx_status *rx_status);
|
||||
int ieee80211_sta_set_ssid(struct net_device *dev, char *ssid, size_t len);
|
||||
int ieee80211_sta_get_ssid(struct net_device *dev, char *ssid, size_t *len);
|
||||
int ieee80211_sta_set_bssid(struct net_device *dev, u8 *bssid);
|
||||
int ieee80211_sta_req_scan(struct net_device *dev, u8 *ssid, size_t ssid_len);
|
||||
void ieee80211_sta_req_auth(struct net_device *dev,
|
||||
int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len);
|
||||
int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len);
|
||||
int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid);
|
||||
int ieee80211_sta_req_scan(struct ieee80211_sub_if_data *sdata, u8 *ssid, size_t ssid_len);
|
||||
void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_if_sta *ifsta);
|
||||
int ieee80211_sta_scan_results(struct net_device *dev,
|
||||
int ieee80211_sta_scan_results(struct ieee80211_local *local,
|
||||
struct iw_request_info *info,
|
||||
char *buf, size_t len);
|
||||
ieee80211_rx_result ieee80211_sta_rx_scan(
|
||||
struct net_device *dev, struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
|
||||
struct ieee80211_rx_status *rx_status);
|
||||
void ieee80211_rx_bss_list_init(struct ieee80211_local *local);
|
||||
void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local);
|
||||
int ieee80211_sta_set_extra_ie(struct net_device *dev, char *ie, size_t len);
|
||||
struct sta_info *ieee80211_ibss_add_sta(struct net_device *dev,
|
||||
int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len);
|
||||
struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
|
||||
struct sk_buff *skb, u8 *bssid,
|
||||
u8 *addr, u64 supp_rates);
|
||||
int ieee80211_sta_deauthenticate(struct net_device *dev, u16 reason);
|
||||
int ieee80211_sta_disassociate(struct net_device *dev, u16 reason);
|
||||
int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason);
|
||||
int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);
|
||||
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
||||
u32 changed);
|
||||
u32 ieee80211_reset_erp_info(struct net_device *dev);
|
||||
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
|
||||
int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
|
||||
struct ieee80211_ht_info *ht_info);
|
||||
int ieee80211_ht_addt_info_ie_to_ht_bss_info(
|
||||
struct ieee80211_ht_addt_info *ht_add_info_ie,
|
||||
struct ieee80211_ht_bss_info *bss_info);
|
||||
void ieee80211_send_addba_request(struct net_device *dev, const u8 *da,
|
||||
void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata, const u8 *da,
|
||||
u16 tid, u8 dialog_token, u16 start_seq_num,
|
||||
u16 agg_size, u16 timeout);
|
||||
void ieee80211_send_delba(struct net_device *dev, const u8 *da, u16 tid,
|
||||
void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, const u8 *da, u16 tid,
|
||||
u16 initiator, u16 reason_code);
|
||||
void ieee80211_send_bar(struct net_device *dev, u8 *ra, u16 tid, u16 ssn);
|
||||
void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn);
|
||||
|
||||
void ieee80211_sta_stop_rx_ba_session(struct net_device *dev, u8 *da,
|
||||
void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *da,
|
||||
u16 tid, u16 initiator, u16 reason);
|
||||
void sta_addba_resp_timer_expired(unsigned long data);
|
||||
void ieee80211_sta_tear_down_BA_sessions(struct net_device *dev, u8 *addr);
|
||||
void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data *sdata, u8 *addr);
|
||||
u64 ieee80211_sta_get_rates(struct ieee80211_local *local,
|
||||
struct ieee802_11_elems *elems,
|
||||
enum ieee80211_band band);
|
||||
void ieee80211_sta_tx(struct net_device *dev, struct sk_buff *skb,
|
||||
void ieee80211_sta_tx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
|
||||
int encrypt);
|
||||
void ieee802_11_parse_elems(u8 *start, size_t len,
|
||||
struct ieee802_11_elems *elems);
|
||||
|
||||
#ifdef CONFIG_MAC80211_MESH
|
||||
void ieee80211_start_mesh(struct net_device *dev);
|
||||
void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata);
|
||||
#else
|
||||
static inline void ieee80211_start_mesh(struct net_device *dev)
|
||||
static inline void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
|
||||
{}
|
||||
#endif
|
||||
|
||||
@ -920,7 +920,7 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
|
||||
struct vif_params *params);
|
||||
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
|
||||
enum ieee80211_if_types type);
|
||||
void ieee80211_if_remove(struct net_device *dev);
|
||||
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
|
||||
void ieee80211_remove_interfaces(struct ieee80211_local *local);
|
||||
|
||||
/* tx handling */
|
||||
@ -938,7 +938,7 @@ u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
|
||||
enum ieee80211_if_types type);
|
||||
int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
|
||||
int rate, int erp, int short_preamble);
|
||||
void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx,
|
||||
void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
|
||||
struct ieee80211_hdr *hdr);
|
||||
|
||||
#ifdef CONFIG_MAC80211_NOINLINE
|
||||
|
||||
@ -56,7 +56,7 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
|
||||
case IEEE80211_IF_TYPE_MESH_POINT:
|
||||
/* Allow compiler to elide mesh_rmc_free call. */
|
||||
if (ieee80211_vif_is_mesh(&sdata->vif))
|
||||
mesh_rmc_free(dev);
|
||||
mesh_rmc_free(sdata);
|
||||
/* fall through */
|
||||
case IEEE80211_IF_TYPE_STA:
|
||||
case IEEE80211_IF_TYPE_IBSS:
|
||||
@ -241,15 +241,13 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ieee80211_if_remove(struct net_device *dev)
|
||||
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
ASSERT_RTNL();
|
||||
|
||||
list_del_rcu(&sdata->list);
|
||||
synchronize_rcu();
|
||||
unregister_netdevice(dev);
|
||||
unregister_netdevice(sdata->dev);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -347,8 +347,8 @@ static int ieee80211_open(struct net_device *dev)
|
||||
goto err_stop;
|
||||
|
||||
if (ieee80211_vif_is_mesh(&sdata->vif))
|
||||
ieee80211_start_mesh(sdata->dev);
|
||||
changed |= ieee80211_reset_erp_info(dev);
|
||||
ieee80211_start_mesh(sdata);
|
||||
changed |= ieee80211_reset_erp_info(sdata);
|
||||
ieee80211_bss_info_change_notify(sdata, changed);
|
||||
ieee80211_enable_keys(sdata);
|
||||
|
||||
@ -448,7 +448,7 @@ static int ieee80211_stop(struct net_device *dev)
|
||||
|
||||
list_for_each_entry_rcu(sta, &local->sta_list, list) {
|
||||
if (sta->sdata == sdata)
|
||||
ieee80211_sta_tear_down_BA_sessions(dev, sta->addr);
|
||||
ieee80211_sta_tear_down_BA_sessions(sdata, sta->addr);
|
||||
}
|
||||
|
||||
rcu_read_unlock();
|
||||
@ -706,7 +706,7 @@ int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
|
||||
sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num;
|
||||
|
||||
|
||||
ieee80211_send_addba_request(sta->sdata->dev, ra, tid,
|
||||
ieee80211_send_addba_request(sta->sdata, ra, tid,
|
||||
sta->ampdu_mlme.tid_tx[tid]->dialog_token,
|
||||
sta->ampdu_mlme.tid_tx[tid]->ssn,
|
||||
0x40, 5000);
|
||||
@ -889,7 +889,7 @@ void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid)
|
||||
}
|
||||
|
||||
if (*state & HT_AGG_STATE_INITIATOR_MSK)
|
||||
ieee80211_send_delba(sta->sdata->dev, ra, tid,
|
||||
ieee80211_send_delba(sta->sdata, ra, tid,
|
||||
WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
|
||||
|
||||
agg_queue = sta->tid_to_tx_q[tid];
|
||||
@ -1200,10 +1200,8 @@ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
||||
changed);
|
||||
}
|
||||
|
||||
u32 ieee80211_reset_erp_info(struct net_device *dev)
|
||||
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
sdata->bss_conf.use_cts_prot = 0;
|
||||
sdata->bss_conf.use_short_preamble = 0;
|
||||
return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE;
|
||||
@ -1438,7 +1436,7 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
|
||||
tid = qc[0] & 0xf;
|
||||
ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
|
||||
& IEEE80211_SCTL_SEQ);
|
||||
ieee80211_send_bar(sta->sdata->dev, hdr->addr1,
|
||||
ieee80211_send_bar(sta->sdata, hdr->addr1,
|
||||
tid, ssn);
|
||||
}
|
||||
}
|
||||
|
||||
@ -39,14 +39,13 @@ void ieee80211s_stop(void)
|
||||
* mesh_matches_local - check if the config of a mesh point matches ours
|
||||
*
|
||||
* @ie: information elements of a management frame from the mesh peer
|
||||
* @dev: local mesh interface
|
||||
* @sdata: local mesh subif
|
||||
*
|
||||
* This function checks if the mesh configuration of a mesh point matches the
|
||||
* local mesh configuration, i.e. if both nodes belong to the same mesh network.
|
||||
*/
|
||||
bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev)
|
||||
bool mesh_matches_local(struct ieee802_11_elems *ie, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_if_sta *sta = &sdata->u.sta;
|
||||
|
||||
/*
|
||||
@ -73,10 +72,8 @@ bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev)
|
||||
* mesh_peer_accepts_plinks - check if an mp is willing to establish peer links
|
||||
*
|
||||
* @ie: information elements of a management frame from the mesh peer
|
||||
* @dev: local mesh interface
|
||||
*/
|
||||
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie,
|
||||
struct net_device *dev)
|
||||
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie)
|
||||
{
|
||||
return (*(ie->mesh_config + CAPAB_OFFSET) & ACCEPT_PLINKS) != 0;
|
||||
}
|
||||
@ -111,9 +108,8 @@ void mesh_ids_set_default(struct ieee80211_if_sta *sta)
|
||||
memcpy(sta->mesh_cc_id, def_id, 4);
|
||||
}
|
||||
|
||||
int mesh_rmc_init(struct net_device *dev)
|
||||
int mesh_rmc_init(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
int i;
|
||||
|
||||
sdata->u.sta.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
|
||||
@ -125,9 +121,8 @@ int mesh_rmc_init(struct net_device *dev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mesh_rmc_free(struct net_device *dev)
|
||||
void mesh_rmc_free(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct mesh_rmc *rmc = sdata->u.sta.rmc;
|
||||
struct rmc_entry *p, *n;
|
||||
int i;
|
||||
@ -158,9 +153,8 @@ void mesh_rmc_free(struct net_device *dev)
|
||||
* it.
|
||||
*/
|
||||
int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
|
||||
struct net_device *dev)
|
||||
struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct mesh_rmc *rmc = sdata->u.sta.rmc;
|
||||
u32 seqnum = 0;
|
||||
int entries = 0;
|
||||
@ -194,10 +188,9 @@ int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev)
|
||||
void mesh_mgmt_ies_add(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct ieee80211_supported_band *sband;
|
||||
u8 *pos;
|
||||
int len, i, rate;
|
||||
@ -262,10 +255,10 @@ void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev)
|
||||
return;
|
||||
}
|
||||
|
||||
u32 mesh_table_hash(u8 *addr, struct net_device *dev, struct mesh_table *tbl)
|
||||
u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata, struct mesh_table *tbl)
|
||||
{
|
||||
/* Use last four bytes of hw addr and interface index as hash index */
|
||||
return jhash_2words(*(u32 *)(addr+2), dev->ifindex, tbl->hash_rnd)
|
||||
return jhash_2words(*(u32 *)(addr+2), sdata->dev->ifindex, tbl->hash_rnd)
|
||||
& tbl->hash_mask;
|
||||
}
|
||||
|
||||
@ -434,7 +427,7 @@ void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
|
||||
ifsta->preq_id = 0;
|
||||
ifsta->dsn = 0;
|
||||
atomic_set(&ifsta->mpaths, 0);
|
||||
mesh_rmc_init(sdata->dev);
|
||||
mesh_rmc_init(sdata);
|
||||
ifsta->last_preq = jiffies;
|
||||
/* Allocate all mesh structures when creating the first mesh interface. */
|
||||
if (!mesh_allocated)
|
||||
|
||||
@ -47,7 +47,7 @@ enum mesh_path_flags {
|
||||
* struct mesh_path - mac80211 mesh path structure
|
||||
*
|
||||
* @dst: mesh path destination mac address
|
||||
* @dev: mesh path device
|
||||
* @sdata: mesh subif
|
||||
* @next_hop: mesh neighbor to which frames for this destination will be
|
||||
* forwarded
|
||||
* @timer: mesh path discovery timer
|
||||
@ -64,14 +64,14 @@ enum mesh_path_flags {
|
||||
* @state_lock: mesh pat state lock
|
||||
*
|
||||
*
|
||||
* The combination of dst and dev is unique in the mesh path table. Since the
|
||||
* The combination of dst and sdata is unique in the mesh path table. Since the
|
||||
* next_hop STA is only protected by RCU as well, deleting the STA must also
|
||||
* remove/substitute the mesh_path structure and wait until that is no longer
|
||||
* reachable before destroying the STA completely.
|
||||
*/
|
||||
struct mesh_path {
|
||||
u8 dst[ETH_ALEN];
|
||||
struct net_device *dev;
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
struct sta_info *next_hop;
|
||||
struct timer_list timer;
|
||||
struct sk_buff_head frame_queue;
|
||||
@ -203,59 +203,66 @@ int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);
|
||||
int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
int mesh_rmc_check(u8 *addr, struct ieee80211s_hdr *mesh_hdr,
|
||||
struct net_device *dev);
|
||||
bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev);
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
bool mesh_matches_local(struct ieee802_11_elems *ie,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_ids_set_default(struct ieee80211_if_sta *sta);
|
||||
void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev);
|
||||
void mesh_rmc_free(struct net_device *dev);
|
||||
int mesh_rmc_init(struct net_device *dev);
|
||||
void mesh_mgmt_ies_add(struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_rmc_free(struct ieee80211_sub_if_data *sdata);
|
||||
int mesh_rmc_init(struct ieee80211_sub_if_data *sdata);
|
||||
void ieee80211s_init(void);
|
||||
void ieee80211s_stop(void);
|
||||
void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata);
|
||||
|
||||
/* Mesh paths */
|
||||
int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev);
|
||||
void mesh_path_start_discovery(struct net_device *dev);
|
||||
struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev);
|
||||
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev);
|
||||
int mesh_nexthop_lookup(struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata);
|
||||
struct mesh_path *mesh_path_lookup(u8 *dst,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
struct mesh_path *mesh_path_lookup_by_idx(int idx,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop);
|
||||
void mesh_path_expire(struct net_device *dev);
|
||||
void mesh_path_flush(struct net_device *dev);
|
||||
void mesh_rx_path_sel_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
size_t len);
|
||||
int mesh_path_add(u8 *dst, struct net_device *dev);
|
||||
void mesh_path_expire(struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_path_flush(struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_rx_path_sel_frame(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt, size_t len);
|
||||
int mesh_path_add(u8 *dst, struct ieee80211_sub_if_data *sdata);
|
||||
/* Mesh plinks */
|
||||
void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev,
|
||||
bool add);
|
||||
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie,
|
||||
struct net_device *dev);
|
||||
void mesh_neighbour_update(u8 *hw_addr, u64 rates,
|
||||
struct ieee80211_sub_if_data *sdata, bool add);
|
||||
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie);
|
||||
void mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_plink_broken(struct sta_info *sta);
|
||||
void mesh_plink_deactivate(struct sta_info *sta);
|
||||
int mesh_plink_open(struct sta_info *sta);
|
||||
int mesh_plink_close(struct sta_info *sta);
|
||||
void mesh_plink_block(struct sta_info *sta);
|
||||
void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
size_t len, struct ieee80211_rx_status *rx_status);
|
||||
void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt, size_t len,
|
||||
struct ieee80211_rx_status *rx_status);
|
||||
|
||||
/* Private interfaces */
|
||||
/* Mesh tables */
|
||||
struct mesh_table *mesh_table_alloc(int size_order);
|
||||
void mesh_table_free(struct mesh_table *tbl, bool free_leafs);
|
||||
struct mesh_table *mesh_table_grow(struct mesh_table *tbl);
|
||||
u32 mesh_table_hash(u8 *addr, struct net_device *dev, struct mesh_table *tbl);
|
||||
u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata,
|
||||
struct mesh_table *tbl);
|
||||
/* Mesh paths */
|
||||
int mesh_path_error_tx(u8 *dest, __le32 dest_dsn, u8 *ra,
|
||||
struct net_device *dev);
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta);
|
||||
void mesh_path_flush_pending(struct mesh_path *mpath);
|
||||
void mesh_path_tx_pending(struct mesh_path *mpath);
|
||||
int mesh_pathtbl_init(void);
|
||||
void mesh_pathtbl_unregister(void);
|
||||
int mesh_path_del(u8 *addr, struct net_device *dev);
|
||||
int mesh_path_del(u8 *addr, struct ieee80211_sub_if_data *sdata);
|
||||
void mesh_path_timer(unsigned long data);
|
||||
void mesh_path_flush_by_nexthop(struct sta_info *sta);
|
||||
void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev);
|
||||
void mesh_path_discard_frame(struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata);
|
||||
|
||||
#ifdef CONFIG_MAC80211_MESH
|
||||
extern int mesh_allocated;
|
||||
|
||||
@ -82,9 +82,9 @@ enum mpath_frame_type {
|
||||
static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
|
||||
u8 *orig_addr, __le32 orig_dsn, u8 dst_flags, u8 *dst,
|
||||
__le32 dst_dsn, u8 *da, u8 hop_count, u8 ttl, __le32 lifetime,
|
||||
__le32 metric, __le32 preq_id, struct net_device *dev)
|
||||
__le32 metric, __le32 preq_id, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
|
||||
struct ieee80211_mgmt *mgmt;
|
||||
u8 *pos;
|
||||
@ -103,7 +103,7 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
|
||||
IEEE80211_STYPE_ACTION);
|
||||
|
||||
memcpy(mgmt->da, da, ETH_ALEN);
|
||||
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
|
||||
memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
|
||||
/* BSSID is left zeroed, wildcard value */
|
||||
mgmt->u.action.category = MESH_PATH_SEL_CATEGORY;
|
||||
mgmt->u.action.u.mesh_action.action_code = action;
|
||||
@ -149,7 +149,7 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
|
||||
pos += ETH_ALEN;
|
||||
memcpy(pos, &dst_dsn, 4);
|
||||
|
||||
ieee80211_sta_tx(dev, skb, 0);
|
||||
ieee80211_sta_tx(sdata, skb, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -161,9 +161,9 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
|
||||
* @ra: node this frame is addressed to
|
||||
*/
|
||||
int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
|
||||
struct net_device *dev)
|
||||
struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
|
||||
struct ieee80211_mgmt *mgmt;
|
||||
u8 *pos;
|
||||
@ -182,7 +182,7 @@ int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
|
||||
IEEE80211_STYPE_ACTION);
|
||||
|
||||
memcpy(mgmt->da, ra, ETH_ALEN);
|
||||
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
|
||||
memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
|
||||
/* BSSID is left zeroed, wildcard value */
|
||||
mgmt->u.action.category = MESH_PATH_SEL_CATEGORY;
|
||||
mgmt->u.action.u.mesh_action.action_code = MPATH_PERR;
|
||||
@ -198,7 +198,7 @@ int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
|
||||
pos += ETH_ALEN;
|
||||
memcpy(pos, &dst_dsn, 4);
|
||||
|
||||
ieee80211_sta_tx(dev, skb, 0);
|
||||
ieee80211_sta_tx(sdata, skb, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -233,7 +233,7 @@ static u32 airtime_link_metric_get(struct ieee80211_local *local,
|
||||
/**
|
||||
* hwmp_route_info_get - Update routing info to originator and transmitter
|
||||
*
|
||||
* @dev: local mesh interface
|
||||
* @sdata: local mesh subif
|
||||
* @mgmt: mesh management frame
|
||||
* @hwmp_ie: hwmp information element (PREP or PREQ)
|
||||
*
|
||||
@ -246,11 +246,11 @@ static u32 airtime_link_metric_get(struct ieee80211_local *local,
|
||||
* Notes: this function is the only place (besides user-provided info) where
|
||||
* path routing information is updated.
|
||||
*/
|
||||
static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
static u32 hwmp_route_info_get(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt,
|
||||
u8 *hwmp_ie)
|
||||
{
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct mesh_path *mpath;
|
||||
struct sta_info *sta;
|
||||
bool fresh_info;
|
||||
@ -301,14 +301,14 @@ static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
new_metric = MAX_METRIC;
|
||||
exp_time = TU_TO_EXP_TIME(orig_lifetime);
|
||||
|
||||
if (memcmp(orig_addr, dev->dev_addr, ETH_ALEN) == 0) {
|
||||
if (memcmp(orig_addr, sdata->dev->dev_addr, ETH_ALEN) == 0) {
|
||||
/* This MP is the originator, we are not interested in this
|
||||
* frame, except for updating transmitter's path info.
|
||||
*/
|
||||
process = false;
|
||||
fresh_info = false;
|
||||
} else {
|
||||
mpath = mesh_path_lookup(orig_addr, dev);
|
||||
mpath = mesh_path_lookup(orig_addr, sdata);
|
||||
if (mpath) {
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
if (mpath->flags & MESH_PATH_FIXED)
|
||||
@ -324,8 +324,8 @@ static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
}
|
||||
}
|
||||
} else {
|
||||
mesh_path_add(orig_addr, dev);
|
||||
mpath = mesh_path_lookup(orig_addr, dev);
|
||||
mesh_path_add(orig_addr, sdata);
|
||||
mpath = mesh_path_lookup(orig_addr, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return 0;
|
||||
@ -357,7 +357,7 @@ static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
else {
|
||||
fresh_info = true;
|
||||
|
||||
mpath = mesh_path_lookup(ta, dev);
|
||||
mpath = mesh_path_lookup(ta, sdata);
|
||||
if (mpath) {
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
if ((mpath->flags & MESH_PATH_FIXED) ||
|
||||
@ -365,8 +365,8 @@ static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
(last_hop_metric > mpath->metric)))
|
||||
fresh_info = false;
|
||||
} else {
|
||||
mesh_path_add(ta, dev);
|
||||
mpath = mesh_path_lookup(ta, dev);
|
||||
mesh_path_add(ta, sdata);
|
||||
mpath = mesh_path_lookup(ta, sdata);
|
||||
if (!mpath) {
|
||||
rcu_read_unlock();
|
||||
return 0;
|
||||
@ -392,10 +392,9 @@ static u32 hwmp_route_info_get(struct net_device *dev,
|
||||
return process ? new_metric : 0;
|
||||
}
|
||||
|
||||
static void hwmp_preq_frame_process(struct net_device *dev,
|
||||
static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt,
|
||||
u8 *preq_elem, u32 metric) {
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_if_sta *ifsta = &sdata->u.sta;
|
||||
struct mesh_path *mpath;
|
||||
u8 *dst_addr, *orig_addr;
|
||||
@ -411,7 +410,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
|
||||
orig_dsn = PREQ_IE_ORIG_DSN(preq_elem);
|
||||
dst_flags = PREQ_IE_DST_F(preq_elem);
|
||||
|
||||
if (memcmp(dst_addr, dev->dev_addr, ETH_ALEN) == 0) {
|
||||
if (memcmp(dst_addr, sdata->dev->dev_addr, ETH_ALEN) == 0) {
|
||||
forward = false;
|
||||
reply = true;
|
||||
metric = 0;
|
||||
@ -423,7 +422,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
|
||||
}
|
||||
} else {
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(dst_addr, dev);
|
||||
mpath = mesh_path_lookup(dst_addr, sdata);
|
||||
if (mpath) {
|
||||
if ((!(mpath->flags & MESH_PATH_DSN_VALID)) ||
|
||||
DSN_LT(mpath->dsn, dst_dsn)) {
|
||||
@ -451,7 +450,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
|
||||
cpu_to_le32(dst_dsn), 0, orig_addr,
|
||||
cpu_to_le32(orig_dsn), mgmt->sa, 0, ttl,
|
||||
cpu_to_le32(lifetime), cpu_to_le32(metric),
|
||||
0, dev);
|
||||
0, sdata);
|
||||
else
|
||||
ifsta->mshstats.dropped_frames_ttl++;
|
||||
}
|
||||
@ -472,20 +471,19 @@ static void hwmp_preq_frame_process(struct net_device *dev,
|
||||
hopcount = PREQ_IE_HOPCOUNT(preq_elem) + 1;
|
||||
mesh_path_sel_frame_tx(MPATH_PREQ, flags, orig_addr,
|
||||
cpu_to_le32(orig_dsn), dst_flags, dst_addr,
|
||||
cpu_to_le32(dst_dsn), dev->broadcast,
|
||||
cpu_to_le32(dst_dsn), sdata->dev->broadcast,
|
||||
hopcount, ttl, cpu_to_le32(lifetime),
|
||||
cpu_to_le32(metric), cpu_to_le32(preq_id),
|
||||
dev);
|
||||
sdata);
|
||||
ifsta->mshstats.fwded_frames++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void hwmp_prep_frame_process(struct net_device *dev,
|
||||
static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt,
|
||||
u8 *prep_elem, u32 metric)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct mesh_path *mpath;
|
||||
u8 *dst_addr, *orig_addr;
|
||||
u8 ttl, hopcount, flags;
|
||||
@ -499,7 +497,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
|
||||
* replies
|
||||
*/
|
||||
dst_addr = PREP_IE_DST_ADDR(prep_elem);
|
||||
if (memcmp(dst_addr, dev->dev_addr, ETH_ALEN) == 0)
|
||||
if (memcmp(dst_addr, sdata->dev->dev_addr, ETH_ALEN) == 0)
|
||||
/* destination, no forwarding required */
|
||||
return;
|
||||
|
||||
@ -510,7 +508,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
|
||||
}
|
||||
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(dst_addr, dev);
|
||||
mpath = mesh_path_lookup(dst_addr, sdata);
|
||||
if (mpath)
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
else
|
||||
@ -533,7 +531,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
|
||||
cpu_to_le32(orig_dsn), 0, dst_addr,
|
||||
cpu_to_le32(dst_dsn), mpath->next_hop->addr, hopcount, ttl,
|
||||
cpu_to_le32(lifetime), cpu_to_le32(metric),
|
||||
0, dev);
|
||||
0, sdata);
|
||||
rcu_read_unlock();
|
||||
sdata->u.sta.mshstats.fwded_frames++;
|
||||
return;
|
||||
@ -544,7 +542,7 @@ fail:
|
||||
return;
|
||||
}
|
||||
|
||||
static void hwmp_perr_frame_process(struct net_device *dev,
|
||||
static void hwmp_perr_frame_process(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt, u8 *perr_elem)
|
||||
{
|
||||
struct mesh_path *mpath;
|
||||
@ -555,7 +553,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
|
||||
dst_addr = PERR_IE_DST_ADDR(perr_elem);
|
||||
dst_dsn = PERR_IE_DST_DSN(perr_elem);
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(dst_addr, dev);
|
||||
mpath = mesh_path_lookup(dst_addr, sdata);
|
||||
if (mpath) {
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
if (mpath->flags & MESH_PATH_ACTIVE &&
|
||||
@ -566,7 +564,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
|
||||
mpath->dsn = dst_dsn;
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
mesh_path_error_tx(dst_addr, cpu_to_le32(dst_dsn),
|
||||
dev->broadcast, dev);
|
||||
sdata->dev->broadcast, sdata);
|
||||
} else
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
}
|
||||
@ -575,7 +573,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
|
||||
|
||||
|
||||
|
||||
void mesh_rx_path_sel_frame(struct net_device *dev,
|
||||
void mesh_rx_path_sel_frame(struct ieee80211_sub_if_data *sdata,
|
||||
struct ieee80211_mgmt *mgmt,
|
||||
size_t len)
|
||||
{
|
||||
@ -592,25 +590,25 @@ void mesh_rx_path_sel_frame(struct net_device *dev,
|
||||
if (!elems.preq || elems.preq_len != 37)
|
||||
/* Right now we support just 1 destination and no AE */
|
||||
return;
|
||||
last_hop_metric = hwmp_route_info_get(dev, mgmt, elems.preq);
|
||||
last_hop_metric = hwmp_route_info_get(sdata, mgmt, elems.preq);
|
||||
if (!last_hop_metric)
|
||||
return;
|
||||
hwmp_preq_frame_process(dev, mgmt, elems.preq, last_hop_metric);
|
||||
hwmp_preq_frame_process(sdata, mgmt, elems.preq, last_hop_metric);
|
||||
break;
|
||||
case MPATH_PREP:
|
||||
if (!elems.prep || elems.prep_len != 31)
|
||||
/* Right now we support no AE */
|
||||
return;
|
||||
last_hop_metric = hwmp_route_info_get(dev, mgmt, elems.prep);
|
||||
last_hop_metric = hwmp_route_info_get(sdata, mgmt, elems.prep);
|
||||
if (!last_hop_metric)
|
||||
return;
|
||||
hwmp_prep_frame_process(dev, mgmt, elems.prep, last_hop_metric);
|
||||
hwmp_prep_frame_process(sdata, mgmt, elems.prep, last_hop_metric);
|
||||
break;
|
||||
case MPATH_PERR:
|
||||
if (!elems.perr || elems.perr_len != 12)
|
||||
/* Right now we support only one destination per PERR */
|
||||
return;
|
||||
hwmp_perr_frame_process(dev, mgmt, elems.perr);
|
||||
hwmp_perr_frame_process(sdata, mgmt, elems.perr);
|
||||
default:
|
||||
return;
|
||||
}
|
||||
@ -628,8 +626,7 @@ void mesh_rx_path_sel_frame(struct net_device *dev,
|
||||
*/
|
||||
static void mesh_queue_preq(struct mesh_path *mpath, u8 flags)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata =
|
||||
IEEE80211_DEV_TO_SUB_IF(mpath->dev);
|
||||
struct ieee80211_sub_if_data *sdata = mpath->sdata;
|
||||
struct ieee80211_if_sta *ifsta = &sdata->u.sta;
|
||||
struct mesh_preq_queue *preq_node;
|
||||
|
||||
@ -672,12 +669,10 @@ static void mesh_queue_preq(struct mesh_path *mpath, u8 flags)
|
||||
/**
|
||||
* mesh_path_start_discovery - launch a path discovery from the PREQ queue
|
||||
*
|
||||
* @dev: local mesh interface
|
||||
* @sdata: local mesh subif
|
||||
*/
|
||||
void mesh_path_start_discovery(struct net_device *dev)
|
||||
void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata =
|
||||
IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_if_sta *ifsta = &sdata->u.sta;
|
||||
struct mesh_preq_queue *preq_node;
|
||||
struct mesh_path *mpath;
|
||||
@ -699,7 +694,7 @@ void mesh_path_start_discovery(struct net_device *dev)
|
||||
spin_unlock(&ifsta->mesh_preq_queue_lock);
|
||||
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(preq_node->dst, dev);
|
||||
mpath = mesh_path_lookup(preq_node->dst, sdata);
|
||||
if (!mpath)
|
||||
goto enddiscovery;
|
||||
|
||||
@ -743,11 +738,11 @@ void mesh_path_start_discovery(struct net_device *dev)
|
||||
dst_flags = MP_F_RF;
|
||||
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
mesh_path_sel_frame_tx(MPATH_PREQ, 0, dev->dev_addr,
|
||||
mesh_path_sel_frame_tx(MPATH_PREQ, 0, sdata->dev->dev_addr,
|
||||
cpu_to_le32(ifsta->dsn), dst_flags, mpath->dst,
|
||||
cpu_to_le32(mpath->dsn), dev->broadcast, 0,
|
||||
cpu_to_le32(mpath->dsn), sdata->dev->broadcast, 0,
|
||||
ttl, cpu_to_le32(lifetime), 0,
|
||||
cpu_to_le32(ifsta->preq_id++), dev);
|
||||
cpu_to_le32(ifsta->preq_id++), sdata);
|
||||
mod_timer(&mpath->timer, jiffies + mpath->discovery_timeout);
|
||||
|
||||
enddiscovery:
|
||||
@ -759,7 +754,7 @@ enddiscovery:
|
||||
* ieee80211s_lookup_nexthop - put the appropriate next hop on a mesh frame
|
||||
*
|
||||
* @skb: 802.11 frame to be sent
|
||||
* @dev: network device the frame will be sent through
|
||||
* @sdata: network subif the frame will be sent through
|
||||
* @fwd_frame: true if this frame was originally from a different host
|
||||
*
|
||||
* Returns: 0 if the next hop was found. Nonzero otherwise. If no next hop is
|
||||
@ -767,9 +762,9 @@ enddiscovery:
|
||||
* sent when the path is resolved. This means the caller must not free the skb
|
||||
* in this case.
|
||||
*/
|
||||
int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
|
||||
int mesh_nexthop_lookup(struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct sk_buff *skb_to_free = NULL;
|
||||
struct mesh_path *mpath;
|
||||
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
||||
@ -777,11 +772,11 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
|
||||
int err = 0;
|
||||
|
||||
rcu_read_lock();
|
||||
mpath = mesh_path_lookup(dst_addr, dev);
|
||||
mpath = mesh_path_lookup(dst_addr, sdata);
|
||||
|
||||
if (!mpath) {
|
||||
mesh_path_add(dst_addr, dev);
|
||||
mpath = mesh_path_lookup(dst_addr, dev);
|
||||
mesh_path_add(dst_addr, sdata);
|
||||
mpath = mesh_path_lookup(dst_addr, sdata);
|
||||
if (!mpath) {
|
||||
dev_kfree_skb(skb);
|
||||
sdata->u.sta.mshstats.dropped_frames_no_route++;
|
||||
@ -793,7 +788,8 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
|
||||
if (mpath->flags & MESH_PATH_ACTIVE) {
|
||||
if (time_after(jiffies, mpath->exp_time -
|
||||
msecs_to_jiffies(sdata->u.sta.mshcfg.path_refresh_time))
|
||||
&& !memcmp(dev->dev_addr, hdr->addr4, ETH_ALEN)
|
||||
&& !memcmp(sdata->dev->dev_addr, hdr->addr4,
|
||||
ETH_ALEN)
|
||||
&& !(mpath->flags & MESH_PATH_RESOLVING)
|
||||
&& !(mpath->flags & MESH_PATH_FIXED)) {
|
||||
mesh_queue_preq(mpath,
|
||||
@ -815,7 +811,7 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
|
||||
|
||||
skb_queue_tail(&mpath->frame_queue, skb);
|
||||
if (skb_to_free)
|
||||
mesh_path_discard_frame(skb_to_free, dev);
|
||||
mesh_path_discard_frame(skb_to_free, sdata);
|
||||
err = -ENOENT;
|
||||
}
|
||||
|
||||
@ -835,7 +831,7 @@ void mesh_path_timer(unsigned long data)
|
||||
if (!mpath)
|
||||
goto endmpathtimer;
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(mpath->dev);
|
||||
sdata = mpath->sdata;
|
||||
if (mpath->flags & MESH_PATH_RESOLVED ||
|
||||
(!(mpath->flags & MESH_PATH_RESOLVING)))
|
||||
mpath->flags &= ~(MESH_PATH_RESOLVING | MESH_PATH_RESOLVED);
|
||||
|
||||
@ -9,7 +9,6 @@
|
||||
|
||||
#include <linux/etherdevice.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/string.h>
|
||||
@ -62,13 +61,13 @@ void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta)
|
||||
/**
|
||||
* mesh_path_lookup - look up a path in the mesh path table
|
||||
* @dst: hardware address (ETH_ALEN length) of destination
|
||||
* @dev: local interface
|
||||
* @sdata: local subif
|
||||
*
|
||||
* Returns: pointer to the mesh path structure, or NULL if not found
|
||||
*
|
||||
* Locking: must be called within a read rcu section.
|
||||
*/
|
||||
struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev)
|
||||
struct mesh_path *mesh_path_lookup(u8 *dst, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct mesh_path *mpath;
|
||||
struct hlist_node *n;
|
||||
@ -78,10 +77,10 @@ struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev)
|
||||
|
||||
tbl = rcu_dereference(mesh_paths);
|
||||
|
||||
bucket = &tbl->hash_buckets[mesh_table_hash(dst, dev, tbl)];
|
||||
bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
|
||||
hlist_for_each_entry_rcu(node, n, bucket, list) {
|
||||
mpath = node->mpath;
|
||||
if (mpath->dev == dev &&
|
||||
if (mpath->sdata == sdata &&
|
||||
memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
|
||||
if (MPATH_EXPIRED(mpath)) {
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
@ -98,13 +97,13 @@ struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev)
|
||||
/**
|
||||
* mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
|
||||
* @idx: index
|
||||
* @dev: local interface, or NULL for all entries
|
||||
* @sdata: local subif, or NULL for all entries
|
||||
*
|
||||
* Returns: pointer to the mesh path structure, or NULL if not found.
|
||||
*
|
||||
* Locking: must be called within a read rcu section.
|
||||
*/
|
||||
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev)
|
||||
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct mpath_node *node;
|
||||
struct hlist_node *p;
|
||||
@ -112,7 +111,7 @@ struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev)
|
||||
int j = 0;
|
||||
|
||||
for_each_mesh_entry(mesh_paths, p, node, i) {
|
||||
if (dev && node->mpath->dev != dev)
|
||||
if (sdata && node->mpath->sdata != sdata)
|
||||
continue;
|
||||
if (j++ == idx) {
|
||||
if (MPATH_EXPIRED(node->mpath)) {
|
||||
@ -131,15 +130,14 @@ struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev)
|
||||
/**
|
||||
* mesh_path_add - allocate and add a new path to the mesh path table
|
||||
* @addr: destination address of the path (ETH_ALEN length)
|
||||
* @dev: local interface
|
||||
* @sdata: local subif
|
||||
*
|
||||
* Returns: 0 on sucess
|
||||
*
|
||||
* State: the initial state of the new path is set to 0
|
||||
*/
|
||||
int mesh_path_add(u8 *dst, struct net_device *dev)
|
||||
int mesh_path_add(u8 *dst, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct mesh_path *mpath, *new_mpath;
|
||||
struct mpath_node *node, *new_node;
|
||||
struct hlist_head *bucket;
|
||||
@ -148,7 +146,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
|
||||
int err = 0;
|
||||
u32 hash_idx;
|
||||
|
||||
if (memcmp(dst, dev->dev_addr, ETH_ALEN) == 0)
|
||||
if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
|
||||
/* never add ourselves as neighbours */
|
||||
return -ENOTSUPP;
|
||||
|
||||
@ -169,7 +167,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
|
||||
|
||||
read_lock(&pathtbl_resize_lock);
|
||||
memcpy(new_mpath->dst, dst, ETH_ALEN);
|
||||
new_mpath->dev = dev;
|
||||
new_mpath->sdata = sdata;
|
||||
new_mpath->flags = 0;
|
||||
skb_queue_head_init(&new_mpath->frame_queue);
|
||||
new_node->mpath = new_mpath;
|
||||
@ -179,7 +177,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
|
||||
spin_lock_init(&new_mpath->state_lock);
|
||||
init_timer(&new_mpath->timer);
|
||||
|
||||
hash_idx = mesh_table_hash(dst, dev, mesh_paths);
|
||||
hash_idx = mesh_table_hash(dst, sdata, mesh_paths);
|
||||
bucket = &mesh_paths->hash_buckets[hash_idx];
|
||||
|
||||
spin_lock(&mesh_paths->hashwlock[hash_idx]);
|
||||
@ -187,7 +185,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
|
||||
err = -EEXIST;
|
||||
hlist_for_each_entry(node, n, bucket, list) {
|
||||
mpath = node->mpath;
|
||||
if (mpath->dev == dev && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
|
||||
if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
|
||||
goto err_exists;
|
||||
}
|
||||
|
||||
@ -241,7 +239,7 @@ void mesh_plink_broken(struct sta_info *sta)
|
||||
struct mesh_path *mpath;
|
||||
struct mpath_node *node;
|
||||
struct hlist_node *p;
|
||||
struct net_device *dev = sta->sdata->dev;
|
||||
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
@ -256,7 +254,7 @@ void mesh_plink_broken(struct sta_info *sta)
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
mesh_path_error_tx(mpath->dst,
|
||||
cpu_to_le32(mpath->dsn),
|
||||
dev->broadcast, dev);
|
||||
sdata->dev->broadcast, sdata);
|
||||
} else
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
}
|
||||
@ -284,11 +282,11 @@ void mesh_path_flush_by_nexthop(struct sta_info *sta)
|
||||
for_each_mesh_entry(mesh_paths, p, node, i) {
|
||||
mpath = node->mpath;
|
||||
if (mpath->next_hop == sta)
|
||||
mesh_path_del(mpath->dst, mpath->dev);
|
||||
mesh_path_del(mpath->dst, mpath->sdata);
|
||||
}
|
||||
}
|
||||
|
||||
void mesh_path_flush(struct net_device *dev)
|
||||
void mesh_path_flush(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct mesh_path *mpath;
|
||||
struct mpath_node *node;
|
||||
@ -297,16 +295,15 @@ void mesh_path_flush(struct net_device *dev)
|
||||
|
||||
for_each_mesh_entry(mesh_paths, p, node, i) {
|
||||
mpath = node->mpath;
|
||||
if (mpath->dev == dev)
|
||||
mesh_path_del(mpath->dst, mpath->dev);
|
||||
if (mpath->sdata == sdata)
|
||||
mesh_path_del(mpath->dst, mpath->sdata);
|
||||
}
|
||||
}
|
||||
|
||||
static void mesh_path_node_reclaim(struct rcu_head *rp)
|
||||
{
|
||||
struct mpath_node *node = container_of(rp, struct mpath_node, rcu);
|
||||
struct ieee80211_sub_if_data *sdata =
|
||||
IEEE80211_DEV_TO_SUB_IF(node->mpath->dev);
|
||||
struct ieee80211_sub_if_data *sdata = node->mpath->sdata;
|
||||
|
||||
del_timer_sync(&node->mpath->timer);
|
||||
atomic_dec(&sdata->u.sta.mpaths);
|
||||
@ -318,11 +315,11 @@ static void mesh_path_node_reclaim(struct rcu_head *rp)
|
||||
* mesh_path_del - delete a mesh path from the table
|
||||
*
|
||||
* @addr: dst address (ETH_ALEN length)
|
||||
* @dev: local interface
|
||||
* @sdata: local subif
|
||||
*
|
||||
* Returns: 0 if succesful
|
||||
*/
|
||||
int mesh_path_del(u8 *addr, struct net_device *dev)
|
||||
int mesh_path_del(u8 *addr, struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct mesh_path *mpath;
|
||||
struct mpath_node *node;
|
||||
@ -332,13 +329,13 @@ int mesh_path_del(u8 *addr, struct net_device *dev)
|
||||
int err = 0;
|
||||
|
||||
read_lock(&pathtbl_resize_lock);
|
||||
hash_idx = mesh_table_hash(addr, dev, mesh_paths);
|
||||
hash_idx = mesh_table_hash(addr, sdata, mesh_paths);
|
||||
bucket = &mesh_paths->hash_buckets[hash_idx];
|
||||
|
||||
spin_lock(&mesh_paths->hashwlock[hash_idx]);
|
||||
hlist_for_each_entry(node, n, bucket, list) {
|
||||
mpath = node->mpath;
|
||||
if (mpath->dev == dev &&
|
||||
if (mpath->sdata == sdata &&
|
||||
memcmp(addr, mpath->dst, ETH_ALEN) == 0) {
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
mpath->flags |= MESH_PATH_RESOLVING;
|
||||
@ -378,29 +375,29 @@ void mesh_path_tx_pending(struct mesh_path *mpath)
|
||||
* mesh_path_discard_frame - discard a frame whose path could not be resolved
|
||||
*
|
||||
* @skb: frame to discard
|
||||
* @dev: network device the frame was to be sent through
|
||||
* @sdata: network subif the frame was to be sent through
|
||||
*
|
||||
* If the frame was beign forwarded from another MP, a PERR frame will be sent
|
||||
* to the precursor.
|
||||
*
|
||||
* Locking: the function must me called within a rcu_read_lock region
|
||||
*/
|
||||
void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev)
|
||||
void mesh_path_discard_frame(struct sk_buff *skb,
|
||||
struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
||||
struct mesh_path *mpath;
|
||||
u32 dsn = 0;
|
||||
|
||||
if (memcmp(hdr->addr4, dev->dev_addr, ETH_ALEN) != 0) {
|
||||
if (memcmp(hdr->addr4, sdata->dev->dev_addr, ETH_ALEN) != 0) {
|
||||
u8 *ra, *da;
|
||||
|
||||
da = hdr->addr3;
|
||||
ra = hdr->addr2;
|
||||
mpath = mesh_path_lookup(da, dev);
|
||||
mpath = mesh_path_lookup(da, sdata);
|
||||
if (mpath)
|
||||
dsn = ++mpath->dsn;
|
||||
mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, dev);
|
||||
mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, sdata);
|
||||
}
|
||||
|
||||
kfree_skb(skb);
|
||||
@ -416,14 +413,11 @@ void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev)
|
||||
*/
|
||||
void mesh_path_flush_pending(struct mesh_path *mpath)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
struct sk_buff *skb;
|
||||
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(mpath->dev);
|
||||
|
||||
while ((skb = skb_dequeue(&mpath->frame_queue)) &&
|
||||
(mpath->flags & MESH_PATH_ACTIVE))
|
||||
mesh_path_discard_frame(skb, mpath->dev);
|
||||
mesh_path_discard_frame(skb, mpath->sdata);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -472,7 +466,7 @@ static int mesh_path_node_copy(struct hlist_node *p, struct mesh_table *newtbl)
|
||||
node = hlist_entry(p, struct mpath_node, list);
|
||||
mpath = node->mpath;
|
||||
new_node->mpath = mpath;
|
||||
hash_idx = mesh_table_hash(mpath->dst, mpath->dev, newtbl);
|
||||
hash_idx = mesh_table_hash(mpath->dst, mpath->sdata, newtbl);
|
||||
hlist_add_head(&new_node->list,
|
||||
&newtbl->hash_buckets[hash_idx]);
|
||||
return 0;
|
||||
@ -489,7 +483,7 @@ int mesh_pathtbl_init(void)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mesh_path_expire(struct net_device *dev)
|
||||
void mesh_path_expire(struct ieee80211_sub_if_data *sdata)
|
||||
{
|
||||
struct mesh_path *mpath;
|
||||
struct mpath_node *node;
|
||||
@ -498,7 +492,7 @@ void mesh_path_expire(struct net_device *dev)
|
||||
|
||||
read_lock(&pathtbl_resize_lock);
|
||||
for_each_mesh_entry(mesh_paths, p, node, i) {
|
||||
if (node->mpath->dev != dev)
|
||||
if (node->mpath->sdata != sdata)
|
||||
continue;
|
||||
mpath = node->mpath;
|
||||
spin_lock_bh(&mpath->state_lock);
|
||||
@ -507,7 +501,7 @@ void mesh_path_expire(struct net_device *dev)
|
||||
time_after(jiffies,
|
||||
mpath->exp_time + MESH_PATH_EXPIRE)) {
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
mesh_path_del(mpath->dst, mpath->dev);
|
||||
mesh_path_del(mpath->dst, mpath->sdata);
|
||||
} else
|
||||
spin_unlock_bh(&mpath->state_lock);
|
||||
}
|
||||
|
||||
@ -144,10 +144,10 @@ void mesh_plink_deactivate(struct sta_info *sta)
|
||||
spin_unlock_bh(&sta->lock);
|
||||
}
|
||||
|
||||
static int mesh_plink_frame_tx(struct net_device *dev,
|
||||
static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
|
||||
enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
|
||||
__le16 reason) {
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
|
||||
struct ieee80211_mgmt *mgmt;
|
||||
bool include_plid = false;
|
||||
@ -166,7 +166,7 @@ static int mesh_plink_frame_tx(struct net_device *dev,
|
||||
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
||||
IEEE80211_STYPE_ACTION);
|
||||
memcpy(mgmt->da, da, ETH_ALEN);
|
||||
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
|
||||
memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
|
||||
/* BSSID is left zeroed, wildcard value */
|
||||
mgmt->u.action.category = PLINK_CATEGORY;
|
||||
mgmt->u.action.u.plink_action.action_code = action;
|
||||
@ -180,7 +180,7 @@ static int mesh_plink_frame_tx(struct net_device *dev,
|
||||
/* two-byte status code followed by two-byte AID */
|
||||
memset(pos, 0, 4);
|
||||
}
|
||||
mesh_mgmt_ies_add(skb, dev);
|
||||
mesh_mgmt_ies_add(skb, sdata);
|
||||
}
|
||||
|
||||
/* Add Peer Link Management element */
|
||||
@ -217,15 +217,14 @@ static int mesh_plink_frame_tx(struct net_device *dev,
|
||||
memcpy(pos, &reason, 2);
|
||||
}
|
||||
|
||||
ieee80211_sta_tx(dev, skb, 0);
|
||||
ieee80211_sta_tx(sdata, skb, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev,
|
||||
void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct ieee80211_sub_if_data *sdata,
|
||||
bool peer_accepting_plinks)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct sta_info *sta;
|
||||
|
||||
rcu_read_lock();
|
||||
@ -257,7 +256,6 @@ static void mesh_plink_timer(unsigned long data)
|
||||
{
|
||||
struct sta_info *sta;
|
||||
__le16 llid, plid, reason;
|
||||
struct net_device *dev = NULL;
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
|
||||
DECLARE_MAC_BUF(mac);
|
||||
@ -282,7 +280,6 @@ static void mesh_plink_timer(unsigned long data)
|
||||
llid = sta->llid;
|
||||
plid = sta->plid;
|
||||
sdata = sta->sdata;
|
||||
dev = sdata->dev;
|
||||
|
||||
switch (sta->plink_state) {
|
||||
case PLINK_OPN_RCVD:
|
||||
@ -299,7 +296,7 @@ static void mesh_plink_timer(unsigned long data)
|
||||
++sta->plink_retries;
|
||||
mod_plink_timer(sta, sta->plink_timeout);
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->addr, llid,
|
||||
0, 0);
|
||||
break;
|
||||
}
|
||||
@ -312,7 +309,7 @@ static void mesh_plink_timer(unsigned long data)
|
||||
sta->plink_state = PLINK_HOLDING;
|
||||
mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, plid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid, plid,
|
||||
reason);
|
||||
break;
|
||||
case PLINK_HOLDING:
|
||||
@ -357,7 +354,7 @@ int mesh_plink_open(struct sta_info *sta)
|
||||
mpl_dbg("Mesh plink: starting establishment with %s\n",
|
||||
print_mac(mac, sta->addr));
|
||||
|
||||
return mesh_plink_frame_tx(sdata->dev, PLINK_OPEN,
|
||||
return mesh_plink_frame_tx(sdata, PLINK_OPEN,
|
||||
sta->addr, llid, 0, 0);
|
||||
}
|
||||
|
||||
@ -403,15 +400,14 @@ int mesh_plink_close(struct sta_info *sta)
|
||||
llid = sta->llid;
|
||||
plid = sta->plid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(sta->sdata->dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sta->sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
|
||||
size_t len, struct ieee80211_rx_status *rx_status)
|
||||
{
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct ieee802_11_elems elems;
|
||||
struct sta_info *sta;
|
||||
@ -478,7 +474,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
|
||||
/* Now we will figure out the appropriate event... */
|
||||
event = PLINK_UNDEFINED;
|
||||
if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, dev))) {
|
||||
if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) {
|
||||
switch (ftype) {
|
||||
case PLINK_OPEN:
|
||||
event = OPN_RJCT;
|
||||
@ -577,9 +573,9 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
sta->llid = llid;
|
||||
mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->addr, llid,
|
||||
0, 0);
|
||||
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr,
|
||||
llid, plid, 0);
|
||||
break;
|
||||
default:
|
||||
@ -604,7 +600,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
break;
|
||||
case OPN_ACPT:
|
||||
@ -613,7 +609,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
sta->plid = plid;
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
|
||||
plid, 0);
|
||||
break;
|
||||
case CNF_ACPT:
|
||||
@ -646,13 +642,13 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
break;
|
||||
case OPN_ACPT:
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
|
||||
plid, 0);
|
||||
break;
|
||||
case CNF_ACPT:
|
||||
@ -685,7 +681,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
break;
|
||||
case OPN_ACPT:
|
||||
@ -695,7 +691,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mpl_dbg("Mesh plink with %s ESTABLISHED\n",
|
||||
print_mac(mac, sta->addr));
|
||||
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
|
||||
plid, 0);
|
||||
break;
|
||||
default:
|
||||
@ -714,13 +710,13 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
llid = sta->llid;
|
||||
mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
break;
|
||||
case OPN_ACPT:
|
||||
llid = sta->llid;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
|
||||
plid, 0);
|
||||
break;
|
||||
default:
|
||||
@ -743,7 +739,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
|
||||
llid = sta->llid;
|
||||
reason = sta->reason;
|
||||
spin_unlock_bh(&sta->lock);
|
||||
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
|
||||
mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
|
||||
plid, reason);
|
||||
break;
|
||||
default:
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -404,11 +404,11 @@ ieee80211_rx_h_passive_scan(struct ieee80211_rx_data *rx)
|
||||
struct sk_buff *skb = rx->skb;
|
||||
|
||||
if (unlikely(local->sta_hw_scanning))
|
||||
return ieee80211_sta_rx_scan(rx->dev, skb, rx->status);
|
||||
return ieee80211_sta_rx_scan(rx->sdata, skb, rx->status);
|
||||
|
||||
if (unlikely(local->sta_sw_scanning)) {
|
||||
/* drop all the other packets during a software scan anyway */
|
||||
if (ieee80211_sta_rx_scan(rx->dev, skb, rx->status)
|
||||
if (ieee80211_sta_rx_scan(rx->sdata, skb, rx->status)
|
||||
!= RX_QUEUED)
|
||||
dev_kfree_skb(skb);
|
||||
return RX_QUEUED;
|
||||
@ -466,7 +466,7 @@ ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
|
||||
|
||||
if (ieee80211_is_data(hdr->frame_control) &&
|
||||
is_multicast_ether_addr(hdr->addr1) &&
|
||||
mesh_rmc_check(hdr->addr4, msh_h_get(hdr, hdrlen), rx->dev))
|
||||
mesh_rmc_check(hdr->addr4, msh_h_get(hdr, hdrlen), rx->sdata))
|
||||
return RX_DROP_MONITOR;
|
||||
#undef msh_h_get
|
||||
|
||||
@ -1523,7 +1523,7 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
|
||||
sdata->vif.type == IEEE80211_IF_TYPE_IBSS ||
|
||||
sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) &&
|
||||
!(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME))
|
||||
ieee80211_sta_rx_mgmt(rx->dev, rx->skb, rx->status);
|
||||
ieee80211_sta_rx_mgmt(sdata, rx->skb, rx->status);
|
||||
else
|
||||
return RX_DROP_MONITOR;
|
||||
|
||||
@ -1570,7 +1570,7 @@ static void ieee80211_rx_michael_mic_report(struct net_device *dev,
|
||||
!ieee80211_is_auth(hdr->frame_control))
|
||||
goto ignore;
|
||||
|
||||
mac80211_ev_michael_mic_failure(rx->dev, keyidx, hdr);
|
||||
mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr);
|
||||
ignore:
|
||||
dev_kfree_skb(rx->skb);
|
||||
rx->skb = NULL;
|
||||
@ -1744,7 +1744,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
|
||||
return 0;
|
||||
if (ieee80211_is_beacon(hdr->frame_control)) {
|
||||
if (!rx->sta)
|
||||
rx->sta = ieee80211_ibss_add_sta(sdata->dev,
|
||||
rx->sta = ieee80211_ibss_add_sta(sdata,
|
||||
rx->skb, bssid, hdr->addr2,
|
||||
BIT(rx->status->rate_idx));
|
||||
return 1;
|
||||
@ -1760,7 +1760,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
|
||||
return 0;
|
||||
rx->flags &= ~IEEE80211_RX_RA_MATCH;
|
||||
} else if (!rx->sta)
|
||||
rx->sta = ieee80211_ibss_add_sta(sdata->dev, rx->skb,
|
||||
rx->sta = ieee80211_ibss_add_sta(sdata, rx->skb,
|
||||
bssid, hdr->addr2,
|
||||
BIT(rx->status->rate_idx));
|
||||
break;
|
||||
@ -2066,7 +2066,7 @@ static u8 ieee80211_rx_reorder_ampdu(struct ieee80211_local *local,
|
||||
/* if this mpdu is fragmented - terminate rx aggregation session */
|
||||
sc = le16_to_cpu(hdr->seq_ctrl);
|
||||
if (sc & IEEE80211_SCTL_FRAG) {
|
||||
ieee80211_sta_stop_rx_ba_session(sta->sdata->dev, sta->addr,
|
||||
ieee80211_sta_stop_rx_ba_session(sta->sdata, sta->addr,
|
||||
tid, 0, WLAN_REASON_QSTA_REQUIRE_SETUP);
|
||||
ret = 1;
|
||||
goto end_reorder;
|
||||
|
||||
@ -1327,7 +1327,7 @@ int ieee80211_master_start_xmit(struct sk_buff *skb,
|
||||
if (is_multicast_ether_addr(hdr->addr3))
|
||||
memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
|
||||
else
|
||||
if (mesh_nexthop_lookup(skb, odev))
|
||||
if (mesh_nexthop_lookup(skb, osdata))
|
||||
return 0;
|
||||
if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0)
|
||||
IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.sta,
|
||||
@ -1908,7 +1908,7 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
|
||||
*pos++ = WLAN_EID_SSID;
|
||||
*pos++ = 0x0;
|
||||
|
||||
mesh_mgmt_ies_add(skb, sdata->dev);
|
||||
mesh_mgmt_ies_add(skb, sdata);
|
||||
|
||||
num_beacons = &sdata->u.sta.num_beacons;
|
||||
} else {
|
||||
|
||||
@ -27,22 +27,19 @@
|
||||
#include "aes_ccm.h"
|
||||
|
||||
|
||||
static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr,
|
||||
static int ieee80211_set_encryption(struct ieee80211_sub_if_data *sdata, u8 *sta_addr,
|
||||
int idx, int alg, int remove,
|
||||
int set_tx_key, const u8 *_key,
|
||||
size_t key_len)
|
||||
{
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
struct sta_info *sta;
|
||||
struct ieee80211_key *key;
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
int err;
|
||||
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
if (idx < 0 || idx >= NUM_DEFAULT_KEYS) {
|
||||
printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
|
||||
dev->name, idx);
|
||||
sdata->dev->name, idx);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@ -127,11 +124,11 @@ static int ieee80211_ioctl_siwgenie(struct net_device *dev,
|
||||
|
||||
if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
|
||||
sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
|
||||
int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length);
|
||||
int ret = ieee80211_sta_set_extra_ie(sdata, extra, data->length);
|
||||
if (ret)
|
||||
return ret;
|
||||
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
|
||||
ieee80211_sta_req_auth(dev, &sdata->u.sta);
|
||||
ieee80211_sta_req_auth(sdata, &sdata->u.sta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -333,12 +330,11 @@ static int ieee80211_ioctl_giwmode(struct net_device *dev,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ieee80211_set_freq(struct net_device *dev, int freqMHz)
|
||||
int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz)
|
||||
{
|
||||
int ret = -EINVAL;
|
||||
struct ieee80211_channel *chan;
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
struct ieee80211_local *local = sdata->local;
|
||||
|
||||
chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);
|
||||
|
||||
@ -346,7 +342,7 @@ int ieee80211_set_freq(struct net_device *dev, int freqMHz)
|
||||
if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
|
||||
chan->flags & IEEE80211_CHAN_NO_IBSS) {
|
||||
printk(KERN_DEBUG "%s: IBSS not allowed on frequency "
|
||||
"%d MHz\n", dev->name, chan->center_freq);
|
||||
"%d MHz\n", sdata->dev->name, chan->center_freq);
|
||||
return ret;
|
||||
}
|
||||
local->oper_channel = chan;
|
||||
@ -379,14 +375,14 @@ static int ieee80211_ioctl_siwfreq(struct net_device *dev,
|
||||
IEEE80211_STA_AUTO_CHANNEL_SEL;
|
||||
return 0;
|
||||
} else
|
||||
return ieee80211_set_freq(dev,
|
||||
return ieee80211_set_freq(sdata,
|
||||
ieee80211_channel_to_frequency(freq->m));
|
||||
} else {
|
||||
int i, div = 1000000;
|
||||
for (i = 0; i < freq->e; i++)
|
||||
div /= 10;
|
||||
if (div > 0)
|
||||
return ieee80211_set_freq(dev, freq->m / div);
|
||||
return ieee80211_set_freq(sdata, freq->m / div);
|
||||
else
|
||||
return -EINVAL;
|
||||
}
|
||||
@ -432,10 +428,10 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
|
||||
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
|
||||
else
|
||||
sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL;
|
||||
ret = ieee80211_sta_set_ssid(dev, ssid, len);
|
||||
ret = ieee80211_sta_set_ssid(sdata, ssid, len);
|
||||
if (ret)
|
||||
return ret;
|
||||
ieee80211_sta_req_auth(dev, &sdata->u.sta);
|
||||
ieee80211_sta_req_auth(sdata, &sdata->u.sta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -460,7 +456,7 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
|
||||
sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
|
||||
int res = ieee80211_sta_get_ssid(dev, ssid, &len);
|
||||
int res = ieee80211_sta_get_ssid(sdata, ssid, &len);
|
||||
if (res == 0) {
|
||||
data->length = len;
|
||||
data->flags = 1;
|
||||
@ -504,10 +500,10 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
|
||||
sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
|
||||
else
|
||||
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
|
||||
ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
|
||||
ret = ieee80211_sta_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
|
||||
if (ret)
|
||||
return ret;
|
||||
ieee80211_sta_req_auth(dev, &sdata->u.sta);
|
||||
ieee80211_sta_req_auth(sdata, &sdata->u.sta);
|
||||
return 0;
|
||||
} else if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
|
||||
/*
|
||||
@ -584,7 +580,7 @@ static int ieee80211_ioctl_siwscan(struct net_device *dev,
|
||||
ssid_len = req->essid_len;
|
||||
}
|
||||
|
||||
return ieee80211_sta_req_scan(dev, ssid, ssid_len);
|
||||
return ieee80211_sta_req_scan(sdata, ssid, ssid_len);
|
||||
}
|
||||
|
||||
|
||||
@ -594,11 +590,14 @@ static int ieee80211_ioctl_giwscan(struct net_device *dev,
|
||||
{
|
||||
int res;
|
||||
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
||||
struct ieee80211_sub_if_data *sdata;
|
||||
|
||||
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
||||
|
||||
if (local->sta_sw_scanning || local->sta_hw_scanning)
|
||||
return -EAGAIN;
|
||||
|
||||
res = ieee80211_sta_scan_results(dev, info, extra, data->length);
|
||||
res = ieee80211_sta_scan_results(local, info, extra, data->length);
|
||||
if (res >= 0) {
|
||||
data->length = res;
|
||||
return 0;
|
||||
@ -894,10 +893,10 @@ static int ieee80211_ioctl_siwmlme(struct net_device *dev,
|
||||
switch (mlme->cmd) {
|
||||
case IW_MLME_DEAUTH:
|
||||
/* TODO: mlme->addr.sa_data */
|
||||
return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
|
||||
return ieee80211_sta_deauthenticate(sdata, mlme->reason_code);
|
||||
case IW_MLME_DISASSOC:
|
||||
/* TODO: mlme->addr.sa_data */
|
||||
return ieee80211_sta_disassociate(dev, mlme->reason_code);
|
||||
return ieee80211_sta_disassociate(sdata, mlme->reason_code);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
@ -938,7 +937,7 @@ static int ieee80211_ioctl_siwencode(struct net_device *dev,
|
||||
}
|
||||
|
||||
return ieee80211_set_encryption(
|
||||
dev, bcaddr,
|
||||
sdata, bcaddr,
|
||||
idx, alg, remove,
|
||||
!sdata->default_key,
|
||||
keybuf, erq->length);
|
||||
@ -1184,7 +1183,7 @@ static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
|
||||
} else
|
||||
idx--;
|
||||
|
||||
return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
|
||||
return ieee80211_set_encryption(sdata, ext->addr.sa_data, idx, alg,
|
||||
remove,
|
||||
ext->ext_flags &
|
||||
IW_ENCODE_EXT_SET_TX_KEY,
|
||||
|
||||
@ -127,7 +127,7 @@ ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
|
||||
if (!(rx->flags & IEEE80211_RX_RA_MATCH))
|
||||
return RX_DROP_UNUSABLE;
|
||||
|
||||
mac80211_ev_michael_mic_failure(rx->dev, rx->key->conf.keyidx,
|
||||
mac80211_ev_michael_mic_failure(rx->sdata, rx->key->conf.keyidx,
|
||||
(void *) skb->data);
|
||||
return RX_DROP_UNUSABLE;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user