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