blob: af671b984df37123cf6841fb9a8e4e5db70bde65 [file] [log] [blame]
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +01001/*
Rui Paulo264d9b72009-11-09 23:46:58 +00002 * Copyright (c) 2008, 2009 open80211s Ltd.
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +01003 * Author: Luis Carlos Cobo <luisca@cozybit.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09009#include <linux/gfp.h>
Johannes Berg902acc72008-02-23 15:17:19 +010010#include <linux/kernel.h>
11#include <linux/random.h>
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010012#include "ieee80211_i.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040013#include "rate.h"
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010014#include "mesh.h"
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010015
Thomas Pedersen8db09852011-08-12 20:01:00 -070016#define PLINK_GET_LLID(p) (p + 2)
17#define PLINK_GET_PLID(p) (p + 4)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010018
19#define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
20 jiffies + HZ * t / 1000))
21
Johannes Berg472dbc42008-09-11 00:01:49 +020022#define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
23#define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
24#define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
25#define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
26#define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010027
Ashok Nagarajan3d4f9692012-03-06 12:48:30 -080028/* We only need a valid sta if user configured a minimum rssi_threshold. */
29#define rssi_threshold_check(sta, sdata) \
Ashok Nagarajan55335132012-02-28 17:04:08 -080030 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
Ashok Nagarajan3d4f9692012-03-06 12:48:30 -080031 (sta && (s8) -ewma_read(&sta->avg_signal) > \
32 sdata->u.mesh.mshcfg.rssi_threshold))
Ashok Nagarajan55335132012-02-28 17:04:08 -080033
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010034enum plink_event {
35 PLINK_UNDEFINED,
36 OPN_ACPT,
37 OPN_RJCT,
38 OPN_IGNR,
39 CNF_ACPT,
40 CNF_RJCT,
41 CNF_IGNR,
42 CLS_ACPT,
43 CLS_IGNR
44};
45
Thomas Pedersenba4a14e2011-09-20 13:43:32 -070046static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
47 enum ieee80211_self_protected_actioncode action,
48 u8 *da, __le16 llid, __le16 plid, __le16 reason);
49
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010050static inline
51void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
52{
Johannes Berg472dbc42008-09-11 00:01:49 +020053 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
Johannes Bergd0709a62008-02-25 16:27:46 +010054 mesh_accept_plinks_update(sdata);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010055}
56
57static inline
58void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
59{
Johannes Berg472dbc42008-09-11 00:01:49 +020060 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
Johannes Bergd0709a62008-02-25 16:27:46 +010061 mesh_accept_plinks_update(sdata);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010062}
63
64/**
65 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
66 *
Rui Paulo23c7a292009-11-09 23:46:42 +000067 * @sta: mesh peer link to restart
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010068 *
Johannes Berg07346f812008-05-03 01:02:02 +020069 * Locking: this function must be called holding sta->lock
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010070 */
71static inline void mesh_plink_fsm_restart(struct sta_info *sta)
72{
Javier Cardona57cf8042011-05-13 10:45:43 -070073 sta->plink_state = NL80211_PLINK_LISTEN;
Luis Carlos Cobo37659ff2008-02-29 12:13:38 -080074 sta->llid = sta->plid = sta->reason = 0;
75 sta->plink_retries = 0;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010076}
77
Johannes Berg93e5deb2008-04-01 15:21:00 +020078/*
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -070079 * Allocate mesh sta entry and insert into station table
Johannes Berg93e5deb2008-04-01 15:21:00 +020080 */
Johannes Berg03e44972008-02-27 09:56:40 +010081static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -070082 u8 *hw_addr)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010083{
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010084 struct sta_info *sta;
85
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -070086 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
Johannes Berg73651ee2008-02-25 16:27:47 +010087 return NULL;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010088
Johannes Berg34e89502010-02-03 13:59:58 +010089 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
Johannes Berg73651ee2008-02-25 16:27:47 +010090 if (!sta)
91 return NULL;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010092
Johannes Berg83d5cc02012-01-12 09:31:10 +010093 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
94 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
95 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
Johannes Bergd9a7ddb2011-12-14 12:35:30 +010096
Johannes Bergc2c98fd2011-09-29 16:04:36 +020097 set_sta_flag(sta, WLAN_STA_WME);
Johannes Bergd9a7ddb2011-12-14 12:35:30 +010098
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010099 return sta;
100}
101
Ben Hutchings2c530402012-07-10 10:55:09 +0000102/**
Ashok Nagarajancbf93222012-05-07 21:00:31 -0700103 * mesh_set_ht_prot_mode - set correct HT protection mode
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700104 *
Ashok Nagarajancbf93222012-05-07 21:00:31 -0700105 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
106 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
107 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
108 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
109 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
110 * HT20 peer is present. Otherwise no-protection mode is selected.
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700111 */
112static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
113{
114 struct ieee80211_local *local = sdata->local;
115 struct sta_info *sta;
116 u32 changed = 0;
117 u16 ht_opmode;
118 bool non_ht_sta = false, ht20_sta = false;
119
120 if (local->_oper_channel_type == NL80211_CHAN_NO_HT)
121 return 0;
122
123 rcu_read_lock();
124 list_for_each_entry_rcu(sta, &local->sta_list, list) {
Ashok Nagarajancbf93222012-05-07 21:00:31 -0700125 if (sdata != sta->sdata ||
126 sta->plink_state != NL80211_PLINK_ESTAB)
127 continue;
128
129 switch (sta->ch_type) {
130 case NL80211_CHAN_NO_HT:
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200131 mpl_dbg(sdata,
132 "mesh_plink %pM: nonHT sta (%pM) is present\n",
Ashok Nagarajancbf93222012-05-07 21:00:31 -0700133 sdata->vif.addr, sta->sta.addr);
134 non_ht_sta = true;
135 goto out;
136 case NL80211_CHAN_HT20:
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200137 mpl_dbg(sdata,
138 "mesh_plink %pM: HT20 sta (%pM) is present\n",
Ashok Nagarajancbf93222012-05-07 21:00:31 -0700139 sdata->vif.addr, sta->sta.addr);
140 ht20_sta = true;
141 default:
142 break;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700143 }
144 }
145out:
146 rcu_read_unlock();
147
148 if (non_ht_sta)
149 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
150 else if (ht20_sta && local->_oper_channel_type > NL80211_CHAN_HT20)
151 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
152 else
153 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
154
155 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
156 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
Ashok Nagarajan70c33ea2012-04-30 14:20:32 -0700157 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700158 changed = BSS_CHANGED_HT;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200159 mpl_dbg(sdata,
160 "mesh_plink %pM: protection mode changed to %d\n",
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700161 sdata->vif.addr, ht_opmode);
162 }
163
164 return changed;
165}
166
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100167/**
John W. Linvillec9370192010-06-21 17:14:07 -0400168 * __mesh_plink_deactivate - deactivate mesh peer link
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100169 *
170 * @sta: mesh peer link to deactivate
171 *
172 * All mesh paths with this peer as next hop will be flushed
173 *
Johannes Berg07346f812008-05-03 01:02:02 +0200174 * Locking: the caller must hold sta->lock
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100175 */
John W. Linvillec9370192010-06-21 17:14:07 -0400176static bool __mesh_plink_deactivate(struct sta_info *sta)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100177{
Johannes Bergd0709a62008-02-25 16:27:46 +0100178 struct ieee80211_sub_if_data *sdata = sta->sdata;
John W. Linvillec9370192010-06-21 17:14:07 -0400179 bool deactivated = false;
Johannes Bergd0709a62008-02-25 16:27:46 +0100180
Javier Cardona57cf8042011-05-13 10:45:43 -0700181 if (sta->plink_state == NL80211_PLINK_ESTAB) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100182 mesh_plink_dec_estab_count(sdata);
John W. Linvillec9370192010-06-21 17:14:07 -0400183 deactivated = true;
184 }
Javier Cardona57cf8042011-05-13 10:45:43 -0700185 sta->plink_state = NL80211_PLINK_BLOCKED;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100186 mesh_path_flush_by_nexthop(sta);
John W. Linvillec9370192010-06-21 17:14:07 -0400187
188 return deactivated;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100189}
190
Johannes Berg902acc72008-02-23 15:17:19 +0100191/**
John W. Linvillec9370192010-06-21 17:14:07 -0400192 * mesh_plink_deactivate - deactivate mesh peer link
Johannes Berg902acc72008-02-23 15:17:19 +0100193 *
194 * @sta: mesh peer link to deactivate
195 *
196 * All mesh paths with this peer as next hop will be flushed
197 */
198void mesh_plink_deactivate(struct sta_info *sta)
199{
John W. Linvillec9370192010-06-21 17:14:07 -0400200 struct ieee80211_sub_if_data *sdata = sta->sdata;
201 bool deactivated;
202
Johannes Berg07346f812008-05-03 01:02:02 +0200203 spin_lock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400204 deactivated = __mesh_plink_deactivate(sta);
Thomas Pedersenba4a14e2011-09-20 13:43:32 -0700205 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
206 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
207 sta->sta.addr, sta->llid, sta->plid,
208 sta->reason);
Johannes Berg07346f812008-05-03 01:02:02 +0200209 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400210
211 if (deactivated)
212 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg902acc72008-02-23 15:17:19 +0100213}
214
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200215static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700216 enum ieee80211_self_protected_actioncode action,
217 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200218 struct ieee80211_local *local = sdata->local;
Thomas Pedersen3b69a9c2011-10-26 14:47:25 -0700219 struct sk_buff *skb;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100220 struct ieee80211_mgmt *mgmt;
221 bool include_plid = false;
Thomas Pedersen8db09852011-08-12 20:01:00 -0700222 u16 peering_proto = 0;
Thomas Pedersen3b69a9c2011-10-26 14:47:25 -0700223 u8 *pos, ie_len = 4;
224 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
225 sizeof(mgmt->u.action.u.self_prot);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100226
Javier Cardona65e8b0c2012-01-17 18:17:46 -0800227 skb = dev_alloc_skb(local->tx_headroom +
Thomas Pedersen3b69a9c2011-10-26 14:47:25 -0700228 hdr_len +
229 2 + /* capability info */
230 2 + /* AID */
231 2 + 8 + /* supported rates */
232 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
233 2 + sdata->u.mesh.mesh_id_len +
234 2 + sizeof(struct ieee80211_meshconf_ie) +
Thomas Pedersen176f3602011-10-26 14:47:27 -0700235 2 + sizeof(struct ieee80211_ht_cap) +
Johannes Berg074d46d2012-03-15 19:45:16 +0100236 2 + sizeof(struct ieee80211_ht_operation) +
Thomas Pedersen3b69a9c2011-10-26 14:47:25 -0700237 2 + 8 + /* peering IE */
238 sdata->u.mesh.ie_len);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100239 if (!skb)
240 return -1;
Javier Cardona65e8b0c2012-01-17 18:17:46 -0800241 skb_reserve(skb, local->tx_headroom);
Thomas Pedersen3b69a9c2011-10-26 14:47:25 -0700242 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
243 memset(mgmt, 0, hdr_len);
Harvey Harrisone7827a72008-07-15 18:44:13 -0700244 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
245 IEEE80211_STYPE_ACTION);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100246 memcpy(mgmt->da, da, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100247 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Javier Cardona915b5c52011-05-03 16:57:10 -0700248 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700249 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
250 mgmt->u.action.u.self_prot.action_code = action;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100251
Thomas Pedersen8db09852011-08-12 20:01:00 -0700252 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
253 /* capability info */
254 pos = skb_put(skb, 2);
255 memset(pos, 0, 2);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700256 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
Thomas Pedersen8db09852011-08-12 20:01:00 -0700257 /* AID */
258 pos = skb_put(skb, 2);
Rui Paulo77fa76b2009-11-09 23:46:52 +0000259 memcpy(pos + 2, &plid, 2);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100260 }
Johannes Bergfc8a7322012-06-28 10:33:25 +0200261 if (ieee80211_add_srates_ie(sdata, skb, true) ||
262 ieee80211_add_ext_srates_ie(sdata, skb, true) ||
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700263 mesh_add_rsn_ie(skb, sdata) ||
264 mesh_add_meshid_ie(skb, sdata) ||
265 mesh_add_meshconf_ie(skb, sdata))
266 return -1;
Thomas Pedersen8db09852011-08-12 20:01:00 -0700267 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
268 if (mesh_add_meshid_ie(skb, sdata))
269 return -1;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100270 }
271
Thomas Pedersen8db09852011-08-12 20:01:00 -0700272 /* Add Mesh Peering Management element */
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100273 switch (action) {
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700274 case WLAN_SP_MESH_PEERING_OPEN:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100275 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700276 case WLAN_SP_MESH_PEERING_CONFIRM:
Thomas Pedersen8db09852011-08-12 20:01:00 -0700277 ie_len += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100278 include_plid = true;
279 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700280 case WLAN_SP_MESH_PEERING_CLOSE:
Thomas Pedersen8db09852011-08-12 20:01:00 -0700281 if (plid) {
282 ie_len += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100283 include_plid = true;
284 }
Thomas Pedersen8db09852011-08-12 20:01:00 -0700285 ie_len += 2; /* reason code */
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100286 break;
Thomas Pedersen8db09852011-08-12 20:01:00 -0700287 default:
288 return -EINVAL;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100289 }
290
Thomas Pedersen8db09852011-08-12 20:01:00 -0700291 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
292 return -ENOMEM;
293
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100294 pos = skb_put(skb, 2 + ie_len);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700295 *pos++ = WLAN_EID_PEER_MGMT;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100296 *pos++ = ie_len;
Thomas Pedersen8db09852011-08-12 20:01:00 -0700297 memcpy(pos, &peering_proto, 2);
298 pos += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100299 memcpy(pos, &llid, 2);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700300 pos += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100301 if (include_plid) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100302 memcpy(pos, &plid, 2);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700303 pos += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100304 }
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700305 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100306 memcpy(pos, &reason, 2);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700307 pos += 2;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100308 }
Thomas Pedersen176f3602011-10-26 14:47:27 -0700309
310 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
311 if (mesh_add_ht_cap_ie(skb, sdata) ||
Johannes Berg074d46d2012-03-15 19:45:16 +0100312 mesh_add_ht_oper_ie(skb, sdata))
Thomas Pedersen176f3602011-10-26 14:47:27 -0700313 return -1;
314 }
315
Thomas Pedersen8db09852011-08-12 20:01:00 -0700316 if (mesh_add_vendor_ies(skb, sdata))
317 return -1;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100318
Johannes Berg62ae67b2009-11-18 18:42:05 +0100319 ieee80211_tx_skb(sdata, skb);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100320 return 0;
321}
322
Ben Hutchings2c530402012-07-10 10:55:09 +0000323/**
324 * mesh_peer_init - initialize new mesh peer and return resulting sta_info
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700325 *
326 * @sdata: local meshif
327 * @addr: peer's address
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700328 * @elems: IEs from beacon or mesh peering frame
329 *
330 * call under RCU
331 */
332static struct sta_info *mesh_peer_init(struct ieee80211_sub_if_data *sdata,
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700333 u8 *addr,
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700334 struct ieee802_11_elems *elems)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100335{
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200336 struct ieee80211_local *local = sdata->local;
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700337 enum ieee80211_band band = local->oper_channel->band;
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700338 struct ieee80211_supported_band *sband;
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700339 u32 rates, basic_rates = 0;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100340 struct sta_info *sta;
Thomas Pedersene87278e2012-04-26 15:01:06 -0700341 bool insert = false;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100342
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700343 sband = local->hw.wiphy->bands[band];
344 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
Johannes Bergd0709a62008-02-25 16:27:46 +0100345
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700346 sta = sta_info_get(sdata, addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100347 if (!sta) {
Thomas Pedersenf5c56812012-05-03 15:06:09 -0700348 /* Userspace handles peer allocation when security is enabled */
349 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) {
350 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
351 elems->ie_start,
352 elems->total_len,
353 GFP_ATOMIC);
354 return NULL;
355 }
356
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700357 sta = mesh_plink_alloc(sdata, addr);
Johannes Berg34e89502010-02-03 13:59:58 +0100358 if (!sta)
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700359 return NULL;
Thomas Pedersene87278e2012-04-26 15:01:06 -0700360 insert = true;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100361 }
362
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700363 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100364 sta->last_rx = jiffies;
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700365 sta->sta.supp_rates[band] = rates;
Thomas Pedersene76781e2012-04-18 19:24:13 -0700366 if (elems->ht_cap_elem &&
367 sdata->local->_oper_channel_type != NL80211_CHAN_NO_HT)
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700368 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
369 elems->ht_cap_elem,
370 &sta->sta.ht_cap);
371 else
372 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
373
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700374 if (elems->ht_operation) {
Thomas Pedersenc7d25822012-04-26 15:01:07 -0700375 if (!(elems->ht_operation->ht_param &
376 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
377 sta->sta.ht_cap.cap &=
378 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700379 sta->ch_type =
380 ieee80211_ht_oper_to_channel_type(elems->ht_operation);
381 }
Thomas Pedersenc7d25822012-04-26 15:01:07 -0700382
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700383 rate_control_rate_init(sta);
384 spin_unlock_bh(&sta->lock);
385
Thomas Pedersene87278e2012-04-26 15:01:06 -0700386 if (insert && sta_info_insert(sta))
387 return NULL;
388
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700389 return sta;
390}
391
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700392void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
393 u8 *hw_addr,
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700394 struct ieee802_11_elems *elems)
395{
396 struct sta_info *sta;
397
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700398 rcu_read_lock();
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700399 sta = mesh_peer_init(sdata, hw_addr, elems);
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700400 if (!sta)
401 goto out;
402
Javier Cardona1570ca52011-04-07 15:08:35 -0700403 if (mesh_peer_accepts_plinks(elems) &&
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700404 sta->plink_state == NL80211_PLINK_LISTEN &&
405 sdata->u.mesh.accepting_plinks &&
406 sdata->u.mesh.mshcfg.auto_open_plinks &&
407 rssi_threshold_check(sta, sdata))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100408 mesh_plink_open(sta);
409
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700410out:
Johannes Bergd0709a62008-02-25 16:27:46 +0100411 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100412}
413
414static void mesh_plink_timer(unsigned long data)
415{
416 struct sta_info *sta;
417 __le16 llid, plid, reason;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100418 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100419
Johannes Bergd0709a62008-02-25 16:27:46 +0100420 /*
421 * This STA is valid because sta_info_destroy() will
422 * del_timer_sync() this timer after having made sure
423 * it cannot be readded (by deleting the plink.)
424 */
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100425 sta = (struct sta_info *) data;
426
Johannes Berg5bb644a2009-05-17 11:40:42 +0200427 if (sta->sdata->local->quiescing) {
428 sta->plink_timer_was_running = true;
429 return;
430 }
431
Johannes Berg07346f812008-05-03 01:02:02 +0200432 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100433 if (sta->ignore_plink_timer) {
434 sta->ignore_plink_timer = false;
Johannes Berg07346f812008-05-03 01:02:02 +0200435 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100436 return;
437 }
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200438 mpl_dbg(sta->sdata,
439 "Mesh plink timer for %pM fired on state %d\n",
Johannes Berg0c68ae262008-10-27 15:56:10 -0700440 sta->sta.addr, sta->plink_state);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100441 reason = 0;
442 llid = sta->llid;
443 plid = sta->plid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100444 sdata = sta->sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100445
446 switch (sta->plink_state) {
Javier Cardona57cf8042011-05-13 10:45:43 -0700447 case NL80211_PLINK_OPN_RCVD:
448 case NL80211_PLINK_OPN_SNT:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100449 /* retry timer */
450 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
451 u32 rand;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200452 mpl_dbg(sta->sdata,
453 "Mesh plink for %pM (retry, timeout): %d %d\n",
Johannes Berg0c68ae262008-10-27 15:56:10 -0700454 sta->sta.addr, sta->plink_retries,
455 sta->plink_timeout);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100456 get_random_bytes(&rand, sizeof(u32));
457 sta->plink_timeout = sta->plink_timeout +
458 rand % sta->plink_timeout;
459 ++sta->plink_retries;
Johannes Bergd0709a62008-02-25 16:27:46 +0100460 mod_plink_timer(sta, sta->plink_timeout);
Johannes Berg07346f812008-05-03 01:02:02 +0200461 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700462 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
463 sta->sta.addr, llid, 0, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100464 break;
465 }
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700466 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100467 /* fall through on else */
Javier Cardona57cf8042011-05-13 10:45:43 -0700468 case NL80211_PLINK_CNF_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100469 /* confirm timer */
470 if (!reason)
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700471 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
Javier Cardona57cf8042011-05-13 10:45:43 -0700472 sta->plink_state = NL80211_PLINK_HOLDING;
Johannes Bergd0709a62008-02-25 16:27:46 +0100473 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200474 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700475 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
476 sta->sta.addr, llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100477 break;
Javier Cardona57cf8042011-05-13 10:45:43 -0700478 case NL80211_PLINK_HOLDING:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100479 /* holding timer */
Johannes Bergd0709a62008-02-25 16:27:46 +0100480 del_timer(&sta->plink_timer);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100481 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200482 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100483 break;
484 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200485 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100486 break;
487 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100488}
489
Johannes Berg5bb644a2009-05-17 11:40:42 +0200490#ifdef CONFIG_PM
491void mesh_plink_quiesce(struct sta_info *sta)
492{
493 if (del_timer_sync(&sta->plink_timer))
494 sta->plink_timer_was_running = true;
495}
496
497void mesh_plink_restart(struct sta_info *sta)
498{
499 if (sta->plink_timer_was_running) {
500 add_timer(&sta->plink_timer);
501 sta->plink_timer_was_running = false;
502 }
503}
504#endif
505
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100506static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
507{
508 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
509 sta->plink_timer.data = (unsigned long) sta;
510 sta->plink_timer.function = mesh_plink_timer;
511 sta->plink_timeout = timeout;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100512 add_timer(&sta->plink_timer);
513}
514
515int mesh_plink_open(struct sta_info *sta)
516{
517 __le16 llid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100518 struct ieee80211_sub_if_data *sdata = sta->sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100519
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200520 if (!test_sta_flag(sta, WLAN_STA_AUTH))
Javier Cardona53e80512011-04-07 15:08:32 -0700521 return -EPERM;
522
Johannes Berg07346f812008-05-03 01:02:02 +0200523 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100524 get_random_bytes(&llid, 2);
525 sta->llid = llid;
Javier Cardona57cf8042011-05-13 10:45:43 -0700526 if (sta->plink_state != NL80211_PLINK_LISTEN) {
Johannes Berg07346f812008-05-03 01:02:02 +0200527 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100528 return -EBUSY;
529 }
Javier Cardona57cf8042011-05-13 10:45:43 -0700530 sta->plink_state = NL80211_PLINK_OPN_SNT;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100531 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200532 spin_unlock_bh(&sta->lock);
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200533 mpl_dbg(sdata,
534 "Mesh plink: starting establishment with %pM\n",
Johannes Berg0c68ae262008-10-27 15:56:10 -0700535 sta->sta.addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100536
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700537 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
Johannes Berg17741cd2008-09-11 00:02:02 +0200538 sta->sta.addr, llid, 0, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100539}
540
541void mesh_plink_block(struct sta_info *sta)
542{
John W. Linvillec9370192010-06-21 17:14:07 -0400543 struct ieee80211_sub_if_data *sdata = sta->sdata;
544 bool deactivated;
545
Johannes Berg07346f812008-05-03 01:02:02 +0200546 spin_lock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400547 deactivated = __mesh_plink_deactivate(sta);
Javier Cardona57cf8042011-05-13 10:45:43 -0700548 sta->plink_state = NL80211_PLINK_BLOCKED;
Johannes Berg07346f812008-05-03 01:02:02 +0200549 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400550
551 if (deactivated)
552 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100553}
554
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100555
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200556void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100557 size_t len, struct ieee80211_rx_status *rx_status)
558{
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100559 struct ieee802_11_elems elems;
560 struct sta_info *sta;
561 enum plink_event event;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700562 enum ieee80211_self_protected_actioncode ftype;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100563 size_t baselen;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700564 bool matches_local = true;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100565 u8 ie_len;
566 u8 *baseaddr;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700567 u32 changed = 0;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100568 __le16 plid, llid, reason;
Rui Paulo1460dd12009-11-09 23:46:48 +0000569 static const char *mplstates[] = {
Javier Cardona57cf8042011-05-13 10:45:43 -0700570 [NL80211_PLINK_LISTEN] = "LISTEN",
571 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
572 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
573 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
574 [NL80211_PLINK_ESTAB] = "ESTAB",
575 [NL80211_PLINK_HOLDING] = "HOLDING",
576 [NL80211_PLINK_BLOCKED] = "BLOCKED"
Rui Paulo1460dd12009-11-09 23:46:48 +0000577 };
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100578
Johannes Berg9c80d3d2008-09-08 15:41:59 +0200579 /* need action_code, aux */
580 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
581 return;
582
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100583 if (is_multicast_ether_addr(mgmt->da)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200584 mpl_dbg(sdata,
585 "Mesh plink: ignore frame from multicast address\n");
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100586 return;
587 }
588
Thomas Pedersen8db09852011-08-12 20:01:00 -0700589 baseaddr = mgmt->u.action.u.self_prot.variable;
590 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
591 if (mgmt->u.action.u.self_prot.action_code ==
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700592 WLAN_SP_MESH_PEERING_CONFIRM) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100593 baseaddr += 4;
David Woo70bdb6b2009-08-12 11:03:44 -0700594 baselen += 4;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100595 }
596 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
Thomas Pedersen8db09852011-08-12 20:01:00 -0700597 if (!elems.peering) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200598 mpl_dbg(sdata,
599 "Mesh plink: missing necessary peer link ie\n");
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100600 return;
601 }
Javier Cardonab130e5c2011-05-03 16:57:07 -0700602 if (elems.rsn_len &&
603 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200604 mpl_dbg(sdata,
605 "Mesh plink: can't establish link with secure peer\n");
Javier Cardona5cff5e02011-04-07 15:08:29 -0700606 return;
607 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100608
Thomas Pedersen8db09852011-08-12 20:01:00 -0700609 ftype = mgmt->u.action.u.self_prot.action_code;
610 ie_len = elems.peering_len;
611 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
612 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
613 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
614 && ie_len != 8)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200615 mpl_dbg(sdata,
616 "Mesh plink: incorrect plink ie length %d %d\n",
617 ftype, ie_len);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100618 return;
619 }
620
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700621 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
622 (!elems.mesh_id || !elems.mesh_config)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200623 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100624 return;
625 }
626 /* Note the lines below are correct, the llid in the frame is the plid
627 * from the point of view of this host.
628 */
Thomas Pedersen8db09852011-08-12 20:01:00 -0700629 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700630 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
Thomas Pedersen8db09852011-08-12 20:01:00 -0700631 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
632 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100633
Johannes Bergd0709a62008-02-25 16:27:46 +0100634 rcu_read_lock();
635
Johannes Bergabe60632009-11-25 17:46:18 +0100636 sta = sta_info_get(sdata, mgmt->sa);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700637 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200638 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
Johannes Bergd0709a62008-02-25 16:27:46 +0100639 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100640 return;
641 }
642
Ashok Nagarajan55335132012-02-28 17:04:08 -0800643 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
Ashok Nagarajan3d4f9692012-03-06 12:48:30 -0800644 !rssi_threshold_check(sta, sdata)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200645 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
Ashok Nagarajan3d4f9692012-03-06 12:48:30 -0800646 mgmt->sa);
Ashok Nagarajan55335132012-02-28 17:04:08 -0800647 rcu_read_unlock();
648 return;
649 }
650
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200651 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200652 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
Javier Cardona53e80512011-04-07 15:08:32 -0700653 rcu_read_unlock();
654 return;
655 }
656
Javier Cardona57cf8042011-05-13 10:45:43 -0700657 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
Johannes Bergd0709a62008-02-25 16:27:46 +0100658 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100659 return;
660 }
661
662 /* Now we will figure out the appropriate event... */
663 event = PLINK_UNDEFINED;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700664 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700665 !mesh_matches_local(sdata, &elems)) {
Christian Lamparterd12c7452010-10-08 22:27:07 +0200666 matches_local = false;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100667 switch (ftype) {
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700668 case WLAN_SP_MESH_PEERING_OPEN:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100669 event = OPN_RJCT;
670 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700671 case WLAN_SP_MESH_PEERING_CONFIRM:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100672 event = CNF_RJCT;
673 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700674 default:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100675 break;
676 }
Christian Lamparterd12c7452010-10-08 22:27:07 +0200677 }
678
679 if (!sta && !matches_local) {
680 rcu_read_unlock();
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700681 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
Christian Lamparterd12c7452010-10-08 22:27:07 +0200682 llid = 0;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700683 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
684 mgmt->sa, llid, plid, reason);
Christian Lamparterd12c7452010-10-08 22:27:07 +0200685 return;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100686 } else if (!sta) {
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700687 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100688 if (!mesh_plink_free_count(sdata)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200689 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
Johannes Berg73651ee2008-02-25 16:27:47 +0100690 rcu_read_unlock();
691 return;
692 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100693 event = OPN_ACPT;
Christian Lamparterd12c7452010-10-08 22:27:07 +0200694 } else if (matches_local) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100695 switch (ftype) {
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700696 case WLAN_SP_MESH_PEERING_OPEN:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100697 if (!mesh_plink_free_count(sdata) ||
Johannes Bergd0709a62008-02-25 16:27:46 +0100698 (sta->plid && sta->plid != plid))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100699 event = OPN_IGNR;
700 else
701 event = OPN_ACPT;
702 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700703 case WLAN_SP_MESH_PEERING_CONFIRM:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100704 if (!mesh_plink_free_count(sdata) ||
Johannes Bergd0709a62008-02-25 16:27:46 +0100705 (sta->llid != llid || sta->plid != plid))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100706 event = CNF_IGNR;
707 else
708 event = CNF_ACPT;
709 break;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700710 case WLAN_SP_MESH_PEERING_CLOSE:
Javier Cardona57cf8042011-05-13 10:45:43 -0700711 if (sta->plink_state == NL80211_PLINK_ESTAB)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100712 /* Do not check for llid or plid. This does not
713 * follow the standard but since multiple plinks
714 * per sta are not supported, it is necessary in
715 * order to avoid a livelock when MP A sees an
716 * establish peer link to MP B but MP B does not
717 * see it. This can be caused by a timeout in
718 * B's peer link establishment or B beign
719 * restarted.
720 */
721 event = CLS_ACPT;
722 else if (sta->plid != plid)
723 event = CLS_IGNR;
724 else if (ie_len == 7 && sta->llid != llid)
725 event = CLS_IGNR;
726 else
727 event = CLS_ACPT;
728 break;
729 default:
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200730 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
Johannes Bergd0709a62008-02-25 16:27:46 +0100731 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100732 return;
733 }
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700734 }
735
736 if (event == OPN_ACPT) {
737 /* allocate sta entry if necessary and update info */
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700738 sta = mesh_peer_init(sdata, mgmt->sa, &elems);
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700739 if (!sta) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200740 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700741 rcu_read_unlock();
742 return;
743 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100744 }
745
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200746 mpl_dbg(sdata,
747 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
Rui Paulo1460dd12009-11-09 23:46:48 +0000748 mgmt->sa, mplstates[sta->plink_state],
Johannes Berg0c68ae262008-10-27 15:56:10 -0700749 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
750 event);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100751 reason = 0;
Thomas Pedersen54ab1ff2012-04-18 19:23:42 -0700752 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100753 switch (sta->plink_state) {
754 /* spin_unlock as soon as state is updated at each case */
Javier Cardona57cf8042011-05-13 10:45:43 -0700755 case NL80211_PLINK_LISTEN:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100756 switch (event) {
757 case CLS_ACPT:
758 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200759 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100760 break;
761 case OPN_ACPT:
Javier Cardona57cf8042011-05-13 10:45:43 -0700762 sta->plink_state = NL80211_PLINK_OPN_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100763 sta->plid = plid;
764 get_random_bytes(&llid, 2);
765 sta->llid = llid;
766 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200767 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700768 mesh_plink_frame_tx(sdata,
769 WLAN_SP_MESH_PEERING_OPEN,
770 sta->sta.addr, llid, 0, 0);
771 mesh_plink_frame_tx(sdata,
772 WLAN_SP_MESH_PEERING_CONFIRM,
773 sta->sta.addr, llid, plid, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100774 break;
775 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200776 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100777 break;
778 }
779 break;
780
Javier Cardona57cf8042011-05-13 10:45:43 -0700781 case NL80211_PLINK_OPN_SNT:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100782 switch (event) {
783 case OPN_RJCT:
784 case CNF_RJCT:
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700785 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100786 case CLS_ACPT:
787 if (!reason)
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700788 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100789 sta->reason = reason;
Javier Cardona57cf8042011-05-13 10:45:43 -0700790 sta->plink_state = NL80211_PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100791 if (!mod_plink_timer(sta,
792 dot11MeshHoldingTimeout(sdata)))
793 sta->ignore_plink_timer = true;
794
795 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200796 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700797 mesh_plink_frame_tx(sdata,
798 WLAN_SP_MESH_PEERING_CLOSE,
799 sta->sta.addr, llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100800 break;
801 case OPN_ACPT:
802 /* retry timer is left untouched */
Javier Cardona57cf8042011-05-13 10:45:43 -0700803 sta->plink_state = NL80211_PLINK_OPN_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100804 sta->plid = plid;
805 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200806 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700807 mesh_plink_frame_tx(sdata,
808 WLAN_SP_MESH_PEERING_CONFIRM,
809 sta->sta.addr, llid, plid, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100810 break;
811 case CNF_ACPT:
Javier Cardona57cf8042011-05-13 10:45:43 -0700812 sta->plink_state = NL80211_PLINK_CNF_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100813 if (!mod_plink_timer(sta,
814 dot11MeshConfirmTimeout(sdata)))
815 sta->ignore_plink_timer = true;
816
Johannes Berg07346f812008-05-03 01:02:02 +0200817 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100818 break;
819 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200820 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100821 break;
822 }
823 break;
824
Javier Cardona57cf8042011-05-13 10:45:43 -0700825 case NL80211_PLINK_OPN_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100826 switch (event) {
827 case OPN_RJCT:
828 case CNF_RJCT:
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700829 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100830 case CLS_ACPT:
831 if (!reason)
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700832 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100833 sta->reason = reason;
Javier Cardona57cf8042011-05-13 10:45:43 -0700834 sta->plink_state = NL80211_PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100835 if (!mod_plink_timer(sta,
836 dot11MeshHoldingTimeout(sdata)))
837 sta->ignore_plink_timer = true;
838
839 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200840 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700841 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
842 sta->sta.addr, llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100843 break;
844 case OPN_ACPT:
845 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200846 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700847 mesh_plink_frame_tx(sdata,
848 WLAN_SP_MESH_PEERING_CONFIRM,
849 sta->sta.addr, llid, plid, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100850 break;
851 case CNF_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100852 del_timer(&sta->plink_timer);
Javier Cardona57cf8042011-05-13 10:45:43 -0700853 sta->plink_state = NL80211_PLINK_ESTAB;
Johannes Berg07346f812008-05-03 01:02:02 +0200854 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400855 mesh_plink_inc_estab_count(sdata);
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700856 changed |= mesh_set_ht_prot_mode(sdata);
857 changed |= BSS_CHANGED_BEACON;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200858 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
Johannes Berg0c68ae262008-10-27 15:56:10 -0700859 sta->sta.addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100860 break;
861 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200862 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100863 break;
864 }
865 break;
866
Javier Cardona57cf8042011-05-13 10:45:43 -0700867 case NL80211_PLINK_CNF_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100868 switch (event) {
869 case OPN_RJCT:
870 case CNF_RJCT:
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700871 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100872 case CLS_ACPT:
873 if (!reason)
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700874 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100875 sta->reason = reason;
Javier Cardona57cf8042011-05-13 10:45:43 -0700876 sta->plink_state = NL80211_PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100877 if (!mod_plink_timer(sta,
878 dot11MeshHoldingTimeout(sdata)))
879 sta->ignore_plink_timer = true;
880
881 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200882 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700883 mesh_plink_frame_tx(sdata,
884 WLAN_SP_MESH_PEERING_CLOSE,
885 sta->sta.addr, llid, plid, reason);
Johannes Bergff59dc72008-02-25 10:11:50 +0100886 break;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100887 case OPN_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100888 del_timer(&sta->plink_timer);
Javier Cardona57cf8042011-05-13 10:45:43 -0700889 sta->plink_state = NL80211_PLINK_ESTAB;
Johannes Berg07346f812008-05-03 01:02:02 +0200890 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400891 mesh_plink_inc_estab_count(sdata);
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700892 changed |= mesh_set_ht_prot_mode(sdata);
893 changed |= BSS_CHANGED_BEACON;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200894 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
Johannes Berg0c68ae262008-10-27 15:56:10 -0700895 sta->sta.addr);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700896 mesh_plink_frame_tx(sdata,
897 WLAN_SP_MESH_PEERING_CONFIRM,
898 sta->sta.addr, llid, plid, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100899 break;
900 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200901 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100902 break;
903 }
904 break;
905
Javier Cardona57cf8042011-05-13 10:45:43 -0700906 case NL80211_PLINK_ESTAB:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100907 switch (event) {
908 case CLS_ACPT:
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700909 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100910 sta->reason = reason;
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700911 __mesh_plink_deactivate(sta);
Javier Cardona57cf8042011-05-13 10:45:43 -0700912 sta->plink_state = NL80211_PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100913 llid = sta->llid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100914 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200915 spin_unlock_bh(&sta->lock);
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700916 changed |= mesh_set_ht_prot_mode(sdata);
917 changed |= BSS_CHANGED_BEACON;
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700918 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
919 sta->sta.addr, llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100920 break;
921 case OPN_ACPT:
922 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200923 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700924 mesh_plink_frame_tx(sdata,
925 WLAN_SP_MESH_PEERING_CONFIRM,
926 sta->sta.addr, llid, plid, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100927 break;
928 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200929 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100930 break;
931 }
932 break;
Javier Cardona57cf8042011-05-13 10:45:43 -0700933 case NL80211_PLINK_HOLDING:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100934 switch (event) {
935 case CLS_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100936 if (del_timer(&sta->plink_timer))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100937 sta->ignore_plink_timer = 1;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100938 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200939 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100940 break;
941 case OPN_ACPT:
942 case CNF_ACPT:
943 case OPN_RJCT:
944 case CNF_RJCT:
945 llid = sta->llid;
946 reason = sta->reason;
Johannes Berg07346f812008-05-03 01:02:02 +0200947 spin_unlock_bh(&sta->lock);
Thomas Pedersen54ef6562011-08-11 19:35:12 -0700948 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
949 sta->sta.addr, llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100950 break;
951 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200952 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100953 }
954 break;
955 default:
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800956 /* should not get here, PLINK_BLOCKED is dealt with at the
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800957 * beginning of the function
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100958 */
Johannes Berg07346f812008-05-03 01:02:02 +0200959 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100960 break;
961 }
Johannes Bergd0709a62008-02-25 16:27:46 +0100962
963 rcu_read_unlock();
Ashok Nagarajan57aac7c2012-04-30 14:20:30 -0700964
965 if (changed)
966 ieee80211_bss_info_change_notify(sdata, changed);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100967}