blob: 2c37bee3095a2741b661f54cb924c40ab773723d [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
16#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
17#define mpl_dbg(fmt, args...) printk(KERN_DEBUG fmt, ##args)
18#else
19#define mpl_dbg(fmt, args...) do { (void)(0); } while (0)
20#endif
21
Rui Paulo09383932009-11-09 23:46:43 +000022#define PLINK_GET_LLID(p) (p + 4)
23#define PLINK_GET_PLID(p) (p + 6)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010024
25#define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
26 jiffies + HZ * t / 1000))
27
28/* Peer link cancel reasons, all subject to ANA approval */
29#define MESH_LINK_CANCELLED 2
30#define MESH_MAX_NEIGHBORS 3
31#define MESH_CAPABILITY_POLICY_VIOLATION 4
32#define MESH_CLOSE_RCVD 5
33#define MESH_MAX_RETRIES 6
34#define MESH_CONFIRM_TIMEOUT 7
35#define MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS 8
36#define MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE 9
37#define MESH_SECURITY_FAILED_VERIFICATION 10
38
Johannes Berg472dbc42008-09-11 00:01:49 +020039#define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
40#define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
41#define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
42#define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
43#define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010044
45enum plink_frame_type {
Javier Cardona915b5c52011-05-03 16:57:10 -070046 PLINK_OPEN = 1,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010047 PLINK_CONFIRM,
48 PLINK_CLOSE
49};
50
51enum plink_event {
52 PLINK_UNDEFINED,
53 OPN_ACPT,
54 OPN_RJCT,
55 OPN_IGNR,
56 CNF_ACPT,
57 CNF_RJCT,
58 CNF_IGNR,
59 CLS_ACPT,
60 CLS_IGNR
61};
62
63static inline
64void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
65{
Johannes Berg472dbc42008-09-11 00:01:49 +020066 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
Johannes Bergd0709a62008-02-25 16:27:46 +010067 mesh_accept_plinks_update(sdata);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010068}
69
70static inline
71void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
72{
Johannes Berg472dbc42008-09-11 00:01:49 +020073 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
Johannes Bergd0709a62008-02-25 16:27:46 +010074 mesh_accept_plinks_update(sdata);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010075}
76
77/**
78 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
79 *
Rui Paulo23c7a292009-11-09 23:46:42 +000080 * @sta: mesh peer link to restart
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010081 *
Johannes Berg07346f812008-05-03 01:02:02 +020082 * Locking: this function must be called holding sta->lock
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010083 */
84static inline void mesh_plink_fsm_restart(struct sta_info *sta)
85{
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -080086 sta->plink_state = PLINK_LISTEN;
Luis Carlos Cobo37659ff2008-02-29 12:13:38 -080087 sta->llid = sta->plid = sta->reason = 0;
88 sta->plink_retries = 0;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010089}
90
Johannes Berg93e5deb2008-04-01 15:21:00 +020091/*
92 * NOTE: This is just an alias for sta_info_alloc(), see notes
93 * on it in the lifecycle management section!
94 */
Johannes Berg03e44972008-02-27 09:56:40 +010095static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
Johannes Berg881d9482009-01-21 15:13:48 +010096 u8 *hw_addr, u32 rates)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010097{
Johannes Bergd0709a62008-02-25 16:27:46 +010098 struct ieee80211_local *local = sdata->local;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +010099 struct sta_info *sta;
100
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100101 if (local->num_sta >= MESH_MAX_PLINKS)
Johannes Berg73651ee2008-02-25 16:27:47 +0100102 return NULL;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100103
Johannes Berg34e89502010-02-03 13:59:58 +0100104 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
Johannes Berg73651ee2008-02-25 16:27:47 +0100105 if (!sta)
106 return NULL;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100107
Javier Cardona96b78df2011-04-07 15:08:33 -0700108 sta->flags = WLAN_STA_AUTHORIZED | WLAN_STA_AUTH;
Johannes Berg323ce792008-09-11 02:45:11 +0200109 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
Christian Lamparterb973c312008-12-27 22:19:49 +0100110 rate_control_rate_init(sta);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100111
112 return sta;
113}
114
115/**
John W. Linvillec9370192010-06-21 17:14:07 -0400116 * __mesh_plink_deactivate - deactivate mesh peer link
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100117 *
118 * @sta: mesh peer link to deactivate
119 *
120 * All mesh paths with this peer as next hop will be flushed
121 *
Johannes Berg07346f812008-05-03 01:02:02 +0200122 * Locking: the caller must hold sta->lock
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100123 */
John W. Linvillec9370192010-06-21 17:14:07 -0400124static bool __mesh_plink_deactivate(struct sta_info *sta)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100125{
Johannes Bergd0709a62008-02-25 16:27:46 +0100126 struct ieee80211_sub_if_data *sdata = sta->sdata;
John W. Linvillec9370192010-06-21 17:14:07 -0400127 bool deactivated = false;
Johannes Bergd0709a62008-02-25 16:27:46 +0100128
John W. Linvillec9370192010-06-21 17:14:07 -0400129 if (sta->plink_state == PLINK_ESTAB) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100130 mesh_plink_dec_estab_count(sdata);
John W. Linvillec9370192010-06-21 17:14:07 -0400131 deactivated = true;
132 }
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800133 sta->plink_state = PLINK_BLOCKED;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100134 mesh_path_flush_by_nexthop(sta);
John W. Linvillec9370192010-06-21 17:14:07 -0400135
136 return deactivated;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100137}
138
Johannes Berg902acc72008-02-23 15:17:19 +0100139/**
John W. Linvillec9370192010-06-21 17:14:07 -0400140 * mesh_plink_deactivate - deactivate mesh peer link
Johannes Berg902acc72008-02-23 15:17:19 +0100141 *
142 * @sta: mesh peer link to deactivate
143 *
144 * All mesh paths with this peer as next hop will be flushed
145 */
146void mesh_plink_deactivate(struct sta_info *sta)
147{
John W. Linvillec9370192010-06-21 17:14:07 -0400148 struct ieee80211_sub_if_data *sdata = sta->sdata;
149 bool deactivated;
150
Johannes Berg07346f812008-05-03 01:02:02 +0200151 spin_lock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400152 deactivated = __mesh_plink_deactivate(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200153 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400154
155 if (deactivated)
156 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg902acc72008-02-23 15:17:19 +0100157}
158
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200159static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100160 enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
161 __le16 reason) {
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200162 struct ieee80211_local *local = sdata->local;
Javier Cardonac80d5452010-12-16 17:37:49 -0800163 struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 +
Javier Cardona581a8b02011-04-07 15:08:27 -0700164 sdata->u.mesh.ie_len);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100165 struct ieee80211_mgmt *mgmt;
166 bool include_plid = false;
Rui Paulo09383932009-11-09 23:46:43 +0000167 static const u8 meshpeeringproto[] = { 0x00, 0x0F, 0xAC, 0x2A };
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100168 u8 *pos;
169 int ie_len;
170
171 if (!skb)
172 return -1;
173 skb_reserve(skb, local->hw.extra_tx_headroom);
174 /* 25 is the size of the common mgmt part (24) plus the size of the
175 * common action part (1)
176 */
177 mgmt = (struct ieee80211_mgmt *)
178 skb_put(skb, 25 + sizeof(mgmt->u.action.u.plink_action));
179 memset(mgmt, 0, 25 + sizeof(mgmt->u.action.u.plink_action));
Harvey Harrisone7827a72008-07-15 18:44:13 -0700180 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
181 IEEE80211_STYPE_ACTION);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100182 memcpy(mgmt->da, da, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100183 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Javier Cardona915b5c52011-05-03 16:57:10 -0700184 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
Javier Cardonad3aaec8a2011-05-03 16:57:09 -0700185 mgmt->u.action.category = WLAN_CATEGORY_MESH_ACTION;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100186 mgmt->u.action.u.plink_action.action_code = action;
187
188 if (action == PLINK_CLOSE)
189 mgmt->u.action.u.plink_action.aux = reason;
190 else {
191 mgmt->u.action.u.plink_action.aux = cpu_to_le16(0x0);
192 if (action == PLINK_CONFIRM) {
193 pos = skb_put(skb, 4);
194 /* two-byte status code followed by two-byte AID */
Rui Paulo77fa76b2009-11-09 23:46:52 +0000195 memset(pos, 0, 2);
196 memcpy(pos + 2, &plid, 2);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100197 }
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200198 mesh_mgmt_ies_add(skb, sdata);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100199 }
200
201 /* Add Peer Link Management element */
202 switch (action) {
203 case PLINK_OPEN:
Rui Paulo09383932009-11-09 23:46:43 +0000204 ie_len = 6;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100205 break;
206 case PLINK_CONFIRM:
Rui Paulo09383932009-11-09 23:46:43 +0000207 ie_len = 8;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100208 include_plid = true;
209 break;
210 case PLINK_CLOSE:
211 default:
212 if (!plid)
Rui Paulo09383932009-11-09 23:46:43 +0000213 ie_len = 8;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100214 else {
Rui Paulo09383932009-11-09 23:46:43 +0000215 ie_len = 10;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100216 include_plid = true;
217 }
218 break;
219 }
220
221 pos = skb_put(skb, 2 + ie_len);
222 *pos++ = WLAN_EID_PEER_LINK;
223 *pos++ = ie_len;
Rui Paulo09383932009-11-09 23:46:43 +0000224 memcpy(pos, meshpeeringproto, sizeof(meshpeeringproto));
225 pos += 4;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100226 memcpy(pos, &llid, 2);
227 if (include_plid) {
228 pos += 2;
229 memcpy(pos, &plid, 2);
230 }
231 if (action == PLINK_CLOSE) {
232 pos += 2;
233 memcpy(pos, &reason, 2);
234 }
235
Johannes Berg62ae67b2009-11-18 18:42:05 +0100236 ieee80211_tx_skb(sdata, skb);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100237 return 0;
238}
239
Javier Cardona1570ca52011-04-07 15:08:35 -0700240void mesh_neighbour_update(u8 *hw_addr, u32 rates,
241 struct ieee80211_sub_if_data *sdata,
242 struct ieee802_11_elems *elems)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100243{
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200244 struct ieee80211_local *local = sdata->local;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100245 struct sta_info *sta;
246
Johannes Bergd0709a62008-02-25 16:27:46 +0100247 rcu_read_lock();
248
Johannes Bergabe60632009-11-25 17:46:18 +0100249 sta = sta_info_get(sdata, hw_addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100250 if (!sta) {
Johannes Berg34e89502010-02-03 13:59:58 +0100251 rcu_read_unlock();
Javier Cardona1570ca52011-04-07 15:08:35 -0700252 /* Userspace handles peer allocation when security is enabled
253 * */
Javier Cardonab130e5c2011-05-03 16:57:07 -0700254 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED)
Javier Cardona1570ca52011-04-07 15:08:35 -0700255 cfg80211_notify_new_peer_candidate(sdata->dev, hw_addr,
256 elems->ie_start, elems->total_len,
257 GFP_KERNEL);
258 else
259 sta = mesh_plink_alloc(sdata, hw_addr, rates);
Johannes Berg34e89502010-02-03 13:59:58 +0100260 if (!sta)
Johannes Berg73651ee2008-02-25 16:27:47 +0100261 return;
Johannes Berg34e89502010-02-03 13:59:58 +0100262 if (sta_info_insert_rcu(sta)) {
Johannes Bergd0709a62008-02-25 16:27:46 +0100263 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100264 return;
Johannes Bergd0709a62008-02-25 16:27:46 +0100265 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100266 }
267
268 sta->last_rx = jiffies;
Johannes Berg323ce792008-09-11 02:45:11 +0200269 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
Javier Cardona1570ca52011-04-07 15:08:35 -0700270 if (mesh_peer_accepts_plinks(elems) &&
271 sta->plink_state == PLINK_LISTEN &&
Johannes Berg472dbc42008-09-11 00:01:49 +0200272 sdata->u.mesh.accepting_plinks &&
273 sdata->u.mesh.mshcfg.auto_open_plinks)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100274 mesh_plink_open(sta);
275
Johannes Bergd0709a62008-02-25 16:27:46 +0100276 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100277}
278
279static void mesh_plink_timer(unsigned long data)
280{
281 struct sta_info *sta;
282 __le16 llid, plid, reason;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100283 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100284
Johannes Bergd0709a62008-02-25 16:27:46 +0100285 /*
286 * This STA is valid because sta_info_destroy() will
287 * del_timer_sync() this timer after having made sure
288 * it cannot be readded (by deleting the plink.)
289 */
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100290 sta = (struct sta_info *) data;
291
Johannes Berg5bb644a2009-05-17 11:40:42 +0200292 if (sta->sdata->local->quiescing) {
293 sta->plink_timer_was_running = true;
294 return;
295 }
296
Johannes Berg07346f812008-05-03 01:02:02 +0200297 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100298 if (sta->ignore_plink_timer) {
299 sta->ignore_plink_timer = false;
Johannes Berg07346f812008-05-03 01:02:02 +0200300 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100301 return;
302 }
Johannes Berg0c68ae262008-10-27 15:56:10 -0700303 mpl_dbg("Mesh plink timer for %pM fired on state %d\n",
304 sta->sta.addr, sta->plink_state);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100305 reason = 0;
306 llid = sta->llid;
307 plid = sta->plid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100308 sdata = sta->sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100309
310 switch (sta->plink_state) {
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800311 case PLINK_OPN_RCVD:
312 case PLINK_OPN_SNT:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100313 /* retry timer */
314 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
315 u32 rand;
Johannes Berg0c68ae262008-10-27 15:56:10 -0700316 mpl_dbg("Mesh plink for %pM (retry, timeout): %d %d\n",
317 sta->sta.addr, sta->plink_retries,
318 sta->plink_timeout);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100319 get_random_bytes(&rand, sizeof(u32));
320 sta->plink_timeout = sta->plink_timeout +
321 rand % sta->plink_timeout;
322 ++sta->plink_retries;
Johannes Bergd0709a62008-02-25 16:27:46 +0100323 mod_plink_timer(sta, sta->plink_timeout);
Johannes Berg07346f812008-05-03 01:02:02 +0200324 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200325 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100326 0, 0);
327 break;
328 }
329 reason = cpu_to_le16(MESH_MAX_RETRIES);
330 /* fall through on else */
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800331 case PLINK_CNF_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100332 /* confirm timer */
333 if (!reason)
334 reason = cpu_to_le16(MESH_CONFIRM_TIMEOUT);
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800335 sta->plink_state = PLINK_HOLDING;
Johannes Bergd0709a62008-02-25 16:27:46 +0100336 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200337 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200338 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, plid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100339 reason);
340 break;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800341 case PLINK_HOLDING:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100342 /* holding timer */
Johannes Bergd0709a62008-02-25 16:27:46 +0100343 del_timer(&sta->plink_timer);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100344 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200345 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100346 break;
347 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200348 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100349 break;
350 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100351}
352
Johannes Berg5bb644a2009-05-17 11:40:42 +0200353#ifdef CONFIG_PM
354void mesh_plink_quiesce(struct sta_info *sta)
355{
356 if (del_timer_sync(&sta->plink_timer))
357 sta->plink_timer_was_running = true;
358}
359
360void mesh_plink_restart(struct sta_info *sta)
361{
362 if (sta->plink_timer_was_running) {
363 add_timer(&sta->plink_timer);
364 sta->plink_timer_was_running = false;
365 }
366}
367#endif
368
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100369static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
370{
371 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
372 sta->plink_timer.data = (unsigned long) sta;
373 sta->plink_timer.function = mesh_plink_timer;
374 sta->plink_timeout = timeout;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100375 add_timer(&sta->plink_timer);
376}
377
378int mesh_plink_open(struct sta_info *sta)
379{
380 __le16 llid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100381 struct ieee80211_sub_if_data *sdata = sta->sdata;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100382
Javier Cardona53e80512011-04-07 15:08:32 -0700383 if (!test_sta_flags(sta, WLAN_STA_AUTH))
384 return -EPERM;
385
Johannes Berg07346f812008-05-03 01:02:02 +0200386 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100387 get_random_bytes(&llid, 2);
388 sta->llid = llid;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800389 if (sta->plink_state != PLINK_LISTEN) {
Johannes Berg07346f812008-05-03 01:02:02 +0200390 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100391 return -EBUSY;
392 }
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800393 sta->plink_state = PLINK_OPN_SNT;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100394 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200395 spin_unlock_bh(&sta->lock);
Johannes Berg0c68ae262008-10-27 15:56:10 -0700396 mpl_dbg("Mesh plink: starting establishment with %pM\n",
397 sta->sta.addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100398
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200399 return mesh_plink_frame_tx(sdata, PLINK_OPEN,
Johannes Berg17741cd2008-09-11 00:02:02 +0200400 sta->sta.addr, llid, 0, 0);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100401}
402
403void mesh_plink_block(struct sta_info *sta)
404{
John W. Linvillec9370192010-06-21 17:14:07 -0400405 struct ieee80211_sub_if_data *sdata = sta->sdata;
406 bool deactivated;
407
Johannes Berg07346f812008-05-03 01:02:02 +0200408 spin_lock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400409 deactivated = __mesh_plink_deactivate(sta);
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800410 sta->plink_state = PLINK_BLOCKED;
Johannes Berg07346f812008-05-03 01:02:02 +0200411 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400412
413 if (deactivated)
414 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100415}
416
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100417
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200418void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100419 size_t len, struct ieee80211_rx_status *rx_status)
420{
Johannes Bergd0709a62008-02-25 16:27:46 +0100421 struct ieee80211_local *local = sdata->local;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100422 struct ieee802_11_elems elems;
423 struct sta_info *sta;
424 enum plink_event event;
425 enum plink_frame_type ftype;
426 size_t baselen;
Christian Lamparterd12c7452010-10-08 22:27:07 +0200427 bool deactivated, matches_local = true;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100428 u8 ie_len;
429 u8 *baseaddr;
430 __le16 plid, llid, reason;
Rui Paulo1460dd12009-11-09 23:46:48 +0000431#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
432 static const char *mplstates[] = {
433 [PLINK_LISTEN] = "LISTEN",
434 [PLINK_OPN_SNT] = "OPN-SNT",
435 [PLINK_OPN_RCVD] = "OPN-RCVD",
436 [PLINK_CNF_RCVD] = "CNF_RCVD",
437 [PLINK_ESTAB] = "ESTAB",
438 [PLINK_HOLDING] = "HOLDING",
439 [PLINK_BLOCKED] = "BLOCKED"
440 };
441#endif
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100442
Johannes Berg9c80d3d2008-09-08 15:41:59 +0200443 /* need action_code, aux */
444 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
445 return;
446
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100447 if (is_multicast_ether_addr(mgmt->da)) {
448 mpl_dbg("Mesh plink: ignore frame from multicast address");
449 return;
450 }
451
452 baseaddr = mgmt->u.action.u.plink_action.variable;
453 baselen = (u8 *) mgmt->u.action.u.plink_action.variable - (u8 *) mgmt;
454 if (mgmt->u.action.u.plink_action.action_code == PLINK_CONFIRM) {
455 baseaddr += 4;
David Woo70bdb6b2009-08-12 11:03:44 -0700456 baselen += 4;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100457 }
458 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
459 if (!elems.peer_link) {
460 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
461 return;
462 }
Javier Cardonab130e5c2011-05-03 16:57:07 -0700463 if (elems.rsn_len &&
464 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
Javier Cardona5cff5e02011-04-07 15:08:29 -0700465 mpl_dbg("Mesh plink: can't establish link with secure peer\n");
466 return;
467 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100468
Rui Paulo09383932009-11-09 23:46:43 +0000469 ftype = mgmt->u.action.u.plink_action.action_code;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100470 ie_len = elems.peer_link_len;
Rui Paulo09383932009-11-09 23:46:43 +0000471 if ((ftype == PLINK_OPEN && ie_len != 6) ||
472 (ftype == PLINK_CONFIRM && ie_len != 8) ||
473 (ftype == PLINK_CLOSE && ie_len != 8 && ie_len != 10)) {
474 mpl_dbg("Mesh plink: incorrect plink ie length %d %d\n",
475 ftype, ie_len);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100476 return;
477 }
478
479 if (ftype != PLINK_CLOSE && (!elems.mesh_id || !elems.mesh_config)) {
480 mpl_dbg("Mesh plink: missing necessary ie\n");
481 return;
482 }
483 /* Note the lines below are correct, the llid in the frame is the plid
484 * from the point of view of this host.
485 */
486 memcpy(&plid, PLINK_GET_LLID(elems.peer_link), 2);
Rui Paulo09383932009-11-09 23:46:43 +0000487 if (ftype == PLINK_CONFIRM || (ftype == PLINK_CLOSE && ie_len == 10))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100488 memcpy(&llid, PLINK_GET_PLID(elems.peer_link), 2);
489
Johannes Bergd0709a62008-02-25 16:27:46 +0100490 rcu_read_lock();
491
Johannes Bergabe60632009-11-25 17:46:18 +0100492 sta = sta_info_get(sdata, mgmt->sa);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100493 if (!sta && ftype != PLINK_OPEN) {
494 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
Johannes Bergd0709a62008-02-25 16:27:46 +0100495 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100496 return;
497 }
498
Javier Cardona53e80512011-04-07 15:08:32 -0700499 if (sta && !test_sta_flags(sta, WLAN_STA_AUTH)) {
500 mpl_dbg("Mesh plink: Action frame from non-authed peer\n");
501 rcu_read_unlock();
502 return;
503 }
504
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800505 if (sta && sta->plink_state == PLINK_BLOCKED) {
Johannes Bergd0709a62008-02-25 16:27:46 +0100506 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100507 return;
508 }
509
510 /* Now we will figure out the appropriate event... */
511 event = PLINK_UNDEFINED;
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200512 if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) {
Christian Lamparterd12c7452010-10-08 22:27:07 +0200513 matches_local = false;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100514 switch (ftype) {
515 case PLINK_OPEN:
516 event = OPN_RJCT;
517 break;
518 case PLINK_CONFIRM:
519 event = CNF_RJCT;
520 break;
521 case PLINK_CLOSE:
522 /* avoid warning */
523 break;
524 }
Christian Lamparterd12c7452010-10-08 22:27:07 +0200525 }
526
527 if (!sta && !matches_local) {
528 rcu_read_unlock();
529 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
530 llid = 0;
531 mesh_plink_frame_tx(sdata, PLINK_CLOSE, mgmt->sa, llid,
532 plid, reason);
533 return;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100534 } else if (!sta) {
535 /* ftype == PLINK_OPEN */
Johannes Berg881d9482009-01-21 15:13:48 +0100536 u32 rates;
Johannes Berg34e89502010-02-03 13:59:58 +0100537
538 rcu_read_unlock();
539
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100540 if (!mesh_plink_free_count(sdata)) {
541 mpl_dbg("Mesh plink error: no more free plinks\n");
542 return;
543 }
544
545 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band);
Johannes Berg03e44972008-02-27 09:56:40 +0100546 sta = mesh_plink_alloc(sdata, mgmt->sa, rates);
Johannes Berg73651ee2008-02-25 16:27:47 +0100547 if (!sta) {
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100548 mpl_dbg("Mesh plink error: plink table full\n");
549 return;
550 }
Johannes Berg34e89502010-02-03 13:59:58 +0100551 if (sta_info_insert_rcu(sta)) {
Johannes Berg73651ee2008-02-25 16:27:47 +0100552 rcu_read_unlock();
553 return;
554 }
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100555 event = OPN_ACPT;
Johannes Berg07346f812008-05-03 01:02:02 +0200556 spin_lock_bh(&sta->lock);
Christian Lamparterd12c7452010-10-08 22:27:07 +0200557 } else if (matches_local) {
Johannes Berg07346f812008-05-03 01:02:02 +0200558 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100559 switch (ftype) {
560 case PLINK_OPEN:
561 if (!mesh_plink_free_count(sdata) ||
Johannes Bergd0709a62008-02-25 16:27:46 +0100562 (sta->plid && sta->plid != plid))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100563 event = OPN_IGNR;
564 else
565 event = OPN_ACPT;
566 break;
567 case PLINK_CONFIRM:
568 if (!mesh_plink_free_count(sdata) ||
Johannes Bergd0709a62008-02-25 16:27:46 +0100569 (sta->llid != llid || sta->plid != plid))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100570 event = CNF_IGNR;
571 else
572 event = CNF_ACPT;
573 break;
574 case PLINK_CLOSE:
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800575 if (sta->plink_state == PLINK_ESTAB)
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100576 /* Do not check for llid or plid. This does not
577 * follow the standard but since multiple plinks
578 * per sta are not supported, it is necessary in
579 * order to avoid a livelock when MP A sees an
580 * establish peer link to MP B but MP B does not
581 * see it. This can be caused by a timeout in
582 * B's peer link establishment or B beign
583 * restarted.
584 */
585 event = CLS_ACPT;
586 else if (sta->plid != plid)
587 event = CLS_IGNR;
588 else if (ie_len == 7 && sta->llid != llid)
589 event = CLS_IGNR;
590 else
591 event = CLS_ACPT;
592 break;
593 default:
594 mpl_dbg("Mesh plink: unknown frame subtype\n");
Johannes Berg07346f812008-05-03 01:02:02 +0200595 spin_unlock_bh(&sta->lock);
Johannes Bergd0709a62008-02-25 16:27:46 +0100596 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100597 return;
598 }
Christian Lamparterd12c7452010-10-08 22:27:07 +0200599 } else {
600 spin_lock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100601 }
602
Rui Paulo1460dd12009-11-09 23:46:48 +0000603 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
604 mgmt->sa, mplstates[sta->plink_state],
Johannes Berg0c68ae262008-10-27 15:56:10 -0700605 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
606 event);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100607 reason = 0;
608 switch (sta->plink_state) {
609 /* spin_unlock as soon as state is updated at each case */
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800610 case PLINK_LISTEN:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100611 switch (event) {
612 case CLS_ACPT:
613 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200614 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100615 break;
616 case OPN_ACPT:
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800617 sta->plink_state = PLINK_OPN_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100618 sta->plid = plid;
619 get_random_bytes(&llid, 2);
620 sta->llid = llid;
621 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200622 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200623 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100624 0, 0);
Johannes Berg17741cd2008-09-11 00:02:02 +0200625 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100626 llid, plid, 0);
627 break;
628 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200629 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100630 break;
631 }
632 break;
633
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800634 case PLINK_OPN_SNT:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100635 switch (event) {
636 case OPN_RJCT:
637 case CNF_RJCT:
638 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
639 case CLS_ACPT:
640 if (!reason)
641 reason = cpu_to_le16(MESH_CLOSE_RCVD);
642 sta->reason = reason;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800643 sta->plink_state = PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100644 if (!mod_plink_timer(sta,
645 dot11MeshHoldingTimeout(sdata)))
646 sta->ignore_plink_timer = true;
647
648 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200649 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200650 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100651 plid, reason);
652 break;
653 case OPN_ACPT:
654 /* retry timer is left untouched */
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800655 sta->plink_state = PLINK_OPN_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100656 sta->plid = plid;
657 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200658 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200659 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100660 plid, 0);
661 break;
662 case CNF_ACPT:
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800663 sta->plink_state = PLINK_CNF_RCVD;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100664 if (!mod_plink_timer(sta,
665 dot11MeshConfirmTimeout(sdata)))
666 sta->ignore_plink_timer = true;
667
Johannes Berg07346f812008-05-03 01:02:02 +0200668 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100669 break;
670 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200671 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100672 break;
673 }
674 break;
675
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800676 case PLINK_OPN_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100677 switch (event) {
678 case OPN_RJCT:
679 case CNF_RJCT:
680 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
681 case CLS_ACPT:
682 if (!reason)
683 reason = cpu_to_le16(MESH_CLOSE_RCVD);
684 sta->reason = reason;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800685 sta->plink_state = PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100686 if (!mod_plink_timer(sta,
687 dot11MeshHoldingTimeout(sdata)))
688 sta->ignore_plink_timer = true;
689
690 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200691 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200692 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100693 plid, reason);
694 break;
695 case OPN_ACPT:
696 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200697 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200698 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100699 plid, 0);
700 break;
701 case CNF_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100702 del_timer(&sta->plink_timer);
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800703 sta->plink_state = PLINK_ESTAB;
Johannes Berg07346f812008-05-03 01:02:02 +0200704 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400705 mesh_plink_inc_estab_count(sdata);
706 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg0c68ae262008-10-27 15:56:10 -0700707 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
708 sta->sta.addr);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100709 break;
710 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200711 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100712 break;
713 }
714 break;
715
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800716 case PLINK_CNF_RCVD:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100717 switch (event) {
718 case OPN_RJCT:
719 case CNF_RJCT:
720 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
721 case CLS_ACPT:
722 if (!reason)
723 reason = cpu_to_le16(MESH_CLOSE_RCVD);
724 sta->reason = reason;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800725 sta->plink_state = PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100726 if (!mod_plink_timer(sta,
727 dot11MeshHoldingTimeout(sdata)))
728 sta->ignore_plink_timer = true;
729
730 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200731 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200732 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100733 plid, reason);
Johannes Bergff59dc72008-02-25 10:11:50 +0100734 break;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100735 case OPN_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100736 del_timer(&sta->plink_timer);
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800737 sta->plink_state = PLINK_ESTAB;
Johannes Berg07346f812008-05-03 01:02:02 +0200738 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400739 mesh_plink_inc_estab_count(sdata);
740 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg0c68ae262008-10-27 15:56:10 -0700741 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
742 sta->sta.addr);
Johannes Berg17741cd2008-09-11 00:02:02 +0200743 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100744 plid, 0);
745 break;
746 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200747 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100748 break;
749 }
750 break;
751
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800752 case PLINK_ESTAB:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100753 switch (event) {
754 case CLS_ACPT:
755 reason = cpu_to_le16(MESH_CLOSE_RCVD);
756 sta->reason = reason;
John W. Linvillec9370192010-06-21 17:14:07 -0400757 deactivated = __mesh_plink_deactivate(sta);
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800758 sta->plink_state = PLINK_HOLDING;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100759 llid = sta->llid;
Johannes Bergd0709a62008-02-25 16:27:46 +0100760 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
Johannes Berg07346f812008-05-03 01:02:02 +0200761 spin_unlock_bh(&sta->lock);
John W. Linvillec9370192010-06-21 17:14:07 -0400762 if (deactivated)
763 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg17741cd2008-09-11 00:02:02 +0200764 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100765 plid, reason);
766 break;
767 case OPN_ACPT:
768 llid = sta->llid;
Johannes Berg07346f812008-05-03 01:02:02 +0200769 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200770 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100771 plid, 0);
772 break;
773 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200774 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100775 break;
776 }
777 break;
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800778 case PLINK_HOLDING:
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100779 switch (event) {
780 case CLS_ACPT:
Johannes Bergd0709a62008-02-25 16:27:46 +0100781 if (del_timer(&sta->plink_timer))
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100782 sta->ignore_plink_timer = 1;
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100783 mesh_plink_fsm_restart(sta);
Johannes Berg07346f812008-05-03 01:02:02 +0200784 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100785 break;
786 case OPN_ACPT:
787 case CNF_ACPT:
788 case OPN_RJCT:
789 case CNF_RJCT:
790 llid = sta->llid;
791 reason = sta->reason;
Johannes Berg07346f812008-05-03 01:02:02 +0200792 spin_unlock_bh(&sta->lock);
Johannes Berg17741cd2008-09-11 00:02:02 +0200793 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr,
794 llid, plid, reason);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100795 break;
796 default:
Johannes Berg07346f812008-05-03 01:02:02 +0200797 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100798 }
799 break;
800 default:
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800801 /* should not get here, PLINK_BLOCKED is dealt with at the
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800802 * beginning of the function
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100803 */
Johannes Berg07346f812008-05-03 01:02:02 +0200804 spin_unlock_bh(&sta->lock);
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100805 break;
806 }
Johannes Bergd0709a62008-02-25 16:27:46 +0100807
808 rcu_read_unlock();
Luis Carlos Coboc3896d2c2008-02-23 15:17:13 +0100809}