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 + 4) 23 #define PLINK_GET_PLID(p) (p + 6) 24 25 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \ 26 jiffies + HZ * t / 1000)) 27 28 /* Peer link cancel reasons, all subject to ANA approval */ 29 #define MESH_LINK_CANCELLED 2 30 #define MESH_MAX_NEIGHBORS 3 31 #define MESH_CAPABILITY_POLICY_VIOLATION 4 32 #define MESH_CLOSE_RCVD 5 33 #define MESH_MAX_RETRIES 6 34 #define MESH_CONFIRM_TIMEOUT 7 35 #define MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS 8 36 #define MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE 9 37 #define MESH_SECURITY_FAILED_VERIFICATION 10 38 39 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries) 40 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout) 41 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout) 42 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout) 43 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks) 44 45 enum plink_frame_type { 46 PLINK_OPEN = 0, 47 PLINK_CONFIRM, 48 PLINK_CLOSE 49 }; 50 51 enum plink_event { 52 PLINK_UNDEFINED, 53 OPN_ACPT, 54 OPN_RJCT, 55 OPN_IGNR, 56 CNF_ACPT, 57 CNF_RJCT, 58 CNF_IGNR, 59 CLS_ACPT, 60 CLS_IGNR 61 }; 62 63 static inline 64 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata) 65 { 66 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks); 67 mesh_accept_plinks_update(sdata); 68 } 69 70 static inline 71 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata) 72 { 73 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks); 74 mesh_accept_plinks_update(sdata); 75 } 76 77 /** 78 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine 79 * 80 * @sta: mesh peer link to restart 81 * 82 * Locking: this function must be called holding sta->lock 83 */ 84 static inline void mesh_plink_fsm_restart(struct sta_info *sta) 85 { 86 sta->plink_state = PLINK_LISTEN; 87 sta->llid = sta->plid = sta->reason = 0; 88 sta->plink_retries = 0; 89 } 90 91 /* 92 * NOTE: This is just an alias for sta_info_alloc(), see notes 93 * on it in the lifecycle management section! 94 */ 95 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata, 96 u8 *hw_addr, u32 rates) 97 { 98 struct ieee80211_local *local = sdata->local; 99 struct sta_info *sta; 100 101 if (local->num_sta >= MESH_MAX_PLINKS) 102 return NULL; 103 104 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL); 105 if (!sta) 106 return NULL; 107 108 sta->flags = WLAN_STA_AUTHORIZED; 109 sta->sta.supp_rates[local->hw.conf.channel->band] = rates; 110 rate_control_rate_init(sta); 111 112 return sta; 113 } 114 115 /** 116 * __mesh_plink_deactivate - deactivate mesh peer link 117 * 118 * @sta: mesh peer link to deactivate 119 * 120 * All mesh paths with this peer as next hop will be flushed 121 * 122 * Locking: the caller must hold sta->lock 123 */ 124 static bool __mesh_plink_deactivate(struct sta_info *sta) 125 { 126 struct ieee80211_sub_if_data *sdata = sta->sdata; 127 bool deactivated = false; 128 129 if (sta->plink_state == PLINK_ESTAB) { 130 mesh_plink_dec_estab_count(sdata); 131 deactivated = true; 132 } 133 sta->plink_state = PLINK_BLOCKED; 134 mesh_path_flush_by_nexthop(sta); 135 136 return deactivated; 137 } 138 139 /** 140 * mesh_plink_deactivate - deactivate mesh peer link 141 * 142 * @sta: mesh peer link to deactivate 143 * 144 * All mesh paths with this peer as next hop will be flushed 145 */ 146 void mesh_plink_deactivate(struct sta_info *sta) 147 { 148 struct ieee80211_sub_if_data *sdata = sta->sdata; 149 bool deactivated; 150 151 spin_lock_bh(&sta->lock); 152 deactivated = __mesh_plink_deactivate(sta); 153 spin_unlock_bh(&sta->lock); 154 155 if (deactivated) 156 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 157 } 158 159 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata, 160 enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid, 161 __le16 reason) { 162 struct ieee80211_local *local = sdata->local; 163 struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400); 164 struct ieee80211_mgmt *mgmt; 165 bool include_plid = false; 166 static const u8 meshpeeringproto[] = { 0x00, 0x0F, 0xAC, 0x2A }; 167 u8 *pos; 168 int ie_len; 169 170 if (!skb) 171 return -1; 172 skb_reserve(skb, local->hw.extra_tx_headroom); 173 /* 25 is the size of the common mgmt part (24) plus the size of the 174 * common action part (1) 175 */ 176 mgmt = (struct ieee80211_mgmt *) 177 skb_put(skb, 25 + sizeof(mgmt->u.action.u.plink_action)); 178 memset(mgmt, 0, 25 + sizeof(mgmt->u.action.u.plink_action)); 179 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 180 IEEE80211_STYPE_ACTION); 181 memcpy(mgmt->da, da, ETH_ALEN); 182 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 183 /* BSSID is left zeroed, wildcard value */ 184 mgmt->u.action.category = WLAN_CATEGORY_MESH_PLINK; 185 mgmt->u.action.u.plink_action.action_code = action; 186 187 if (action == PLINK_CLOSE) 188 mgmt->u.action.u.plink_action.aux = reason; 189 else { 190 mgmt->u.action.u.plink_action.aux = cpu_to_le16(0x0); 191 if (action == PLINK_CONFIRM) { 192 pos = skb_put(skb, 4); 193 /* two-byte status code followed by two-byte AID */ 194 memset(pos, 0, 2); 195 memcpy(pos + 2, &plid, 2); 196 } 197 mesh_mgmt_ies_add(skb, sdata); 198 } 199 200 /* Add Peer Link Management element */ 201 switch (action) { 202 case PLINK_OPEN: 203 ie_len = 6; 204 break; 205 case PLINK_CONFIRM: 206 ie_len = 8; 207 include_plid = true; 208 break; 209 case PLINK_CLOSE: 210 default: 211 if (!plid) 212 ie_len = 8; 213 else { 214 ie_len = 10; 215 include_plid = true; 216 } 217 break; 218 } 219 220 pos = skb_put(skb, 2 + ie_len); 221 *pos++ = WLAN_EID_PEER_LINK; 222 *pos++ = ie_len; 223 memcpy(pos, meshpeeringproto, sizeof(meshpeeringproto)); 224 pos += 4; 225 memcpy(pos, &llid, 2); 226 if (include_plid) { 227 pos += 2; 228 memcpy(pos, &plid, 2); 229 } 230 if (action == PLINK_CLOSE) { 231 pos += 2; 232 memcpy(pos, &reason, 2); 233 } 234 235 ieee80211_tx_skb(sdata, skb); 236 return 0; 237 } 238 239 void mesh_neighbour_update(u8 *hw_addr, u32 rates, struct ieee80211_sub_if_data *sdata, 240 bool peer_accepting_plinks) 241 { 242 struct ieee80211_local *local = sdata->local; 243 struct sta_info *sta; 244 245 rcu_read_lock(); 246 247 sta = sta_info_get(sdata, hw_addr); 248 if (!sta) { 249 rcu_read_unlock(); 250 251 sta = mesh_plink_alloc(sdata, hw_addr, rates); 252 if (!sta) 253 return; 254 if (sta_info_insert_rcu(sta)) { 255 rcu_read_unlock(); 256 return; 257 } 258 } 259 260 sta->last_rx = jiffies; 261 sta->sta.supp_rates[local->hw.conf.channel->band] = rates; 262 if (peer_accepting_plinks && sta->plink_state == PLINK_LISTEN && 263 sdata->u.mesh.accepting_plinks && 264 sdata->u.mesh.mshcfg.auto_open_plinks) 265 mesh_plink_open(sta); 266 267 rcu_read_unlock(); 268 } 269 270 static void mesh_plink_timer(unsigned long data) 271 { 272 struct sta_info *sta; 273 __le16 llid, plid, reason; 274 struct ieee80211_sub_if_data *sdata; 275 276 /* 277 * This STA is valid because sta_info_destroy() will 278 * del_timer_sync() this timer after having made sure 279 * it cannot be readded (by deleting the plink.) 280 */ 281 sta = (struct sta_info *) data; 282 283 if (sta->sdata->local->quiescing) { 284 sta->plink_timer_was_running = true; 285 return; 286 } 287 288 spin_lock_bh(&sta->lock); 289 if (sta->ignore_plink_timer) { 290 sta->ignore_plink_timer = false; 291 spin_unlock_bh(&sta->lock); 292 return; 293 } 294 mpl_dbg("Mesh plink timer for %pM fired on state %d\n", 295 sta->sta.addr, sta->plink_state); 296 reason = 0; 297 llid = sta->llid; 298 plid = sta->plid; 299 sdata = sta->sdata; 300 301 switch (sta->plink_state) { 302 case PLINK_OPN_RCVD: 303 case PLINK_OPN_SNT: 304 /* retry timer */ 305 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) { 306 u32 rand; 307 mpl_dbg("Mesh plink for %pM (retry, timeout): %d %d\n", 308 sta->sta.addr, sta->plink_retries, 309 sta->plink_timeout); 310 get_random_bytes(&rand, sizeof(u32)); 311 sta->plink_timeout = sta->plink_timeout + 312 rand % sta->plink_timeout; 313 ++sta->plink_retries; 314 mod_plink_timer(sta, sta->plink_timeout); 315 spin_unlock_bh(&sta->lock); 316 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid, 317 0, 0); 318 break; 319 } 320 reason = cpu_to_le16(MESH_MAX_RETRIES); 321 /* fall through on else */ 322 case PLINK_CNF_RCVD: 323 /* confirm timer */ 324 if (!reason) 325 reason = cpu_to_le16(MESH_CONFIRM_TIMEOUT); 326 sta->plink_state = PLINK_HOLDING; 327 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); 328 spin_unlock_bh(&sta->lock); 329 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, plid, 330 reason); 331 break; 332 case PLINK_HOLDING: 333 /* holding timer */ 334 del_timer(&sta->plink_timer); 335 mesh_plink_fsm_restart(sta); 336 spin_unlock_bh(&sta->lock); 337 break; 338 default: 339 spin_unlock_bh(&sta->lock); 340 break; 341 } 342 } 343 344 #ifdef CONFIG_PM 345 void mesh_plink_quiesce(struct sta_info *sta) 346 { 347 if (del_timer_sync(&sta->plink_timer)) 348 sta->plink_timer_was_running = true; 349 } 350 351 void mesh_plink_restart(struct sta_info *sta) 352 { 353 if (sta->plink_timer_was_running) { 354 add_timer(&sta->plink_timer); 355 sta->plink_timer_was_running = false; 356 } 357 } 358 #endif 359 360 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout) 361 { 362 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000); 363 sta->plink_timer.data = (unsigned long) sta; 364 sta->plink_timer.function = mesh_plink_timer; 365 sta->plink_timeout = timeout; 366 add_timer(&sta->plink_timer); 367 } 368 369 int mesh_plink_open(struct sta_info *sta) 370 { 371 __le16 llid; 372 struct ieee80211_sub_if_data *sdata = sta->sdata; 373 374 spin_lock_bh(&sta->lock); 375 get_random_bytes(&llid, 2); 376 sta->llid = llid; 377 if (sta->plink_state != PLINK_LISTEN) { 378 spin_unlock_bh(&sta->lock); 379 return -EBUSY; 380 } 381 sta->plink_state = PLINK_OPN_SNT; 382 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata)); 383 spin_unlock_bh(&sta->lock); 384 mpl_dbg("Mesh plink: starting establishment with %pM\n", 385 sta->sta.addr); 386 387 return mesh_plink_frame_tx(sdata, PLINK_OPEN, 388 sta->sta.addr, llid, 0, 0); 389 } 390 391 void mesh_plink_block(struct sta_info *sta) 392 { 393 struct ieee80211_sub_if_data *sdata = sta->sdata; 394 bool deactivated; 395 396 spin_lock_bh(&sta->lock); 397 deactivated = __mesh_plink_deactivate(sta); 398 sta->plink_state = PLINK_BLOCKED; 399 spin_unlock_bh(&sta->lock); 400 401 if (deactivated) 402 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 403 } 404 405 406 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt, 407 size_t len, struct ieee80211_rx_status *rx_status) 408 { 409 struct ieee80211_local *local = sdata->local; 410 struct ieee802_11_elems elems; 411 struct sta_info *sta; 412 enum plink_event event; 413 enum plink_frame_type ftype; 414 size_t baselen; 415 bool deactivated; 416 u8 ie_len; 417 u8 *baseaddr; 418 __le16 plid, llid, reason; 419 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG 420 static const char *mplstates[] = { 421 [PLINK_LISTEN] = "LISTEN", 422 [PLINK_OPN_SNT] = "OPN-SNT", 423 [PLINK_OPN_RCVD] = "OPN-RCVD", 424 [PLINK_CNF_RCVD] = "CNF_RCVD", 425 [PLINK_ESTAB] = "ESTAB", 426 [PLINK_HOLDING] = "HOLDING", 427 [PLINK_BLOCKED] = "BLOCKED" 428 }; 429 #endif 430 431 /* need action_code, aux */ 432 if (len < IEEE80211_MIN_ACTION_SIZE + 3) 433 return; 434 435 if (is_multicast_ether_addr(mgmt->da)) { 436 mpl_dbg("Mesh plink: ignore frame from multicast address"); 437 return; 438 } 439 440 baseaddr = mgmt->u.action.u.plink_action.variable; 441 baselen = (u8 *) mgmt->u.action.u.plink_action.variable - (u8 *) mgmt; 442 if (mgmt->u.action.u.plink_action.action_code == PLINK_CONFIRM) { 443 baseaddr += 4; 444 baselen += 4; 445 } 446 ieee802_11_parse_elems(baseaddr, len - baselen, &elems); 447 if (!elems.peer_link) { 448 mpl_dbg("Mesh plink: missing necessary peer link ie\n"); 449 return; 450 } 451 452 ftype = mgmt->u.action.u.plink_action.action_code; 453 ie_len = elems.peer_link_len; 454 if ((ftype == PLINK_OPEN && ie_len != 6) || 455 (ftype == PLINK_CONFIRM && ie_len != 8) || 456 (ftype == PLINK_CLOSE && ie_len != 8 && ie_len != 10)) { 457 mpl_dbg("Mesh plink: incorrect plink ie length %d %d\n", 458 ftype, ie_len); 459 return; 460 } 461 462 if (ftype != PLINK_CLOSE && (!elems.mesh_id || !elems.mesh_config)) { 463 mpl_dbg("Mesh plink: missing necessary ie\n"); 464 return; 465 } 466 /* Note the lines below are correct, the llid in the frame is the plid 467 * from the point of view of this host. 468 */ 469 memcpy(&plid, PLINK_GET_LLID(elems.peer_link), 2); 470 if (ftype == PLINK_CONFIRM || (ftype == PLINK_CLOSE && ie_len == 10)) 471 memcpy(&llid, PLINK_GET_PLID(elems.peer_link), 2); 472 473 rcu_read_lock(); 474 475 sta = sta_info_get(sdata, mgmt->sa); 476 if (!sta && ftype != PLINK_OPEN) { 477 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n"); 478 rcu_read_unlock(); 479 return; 480 } 481 482 if (sta && sta->plink_state == PLINK_BLOCKED) { 483 rcu_read_unlock(); 484 return; 485 } 486 487 /* Now we will figure out the appropriate event... */ 488 event = PLINK_UNDEFINED; 489 if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) { 490 switch (ftype) { 491 case PLINK_OPEN: 492 event = OPN_RJCT; 493 break; 494 case PLINK_CONFIRM: 495 event = CNF_RJCT; 496 break; 497 case PLINK_CLOSE: 498 /* avoid warning */ 499 break; 500 } 501 spin_lock_bh(&sta->lock); 502 } else if (!sta) { 503 /* ftype == PLINK_OPEN */ 504 u32 rates; 505 506 rcu_read_unlock(); 507 508 if (!mesh_plink_free_count(sdata)) { 509 mpl_dbg("Mesh plink error: no more free plinks\n"); 510 return; 511 } 512 513 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band); 514 sta = mesh_plink_alloc(sdata, mgmt->sa, rates); 515 if (!sta) { 516 mpl_dbg("Mesh plink error: plink table full\n"); 517 return; 518 } 519 if (sta_info_insert_rcu(sta)) { 520 rcu_read_unlock(); 521 return; 522 } 523 event = OPN_ACPT; 524 spin_lock_bh(&sta->lock); 525 } else { 526 spin_lock_bh(&sta->lock); 527 switch (ftype) { 528 case PLINK_OPEN: 529 if (!mesh_plink_free_count(sdata) || 530 (sta->plid && sta->plid != plid)) 531 event = OPN_IGNR; 532 else 533 event = OPN_ACPT; 534 break; 535 case PLINK_CONFIRM: 536 if (!mesh_plink_free_count(sdata) || 537 (sta->llid != llid || sta->plid != plid)) 538 event = CNF_IGNR; 539 else 540 event = CNF_ACPT; 541 break; 542 case PLINK_CLOSE: 543 if (sta->plink_state == PLINK_ESTAB) 544 /* Do not check for llid or plid. This does not 545 * follow the standard but since multiple plinks 546 * per sta are not supported, it is necessary in 547 * order to avoid a livelock when MP A sees an 548 * establish peer link to MP B but MP B does not 549 * see it. This can be caused by a timeout in 550 * B's peer link establishment or B beign 551 * restarted. 552 */ 553 event = CLS_ACPT; 554 else if (sta->plid != plid) 555 event = CLS_IGNR; 556 else if (ie_len == 7 && sta->llid != llid) 557 event = CLS_IGNR; 558 else 559 event = CLS_ACPT; 560 break; 561 default: 562 mpl_dbg("Mesh plink: unknown frame subtype\n"); 563 spin_unlock_bh(&sta->lock); 564 rcu_read_unlock(); 565 return; 566 } 567 } 568 569 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n", 570 mgmt->sa, mplstates[sta->plink_state], 571 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid), 572 event); 573 reason = 0; 574 switch (sta->plink_state) { 575 /* spin_unlock as soon as state is updated at each case */ 576 case PLINK_LISTEN: 577 switch (event) { 578 case CLS_ACPT: 579 mesh_plink_fsm_restart(sta); 580 spin_unlock_bh(&sta->lock); 581 break; 582 case OPN_ACPT: 583 sta->plink_state = PLINK_OPN_RCVD; 584 sta->plid = plid; 585 get_random_bytes(&llid, 2); 586 sta->llid = llid; 587 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata)); 588 spin_unlock_bh(&sta->lock); 589 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid, 590 0, 0); 591 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, 592 llid, plid, 0); 593 break; 594 default: 595 spin_unlock_bh(&sta->lock); 596 break; 597 } 598 break; 599 600 case PLINK_OPN_SNT: 601 switch (event) { 602 case OPN_RJCT: 603 case CNF_RJCT: 604 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION); 605 case CLS_ACPT: 606 if (!reason) 607 reason = cpu_to_le16(MESH_CLOSE_RCVD); 608 sta->reason = reason; 609 sta->plink_state = PLINK_HOLDING; 610 if (!mod_plink_timer(sta, 611 dot11MeshHoldingTimeout(sdata))) 612 sta->ignore_plink_timer = true; 613 614 llid = sta->llid; 615 spin_unlock_bh(&sta->lock); 616 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, 617 plid, reason); 618 break; 619 case OPN_ACPT: 620 /* retry timer is left untouched */ 621 sta->plink_state = PLINK_OPN_RCVD; 622 sta->plid = plid; 623 llid = sta->llid; 624 spin_unlock_bh(&sta->lock); 625 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid, 626 plid, 0); 627 break; 628 case CNF_ACPT: 629 sta->plink_state = PLINK_CNF_RCVD; 630 if (!mod_plink_timer(sta, 631 dot11MeshConfirmTimeout(sdata))) 632 sta->ignore_plink_timer = true; 633 634 spin_unlock_bh(&sta->lock); 635 break; 636 default: 637 spin_unlock_bh(&sta->lock); 638 break; 639 } 640 break; 641 642 case PLINK_OPN_RCVD: 643 switch (event) { 644 case OPN_RJCT: 645 case CNF_RJCT: 646 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION); 647 case CLS_ACPT: 648 if (!reason) 649 reason = cpu_to_le16(MESH_CLOSE_RCVD); 650 sta->reason = reason; 651 sta->plink_state = PLINK_HOLDING; 652 if (!mod_plink_timer(sta, 653 dot11MeshHoldingTimeout(sdata))) 654 sta->ignore_plink_timer = true; 655 656 llid = sta->llid; 657 spin_unlock_bh(&sta->lock); 658 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, 659 plid, reason); 660 break; 661 case OPN_ACPT: 662 llid = sta->llid; 663 spin_unlock_bh(&sta->lock); 664 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid, 665 plid, 0); 666 break; 667 case CNF_ACPT: 668 del_timer(&sta->plink_timer); 669 sta->plink_state = PLINK_ESTAB; 670 spin_unlock_bh(&sta->lock); 671 mesh_plink_inc_estab_count(sdata); 672 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 673 mpl_dbg("Mesh plink with %pM ESTABLISHED\n", 674 sta->sta.addr); 675 break; 676 default: 677 spin_unlock_bh(&sta->lock); 678 break; 679 } 680 break; 681 682 case PLINK_CNF_RCVD: 683 switch (event) { 684 case OPN_RJCT: 685 case CNF_RJCT: 686 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION); 687 case CLS_ACPT: 688 if (!reason) 689 reason = cpu_to_le16(MESH_CLOSE_RCVD); 690 sta->reason = reason; 691 sta->plink_state = PLINK_HOLDING; 692 if (!mod_plink_timer(sta, 693 dot11MeshHoldingTimeout(sdata))) 694 sta->ignore_plink_timer = true; 695 696 llid = sta->llid; 697 spin_unlock_bh(&sta->lock); 698 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, 699 plid, reason); 700 break; 701 case OPN_ACPT: 702 del_timer(&sta->plink_timer); 703 sta->plink_state = PLINK_ESTAB; 704 spin_unlock_bh(&sta->lock); 705 mesh_plink_inc_estab_count(sdata); 706 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 707 mpl_dbg("Mesh plink with %pM ESTABLISHED\n", 708 sta->sta.addr); 709 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid, 710 plid, 0); 711 break; 712 default: 713 spin_unlock_bh(&sta->lock); 714 break; 715 } 716 break; 717 718 case PLINK_ESTAB: 719 switch (event) { 720 case CLS_ACPT: 721 reason = cpu_to_le16(MESH_CLOSE_RCVD); 722 sta->reason = reason; 723 deactivated = __mesh_plink_deactivate(sta); 724 sta->plink_state = PLINK_HOLDING; 725 llid = sta->llid; 726 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); 727 spin_unlock_bh(&sta->lock); 728 if (deactivated) 729 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON); 730 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, 731 plid, reason); 732 break; 733 case OPN_ACPT: 734 llid = sta->llid; 735 spin_unlock_bh(&sta->lock); 736 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid, 737 plid, 0); 738 break; 739 default: 740 spin_unlock_bh(&sta->lock); 741 break; 742 } 743 break; 744 case PLINK_HOLDING: 745 switch (event) { 746 case CLS_ACPT: 747 if (del_timer(&sta->plink_timer)) 748 sta->ignore_plink_timer = 1; 749 mesh_plink_fsm_restart(sta); 750 spin_unlock_bh(&sta->lock); 751 break; 752 case OPN_ACPT: 753 case CNF_ACPT: 754 case OPN_RJCT: 755 case CNF_RJCT: 756 llid = sta->llid; 757 reason = sta->reason; 758 spin_unlock_bh(&sta->lock); 759 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, 760 llid, plid, reason); 761 break; 762 default: 763 spin_unlock_bh(&sta->lock); 764 } 765 break; 766 default: 767 /* should not get here, PLINK_BLOCKED is dealt with at the 768 * beginning of the function 769 */ 770 spin_unlock_bh(&sta->lock); 771 break; 772 } 773 774 rcu_read_unlock(); 775 } 776