Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/net/mac80211/mesh_plink.c

 /*
  * Copyright (c) 2008, 2009 open80211s Ltd.
  * Author:     Luis Carlos Cobo <luisca@cozybit.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/gfp.h>
 #include <linux/kernel.h>
@@ skipping 394 matching lines @@
 
 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
                          size_t len, struct ieee80211_rx_status *rx_status)
 {
         struct ieee80211_local *local = sdata->local;
         struct ieee802_11_elems elems;
         struct sta_info *sta;
         enum plink_event event;
         enum plink_frame_type ftype;
         size_t baselen;
-        bool deactivated;
+        bool deactivated, matches_local = true;
         u8 ie_len;
         u8 *baseaddr;
         __le16 plid, llid, reason;
 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
         static const char *mplstates[] = {
                 [PLINK_LISTEN] = "LISTEN",
                 [PLINK_OPN_SNT] = "OPN-SNT",
                 [PLINK_OPN_RCVD] = "OPN-RCVD",
                 [PLINK_CNF_RCVD] = "CNF_RCVD",
                 [PLINK_ESTAB] = "ESTAB",
@@ skipping 54 matching lines @@
         }
 
         if (sta && sta->plink_state == PLINK_BLOCKED) {
                 rcu_read_unlock();
                 return;
         }
 
         /* Now we will figure out the appropriate event... */
         event = PLINK_UNDEFINED;
         if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) {
+                matches_local = false;
                 switch (ftype) {
                 case PLINK_OPEN:
                         event = OPN_RJCT;
                         break;
                 case PLINK_CONFIRM:
                         event = CNF_RJCT;
                         break;
                 case PLINK_CLOSE:
                         /* avoid warning */
                         break;
                 }
-                spin_lock_bh(&sta->lock);
+        }
+
+        if (!sta && !matches_local) {
+                rcu_read_unlock();
+                reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
+                llid = 0;
+                mesh_plink_frame_tx(sdata, PLINK_CLOSE, mgmt->sa, llid,
+                                    plid, reason);
+                return;
         } else if (!sta) {
                 /* ftype == PLINK_OPEN */
                 u32 rates;
 
                 rcu_read_unlock();
 
                 if (!mesh_plink_free_count(sdata)) {
                         mpl_dbg("Mesh plink error: no more free plinks\n");
                         return;
                 }
 
                 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band);
                 sta = mesh_plink_alloc(sdata, mgmt->sa, rates);
                 if (!sta) {
                         mpl_dbg("Mesh plink error: plink table full\n");
                         return;
                 }
                 if (sta_info_insert_rcu(sta)) {
                         rcu_read_unlock();
                         return;
                 }
                 event = OPN_ACPT;
                 spin_lock_bh(&sta->lock);
-        } else {
+        } else if (matches_local) {
                 spin_lock_bh(&sta->lock);
                 switch (ftype) {
                 case PLINK_OPEN:
                         if (!mesh_plink_free_count(sdata) ||
                             (sta->plid && sta->plid != plid))
                                 event = OPN_IGNR;
                         else
                                 event = OPN_ACPT;
                         break;
                 case PLINK_CONFIRM:
@@ skipping 21 matching lines @@
                                 event = CLS_IGNR;
                         else
                                 event = CLS_ACPT;
                         break;
                 default:
                         mpl_dbg("Mesh plink: unknown frame subtype\n");
                         spin_unlock_bh(&sta->lock);
                         rcu_read_unlock();
                         return;
                 }
+        } else {
+                spin_lock_bh(&sta->lock);
         }
 
         mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
                 mgmt->sa, mplstates[sta->plink_state],
                 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
                 event);
         reason = 0;
         switch (sta->plink_state) {
                 /* spin_unlock as soon as state is updated at each case */
         case PLINK_LISTEN:
@@ skipping 189 matching lines @@
         default:
                 /* should not get here, PLINK_BLOCKED is dealt with at the
                  * beginning of the function
                  */
                 spin_unlock_bh(&sta->lock);
                 break;
         }
 
         rcu_read_unlock();
 }