net/mac80211/mesh_plink.c

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