projects / deliverable / linux.git / blob
? search:


2e0ae73106972cf5886d76d3f58318e65b716118
[deliverable/linux.git] / net / mac80211 / mesh_plink.c
1 /*
2 * Copyright (c) 2008, 2009 open80211s Ltd.
3 * 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 */
9 #include <linux/gfp.h>
10 #include <linux/kernel.h>
11 #include <linux/random.h>
12 #include "ieee80211_i.h"
13 #include "rate.h"
14 #include "mesh.h"
15
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
22 #define PLINK_GET_LLID(p) (p + 2)
23 #define PLINK_GET_PLID(p) (p + 4)
24
25 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
26 jiffies + HZ * t / 1000))
27
28 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
29 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
30 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
31 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
32 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
33
34 /* We only need a valid sta if user configured a minimum rssi_threshold. */
35 #define rssi_threshold_check(sta, sdata) \
36 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
37 (sta && (s8) -ewma_read(&sta->avg_signal) > \
38 sdata->u.mesh.mshcfg.rssi_threshold))
39
40 enum plink_event {
41 PLINK_UNDEFINED,
42 OPN_ACPT,
43 OPN_RJCT,
44 OPN_IGNR,
45 CNF_ACPT,
46 CNF_RJCT,
47 CNF_IGNR,
48 CLS_ACPT,
49 CLS_IGNR
50 };
51
52 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
53 enum ieee80211_self_protected_actioncode action,
54 u8 *da, __le16 llid, __le16 plid, __le16 reason);
55
56 static inline
57 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
58 {
59 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
60 mesh_accept_plinks_update(sdata);
61 }
62
63 static inline
64 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
65 {
66 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
67 mesh_accept_plinks_update(sdata);
68 }
69
70 /**
71 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
72 *
73 * @sta: mesh peer link to restart
74 *
75 * Locking: this function must be called holding sta->lock
76 */
77 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
78 {
79 sta->plink_state = NL80211_PLINK_LISTEN;
80 sta->llid = sta->plid = sta->reason = 0;
81 sta->plink_retries = 0;
82 }
83
84 /*
85 * Allocate mesh sta entry and insert into station table
86 */
87 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
88 u8 *hw_addr)
89 {
90 struct sta_info *sta;
91
92 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
93 return NULL;
94
95 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
96 if (!sta)
97 return NULL;
98
99 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
100 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
101 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
102
103 set_sta_flag(sta, WLAN_STA_WME);
104
105 return sta;
106 }
107
108 /** mesh_set_ht_prot_mode - set correct HT protection mode
109 *
110 * Section 9.23.3.5 of IEEE 80211s standard describes the protection rules for
111 * HT mesh STA in a MBSS. Three HT protection modes are supported for now,
112 * non-HT mixed mode, 20MHz-protection and no-protection mode. non-HT mixed
113 * mode is selected if any non-HT peers are present in our MBSS.
114 * 20MHz-protection mode is selected if all peers in our 20/40MHz MBSS support
115 * HT and atleast one HT20 peer is present. Otherwise no-protection mode is
116 * selected.
117 */
118 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
119 {
120 struct ieee80211_local *local = sdata->local;
121 struct sta_info *sta;
122 u32 changed = 0;
123 u16 ht_opmode;
124 bool non_ht_sta = false, ht20_sta = false;
125
126 if (local->_oper_channel_type == NL80211_CHAN_NO_HT)
127 return 0;
128
129 rcu_read_lock();
130 list_for_each_entry_rcu(sta, &local->sta_list, list) {
131 if (sdata == sta->sdata &&
132 sta->plink_state == NL80211_PLINK_ESTAB) {
133 switch (sta->ch_type) {
134 case NL80211_CHAN_NO_HT:
135 mpl_dbg("mesh_plink %pM: nonHT sta (%pM) is present",
136 sdata->vif.addr, sta->sta.addr);
137 non_ht_sta = true;
138 goto out;
139 case NL80211_CHAN_HT20:
140 mpl_dbg("mesh_plink %pM: HT20 sta (%pM) is present",
141 sdata->vif.addr, sta->sta.addr);
142 ht20_sta = true;
143 default:
144 break;
145 }
146 }
147 }
148 out:
149 rcu_read_unlock();
150
151 if (non_ht_sta)
152 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
153 else if (ht20_sta && local->_oper_channel_type > NL80211_CHAN_HT20)
154 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
155 else
156 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
157
158 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
159 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
160 changed = BSS_CHANGED_HT;
161 mpl_dbg("mesh_plink %pM: protection mode changed to %d",
162 sdata->vif.addr, ht_opmode);
163 }
164
165 return changed;
166 }
167
168 /**
169 * __mesh_plink_deactivate - deactivate mesh peer link
170 *
171 * @sta: mesh peer link to deactivate
172 *
173 * All mesh paths with this peer as next hop will be flushed
174 *
175 * Locking: the caller must hold sta->lock
176 */
177 static bool __mesh_plink_deactivate(struct sta_info *sta)
178 {
179 struct ieee80211_sub_if_data *sdata = sta->sdata;
180 bool deactivated = false;
181
182 if (sta->plink_state == NL80211_PLINK_ESTAB) {
183 mesh_plink_dec_estab_count(sdata);
184 deactivated = true;
185 }
186 sta->plink_state = NL80211_PLINK_BLOCKED;
187 mesh_path_flush_by_nexthop(sta);
188
189 return deactivated;
190 }
191
192 /**
193 * mesh_plink_deactivate - deactivate mesh peer link
194 *
195 * @sta: mesh peer link to deactivate
196 *
197 * All mesh paths with this peer as next hop will be flushed
198 */
199 void mesh_plink_deactivate(struct sta_info *sta)
200 {
201 struct ieee80211_sub_if_data *sdata = sta->sdata;
202 bool deactivated;
203
204 spin_lock_bh(&sta->lock);
205 deactivated = __mesh_plink_deactivate(sta);
206 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
207 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
208 sta->sta.addr, sta->llid, sta->plid,
209 sta->reason);
210 spin_unlock_bh(&sta->lock);
211
212 if (deactivated)
213 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
214 }
215
216 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
217 enum ieee80211_self_protected_actioncode action,
218 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
219 struct ieee80211_local *local = sdata->local;
220 struct sk_buff *skb;
221 struct ieee80211_mgmt *mgmt;
222 bool include_plid = false;
223 u16 peering_proto = 0;
224 u8 *pos, ie_len = 4;
225 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
226 sizeof(mgmt->u.action.u.self_prot);
227
228 skb = dev_alloc_skb(local->tx_headroom +
229 hdr_len +
230 2 + /* capability info */
231 2 + /* AID */
232 2 + 8 + /* supported rates */
233 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
234 2 + sdata->u.mesh.mesh_id_len +
235 2 + sizeof(struct ieee80211_meshconf_ie) +
236 2 + sizeof(struct ieee80211_ht_cap) +
237 2 + sizeof(struct ieee80211_ht_operation) +
238 2 + 8 + /* peering IE */
239 sdata->u.mesh.ie_len);
240 if (!skb)
241 return -1;
242 skb_reserve(skb, local->tx_headroom);
243 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
244 memset(mgmt, 0, hdr_len);
245 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
246 IEEE80211_STYPE_ACTION);
247 memcpy(mgmt->da, da, ETH_ALEN);
248 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
249 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
250 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
251 mgmt->u.action.u.self_prot.action_code = action;
252
253 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
254 /* capability info */
255 pos = skb_put(skb, 2);
256 memset(pos, 0, 2);
257 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
258 /* AID */
259 pos = skb_put(skb, 2);
260 memcpy(pos + 2, &plid, 2);
261 }
262 if (ieee80211_add_srates_ie(&sdata->vif, skb, true) ||
263 ieee80211_add_ext_srates_ie(&sdata->vif, skb, true) ||
264 mesh_add_rsn_ie(skb, sdata) ||
265 mesh_add_meshid_ie(skb, sdata) ||
266 mesh_add_meshconf_ie(skb, sdata))
267 return -1;
268 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
269 if (mesh_add_meshid_ie(skb, sdata))
270 return -1;
271 }
272
273 /* Add Mesh Peering Management element */
274 switch (action) {
275 case WLAN_SP_MESH_PEERING_OPEN:
276 break;
277 case WLAN_SP_MESH_PEERING_CONFIRM:
278 ie_len += 2;
279 include_plid = true;
280 break;
281 case WLAN_SP_MESH_PEERING_CLOSE:
282 if (plid) {
283 ie_len += 2;
284 include_plid = true;
285 }
286 ie_len += 2; /* reason code */
287 break;
288 default:
289 return -EINVAL;
290 }
291
292 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
293 return -ENOMEM;
294
295 pos = skb_put(skb, 2 + ie_len);
296 *pos++ = WLAN_EID_PEER_MGMT;
297 *pos++ = ie_len;
298 memcpy(pos, &peering_proto, 2);
299 pos += 2;
300 memcpy(pos, &llid, 2);
301 pos += 2;
302 if (include_plid) {
303 memcpy(pos, &plid, 2);
304 pos += 2;
305 }
306 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
307 memcpy(pos, &reason, 2);
308 pos += 2;
309 }
310
311 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
312 if (mesh_add_ht_cap_ie(skb, sdata) ||
313 mesh_add_ht_oper_ie(skb, sdata))
314 return -1;
315 }
316
317 if (mesh_add_vendor_ies(skb, sdata))
318 return -1;
319
320 ieee80211_tx_skb(sdata, skb);
321 return 0;
322 }
323
324 /* mesh_peer_init - initialize new mesh peer and return resulting sta_info
325 *
326 * @sdata: local meshif
327 * @addr: peer's address
328 * @elems: IEs from beacon or mesh peering frame
329 *
330 * call under RCU
331 */
332 static struct sta_info *mesh_peer_init(struct ieee80211_sub_if_data *sdata,
333 u8 *addr,
334 struct ieee802_11_elems *elems)
335 {
336 struct ieee80211_local *local = sdata->local;
337 enum ieee80211_band band = local->oper_channel->band;
338 struct ieee80211_supported_band *sband;
339 u32 rates, basic_rates = 0;
340 struct sta_info *sta;
341 bool insert = false;
342
343 sband = local->hw.wiphy->bands[band];
344 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
345
346 sta = sta_info_get(sdata, addr);
347 if (!sta) {
348 sta = mesh_plink_alloc(sdata, addr);
349 if (!sta)
350 return NULL;
351 insert = true;
352 }
353
354 spin_lock_bh(&sta->lock);
355 sta->last_rx = jiffies;
356 sta->sta.supp_rates[band] = rates;
357 if (elems->ht_cap_elem &&
358 sdata->local->_oper_channel_type != NL80211_CHAN_NO_HT)
359 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
360 elems->ht_cap_elem,
361 &sta->sta.ht_cap);
362 else
363 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
364
365 if (elems->ht_operation) {
366 if (!(elems->ht_operation->ht_param &
367 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
368 sta->sta.ht_cap.cap &=
369 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
370 sta->ch_type =
371 ieee80211_ht_oper_to_channel_type(elems->ht_operation);
372 }
373
374 rate_control_rate_init(sta);
375 spin_unlock_bh(&sta->lock);
376
377 if (insert && sta_info_insert(sta))
378 return NULL;
379
380 return sta;
381 }
382
383 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
384 u8 *hw_addr,
385 struct ieee802_11_elems *elems)
386 {
387 struct sta_info *sta;
388
389 /* Userspace handles peer allocation when security is enabled */
390 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) {
391 cfg80211_notify_new_peer_candidate(sdata->dev, hw_addr,
392 elems->ie_start,
393 elems->total_len,
394 GFP_KERNEL);
395 return;
396 }
397
398 rcu_read_lock();
399 sta = mesh_peer_init(sdata, hw_addr, elems);
400 if (!sta)
401 goto out;
402
403 if (mesh_peer_accepts_plinks(elems) &&
404 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))
408 mesh_plink_open(sta);
409
410 out:
411 rcu_read_unlock();
412 }
413
414 static void mesh_plink_timer(unsigned long data)
415 {
416 struct sta_info *sta;
417 __le16 llid, plid, reason;
418 struct ieee80211_sub_if_data *sdata;
419
420 /*
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 */
425 sta = (struct sta_info *) data;
426
427 if (sta->sdata->local->quiescing) {
428 sta->plink_timer_was_running = true;
429 return;
430 }
431
432 spin_lock_bh(&sta->lock);
433 if (sta->ignore_plink_timer) {
434 sta->ignore_plink_timer = false;
435 spin_unlock_bh(&sta->lock);
436 return;
437 }
438 mpl_dbg("Mesh plink timer for %pM fired on state %d\n",
439 sta->sta.addr, sta->plink_state);
440 reason = 0;
441 llid = sta->llid;
442 plid = sta->plid;
443 sdata = sta->sdata;
444
445 switch (sta->plink_state) {
446 case NL80211_PLINK_OPN_RCVD:
447 case NL80211_PLINK_OPN_SNT:
448 /* retry timer */
449 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
450 u32 rand;
451 mpl_dbg("Mesh plink for %pM (retry, timeout): %d %d\n",
452 sta->sta.addr, sta->plink_retries,
453 sta->plink_timeout);
454 get_random_bytes(&rand, sizeof(u32));
455 sta->plink_timeout = sta->plink_timeout +
456 rand % sta->plink_timeout;
457 ++sta->plink_retries;
458 mod_plink_timer(sta, sta->plink_timeout);
459 spin_unlock_bh(&sta->lock);
460 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
461 sta->sta.addr, llid, 0, 0);
462 break;
463 }
464 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
465 /* fall through on else */
466 case NL80211_PLINK_CNF_RCVD:
467 /* confirm timer */
468 if (!reason)
469 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
470 sta->plink_state = NL80211_PLINK_HOLDING;
471 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
472 spin_unlock_bh(&sta->lock);
473 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
474 sta->sta.addr, llid, plid, reason);
475 break;
476 case NL80211_PLINK_HOLDING:
477 /* holding timer */
478 del_timer(&sta->plink_timer);
479 mesh_plink_fsm_restart(sta);
480 spin_unlock_bh(&sta->lock);
481 break;
482 default:
483 spin_unlock_bh(&sta->lock);
484 break;
485 }
486 }
487
488 #ifdef CONFIG_PM
489 void mesh_plink_quiesce(struct sta_info *sta)
490 {
491 if (del_timer_sync(&sta->plink_timer))
492 sta->plink_timer_was_running = true;
493 }
494
495 void mesh_plink_restart(struct sta_info *sta)
496 {
497 if (sta->plink_timer_was_running) {
498 add_timer(&sta->plink_timer);
499 sta->plink_timer_was_running = false;
500 }
501 }
502 #endif
503
504 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
505 {
506 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
507 sta->plink_timer.data = (unsigned long) sta;
508 sta->plink_timer.function = mesh_plink_timer;
509 sta->plink_timeout = timeout;
510 add_timer(&sta->plink_timer);
511 }
512
513 int mesh_plink_open(struct sta_info *sta)
514 {
515 __le16 llid;
516 struct ieee80211_sub_if_data *sdata = sta->sdata;
517
518 if (!test_sta_flag(sta, WLAN_STA_AUTH))
519 return -EPERM;
520
521 spin_lock_bh(&sta->lock);
522 get_random_bytes(&llid, 2);
523 sta->llid = llid;
524 if (sta->plink_state != NL80211_PLINK_LISTEN) {
525 spin_unlock_bh(&sta->lock);
526 return -EBUSY;
527 }
528 sta->plink_state = NL80211_PLINK_OPN_SNT;
529 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
530 spin_unlock_bh(&sta->lock);
531 mpl_dbg("Mesh plink: starting establishment with %pM\n",
532 sta->sta.addr);
533
534 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
535 sta->sta.addr, llid, 0, 0);
536 }
537
538 void mesh_plink_block(struct sta_info *sta)
539 {
540 struct ieee80211_sub_if_data *sdata = sta->sdata;
541 bool deactivated;
542
543 spin_lock_bh(&sta->lock);
544 deactivated = __mesh_plink_deactivate(sta);
545 sta->plink_state = NL80211_PLINK_BLOCKED;
546 spin_unlock_bh(&sta->lock);
547
548 if (deactivated)
549 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
550 }
551
552
553 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
554 size_t len, struct ieee80211_rx_status *rx_status)
555 {
556 struct ieee802_11_elems elems;
557 struct sta_info *sta;
558 enum plink_event event;
559 enum ieee80211_self_protected_actioncode ftype;
560 size_t baselen;
561 bool matches_local = true;
562 u8 ie_len;
563 u8 *baseaddr;
564 u32 changed = 0;
565 __le16 plid, llid, reason;
566 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
567 static const char *mplstates[] = {
568 [NL80211_PLINK_LISTEN] = "LISTEN",
569 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
570 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
571 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
572 [NL80211_PLINK_ESTAB] = "ESTAB",
573 [NL80211_PLINK_HOLDING] = "HOLDING",
574 [NL80211_PLINK_BLOCKED] = "BLOCKED"
575 };
576 #endif
577
578 /* need action_code, aux */
579 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
580 return;
581
582 if (is_multicast_ether_addr(mgmt->da)) {
583 mpl_dbg("Mesh plink: ignore frame from multicast address");
584 return;
585 }
586
587 baseaddr = mgmt->u.action.u.self_prot.variable;
588 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
589 if (mgmt->u.action.u.self_prot.action_code ==
590 WLAN_SP_MESH_PEERING_CONFIRM) {
591 baseaddr += 4;
592 baselen += 4;
593 }
594 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
595 if (!elems.peering) {
596 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
597 return;
598 }
599 if (elems.rsn_len &&
600 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
601 mpl_dbg("Mesh plink: can't establish link with secure peer\n");
602 return;
603 }
604
605 ftype = mgmt->u.action.u.self_prot.action_code;
606 ie_len = elems.peering_len;
607 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
608 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
609 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
610 && ie_len != 8)) {
611 mpl_dbg("Mesh plink: incorrect plink ie length %d %d\n",
612 ftype, ie_len);
613 return;
614 }
615
616 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
617 (!elems.mesh_id || !elems.mesh_config)) {
618 mpl_dbg("Mesh plink: missing necessary ie\n");
619 return;
620 }
621 /* Note the lines below are correct, the llid in the frame is the plid
622 * from the point of view of this host.
623 */
624 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
625 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
626 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
627 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
628
629 rcu_read_lock();
630
631 sta = sta_info_get(sdata, mgmt->sa);
632 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
633 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
634 rcu_read_unlock();
635 return;
636 }
637
638 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
639 !rssi_threshold_check(sta, sdata)) {
640 mpl_dbg("Mesh plink: %pM does not meet rssi threshold\n",
641 mgmt->sa);
642 rcu_read_unlock();
643 return;
644 }
645
646 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
647 mpl_dbg("Mesh plink: Action frame from non-authed peer\n");
648 rcu_read_unlock();
649 return;
650 }
651
652 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
653 rcu_read_unlock();
654 return;
655 }
656
657 /* Now we will figure out the appropriate event... */
658 event = PLINK_UNDEFINED;
659 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
660 !mesh_matches_local(sdata, &elems)) {
661 matches_local = false;
662 switch (ftype) {
663 case WLAN_SP_MESH_PEERING_OPEN:
664 event = OPN_RJCT;
665 break;
666 case WLAN_SP_MESH_PEERING_CONFIRM:
667 event = CNF_RJCT;
668 break;
669 default:
670 break;
671 }
672 }
673
674 if (!sta && !matches_local) {
675 rcu_read_unlock();
676 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
677 llid = 0;
678 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
679 mgmt->sa, llid, plid, reason);
680 return;
681 } else if (!sta) {
682 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
683 if (!mesh_plink_free_count(sdata)) {
684 mpl_dbg("Mesh plink error: no more free plinks\n");
685 rcu_read_unlock();
686 return;
687 }
688 event = OPN_ACPT;
689 } else if (matches_local) {
690 switch (ftype) {
691 case WLAN_SP_MESH_PEERING_OPEN:
692 if (!mesh_plink_free_count(sdata) ||
693 (sta->plid && sta->plid != plid))
694 event = OPN_IGNR;
695 else
696 event = OPN_ACPT;
697 break;
698 case WLAN_SP_MESH_PEERING_CONFIRM:
699 if (!mesh_plink_free_count(sdata) ||
700 (sta->llid != llid || sta->plid != plid))
701 event = CNF_IGNR;
702 else
703 event = CNF_ACPT;
704 break;
705 case WLAN_SP_MESH_PEERING_CLOSE:
706 if (sta->plink_state == NL80211_PLINK_ESTAB)
707 /* Do not check for llid or plid. This does not
708 * follow the standard but since multiple plinks
709 * per sta are not supported, it is necessary in
710 * order to avoid a livelock when MP A sees an
711 * establish peer link to MP B but MP B does not
712 * see it. This can be caused by a timeout in
713 * B's peer link establishment or B beign
714 * restarted.
715 */
716 event = CLS_ACPT;
717 else if (sta->plid != plid)
718 event = CLS_IGNR;
719 else if (ie_len == 7 && sta->llid != llid)
720 event = CLS_IGNR;
721 else
722 event = CLS_ACPT;
723 break;
724 default:
725 mpl_dbg("Mesh plink: unknown frame subtype\n");
726 rcu_read_unlock();
727 return;
728 }
729 }
730
731 if (event == OPN_ACPT) {
732 /* allocate sta entry if necessary and update info */
733 sta = mesh_peer_init(sdata, mgmt->sa, &elems);
734 if (!sta) {
735 mpl_dbg("Mesh plink: failed to init peer!\n");
736 rcu_read_unlock();
737 return;
738 }
739 }
740
741 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
742 mgmt->sa, mplstates[sta->plink_state],
743 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
744 event);
745 reason = 0;
746 spin_lock_bh(&sta->lock);
747 switch (sta->plink_state) {
748 /* spin_unlock as soon as state is updated at each case */
749 case NL80211_PLINK_LISTEN:
750 switch (event) {
751 case CLS_ACPT:
752 mesh_plink_fsm_restart(sta);
753 spin_unlock_bh(&sta->lock);
754 break;
755 case OPN_ACPT:
756 sta->plink_state = NL80211_PLINK_OPN_RCVD;
757 sta->plid = plid;
758 get_random_bytes(&llid, 2);
759 sta->llid = llid;
760 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
761 spin_unlock_bh(&sta->lock);
762 mesh_plink_frame_tx(sdata,
763 WLAN_SP_MESH_PEERING_OPEN,
764 sta->sta.addr, llid, 0, 0);
765 mesh_plink_frame_tx(sdata,
766 WLAN_SP_MESH_PEERING_CONFIRM,
767 sta->sta.addr, llid, plid, 0);
768 break;
769 default:
770 spin_unlock_bh(&sta->lock);
771 break;
772 }
773 break;
774
775 case NL80211_PLINK_OPN_SNT:
776 switch (event) {
777 case OPN_RJCT:
778 case CNF_RJCT:
779 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
780 case CLS_ACPT:
781 if (!reason)
782 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
783 sta->reason = reason;
784 sta->plink_state = NL80211_PLINK_HOLDING;
785 if (!mod_plink_timer(sta,
786 dot11MeshHoldingTimeout(sdata)))
787 sta->ignore_plink_timer = true;
788
789 llid = sta->llid;
790 spin_unlock_bh(&sta->lock);
791 mesh_plink_frame_tx(sdata,
792 WLAN_SP_MESH_PEERING_CLOSE,
793 sta->sta.addr, llid, plid, reason);
794 break;
795 case OPN_ACPT:
796 /* retry timer is left untouched */
797 sta->plink_state = NL80211_PLINK_OPN_RCVD;
798 sta->plid = plid;
799 llid = sta->llid;
800 spin_unlock_bh(&sta->lock);
801 mesh_plink_frame_tx(sdata,
802 WLAN_SP_MESH_PEERING_CONFIRM,
803 sta->sta.addr, llid, plid, 0);
804 break;
805 case CNF_ACPT:
806 sta->plink_state = NL80211_PLINK_CNF_RCVD;
807 if (!mod_plink_timer(sta,
808 dot11MeshConfirmTimeout(sdata)))
809 sta->ignore_plink_timer = true;
810
811 spin_unlock_bh(&sta->lock);
812 break;
813 default:
814 spin_unlock_bh(&sta->lock);
815 break;
816 }
817 break;
818
819 case NL80211_PLINK_OPN_RCVD:
820 switch (event) {
821 case OPN_RJCT:
822 case CNF_RJCT:
823 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
824 case CLS_ACPT:
825 if (!reason)
826 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
827 sta->reason = reason;
828 sta->plink_state = NL80211_PLINK_HOLDING;
829 if (!mod_plink_timer(sta,
830 dot11MeshHoldingTimeout(sdata)))
831 sta->ignore_plink_timer = true;
832
833 llid = sta->llid;
834 spin_unlock_bh(&sta->lock);
835 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
836 sta->sta.addr, llid, plid, reason);
837 break;
838 case OPN_ACPT:
839 llid = sta->llid;
840 spin_unlock_bh(&sta->lock);
841 mesh_plink_frame_tx(sdata,
842 WLAN_SP_MESH_PEERING_CONFIRM,
843 sta->sta.addr, llid, plid, 0);
844 break;
845 case CNF_ACPT:
846 del_timer(&sta->plink_timer);
847 sta->plink_state = NL80211_PLINK_ESTAB;
848 spin_unlock_bh(&sta->lock);
849 mesh_plink_inc_estab_count(sdata);
850 changed |= mesh_set_ht_prot_mode(sdata);
851 changed |= BSS_CHANGED_BEACON;
852 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
853 sta->sta.addr);
854 break;
855 default:
856 spin_unlock_bh(&sta->lock);
857 break;
858 }
859 break;
860
861 case NL80211_PLINK_CNF_RCVD:
862 switch (event) {
863 case OPN_RJCT:
864 case CNF_RJCT:
865 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
866 case CLS_ACPT:
867 if (!reason)
868 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
869 sta->reason = reason;
870 sta->plink_state = NL80211_PLINK_HOLDING;
871 if (!mod_plink_timer(sta,
872 dot11MeshHoldingTimeout(sdata)))
873 sta->ignore_plink_timer = true;
874
875 llid = sta->llid;
876 spin_unlock_bh(&sta->lock);
877 mesh_plink_frame_tx(sdata,
878 WLAN_SP_MESH_PEERING_CLOSE,
879 sta->sta.addr, llid, plid, reason);
880 break;
881 case OPN_ACPT:
882 del_timer(&sta->plink_timer);
883 sta->plink_state = NL80211_PLINK_ESTAB;
884 spin_unlock_bh(&sta->lock);
885 mesh_plink_inc_estab_count(sdata);
886 changed |= mesh_set_ht_prot_mode(sdata);
887 changed |= BSS_CHANGED_BEACON;
888 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
889 sta->sta.addr);
890 mesh_plink_frame_tx(sdata,
891 WLAN_SP_MESH_PEERING_CONFIRM,
892 sta->sta.addr, llid, plid, 0);
893 break;
894 default:
895 spin_unlock_bh(&sta->lock);
896 break;
897 }
898 break;
899
900 case NL80211_PLINK_ESTAB:
901 switch (event) {
902 case CLS_ACPT:
903 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
904 sta->reason = reason;
905 __mesh_plink_deactivate(sta);
906 sta->plink_state = NL80211_PLINK_HOLDING;
907 llid = sta->llid;
908 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
909 spin_unlock_bh(&sta->lock);
910 changed |= mesh_set_ht_prot_mode(sdata);
911 changed |= BSS_CHANGED_BEACON;
912 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
913 sta->sta.addr, llid, plid, reason);
914 break;
915 case OPN_ACPT:
916 llid = sta->llid;
917 spin_unlock_bh(&sta->lock);
918 mesh_plink_frame_tx(sdata,
919 WLAN_SP_MESH_PEERING_CONFIRM,
920 sta->sta.addr, llid, plid, 0);
921 break;
922 default:
923 spin_unlock_bh(&sta->lock);
924 break;
925 }
926 break;
927 case NL80211_PLINK_HOLDING:
928 switch (event) {
929 case CLS_ACPT:
930 if (del_timer(&sta->plink_timer))
931 sta->ignore_plink_timer = 1;
932 mesh_plink_fsm_restart(sta);
933 spin_unlock_bh(&sta->lock);
934 break;
935 case OPN_ACPT:
936 case CNF_ACPT:
937 case OPN_RJCT:
938 case CNF_RJCT:
939 llid = sta->llid;
940 reason = sta->reason;
941 spin_unlock_bh(&sta->lock);
942 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
943 sta->sta.addr, llid, plid, reason);
944 break;
945 default:
946 spin_unlock_bh(&sta->lock);
947 }
948 break;
949 default:
950 /* should not get here, PLINK_BLOCKED is dealt with at the
951 * beginning of the function
952 */
953 spin_unlock_bh(&sta->lock);
954 break;
955 }
956
957 rcu_read_unlock();
958
959 if (changed)
960 ieee80211_bss_info_change_notify(sdata, changed);
961 }
Linux kernel - Deliverables
This page took 0.051349 seconds and 4 git commands to generate.