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