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