← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to net/wireless/nl80211.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/wireless/nl80211.c
124
124
        [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
125
125
 
126
126
        [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
 
127
        [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
127
128
 
128
129
        [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
129
130
                                         .len = NL80211_HT_CAPABILITY_LEN },
172
173
        [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
173
174
        [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
174
175
        [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
 
176
        [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
 
177
        [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
 
178
        [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
175
179
};
176
180
 
177
181
/* policy for the key attributes */
193
197
        [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
194
198
};
195
199
 
 
200
/* policy for WoWLAN attributes */
 
201
static const struct nla_policy
 
202
nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
 
203
        [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
 
204
        [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
 
205
        [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
 
206
        [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
 
207
};
 
208
 
196
209
/* ifidx get helper */
197
210
static int nl80211_get_ifidx(struct netlink_callback *cb)
198
211
{
533
546
        case NL80211_IFTYPE_AP:
534
547
        case NL80211_IFTYPE_AP_VLAN:
535
548
        case NL80211_IFTYPE_P2P_GO:
 
549
        case NL80211_IFTYPE_MESH_POINT:
536
550
                break;
537
551
        case NL80211_IFTYPE_ADHOC:
538
552
                if (!wdev->current_bss)
550
564
        return 0;
551
565
}
552
566
 
 
567
static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
 
568
{
 
569
        struct nlattr *nl_modes = nla_nest_start(msg, attr);
 
570
        int i;
 
571
 
 
572
        if (!nl_modes)
 
573
                goto nla_put_failure;
 
574
 
 
575
        i = 0;
 
576
        while (ifmodes) {
 
577
                if (ifmodes & 1)
 
578
                        NLA_PUT_FLAG(msg, i);
 
579
                ifmodes >>= 1;
 
580
                i++;
 
581
        }
 
582
 
 
583
        nla_nest_end(msg, nl_modes);
 
584
        return 0;
 
585
 
 
586
nla_put_failure:
 
587
        return -ENOBUFS;
 
588
}
 
589
 
 
590
static int nl80211_put_iface_combinations(struct wiphy *wiphy,
 
591
                                          struct sk_buff *msg)
 
592
{
 
593
        struct nlattr *nl_combis;
 
594
        int i, j;
 
595
 
 
596
        nl_combis = nla_nest_start(msg,
 
597
                                NL80211_ATTR_INTERFACE_COMBINATIONS);
 
598
        if (!nl_combis)
 
599
                goto nla_put_failure;
 
600
 
 
601
        for (i = 0; i < wiphy->n_iface_combinations; i++) {
 
602
                const struct ieee80211_iface_combination *c;
 
603
                struct nlattr *nl_combi, *nl_limits;
 
604
 
 
605
                c = &wiphy->iface_combinations[i];
 
606
 
 
607
                nl_combi = nla_nest_start(msg, i + 1);
 
608
                if (!nl_combi)
 
609
                        goto nla_put_failure;
 
610
 
 
611
                nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
 
612
                if (!nl_limits)
 
613
                        goto nla_put_failure;
 
614
 
 
615
                for (j = 0; j < c->n_limits; j++) {
 
616
                        struct nlattr *nl_limit;
 
617
 
 
618
                        nl_limit = nla_nest_start(msg, j + 1);
 
619
                        if (!nl_limit)
 
620
                                goto nla_put_failure;
 
621
                        NLA_PUT_U32(msg, NL80211_IFACE_LIMIT_MAX,
 
622
                                    c->limits[j].max);
 
623
                        if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
 
624
                                                c->limits[j].types))
 
625
                                goto nla_put_failure;
 
626
                        nla_nest_end(msg, nl_limit);
 
627
                }
 
628
 
 
629
                nla_nest_end(msg, nl_limits);
 
630
 
 
631
                if (c->beacon_int_infra_match)
 
632
                        NLA_PUT_FLAG(msg,
 
633
                                NL80211_IFACE_COMB_STA_AP_BI_MATCH);
 
634
                NLA_PUT_U32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
 
635
                            c->num_different_channels);
 
636
                NLA_PUT_U32(msg, NL80211_IFACE_COMB_MAXNUM,
 
637
                            c->max_interfaces);
 
638
 
 
639
                nla_nest_end(msg, nl_combi);
 
640
        }
 
641
 
 
642
        nla_nest_end(msg, nl_combis);
 
643
 
 
644
        return 0;
 
645
nla_put_failure:
 
646
        return -ENOBUFS;
 
647
}
 
648
 
553
649
static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
554
650
                              struct cfg80211_registered_device *dev)
555
651
{
557
653
        struct nlattr *nl_bands, *nl_band;
558
654
        struct nlattr *nl_freqs, *nl_freq;
559
655
        struct nlattr *nl_rates, *nl_rate;
560
 
        struct nlattr *nl_modes;
561
656
        struct nlattr *nl_cmds;
562
657
        enum ieee80211_band band;
563
658
        struct ieee80211_channel *chan;
564
659
        struct ieee80211_rate *rate;
565
660
        int i;
566
 
        u16 ifmodes = dev->wiphy.interface_modes;
567
661
        const struct ieee80211_txrx_stypes *mgmt_stypes =
568
662
                                dev->wiphy.mgmt_stypes;
569
663
 
594
688
 
595
689
        if (dev->wiphy.flags & WIPHY_FLAG_IBSS_RSN)
596
690
                NLA_PUT_FLAG(msg, NL80211_ATTR_SUPPORT_IBSS_RSN);
 
691
        if (dev->wiphy.flags & WIPHY_FLAG_MESH_AUTH)
 
692
                NLA_PUT_FLAG(msg, NL80211_ATTR_SUPPORT_MESH_AUTH);
597
693
 
598
694
        NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
599
695
                sizeof(u32) * dev->wiphy.n_cipher_suites,
621
717
                }
622
718
        }
623
719
 
624
 
        nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
625
 
        if (!nl_modes)
 
720
        if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
 
721
                                dev->wiphy.interface_modes))
626
722
                goto nla_put_failure;
627
723
 
628
 
        i = 0;
629
 
        while (ifmodes) {
630
 
                if (ifmodes & 1)
631
 
                        NLA_PUT_FLAG(msg, i);
632
 
                ifmodes >>= 1;
633
 
                i++;
634
 
        }
635
 
 
636
 
        nla_nest_end(msg, nl_modes);
637
 
 
638
724
        nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
639
725
        if (!nl_bands)
640
726
                goto nla_put_failure;
746
832
        }
747
833
        CMD(set_channel, SET_CHANNEL);
748
834
        CMD(set_wds_peer, SET_WDS_PEER);
 
835
        if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
 
836
                CMD(sched_scan_start, START_SCHED_SCAN);
749
837
 
750
838
#undef CMD
751
839
 
818
906
                nla_nest_end(msg, nl_ifs);
819
907
        }
820
908
 
 
909
        if (dev->wiphy.wowlan.flags || dev->wiphy.wowlan.n_patterns) {
 
910
                struct nlattr *nl_wowlan;
 
911
 
 
912
                nl_wowlan = nla_nest_start(msg,
 
913
                                NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
 
914
                if (!nl_wowlan)
 
915
                        goto nla_put_failure;
 
916
 
 
917
                if (dev->wiphy.wowlan.flags & WIPHY_WOWLAN_ANY)
 
918
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_ANY);
 
919
                if (dev->wiphy.wowlan.flags & WIPHY_WOWLAN_DISCONNECT)
 
920
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_DISCONNECT);
 
921
                if (dev->wiphy.wowlan.flags & WIPHY_WOWLAN_MAGIC_PKT)
 
922
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT);
 
923
                if (dev->wiphy.wowlan.n_patterns) {
 
924
                        struct nl80211_wowlan_pattern_support pat = {
 
925
                                .max_patterns = dev->wiphy.wowlan.n_patterns,
 
926
                                .min_pattern_len =
 
927
                                        dev->wiphy.wowlan.pattern_min_len,
 
928
                                .max_pattern_len =
 
929
                                        dev->wiphy.wowlan.pattern_max_len,
 
930
                        };
 
931
                        NLA_PUT(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
 
932
                                sizeof(pat), &pat);
 
933
                }
 
934
 
 
935
                nla_nest_end(msg, nl_wowlan);
 
936
        }
 
937
 
 
938
        if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
 
939
                                dev->wiphy.software_iftypes))
 
940
                goto nla_put_failure;
 
941
 
 
942
        if (nl80211_put_iface_combinations(&dev->wiphy, msg))
 
943
                goto nla_put_failure;
 
944
 
821
945
        return genlmsg_end(msg, hdr);
822
946
 
823
947
 nla_put_failure:
1679
1803
                if (err)
1680
1804
                        goto out;
1681
1805
 
1682
 
                if (!(rdev->wiphy.flags &
1683
 
                                WIPHY_FLAG_SUPPORTS_SEPARATE_DEFAULT_KEYS)) {
1684
 
                        if (!key.def_uni || !key.def_multi) {
1685
 
                                err = -EOPNOTSUPP;
1686
 
                                goto out;
1687
 
                        }
1688
 
                }
1689
 
 
1690
1806
                err = rdev->ops->set_default_key(&rdev->wiphy, dev, key.idx,
1691
1807
                                                 key.def_uni, key.def_multi);
1692
1808
 
1837
1953
                    struct beacon_parameters *info);
1838
1954
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
1839
1955
        struct net_device *dev = info->user_ptr[1];
 
1956
        struct wireless_dev *wdev = dev->ieee80211_ptr;
1840
1957
        struct beacon_parameters params;
1841
 
        int haveinfo = 0;
 
1958
        int haveinfo = 0, err;
1842
1959
 
1843
1960
        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1844
1961
                return -EINVAL;
1847
1964
            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
1848
1965
                return -EOPNOTSUPP;
1849
1966
 
 
1967
        memset(&params, 0, sizeof(params));
 
1968
 
1850
1969
        switch (info->genlhdr->cmd) {
1851
1970
        case NL80211_CMD_NEW_BEACON:
1852
1971
                /* these are required for NEW_BEACON */
1855
1974
                    !info->attrs[NL80211_ATTR_BEACON_HEAD])
1856
1975
                        return -EINVAL;
1857
1976
 
 
1977
                params.interval =
 
1978
                        nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
 
1979
                params.dtim_period =
 
1980
                        nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
 
1981
 
 
1982
                err = cfg80211_validate_beacon_int(rdev, params.interval);
 
1983
                if (err)
 
1984
                        return err;
 
1985
 
1858
1986
                call = rdev->ops->add_beacon;
1859
1987
                break;
1860
1988
        case NL80211_CMD_SET_BEACON:
1868
1996
        if (!call)
1869
1997
                return -EOPNOTSUPP;
1870
1998
 
1871
 
        memset(&params, 0, sizeof(params));
1872
 
 
1873
 
        if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1874
 
                params.interval =
1875
 
                    nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1876
 
                haveinfo = 1;
1877
 
        }
1878
 
 
1879
 
        if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1880
 
                params.dtim_period =
1881
 
                    nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1882
 
                haveinfo = 1;
1883
 
        }
1884
 
 
1885
1999
        if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1886
2000
                params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1887
2001
                params.head_len =
1899
2013
        if (!haveinfo)
1900
2014
                return -EINVAL;
1901
2015
 
1902
 
        return call(&rdev->wiphy, dev, &params);
 
2016
        err = call(&rdev->wiphy, dev, &params);
 
2017
        if (!err && params.interval)
 
2018
                wdev->beacon_interval = params.interval;
 
2019
        return err;
1903
2020
}
1904
2021
 
1905
2022
static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1906
2023
{
1907
2024
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
1908
2025
        struct net_device *dev = info->user_ptr[1];
 
2026
        struct wireless_dev *wdev = dev->ieee80211_ptr;
 
2027
        int err;
1909
2028
 
1910
2029
        if (!rdev->ops->del_beacon)
1911
2030
                return -EOPNOTSUPP;
1914
2033
            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
1915
2034
                return -EOPNOTSUPP;
1916
2035
 
1917
 
        return rdev->ops->del_beacon(&rdev->wiphy, dev);
 
2036
        err = rdev->ops->del_beacon(&rdev->wiphy, dev);
 
2037
        if (!err)
 
2038
                wdev->beacon_interval = 0;
 
2039
        return err;
1918
2040
}
1919
2041
 
1920
2042
static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1922
2044
        [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1923
2045
        [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
1924
2046
        [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
 
2047
        [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
1925
2048
};
1926
2049
 
1927
2050
static int parse_station_flags(struct genl_info *info,
1968
2091
        return 0;
1969
2092
}
1970
2093
 
 
2094
static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
 
2095
                                 int attr)
 
2096
{
 
2097
        struct nlattr *rate;
 
2098
        u16 bitrate;
 
2099
 
 
2100
        rate = nla_nest_start(msg, attr);
 
2101
        if (!rate)
 
2102
                goto nla_put_failure;
 
2103
 
 
2104
        /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
 
2105
        bitrate = cfg80211_calculate_bitrate(info);
 
2106
        if (bitrate > 0)
 
2107
                NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
 
2108
 
 
2109
        if (info->flags & RATE_INFO_FLAGS_MCS)
 
2110
                NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS, info->mcs);
 
2111
        if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
 
2112
                NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
 
2113
        if (info->flags & RATE_INFO_FLAGS_SHORT_GI)
 
2114
                NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
 
2115
 
 
2116
        nla_nest_end(msg, rate);
 
2117
        return true;
 
2118
 
 
2119
nla_put_failure:
 
2120
        return false;
 
2121
}
 
2122
 
1971
2123
static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1972
2124
                                int flags, struct net_device *dev,
1973
2125
                                const u8 *mac_addr, struct station_info *sinfo)
1974
2126
{
1975
2127
        void *hdr;
1976
 
        struct nlattr *sinfoattr, *txrate;
1977
 
        u16 bitrate;
 
2128
        struct nlattr *sinfoattr, *bss_param;
1978
2129
 
1979
2130
        hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1980
2131
        if (!hdr)
1988
2139
        sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1989
2140
        if (!sinfoattr)
1990
2141
                goto nla_put_failure;
 
2142
        if (sinfo->filled & STATION_INFO_CONNECTED_TIME)
 
2143
                NLA_PUT_U32(msg, NL80211_STA_INFO_CONNECTED_TIME,
 
2144
                            sinfo->connected_time);
1991
2145
        if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1992
2146
                NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1993
2147
                            sinfo->inactive_time);
2013
2167
                NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL_AVG,
2014
2168
                           sinfo->signal_avg);
2015
2169
        if (sinfo->filled & STATION_INFO_TX_BITRATE) {
2016
 
                txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
2017
 
                if (!txrate)
2018
 
                        goto nla_put_failure;
2019
 
 
2020
 
                /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
2021
 
                bitrate = cfg80211_calculate_bitrate(&sinfo->txrate);
2022
 
                if (bitrate > 0)
2023
 
                        NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
2024
 
 
2025
 
                if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
2026
 
                        NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
2027
 
                                    sinfo->txrate.mcs);
2028
 
                if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
2029
 
                        NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
2030
 
                if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
2031
 
                        NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
2032
 
 
2033
 
                nla_nest_end(msg, txrate);
 
2170
                if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
 
2171
                                          NL80211_STA_INFO_TX_BITRATE))
 
2172
                        goto nla_put_failure;
 
2173
        }
 
2174
        if (sinfo->filled & STATION_INFO_RX_BITRATE) {
 
2175
                if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
 
2176
                                          NL80211_STA_INFO_RX_BITRATE))
 
2177
                        goto nla_put_failure;
2034
2178
        }
2035
2179
        if (sinfo->filled & STATION_INFO_RX_PACKETS)
2036
2180
                NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
2044
2188
        if (sinfo->filled & STATION_INFO_TX_FAILED)
2045
2189
                NLA_PUT_U32(msg, NL80211_STA_INFO_TX_FAILED,
2046
2190
                            sinfo->tx_failed);
 
2191
        if (sinfo->filled & STATION_INFO_BSS_PARAM) {
 
2192
                bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
 
2193
                if (!bss_param)
 
2194
                        goto nla_put_failure;
 
2195
 
 
2196
                if (sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT)
 
2197
                        NLA_PUT_FLAG(msg, NL80211_STA_BSS_PARAM_CTS_PROT);
 
2198
                if (sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE)
 
2199
                        NLA_PUT_FLAG(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE);
 
2200
                if (sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME)
 
2201
                        NLA_PUT_FLAG(msg,
 
2202
                                     NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME);
 
2203
                NLA_PUT_U8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
 
2204
                           sinfo->bss_param.dtim_period);
 
2205
                NLA_PUT_U16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
 
2206
                            sinfo->bss_param.beacon_interval);
 
2207
 
 
2208
                nla_nest_end(msg, bss_param);
 
2209
        }
2047
2210
        nla_nest_end(msg, sinfoattr);
2048
2211
 
2049
2212
        return genlmsg_end(msg, hdr);
2172
2335
        memset(&params, 0, sizeof(params));
2173
2336
 
2174
2337
        params.listen_interval = -1;
 
2338
        params.plink_state = -1;
2175
2339
 
2176
2340
        if (info->attrs[NL80211_ATTR_STA_AID])
2177
2341
                return -EINVAL;
2203
2367
                params.plink_action =
2204
2368
                    nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
2205
2369
 
 
2370
        if (info->attrs[NL80211_ATTR_STA_PLINK_STATE])
 
2371
                params.plink_state =
 
2372
                    nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
 
2373
 
2206
2374
        err = get_vlan(info, rdev, &params.vlan);
2207
2375
        if (err)
2208
2376
                goto out;
2242
2410
                        err = -EINVAL;
2243
2411
                if (params.listen_interval >= 0)
2244
2412
                        err = -EINVAL;
2245
 
                if (params.supported_rates)
2246
 
                        err = -EINVAL;
2247
 
                if (params.sta_flags_mask)
 
2413
                if (params.sta_flags_mask &
 
2414
                                ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
 
2415
                                  BIT(NL80211_STA_FLAG_MFP) |
 
2416
                                  BIT(NL80211_STA_FLAG_AUTHORIZED)))
2248
2417
                        err = -EINVAL;
2249
2418
                break;
2250
2419
        default:
2306
2475
                params.ht_capa =
2307
2476
                        nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2308
2477
 
 
2478
        if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
 
2479
                params.plink_action =
 
2480
                    nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
 
2481
 
2309
2482
        if (parse_station_flags(info, &params))
2310
2483
                return -EINVAL;
2311
2484
 
2312
2485
        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2313
2486
            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
 
2487
            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
2314
2488
            dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2315
2489
                return -EINVAL;
2316
2490
 
2718
2892
        hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2719
2893
                             NL80211_CMD_GET_MESH_CONFIG);
2720
2894
        if (!hdr)
2721
 
                goto nla_put_failure;
 
2895
                goto out;
2722
2896
        pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
2723
2897
        if (!pinfoattr)
2724
2898
                goto nla_put_failure;
2759
2933
 
2760
2934
 nla_put_failure:
2761
2935
        genlmsg_cancel(msg, hdr);
 
2936
 out:
2762
2937
        nlmsg_free(msg);
2763
2938
        return -ENOBUFS;
2764
2939
}
2785
2960
        nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
2786
2961
        [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
2787
2962
        [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
2788
 
        [NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE] = { .type = NLA_BINARY,
 
2963
        [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
 
2964
        [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
2789
2965
                .len = IEEE80211_MAX_DATA_LEN },
 
2966
        [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
2790
2967
};
2791
2968
 
2792
2969
static int nl80211_parse_mesh_config(struct genl_info *info,
2887
3064
                 IEEE80211_PATH_METRIC_VENDOR :
2888
3065
                 IEEE80211_PATH_METRIC_AIRTIME;
2889
3066
 
2890
 
        if (tb[NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE]) {
 
3067
 
 
3068
        if (tb[NL80211_MESH_SETUP_IE]) {
2891
3069
                struct nlattr *ieattr =
2892
 
                        tb[NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE];
 
3070
                        tb[NL80211_MESH_SETUP_IE];
2893
3071
                if (!is_valid_ie_attr(ieattr))
2894
3072
                        return -EINVAL;
2895
 
                setup->vendor_ie = nla_data(ieattr);
2896
 
                setup->vendor_ie_len = nla_len(ieattr);
 
3073
                setup->ie = nla_data(ieattr);
 
3074
                setup->ie_len = nla_len(ieattr);
2897
3075
        }
 
3076
        setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
 
3077
        setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
2898
3078
 
2899
3079
        return 0;
2900
3080
}
2954
3134
        hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2955
3135
                             NL80211_CMD_GET_REG);
2956
3136
        if (!hdr)
2957
 
                goto nla_put_failure;
 
3137
                goto put_failure;
2958
3138
 
2959
3139
        NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2960
3140
                cfg80211_regdomain->alpha2);
3001
3181
 
3002
3182
nla_put_failure:
3003
3183
        genlmsg_cancel(msg, hdr);
 
3184
put_failure:
3004
3185
        nlmsg_free(msg);
3005
3186
        err = -EMSGSIZE;
3006
3187
out:
3113
3294
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
3114
3295
        struct net_device *dev = info->user_ptr[1];
3115
3296
        struct cfg80211_scan_request *request;
3116
 
        struct cfg80211_ssid *ssid;
3117
 
        struct ieee80211_channel *channel;
3118
3297
        struct nlattr *attr;
3119
3298
        struct wiphy *wiphy;
3120
3299
        int err, tmp, n_ssids = 0, n_channels, i;
3161
3340
                return -EINVAL;
3162
3341
 
3163
3342
        request = kzalloc(sizeof(*request)
3164
 
                        + sizeof(*ssid) * n_ssids
3165
 
                        + sizeof(channel) * n_channels
 
3343
                        + sizeof(*request->ssids) * n_ssids
 
3344
                        + sizeof(*request->channels) * n_channels
3166
3345
                        + ie_len, GFP_KERNEL);
3167
3346
        if (!request)
3168
3347
                return -ENOMEM;
3227
3406
        i = 0;
3228
3407
        if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
3229
3408
                nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
3230
 
                        if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
 
3409
                        if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
3231
3410
                                err = -EINVAL;
3232
3411
                                goto out_free;
3233
3412
                        }
 
3413
                        request->ssids[i].ssid_len = nla_len(attr);
3234
3414
                        memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
3235
 
                        request->ssids[i].ssid_len = nla_len(attr);
3236
3415
                        i++;
3237
3416
                }
3238
3417
        }
3262
3441
        return err;
3263
3442
}
3264
3443
 
 
3444
static int nl80211_start_sched_scan(struct sk_buff *skb,
 
3445
                                    struct genl_info *info)
 
3446
{
 
3447
        struct cfg80211_sched_scan_request *request;
 
3448
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
 
3449
        struct net_device *dev = info->user_ptr[1];
 
3450
        struct nlattr *attr;
 
3451
        struct wiphy *wiphy;
 
3452
        int err, tmp, n_ssids = 0, n_channels, i;
 
3453
        u32 interval;
 
3454
        enum ieee80211_band band;
 
3455
        size_t ie_len;
 
3456
 
 
3457
        if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
 
3458
            !rdev->ops->sched_scan_start)
 
3459
                return -EOPNOTSUPP;
 
3460
 
 
3461
        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
 
3462
                return -EINVAL;
 
3463
 
 
3464
        if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
 
3465
                return -EINVAL;
 
3466
 
 
3467
        interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
 
3468
        if (interval == 0)
 
3469
                return -EINVAL;
 
3470
 
 
3471
        wiphy = &rdev->wiphy;
 
3472
 
 
3473
        if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
 
3474
                n_channels = validate_scan_freqs(
 
3475
                                info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
 
3476
                if (!n_channels)
 
3477
                        return -EINVAL;
 
3478
        } else {
 
3479
                n_channels = 0;
 
3480
 
 
3481
                for (band = 0; band < IEEE80211_NUM_BANDS; band++)
 
3482
                        if (wiphy->bands[band])
 
3483
                                n_channels += wiphy->bands[band]->n_channels;
 
3484
        }
 
3485
 
 
3486
        if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
 
3487
                nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
 
3488
                                    tmp)
 
3489
                        n_ssids++;
 
3490
 
 
3491
        if (n_ssids > wiphy->max_scan_ssids)
 
3492
                return -EINVAL;
 
3493
 
 
3494
        if (info->attrs[NL80211_ATTR_IE])
 
3495
                ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
 
3496
        else
 
3497
                ie_len = 0;
 
3498
 
 
3499
        if (ie_len > wiphy->max_scan_ie_len)
 
3500
                return -EINVAL;
 
3501
 
 
3502
        mutex_lock(&rdev->sched_scan_mtx);
 
3503
 
 
3504
        if (rdev->sched_scan_req) {
 
3505
                err = -EINPROGRESS;
 
3506
                goto out;
 
3507
        }
 
3508
 
 
3509
        request = kzalloc(sizeof(*request)
 
3510
                        + sizeof(*request->ssids) * n_ssids
 
3511
                        + sizeof(*request->channels) * n_channels
 
3512
                        + ie_len, GFP_KERNEL);
 
3513
        if (!request) {
 
3514
                err = -ENOMEM;
 
3515
                goto out;
 
3516
        }
 
3517
 
 
3518
        if (n_ssids)
 
3519
                request->ssids = (void *)&request->channels[n_channels];
 
3520
        request->n_ssids = n_ssids;
 
3521
        if (ie_len) {
 
3522
                if (request->ssids)
 
3523
                        request->ie = (void *)(request->ssids + n_ssids);
 
3524
                else
 
3525
                        request->ie = (void *)(request->channels + n_channels);
 
3526
        }
 
3527
 
 
3528
        i = 0;
 
3529
        if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
 
3530
                /* user specified, bail out if channel not found */
 
3531
                nla_for_each_nested(attr,
 
3532
                                    info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
 
3533
                                    tmp) {
 
3534
                        struct ieee80211_channel *chan;
 
3535
 
 
3536
                        chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
 
3537
 
 
3538
                        if (!chan) {
 
3539
                                err = -EINVAL;
 
3540
                                goto out_free;
 
3541
                        }
 
3542
 
 
3543
                        /* ignore disabled channels */
 
3544
                        if (chan->flags & IEEE80211_CHAN_DISABLED)
 
3545
                                continue;
 
3546
 
 
3547
                        request->channels[i] = chan;
 
3548
                        i++;
 
3549
                }
 
3550
        } else {
 
3551
                /* all channels */
 
3552
                for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 
3553
                        int j;
 
3554
                        if (!wiphy->bands[band])
 
3555
                                continue;
 
3556
                        for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
 
3557
                                struct ieee80211_channel *chan;
 
3558
 
 
3559
                                chan = &wiphy->bands[band]->channels[j];
 
3560
 
 
3561
                                if (chan->flags & IEEE80211_CHAN_DISABLED)
 
3562
                                        continue;
 
3563
 
 
3564
                                request->channels[i] = chan;
 
3565
                                i++;
 
3566
                        }
 
3567
                }
 
3568
        }
 
3569
 
 
3570
        if (!i) {
 
3571
                err = -EINVAL;
 
3572
                goto out_free;
 
3573
        }
 
3574
 
 
3575
        request->n_channels = i;
 
3576
 
 
3577
        i = 0;
 
3578
        if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
 
3579
                nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
 
3580
                                    tmp) {
 
3581
                        if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
 
3582
                                err = -EINVAL;
 
3583
                                goto out_free;
 
3584
                        }
 
3585
                        request->ssids[i].ssid_len = nla_len(attr);
 
3586
                        memcpy(request->ssids[i].ssid, nla_data(attr),
 
3587
                               nla_len(attr));
 
3588
                        i++;
 
3589
                }
 
3590
        }
 
3591
 
 
3592
        if (info->attrs[NL80211_ATTR_IE]) {
 
3593
                request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
 
3594
                memcpy((void *)request->ie,
 
3595
                       nla_data(info->attrs[NL80211_ATTR_IE]),
 
3596
                       request->ie_len);
 
3597
        }
 
3598
 
 
3599
        request->dev = dev;
 
3600
        request->wiphy = &rdev->wiphy;
 
3601
        request->interval = interval;
 
3602
 
 
3603
        err = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request);
 
3604
        if (!err) {
 
3605
                rdev->sched_scan_req = request;
 
3606
                nl80211_send_sched_scan(rdev, dev,
 
3607
                                        NL80211_CMD_START_SCHED_SCAN);
 
3608
                goto out;
 
3609
        }
 
3610
 
 
3611
out_free:
 
3612
        kfree(request);
 
3613
out:
 
3614
        mutex_unlock(&rdev->sched_scan_mtx);
 
3615
        return err;
 
3616
}
 
3617
 
 
3618
static int nl80211_stop_sched_scan(struct sk_buff *skb,
 
3619
                                   struct genl_info *info)
 
3620
{
 
3621
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
 
3622
        int err;
 
3623
 
 
3624
        if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
 
3625
            !rdev->ops->sched_scan_stop)
 
3626
                return -EOPNOTSUPP;
 
3627
 
 
3628
        mutex_lock(&rdev->sched_scan_mtx);
 
3629
        err = __cfg80211_stop_sched_scan(rdev, false);
 
3630
        mutex_unlock(&rdev->sched_scan_mtx);
 
3631
 
 
3632
        return err;
 
3633
}
 
3634
 
3265
3635
static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
3266
3636
                            struct cfg80211_registered_device *rdev,
3267
3637
                            struct wireless_dev *wdev,
4760
5130
        return cfg80211_leave_mesh(rdev, dev);
4761
5131
}
4762
5132
 
 
5133
static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
 
5134
{
 
5135
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
 
5136
        struct sk_buff *msg;
 
5137
        void *hdr;
 
5138
 
 
5139
        if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
 
5140
                return -EOPNOTSUPP;
 
5141
 
 
5142
        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 
5143
        if (!msg)
 
5144
                return -ENOMEM;
 
5145
 
 
5146
        hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
 
5147
                             NL80211_CMD_GET_WOWLAN);
 
5148
        if (!hdr)
 
5149
                goto nla_put_failure;
 
5150
 
 
5151
        if (rdev->wowlan) {
 
5152
                struct nlattr *nl_wowlan;
 
5153
 
 
5154
                nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
 
5155
                if (!nl_wowlan)
 
5156
                        goto nla_put_failure;
 
5157
 
 
5158
                if (rdev->wowlan->any)
 
5159
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_ANY);
 
5160
                if (rdev->wowlan->disconnect)
 
5161
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_DISCONNECT);
 
5162
                if (rdev->wowlan->magic_pkt)
 
5163
                        NLA_PUT_FLAG(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT);
 
5164
                if (rdev->wowlan->n_patterns) {
 
5165
                        struct nlattr *nl_pats, *nl_pat;
 
5166
                        int i, pat_len;
 
5167
 
 
5168
                        nl_pats = nla_nest_start(msg,
 
5169
                                        NL80211_WOWLAN_TRIG_PKT_PATTERN);
 
5170
                        if (!nl_pats)
 
5171
                                goto nla_put_failure;
 
5172
 
 
5173
                        for (i = 0; i < rdev->wowlan->n_patterns; i++) {
 
5174
                                nl_pat = nla_nest_start(msg, i + 1);
 
5175
                                if (!nl_pat)
 
5176
                                        goto nla_put_failure;
 
5177
                                pat_len = rdev->wowlan->patterns[i].pattern_len;
 
5178
                                NLA_PUT(msg, NL80211_WOWLAN_PKTPAT_MASK,
 
5179
                                        DIV_ROUND_UP(pat_len, 8),
 
5180
                                        rdev->wowlan->patterns[i].mask);
 
5181
                                NLA_PUT(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
 
5182
                                        pat_len,
 
5183
                                        rdev->wowlan->patterns[i].pattern);
 
5184
                                nla_nest_end(msg, nl_pat);
 
5185
                        }
 
5186
                        nla_nest_end(msg, nl_pats);
 
5187
                }
 
5188
 
 
5189
                nla_nest_end(msg, nl_wowlan);
 
5190
        }
 
5191
 
 
5192
        genlmsg_end(msg, hdr);
 
5193
        return genlmsg_reply(msg, info);
 
5194
 
 
5195
nla_put_failure:
 
5196
        nlmsg_free(msg);
 
5197
        return -ENOBUFS;
 
5198
}
 
5199
 
 
5200
static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
 
5201
{
 
5202
        struct cfg80211_registered_device *rdev = info->user_ptr[0];
 
5203
        struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
 
5204
        struct cfg80211_wowlan no_triggers = {};
 
5205
        struct cfg80211_wowlan new_triggers = {};
 
5206
        struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
 
5207
        int err, i;
 
5208
 
 
5209
        if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
 
5210
                return -EOPNOTSUPP;
 
5211
 
 
5212
        if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS])
 
5213
                goto no_triggers;
 
5214
 
 
5215
        err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
 
5216
                        nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
 
5217
                        nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
 
5218
                        nl80211_wowlan_policy);
 
5219
        if (err)
 
5220
                return err;
 
5221
 
 
5222
        if (tb[NL80211_WOWLAN_TRIG_ANY]) {
 
5223
                if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
 
5224
                        return -EINVAL;
 
5225
                new_triggers.any = true;
 
5226
        }
 
5227
 
 
5228
        if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
 
5229
                if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
 
5230
                        return -EINVAL;
 
5231
                new_triggers.disconnect = true;
 
5232
        }
 
5233
 
 
5234
        if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
 
5235
                if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
 
5236
                        return -EINVAL;
 
5237
                new_triggers.magic_pkt = true;
 
5238
        }
 
5239
 
 
5240
        if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
 
5241
                struct nlattr *pat;
 
5242
                int n_patterns = 0;
 
5243
                int rem, pat_len, mask_len;
 
5244
                struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
 
5245
 
 
5246
                nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
 
5247
                                    rem)
 
5248
                        n_patterns++;
 
5249
                if (n_patterns > wowlan->n_patterns)
 
5250
                        return -EINVAL;
 
5251
 
 
5252
                new_triggers.patterns = kcalloc(n_patterns,
 
5253
                                                sizeof(new_triggers.patterns[0]),
 
5254
                                                GFP_KERNEL);
 
5255
                if (!new_triggers.patterns)
 
5256
                        return -ENOMEM;
 
5257
 
 
5258
                new_triggers.n_patterns = n_patterns;
 
5259
                i = 0;
 
5260
 
 
5261
                nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
 
5262
                                    rem) {
 
5263
                        nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
 
5264
                                  nla_data(pat), nla_len(pat), NULL);
 
5265
                        err = -EINVAL;
 
5266
                        if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
 
5267
                            !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
 
5268
                                goto error;
 
5269
                        pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
 
5270
                        mask_len = DIV_ROUND_UP(pat_len, 8);
 
5271
                        if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
 
5272
                            mask_len)
 
5273
                                goto error;
 
5274
                        if (pat_len > wowlan->pattern_max_len ||
 
5275
                            pat_len < wowlan->pattern_min_len)
 
5276
                                goto error;
 
5277
 
 
5278
                        new_triggers.patterns[i].mask =
 
5279
                                kmalloc(mask_len + pat_len, GFP_KERNEL);
 
5280
                        if (!new_triggers.patterns[i].mask) {
 
5281
                                err = -ENOMEM;
 
5282
                                goto error;
 
5283
                        }
 
5284
                        new_triggers.patterns[i].pattern =
 
5285
                                new_triggers.patterns[i].mask + mask_len;
 
5286
                        memcpy(new_triggers.patterns[i].mask,
 
5287
                               nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
 
5288
                               mask_len);
 
5289
                        new_triggers.patterns[i].pattern_len = pat_len;
 
5290
                        memcpy(new_triggers.patterns[i].pattern,
 
5291
                               nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
 
5292
                               pat_len);
 
5293
                        i++;
 
5294
                }
 
5295
        }
 
5296
 
 
5297
        if (memcmp(&new_triggers, &no_triggers, sizeof(new_triggers))) {
 
5298
                struct cfg80211_wowlan *ntrig;
 
5299
                ntrig = kmemdup(&new_triggers, sizeof(new_triggers),
 
5300
                                GFP_KERNEL);
 
5301
                if (!ntrig) {
 
5302
                        err = -ENOMEM;
 
5303
                        goto error;
 
5304
                }
 
5305
                cfg80211_rdev_free_wowlan(rdev);
 
5306
                rdev->wowlan = ntrig;
 
5307
        } else {
 
5308
 no_triggers:
 
5309
                cfg80211_rdev_free_wowlan(rdev);
 
5310
                rdev->wowlan = NULL;
 
5311
        }
 
5312
 
 
5313
        return 0;
 
5314
 error:
 
5315
        for (i = 0; i < new_triggers.n_patterns; i++)
 
5316
                kfree(new_triggers.patterns[i].mask);
 
5317
        kfree(new_triggers.patterns);
 
5318
        return err;
 
5319
}
 
5320
 
4763
5321
#define NL80211_FLAG_NEED_WIPHY         0x01
4764
5322
#define NL80211_FLAG_NEED_NETDEV        0x02
4765
5323
#define NL80211_FLAG_NEED_RTNL          0x04
5044
5602
                .dumpit = nl80211_dump_scan,
5045
5603
        },
5046
5604
        {
 
5605
                .cmd = NL80211_CMD_START_SCHED_SCAN,
 
5606
                .doit = nl80211_start_sched_scan,
 
5607
                .policy = nl80211_policy,
 
5608
                .flags = GENL_ADMIN_PERM,
 
5609
                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
 
5610
                                  NL80211_FLAG_NEED_RTNL,
 
5611
        },
 
5612
        {
 
5613
                .cmd = NL80211_CMD_STOP_SCHED_SCAN,
 
5614
                .doit = nl80211_stop_sched_scan,
 
5615
                .policy = nl80211_policy,
 
5616
                .flags = GENL_ADMIN_PERM,
 
5617
                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
 
5618
                                  NL80211_FLAG_NEED_RTNL,
 
5619
        },
 
5620
        {
5047
5621
                .cmd = NL80211_CMD_AUTHENTICATE,
5048
5622
                .doit = nl80211_authenticate,
5049
5623
                .policy = nl80211_policy,
5258
5832
                .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
5259
5833
                                  NL80211_FLAG_NEED_RTNL,
5260
5834
        },
 
5835
        {
 
5836
                .cmd = NL80211_CMD_GET_WOWLAN,
 
5837
                .doit = nl80211_get_wowlan,
 
5838
                .policy = nl80211_policy,
 
5839
                /* can be retrieved by unprivileged users */
 
5840
                .internal_flags = NL80211_FLAG_NEED_WIPHY |
 
5841
                                  NL80211_FLAG_NEED_RTNL,
 
5842
        },
 
5843
        {
 
5844
                .cmd = NL80211_CMD_SET_WOWLAN,
 
5845
                .doit = nl80211_set_wowlan,
 
5846
                .policy = nl80211_policy,
 
5847
                .flags = GENL_ADMIN_PERM,
 
5848
                .internal_flags = NL80211_FLAG_NEED_WIPHY |
 
5849
                                  NL80211_FLAG_NEED_RTNL,
 
5850
        },
5261
5851
};
5262
5852
 
5263
5853
static struct genl_multicast_group nl80211_mlme_mcgrp = {
5353
5943
        return -EMSGSIZE;
5354
5944
}
5355
5945
 
 
5946
static int
 
5947
nl80211_send_sched_scan_msg(struct sk_buff *msg,
 
5948
                            struct cfg80211_registered_device *rdev,
 
5949
                            struct net_device *netdev,
 
5950
                            u32 pid, u32 seq, int flags, u32 cmd)
 
5951
{
 
5952
        void *hdr;
 
5953
 
 
5954
        hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
 
5955
        if (!hdr)
 
5956
                return -1;
 
5957
 
 
5958
        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
 
5959
        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
 
5960
 
 
5961
        return genlmsg_end(msg, hdr);
 
5962
 
 
5963
 nla_put_failure:
 
5964
        genlmsg_cancel(msg, hdr);
 
5965
        return -EMSGSIZE;
 
5966
}
 
5967
 
5356
5968
void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
5357
5969
                             struct net_device *netdev)
5358
5970
{
5410
6022
                                nl80211_scan_mcgrp.id, GFP_KERNEL);
5411
6023
}
5412
6024
 
 
6025
void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
 
6026
                                     struct net_device *netdev)
 
6027
{
 
6028
        struct sk_buff *msg;
 
6029
 
 
6030
        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 
6031
        if (!msg)
 
6032
                return;
 
6033
 
 
6034
        if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
 
6035
                                        NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
 
6036
                nlmsg_free(msg);
 
6037
                return;
 
6038
        }
 
6039
 
 
6040
        genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
 
6041
                                nl80211_scan_mcgrp.id, GFP_KERNEL);
 
6042
}
 
6043
 
 
6044
void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
 
6045
                             struct net_device *netdev, u32 cmd)
 
6046
{
 
6047
        struct sk_buff *msg;
 
6048
 
 
6049
        msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 
6050
        if (!msg)
 
6051
                return;
 
6052
 
 
6053
        if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
 
6054
                nlmsg_free(msg);
 
6055
                return;
 
6056
        }
 
6057
 
 
6058
        genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
 
6059
                                nl80211_scan_mcgrp.id, GFP_KERNEL);
 
6060
}
 
6061
 
5413
6062
/*
5414
6063
 * This can happen on global regulatory changes or device specific settings
5415
6064
 * based on custom world regulatory domains.
5765
6414
        nlmsg_free(msg);
5766
6415
}
5767
6416
 
 
6417
void nl80211_send_new_peer_candidate(struct cfg80211_registered_device *rdev,
 
6418
                struct net_device *netdev,
 
6419
                const u8 *macaddr, const u8* ie, u8 ie_len,
 
6420
                gfp_t gfp)
 
6421
{
 
6422
        struct sk_buff *msg;
 
6423
        void *hdr;
 
6424
 
 
6425
        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
 
6426
        if (!msg)
 
6427
                return;
 
6428
 
 
6429
        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
 
6430
        if (!hdr) {
 
6431
                nlmsg_free(msg);
 
6432
                return;
 
6433
        }
 
6434
 
 
6435
        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
 
6436
        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
 
6437
        NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, macaddr);
 
6438
        if (ie_len && ie)
 
6439
                NLA_PUT(msg, NL80211_ATTR_IE, ie_len , ie);
 
6440
 
 
6441
        if (genlmsg_end(msg, hdr) < 0) {
 
6442
                nlmsg_free(msg);
 
6443
                return;
 
6444
        }
 
6445
 
 
6446
        genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
 
6447
                                nl80211_mlme_mcgrp.id, gfp);
 
6448
        return;
 
6449
 
 
6450
 nla_put_failure:
 
6451
        genlmsg_cancel(msg, hdr);
 
6452
        nlmsg_free(msg);
 
6453
}
 
6454
 
5768
6455
void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
5769
6456
                                 struct net_device *netdev, const u8 *addr,
5770
6457
                                 enum nl80211_key_type key_type, int key_id,
5788
6475
        if (addr)
5789
6476
                NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
5790
6477
        NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
5791
 
        NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
 
6478
        if (key_id != -1)
 
6479
                NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
5792
6480
        if (tsc)
5793
6481
                NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
5794
6482
 
5946
6634
                                nl80211_mlme_mcgrp.id, gfp);
5947
6635
}
5948
6636
 
 
6637
void nl80211_send_sta_del_event(struct cfg80211_registered_device *rdev,
 
6638
                                struct net_device *dev, const u8 *mac_addr,
 
6639
                                gfp_t gfp)
 
6640
{
 
6641
        struct sk_buff *msg;
 
6642
        void *hdr;
 
6643
 
 
6644
        msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
 
6645
        if (!msg)
 
6646
                return;
 
6647
 
 
6648
        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
 
6649
        if (!hdr) {
 
6650
                nlmsg_free(msg);
 
6651
                return;
 
6652
        }
 
6653
 
 
6654
        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 
6655
        NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 
6656
 
 
6657
        if (genlmsg_end(msg, hdr) < 0) {
 
6658
                nlmsg_free(msg);
 
6659
                return;
 
6660
        }
 
6661
 
 
6662
        genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
 
6663
                                nl80211_mlme_mcgrp.id, gfp);
 
6664
        return;
 
6665
 
 
6666
 nla_put_failure:
 
6667
        genlmsg_cancel(msg, hdr);
 
6668
        nlmsg_free(msg);
 
6669
}
 
6670
 
5949
6671
int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
5950
6672
                      struct net_device *netdev, u32 nlpid,
5951
6673
                      int freq, const u8 *buf, size_t len, gfp_t gfp)