projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-5.3/io_uring-20190711' of git://git.kernel.dk/linux-block
[linux-2.6-block.git] / net / mac80211 / mesh_plink.c
CommitLineData
d2912cb1 1// SPDX-License-Identifier: GPL-2.0-only
c3896d2c 2/*
264d9b7d 3 * Copyright (c) 2008, 2009 open80211s Ltd.
4abb52a4 4 * Copyright (C) 2019 Intel Corporation
c3896d2c 5 * Author: Luis Carlos Cobo <luisca@cozybit.com>
c3896d2c 6 */
5a0e3ad6 7#include <linux/gfp.h>
902acc78
JB		 8#include <linux/kernel.h>
9#include <linux/random.h>
b2d09103
IM		 10#include <linux/rculist.h>
11
c3896d2c 12#include "ieee80211_i.h"
2c8dccc7 13#include "rate.h"
c3896d2c 14#include "mesh.h"
c3896d2c 15
a69bd8e6 16#define PLINK_CNF_AID(mgmt) ((mgmt)->u.action.u.self_prot.variable + 2)
8db09850
TP		 17#define PLINK_GET_LLID(p) (p + 2)
18#define PLINK_GET_PLID(p) (p + 4)
c3896d2c 19
433f5bc1 20#define mod_plink_timer(s, t) (mod_timer(&s->mesh->plink_timer, \
cc57ac53 21 jiffies + msecs_to_jiffies(t)))
c3896d2c 22
c3896d2c
LCC		 23enum plink_event {
24 PLINK_UNDEFINED,
25 OPN_ACPT,
26 OPN_RJCT,
27 OPN_IGNR,
28 CNF_ACPT,
29 CNF_RJCT,
30 CNF_IGNR,
31 CLS_ACPT,
32 CLS_IGNR
33};
34
95e48add
TP		 35static const char * const mplstates[] = {
36 [NL80211_PLINK_LISTEN] = "LISTEN",
37 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
38 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
39 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
40 [NL80211_PLINK_ESTAB] = "ESTAB",
41 [NL80211_PLINK_HOLDING] = "HOLDING",
42 [NL80211_PLINK_BLOCKED] = "BLOCKED"
43};
44
45static const char * const mplevents[] = {
46 [PLINK_UNDEFINED] = "NONE",
47 [OPN_ACPT] = "OPN_ACPT",
48 [OPN_RJCT] = "OPN_RJCT",
49 [OPN_IGNR] = "OPN_IGNR",
50 [CNF_ACPT] = "CNF_ACPT",
51 [CNF_RJCT] = "CNF_RJCT",
52 [CNF_IGNR] = "CNF_IGNR",
53 [CLS_ACPT] = "CLS_ACPT",
54 [CLS_IGNR] = "CLS_IGNR"
55};
56
36c9bb29
BC		 57/* We only need a valid sta if user configured a minimum rssi_threshold. */
58static bool rssi_threshold_check(struct ieee80211_sub_if_data *sdata,
59 struct sta_info *sta)
60{
61 s32 rssi_threshold = sdata->u.mesh.mshcfg.rssi_threshold;
62 return rssi_threshold == 0 ||
e5a9f8d0 63 (sta &&
0be6ed13 64 (s8)-ewma_signal_read(&sta->rx_stats_avg.signal) >
e5a9f8d0 65 rssi_threshold);
36c9bb29
BC		 66}
67
c3896d2c
LCC		 68/**
69 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
70 *
23c7a29c 71 * @sta: mesh peer link to restart
c3896d2c 72 *
433f5bc1 73 * Locking: this function must be called holding sta->mesh->plink_lock
c3896d2c
LCC		 74 */
75static inline void mesh_plink_fsm_restart(struct sta_info *sta)
76{
433f5bc1
JB		 77 lockdep_assert_held(&sta->mesh->plink_lock);
78 sta->mesh->plink_state = NL80211_PLINK_LISTEN;
79 sta->mesh->llid = sta->mesh->plid = sta->mesh->reason = 0;
80 sta->mesh->plink_retries = 0;
c3896d2c
LCC		 81}
82
3b144658
TP		 83/*
84 * mesh_set_short_slot_time - enable / disable ERP short slot time.
85 *
86 * The standard indirectly mandates mesh STAs to turn off short slot time by
87 * disallowing advertising this (802.11-2012 8.4.1.4), but that doesn't mean we
88 * can't be sneaky about it. Enable short slot time if all mesh STAs in the
89 * MBSS support ERP rates.
90 *
91 * Returns BSS_CHANGED_ERP_SLOT or 0 for no change.
92 */
93static u32 mesh_set_short_slot_time(struct ieee80211_sub_if_data *sdata)
94{
95 struct ieee80211_local *local = sdata->local;
21a8e9dd 96 struct ieee80211_supported_band *sband;
3b144658
TP		 97 struct sta_info *sta;
98 u32 erp_rates = 0, changed = 0;
99 int i;
100 bool short_slot = false;
101
21a8e9dd
MSS		 102 sband = ieee80211_get_sband(sdata);
103 if (!sband)
104 return changed;
105
106 if (sband->band == NL80211_BAND_5GHZ) {
3b144658
TP		 107 /* (IEEE 802.11-2012 19.4.5) */
108 short_slot = true;
109 goto out;
21a8e9dd 110 } else if (sband->band != NL80211_BAND_2GHZ) {
3b144658 111 goto out;
21a8e9dd 112 }
3b144658
TP		 113
114 for (i = 0; i < sband->n_bitrates; i++)
115 if (sband->bitrates[i].flags & IEEE80211_RATE_ERP_G)
116 erp_rates |= BIT(i);
117
118 if (!erp_rates)
119 goto out;
120
121 rcu_read_lock();
122 list_for_each_entry_rcu(sta, &local->sta_list, list) {
123 if (sdata != sta->sdata ||
433f5bc1 124 sta->mesh->plink_state != NL80211_PLINK_ESTAB)
3b144658
TP		 125 continue;
126
127 short_slot = false;
21a8e9dd 128 if (erp_rates & sta->sta.supp_rates[sband->band])
3b144658
TP		 129 short_slot = true;
130 else
131 break;
132 }
133 rcu_read_unlock();
134
135out:
136 if (sdata->vif.bss_conf.use_short_slot != short_slot) {
137 sdata->vif.bss_conf.use_short_slot = short_slot;
138 changed = BSS_CHANGED_ERP_SLOT;
139 mpl_dbg(sdata, "mesh_plink %pM: ERP short slot time %d\n",
140 sdata->vif.addr, short_slot);
141 }
142 return changed;
143}
144
2c53040f 145/**
cbf9322e 146 * mesh_set_ht_prot_mode - set correct HT protection mode
57aac7c5 147 *
cbf9322e
AN		 148 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
149 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
150 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
151 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
152 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
153 * HT20 peer is present. Otherwise no-protection mode is selected.
57aac7c5
AN		 154 */
155static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
156{
157 struct ieee80211_local *local = sdata->local;
158 struct sta_info *sta;
57aac7c5
AN		 159 u16 ht_opmode;
160 bool non_ht_sta = false, ht20_sta = false;
161
0418a445
SW		 162 switch (sdata->vif.bss_conf.chandef.width) {
163 case NL80211_CHAN_WIDTH_20_NOHT:
164 case NL80211_CHAN_WIDTH_5:
165 case NL80211_CHAN_WIDTH_10:
57aac7c5 166 return 0;
0418a445
SW		 167 default:
168 break;
169 }
57aac7c5
AN		 170
171 rcu_read_lock();
172 list_for_each_entry_rcu(sta, &local->sta_list, list) {
cbf9322e 173 if (sdata != sta->sdata ||
433f5bc1 174 sta->mesh->plink_state != NL80211_PLINK_ESTAB)
cbf9322e
AN		 175 continue;
176
52ac8c48
TP		 177 if (sta->sta.bandwidth > IEEE80211_STA_RX_BW_20)
178 continue;
179
180 if (!sta->sta.ht_cap.ht_supported) {
181 mpl_dbg(sdata, "nonHT sta (%pM) is present\n",
182 sta->sta.addr);
cbf9322e 183 non_ht_sta = true;
cbf9322e 184 break;
57aac7c5 185 }
52ac8c48
TP		 186
187 mpl_dbg(sdata, "HT20 sta (%pM) is present\n", sta->sta.addr);
188 ht20_sta = true;
57aac7c5 189 }
57aac7c5
AN		 190 rcu_read_unlock();
191
192 if (non_ht_sta)
193 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
466f310d 194 else if (ht20_sta &&
4bf88530 195 sdata->vif.bss_conf.chandef.width > NL80211_CHAN_WIDTH_20)
57aac7c5
AN		 196 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
197 else
198 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
199
52ac8c48
TP		 200 if (sdata->vif.bss_conf.ht_operation_mode == ht_opmode)
201 return 0;
57aac7c5 202
52ac8c48
TP		 203 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
204 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
205 mpl_dbg(sdata, "selected new HT protection mode %d\n", ht_opmode);
206 return BSS_CHANGED_HT;
57aac7c5
AN		 207}
208
f698d856 209static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
a69bd8e6 210 struct sta_info *sta,
bf7cd94d 211 enum ieee80211_self_protected_actioncode action,
6f101ef0 212 u8 *da, u16 llid, u16 plid, u16 reason)
bf7cd94d 213{
f698d856 214 struct ieee80211_local *local = sdata->local;
3b69a9c5 215 struct sk_buff *skb;
e7570dfb 216 struct ieee80211_tx_info *info;
c3896d2c
LCC		 217 struct ieee80211_mgmt *mgmt;
218 bool include_plid = false;
8db09850 219 u16 peering_proto = 0;
3b69a9c5 220 u8 *pos, ie_len = 4;
4c121fd6 221 int hdr_len = offsetofend(struct ieee80211_mgmt, u.action.u.self_prot);
f609a43d 222 int err = -ENOMEM;
3b69a9c5 223
65e8b0cc 224 skb = dev_alloc_skb(local->tx_headroom +
3b69a9c5
TP		 225 hdr_len +
226 2 + /* capability info */
227 2 + /* AID */
228 2 + 8 + /* supported rates */
229 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
230 2 + sdata->u.mesh.mesh_id_len +
231 2 + sizeof(struct ieee80211_meshconf_ie) +
176f3608 232 2 + sizeof(struct ieee80211_ht_cap) +
074d46d1 233 2 + sizeof(struct ieee80211_ht_operation) +
c85fb53c
BC		 234 2 + sizeof(struct ieee80211_vht_cap) +
235 2 + sizeof(struct ieee80211_vht_operation) +
3b69a9c5
TP		 236 2 + 8 + /* peering IE */
237 sdata->u.mesh.ie_len);
c3896d2c 238 if (!skb)
87d84c45 239 return err;
e7570dfb 240 info = IEEE80211_SKB_CB(skb);
65e8b0cc 241 skb_reserve(skb, local->tx_headroom);
b080db58 242 mgmt = skb_put_zero(skb, hdr_len);
e7827a70
HH		 243 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
244 IEEE80211_STYPE_ACTION);
c3896d2c 245 memcpy(mgmt->da, da, ETH_ALEN);
47846c9b 246 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
915b5c50 247 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
8db09850
TP		 248 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
249 mgmt->u.action.u.self_prot.action_code = action;
c3896d2c 250
8db09850 251 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
21a8e9dd
MSS		 252 struct ieee80211_supported_band *sband;
253 enum nl80211_band band;
254
255 sband = ieee80211_get_sband(sdata);
256 if (!sband) {
257 err = -EINVAL;
258 goto free;
259 }
260 band = sband->band;
55de908a 261
8db09850 262 /* capability info */
e45a79da 263 pos = skb_put_zero(skb, 2);
54ef656b 264 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
8db09850
TP		 265 /* AID */
266 pos = skb_put(skb, 2);
a69bd8e6 267 put_unaligned_le16(sta->sta.aid, pos);
c3896d2c 268 }
55de908a
JB		 269 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
270 ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
bf7cd94d
JB		 271 mesh_add_rsn_ie(sdata, skb) ||
272 mesh_add_meshid_ie(sdata, skb) ||
273 mesh_add_meshconf_ie(sdata, skb))
f609a43d 274 goto free;
8db09850 275 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
e7570dfb 276 info->flags |= IEEE80211_TX_CTL_NO_ACK;
bf7cd94d 277 if (mesh_add_meshid_ie(sdata, skb))
f609a43d 278 goto free;
c3896d2c
LCC		 279 }
280
8db09850 281 /* Add Mesh Peering Management element */
c3896d2c 282 switch (action) {
54ef656b 283 case WLAN_SP_MESH_PEERING_OPEN:
c3896d2c 284 break;
54ef656b 285 case WLAN_SP_MESH_PEERING_CONFIRM:
8db09850 286 ie_len += 2;
c3896d2c
LCC		 287 include_plid = true;
288 break;
54ef656b 289 case WLAN_SP_MESH_PEERING_CLOSE:
8db09850
TP		 290 if (plid) {
291 ie_len += 2;
c3896d2c
LCC		 292 include_plid = true;
293 }
8db09850 294 ie_len += 2; /* reason code */
c3896d2c 295 break;
8db09850 296 default:
f609a43d
TP		 297 err = -EINVAL;
298 goto free;
c3896d2c
LCC		 299 }
300
8db09850 301 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
f609a43d 302 goto free;
8db09850 303
c3896d2c 304 pos = skb_put(skb, 2 + ie_len);
8db09850 305 *pos++ = WLAN_EID_PEER_MGMT;
c3896d2c 306 *pos++ = ie_len;
8db09850
TP		 307 memcpy(pos, &peering_proto, 2);
308 pos += 2;
6f101ef0 309 put_unaligned_le16(llid, pos);
8db09850 310 pos += 2;
c3896d2c 311 if (include_plid) {
6f101ef0 312 put_unaligned_le16(plid, pos);
8db09850 313 pos += 2;
c3896d2c 314 }
54ef656b 315 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
6f101ef0 316 put_unaligned_le16(reason, pos);
8db09850 317 pos += 2;
c3896d2c 318 }
176f3608
TP		 319
320 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
bf7cd94d 321 if (mesh_add_ht_cap_ie(sdata, skb) ||
c85fb53c
BC		 322 mesh_add_ht_oper_ie(sdata, skb) ||
323 mesh_add_vht_cap_ie(sdata, skb) ||
324 mesh_add_vht_oper_ie(sdata, skb))
f609a43d 325 goto free;
176f3608
TP		 326 }
327
bf7cd94d 328 if (mesh_add_vendor_ies(sdata, skb))
f609a43d 329 goto free;
c3896d2c 330
62ae67be 331 ieee80211_tx_skb(sdata, skb);
c3896d2c 332 return 0;
f609a43d
TP		 333free:
334 kfree_skb(skb);
335 return err;
c3896d2c
LCC		 336}
337
fa87a656
BC		 338/**
339 * __mesh_plink_deactivate - deactivate mesh peer link
340 *
341 * @sta: mesh peer link to deactivate
342 *
e596af82
BC		 343 * Mesh paths with this peer as next hop should be flushed
344 * by the caller outside of plink_lock.
345 *
fa87a656
BC		 346 * Returns beacon changed flag if the beacon content changed.
347 *
348 * Locking: the caller must hold sta->mesh->plink_lock
349 */
350static u32 __mesh_plink_deactivate(struct sta_info *sta)
351{
352 struct ieee80211_sub_if_data *sdata = sta->sdata;
353 u32 changed = 0;
354
355 lockdep_assert_held(&sta->mesh->plink_lock);
356
357 if (sta->mesh->plink_state == NL80211_PLINK_ESTAB)
358 changed = mesh_plink_dec_estab_count(sdata);
359 sta->mesh->plink_state = NL80211_PLINK_BLOCKED;
fa87a656
BC		 360
361 ieee80211_mps_sta_status_update(sta);
362 changed |= ieee80211_mps_set_sta_local_pm(sta,
363 NL80211_MESH_POWER_UNKNOWN);
364
365 return changed;
366}
367
368/**
369 * mesh_plink_deactivate - deactivate mesh peer link
370 *
371 * @sta: mesh peer link to deactivate
372 *
373 * All mesh paths with this peer as next hop will be flushed
374 */
375u32 mesh_plink_deactivate(struct sta_info *sta)
376{
377 struct ieee80211_sub_if_data *sdata = sta->sdata;
378 u32 changed;
379
380 spin_lock_bh(&sta->mesh->plink_lock);
381 changed = __mesh_plink_deactivate(sta);
efc401f4
BC		 382
383 if (!sdata->u.mesh.user_mpm) {
384 sta->mesh->reason = WLAN_REASON_MESH_PEER_CANCELED;
385 mesh_plink_frame_tx(sdata, sta, WLAN_SP_MESH_PEERING_CLOSE,
386 sta->sta.addr, sta->mesh->llid,
387 sta->mesh->plid, sta->mesh->reason);
388 }
fa87a656 389 spin_unlock_bh(&sta->mesh->plink_lock);
efc401f4
BC		 390 if (!sdata->u.mesh.user_mpm)
391 del_timer_sync(&sta->mesh->plink_timer);
e596af82 392 mesh_path_flush_by_nexthop(sta);
fa87a656 393
efc401f4
BC		 394 /* make sure no readers can access nexthop sta from here on */
395 synchronize_net();
396
fa87a656
BC		 397 return changed;
398}
399
296fcba3
TP		 400static void mesh_sta_info_init(struct ieee80211_sub_if_data *sdata,
401 struct sta_info *sta,
1d6741d8 402 struct ieee802_11_elems *elems)
c3896d2c 403{
f698d856 404 struct ieee80211_local *local = sdata->local;
54ab1ffb 405 struct ieee80211_supported_band *sband;
f68d776a 406 u32 rates, basic_rates = 0, changed = 0;
abcff6ef 407 enum ieee80211_sta_rx_bandwidth bw = sta->sta.bandwidth;
c3896d2c 408
21a8e9dd
MSS		 409 sband = ieee80211_get_sband(sdata);
410 if (!sband)
411 return;
412
413 rates = ieee80211_sta_get_rates(sdata, elems, sband->band,
414 &basic_rates);
d0709a65 415
433f5bc1 416 spin_lock_bh(&sta->mesh->plink_lock);
e5a9f8d0 417 sta->rx_stats.last_rx = jiffies;
296fcba3
TP		 418
419 /* rates and capabilities don't change during peering */
433f5bc1
JB		 420 if (sta->mesh->plink_state == NL80211_PLINK_ESTAB &&
421 sta->mesh->processed_beacon)
296fcba3 422 goto out;
433f5bc1 423 sta->mesh->processed_beacon = true;
bae35d92 424
21a8e9dd 425 if (sta->sta.supp_rates[sband->band] != rates)
f68d776a 426 changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
21a8e9dd 427 sta->sta.supp_rates[sband->band] = rates;
54ab1ffb 428
52ac8c48
TP		 429 if (ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
430 elems->ht_cap_elem, sta))
431 changed |= IEEE80211_RC_BW_CHANGED;
4bf88530 432
c85fb53c
BC		 433 ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
434 elems->vht_cap_elem, sta);
435
abcff6ef
JD		 436 if (bw != sta->sta.bandwidth)
437 changed |= IEEE80211_RC_BW_CHANGED;
438
52ac8c48
TP		 439 /* HT peer is operating 20MHz-only */
440 if (elems->ht_operation &&
441 !(elems->ht_operation->ht_param &
442 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
443 if (sta->sta.bandwidth != IEEE80211_STA_RX_BW_20)
f68d776a 444 changed |= IEEE80211_RC_BW_CHANGED;
52ac8c48 445 sta->sta.bandwidth = IEEE80211_STA_RX_BW_20;
57aac7c5 446 }
c7d25828 447
1d6741d8 448 if (!test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
59cf1d65 449 rate_control_rate_init(sta);
f68d776a
TP		 450 else
451 rate_control_rate_update(local, sband, sta, changed);
296fcba3 452out:
433f5bc1 453 spin_unlock_bh(&sta->mesh->plink_lock);
296fcba3
TP		 454}
455
0e0060fc
BC		 456static int mesh_allocate_aid(struct ieee80211_sub_if_data *sdata)
457{
458 struct sta_info *sta;
459 unsigned long *aid_map;
460 int aid;
461
462 aid_map = kcalloc(BITS_TO_LONGS(IEEE80211_MAX_AID + 1),
463 sizeof(*aid_map), GFP_KERNEL);
464 if (!aid_map)
465 return -ENOMEM;
466
467 /* reserve aid 0 for mcast indication */
468 __set_bit(0, aid_map);
469
470 rcu_read_lock();
471 list_for_each_entry_rcu(sta, &sdata->local->sta_list, list)
472 __set_bit(sta->sta.aid, aid_map);
473 rcu_read_unlock();
474
475 aid = find_first_zero_bit(aid_map, IEEE80211_MAX_AID + 1);
476 kfree(aid_map);
477
478 if (aid > IEEE80211_MAX_AID)
479 return -ENOBUFS;
480
481 return aid;
482}
483
296fcba3
TP		 484static struct sta_info *
485__mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *hw_addr)
486{
487 struct sta_info *sta;
0e0060fc 488 int aid;
54ab1ffb 489
296fcba3 490 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
e87278e7
TP		 491 return NULL;
492
0e0060fc
BC		 493 aid = mesh_allocate_aid(sdata);
494 if (aid < 0)
495 return NULL;
496
296fcba3
TP		 497 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
498 if (!sta)
499 return NULL;
500
433f5bc1 501 sta->mesh->plink_state = NL80211_PLINK_LISTEN;
a74a8c84 502 sta->sta.wme = true;
0e0060fc 503 sta->sta.aid = aid;
296fcba3
TP		 504
505 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
506 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
507 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
508
296fcba3
TP		 509 return sta;
510}
511
512static struct sta_info *
513mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *addr,
ecbc12ad
BC		 514 struct ieee802_11_elems *elems,
515 struct ieee80211_rx_status *rx_status)
296fcba3
TP		 516{
517 struct sta_info *sta = NULL;
518
a6dad6a2
TP		 519 /* Userspace handles station allocation */
520 if (sdata->u.mesh.user_mpm ||
11197d00
MH		 521 sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) {
522 if (mesh_peer_accepts_plinks(elems) &&
ecbc12ad
BC		 523 mesh_plink_availables(sdata)) {
524 int sig = 0;
525
526 if (ieee80211_hw_check(&sdata->local->hw, SIGNAL_DBM))
527 sig = rx_status->signal;
528
11197d00
MH		 529 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
530 elems->ie_start,
531 elems->total_len,
ecbc12ad
BC		 532 sig, GFP_KERNEL);
533 }
11197d00 534 } else
296fcba3
TP		 535 sta = __mesh_sta_info_alloc(sdata, addr);
536
54ab1ffb
TP		 537 return sta;
538}
539
296fcba3
TP		 540/*
541 * mesh_sta_info_get - return mesh sta info entry for @addr.
542 *
543 * @sdata: local meshif
544 * @addr: peer's address
545 * @elems: IEs from beacon or mesh peering frame.
ecbc12ad 546 * @rx_status: rx status for the frame for signal reporting
296fcba3
TP		 547 *
548 * Return existing or newly allocated sta_info under RCU read lock.
549 * (re)initialize with given IEs.
550 */
551static struct sta_info *
552mesh_sta_info_get(struct ieee80211_sub_if_data *sdata,
ecbc12ad
BC		 553 u8 *addr, struct ieee802_11_elems *elems,
554 struct ieee80211_rx_status *rx_status) __acquires(RCU)
296fcba3
TP		 555{
556 struct sta_info *sta = NULL;
557
558 rcu_read_lock();
559 sta = sta_info_get(sdata, addr);
560 if (sta) {
1d6741d8 561 mesh_sta_info_init(sdata, sta, elems);
296fcba3
TP		 562 } else {
563 rcu_read_unlock();
564 /* can't run atomic */
ecbc12ad 565 sta = mesh_sta_info_alloc(sdata, addr, elems, rx_status);
296fcba3
TP		 566 if (!sta) {
567 rcu_read_lock();
568 return NULL;
569 }
570
1d6741d8 571 mesh_sta_info_init(sdata, sta, elems);
3b4797bc 572
296fcba3
TP		 573 if (sta_info_insert_rcu(sta))
574 return NULL;
575 }
576
577 return sta;
578}
579
580/*
581 * mesh_neighbour_update - update or initialize new mesh neighbor.
582 *
583 * @sdata: local meshif
584 * @addr: peer's address
585 * @elems: IEs from beacon or mesh peering frame
ecbc12ad 586 * @rx_status: rx status for the frame for signal reporting
296fcba3
TP		 587 *
588 * Initiates peering if appropriate.
589 */
f743ff49
TP		 590void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
591 u8 *hw_addr,
ecbc12ad
BC		 592 struct ieee802_11_elems *elems,
593 struct ieee80211_rx_status *rx_status)
54ab1ffb
TP		 594{
595 struct sta_info *sta;
39886b61 596 u32 changed = 0;
54ab1ffb 597
ecbc12ad 598 sta = mesh_sta_info_get(sdata, hw_addr, elems, rx_status);
54ab1ffb
TP		 599 if (!sta)
600 goto out;
601
dbdaee7a
BC		 602 sta->mesh->connected_to_gate = elems->mesh_config->meshconf_form &
603 IEEE80211_MESHCONF_FORM_CONNECTED_TO_GATE;
604
1570ca59 605 if (mesh_peer_accepts_plinks(elems) &&
433f5bc1 606 sta->mesh->plink_state == NL80211_PLINK_LISTEN &&
54ab1ffb
TP		 607 sdata->u.mesh.accepting_plinks &&
608 sdata->u.mesh.mshcfg.auto_open_plinks &&
36c9bb29 609 rssi_threshold_check(sdata, sta))
39886b61 610 changed = mesh_plink_open(sta);
c3896d2c 611
3f52b7e3 612 ieee80211_mps_frame_release(sta, elems);
54ab1ffb 613out:
d0709a65 614 rcu_read_unlock();
2b5e1967 615 ieee80211_mbss_info_change_notify(sdata, changed);
c3896d2c
LCC		 616}
617
4c02d62f 618void mesh_plink_timer(struct timer_list *t)
c3896d2c 619{
4c02d62f 620 struct mesh_sta *mesh = from_timer(mesh, t, plink_timer);
c3896d2c 621 struct sta_info *sta;
6f101ef0 622 u16 reason = 0;
c3896d2c 623 struct ieee80211_sub_if_data *sdata;
453e66f2 624 struct mesh_config *mshcfg;
4efec451 625 enum ieee80211_self_protected_actioncode action = 0;
c3896d2c 626
d0709a65
JB		 627 /*
628 * This STA is valid because sta_info_destroy() will
629 * del_timer_sync() this timer after having made sure
630 * it cannot be readded (by deleting the plink.)
631 */
4c02d62f 632 sta = mesh->plink_sta;
c3896d2c 633
690205f1 634 if (sta->sdata->local->quiescing)
5bb644a0 635 return;
5bb644a0 636
433f5bc1 637 spin_lock_bh(&sta->mesh->plink_lock);
2b470c39
BC		 638
639 /* If a timer fires just before a state transition on another CPU,
640 * we may have already extended the timeout and changed state by the
641 * time we've acquired the lock and arrived here. In that case,
642 * skip this timer and wait for the new one.
643 */
433f5bc1 644 if (time_before(jiffies, sta->mesh->plink_timer.expires)) {
2b470c39
BC		 645 mpl_dbg(sta->sdata,
646 "Ignoring timer for %pM in state %s (timer adjusted)",
433f5bc1
JB		 647 sta->sta.addr, mplstates[sta->mesh->plink_state]);
648 spin_unlock_bh(&sta->mesh->plink_lock);
c3896d2c
LCC		 649 return;
650 }
2b470c39
BC		 651
652 /* del_timer() and handler may race when entering these states */
433f5bc1
JB		 653 if (sta->mesh->plink_state == NL80211_PLINK_LISTEN ||
654 sta->mesh->plink_state == NL80211_PLINK_ESTAB) {
2b470c39
BC		 655 mpl_dbg(sta->sdata,
656 "Ignoring timer for %pM in state %s (timer deleted)",
433f5bc1
JB		 657 sta->sta.addr, mplstates[sta->mesh->plink_state]);
658 spin_unlock_bh(&sta->mesh->plink_lock);
2b470c39
BC		 659 return;
660 }
661
bdcbd8e0 662 mpl_dbg(sta->sdata,
3088f7d2 663 "Mesh plink timer for %pM fired on state %s\n",
433f5bc1 664 sta->sta.addr, mplstates[sta->mesh->plink_state]);
d0709a65 665 sdata = sta->sdata;
453e66f2 666 mshcfg = &sdata->u.mesh.mshcfg;
c3896d2c 667
433f5bc1 668 switch (sta->mesh->plink_state) {
57cf8043
JC		 669 case NL80211_PLINK_OPN_RCVD:
670 case NL80211_PLINK_OPN_SNT:
c3896d2c 671 /* retry timer */
433f5bc1 672 if (sta->mesh->plink_retries < mshcfg->dot11MeshMaxRetries) {
c3896d2c 673 u32 rand;
bdcbd8e0
JB		 674 mpl_dbg(sta->sdata,
675 "Mesh plink for %pM (retry, timeout): %d %d\n",
433f5bc1
JB		 676 sta->sta.addr, sta->mesh->plink_retries,
677 sta->mesh->plink_timeout);
c3896d2c 678 get_random_bytes(&rand, sizeof(u32));
433f5bc1
JB		 679 sta->mesh->plink_timeout = sta->mesh->plink_timeout +
680 rand % sta->mesh->plink_timeout;
681 ++sta->mesh->plink_retries;
682 mod_plink_timer(sta, sta->mesh->plink_timeout);
4efec451 683 action = WLAN_SP_MESH_PEERING_OPEN;
c3896d2c
LCC		 684 break;
685 }
6f101ef0 686 reason = WLAN_REASON_MESH_MAX_RETRIES;
02049ce2 687 /* fall through */
57cf8043 688 case NL80211_PLINK_CNF_RCVD:
c3896d2c
LCC		 689 /* confirm timer */
690 if (!reason)
6f101ef0 691 reason = WLAN_REASON_MESH_CONFIRM_TIMEOUT;
433f5bc1 692 sta->mesh->plink_state = NL80211_PLINK_HOLDING;
453e66f2 693 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
4efec451 694 action = WLAN_SP_MESH_PEERING_CLOSE;
c3896d2c 695 break;
57cf8043 696 case NL80211_PLINK_HOLDING:
c3896d2c 697 /* holding timer */
433f5bc1 698 del_timer(&sta->mesh->plink_timer);
c3896d2c 699 mesh_plink_fsm_restart(sta);
c3896d2c
LCC		 700 break;
701 default:
c3896d2c
LCC		 702 break;
703 }
433f5bc1 704 spin_unlock_bh(&sta->mesh->plink_lock);
4efec451 705 if (action)
a69bd8e6 706 mesh_plink_frame_tx(sdata, sta, action, sta->sta.addr,
433f5bc1 707 sta->mesh->llid, sta->mesh->plid, reason);
c3896d2c
LCC		 708}
709
0df2f6c1 710static inline void mesh_plink_timer_set(struct sta_info *sta, u32 timeout)
c3896d2c 711{
433f5bc1 712 sta->mesh->plink_timeout = timeout;
4c02d62f 713 mod_timer(&sta->mesh->plink_timer, jiffies + msecs_to_jiffies(timeout));
c3896d2c
LCC		 714}
715
204d1304 716static bool llid_in_use(struct ieee80211_sub_if_data *sdata,
6f101ef0 717 u16 llid)
204d1304
TP		 718{
719 struct ieee80211_local *local = sdata->local;
720 bool in_use = false;
721 struct sta_info *sta;
722
723 rcu_read_lock();
724 list_for_each_entry_rcu(sta, &local->sta_list, list) {
520c75dc
MS		 725 if (sdata != sta->sdata)
726 continue;
727
433f5bc1 728 if (!memcmp(&sta->mesh->llid, &llid, sizeof(llid))) {
204d1304
TP		 729 in_use = true;
730 break;
731 }
732 }
733 rcu_read_unlock();
734
735 return in_use;
736}
737
6f101ef0 738static u16 mesh_get_new_llid(struct ieee80211_sub_if_data *sdata)
204d1304
TP		 739{
740 u16 llid;
741
742 do {
743 get_random_bytes(&llid, sizeof(llid));
6f101ef0 744 } while (llid_in_use(sdata, llid));
204d1304 745
6f101ef0 746 return llid;
204d1304
TP		 747}
748
39886b61 749u32 mesh_plink_open(struct sta_info *sta)
c3896d2c 750{
d0709a65 751 struct ieee80211_sub_if_data *sdata = sta->sdata;
39886b61 752 u32 changed;
c3896d2c 753
c2c98fde 754 if (!test_sta_flag(sta, WLAN_STA_AUTH))
39886b61 755 return 0;
53e80511 756
433f5bc1
JB		 757 spin_lock_bh(&sta->mesh->plink_lock);
758 sta->mesh->llid = mesh_get_new_llid(sdata);
759 if (sta->mesh->plink_state != NL80211_PLINK_LISTEN &&
760 sta->mesh->plink_state != NL80211_PLINK_BLOCKED) {
761 spin_unlock_bh(&sta->mesh->plink_lock);
39886b61 762 return 0;
c3896d2c 763 }
433f5bc1 764 sta->mesh->plink_state = NL80211_PLINK_OPN_SNT;
453e66f2 765 mesh_plink_timer_set(sta, sdata->u.mesh.mshcfg.dot11MeshRetryTimeout);
433f5bc1 766 spin_unlock_bh(&sta->mesh->plink_lock);
bdcbd8e0
JB		 767 mpl_dbg(sdata,
768 "Mesh plink: starting establishment with %pM\n",
0c68ae26 769 sta->sta.addr);
c3896d2c 770
3f52b7e3 771 /* set the non-peer mode to active during peering */
39886b61 772 changed = ieee80211_mps_local_status_update(sdata);
3f52b7e3 773
a69bd8e6 774 mesh_plink_frame_tx(sdata, sta, WLAN_SP_MESH_PEERING_OPEN,
433f5bc1 775 sta->sta.addr, sta->mesh->llid, 0, 0);
39886b61 776 return changed;
c3896d2c
LCC		 777}
778
39886b61 779u32 mesh_plink_block(struct sta_info *sta)
c3896d2c 780{
df323818 781 u32 changed;
c9370197 782
433f5bc1 783 spin_lock_bh(&sta->mesh->plink_lock);
df323818 784 changed = __mesh_plink_deactivate(sta);
433f5bc1
JB		 785 sta->mesh->plink_state = NL80211_PLINK_BLOCKED;
786 spin_unlock_bh(&sta->mesh->plink_lock);
e596af82 787 mesh_path_flush_by_nexthop(sta);
c9370197 788
39886b61 789 return changed;
c3896d2c
LCC		 790}
791
e76d67f0
BC		 792static void mesh_plink_close(struct ieee80211_sub_if_data *sdata,
793 struct sta_info *sta,
794 enum plink_event event)
795{
796 struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
6f101ef0
CYY		 797 u16 reason = (event == CLS_ACPT) ?
798 WLAN_REASON_MESH_CLOSE : WLAN_REASON_MESH_CONFIG;
e76d67f0 799
433f5bc1
JB		 800 sta->mesh->reason = reason;
801 sta->mesh->plink_state = NL80211_PLINK_HOLDING;
272a9e26 802 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
e76d67f0
BC		 803}
804
805static u32 mesh_plink_establish(struct ieee80211_sub_if_data *sdata,
806 struct sta_info *sta)
807{
808 struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
809 u32 changed = 0;
810
433f5bc1
JB		 811 del_timer(&sta->mesh->plink_timer);
812 sta->mesh->plink_state = NL80211_PLINK_ESTAB;
e76d67f0
BC		 813 changed |= mesh_plink_inc_estab_count(sdata);
814 changed |= mesh_set_ht_prot_mode(sdata);
815 changed |= mesh_set_short_slot_time(sdata);
816 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n", sta->sta.addr);
817 ieee80211_mps_sta_status_update(sta);
818 changed |= ieee80211_mps_set_sta_local_pm(sta, mshcfg->power_mode);
819 return changed;
820}
821
c7e67811
TP		 822/**
823 * mesh_plink_fsm - step @sta MPM based on @event
824 *
825 * @sdata: interface
826 * @sta: mesh neighbor
827 * @event: peering event
828 *
829 * Return: changed MBSS flags
830 */
831static u32 mesh_plink_fsm(struct ieee80211_sub_if_data *sdata,
832 struct sta_info *sta, enum plink_event event)
833{
834 struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
835 enum ieee80211_self_protected_actioncode action = 0;
836 u32 changed = 0;
e596af82 837 bool flush = false;
c7e67811
TP		 838
839 mpl_dbg(sdata, "peer %pM in state %s got event %s\n", sta->sta.addr,
433f5bc1 840 mplstates[sta->mesh->plink_state], mplevents[event]);
c7e67811 841
433f5bc1
JB		 842 spin_lock_bh(&sta->mesh->plink_lock);
843 switch (sta->mesh->plink_state) {
c7e67811
TP		 844 case NL80211_PLINK_LISTEN:
845 switch (event) {
846 case CLS_ACPT:
847 mesh_plink_fsm_restart(sta);
848 break;
849 case OPN_ACPT:
433f5bc1
JB		 850 sta->mesh->plink_state = NL80211_PLINK_OPN_RCVD;
851 sta->mesh->llid = mesh_get_new_llid(sdata);
c7e67811
TP		 852 mesh_plink_timer_set(sta,
853 mshcfg->dot11MeshRetryTimeout);
854
855 /* set the non-peer mode to active during peering */
856 changed |= ieee80211_mps_local_status_update(sdata);
857 action = WLAN_SP_MESH_PEERING_OPEN;
858 break;
859 default:
860 break;
861 }
862 break;
863 case NL80211_PLINK_OPN_SNT:
864 switch (event) {
865 case OPN_RJCT:
866 case CNF_RJCT:
867 case CLS_ACPT:
868 mesh_plink_close(sdata, sta, event);
869 action = WLAN_SP_MESH_PEERING_CLOSE;
870 break;
871 case OPN_ACPT:
872 /* retry timer is left untouched */
433f5bc1 873 sta->mesh->plink_state = NL80211_PLINK_OPN_RCVD;
c7e67811
TP		 874 action = WLAN_SP_MESH_PEERING_CONFIRM;
875 break;
876 case CNF_ACPT:
433f5bc1 877 sta->mesh->plink_state = NL80211_PLINK_CNF_RCVD;
2b470c39 878 mod_plink_timer(sta, mshcfg->dot11MeshConfirmTimeout);
c7e67811
TP		 879 break;
880 default:
881 break;
882 }
883 break;
884 case NL80211_PLINK_OPN_RCVD:
885 switch (event) {
886 case OPN_RJCT:
887 case CNF_RJCT:
888 case CLS_ACPT:
889 mesh_plink_close(sdata, sta, event);
890 action = WLAN_SP_MESH_PEERING_CLOSE;
891 break;
892 case OPN_ACPT:
893 action = WLAN_SP_MESH_PEERING_CONFIRM;
894 break;
895 case CNF_ACPT:
896 changed |= mesh_plink_establish(sdata, sta);
897 break;
898 default:
899 break;
900 }
901 break;
902 case NL80211_PLINK_CNF_RCVD:
903 switch (event) {
904 case OPN_RJCT:
905 case CNF_RJCT:
906 case CLS_ACPT:
907 mesh_plink_close(sdata, sta, event);
908 action = WLAN_SP_MESH_PEERING_CLOSE;
909 break;
910 case OPN_ACPT:
911 changed |= mesh_plink_establish(sdata, sta);
912 action = WLAN_SP_MESH_PEERING_CONFIRM;
913 break;
914 default:
915 break;
916 }
917 break;
918 case NL80211_PLINK_ESTAB:
919 switch (event) {
920 case CLS_ACPT:
921 changed |= __mesh_plink_deactivate(sta);
922 changed |= mesh_set_ht_prot_mode(sdata);
923 changed |= mesh_set_short_slot_time(sdata);
924 mesh_plink_close(sdata, sta, event);
925 action = WLAN_SP_MESH_PEERING_CLOSE;
e596af82 926 flush = true;
c7e67811
TP		 927 break;
928 case OPN_ACPT:
929 action = WLAN_SP_MESH_PEERING_CONFIRM;
930 break;
931 default:
932 break;
933 }
934 break;
935 case NL80211_PLINK_HOLDING:
936 switch (event) {
937 case CLS_ACPT:
433f5bc1 938 del_timer(&sta->mesh->plink_timer);
c7e67811
TP		 939 mesh_plink_fsm_restart(sta);
940 break;
941 case OPN_ACPT:
942 case CNF_ACPT:
943 case OPN_RJCT:
944 case CNF_RJCT:
945 action = WLAN_SP_MESH_PEERING_CLOSE;
946 break;
947 default:
948 break;
949 }
950 break;
951 default:
952 /* should not get here, PLINK_BLOCKED is dealt with at the
953 * beginning of the function
954 */
955 break;
956 }
433f5bc1 957 spin_unlock_bh(&sta->mesh->plink_lock);
e596af82
BC		 958 if (flush)
959 mesh_path_flush_by_nexthop(sta);
c7e67811 960 if (action) {
a69bd8e6 961 mesh_plink_frame_tx(sdata, sta, action, sta->sta.addr,
433f5bc1
JB		 962 sta->mesh->llid, sta->mesh->plid,
963 sta->mesh->reason);
c7e67811
TP		 964
965 /* also send confirm in open case */
966 if (action == WLAN_SP_MESH_PEERING_OPEN) {
a69bd8e6 967 mesh_plink_frame_tx(sdata, sta,
c7e67811 968 WLAN_SP_MESH_PEERING_CONFIRM,
433f5bc1
JB		 969 sta->sta.addr, sta->mesh->llid,
970 sta->mesh->plid, 0);
c7e67811
TP		 971 }
972 }
973
974 return changed;
975}
976
c99a89ed
TP		 977/*
978 * mesh_plink_get_event - get correct MPM event
979 *
980 * @sdata: interface
981 * @sta: peer, leave NULL if processing a frame from a new suitable peer
982 * @elems: peering management IEs
983 * @ftype: frame type
984 * @llid: peer's peer link ID
985 * @plid: peer's local link ID
986 *
987 * Return: new peering event for @sta, but PLINK_UNDEFINED should be treated as
988 * an error.
989 */
990static enum plink_event
991mesh_plink_get_event(struct ieee80211_sub_if_data *sdata,
992 struct sta_info *sta,
993 struct ieee802_11_elems *elems,
994 enum ieee80211_self_protected_actioncode ftype,
6f101ef0 995 u16 llid, u16 plid)
c99a89ed
TP		 996{
997 enum plink_event event = PLINK_UNDEFINED;
998 u8 ie_len = elems->peering_len;
999 bool matches_local;
1000
1001 matches_local = (ftype == WLAN_SP_MESH_PEERING_CLOSE ||
1002 mesh_matches_local(sdata, elems));
1003
1004 /* deny open request from non-matching peer */
1005 if (!matches_local && !sta) {
1006 event = OPN_RJCT;
1007 goto out;
1008 }
1009
1010 if (!sta) {
1011 if (ftype != WLAN_SP_MESH_PEERING_OPEN) {
1012 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
1013 goto out;
1014 }
1015 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
1016 if (!mesh_plink_free_count(sdata)) {
1017 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
1018 goto out;
1019 }
b8631c00
SS		 1020
1021 /* new matching peer */
1022 event = OPN_ACPT;
1023 goto out;
c99a89ed
TP		 1024 } else {
1025 if (!test_sta_flag(sta, WLAN_STA_AUTH)) {
1026 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
1027 goto out;
1028 }
433f5bc1 1029 if (sta->mesh->plink_state == NL80211_PLINK_BLOCKED)
c99a89ed
TP		 1030 goto out;
1031 }
1032
c99a89ed
TP		 1033 switch (ftype) {
1034 case WLAN_SP_MESH_PEERING_OPEN:
1035 if (!matches_local)
1036 event = OPN_RJCT;
1037 if (!mesh_plink_free_count(sdata) ||
433f5bc1 1038 (sta->mesh->plid && sta->mesh->plid != plid))
c99a89ed
TP		 1039 event = OPN_IGNR;
1040 else
1041 event = OPN_ACPT;
1042 break;
1043 case WLAN_SP_MESH_PEERING_CONFIRM:
1044 if (!matches_local)
1045 event = CNF_RJCT;
1046 if (!mesh_plink_free_count(sdata) ||
433f5bc1
JB		 1047 sta->mesh->llid != llid ||
1048 (sta->mesh->plid && sta->mesh->plid != plid))
c99a89ed
TP		 1049 event = CNF_IGNR;
1050 else
1051 event = CNF_ACPT;
1052 break;
1053 case WLAN_SP_MESH_PEERING_CLOSE:
433f5bc1 1054 if (sta->mesh->plink_state == NL80211_PLINK_ESTAB)
c99a89ed
TP		 1055 /* Do not check for llid or plid. This does not
1056 * follow the standard but since multiple plinks
1057 * per sta are not supported, it is necessary in
1058 * order to avoid a livelock when MP A sees an
1059 * establish peer link to MP B but MP B does not
1060 * see it. This can be caused by a timeout in
1061 * B's peer link establishment or B beign
1062 * restarted.
1063 */
1064 event = CLS_ACPT;
433f5bc1 1065 else if (sta->mesh->plid != plid)
c99a89ed 1066 event = CLS_IGNR;
433f5bc1 1067 else if (ie_len == 8 && sta->mesh->llid != llid)
c99a89ed
TP		 1068 event = CLS_IGNR;
1069 else
1070 event = CLS_ACPT;
1071 break;
1072 default:
1073 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
1074 break;
1075 }
1076
1077out:
1078 return event;
1079}
1080
05a23ae9
TP		 1081static void
1082mesh_process_plink_frame(struct ieee80211_sub_if_data *sdata,
1083 struct ieee80211_mgmt *mgmt,
ecbc12ad
BC		 1084 struct ieee802_11_elems *elems,
1085 struct ieee80211_rx_status *rx_status)
c3896d2c 1086{
05a23ae9 1087
c3896d2c
LCC		 1088 struct sta_info *sta;
1089 enum plink_event event;
54ef656b 1090 enum ieee80211_self_protected_actioncode ftype;
57aac7c5 1091 u32 changed = 0;
c99a89ed 1092 u8 ie_len = elems->peering_len;
6f101ef0 1093 u16 plid, llid = 0;
c3896d2c 1094
05a23ae9 1095 if (!elems->peering) {
bdcbd8e0
JB		 1096 mpl_dbg(sdata,
1097 "Mesh plink: missing necessary peer link ie\n");
c3896d2c
LCC		 1098 return;
1099 }
bf7cd94d 1100
05a23ae9 1101 if (elems->rsn_len &&
bf7cd94d 1102 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
bdcbd8e0
JB		 1103 mpl_dbg(sdata,
1104 "Mesh plink: can't establish link with secure peer\n");
5cff5e01
JC		 1105 return;
1106 }
c3896d2c 1107
8db09850 1108 ftype = mgmt->u.action.u.self_prot.action_code;
8db09850
TP		 1109 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
1110 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
1111 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
1112 && ie_len != 8)) {
bdcbd8e0
JB		 1113 mpl_dbg(sdata,
1114 "Mesh plink: incorrect plink ie length %d %d\n",
1115 ftype, ie_len);
c3896d2c
LCC		 1116 return;
1117 }
1118
54ef656b 1119 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
05a23ae9 1120 (!elems->mesh_id || !elems->mesh_config)) {
bdcbd8e0 1121 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
c3896d2c
LCC		 1122 return;
1123 }
1124 /* Note the lines below are correct, the llid in the frame is the plid
1125 * from the point of view of this host.
1126 */
f8134fed 1127 plid = get_unaligned_le16(PLINK_GET_LLID(elems->peering));
54ef656b 1128 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
f8134fed
BC		 1129 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
1130 llid = get_unaligned_le16(PLINK_GET_PLID(elems->peering));
c3896d2c 1131
296fcba3 1132 /* WARNING: Only for sta pointer, is dropped & re-acquired */
d0709a65
JB		 1133 rcu_read_lock();
1134
abe60632 1135 sta = sta_info_get(sdata, mgmt->sa);
32cb05bf 1136
55335137 1137 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
36c9bb29 1138 !rssi_threshold_check(sdata, sta)) {
bdcbd8e0 1139 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
3d4f9699 1140 mgmt->sa);
fc10302e 1141 goto unlock_rcu;
55335137
AN		 1142 }
1143
c3896d2c 1144 /* Now we will figure out the appropriate event... */
c99a89ed 1145 event = mesh_plink_get_event(sdata, sta, elems, ftype, llid, plid);
54ab1ffb
TP		 1146
1147 if (event == OPN_ACPT) {
296fcba3 1148 rcu_read_unlock();
54ab1ffb 1149 /* allocate sta entry if necessary and update info */
ecbc12ad 1150 sta = mesh_sta_info_get(sdata, mgmt->sa, elems, rx_status);
54ab1ffb 1151 if (!sta) {
bdcbd8e0 1152 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
fc10302e 1153 goto unlock_rcu;
54ab1ffb 1154 }
433f5bc1 1155 sta->mesh->plid = plid;
c99a89ed 1156 } else if (!sta && event == OPN_RJCT) {
a69bd8e6 1157 mesh_plink_frame_tx(sdata, NULL, WLAN_SP_MESH_PEERING_CLOSE,
c99a89ed 1158 mgmt->sa, 0, plid,
6f101ef0 1159 WLAN_REASON_MESH_CONFIG);
c99a89ed
TP		 1160 goto unlock_rcu;
1161 } else if (!sta || event == PLINK_UNDEFINED) {
1162 /* something went wrong */
1163 goto unlock_rcu;
c3896d2c
LCC		 1164 }
1165
a69bd8e6
BC		 1166 if (event == CNF_ACPT) {
1167 /* 802.11-2012 13.3.7.2 - update plid on CNF if not set */
0e0060fc 1168 if (!sta->mesh->plid)
a69bd8e6 1169 sta->mesh->plid = plid;
a69bd8e6
BC		 1170
1171 sta->mesh->aid = get_unaligned_le16(PLINK_CNF_AID(mgmt));
1172 }
6c6fa496 1173
c7e67811 1174 changed |= mesh_plink_fsm(sdata, sta, event);
d0709a65 1175
fc10302e 1176unlock_rcu:
d0709a65 1177 rcu_read_unlock();
57aac7c5 1178
ecccd072 1179 if (changed)
2b5e1967 1180 ieee80211_mbss_info_change_notify(sdata, changed);
c3896d2c 1181}
05a23ae9
TP		 1182
1183void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
1184 struct ieee80211_mgmt *mgmt, size_t len,
1185 struct ieee80211_rx_status *rx_status)
1186{
1187 struct ieee802_11_elems elems;
1188 size_t baselen;
1189 u8 *baseaddr;
1190
1191 /* need action_code, aux */
1192 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
1193 return;
1194
1195 if (sdata->u.mesh.user_mpm)
1196 /* userspace must register for these */
1197 return;
1198
1199 if (is_multicast_ether_addr(mgmt->da)) {
1200 mpl_dbg(sdata,
1201 "Mesh plink: ignore frame from multicast address\n");
1202 return;
1203 }
1204
1205 baseaddr = mgmt->u.action.u.self_prot.variable;
1206 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
1207 if (mgmt->u.action.u.self_prot.action_code ==
1208 WLAN_SP_MESH_PEERING_CONFIRM) {
1209 baseaddr += 4;
1210 baselen += 4;
b3e7de87
BC		 1211
1212 if (baselen > len)
1213 return;
05a23ae9 1214 }
4abb52a4
SS		 1215 ieee802_11_parse_elems(baseaddr, len - baselen, true, &elems,
1216 mgmt->bssid, NULL);
ecbc12ad 1217 mesh_process_plink_frame(sdata, mgmt, &elems, rx_status);
05a23ae9 1218}
Linux 6.x block layer and io_uring tree(s)