1 files changed, 295 insertions, 33 deletions

diff --git a/net/mac80211/util.c b/net/mac80211/util.c
index d5230ecc784d..9919892575f4 100644
--- a/net/mac80211/util.c
+++ b/net/mac80211/util.c
@@ -20,6 +20,7 @@
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
 #include <linux/bitmap.h>
+#include <linux/crc32.h>
 #include <net/net_namespace.h>
 #include <net/cfg80211.h>
 #include <net/rtnetlink.h>
@@ -96,13 +97,13 @@ u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
 
 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
 {
-        struct sk_buff *skb = tx->skb;
+        struct sk_buff *skb;
         struct ieee80211_hdr *hdr;
 
-        do {
+        skb_queue_walk(&tx->skbs, skb) {
                 hdr = (struct ieee80211_hdr *) skb->data;
                 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
-        } while ((skb = skb->next));
+        }
 }
 
 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
@@ -564,6 +565,172 @@ void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
 }
 EXPORT_SYMBOL(ieee80211_queue_delayed_work);
 
+u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
+                               struct ieee802_11_elems *elems,
+                               u64 filter, u32 crc)
+{
+        size_t left = len;
+        u8 *pos = start;
+        bool calc_crc = filter != 0;
+
+        memset(elems, 0, sizeof(*elems));
+        elems->ie_start = start;
+        elems->total_len = len;
+
+        while (left >= 2) {
+                u8 id, elen;
+
+                id = *pos++;
+                elen = *pos++;
+                left -= 2;
+
+                if (elen > left)
+                        break;
+
+                if (calc_crc && id < 64 && (filter & (1ULL << id)))
+                        crc = crc32_be(crc, pos - 2, elen + 2);
+
+                switch (id) {
+                case WLAN_EID_SSID:
+                        elems->ssid = pos;
+                        elems->ssid_len = elen;
+                        break;
+                case WLAN_EID_SUPP_RATES:
+                        elems->supp_rates = pos;
+                        elems->supp_rates_len = elen;
+                        break;
+                case WLAN_EID_FH_PARAMS:
+                        elems->fh_params = pos;
+                        elems->fh_params_len = elen;
+                        break;
+                case WLAN_EID_DS_PARAMS:
+                        elems->ds_params = pos;
+                        elems->ds_params_len = elen;
+                        break;
+                case WLAN_EID_CF_PARAMS:
+                        elems->cf_params = pos;
+                        elems->cf_params_len = elen;
+                        break;
+                case WLAN_EID_TIM:
+                        if (elen >= sizeof(struct ieee80211_tim_ie)) {
+                                elems->tim = (void *)pos;
+                                elems->tim_len = elen;
+                        }
+                        break;
+                case WLAN_EID_IBSS_PARAMS:
+                        elems->ibss_params = pos;
+                        elems->ibss_params_len = elen;
+                        break;
+                case WLAN_EID_CHALLENGE:
+                        elems->challenge = pos;
+                        elems->challenge_len = elen;
+                        break;
+                case WLAN_EID_VENDOR_SPECIFIC:
+                        if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
+                            pos[2] == 0xf2) {
+                                /* Microsoft OUI (00:50:F2) */
+
+                                if (calc_crc)
+                                        crc = crc32_be(crc, pos - 2, elen + 2);
+
+                                if (pos[3] == 1) {
+                                        /* OUI Type 1 - WPA IE */
+                                        elems->wpa = pos;
+                                        elems->wpa_len = elen;
+                                } else if (elen >= 5 && pos[3] == 2) {
+                                        /* OUI Type 2 - WMM IE */
+                                        if (pos[4] == 0) {
+                                                elems->wmm_info = pos;
+                                                elems->wmm_info_len = elen;
+                                        } else if (pos[4] == 1) {
+                                                elems->wmm_param = pos;
+                                                elems->wmm_param_len = elen;
+                                        }
+                                }
+                        }
+                        break;
+                case WLAN_EID_RSN:
+                        elems->rsn = pos;
+                        elems->rsn_len = elen;
+                        break;
+                case WLAN_EID_ERP_INFO:
+                        elems->erp_info = pos;
+                        elems->erp_info_len = elen;
+                        break;
+                case WLAN_EID_EXT_SUPP_RATES:
+                        elems->ext_supp_rates = pos;
+                        elems->ext_supp_rates_len = elen;
+                        break;
+                case WLAN_EID_HT_CAPABILITY:
+                        if (elen >= sizeof(struct ieee80211_ht_cap))
+                                elems->ht_cap_elem = (void *)pos;
+                        break;
+                case WLAN_EID_HT_INFORMATION:
+                        if (elen >= sizeof(struct ieee80211_ht_info))
+                                elems->ht_info_elem = (void *)pos;
+                        break;
+                case WLAN_EID_MESH_ID:
+                        elems->mesh_id = pos;
+                        elems->mesh_id_len = elen;
+                        break;
+                case WLAN_EID_MESH_CONFIG:
+                        if (elen >= sizeof(struct ieee80211_meshconf_ie))
+                                elems->mesh_config = (void *)pos;
+                        break;
+                case WLAN_EID_PEER_MGMT:
+                        elems->peering = pos;
+                        elems->peering_len = elen;
+                        break;
+                case WLAN_EID_PREQ:
+                        elems->preq = pos;
+                        elems->preq_len = elen;
+                        break;
+                case WLAN_EID_PREP:
+                        elems->prep = pos;
+                        elems->prep_len = elen;
+                        break;
+                case WLAN_EID_PERR:
+                        elems->perr = pos;
+                        elems->perr_len = elen;
+                        break;
+                case WLAN_EID_RANN:
+                        if (elen >= sizeof(struct ieee80211_rann_ie))
+                                elems->rann = (void *)pos;
+                        break;
+                case WLAN_EID_CHANNEL_SWITCH:
+                        elems->ch_switch_elem = pos;
+                        elems->ch_switch_elem_len = elen;
+                        break;
+                case WLAN_EID_QUIET:
+                        if (!elems->quiet_elem) {
+                                elems->quiet_elem = pos;
+                                elems->quiet_elem_len = elen;
+                        }
+                        elems->num_of_quiet_elem++;
+                        break;
+                case WLAN_EID_COUNTRY:
+                        elems->country_elem = pos;
+                        elems->country_elem_len = elen;
+                        break;
+                case WLAN_EID_PWR_CONSTRAINT:
+                        elems->pwr_constr_elem = pos;
+                        elems->pwr_constr_elem_len = elen;
+                        break;
+                case WLAN_EID_TIMEOUT_INTERVAL:
+                        elems->timeout_int = pos;
+                        elems->timeout_int_len = elen;
+                        break;
+                default:
+                        break;
+                }
+
+                left -= elen;
+                pos += elen;
+        }
+
+        return crc;
+}
+
 void ieee802_11_parse_elems(u8 *start, size_t len,
                             struct ieee802_11_elems *elems)
 {
@@ -812,23 +979,9 @@ int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
                 offset = noffset;
         }
 
-        if (sband->ht_cap.ht_supported) {
-                u16 cap = sband->ht_cap.cap;
-                __le16 tmp;
-
-                *pos++ = WLAN_EID_HT_CAPABILITY;
-                *pos++ = sizeof(struct ieee80211_ht_cap);
-                memset(pos, 0, sizeof(struct ieee80211_ht_cap));
-                tmp = cpu_to_le16(cap);
-                memcpy(pos, &tmp, sizeof(u16));
-                pos += sizeof(u16);
-                *pos++ = sband->ht_cap.ampdu_factor |
-                         (sband->ht_cap.ampdu_density <<
-                                IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
-                memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
-                pos += sizeof(sband->ht_cap.mcs);
-                pos += 2 + 4 + 1; /* ext info, BF cap, antsel */
-        }
+        if (sband->ht_cap.ht_supported)
+                pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
+                                                sband->ht_cap.cap);
 
         /*
          * If adding more here, adjust code in main.c
@@ -989,16 +1142,6 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                  */
         }
 #endif
-
-        /* setup fragmentation threshold */
-        drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
-
-        /* setup RTS threshold */
-        drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
-
-        /* reset coverage class */
-        drv_set_coverage_class(local, hw->wiphy->coverage_class);
-
         /* everything else happens only if HW was up & running */
         if (!local->open_count)
                 goto wake_up;
@@ -1017,6 +1160,15 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                 return res;
         }
 
+        /* setup fragmentation threshold */
+        drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
+
+        /* setup RTS threshold */
+        drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
+
+        /* reset coverage class */
+        drv_set_coverage_class(local, hw->wiphy->coverage_class);
+
         ieee80211_led_radio(local, true);
         ieee80211_mod_tpt_led_trig(local,
                                    IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
@@ -1026,7 +1178,7 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
                     sdata->vif.type != NL80211_IFTYPE_MONITOR &&
                     ieee80211_sdata_running(sdata))
-                        res = drv_add_interface(local, &sdata->vif);
+                        res = drv_add_interface(local, sdata);
         }
 
         /* add STAs back */
@@ -1076,11 +1228,13 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                           BSS_CHANGED_BEACON_INT |
                           BSS_CHANGED_BSSID |
                           BSS_CHANGED_CQM |
-                          BSS_CHANGED_QOS;
+                          BSS_CHANGED_QOS |
+                          BSS_CHANGED_IDLE;
 
                 switch (sdata->vif.type) {
                 case NL80211_IFTYPE_STATION:
-                        changed |= BSS_CHANGED_ASSOC;
+                        changed |= BSS_CHANGED_ASSOC |
+                                   BSS_CHANGED_ARP_FILTER;
                         mutex_lock(&sdata->u.mgd.mtx);
                         ieee80211_bss_info_change_notify(sdata, changed);
                         mutex_unlock(&sdata->u.mgd.mtx);
@@ -1090,6 +1244,10 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                         /* fall through */
                 case NL80211_IFTYPE_AP:
                         changed |= BSS_CHANGED_SSID;
+
+                        if (sdata->vif.type == NL80211_IFTYPE_AP)
+                                changed |= BSS_CHANGED_AP_PROBE_RESP;
+
                         /* fall through */
                 case NL80211_IFTYPE_MESH_POINT:
                         changed |= BSS_CHANGED_BEACON |
@@ -1111,6 +1269,8 @@ int ieee80211_reconfig(struct ieee80211_local *local)
                 }
         }
 
+        ieee80211_recalc_ps(local, -1);
+
         /*
          * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
          * sessions can be established after a resume.
@@ -1366,6 +1526,108 @@ void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
 }
 EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
 
+u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
+                              u16 cap)
+{
+        __le16 tmp;
+
+        *pos++ = WLAN_EID_HT_CAPABILITY;
+        *pos++ = sizeof(struct ieee80211_ht_cap);
+        memset(pos, 0, sizeof(struct ieee80211_ht_cap));
+
+        /* capability flags */
+        tmp = cpu_to_le16(cap);
+        memcpy(pos, &tmp, sizeof(u16));
+        pos += sizeof(u16);
+
+        /* AMPDU parameters */
+        *pos++ = ht_cap->ampdu_factor |
+                 (ht_cap->ampdu_density <<
+                        IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
+
+        /* MCS set */
+        memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
+        pos += sizeof(ht_cap->mcs);
+
+        /* extended capabilities */
+        pos += sizeof(__le16);
+
+        /* BF capabilities */
+        pos += sizeof(__le32);
+
+        /* antenna selection */
+        pos += sizeof(u8);
+
+        return pos;
+}
+
+u8 *ieee80211_ie_build_ht_info(u8 *pos,
+                               struct ieee80211_sta_ht_cap *ht_cap,
+                               struct ieee80211_channel *channel,
+                               enum nl80211_channel_type channel_type)
+{
+        struct ieee80211_ht_info *ht_info;
+        /* Build HT Information */
+        *pos++ = WLAN_EID_HT_INFORMATION;
+        *pos++ = sizeof(struct ieee80211_ht_info);
+        ht_info = (struct ieee80211_ht_info *)pos;
+        ht_info->control_chan =
+                        ieee80211_frequency_to_channel(channel->center_freq);
+        switch (channel_type) {
+        case NL80211_CHAN_HT40MINUS:
+                ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+                break;
+        case NL80211_CHAN_HT40PLUS:
+                ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+                break;
+        case NL80211_CHAN_HT20:
+        default:
+                ht_info->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
+                break;
+        }
+        if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
+                ht_info->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
+
+        /*
+         * Note: According to 802.11n-2009 9.13.3.1, HT Protection field and
+         * RIFS Mode are reserved in IBSS mode, therefore keep them at 0
+         */
+        ht_info->operation_mode = 0x0000;
+        ht_info->stbc_param = 0x0000;
+
+        /* It seems that Basic MCS set and Supported MCS set
+           are identical for the first 10 bytes */
+        memset(&ht_info->basic_set, 0, 16);
+        memcpy(&ht_info->basic_set, &ht_cap->mcs, 10);
+
+        return pos + sizeof(struct ieee80211_ht_info);
+}
+
+enum nl80211_channel_type
+ieee80211_ht_info_to_channel_type(struct ieee80211_ht_info *ht_info)
+{
+        enum nl80211_channel_type channel_type;
+
+        if (!ht_info)
+                return NL80211_CHAN_NO_HT;
+
+        switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
+        case IEEE80211_HT_PARAM_CHA_SEC_NONE:
+                channel_type = NL80211_CHAN_HT20;
+                break;
+        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+                channel_type = NL80211_CHAN_HT40PLUS;
+                break;
+        case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+                channel_type = NL80211_CHAN_HT40MINUS;
+                break;
+        default:
+                channel_type = NL80211_CHAN_NO_HT;
+        }
+
+        return channel_type;
+}
+
 int ieee80211_add_srates_ie(struct ieee80211_vif *vif, struct sk_buff *skb)
 {
         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);