blob: e0ecc9f153d406027ab0d731b7da1362d71c9966 [file] [log] [blame]
Johannes Berg55682962007-09-20 13:09:35 -04001/*
2 * This is the new netlink-based wireless configuration interface.
3 *
Johannes Berg08645122009-05-11 13:54:58 +02004 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg55682962007-09-20 13:09:35 -04005 */
6
7#include <linux/if.h>
8#include <linux/module.h>
9#include <linux/err.h>
Johannes Berg55682962007-09-20 13:09:35 -040010#include <linux/list.h>
11#include <linux/if_ether.h>
12#include <linux/ieee80211.h>
13#include <linux/nl80211.h>
14#include <linux/rtnetlink.h>
15#include <linux/netlink.h>
Johannes Berg2a519312009-02-10 21:25:55 +010016#include <linux/etherdevice.h>
Johannes Berg463d0182009-07-14 00:33:35 +020017#include <net/net_namespace.h>
Johannes Berg55682962007-09-20 13:09:35 -040018#include <net/genetlink.h>
19#include <net/cfg80211.h>
Johannes Berg463d0182009-07-14 00:33:35 +020020#include <net/sock.h>
Johannes Berg55682962007-09-20 13:09:35 -040021#include "core.h"
22#include "nl80211.h"
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070023#include "reg.h"
Johannes Berg55682962007-09-20 13:09:35 -040024
25/* the netlink family */
26static struct genl_family nl80211_fam = {
27 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
28 .name = "nl80211", /* have users key off the name instead */
29 .hdrsize = 0, /* no private header */
30 .version = 1, /* no particular meaning now */
31 .maxattr = NL80211_ATTR_MAX,
Johannes Berg463d0182009-07-14 00:33:35 +020032 .netnsok = true,
Johannes Berg55682962007-09-20 13:09:35 -040033};
34
Johannes Berg79c97e92009-07-07 03:56:12 +020035/* internal helper: get rdev and dev */
Johannes Berg463d0182009-07-14 00:33:35 +020036static int get_rdev_dev_by_info_ifindex(struct genl_info *info,
Johannes Berg79c97e92009-07-07 03:56:12 +020037 struct cfg80211_registered_device **rdev,
Johannes Berg55682962007-09-20 13:09:35 -040038 struct net_device **dev)
39{
Johannes Berg463d0182009-07-14 00:33:35 +020040 struct nlattr **attrs = info->attrs;
Johannes Berg55682962007-09-20 13:09:35 -040041 int ifindex;
42
Johannes Bergbba95fe2008-07-29 13:22:51 +020043 if (!attrs[NL80211_ATTR_IFINDEX])
Johannes Berg55682962007-09-20 13:09:35 -040044 return -EINVAL;
45
Johannes Bergbba95fe2008-07-29 13:22:51 +020046 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
Johannes Berg463d0182009-07-14 00:33:35 +020047 *dev = dev_get_by_index(genl_info_net(info), ifindex);
Johannes Berg55682962007-09-20 13:09:35 -040048 if (!*dev)
49 return -ENODEV;
50
Johannes Berg463d0182009-07-14 00:33:35 +020051 *rdev = cfg80211_get_dev_from_ifindex(genl_info_net(info), ifindex);
Johannes Berg79c97e92009-07-07 03:56:12 +020052 if (IS_ERR(*rdev)) {
Johannes Berg55682962007-09-20 13:09:35 -040053 dev_put(*dev);
Johannes Berg79c97e92009-07-07 03:56:12 +020054 return PTR_ERR(*rdev);
Johannes Berg55682962007-09-20 13:09:35 -040055 }
56
57 return 0;
58}
59
60/* policy for the attributes */
61static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
62 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
63 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
David S. Miller079e24e2009-05-26 21:15:00 -070064 .len = 20-1 },
Jouni Malinen31888482008-10-30 16:59:24 +020065 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
Jouni Malinen72bdcf32008-11-26 16:15:24 +020066 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
Sujith094d05d2008-12-12 11:57:43 +053067 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +020068 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
69 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
70 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
71 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
Johannes Berg55682962007-09-20 13:09:35 -040072
73 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
74 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
75 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
Johannes Berg41ade002007-12-19 02:03:29 +010076
77 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
Johannes Berg3e5d7642009-07-07 14:37:26 +020078 [NL80211_ATTR_PREV_BSSID] = { .type = NLA_BINARY, .len = ETH_ALEN },
Johannes Berg41ade002007-12-19 02:03:29 +010079
Johannes Bergb9454e82009-07-08 13:29:08 +020080 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
Johannes Berg41ade002007-12-19 02:03:29 +010081 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
82 .len = WLAN_MAX_KEY_LEN },
83 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
84 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
85 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
Jouni Malinen9f26a952009-05-15 12:38:32 +030086 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
Johannes Berged1b6cc2007-12-19 02:03:32 +010087
88 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
89 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
90 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
91 .len = IEEE80211_MAX_DATA_LEN },
92 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
93 .len = IEEE80211_MAX_DATA_LEN },
Johannes Berg5727ef12007-12-19 02:03:34 +010094 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
95 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
96 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
97 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
98 .len = NL80211_MAX_SUPP_RATES },
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +010099 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
Johannes Berg5727ef12007-12-19 02:03:34 +0100100 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
Johannes Berg0a9542e2008-10-15 11:54:04 +0200101 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100102 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
103 .len = IEEE80211_MAX_MESH_ID_LEN },
104 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
Jouni Malinen9f1ba902008-08-07 20:07:01 +0300105
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700106 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
107 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
108
Jouni Malinen9f1ba902008-08-07 20:07:01 +0300109 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
110 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
111 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
Jouni Malinen90c97a02008-10-30 16:59:22 +0200112 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
113 .len = NL80211_MAX_SUPP_RATES },
Jouni Malinen36aedc902008-08-25 11:58:58 +0300114
colin@cozybit.com93da9cc2008-10-21 12:03:48 -0700115 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
116
Jouni Malinen36aedc902008-08-25 11:58:58 +0300117 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
118 .len = NL80211_HT_CAPABILITY_LEN },
Jouni Malinen9aed3cc2009-01-13 16:03:29 +0200119
120 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
121 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
122 .len = IEEE80211_MAX_DATA_LEN },
Johannes Berg2a519312009-02-10 21:25:55 +0100123 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
124 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
Jouni Malinen636a5d32009-03-19 13:39:22 +0200125
126 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
127 .len = IEEE80211_MAX_SSID_LEN },
128 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
129 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
Johannes Berg04a773a2009-04-19 21:24:32 +0200130 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
Jouni Malinen1965c852009-04-22 21:38:25 +0300131 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
Jouni Malinendc6382c2009-05-06 22:09:37 +0300132 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
Johannes Bergeccb8e82009-05-11 21:57:56 +0300133 [NL80211_ATTR_STA_FLAGS2] = {
134 .len = sizeof(struct nl80211_sta_flag_update),
135 },
Jouni Malinen3f77316c2009-05-11 21:57:57 +0300136 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
Samuel Ortizb23aa672009-07-01 21:26:54 +0200137 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
138 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
139 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
Johannes Berg463d0182009-07-14 00:33:35 +0200140 [NL80211_ATTR_PID] = { .type = NLA_U32 },
Johannes Berg55682962007-09-20 13:09:35 -0400141};
142
Johannes Bergb9454e82009-07-08 13:29:08 +0200143/* policy for the attributes */
144static struct nla_policy
145nl80211_key_policy[NL80211_KEY_MAX + 1] __read_mostly = {
Johannes Bergfffd0932009-07-08 14:22:54 +0200146 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
Johannes Bergb9454e82009-07-08 13:29:08 +0200147 [NL80211_KEY_IDX] = { .type = NLA_U8 },
148 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
149 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
150 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
151 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
152};
153
Johannes Bergf4a11bb2009-03-27 12:40:28 +0100154/* IE validation */
155static bool is_valid_ie_attr(const struct nlattr *attr)
156{
157 const u8 *pos;
158 int len;
159
160 if (!attr)
161 return true;
162
163 pos = nla_data(attr);
164 len = nla_len(attr);
165
166 while (len) {
167 u8 elemlen;
168
169 if (len < 2)
170 return false;
171 len -= 2;
172
173 elemlen = pos[1];
174 if (elemlen > len)
175 return false;
176
177 len -= elemlen;
178 pos += 2 + elemlen;
179 }
180
181 return true;
182}
183
Johannes Berg55682962007-09-20 13:09:35 -0400184/* message building helper */
185static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
186 int flags, u8 cmd)
187{
188 /* since there is no private header just add the generic one */
189 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
190}
191
Luis R. Rodriguez5dab3b82009-04-02 14:08:08 -0400192static int nl80211_msg_put_channel(struct sk_buff *msg,
193 struct ieee80211_channel *chan)
194{
195 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
196 chan->center_freq);
197
198 if (chan->flags & IEEE80211_CHAN_DISABLED)
199 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
200 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
201 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
202 if (chan->flags & IEEE80211_CHAN_NO_IBSS)
203 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
204 if (chan->flags & IEEE80211_CHAN_RADAR)
205 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
206
207 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
208 DBM_TO_MBM(chan->max_power));
209
210 return 0;
211
212 nla_put_failure:
213 return -ENOBUFS;
214}
215
Johannes Berg55682962007-09-20 13:09:35 -0400216/* netlink command implementations */
217
Johannes Bergb9454e82009-07-08 13:29:08 +0200218struct key_parse {
219 struct key_params p;
220 int idx;
221 bool def, defmgmt;
222};
223
224static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
225{
226 struct nlattr *tb[NL80211_KEY_MAX + 1];
227 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
228 nl80211_key_policy);
229 if (err)
230 return err;
231
232 k->def = !!tb[NL80211_KEY_DEFAULT];
233 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
234
235 if (tb[NL80211_KEY_IDX])
236 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
237
238 if (tb[NL80211_KEY_DATA]) {
239 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
240 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
241 }
242
243 if (tb[NL80211_KEY_SEQ]) {
244 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
245 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
246 }
247
248 if (tb[NL80211_KEY_CIPHER])
249 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
250
251 return 0;
252}
253
254static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
255{
256 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
257 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
258 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
259 }
260
261 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
262 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
263 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
264 }
265
266 if (info->attrs[NL80211_ATTR_KEY_IDX])
267 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
268
269 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
270 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
271
272 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
273 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
274
275 return 0;
276}
277
278static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
279{
280 int err;
281
282 memset(k, 0, sizeof(*k));
283 k->idx = -1;
284
285 if (info->attrs[NL80211_ATTR_KEY])
286 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
287 else
288 err = nl80211_parse_key_old(info, k);
289
290 if (err)
291 return err;
292
293 if (k->def && k->defmgmt)
294 return -EINVAL;
295
296 if (k->idx != -1) {
297 if (k->defmgmt) {
298 if (k->idx < 4 || k->idx > 5)
299 return -EINVAL;
300 } else if (k->def) {
301 if (k->idx < 0 || k->idx > 3)
302 return -EINVAL;
303 } else {
304 if (k->idx < 0 || k->idx > 5)
305 return -EINVAL;
306 }
307 }
308
309 return 0;
310}
311
Johannes Bergfffd0932009-07-08 14:22:54 +0200312static struct cfg80211_cached_keys *
313nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
314 struct nlattr *keys)
315{
316 struct key_parse parse;
317 struct nlattr *key;
318 struct cfg80211_cached_keys *result;
319 int rem, err, def = 0;
320
321 result = kzalloc(sizeof(*result), GFP_KERNEL);
322 if (!result)
323 return ERR_PTR(-ENOMEM);
324
325 result->def = -1;
326 result->defmgmt = -1;
327
328 nla_for_each_nested(key, keys, rem) {
329 memset(&parse, 0, sizeof(parse));
330 parse.idx = -1;
331
332 err = nl80211_parse_key_new(key, &parse);
333 if (err)
334 goto error;
335 err = -EINVAL;
336 if (!parse.p.key)
337 goto error;
338 if (parse.idx < 0 || parse.idx > 4)
339 goto error;
340 if (parse.def) {
341 if (def)
342 goto error;
343 def = 1;
344 result->def = parse.idx;
345 } else if (parse.defmgmt)
346 goto error;
347 err = cfg80211_validate_key_settings(rdev, &parse.p,
348 parse.idx, NULL);
349 if (err)
350 goto error;
351 result->params[parse.idx].cipher = parse.p.cipher;
352 result->params[parse.idx].key_len = parse.p.key_len;
353 result->params[parse.idx].key = result->data[parse.idx];
354 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
355 }
356
357 return result;
358 error:
359 kfree(result);
360 return ERR_PTR(err);
361}
362
363static int nl80211_key_allowed(struct wireless_dev *wdev)
364{
365 ASSERT_WDEV_LOCK(wdev);
366
367 if (!netif_running(wdev->netdev))
368 return -ENETDOWN;
369
370 switch (wdev->iftype) {
371 case NL80211_IFTYPE_AP:
372 case NL80211_IFTYPE_AP_VLAN:
373 break;
374 case NL80211_IFTYPE_ADHOC:
375 if (!wdev->current_bss)
376 return -ENOLINK;
377 break;
378 case NL80211_IFTYPE_STATION:
379 if (wdev->sme_state != CFG80211_SME_CONNECTED)
380 return -ENOLINK;
381 break;
382 default:
383 return -EINVAL;
384 }
385
386 return 0;
387}
388
Johannes Berg55682962007-09-20 13:09:35 -0400389static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
390 struct cfg80211_registered_device *dev)
391{
392 void *hdr;
Johannes Bergee688b002008-01-24 19:38:39 +0100393 struct nlattr *nl_bands, *nl_band;
394 struct nlattr *nl_freqs, *nl_freq;
395 struct nlattr *nl_rates, *nl_rate;
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700396 struct nlattr *nl_modes;
Johannes Berg8fdc6212009-03-14 09:34:01 +0100397 struct nlattr *nl_cmds;
Johannes Bergee688b002008-01-24 19:38:39 +0100398 enum ieee80211_band band;
399 struct ieee80211_channel *chan;
400 struct ieee80211_rate *rate;
401 int i;
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700402 u16 ifmodes = dev->wiphy.interface_modes;
Johannes Berg55682962007-09-20 13:09:35 -0400403
404 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
405 if (!hdr)
406 return -1;
407
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500408 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
Johannes Berg55682962007-09-20 13:09:35 -0400409 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200410
Johannes Bergf5ea9122009-08-07 16:17:38 +0200411 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
412 cfg80211_rdev_list_generation);
413
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200414 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
415 dev->wiphy.retry_short);
416 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
417 dev->wiphy.retry_long);
418 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
419 dev->wiphy.frag_threshold);
420 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
421 dev->wiphy.rts_threshold);
422
Johannes Berg2a519312009-02-10 21:25:55 +0100423 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
424 dev->wiphy.max_scan_ssids);
Johannes Berg18a83652009-03-31 12:12:05 +0200425 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
426 dev->wiphy.max_scan_ie_len);
Johannes Bergee688b002008-01-24 19:38:39 +0100427
Johannes Berg25e47c12009-04-02 20:14:06 +0200428 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
429 sizeof(u32) * dev->wiphy.n_cipher_suites,
430 dev->wiphy.cipher_suites);
431
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700432 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
433 if (!nl_modes)
434 goto nla_put_failure;
435
436 i = 0;
437 while (ifmodes) {
438 if (ifmodes & 1)
439 NLA_PUT_FLAG(msg, i);
440 ifmodes >>= 1;
441 i++;
442 }
443
444 nla_nest_end(msg, nl_modes);
445
Johannes Bergee688b002008-01-24 19:38:39 +0100446 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
447 if (!nl_bands)
448 goto nla_put_failure;
449
450 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
451 if (!dev->wiphy.bands[band])
452 continue;
453
454 nl_band = nla_nest_start(msg, band);
455 if (!nl_band)
456 goto nla_put_failure;
457
Johannes Bergd51626d2008-10-09 12:20:13 +0200458 /* add HT info */
459 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
460 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
461 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
462 &dev->wiphy.bands[band]->ht_cap.mcs);
463 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
464 dev->wiphy.bands[band]->ht_cap.cap);
465 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
466 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
467 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
468 dev->wiphy.bands[band]->ht_cap.ampdu_density);
469 }
470
Johannes Bergee688b002008-01-24 19:38:39 +0100471 /* add frequencies */
472 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
473 if (!nl_freqs)
474 goto nla_put_failure;
475
476 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
477 nl_freq = nla_nest_start(msg, i);
478 if (!nl_freq)
479 goto nla_put_failure;
480
481 chan = &dev->wiphy.bands[band]->channels[i];
Johannes Bergee688b002008-01-24 19:38:39 +0100482
Luis R. Rodriguez5dab3b82009-04-02 14:08:08 -0400483 if (nl80211_msg_put_channel(msg, chan))
484 goto nla_put_failure;
Jouni Malinene2f367f262008-11-21 19:01:30 +0200485
Johannes Bergee688b002008-01-24 19:38:39 +0100486 nla_nest_end(msg, nl_freq);
487 }
488
489 nla_nest_end(msg, nl_freqs);
490
491 /* add bitrates */
492 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
493 if (!nl_rates)
494 goto nla_put_failure;
495
496 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
497 nl_rate = nla_nest_start(msg, i);
498 if (!nl_rate)
499 goto nla_put_failure;
500
501 rate = &dev->wiphy.bands[band]->bitrates[i];
502 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
503 rate->bitrate);
504 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
505 NLA_PUT_FLAG(msg,
506 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
507
508 nla_nest_end(msg, nl_rate);
509 }
510
511 nla_nest_end(msg, nl_rates);
512
513 nla_nest_end(msg, nl_band);
514 }
515 nla_nest_end(msg, nl_bands);
516
Johannes Berg8fdc6212009-03-14 09:34:01 +0100517 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
518 if (!nl_cmds)
519 goto nla_put_failure;
520
521 i = 0;
522#define CMD(op, n) \
523 do { \
524 if (dev->ops->op) { \
525 i++; \
526 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \
527 } \
528 } while (0)
529
530 CMD(add_virtual_intf, NEW_INTERFACE);
531 CMD(change_virtual_intf, SET_INTERFACE);
532 CMD(add_key, NEW_KEY);
533 CMD(add_beacon, NEW_BEACON);
534 CMD(add_station, NEW_STATION);
535 CMD(add_mpath, NEW_MPATH);
536 CMD(set_mesh_params, SET_MESH_PARAMS);
537 CMD(change_bss, SET_BSS);
Jouni Malinen636a5d32009-03-19 13:39:22 +0200538 CMD(auth, AUTHENTICATE);
539 CMD(assoc, ASSOCIATE);
540 CMD(deauth, DEAUTHENTICATE);
541 CMD(disassoc, DISASSOCIATE);
Johannes Berg04a773a2009-04-19 21:24:32 +0200542 CMD(join_ibss, JOIN_IBSS);
Johannes Berg463d0182009-07-14 00:33:35 +0200543 if (dev->wiphy.netnsok) {
544 i++;
545 NLA_PUT_U32(msg, i, NL80211_CMD_SET_WIPHY_NETNS);
546 }
Johannes Berg8fdc6212009-03-14 09:34:01 +0100547
548#undef CMD
Samuel Ortizb23aa672009-07-01 21:26:54 +0200549
Johannes Berg6829c872009-07-02 09:13:27 +0200550 if (dev->ops->connect || dev->ops->auth) {
Samuel Ortizb23aa672009-07-01 21:26:54 +0200551 i++;
552 NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT);
553 }
554
Johannes Berg6829c872009-07-02 09:13:27 +0200555 if (dev->ops->disconnect || dev->ops->deauth) {
Samuel Ortizb23aa672009-07-01 21:26:54 +0200556 i++;
557 NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT);
558 }
559
Johannes Berg8fdc6212009-03-14 09:34:01 +0100560 nla_nest_end(msg, nl_cmds);
561
Johannes Berg55682962007-09-20 13:09:35 -0400562 return genlmsg_end(msg, hdr);
563
564 nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -0700565 genlmsg_cancel(msg, hdr);
566 return -EMSGSIZE;
Johannes Berg55682962007-09-20 13:09:35 -0400567}
568
569static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
570{
571 int idx = 0;
572 int start = cb->args[0];
573 struct cfg80211_registered_device *dev;
574
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500575 mutex_lock(&cfg80211_mutex);
Johannes Berg79c97e92009-07-07 03:56:12 +0200576 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
Johannes Berg463d0182009-07-14 00:33:35 +0200577 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
578 continue;
Julius Volzb4637272008-07-08 14:02:19 +0200579 if (++idx <= start)
Johannes Berg55682962007-09-20 13:09:35 -0400580 continue;
581 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
582 cb->nlh->nlmsg_seq, NLM_F_MULTI,
Julius Volzb4637272008-07-08 14:02:19 +0200583 dev) < 0) {
584 idx--;
Johannes Berg55682962007-09-20 13:09:35 -0400585 break;
Julius Volzb4637272008-07-08 14:02:19 +0200586 }
Johannes Berg55682962007-09-20 13:09:35 -0400587 }
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500588 mutex_unlock(&cfg80211_mutex);
Johannes Berg55682962007-09-20 13:09:35 -0400589
590 cb->args[0] = idx;
591
592 return skb->len;
593}
594
595static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
596{
597 struct sk_buff *msg;
598 struct cfg80211_registered_device *dev;
599
600 dev = cfg80211_get_dev_from_info(info);
601 if (IS_ERR(dev))
602 return PTR_ERR(dev);
603
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -0700604 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg55682962007-09-20 13:09:35 -0400605 if (!msg)
606 goto out_err;
607
608 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
609 goto out_free;
610
Johannes Berg4d0c8ae2009-07-07 03:56:09 +0200611 cfg80211_unlock_rdev(dev);
Johannes Berg55682962007-09-20 13:09:35 -0400612
Johannes Berg134e6372009-07-10 09:51:34 +0000613 return genlmsg_reply(msg, info);
Johannes Berg55682962007-09-20 13:09:35 -0400614
615 out_free:
616 nlmsg_free(msg);
617 out_err:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +0200618 cfg80211_unlock_rdev(dev);
Johannes Berg55682962007-09-20 13:09:35 -0400619 return -ENOBUFS;
620}
621
Jouni Malinen31888482008-10-30 16:59:24 +0200622static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
623 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
624 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
625 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
626 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
627 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
628};
629
630static int parse_txq_params(struct nlattr *tb[],
631 struct ieee80211_txq_params *txq_params)
632{
633 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
634 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
635 !tb[NL80211_TXQ_ATTR_AIFS])
636 return -EINVAL;
637
638 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
639 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
640 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
641 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
642 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
643
644 return 0;
645}
646
Johannes Berg55682962007-09-20 13:09:35 -0400647static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
648{
649 struct cfg80211_registered_device *rdev;
Jouni Malinen31888482008-10-30 16:59:24 +0200650 int result = 0, rem_txq_params = 0;
651 struct nlattr *nl_txq_params;
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200652 u32 changed;
653 u8 retry_short = 0, retry_long = 0;
654 u32 frag_threshold = 0, rts_threshold = 0;
Johannes Berg55682962007-09-20 13:09:35 -0400655
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100656 rtnl_lock();
Johannes Berg55682962007-09-20 13:09:35 -0400657
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100658 mutex_lock(&cfg80211_mutex);
659
Johannes Berg79c97e92009-07-07 03:56:12 +0200660 rdev = __cfg80211_rdev_from_info(info);
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100661 if (IS_ERR(rdev)) {
Jiri Slaby1f5fc702009-06-20 12:31:11 +0200662 mutex_unlock(&cfg80211_mutex);
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100663 result = PTR_ERR(rdev);
664 goto unlock;
665 }
666
667 mutex_lock(&rdev->mtx);
668
669 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
Jouni Malinen31888482008-10-30 16:59:24 +0200670 result = cfg80211_dev_rename(
671 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100672
673 mutex_unlock(&cfg80211_mutex);
674
675 if (result)
676 goto bad_res;
Johannes Berg55682962007-09-20 13:09:35 -0400677
Jouni Malinen31888482008-10-30 16:59:24 +0200678 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
679 struct ieee80211_txq_params txq_params;
680 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
681
682 if (!rdev->ops->set_txq_params) {
683 result = -EOPNOTSUPP;
684 goto bad_res;
685 }
686
687 nla_for_each_nested(nl_txq_params,
688 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
689 rem_txq_params) {
690 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
691 nla_data(nl_txq_params),
692 nla_len(nl_txq_params),
693 txq_params_policy);
694 result = parse_txq_params(tb, &txq_params);
695 if (result)
696 goto bad_res;
697
698 result = rdev->ops->set_txq_params(&rdev->wiphy,
699 &txq_params);
700 if (result)
701 goto bad_res;
702 }
703 }
704
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200705 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
Sujith094d05d2008-12-12 11:57:43 +0530706 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
Luis R. Rodriguez294196a2009-05-02 00:37:20 -0400707 u32 freq;
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200708
Johannes Berg306d6112008-12-08 12:39:04 +0100709 result = -EINVAL;
710
Sujith094d05d2008-12-12 11:57:43 +0530711 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
712 channel_type = nla_get_u32(info->attrs[
713 NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
714 if (channel_type != NL80211_CHAN_NO_HT &&
715 channel_type != NL80211_CHAN_HT20 &&
716 channel_type != NL80211_CHAN_HT40PLUS &&
717 channel_type != NL80211_CHAN_HT40MINUS)
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200718 goto bad_res;
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200719 }
720
721 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
Johannes Berg306d6112008-12-08 12:39:04 +0100722
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200723 mutex_lock(&rdev->devlist_mtx);
Johannes Berg4b181142009-08-08 11:03:58 +0200724 result = rdev_set_freq(rdev, NULL, freq, channel_type);
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200725 mutex_unlock(&rdev->devlist_mtx);
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200726 if (result)
727 goto bad_res;
728 }
729
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200730 changed = 0;
731
732 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
733 retry_short = nla_get_u8(
734 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
735 if (retry_short == 0) {
736 result = -EINVAL;
737 goto bad_res;
738 }
739 changed |= WIPHY_PARAM_RETRY_SHORT;
740 }
741
742 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
743 retry_long = nla_get_u8(
744 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
745 if (retry_long == 0) {
746 result = -EINVAL;
747 goto bad_res;
748 }
749 changed |= WIPHY_PARAM_RETRY_LONG;
750 }
751
752 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
753 frag_threshold = nla_get_u32(
754 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
755 if (frag_threshold < 256) {
756 result = -EINVAL;
757 goto bad_res;
758 }
759 if (frag_threshold != (u32) -1) {
760 /*
761 * Fragments (apart from the last one) are required to
762 * have even length. Make the fragmentation code
763 * simpler by stripping LSB should someone try to use
764 * odd threshold value.
765 */
766 frag_threshold &= ~0x1;
767 }
768 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
769 }
770
771 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
772 rts_threshold = nla_get_u32(
773 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
774 changed |= WIPHY_PARAM_RTS_THRESHOLD;
775 }
776
777 if (changed) {
778 u8 old_retry_short, old_retry_long;
779 u32 old_frag_threshold, old_rts_threshold;
780
781 if (!rdev->ops->set_wiphy_params) {
782 result = -EOPNOTSUPP;
783 goto bad_res;
784 }
785
786 old_retry_short = rdev->wiphy.retry_short;
787 old_retry_long = rdev->wiphy.retry_long;
788 old_frag_threshold = rdev->wiphy.frag_threshold;
789 old_rts_threshold = rdev->wiphy.rts_threshold;
790
791 if (changed & WIPHY_PARAM_RETRY_SHORT)
792 rdev->wiphy.retry_short = retry_short;
793 if (changed & WIPHY_PARAM_RETRY_LONG)
794 rdev->wiphy.retry_long = retry_long;
795 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
796 rdev->wiphy.frag_threshold = frag_threshold;
797 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
798 rdev->wiphy.rts_threshold = rts_threshold;
799
800 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
801 if (result) {
802 rdev->wiphy.retry_short = old_retry_short;
803 rdev->wiphy.retry_long = old_retry_long;
804 rdev->wiphy.frag_threshold = old_frag_threshold;
805 rdev->wiphy.rts_threshold = old_rts_threshold;
806 }
807 }
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200808
Johannes Berg306d6112008-12-08 12:39:04 +0100809 bad_res:
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100810 mutex_unlock(&rdev->mtx);
811 unlock:
812 rtnl_unlock();
Johannes Berg55682962007-09-20 13:09:35 -0400813 return result;
814}
815
816
817static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
Johannes Bergd7264052009-04-19 16:23:20 +0200818 struct cfg80211_registered_device *rdev,
Johannes Berg55682962007-09-20 13:09:35 -0400819 struct net_device *dev)
820{
821 void *hdr;
822
823 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
824 if (!hdr)
825 return -1;
826
827 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
Johannes Bergd7264052009-04-19 16:23:20 +0200828 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
Johannes Berg55682962007-09-20 13:09:35 -0400829 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
Johannes Berg60719ff2008-09-16 14:55:09 +0200830 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200831
832 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
833 rdev->devlist_generation ^
834 (cfg80211_rdev_list_generation << 2));
835
Johannes Berg55682962007-09-20 13:09:35 -0400836 return genlmsg_end(msg, hdr);
837
838 nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -0700839 genlmsg_cancel(msg, hdr);
840 return -EMSGSIZE;
Johannes Berg55682962007-09-20 13:09:35 -0400841}
842
843static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
844{
845 int wp_idx = 0;
846 int if_idx = 0;
847 int wp_start = cb->args[0];
848 int if_start = cb->args[1];
Johannes Bergf5ea9122009-08-07 16:17:38 +0200849 struct cfg80211_registered_device *rdev;
Johannes Berg55682962007-09-20 13:09:35 -0400850 struct wireless_dev *wdev;
851
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500852 mutex_lock(&cfg80211_mutex);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200853 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
854 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
Johannes Berg463d0182009-07-14 00:33:35 +0200855 continue;
Johannes Bergbba95fe2008-07-29 13:22:51 +0200856 if (wp_idx < wp_start) {
857 wp_idx++;
Johannes Berg55682962007-09-20 13:09:35 -0400858 continue;
Johannes Bergbba95fe2008-07-29 13:22:51 +0200859 }
Johannes Berg55682962007-09-20 13:09:35 -0400860 if_idx = 0;
861
Johannes Bergf5ea9122009-08-07 16:17:38 +0200862 mutex_lock(&rdev->devlist_mtx);
863 list_for_each_entry(wdev, &rdev->netdev_list, list) {
Johannes Bergbba95fe2008-07-29 13:22:51 +0200864 if (if_idx < if_start) {
865 if_idx++;
Johannes Berg55682962007-09-20 13:09:35 -0400866 continue;
Johannes Bergbba95fe2008-07-29 13:22:51 +0200867 }
Johannes Berg55682962007-09-20 13:09:35 -0400868 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
869 cb->nlh->nlmsg_seq, NLM_F_MULTI,
Johannes Bergf5ea9122009-08-07 16:17:38 +0200870 rdev, wdev->netdev) < 0) {
871 mutex_unlock(&rdev->devlist_mtx);
Johannes Bergbba95fe2008-07-29 13:22:51 +0200872 goto out;
873 }
874 if_idx++;
Johannes Berg55682962007-09-20 13:09:35 -0400875 }
Johannes Bergf5ea9122009-08-07 16:17:38 +0200876 mutex_unlock(&rdev->devlist_mtx);
Johannes Bergbba95fe2008-07-29 13:22:51 +0200877
878 wp_idx++;
Johannes Berg55682962007-09-20 13:09:35 -0400879 }
Johannes Bergbba95fe2008-07-29 13:22:51 +0200880 out:
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500881 mutex_unlock(&cfg80211_mutex);
Johannes Berg55682962007-09-20 13:09:35 -0400882
883 cb->args[0] = wp_idx;
884 cb->args[1] = if_idx;
885
886 return skb->len;
887}
888
889static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
890{
891 struct sk_buff *msg;
892 struct cfg80211_registered_device *dev;
893 struct net_device *netdev;
894 int err;
895
Johannes Berg463d0182009-07-14 00:33:35 +0200896 err = get_rdev_dev_by_info_ifindex(info, &dev, &netdev);
Johannes Berg55682962007-09-20 13:09:35 -0400897 if (err)
898 return err;
899
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -0700900 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg55682962007-09-20 13:09:35 -0400901 if (!msg)
902 goto out_err;
903
Johannes Bergd7264052009-04-19 16:23:20 +0200904 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
905 dev, netdev) < 0)
Johannes Berg55682962007-09-20 13:09:35 -0400906 goto out_free;
907
908 dev_put(netdev);
Johannes Berg4d0c8ae2009-07-07 03:56:09 +0200909 cfg80211_unlock_rdev(dev);
Johannes Berg55682962007-09-20 13:09:35 -0400910
Johannes Berg134e6372009-07-10 09:51:34 +0000911 return genlmsg_reply(msg, info);
Johannes Berg55682962007-09-20 13:09:35 -0400912
913 out_free:
914 nlmsg_free(msg);
915 out_err:
916 dev_put(netdev);
Johannes Berg4d0c8ae2009-07-07 03:56:09 +0200917 cfg80211_unlock_rdev(dev);
Johannes Berg55682962007-09-20 13:09:35 -0400918 return -ENOBUFS;
919}
920
Michael Wu66f7ac52008-01-31 19:48:22 +0100921static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
922 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
923 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
924 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
925 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
926 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
927};
928
929static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
930{
931 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
932 int flag;
933
934 *mntrflags = 0;
935
936 if (!nla)
937 return -EINVAL;
938
939 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
940 nla, mntr_flags_policy))
941 return -EINVAL;
942
943 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
944 if (flags[flag])
945 *mntrflags |= (1<<flag);
946
947 return 0;
948}
949
Johannes Berg55682962007-09-20 13:09:35 -0400950static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
951{
Johannes Berg79c97e92009-07-07 03:56:12 +0200952 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100953 struct vif_params params;
Johannes Berge36d56b2009-06-09 21:04:43 +0200954 int err;
Johannes Berg04a773a2009-04-19 21:24:32 +0200955 enum nl80211_iftype otype, ntype;
Johannes Berg55682962007-09-20 13:09:35 -0400956 struct net_device *dev;
Johannes Berg92ffe052008-09-16 20:39:36 +0200957 u32 _flags, *flags = NULL;
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100958 bool change = false;
Johannes Berg55682962007-09-20 13:09:35 -0400959
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100960 memset(&params, 0, sizeof(params));
961
Johannes Berg3b858752009-03-12 09:55:09 +0100962 rtnl_lock();
963
Johannes Berg463d0182009-07-14 00:33:35 +0200964 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg55682962007-09-20 13:09:35 -0400965 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +0100966 goto unlock_rtnl;
967
Johannes Berg04a773a2009-04-19 21:24:32 +0200968 otype = ntype = dev->ieee80211_ptr->iftype;
Johannes Berg55682962007-09-20 13:09:35 -0400969
Johannes Berg723b0382008-09-16 20:22:09 +0200970 if (info->attrs[NL80211_ATTR_IFTYPE]) {
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100971 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
Johannes Berg04a773a2009-04-19 21:24:32 +0200972 if (otype != ntype)
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100973 change = true;
Johannes Berg04a773a2009-04-19 21:24:32 +0200974 if (ntype > NL80211_IFTYPE_MAX) {
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100975 err = -EINVAL;
Johannes Berg723b0382008-09-16 20:22:09 +0200976 goto unlock;
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100977 }
Johannes Berg723b0382008-09-16 20:22:09 +0200978 }
979
Johannes Berg92ffe052008-09-16 20:39:36 +0200980 if (info->attrs[NL80211_ATTR_MESH_ID]) {
Johannes Berg04a773a2009-04-19 21:24:32 +0200981 if (ntype != NL80211_IFTYPE_MESH_POINT) {
Johannes Berg92ffe052008-09-16 20:39:36 +0200982 err = -EINVAL;
983 goto unlock;
984 }
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100985 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
986 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100987 change = true;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100988 }
989
Johannes Berg92ffe052008-09-16 20:39:36 +0200990 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
Johannes Berg04a773a2009-04-19 21:24:32 +0200991 if (ntype != NL80211_IFTYPE_MONITOR) {
Johannes Berg92ffe052008-09-16 20:39:36 +0200992 err = -EINVAL;
993 goto unlock;
994 }
995 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
996 &_flags);
Johannes Bergac7f9cf2009-03-21 17:07:59 +0100997 if (err)
998 goto unlock;
999
1000 flags = &_flags;
1001 change = true;
Johannes Berg92ffe052008-09-16 20:39:36 +02001002 }
Johannes Berg3b858752009-03-12 09:55:09 +01001003
Johannes Bergac7f9cf2009-03-21 17:07:59 +01001004 if (change)
Johannes Berg3d54d252009-08-21 14:51:05 +02001005 err = cfg80211_change_iface(rdev, dev, ntype, flags, &params);
Johannes Bergac7f9cf2009-03-21 17:07:59 +01001006 else
1007 err = 0;
Johannes Berg60719ff2008-09-16 14:55:09 +02001008
Johannes Berg55682962007-09-20 13:09:35 -04001009 unlock:
Johannes Berge36d56b2009-06-09 21:04:43 +02001010 dev_put(dev);
Johannes Berg79c97e92009-07-07 03:56:12 +02001011 cfg80211_unlock_rdev(rdev);
Johannes Berg3b858752009-03-12 09:55:09 +01001012 unlock_rtnl:
1013 rtnl_unlock();
Johannes Berg55682962007-09-20 13:09:35 -04001014 return err;
1015}
1016
1017static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
1018{
Johannes Berg79c97e92009-07-07 03:56:12 +02001019 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001020 struct vif_params params;
Johannes Berg55682962007-09-20 13:09:35 -04001021 int err;
1022 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
Michael Wu66f7ac52008-01-31 19:48:22 +01001023 u32 flags;
Johannes Berg55682962007-09-20 13:09:35 -04001024
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001025 memset(&params, 0, sizeof(params));
1026
Johannes Berg55682962007-09-20 13:09:35 -04001027 if (!info->attrs[NL80211_ATTR_IFNAME])
1028 return -EINVAL;
1029
1030 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1031 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1032 if (type > NL80211_IFTYPE_MAX)
1033 return -EINVAL;
1034 }
1035
Johannes Berg3b858752009-03-12 09:55:09 +01001036 rtnl_lock();
1037
Johannes Berg79c97e92009-07-07 03:56:12 +02001038 rdev = cfg80211_get_dev_from_info(info);
1039 if (IS_ERR(rdev)) {
1040 err = PTR_ERR(rdev);
Johannes Berg3b858752009-03-12 09:55:09 +01001041 goto unlock_rtnl;
1042 }
Johannes Berg55682962007-09-20 13:09:35 -04001043
Johannes Berg79c97e92009-07-07 03:56:12 +02001044 if (!rdev->ops->add_virtual_intf ||
1045 !(rdev->wiphy.interface_modes & (1 << type))) {
Johannes Berg55682962007-09-20 13:09:35 -04001046 err = -EOPNOTSUPP;
1047 goto unlock;
1048 }
1049
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001050 if (type == NL80211_IFTYPE_MESH_POINT &&
1051 info->attrs[NL80211_ATTR_MESH_ID]) {
1052 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
1053 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1054 }
1055
Michael Wu66f7ac52008-01-31 19:48:22 +01001056 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1057 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1058 &flags);
Johannes Berg79c97e92009-07-07 03:56:12 +02001059 err = rdev->ops->add_virtual_intf(&rdev->wiphy,
Michael Wu66f7ac52008-01-31 19:48:22 +01001060 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001061 type, err ? NULL : &flags, &params);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001062
Johannes Berg55682962007-09-20 13:09:35 -04001063 unlock:
Johannes Berg79c97e92009-07-07 03:56:12 +02001064 cfg80211_unlock_rdev(rdev);
Johannes Berg3b858752009-03-12 09:55:09 +01001065 unlock_rtnl:
1066 rtnl_unlock();
Johannes Berg55682962007-09-20 13:09:35 -04001067 return err;
1068}
1069
1070static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1071{
Johannes Berg79c97e92009-07-07 03:56:12 +02001072 struct cfg80211_registered_device *rdev;
Johannes Berg463d0182009-07-14 00:33:35 +02001073 int err;
Johannes Berg55682962007-09-20 13:09:35 -04001074 struct net_device *dev;
1075
Johannes Berg3b858752009-03-12 09:55:09 +01001076 rtnl_lock();
1077
Johannes Berg463d0182009-07-14 00:33:35 +02001078 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg55682962007-09-20 13:09:35 -04001079 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001080 goto unlock_rtnl;
Johannes Berg55682962007-09-20 13:09:35 -04001081
Johannes Berg79c97e92009-07-07 03:56:12 +02001082 if (!rdev->ops->del_virtual_intf) {
Johannes Berg55682962007-09-20 13:09:35 -04001083 err = -EOPNOTSUPP;
1084 goto out;
1085 }
1086
Johannes Berg463d0182009-07-14 00:33:35 +02001087 err = rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
Johannes Berg55682962007-09-20 13:09:35 -04001088
1089 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001090 cfg80211_unlock_rdev(rdev);
Johannes Berg463d0182009-07-14 00:33:35 +02001091 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001092 unlock_rtnl:
1093 rtnl_unlock();
Johannes Berg55682962007-09-20 13:09:35 -04001094 return err;
1095}
1096
Johannes Berg41ade002007-12-19 02:03:29 +01001097struct get_key_cookie {
1098 struct sk_buff *msg;
1099 int error;
Johannes Bergb9454e82009-07-08 13:29:08 +02001100 int idx;
Johannes Berg41ade002007-12-19 02:03:29 +01001101};
1102
1103static void get_key_callback(void *c, struct key_params *params)
1104{
Johannes Bergb9454e82009-07-08 13:29:08 +02001105 struct nlattr *key;
Johannes Berg41ade002007-12-19 02:03:29 +01001106 struct get_key_cookie *cookie = c;
1107
1108 if (params->key)
1109 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
1110 params->key_len, params->key);
1111
1112 if (params->seq)
1113 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
1114 params->seq_len, params->seq);
1115
1116 if (params->cipher)
1117 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1118 params->cipher);
1119
Johannes Bergb9454e82009-07-08 13:29:08 +02001120 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1121 if (!key)
1122 goto nla_put_failure;
1123
1124 if (params->key)
1125 NLA_PUT(cookie->msg, NL80211_KEY_DATA,
1126 params->key_len, params->key);
1127
1128 if (params->seq)
1129 NLA_PUT(cookie->msg, NL80211_KEY_SEQ,
1130 params->seq_len, params->seq);
1131
1132 if (params->cipher)
1133 NLA_PUT_U32(cookie->msg, NL80211_KEY_CIPHER,
1134 params->cipher);
1135
1136 NLA_PUT_U8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx);
1137
1138 nla_nest_end(cookie->msg, key);
1139
Johannes Berg41ade002007-12-19 02:03:29 +01001140 return;
1141 nla_put_failure:
1142 cookie->error = 1;
1143}
1144
1145static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
1146{
Johannes Berg79c97e92009-07-07 03:56:12 +02001147 struct cfg80211_registered_device *rdev;
Johannes Berg41ade002007-12-19 02:03:29 +01001148 int err;
1149 struct net_device *dev;
1150 u8 key_idx = 0;
1151 u8 *mac_addr = NULL;
1152 struct get_key_cookie cookie = {
1153 .error = 0,
1154 };
1155 void *hdr;
1156 struct sk_buff *msg;
1157
1158 if (info->attrs[NL80211_ATTR_KEY_IDX])
1159 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1160
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001161 if (key_idx > 5)
Johannes Berg41ade002007-12-19 02:03:29 +01001162 return -EINVAL;
1163
1164 if (info->attrs[NL80211_ATTR_MAC])
1165 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1166
Johannes Berg3b858752009-03-12 09:55:09 +01001167 rtnl_lock();
1168
Johannes Berg463d0182009-07-14 00:33:35 +02001169 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg41ade002007-12-19 02:03:29 +01001170 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001171 goto unlock_rtnl;
Johannes Berg41ade002007-12-19 02:03:29 +01001172
Johannes Berg79c97e92009-07-07 03:56:12 +02001173 if (!rdev->ops->get_key) {
Johannes Berg41ade002007-12-19 02:03:29 +01001174 err = -EOPNOTSUPP;
1175 goto out;
1176 }
1177
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07001178 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg41ade002007-12-19 02:03:29 +01001179 if (!msg) {
1180 err = -ENOMEM;
1181 goto out;
1182 }
1183
1184 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1185 NL80211_CMD_NEW_KEY);
1186
1187 if (IS_ERR(hdr)) {
1188 err = PTR_ERR(hdr);
Niko Jokinen6c95e2a2009-07-15 11:00:53 +03001189 goto free_msg;
Johannes Berg41ade002007-12-19 02:03:29 +01001190 }
1191
1192 cookie.msg = msg;
Johannes Bergb9454e82009-07-08 13:29:08 +02001193 cookie.idx = key_idx;
Johannes Berg41ade002007-12-19 02:03:29 +01001194
1195 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1196 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1197 if (mac_addr)
1198 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1199
Johannes Berg79c97e92009-07-07 03:56:12 +02001200 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, mac_addr,
Johannes Berg41ade002007-12-19 02:03:29 +01001201 &cookie, get_key_callback);
Johannes Berg41ade002007-12-19 02:03:29 +01001202
1203 if (err)
Niko Jokinen6c95e2a2009-07-15 11:00:53 +03001204 goto free_msg;
Johannes Berg41ade002007-12-19 02:03:29 +01001205
1206 if (cookie.error)
1207 goto nla_put_failure;
1208
1209 genlmsg_end(msg, hdr);
Johannes Berg134e6372009-07-10 09:51:34 +00001210 err = genlmsg_reply(msg, info);
Johannes Berg41ade002007-12-19 02:03:29 +01001211 goto out;
1212
1213 nla_put_failure:
1214 err = -ENOBUFS;
Niko Jokinen6c95e2a2009-07-15 11:00:53 +03001215 free_msg:
Johannes Berg41ade002007-12-19 02:03:29 +01001216 nlmsg_free(msg);
1217 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001218 cfg80211_unlock_rdev(rdev);
Johannes Berg41ade002007-12-19 02:03:29 +01001219 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001220 unlock_rtnl:
1221 rtnl_unlock();
1222
Johannes Berg41ade002007-12-19 02:03:29 +01001223 return err;
1224}
1225
1226static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
1227{
Johannes Berg79c97e92009-07-07 03:56:12 +02001228 struct cfg80211_registered_device *rdev;
Johannes Bergb9454e82009-07-08 13:29:08 +02001229 struct key_parse key;
Johannes Berg41ade002007-12-19 02:03:29 +01001230 int err;
1231 struct net_device *dev;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001232 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
1233 u8 key_index);
Johannes Berg41ade002007-12-19 02:03:29 +01001234
Johannes Bergb9454e82009-07-08 13:29:08 +02001235 err = nl80211_parse_key(info, &key);
1236 if (err)
1237 return err;
1238
1239 if (key.idx < 0)
Johannes Berg41ade002007-12-19 02:03:29 +01001240 return -EINVAL;
1241
Johannes Bergb9454e82009-07-08 13:29:08 +02001242 /* only support setting default key */
1243 if (!key.def && !key.defmgmt)
Johannes Berg41ade002007-12-19 02:03:29 +01001244 return -EINVAL;
1245
Johannes Berg3b858752009-03-12 09:55:09 +01001246 rtnl_lock();
1247
Johannes Berg463d0182009-07-14 00:33:35 +02001248 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg41ade002007-12-19 02:03:29 +01001249 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001250 goto unlock_rtnl;
Johannes Berg41ade002007-12-19 02:03:29 +01001251
Johannes Bergb9454e82009-07-08 13:29:08 +02001252 if (key.def)
Johannes Berg79c97e92009-07-07 03:56:12 +02001253 func = rdev->ops->set_default_key;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001254 else
Johannes Berg79c97e92009-07-07 03:56:12 +02001255 func = rdev->ops->set_default_mgmt_key;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +02001256
1257 if (!func) {
Johannes Berg41ade002007-12-19 02:03:29 +01001258 err = -EOPNOTSUPP;
1259 goto out;
1260 }
1261
Johannes Bergfffd0932009-07-08 14:22:54 +02001262 wdev_lock(dev->ieee80211_ptr);
1263 err = nl80211_key_allowed(dev->ieee80211_ptr);
1264 if (!err)
1265 err = func(&rdev->wiphy, dev, key.idx);
1266
Johannes Berg08645122009-05-11 13:54:58 +02001267#ifdef CONFIG_WIRELESS_EXT
1268 if (!err) {
Johannes Berg79c97e92009-07-07 03:56:12 +02001269 if (func == rdev->ops->set_default_key)
Johannes Bergb9454e82009-07-08 13:29:08 +02001270 dev->ieee80211_ptr->wext.default_key = key.idx;
Johannes Berg08645122009-05-11 13:54:58 +02001271 else
Johannes Bergb9454e82009-07-08 13:29:08 +02001272 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
Johannes Berg08645122009-05-11 13:54:58 +02001273 }
1274#endif
Johannes Bergfffd0932009-07-08 14:22:54 +02001275 wdev_unlock(dev->ieee80211_ptr);
Johannes Berg41ade002007-12-19 02:03:29 +01001276
1277 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001278 cfg80211_unlock_rdev(rdev);
Johannes Berg41ade002007-12-19 02:03:29 +01001279 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001280
1281 unlock_rtnl:
1282 rtnl_unlock();
1283
Johannes Berg41ade002007-12-19 02:03:29 +01001284 return err;
1285}
1286
1287static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
1288{
Johannes Berg79c97e92009-07-07 03:56:12 +02001289 struct cfg80211_registered_device *rdev;
Johannes Bergfffd0932009-07-08 14:22:54 +02001290 int err;
Johannes Berg41ade002007-12-19 02:03:29 +01001291 struct net_device *dev;
Johannes Bergb9454e82009-07-08 13:29:08 +02001292 struct key_parse key;
Johannes Berg41ade002007-12-19 02:03:29 +01001293 u8 *mac_addr = NULL;
1294
Johannes Bergb9454e82009-07-08 13:29:08 +02001295 err = nl80211_parse_key(info, &key);
1296 if (err)
1297 return err;
Johannes Berg41ade002007-12-19 02:03:29 +01001298
Johannes Bergb9454e82009-07-08 13:29:08 +02001299 if (!key.p.key)
Johannes Berg41ade002007-12-19 02:03:29 +01001300 return -EINVAL;
1301
Johannes Berg41ade002007-12-19 02:03:29 +01001302 if (info->attrs[NL80211_ATTR_MAC])
1303 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1304
Johannes Berg3b858752009-03-12 09:55:09 +01001305 rtnl_lock();
1306
Johannes Berg463d0182009-07-14 00:33:35 +02001307 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg41ade002007-12-19 02:03:29 +01001308 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001309 goto unlock_rtnl;
Johannes Berg41ade002007-12-19 02:03:29 +01001310
Johannes Berg79c97e92009-07-07 03:56:12 +02001311 if (!rdev->ops->add_key) {
Johannes Berg41ade002007-12-19 02:03:29 +01001312 err = -EOPNOTSUPP;
1313 goto out;
1314 }
1315
Johannes Bergfffd0932009-07-08 14:22:54 +02001316 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx, mac_addr)) {
1317 err = -EINVAL;
1318 goto out;
1319 }
1320
1321 wdev_lock(dev->ieee80211_ptr);
1322 err = nl80211_key_allowed(dev->ieee80211_ptr);
1323 if (!err)
1324 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx,
1325 mac_addr, &key.p);
1326 wdev_unlock(dev->ieee80211_ptr);
Johannes Berg41ade002007-12-19 02:03:29 +01001327
1328 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001329 cfg80211_unlock_rdev(rdev);
Johannes Berg41ade002007-12-19 02:03:29 +01001330 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001331 unlock_rtnl:
1332 rtnl_unlock();
1333
Johannes Berg41ade002007-12-19 02:03:29 +01001334 return err;
1335}
1336
1337static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
1338{
Johannes Berg79c97e92009-07-07 03:56:12 +02001339 struct cfg80211_registered_device *rdev;
Johannes Berg41ade002007-12-19 02:03:29 +01001340 int err;
1341 struct net_device *dev;
Johannes Berg41ade002007-12-19 02:03:29 +01001342 u8 *mac_addr = NULL;
Johannes Bergb9454e82009-07-08 13:29:08 +02001343 struct key_parse key;
Johannes Berg41ade002007-12-19 02:03:29 +01001344
Johannes Bergb9454e82009-07-08 13:29:08 +02001345 err = nl80211_parse_key(info, &key);
1346 if (err)
1347 return err;
Johannes Berg41ade002007-12-19 02:03:29 +01001348
1349 if (info->attrs[NL80211_ATTR_MAC])
1350 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1351
Johannes Berg3b858752009-03-12 09:55:09 +01001352 rtnl_lock();
1353
Johannes Berg463d0182009-07-14 00:33:35 +02001354 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg41ade002007-12-19 02:03:29 +01001355 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001356 goto unlock_rtnl;
Johannes Berg41ade002007-12-19 02:03:29 +01001357
Johannes Berg79c97e92009-07-07 03:56:12 +02001358 if (!rdev->ops->del_key) {
Johannes Berg41ade002007-12-19 02:03:29 +01001359 err = -EOPNOTSUPP;
1360 goto out;
1361 }
1362
Johannes Bergfffd0932009-07-08 14:22:54 +02001363 wdev_lock(dev->ieee80211_ptr);
1364 err = nl80211_key_allowed(dev->ieee80211_ptr);
1365 if (!err)
1366 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx, mac_addr);
Johannes Berg41ade002007-12-19 02:03:29 +01001367
Johannes Berg08645122009-05-11 13:54:58 +02001368#ifdef CONFIG_WIRELESS_EXT
1369 if (!err) {
Johannes Bergb9454e82009-07-08 13:29:08 +02001370 if (key.idx == dev->ieee80211_ptr->wext.default_key)
Johannes Berg08645122009-05-11 13:54:58 +02001371 dev->ieee80211_ptr->wext.default_key = -1;
Johannes Bergb9454e82009-07-08 13:29:08 +02001372 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
Johannes Berg08645122009-05-11 13:54:58 +02001373 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
1374 }
1375#endif
Johannes Bergfffd0932009-07-08 14:22:54 +02001376 wdev_unlock(dev->ieee80211_ptr);
Johannes Berg08645122009-05-11 13:54:58 +02001377
Johannes Berg41ade002007-12-19 02:03:29 +01001378 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001379 cfg80211_unlock_rdev(rdev);
Johannes Berg41ade002007-12-19 02:03:29 +01001380 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001381
1382 unlock_rtnl:
1383 rtnl_unlock();
1384
Johannes Berg41ade002007-12-19 02:03:29 +01001385 return err;
1386}
1387
Johannes Berged1b6cc2007-12-19 02:03:32 +01001388static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
1389{
1390 int (*call)(struct wiphy *wiphy, struct net_device *dev,
1391 struct beacon_parameters *info);
Johannes Berg79c97e92009-07-07 03:56:12 +02001392 struct cfg80211_registered_device *rdev;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001393 int err;
1394 struct net_device *dev;
1395 struct beacon_parameters params;
1396 int haveinfo = 0;
1397
Johannes Bergf4a11bb2009-03-27 12:40:28 +01001398 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1399 return -EINVAL;
1400
Johannes Berg3b858752009-03-12 09:55:09 +01001401 rtnl_lock();
1402
Johannes Berg463d0182009-07-14 00:33:35 +02001403 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001404 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001405 goto unlock_rtnl;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001406
Jouni Malineneec60b02009-03-20 21:21:19 +02001407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1408 err = -EOPNOTSUPP;
1409 goto out;
1410 }
1411
Johannes Berged1b6cc2007-12-19 02:03:32 +01001412 switch (info->genlhdr->cmd) {
1413 case NL80211_CMD_NEW_BEACON:
1414 /* these are required for NEW_BEACON */
1415 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
1416 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
1417 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1418 err = -EINVAL;
1419 goto out;
1420 }
1421
Johannes Berg79c97e92009-07-07 03:56:12 +02001422 call = rdev->ops->add_beacon;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001423 break;
1424 case NL80211_CMD_SET_BEACON:
Johannes Berg79c97e92009-07-07 03:56:12 +02001425 call = rdev->ops->set_beacon;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001426 break;
1427 default:
1428 WARN_ON(1);
1429 err = -EOPNOTSUPP;
1430 goto out;
1431 }
1432
1433 if (!call) {
1434 err = -EOPNOTSUPP;
1435 goto out;
1436 }
1437
1438 memset(&params, 0, sizeof(params));
1439
1440 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1441 params.interval =
1442 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1443 haveinfo = 1;
1444 }
1445
1446 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1447 params.dtim_period =
1448 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1449 haveinfo = 1;
1450 }
1451
1452 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1453 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1454 params.head_len =
1455 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1456 haveinfo = 1;
1457 }
1458
1459 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1460 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1461 params.tail_len =
1462 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1463 haveinfo = 1;
1464 }
1465
1466 if (!haveinfo) {
1467 err = -EINVAL;
1468 goto out;
1469 }
1470
Johannes Berg79c97e92009-07-07 03:56:12 +02001471 err = call(&rdev->wiphy, dev, &params);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001472
1473 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001474 cfg80211_unlock_rdev(rdev);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001475 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001476 unlock_rtnl:
1477 rtnl_unlock();
1478
Johannes Berged1b6cc2007-12-19 02:03:32 +01001479 return err;
1480}
1481
1482static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1483{
Johannes Berg79c97e92009-07-07 03:56:12 +02001484 struct cfg80211_registered_device *rdev;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001485 int err;
1486 struct net_device *dev;
1487
Johannes Berg3b858752009-03-12 09:55:09 +01001488 rtnl_lock();
1489
Johannes Berg463d0182009-07-14 00:33:35 +02001490 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001491 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001492 goto unlock_rtnl;
Johannes Berged1b6cc2007-12-19 02:03:32 +01001493
Johannes Berg79c97e92009-07-07 03:56:12 +02001494 if (!rdev->ops->del_beacon) {
Johannes Berged1b6cc2007-12-19 02:03:32 +01001495 err = -EOPNOTSUPP;
1496 goto out;
1497 }
1498
Jouni Malineneec60b02009-03-20 21:21:19 +02001499 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1500 err = -EOPNOTSUPP;
1501 goto out;
1502 }
Johannes Berg79c97e92009-07-07 03:56:12 +02001503 err = rdev->ops->del_beacon(&rdev->wiphy, dev);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001504
1505 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001506 cfg80211_unlock_rdev(rdev);
Johannes Berged1b6cc2007-12-19 02:03:32 +01001507 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001508 unlock_rtnl:
1509 rtnl_unlock();
1510
Johannes Berged1b6cc2007-12-19 02:03:32 +01001511 return err;
1512}
1513
Johannes Berg5727ef12007-12-19 02:03:34 +01001514static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1515 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1516 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1517 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
Jouni Malinen0e467242009-05-11 21:57:55 +03001518 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
Johannes Berg5727ef12007-12-19 02:03:34 +01001519};
1520
Johannes Bergeccb8e82009-05-11 21:57:56 +03001521static int parse_station_flags(struct genl_info *info,
1522 struct station_parameters *params)
Johannes Berg5727ef12007-12-19 02:03:34 +01001523{
1524 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
Johannes Bergeccb8e82009-05-11 21:57:56 +03001525 struct nlattr *nla;
Johannes Berg5727ef12007-12-19 02:03:34 +01001526 int flag;
1527
Johannes Bergeccb8e82009-05-11 21:57:56 +03001528 /*
1529 * Try parsing the new attribute first so userspace
1530 * can specify both for older kernels.
1531 */
1532 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
1533 if (nla) {
1534 struct nl80211_sta_flag_update *sta_flags;
Johannes Berg5727ef12007-12-19 02:03:34 +01001535
Johannes Bergeccb8e82009-05-11 21:57:56 +03001536 sta_flags = nla_data(nla);
1537 params->sta_flags_mask = sta_flags->mask;
1538 params->sta_flags_set = sta_flags->set;
1539 if ((params->sta_flags_mask |
1540 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
1541 return -EINVAL;
1542 return 0;
1543 }
1544
1545 /* if present, parse the old attribute */
1546
1547 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
Johannes Berg5727ef12007-12-19 02:03:34 +01001548 if (!nla)
1549 return 0;
1550
1551 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1552 nla, sta_flags_policy))
1553 return -EINVAL;
1554
Johannes Bergeccb8e82009-05-11 21:57:56 +03001555 params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1;
1556 params->sta_flags_mask &= ~1;
Johannes Berg5727ef12007-12-19 02:03:34 +01001557
1558 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1559 if (flags[flag])
Johannes Bergeccb8e82009-05-11 21:57:56 +03001560 params->sta_flags_set |= (1<<flag);
Johannes Berg5727ef12007-12-19 02:03:34 +01001561
1562 return 0;
1563}
1564
Henning Rogge420e7fa2008-12-11 22:04:19 +01001565static u16 nl80211_calculate_bitrate(struct rate_info *rate)
1566{
1567 int modulation, streams, bitrate;
1568
1569 if (!(rate->flags & RATE_INFO_FLAGS_MCS))
1570 return rate->legacy;
1571
1572 /* the formula below does only work for MCS values smaller than 32 */
1573 if (rate->mcs >= 32)
1574 return 0;
1575
1576 modulation = rate->mcs & 7;
1577 streams = (rate->mcs >> 3) + 1;
1578
1579 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ?
1580 13500000 : 6500000;
1581
1582 if (modulation < 4)
1583 bitrate *= (modulation + 1);
1584 else if (modulation == 4)
1585 bitrate *= (modulation + 2);
1586 else
1587 bitrate *= (modulation + 3);
1588
1589 bitrate *= streams;
1590
1591 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI)
1592 bitrate = (bitrate / 9) * 10;
1593
1594 /* do NOT round down here */
1595 return (bitrate + 50000) / 100000;
1596}
1597
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001598static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1599 int flags, struct net_device *dev,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001600 u8 *mac_addr, struct station_info *sinfo)
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001601{
1602 void *hdr;
Henning Rogge420e7fa2008-12-11 22:04:19 +01001603 struct nlattr *sinfoattr, *txrate;
1604 u16 bitrate;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001605
1606 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1607 if (!hdr)
1608 return -1;
1609
1610 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1611 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1612
Johannes Bergf5ea9122009-08-07 16:17:38 +02001613 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, sinfo->generation);
1614
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001615 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1616 if (!sinfoattr)
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001617 goto nla_put_failure;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001618 if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1619 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1620 sinfo->inactive_time);
1621 if (sinfo->filled & STATION_INFO_RX_BYTES)
1622 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1623 sinfo->rx_bytes);
1624 if (sinfo->filled & STATION_INFO_TX_BYTES)
1625 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1626 sinfo->tx_bytes);
1627 if (sinfo->filled & STATION_INFO_LLID)
1628 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1629 sinfo->llid);
1630 if (sinfo->filled & STATION_INFO_PLID)
1631 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1632 sinfo->plid);
1633 if (sinfo->filled & STATION_INFO_PLINK_STATE)
1634 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1635 sinfo->plink_state);
Henning Rogge420e7fa2008-12-11 22:04:19 +01001636 if (sinfo->filled & STATION_INFO_SIGNAL)
1637 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
1638 sinfo->signal);
1639 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
1640 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
1641 if (!txrate)
1642 goto nla_put_failure;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001643
Henning Rogge420e7fa2008-12-11 22:04:19 +01001644 /* nl80211_calculate_bitrate will return 0 for mcs >= 32 */
1645 bitrate = nl80211_calculate_bitrate(&sinfo->txrate);
1646 if (bitrate > 0)
1647 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
1648
1649 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
1650 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
1651 sinfo->txrate.mcs);
1652 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
1653 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
1654 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
1655 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
1656
1657 nla_nest_end(msg, txrate);
1658 }
Jouni Malinen98c8a60a2009-02-17 13:24:57 +02001659 if (sinfo->filled & STATION_INFO_RX_PACKETS)
1660 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
1661 sinfo->rx_packets);
1662 if (sinfo->filled & STATION_INFO_TX_PACKETS)
1663 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS,
1664 sinfo->tx_packets);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001665 nla_nest_end(msg, sinfoattr);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001666
1667 return genlmsg_end(msg, hdr);
1668
1669 nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -07001670 genlmsg_cancel(msg, hdr);
1671 return -EMSGSIZE;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001672}
1673
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001674static int nl80211_dump_station(struct sk_buff *skb,
Johannes Bergbba95fe2008-07-29 13:22:51 +02001675 struct netlink_callback *cb)
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001676{
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001677 struct station_info sinfo;
1678 struct cfg80211_registered_device *dev;
Johannes Bergbba95fe2008-07-29 13:22:51 +02001679 struct net_device *netdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001680 u8 mac_addr[ETH_ALEN];
Johannes Bergbba95fe2008-07-29 13:22:51 +02001681 int ifidx = cb->args[0];
1682 int sta_idx = cb->args[1];
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001683 int err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001684
Johannes Bergbba95fe2008-07-29 13:22:51 +02001685 if (!ifidx) {
1686 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1687 nl80211_fam.attrbuf, nl80211_fam.maxattr,
1688 nl80211_policy);
1689 if (err)
1690 return err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001691
Johannes Bergbba95fe2008-07-29 13:22:51 +02001692 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1693 return -EINVAL;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001694
Johannes Bergbba95fe2008-07-29 13:22:51 +02001695 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1696 if (!ifidx)
1697 return -EINVAL;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001698 }
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001699
Johannes Berg3b858752009-03-12 09:55:09 +01001700 rtnl_lock();
1701
Johannes Berg463d0182009-07-14 00:33:35 +02001702 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
Johannes Berg3b858752009-03-12 09:55:09 +01001703 if (!netdev) {
1704 err = -ENODEV;
1705 goto out_rtnl;
1706 }
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001707
Johannes Berg463d0182009-07-14 00:33:35 +02001708 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
Johannes Bergbba95fe2008-07-29 13:22:51 +02001709 if (IS_ERR(dev)) {
1710 err = PTR_ERR(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001711 goto out_rtnl;
Johannes Bergbba95fe2008-07-29 13:22:51 +02001712 }
1713
1714 if (!dev->ops->dump_station) {
Jouni Malineneec60b02009-03-20 21:21:19 +02001715 err = -EOPNOTSUPP;
Johannes Bergbba95fe2008-07-29 13:22:51 +02001716 goto out_err;
1717 }
1718
Johannes Bergbba95fe2008-07-29 13:22:51 +02001719 while (1) {
1720 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1721 mac_addr, &sinfo);
1722 if (err == -ENOENT)
1723 break;
1724 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001725 goto out_err;
Johannes Bergbba95fe2008-07-29 13:22:51 +02001726
1727 if (nl80211_send_station(skb,
1728 NETLINK_CB(cb->skb).pid,
1729 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1730 netdev, mac_addr,
1731 &sinfo) < 0)
1732 goto out;
1733
1734 sta_idx++;
1735 }
1736
1737
1738 out:
1739 cb->args[1] = sta_idx;
1740 err = skb->len;
Johannes Bergbba95fe2008-07-29 13:22:51 +02001741 out_err:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02001742 cfg80211_unlock_rdev(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001743 out_rtnl:
1744 rtnl_unlock();
Johannes Bergbba95fe2008-07-29 13:22:51 +02001745
1746 return err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001747}
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001748
Johannes Berg5727ef12007-12-19 02:03:34 +01001749static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1750{
Johannes Berg79c97e92009-07-07 03:56:12 +02001751 struct cfg80211_registered_device *rdev;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001752 int err;
1753 struct net_device *dev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001754 struct station_info sinfo;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001755 struct sk_buff *msg;
1756 u8 *mac_addr = NULL;
1757
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001758 memset(&sinfo, 0, sizeof(sinfo));
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001759
1760 if (!info->attrs[NL80211_ATTR_MAC])
1761 return -EINVAL;
1762
1763 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1764
Johannes Berg3b858752009-03-12 09:55:09 +01001765 rtnl_lock();
1766
Johannes Berg463d0182009-07-14 00:33:35 +02001767 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001768 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001769 goto out_rtnl;
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001770
Johannes Berg79c97e92009-07-07 03:56:12 +02001771 if (!rdev->ops->get_station) {
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001772 err = -EOPNOTSUPP;
1773 goto out;
1774 }
1775
Johannes Berg79c97e92009-07-07 03:56:12 +02001776 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001777 if (err)
1778 goto out;
1779
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07001780 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001781 if (!msg)
1782 goto out;
1783
1784 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001785 dev, mac_addr, &sinfo) < 0)
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001786 goto out_free;
1787
Johannes Berg134e6372009-07-10 09:51:34 +00001788 err = genlmsg_reply(msg, info);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001789 goto out;
1790
1791 out_free:
1792 nlmsg_free(msg);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001793 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02001794 cfg80211_unlock_rdev(rdev);
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001795 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001796 out_rtnl:
1797 rtnl_unlock();
1798
Johannes Bergfd5b74d2007-12-19 02:03:36 +01001799 return err;
Johannes Berg5727ef12007-12-19 02:03:34 +01001800}
1801
1802/*
1803 * Get vlan interface making sure it is on the right wiphy.
1804 */
Johannes Berg463d0182009-07-14 00:33:35 +02001805static int get_vlan(struct genl_info *info,
Johannes Berg5727ef12007-12-19 02:03:34 +01001806 struct cfg80211_registered_device *rdev,
1807 struct net_device **vlan)
1808{
Johannes Berg463d0182009-07-14 00:33:35 +02001809 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
Johannes Berg5727ef12007-12-19 02:03:34 +01001810 *vlan = NULL;
1811
1812 if (vlanattr) {
Johannes Berg463d0182009-07-14 00:33:35 +02001813 *vlan = dev_get_by_index(genl_info_net(info),
1814 nla_get_u32(vlanattr));
Johannes Berg5727ef12007-12-19 02:03:34 +01001815 if (!*vlan)
1816 return -ENODEV;
1817 if (!(*vlan)->ieee80211_ptr)
1818 return -EINVAL;
1819 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1820 return -EINVAL;
1821 }
1822 return 0;
1823}
1824
1825static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1826{
Johannes Berg79c97e92009-07-07 03:56:12 +02001827 struct cfg80211_registered_device *rdev;
Johannes Berg5727ef12007-12-19 02:03:34 +01001828 int err;
1829 struct net_device *dev;
1830 struct station_parameters params;
1831 u8 *mac_addr = NULL;
1832
1833 memset(&params, 0, sizeof(params));
1834
1835 params.listen_interval = -1;
1836
1837 if (info->attrs[NL80211_ATTR_STA_AID])
1838 return -EINVAL;
1839
1840 if (!info->attrs[NL80211_ATTR_MAC])
1841 return -EINVAL;
1842
1843 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1844
1845 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
1846 params.supported_rates =
1847 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1848 params.supported_rates_len =
1849 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1850 }
1851
1852 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1853 params.listen_interval =
1854 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1855
Jouni Malinen36aedc902008-08-25 11:58:58 +03001856 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1857 params.ht_capa =
1858 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1859
Johannes Bergeccb8e82009-05-11 21:57:56 +03001860 if (parse_station_flags(info, &params))
Johannes Berg5727ef12007-12-19 02:03:34 +01001861 return -EINVAL;
1862
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01001863 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
1864 params.plink_action =
1865 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
1866
Johannes Berg3b858752009-03-12 09:55:09 +01001867 rtnl_lock();
1868
Johannes Berg463d0182009-07-14 00:33:35 +02001869 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg5727ef12007-12-19 02:03:34 +01001870 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001871 goto out_rtnl;
Johannes Berg5727ef12007-12-19 02:03:34 +01001872
Johannes Berg463d0182009-07-14 00:33:35 +02001873 err = get_vlan(info, rdev, &params.vlan);
Johannes Berga97f4422009-06-18 17:23:43 +02001874 if (err)
Johannes Berg034d6552009-05-27 10:35:29 +02001875 goto out;
Johannes Berga97f4422009-06-18 17:23:43 +02001876
1877 /* validate settings */
1878 err = 0;
1879
1880 switch (dev->ieee80211_ptr->iftype) {
1881 case NL80211_IFTYPE_AP:
1882 case NL80211_IFTYPE_AP_VLAN:
1883 /* disallow mesh-specific things */
1884 if (params.plink_action)
1885 err = -EINVAL;
1886 break;
1887 case NL80211_IFTYPE_STATION:
1888 /* disallow everything but AUTHORIZED flag */
1889 if (params.plink_action)
1890 err = -EINVAL;
1891 if (params.vlan)
1892 err = -EINVAL;
1893 if (params.supported_rates)
1894 err = -EINVAL;
1895 if (params.ht_capa)
1896 err = -EINVAL;
1897 if (params.listen_interval >= 0)
1898 err = -EINVAL;
1899 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
1900 err = -EINVAL;
1901 break;
1902 case NL80211_IFTYPE_MESH_POINT:
1903 /* disallow things mesh doesn't support */
1904 if (params.vlan)
1905 err = -EINVAL;
1906 if (params.ht_capa)
1907 err = -EINVAL;
1908 if (params.listen_interval >= 0)
1909 err = -EINVAL;
1910 if (params.supported_rates)
1911 err = -EINVAL;
1912 if (params.sta_flags_mask)
1913 err = -EINVAL;
1914 break;
1915 default:
1916 err = -EINVAL;
Johannes Berg034d6552009-05-27 10:35:29 +02001917 }
1918
Johannes Berg5727ef12007-12-19 02:03:34 +01001919 if (err)
1920 goto out;
1921
Johannes Berg79c97e92009-07-07 03:56:12 +02001922 if (!rdev->ops->change_station) {
Johannes Berg5727ef12007-12-19 02:03:34 +01001923 err = -EOPNOTSUPP;
1924 goto out;
1925 }
1926
Johannes Berg79c97e92009-07-07 03:56:12 +02001927 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, &params);
Johannes Berg5727ef12007-12-19 02:03:34 +01001928
1929 out:
1930 if (params.vlan)
1931 dev_put(params.vlan);
Johannes Berg79c97e92009-07-07 03:56:12 +02001932 cfg80211_unlock_rdev(rdev);
Johannes Berg5727ef12007-12-19 02:03:34 +01001933 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01001934 out_rtnl:
1935 rtnl_unlock();
1936
Johannes Berg5727ef12007-12-19 02:03:34 +01001937 return err;
1938}
1939
1940static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
1941{
Johannes Berg79c97e92009-07-07 03:56:12 +02001942 struct cfg80211_registered_device *rdev;
Johannes Berg5727ef12007-12-19 02:03:34 +01001943 int err;
1944 struct net_device *dev;
1945 struct station_parameters params;
1946 u8 *mac_addr = NULL;
1947
1948 memset(&params, 0, sizeof(params));
1949
1950 if (!info->attrs[NL80211_ATTR_MAC])
1951 return -EINVAL;
1952
Johannes Berg5727ef12007-12-19 02:03:34 +01001953 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1954 return -EINVAL;
1955
1956 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
1957 return -EINVAL;
1958
1959 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1960 params.supported_rates =
1961 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1962 params.supported_rates_len =
1963 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1964 params.listen_interval =
1965 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
Johannes Berg51b50fb2009-05-24 16:42:30 +02001966
Johannes Berga97f4422009-06-18 17:23:43 +02001967 if (info->attrs[NL80211_ATTR_STA_AID]) {
1968 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
1969 if (!params.aid || params.aid > IEEE80211_MAX_AID)
1970 return -EINVAL;
1971 }
Johannes Berg51b50fb2009-05-24 16:42:30 +02001972
Jouni Malinen36aedc902008-08-25 11:58:58 +03001973 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1974 params.ht_capa =
1975 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
Johannes Berg5727ef12007-12-19 02:03:34 +01001976
Johannes Bergeccb8e82009-05-11 21:57:56 +03001977 if (parse_station_flags(info, &params))
Johannes Berg5727ef12007-12-19 02:03:34 +01001978 return -EINVAL;
1979
Johannes Berg3b858752009-03-12 09:55:09 +01001980 rtnl_lock();
1981
Johannes Berg463d0182009-07-14 00:33:35 +02001982 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg5727ef12007-12-19 02:03:34 +01001983 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01001984 goto out_rtnl;
Johannes Berg5727ef12007-12-19 02:03:34 +01001985
Johannes Berg463d0182009-07-14 00:33:35 +02001986 err = get_vlan(info, rdev, &params.vlan);
Johannes Berga97f4422009-06-18 17:23:43 +02001987 if (err)
Johannes Berge80cf852009-05-11 14:43:13 +02001988 goto out;
Johannes Berga97f4422009-06-18 17:23:43 +02001989
1990 /* validate settings */
1991 err = 0;
1992
1993 switch (dev->ieee80211_ptr->iftype) {
1994 case NL80211_IFTYPE_AP:
1995 case NL80211_IFTYPE_AP_VLAN:
1996 /* all ok but must have AID */
1997 if (!params.aid)
1998 err = -EINVAL;
1999 break;
2000 case NL80211_IFTYPE_MESH_POINT:
2001 /* disallow things mesh doesn't support */
2002 if (params.vlan)
2003 err = -EINVAL;
2004 if (params.aid)
2005 err = -EINVAL;
2006 if (params.ht_capa)
2007 err = -EINVAL;
2008 if (params.listen_interval >= 0)
2009 err = -EINVAL;
2010 if (params.supported_rates)
2011 err = -EINVAL;
2012 if (params.sta_flags_mask)
2013 err = -EINVAL;
2014 break;
2015 default:
2016 err = -EINVAL;
Johannes Berge80cf852009-05-11 14:43:13 +02002017 }
2018
Johannes Berg5727ef12007-12-19 02:03:34 +01002019 if (err)
2020 goto out;
2021
Johannes Berg79c97e92009-07-07 03:56:12 +02002022 if (!rdev->ops->add_station) {
Johannes Berg5727ef12007-12-19 02:03:34 +01002023 err = -EOPNOTSUPP;
2024 goto out;
2025 }
2026
Jouni Malinen35a8efe2009-03-20 21:21:18 +02002027 if (!netif_running(dev)) {
2028 err = -ENETDOWN;
2029 goto out;
2030 }
2031
Johannes Berg79c97e92009-07-07 03:56:12 +02002032 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, &params);
Johannes Berg5727ef12007-12-19 02:03:34 +01002033
2034 out:
2035 if (params.vlan)
2036 dev_put(params.vlan);
Johannes Berg79c97e92009-07-07 03:56:12 +02002037 cfg80211_unlock_rdev(rdev);
Johannes Berg5727ef12007-12-19 02:03:34 +01002038 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002039 out_rtnl:
2040 rtnl_unlock();
2041
Johannes Berg5727ef12007-12-19 02:03:34 +01002042 return err;
2043}
2044
2045static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
2046{
Johannes Berg79c97e92009-07-07 03:56:12 +02002047 struct cfg80211_registered_device *rdev;
Johannes Berg5727ef12007-12-19 02:03:34 +01002048 int err;
2049 struct net_device *dev;
2050 u8 *mac_addr = NULL;
2051
2052 if (info->attrs[NL80211_ATTR_MAC])
2053 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2054
Johannes Berg3b858752009-03-12 09:55:09 +01002055 rtnl_lock();
2056
Johannes Berg463d0182009-07-14 00:33:35 +02002057 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg5727ef12007-12-19 02:03:34 +01002058 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002059 goto out_rtnl;
Johannes Berg5727ef12007-12-19 02:03:34 +01002060
Johannes Berge80cf852009-05-11 14:43:13 +02002061 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
Andrey Yurovsky155cc9e2009-06-16 11:31:04 -07002062 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
2063 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
Johannes Berge80cf852009-05-11 14:43:13 +02002064 err = -EINVAL;
2065 goto out;
2066 }
2067
Johannes Berg79c97e92009-07-07 03:56:12 +02002068 if (!rdev->ops->del_station) {
Johannes Berg5727ef12007-12-19 02:03:34 +01002069 err = -EOPNOTSUPP;
2070 goto out;
2071 }
2072
Johannes Berg79c97e92009-07-07 03:56:12 +02002073 err = rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
Johannes Berg5727ef12007-12-19 02:03:34 +01002074
2075 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002076 cfg80211_unlock_rdev(rdev);
Johannes Berg5727ef12007-12-19 02:03:34 +01002077 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002078 out_rtnl:
2079 rtnl_unlock();
2080
Johannes Berg5727ef12007-12-19 02:03:34 +01002081 return err;
2082}
2083
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002084static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
2085 int flags, struct net_device *dev,
2086 u8 *dst, u8 *next_hop,
2087 struct mpath_info *pinfo)
2088{
2089 void *hdr;
2090 struct nlattr *pinfoattr;
2091
2092 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2093 if (!hdr)
2094 return -1;
2095
2096 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2097 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
2098 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
2099
Johannes Bergf5ea9122009-08-07 16:17:38 +02002100 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, pinfo->generation);
2101
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002102 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
2103 if (!pinfoattr)
2104 goto nla_put_failure;
2105 if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
2106 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
2107 pinfo->frame_qlen);
2108 if (pinfo->filled & MPATH_INFO_DSN)
2109 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
2110 pinfo->dsn);
2111 if (pinfo->filled & MPATH_INFO_METRIC)
2112 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
2113 pinfo->metric);
2114 if (pinfo->filled & MPATH_INFO_EXPTIME)
2115 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
2116 pinfo->exptime);
2117 if (pinfo->filled & MPATH_INFO_FLAGS)
2118 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
2119 pinfo->flags);
2120 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
2121 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
2122 pinfo->discovery_timeout);
2123 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
2124 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
2125 pinfo->discovery_retries);
2126
2127 nla_nest_end(msg, pinfoattr);
2128
2129 return genlmsg_end(msg, hdr);
2130
2131 nla_put_failure:
Thomas Grafbc3ed282008-06-03 16:36:54 -07002132 genlmsg_cancel(msg, hdr);
2133 return -EMSGSIZE;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002134}
2135
2136static int nl80211_dump_mpath(struct sk_buff *skb,
Johannes Bergbba95fe2008-07-29 13:22:51 +02002137 struct netlink_callback *cb)
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002138{
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002139 struct mpath_info pinfo;
2140 struct cfg80211_registered_device *dev;
Johannes Bergbba95fe2008-07-29 13:22:51 +02002141 struct net_device *netdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002142 u8 dst[ETH_ALEN];
2143 u8 next_hop[ETH_ALEN];
Johannes Bergbba95fe2008-07-29 13:22:51 +02002144 int ifidx = cb->args[0];
2145 int path_idx = cb->args[1];
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002146 int err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002147
Johannes Bergbba95fe2008-07-29 13:22:51 +02002148 if (!ifidx) {
2149 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
2150 nl80211_fam.attrbuf, nl80211_fam.maxattr,
2151 nl80211_policy);
2152 if (err)
2153 return err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002154
Johannes Bergbba95fe2008-07-29 13:22:51 +02002155 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
2156 return -EINVAL;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002157
Johannes Bergbba95fe2008-07-29 13:22:51 +02002158 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
2159 if (!ifidx)
2160 return -EINVAL;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002161 }
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002162
Johannes Berg3b858752009-03-12 09:55:09 +01002163 rtnl_lock();
2164
Johannes Berg463d0182009-07-14 00:33:35 +02002165 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
Johannes Berg3b858752009-03-12 09:55:09 +01002166 if (!netdev) {
2167 err = -ENODEV;
2168 goto out_rtnl;
2169 }
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002170
Johannes Berg463d0182009-07-14 00:33:35 +02002171 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
Johannes Bergbba95fe2008-07-29 13:22:51 +02002172 if (IS_ERR(dev)) {
2173 err = PTR_ERR(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002174 goto out_rtnl;
Johannes Bergbba95fe2008-07-29 13:22:51 +02002175 }
2176
2177 if (!dev->ops->dump_mpath) {
Jouni Malineneec60b02009-03-20 21:21:19 +02002178 err = -EOPNOTSUPP;
Johannes Bergbba95fe2008-07-29 13:22:51 +02002179 goto out_err;
2180 }
2181
Jouni Malineneec60b02009-03-20 21:21:19 +02002182 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2183 err = -EOPNOTSUPP;
Roel Kluin0448b5f2009-08-22 21:15:49 +02002184 goto out_err;
Jouni Malineneec60b02009-03-20 21:21:19 +02002185 }
2186
Johannes Bergbba95fe2008-07-29 13:22:51 +02002187 while (1) {
2188 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
2189 dst, next_hop, &pinfo);
2190 if (err == -ENOENT)
2191 break;
2192 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002193 goto out_err;
Johannes Bergbba95fe2008-07-29 13:22:51 +02002194
2195 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
2196 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2197 netdev, dst, next_hop,
2198 &pinfo) < 0)
2199 goto out;
2200
2201 path_idx++;
2202 }
2203
2204
2205 out:
2206 cb->args[1] = path_idx;
2207 err = skb->len;
Johannes Bergbba95fe2008-07-29 13:22:51 +02002208 out_err:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02002209 cfg80211_unlock_rdev(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002210 out_rtnl:
2211 rtnl_unlock();
Johannes Bergbba95fe2008-07-29 13:22:51 +02002212
2213 return err;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002214}
2215
2216static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
2217{
Johannes Berg79c97e92009-07-07 03:56:12 +02002218 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002219 int err;
2220 struct net_device *dev;
2221 struct mpath_info pinfo;
2222 struct sk_buff *msg;
2223 u8 *dst = NULL;
2224 u8 next_hop[ETH_ALEN];
2225
2226 memset(&pinfo, 0, sizeof(pinfo));
2227
2228 if (!info->attrs[NL80211_ATTR_MAC])
2229 return -EINVAL;
2230
2231 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2232
Johannes Berg3b858752009-03-12 09:55:09 +01002233 rtnl_lock();
2234
Johannes Berg463d0182009-07-14 00:33:35 +02002235 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002236 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002237 goto out_rtnl;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002238
Johannes Berg79c97e92009-07-07 03:56:12 +02002239 if (!rdev->ops->get_mpath) {
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002240 err = -EOPNOTSUPP;
2241 goto out;
2242 }
2243
Jouni Malineneec60b02009-03-20 21:21:19 +02002244 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2245 err = -EOPNOTSUPP;
2246 goto out;
2247 }
2248
Johannes Berg79c97e92009-07-07 03:56:12 +02002249 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002250 if (err)
2251 goto out;
2252
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07002253 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002254 if (!msg)
2255 goto out;
2256
2257 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
2258 dev, dst, next_hop, &pinfo) < 0)
2259 goto out_free;
2260
Johannes Berg134e6372009-07-10 09:51:34 +00002261 err = genlmsg_reply(msg, info);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002262 goto out;
2263
2264 out_free:
2265 nlmsg_free(msg);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002266 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002267 cfg80211_unlock_rdev(rdev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002268 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002269 out_rtnl:
2270 rtnl_unlock();
2271
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002272 return err;
2273}
2274
2275static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
2276{
Johannes Berg79c97e92009-07-07 03:56:12 +02002277 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002278 int err;
2279 struct net_device *dev;
2280 u8 *dst = NULL;
2281 u8 *next_hop = NULL;
2282
2283 if (!info->attrs[NL80211_ATTR_MAC])
2284 return -EINVAL;
2285
2286 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2287 return -EINVAL;
2288
2289 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2290 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2291
Johannes Berg3b858752009-03-12 09:55:09 +01002292 rtnl_lock();
2293
Johannes Berg463d0182009-07-14 00:33:35 +02002294 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002295 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002296 goto out_rtnl;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002297
Johannes Berg79c97e92009-07-07 03:56:12 +02002298 if (!rdev->ops->change_mpath) {
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002299 err = -EOPNOTSUPP;
2300 goto out;
2301 }
2302
Jouni Malineneec60b02009-03-20 21:21:19 +02002303 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2304 err = -EOPNOTSUPP;
2305 goto out;
2306 }
2307
Jouni Malinen35a8efe2009-03-20 21:21:18 +02002308 if (!netif_running(dev)) {
2309 err = -ENETDOWN;
2310 goto out;
2311 }
2312
Johannes Berg79c97e92009-07-07 03:56:12 +02002313 err = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002314
2315 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002316 cfg80211_unlock_rdev(rdev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002317 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002318 out_rtnl:
2319 rtnl_unlock();
2320
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002321 return err;
2322}
2323static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
2324{
Johannes Berg79c97e92009-07-07 03:56:12 +02002325 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002326 int err;
2327 struct net_device *dev;
2328 u8 *dst = NULL;
2329 u8 *next_hop = NULL;
2330
2331 if (!info->attrs[NL80211_ATTR_MAC])
2332 return -EINVAL;
2333
2334 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2335 return -EINVAL;
2336
2337 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2338 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2339
Johannes Berg3b858752009-03-12 09:55:09 +01002340 rtnl_lock();
2341
Johannes Berg463d0182009-07-14 00:33:35 +02002342 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002343 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002344 goto out_rtnl;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002345
Johannes Berg79c97e92009-07-07 03:56:12 +02002346 if (!rdev->ops->add_mpath) {
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002347 err = -EOPNOTSUPP;
2348 goto out;
2349 }
2350
Jouni Malineneec60b02009-03-20 21:21:19 +02002351 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2352 err = -EOPNOTSUPP;
2353 goto out;
2354 }
2355
Jouni Malinen35a8efe2009-03-20 21:21:18 +02002356 if (!netif_running(dev)) {
2357 err = -ENETDOWN;
2358 goto out;
2359 }
2360
Johannes Berg79c97e92009-07-07 03:56:12 +02002361 err = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002362
2363 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002364 cfg80211_unlock_rdev(rdev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002365 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002366 out_rtnl:
2367 rtnl_unlock();
2368
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002369 return err;
2370}
2371
2372static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
2373{
Johannes Berg79c97e92009-07-07 03:56:12 +02002374 struct cfg80211_registered_device *rdev;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002375 int err;
2376 struct net_device *dev;
2377 u8 *dst = NULL;
2378
2379 if (info->attrs[NL80211_ATTR_MAC])
2380 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2381
Johannes Berg3b858752009-03-12 09:55:09 +01002382 rtnl_lock();
2383
Johannes Berg463d0182009-07-14 00:33:35 +02002384 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002385 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002386 goto out_rtnl;
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002387
Johannes Berg79c97e92009-07-07 03:56:12 +02002388 if (!rdev->ops->del_mpath) {
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002389 err = -EOPNOTSUPP;
2390 goto out;
2391 }
2392
Johannes Berg79c97e92009-07-07 03:56:12 +02002393 err = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002394
2395 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002396 cfg80211_unlock_rdev(rdev);
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002397 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002398 out_rtnl:
2399 rtnl_unlock();
2400
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01002401 return err;
2402}
2403
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002404static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
2405{
Johannes Berg79c97e92009-07-07 03:56:12 +02002406 struct cfg80211_registered_device *rdev;
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002407 int err;
2408 struct net_device *dev;
2409 struct bss_parameters params;
2410
2411 memset(&params, 0, sizeof(params));
2412 /* default to not changing parameters */
2413 params.use_cts_prot = -1;
2414 params.use_short_preamble = -1;
2415 params.use_short_slot_time = -1;
2416
2417 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
2418 params.use_cts_prot =
2419 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
2420 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
2421 params.use_short_preamble =
2422 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
2423 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
2424 params.use_short_slot_time =
2425 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
Jouni Malinen90c97a02008-10-30 16:59:22 +02002426 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
2427 params.basic_rates =
2428 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2429 params.basic_rates_len =
2430 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2431 }
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002432
Johannes Berg3b858752009-03-12 09:55:09 +01002433 rtnl_lock();
2434
Johannes Berg463d0182009-07-14 00:33:35 +02002435 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002436 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002437 goto out_rtnl;
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002438
Johannes Berg79c97e92009-07-07 03:56:12 +02002439 if (!rdev->ops->change_bss) {
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002440 err = -EOPNOTSUPP;
2441 goto out;
2442 }
2443
Jouni Malineneec60b02009-03-20 21:21:19 +02002444 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2445 err = -EOPNOTSUPP;
2446 goto out;
2447 }
2448
Johannes Berg79c97e92009-07-07 03:56:12 +02002449 err = rdev->ops->change_bss(&rdev->wiphy, dev, &params);
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002450
2451 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02002452 cfg80211_unlock_rdev(rdev);
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002453 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002454 out_rtnl:
2455 rtnl_unlock();
2456
Jouni Malinen9f1ba902008-08-07 20:07:01 +03002457 return err;
2458}
2459
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002460static const struct nla_policy
2461 reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
2462 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2463 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2464 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2465 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2466 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2467 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2468};
2469
2470static int parse_reg_rule(struct nlattr *tb[],
2471 struct ieee80211_reg_rule *reg_rule)
2472{
2473 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
2474 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
2475
2476 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
2477 return -EINVAL;
2478 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
2479 return -EINVAL;
2480 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
2481 return -EINVAL;
2482 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2483 return -EINVAL;
2484 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2485 return -EINVAL;
2486
2487 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
2488
2489 freq_range->start_freq_khz =
2490 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
2491 freq_range->end_freq_khz =
2492 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
2493 freq_range->max_bandwidth_khz =
2494 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
2495
2496 power_rule->max_eirp =
2497 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
2498
2499 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
2500 power_rule->max_antenna_gain =
2501 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
2502
2503 return 0;
2504}
2505
2506static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2507{
2508 int r;
2509 char *data = NULL;
2510
Luis R. Rodriguez80778f12009-02-21 00:04:22 -05002511 /*
2512 * You should only get this when cfg80211 hasn't yet initialized
2513 * completely when built-in to the kernel right between the time
2514 * window between nl80211_init() and regulatory_init(), if that is
2515 * even possible.
2516 */
2517 mutex_lock(&cfg80211_mutex);
2518 if (unlikely(!cfg80211_regdomain)) {
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002519 mutex_unlock(&cfg80211_mutex);
2520 return -EINPROGRESS;
Luis R. Rodriguez80778f12009-02-21 00:04:22 -05002521 }
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002522 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguez80778f12009-02-21 00:04:22 -05002523
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002524 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2525 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002526
2527 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2528
2529#ifdef CONFIG_WIRELESS_OLD_REGULATORY
2530 /* We ignore world regdom requests with the old regdom setup */
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002531 if (is_world_regdom(data))
2532 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002533#endif
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002534
2535 r = regulatory_hint_user(data);
2536
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002537 return r;
2538}
2539
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002540static int nl80211_get_mesh_params(struct sk_buff *skb,
2541 struct genl_info *info)
2542{
Johannes Berg79c97e92009-07-07 03:56:12 +02002543 struct cfg80211_registered_device *rdev;
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002544 struct mesh_config cur_params;
2545 int err;
2546 struct net_device *dev;
2547 void *hdr;
2548 struct nlattr *pinfoattr;
2549 struct sk_buff *msg;
2550
Johannes Berg3b858752009-03-12 09:55:09 +01002551 rtnl_lock();
2552
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002553 /* Look up our device */
Johannes Berg463d0182009-07-14 00:33:35 +02002554 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002555 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002556 goto out_rtnl;
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002557
Johannes Berg79c97e92009-07-07 03:56:12 +02002558 if (!rdev->ops->get_mesh_params) {
Jouni Malinenf3f92582009-03-20 17:57:36 +02002559 err = -EOPNOTSUPP;
2560 goto out;
2561 }
2562
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002563 /* Get the mesh params */
Johannes Berg79c97e92009-07-07 03:56:12 +02002564 err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002565 if (err)
2566 goto out;
2567
2568 /* Draw up a netlink message to send back */
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07002569 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002570 if (!msg) {
2571 err = -ENOBUFS;
2572 goto out;
2573 }
2574 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2575 NL80211_CMD_GET_MESH_PARAMS);
2576 if (!hdr)
2577 goto nla_put_failure;
2578 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
2579 if (!pinfoattr)
2580 goto nla_put_failure;
2581 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2582 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
2583 cur_params.dot11MeshRetryTimeout);
2584 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
2585 cur_params.dot11MeshConfirmTimeout);
2586 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
2587 cur_params.dot11MeshHoldingTimeout);
2588 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
2589 cur_params.dot11MeshMaxPeerLinks);
2590 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
2591 cur_params.dot11MeshMaxRetries);
2592 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
2593 cur_params.dot11MeshTTL);
2594 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
2595 cur_params.auto_open_plinks);
2596 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2597 cur_params.dot11MeshHWMPmaxPREQretries);
2598 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
2599 cur_params.path_refresh_time);
2600 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2601 cur_params.min_discovery_timeout);
2602 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2603 cur_params.dot11MeshHWMPactivePathTimeout);
2604 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2605 cur_params.dot11MeshHWMPpreqMinInterval);
2606 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2607 cur_params.dot11MeshHWMPnetDiameterTraversalTime);
2608 nla_nest_end(msg, pinfoattr);
2609 genlmsg_end(msg, hdr);
Johannes Berg134e6372009-07-10 09:51:34 +00002610 err = genlmsg_reply(msg, info);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002611 goto out;
2612
Johannes Berg3b858752009-03-12 09:55:09 +01002613 nla_put_failure:
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002614 genlmsg_cancel(msg, hdr);
2615 err = -EMSGSIZE;
Johannes Berg3b858752009-03-12 09:55:09 +01002616 out:
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002617 /* Cleanup */
Johannes Berg79c97e92009-07-07 03:56:12 +02002618 cfg80211_unlock_rdev(rdev);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002619 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002620 out_rtnl:
2621 rtnl_unlock();
2622
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002623 return err;
2624}
2625
2626#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2627do {\
2628 if (table[attr_num]) {\
2629 cfg.param = nla_fn(table[attr_num]); \
2630 mask |= (1 << (attr_num - 1)); \
2631 } \
2632} while (0);\
2633
2634static struct nla_policy
2635nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
2636 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
2637 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
2638 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
2639 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
2640 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
2641 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
2642 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
2643
2644 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
2645 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
2646 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
2647 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
2648 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
2649 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
2650};
2651
2652static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
2653{
2654 int err;
2655 u32 mask;
Johannes Berg79c97e92009-07-07 03:56:12 +02002656 struct cfg80211_registered_device *rdev;
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002657 struct net_device *dev;
2658 struct mesh_config cfg;
2659 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
2660 struct nlattr *parent_attr;
2661
2662 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
2663 if (!parent_attr)
2664 return -EINVAL;
2665 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
2666 parent_attr, nl80211_meshconf_params_policy))
2667 return -EINVAL;
2668
Johannes Berg3b858752009-03-12 09:55:09 +01002669 rtnl_lock();
2670
Johannes Berg463d0182009-07-14 00:33:35 +02002671 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002672 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002673 goto out_rtnl;
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002674
Johannes Berg79c97e92009-07-07 03:56:12 +02002675 if (!rdev->ops->set_mesh_params) {
Jouni Malinenf3f92582009-03-20 17:57:36 +02002676 err = -EOPNOTSUPP;
2677 goto out;
2678 }
2679
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002680 /* This makes sure that there aren't more than 32 mesh config
2681 * parameters (otherwise our bitfield scheme would not work.) */
2682 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
2683
2684 /* Fill in the params struct */
2685 mask = 0;
2686 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
2687 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
2688 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
2689 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
2690 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
2691 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
2692 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
2693 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
2694 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
2695 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
2696 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
2697 mask, NL80211_MESHCONF_TTL, nla_get_u8);
2698 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
2699 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
2700 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
2701 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2702 nla_get_u8);
2703 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
2704 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
2705 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
2706 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2707 nla_get_u16);
2708 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
2709 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2710 nla_get_u32);
2711 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
2712 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2713 nla_get_u16);
2714 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2715 dot11MeshHWMPnetDiameterTraversalTime,
2716 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2717 nla_get_u16);
2718
2719 /* Apply changes */
Johannes Berg79c97e92009-07-07 03:56:12 +02002720 err = rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002721
Jouni Malinenf3f92582009-03-20 17:57:36 +02002722 out:
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002723 /* cleanup */
Johannes Berg79c97e92009-07-07 03:56:12 +02002724 cfg80211_unlock_rdev(rdev);
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002725 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01002726 out_rtnl:
2727 rtnl_unlock();
2728
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07002729 return err;
2730}
2731
2732#undef FILL_IN_MESH_PARAM_IF_SET
2733
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08002734static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
2735{
2736 struct sk_buff *msg;
2737 void *hdr = NULL;
2738 struct nlattr *nl_reg_rules;
2739 unsigned int i;
2740 int err = -EINVAL;
2741
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002742 mutex_lock(&cfg80211_mutex);
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08002743
2744 if (!cfg80211_regdomain)
2745 goto out;
2746
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07002747 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08002748 if (!msg) {
2749 err = -ENOBUFS;
2750 goto out;
2751 }
2752
2753 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2754 NL80211_CMD_GET_REG);
2755 if (!hdr)
2756 goto nla_put_failure;
2757
2758 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2759 cfg80211_regdomain->alpha2);
2760
2761 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
2762 if (!nl_reg_rules)
2763 goto nla_put_failure;
2764
2765 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
2766 struct nlattr *nl_reg_rule;
2767 const struct ieee80211_reg_rule *reg_rule;
2768 const struct ieee80211_freq_range *freq_range;
2769 const struct ieee80211_power_rule *power_rule;
2770
2771 reg_rule = &cfg80211_regdomain->reg_rules[i];
2772 freq_range = &reg_rule->freq_range;
2773 power_rule = &reg_rule->power_rule;
2774
2775 nl_reg_rule = nla_nest_start(msg, i);
2776 if (!nl_reg_rule)
2777 goto nla_put_failure;
2778
2779 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
2780 reg_rule->flags);
2781 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
2782 freq_range->start_freq_khz);
2783 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
2784 freq_range->end_freq_khz);
2785 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
2786 freq_range->max_bandwidth_khz);
2787 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
2788 power_rule->max_antenna_gain);
2789 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
2790 power_rule->max_eirp);
2791
2792 nla_nest_end(msg, nl_reg_rule);
2793 }
2794
2795 nla_nest_end(msg, nl_reg_rules);
2796
2797 genlmsg_end(msg, hdr);
Johannes Berg134e6372009-07-10 09:51:34 +00002798 err = genlmsg_reply(msg, info);
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08002799 goto out;
2800
2801nla_put_failure:
2802 genlmsg_cancel(msg, hdr);
2803 err = -EMSGSIZE;
2804out:
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002805 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08002806 return err;
2807}
2808
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002809static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2810{
2811 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2812 struct nlattr *nl_reg_rule;
2813 char *alpha2 = NULL;
2814 int rem_reg_rules = 0, r = 0;
2815 u32 num_rules = 0, rule_idx = 0, size_of_regd;
2816 struct ieee80211_regdomain *rd = NULL;
2817
2818 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2819 return -EINVAL;
2820
2821 if (!info->attrs[NL80211_ATTR_REG_RULES])
2822 return -EINVAL;
2823
2824 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2825
2826 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2827 rem_reg_rules) {
2828 num_rules++;
2829 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
Luis R. Rodriguez4776c6e2009-05-13 17:04:39 -04002830 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002831 }
2832
Luis R. Rodriguez61405e92009-05-13 17:04:41 -04002833 mutex_lock(&cfg80211_mutex);
2834
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002835 if (!reg_is_valid_request(alpha2)) {
2836 r = -EINVAL;
2837 goto bad_reg;
2838 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002839
2840 size_of_regd = sizeof(struct ieee80211_regdomain) +
2841 (num_rules * sizeof(struct ieee80211_reg_rule));
2842
2843 rd = kzalloc(size_of_regd, GFP_KERNEL);
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002844 if (!rd) {
2845 r = -ENOMEM;
2846 goto bad_reg;
2847 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002848
2849 rd->n_reg_rules = num_rules;
2850 rd->alpha2[0] = alpha2[0];
2851 rd->alpha2[1] = alpha2[1];
2852
2853 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2854 rem_reg_rules) {
2855 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2856 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2857 reg_rule_policy);
2858 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2859 if (r)
2860 goto bad_reg;
2861
2862 rule_idx++;
2863
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002864 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
2865 r = -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002866 goto bad_reg;
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002867 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002868 }
2869
2870 BUG_ON(rule_idx != num_rules);
2871
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002872 r = set_regdom(rd);
Luis R. Rodriguez61405e92009-05-13 17:04:41 -04002873
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002874 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002875
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002876 return r;
2877
Johannes Bergd2372b32008-10-24 20:32:20 +02002878 bad_reg:
Luis R. Rodriguez61405e92009-05-13 17:04:41 -04002879 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002880 kfree(rd);
Luis R. Rodriguezd0e18f82009-05-13 17:04:40 -04002881 return r;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002882}
2883
Johannes Berg83f5e2c2009-06-17 17:41:49 +02002884static int validate_scan_freqs(struct nlattr *freqs)
2885{
2886 struct nlattr *attr1, *attr2;
2887 int n_channels = 0, tmp1, tmp2;
2888
2889 nla_for_each_nested(attr1, freqs, tmp1) {
2890 n_channels++;
2891 /*
2892 * Some hardware has a limited channel list for
2893 * scanning, and it is pretty much nonsensical
2894 * to scan for a channel twice, so disallow that
2895 * and don't require drivers to check that the
2896 * channel list they get isn't longer than what
2897 * they can scan, as long as they can scan all
2898 * the channels they registered at once.
2899 */
2900 nla_for_each_nested(attr2, freqs, tmp2)
2901 if (attr1 != attr2 &&
2902 nla_get_u32(attr1) == nla_get_u32(attr2))
2903 return 0;
2904 }
2905
2906 return n_channels;
2907}
2908
Johannes Berg2a519312009-02-10 21:25:55 +01002909static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
2910{
Johannes Berg79c97e92009-07-07 03:56:12 +02002911 struct cfg80211_registered_device *rdev;
Johannes Berg2a519312009-02-10 21:25:55 +01002912 struct net_device *dev;
2913 struct cfg80211_scan_request *request;
2914 struct cfg80211_ssid *ssid;
2915 struct ieee80211_channel *channel;
2916 struct nlattr *attr;
2917 struct wiphy *wiphy;
Johannes Berg83f5e2c2009-06-17 17:41:49 +02002918 int err, tmp, n_ssids = 0, n_channels, i;
Johannes Berg2a519312009-02-10 21:25:55 +01002919 enum ieee80211_band band;
Jouni Malinen70692ad2009-02-16 19:39:13 +02002920 size_t ie_len;
Johannes Berg2a519312009-02-10 21:25:55 +01002921
Johannes Bergf4a11bb2009-03-27 12:40:28 +01002922 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2923 return -EINVAL;
2924
Johannes Berg3b858752009-03-12 09:55:09 +01002925 rtnl_lock();
2926
Johannes Berg463d0182009-07-14 00:33:35 +02002927 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg2a519312009-02-10 21:25:55 +01002928 if (err)
Johannes Berg3b858752009-03-12 09:55:09 +01002929 goto out_rtnl;
Johannes Berg2a519312009-02-10 21:25:55 +01002930
Johannes Berg79c97e92009-07-07 03:56:12 +02002931 wiphy = &rdev->wiphy;
Johannes Berg2a519312009-02-10 21:25:55 +01002932
Johannes Berg79c97e92009-07-07 03:56:12 +02002933 if (!rdev->ops->scan) {
Johannes Berg2a519312009-02-10 21:25:55 +01002934 err = -EOPNOTSUPP;
2935 goto out;
2936 }
2937
Jouni Malinen35a8efe2009-03-20 21:21:18 +02002938 if (!netif_running(dev)) {
2939 err = -ENETDOWN;
2940 goto out;
2941 }
2942
Johannes Berg79c97e92009-07-07 03:56:12 +02002943 if (rdev->scan_req) {
Johannes Berg2a519312009-02-10 21:25:55 +01002944 err = -EBUSY;
Johannes Berg3b858752009-03-12 09:55:09 +01002945 goto out;
Johannes Berg2a519312009-02-10 21:25:55 +01002946 }
2947
2948 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
Johannes Berg83f5e2c2009-06-17 17:41:49 +02002949 n_channels = validate_scan_freqs(
2950 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
Johannes Berg2a519312009-02-10 21:25:55 +01002951 if (!n_channels) {
2952 err = -EINVAL;
Johannes Berg3b858752009-03-12 09:55:09 +01002953 goto out;
Johannes Berg2a519312009-02-10 21:25:55 +01002954 }
2955 } else {
Johannes Berg83f5e2c2009-06-17 17:41:49 +02002956 n_channels = 0;
2957
Johannes Berg2a519312009-02-10 21:25:55 +01002958 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
2959 if (wiphy->bands[band])
2960 n_channels += wiphy->bands[band]->n_channels;
2961 }
2962
2963 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
2964 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
2965 n_ssids++;
2966
2967 if (n_ssids > wiphy->max_scan_ssids) {
2968 err = -EINVAL;
Johannes Berg3b858752009-03-12 09:55:09 +01002969 goto out;
Johannes Berg2a519312009-02-10 21:25:55 +01002970 }
2971
Jouni Malinen70692ad2009-02-16 19:39:13 +02002972 if (info->attrs[NL80211_ATTR_IE])
2973 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2974 else
2975 ie_len = 0;
2976
Johannes Berg18a83652009-03-31 12:12:05 +02002977 if (ie_len > wiphy->max_scan_ie_len) {
2978 err = -EINVAL;
2979 goto out;
2980 }
2981
Johannes Berg2a519312009-02-10 21:25:55 +01002982 request = kzalloc(sizeof(*request)
2983 + sizeof(*ssid) * n_ssids
Jouni Malinen70692ad2009-02-16 19:39:13 +02002984 + sizeof(channel) * n_channels
2985 + ie_len, GFP_KERNEL);
Johannes Berg2a519312009-02-10 21:25:55 +01002986 if (!request) {
2987 err = -ENOMEM;
Johannes Berg3b858752009-03-12 09:55:09 +01002988 goto out;
Johannes Berg2a519312009-02-10 21:25:55 +01002989 }
2990
Johannes Berg2a519312009-02-10 21:25:55 +01002991 request->n_channels = n_channels;
2992 if (n_ssids)
Johannes Berg5ba63532009-08-07 17:54:07 +02002993 request->ssids = (void *)&request->channels[n_channels];
Johannes Berg2a519312009-02-10 21:25:55 +01002994 request->n_ssids = n_ssids;
Jouni Malinen70692ad2009-02-16 19:39:13 +02002995 if (ie_len) {
2996 if (request->ssids)
2997 request->ie = (void *)(request->ssids + n_ssids);
2998 else
2999 request->ie = (void *)(request->channels + n_channels);
3000 }
Johannes Berg2a519312009-02-10 21:25:55 +01003001
3002 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3003 /* user specified, bail out if channel not found */
3004 request->n_channels = n_channels;
3005 i = 0;
3006 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
3007 request->channels[i] = ieee80211_get_channel(wiphy, nla_get_u32(attr));
3008 if (!request->channels[i]) {
3009 err = -EINVAL;
3010 goto out_free;
3011 }
3012 i++;
3013 }
3014 } else {
3015 /* all channels */
3016 i = 0;
3017 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
3018 int j;
3019 if (!wiphy->bands[band])
3020 continue;
3021 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
3022 request->channels[i] = &wiphy->bands[band]->channels[j];
3023 i++;
3024 }
3025 }
3026 }
3027
3028 i = 0;
3029 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
3030 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
3031 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
3032 err = -EINVAL;
3033 goto out_free;
3034 }
3035 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
3036 request->ssids[i].ssid_len = nla_len(attr);
3037 i++;
3038 }
3039 }
3040
Jouni Malinen70692ad2009-02-16 19:39:13 +02003041 if (info->attrs[NL80211_ATTR_IE]) {
3042 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
Johannes Bergde95a542009-04-01 11:58:36 +02003043 memcpy((void *)request->ie,
3044 nla_data(info->attrs[NL80211_ATTR_IE]),
Jouni Malinen70692ad2009-02-16 19:39:13 +02003045 request->ie_len);
3046 }
3047
Johannes Berg463d0182009-07-14 00:33:35 +02003048 request->dev = dev;
Johannes Berg79c97e92009-07-07 03:56:12 +02003049 request->wiphy = &rdev->wiphy;
Johannes Berg2a519312009-02-10 21:25:55 +01003050
Johannes Berg79c97e92009-07-07 03:56:12 +02003051 rdev->scan_req = request;
3052 err = rdev->ops->scan(&rdev->wiphy, dev, request);
Johannes Berg2a519312009-02-10 21:25:55 +01003053
Johannes Berg463d0182009-07-14 00:33:35 +02003054 if (!err) {
Johannes Berg79c97e92009-07-07 03:56:12 +02003055 nl80211_send_scan_start(rdev, dev);
Johannes Berg463d0182009-07-14 00:33:35 +02003056 dev_hold(dev);
3057 }
Johannes Berga538e2d2009-06-16 19:56:42 +02003058
Johannes Berg2a519312009-02-10 21:25:55 +01003059 out_free:
3060 if (err) {
Johannes Berg79c97e92009-07-07 03:56:12 +02003061 rdev->scan_req = NULL;
Johannes Berg2a519312009-02-10 21:25:55 +01003062 kfree(request);
3063 }
Johannes Berg2a519312009-02-10 21:25:55 +01003064 out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003065 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01003066 dev_put(dev);
Johannes Berg3b858752009-03-12 09:55:09 +01003067 out_rtnl:
3068 rtnl_unlock();
3069
Johannes Berg2a519312009-02-10 21:25:55 +01003070 return err;
3071}
3072
3073static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
3074 struct cfg80211_registered_device *rdev,
Johannes Berg48ab9052009-07-10 18:42:31 +02003075 struct wireless_dev *wdev,
3076 struct cfg80211_internal_bss *intbss)
Johannes Berg2a519312009-02-10 21:25:55 +01003077{
Johannes Berg48ab9052009-07-10 18:42:31 +02003078 struct cfg80211_bss *res = &intbss->pub;
Johannes Berg2a519312009-02-10 21:25:55 +01003079 void *hdr;
3080 struct nlattr *bss;
Johannes Berg48ab9052009-07-10 18:42:31 +02003081 int i;
3082
3083 ASSERT_WDEV_LOCK(wdev);
Johannes Berg2a519312009-02-10 21:25:55 +01003084
3085 hdr = nl80211hdr_put(msg, pid, seq, flags,
3086 NL80211_CMD_NEW_SCAN_RESULTS);
3087 if (!hdr)
3088 return -1;
3089
Johannes Bergf5ea9122009-08-07 16:17:38 +02003090 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation);
Johannes Berg48ab9052009-07-10 18:42:31 +02003091 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex);
Johannes Berg2a519312009-02-10 21:25:55 +01003092
3093 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
3094 if (!bss)
3095 goto nla_put_failure;
3096 if (!is_zero_ether_addr(res->bssid))
3097 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid);
3098 if (res->information_elements && res->len_information_elements)
3099 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS,
3100 res->len_information_elements,
3101 res->information_elements);
3102 if (res->tsf)
3103 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf);
3104 if (res->beacon_interval)
3105 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval);
3106 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability);
3107 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq);
Holger Schurig7c896062009-09-24 12:21:01 +02003108 NLA_PUT_U32(msg, NL80211_BSS_SEEN_MS_AGO,
3109 jiffies_to_msecs(jiffies - intbss->ts));
Johannes Berg2a519312009-02-10 21:25:55 +01003110
Johannes Berg77965c92009-02-18 18:45:06 +01003111 switch (rdev->wiphy.signal_type) {
Johannes Berg2a519312009-02-10 21:25:55 +01003112 case CFG80211_SIGNAL_TYPE_MBM:
3113 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal);
3114 break;
3115 case CFG80211_SIGNAL_TYPE_UNSPEC:
3116 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal);
3117 break;
3118 default:
3119 break;
3120 }
3121
Johannes Berg48ab9052009-07-10 18:42:31 +02003122 switch (wdev->iftype) {
3123 case NL80211_IFTYPE_STATION:
3124 if (intbss == wdev->current_bss)
3125 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3126 NL80211_BSS_STATUS_ASSOCIATED);
3127 else for (i = 0; i < MAX_AUTH_BSSES; i++) {
3128 if (intbss != wdev->auth_bsses[i])
3129 continue;
3130 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3131 NL80211_BSS_STATUS_AUTHENTICATED);
3132 break;
3133 }
3134 break;
3135 case NL80211_IFTYPE_ADHOC:
3136 if (intbss == wdev->current_bss)
3137 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3138 NL80211_BSS_STATUS_IBSS_JOINED);
3139 break;
3140 default:
3141 break;
3142 }
3143
Johannes Berg2a519312009-02-10 21:25:55 +01003144 nla_nest_end(msg, bss);
3145
3146 return genlmsg_end(msg, hdr);
3147
3148 nla_put_failure:
3149 genlmsg_cancel(msg, hdr);
3150 return -EMSGSIZE;
3151}
3152
3153static int nl80211_dump_scan(struct sk_buff *skb,
3154 struct netlink_callback *cb)
3155{
Johannes Berg48ab9052009-07-10 18:42:31 +02003156 struct cfg80211_registered_device *rdev;
3157 struct net_device *dev;
Johannes Berg2a519312009-02-10 21:25:55 +01003158 struct cfg80211_internal_bss *scan;
Johannes Berg48ab9052009-07-10 18:42:31 +02003159 struct wireless_dev *wdev;
Johannes Berg2a519312009-02-10 21:25:55 +01003160 int ifidx = cb->args[0];
3161 int start = cb->args[1], idx = 0;
3162 int err;
3163
3164 if (!ifidx) {
3165 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
3166 nl80211_fam.attrbuf, nl80211_fam.maxattr,
3167 nl80211_policy);
3168 if (err)
3169 return err;
3170
3171 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
3172 return -EINVAL;
3173
3174 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
3175 if (!ifidx)
3176 return -EINVAL;
3177 cb->args[0] = ifidx;
3178 }
3179
Johannes Berg463d0182009-07-14 00:33:35 +02003180 dev = dev_get_by_index(sock_net(skb->sk), ifidx);
Johannes Berg48ab9052009-07-10 18:42:31 +02003181 if (!dev)
Johannes Berg2a519312009-02-10 21:25:55 +01003182 return -ENODEV;
3183
Johannes Berg463d0182009-07-14 00:33:35 +02003184 rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
Johannes Berg48ab9052009-07-10 18:42:31 +02003185 if (IS_ERR(rdev)) {
3186 err = PTR_ERR(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01003187 goto out_put_netdev;
3188 }
3189
Johannes Berg48ab9052009-07-10 18:42:31 +02003190 wdev = dev->ieee80211_ptr;
Johannes Berg2a519312009-02-10 21:25:55 +01003191
Johannes Berg48ab9052009-07-10 18:42:31 +02003192 wdev_lock(wdev);
3193 spin_lock_bh(&rdev->bss_lock);
3194 cfg80211_bss_expire(rdev);
3195
3196 list_for_each_entry(scan, &rdev->bss_list, list) {
Johannes Berg2a519312009-02-10 21:25:55 +01003197 if (++idx <= start)
3198 continue;
3199 if (nl80211_send_bss(skb,
3200 NETLINK_CB(cb->skb).pid,
3201 cb->nlh->nlmsg_seq, NLM_F_MULTI,
Johannes Berg48ab9052009-07-10 18:42:31 +02003202 rdev, wdev, scan) < 0) {
Johannes Berg2a519312009-02-10 21:25:55 +01003203 idx--;
3204 goto out;
3205 }
3206 }
3207
3208 out:
Johannes Berg48ab9052009-07-10 18:42:31 +02003209 spin_unlock_bh(&rdev->bss_lock);
3210 wdev_unlock(wdev);
Johannes Berg2a519312009-02-10 21:25:55 +01003211
3212 cb->args[1] = idx;
3213 err = skb->len;
Johannes Berg48ab9052009-07-10 18:42:31 +02003214 cfg80211_unlock_rdev(rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01003215 out_put_netdev:
Johannes Berg48ab9052009-07-10 18:42:31 +02003216 dev_put(dev);
Johannes Berg2a519312009-02-10 21:25:55 +01003217
3218 return err;
3219}
3220
Jouni Malinen255e7372009-03-20 21:21:17 +02003221static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
3222{
Samuel Ortizb23aa672009-07-01 21:26:54 +02003223 return auth_type <= NL80211_AUTHTYPE_MAX;
Jouni Malinen255e7372009-03-20 21:21:17 +02003224}
3225
Samuel Ortizb23aa672009-07-01 21:26:54 +02003226static bool nl80211_valid_wpa_versions(u32 wpa_versions)
3227{
3228 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
3229 NL80211_WPA_VERSION_2));
3230}
3231
3232static bool nl80211_valid_akm_suite(u32 akm)
3233{
3234 return akm == WLAN_AKM_SUITE_8021X ||
3235 akm == WLAN_AKM_SUITE_PSK;
3236}
3237
3238static bool nl80211_valid_cipher_suite(u32 cipher)
3239{
3240 return cipher == WLAN_CIPHER_SUITE_WEP40 ||
3241 cipher == WLAN_CIPHER_SUITE_WEP104 ||
3242 cipher == WLAN_CIPHER_SUITE_TKIP ||
3243 cipher == WLAN_CIPHER_SUITE_CCMP ||
3244 cipher == WLAN_CIPHER_SUITE_AES_CMAC;
3245}
3246
3247
Jouni Malinen636a5d32009-03-19 13:39:22 +02003248static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
3249{
Johannes Berg79c97e92009-07-07 03:56:12 +02003250 struct cfg80211_registered_device *rdev;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003251 struct net_device *dev;
Johannes Berg19957bb2009-07-02 17:20:43 +02003252 struct ieee80211_channel *chan;
3253 const u8 *bssid, *ssid, *ie = NULL;
3254 int err, ssid_len, ie_len = 0;
3255 enum nl80211_auth_type auth_type;
Johannes Bergfffd0932009-07-08 14:22:54 +02003256 struct key_parse key;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003257
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003258 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3259 return -EINVAL;
3260
3261 if (!info->attrs[NL80211_ATTR_MAC])
3262 return -EINVAL;
3263
Jouni Malinen17780922009-03-27 20:52:47 +02003264 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
3265 return -EINVAL;
3266
Johannes Berg19957bb2009-07-02 17:20:43 +02003267 if (!info->attrs[NL80211_ATTR_SSID])
3268 return -EINVAL;
3269
3270 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
3271 return -EINVAL;
3272
Johannes Bergfffd0932009-07-08 14:22:54 +02003273 err = nl80211_parse_key(info, &key);
3274 if (err)
3275 return err;
3276
3277 if (key.idx >= 0) {
3278 if (!key.p.key || !key.p.key_len)
3279 return -EINVAL;
3280 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
3281 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
3282 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
3283 key.p.key_len != WLAN_KEY_LEN_WEP104))
3284 return -EINVAL;
3285 if (key.idx > 4)
3286 return -EINVAL;
3287 } else {
3288 key.p.key_len = 0;
3289 key.p.key = NULL;
3290 }
3291
Jouni Malinen636a5d32009-03-19 13:39:22 +02003292 rtnl_lock();
3293
Johannes Berg463d0182009-07-14 00:33:35 +02003294 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003295 if (err)
3296 goto unlock_rtnl;
3297
Johannes Berg79c97e92009-07-07 03:56:12 +02003298 if (!rdev->ops->auth) {
Jouni Malinen636a5d32009-03-19 13:39:22 +02003299 err = -EOPNOTSUPP;
3300 goto out;
3301 }
3302
Jouni Malineneec60b02009-03-20 21:21:19 +02003303 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3304 err = -EOPNOTSUPP;
3305 goto out;
3306 }
3307
Jouni Malinen35a8efe2009-03-20 21:21:18 +02003308 if (!netif_running(dev)) {
3309 err = -ENETDOWN;
3310 goto out;
3311 }
3312
Johannes Berg19957bb2009-07-02 17:20:43 +02003313 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
Johannes Berg79c97e92009-07-07 03:56:12 +02003314 chan = ieee80211_get_channel(&rdev->wiphy,
Johannes Berg19957bb2009-07-02 17:20:43 +02003315 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3316 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
Jouni Malinen17780922009-03-27 20:52:47 +02003317 err = -EINVAL;
3318 goto out;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003319 }
3320
Johannes Berg19957bb2009-07-02 17:20:43 +02003321 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3322 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3323
3324 if (info->attrs[NL80211_ATTR_IE]) {
3325 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3326 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3327 }
3328
3329 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3330 if (!nl80211_valid_auth_type(auth_type)) {
3331 err = -EINVAL;
3332 goto out;
3333 }
3334
Johannes Berg79c97e92009-07-07 03:56:12 +02003335 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
Johannes Bergfffd0932009-07-08 14:22:54 +02003336 ssid, ssid_len, ie, ie_len,
3337 key.p.key, key.p.key_len, key.idx);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003338
3339out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003340 cfg80211_unlock_rdev(rdev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003341 dev_put(dev);
3342unlock_rtnl:
3343 rtnl_unlock();
3344 return err;
3345}
3346
Samuel Ortizb23aa672009-07-01 21:26:54 +02003347static int nl80211_crypto_settings(struct genl_info *info,
Johannes Berg3dc27d22009-07-02 21:36:37 +02003348 struct cfg80211_crypto_settings *settings,
3349 int cipher_limit)
Samuel Ortizb23aa672009-07-01 21:26:54 +02003350{
Johannes Bergc0b2bbd2009-07-25 16:54:36 +02003351 memset(settings, 0, sizeof(*settings));
3352
Samuel Ortizb23aa672009-07-01 21:26:54 +02003353 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
3354
3355 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
3356 void *data;
3357 int len, i;
3358
3359 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3360 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3361 settings->n_ciphers_pairwise = len / sizeof(u32);
3362
3363 if (len % sizeof(u32))
3364 return -EINVAL;
3365
Johannes Berg3dc27d22009-07-02 21:36:37 +02003366 if (settings->n_ciphers_pairwise > cipher_limit)
Samuel Ortizb23aa672009-07-01 21:26:54 +02003367 return -EINVAL;
3368
3369 memcpy(settings->ciphers_pairwise, data, len);
3370
3371 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3372 if (!nl80211_valid_cipher_suite(
3373 settings->ciphers_pairwise[i]))
3374 return -EINVAL;
3375 }
3376
3377 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
3378 settings->cipher_group =
3379 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
3380 if (!nl80211_valid_cipher_suite(settings->cipher_group))
3381 return -EINVAL;
3382 }
3383
3384 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
3385 settings->wpa_versions =
3386 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
3387 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
3388 return -EINVAL;
3389 }
3390
3391 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
3392 void *data;
3393 int len, i;
3394
3395 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
3396 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
3397 settings->n_akm_suites = len / sizeof(u32);
3398
3399 if (len % sizeof(u32))
3400 return -EINVAL;
3401
3402 memcpy(settings->akm_suites, data, len);
3403
3404 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3405 if (!nl80211_valid_akm_suite(settings->akm_suites[i]))
3406 return -EINVAL;
3407 }
3408
3409 return 0;
3410}
3411
Jouni Malinen636a5d32009-03-19 13:39:22 +02003412static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
3413{
Johannes Berg19957bb2009-07-02 17:20:43 +02003414 struct cfg80211_registered_device *rdev;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003415 struct net_device *dev;
Johannes Berg19957bb2009-07-02 17:20:43 +02003416 struct cfg80211_crypto_settings crypto;
Johannes Berg59bbb6f2009-08-07 17:22:35 +02003417 struct ieee80211_channel *chan, *fixedchan;
Johannes Berg3e5d7642009-07-07 14:37:26 +02003418 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
Johannes Berg19957bb2009-07-02 17:20:43 +02003419 int err, ssid_len, ie_len = 0;
3420 bool use_mfp = false;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003421
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003422 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3423 return -EINVAL;
3424
3425 if (!info->attrs[NL80211_ATTR_MAC] ||
Johannes Berg19957bb2009-07-02 17:20:43 +02003426 !info->attrs[NL80211_ATTR_SSID] ||
3427 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003428 return -EINVAL;
3429
Jouni Malinen636a5d32009-03-19 13:39:22 +02003430 rtnl_lock();
3431
Johannes Berg463d0182009-07-14 00:33:35 +02003432 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003433 if (err)
3434 goto unlock_rtnl;
3435
Johannes Berg19957bb2009-07-02 17:20:43 +02003436 if (!rdev->ops->assoc) {
Jouni Malinen636a5d32009-03-19 13:39:22 +02003437 err = -EOPNOTSUPP;
3438 goto out;
3439 }
3440
Jouni Malineneec60b02009-03-20 21:21:19 +02003441 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3442 err = -EOPNOTSUPP;
3443 goto out;
3444 }
3445
Jouni Malinen35a8efe2009-03-20 21:21:18 +02003446 if (!netif_running(dev)) {
3447 err = -ENETDOWN;
3448 goto out;
3449 }
3450
Johannes Berg19957bb2009-07-02 17:20:43 +02003451 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003452
Johannes Berg19957bb2009-07-02 17:20:43 +02003453 chan = ieee80211_get_channel(&rdev->wiphy,
3454 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3455 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3456 err = -EINVAL;
3457 goto out;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003458 }
3459
Johannes Berg59bbb6f2009-08-07 17:22:35 +02003460 mutex_lock(&rdev->devlist_mtx);
3461 fixedchan = rdev_fixed_channel(rdev, NULL);
3462 if (fixedchan && chan != fixedchan) {
3463 err = -EBUSY;
3464 mutex_unlock(&rdev->devlist_mtx);
3465 goto out;
3466 }
3467 mutex_unlock(&rdev->devlist_mtx);
3468
Johannes Berg19957bb2009-07-02 17:20:43 +02003469 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3470 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003471
3472 if (info->attrs[NL80211_ATTR_IE]) {
Johannes Berg19957bb2009-07-02 17:20:43 +02003473 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3474 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003475 }
3476
Jouni Malinendc6382c2009-05-06 22:09:37 +03003477 if (info->attrs[NL80211_ATTR_USE_MFP]) {
Johannes Berg4f5dadc2009-07-07 03:56:10 +02003478 enum nl80211_mfp mfp =
Jouni Malinendc6382c2009-05-06 22:09:37 +03003479 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
Johannes Berg4f5dadc2009-07-07 03:56:10 +02003480 if (mfp == NL80211_MFP_REQUIRED)
Johannes Berg19957bb2009-07-02 17:20:43 +02003481 use_mfp = true;
Johannes Berg4f5dadc2009-07-07 03:56:10 +02003482 else if (mfp != NL80211_MFP_NO) {
Jouni Malinendc6382c2009-05-06 22:09:37 +03003483 err = -EINVAL;
3484 goto out;
3485 }
3486 }
3487
Johannes Berg3e5d7642009-07-07 14:37:26 +02003488 if (info->attrs[NL80211_ATTR_PREV_BSSID])
3489 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3490
Johannes Berg3dc27d22009-07-02 21:36:37 +02003491 err = nl80211_crypto_settings(info, &crypto, 1);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003492 if (!err)
Johannes Berg3e5d7642009-07-07 14:37:26 +02003493 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
3494 ssid, ssid_len, ie, ie_len, use_mfp,
Johannes Berg19957bb2009-07-02 17:20:43 +02003495 &crypto);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003496
3497out:
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02003498 cfg80211_unlock_rdev(rdev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003499 dev_put(dev);
3500unlock_rtnl:
3501 rtnl_unlock();
3502 return err;
3503}
3504
3505static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
3506{
Johannes Berg79c97e92009-07-07 03:56:12 +02003507 struct cfg80211_registered_device *rdev;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003508 struct net_device *dev;
Johannes Berg19957bb2009-07-02 17:20:43 +02003509 const u8 *ie = NULL, *bssid;
3510 int err, ie_len = 0;
3511 u16 reason_code;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003512
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003513 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3514 return -EINVAL;
3515
3516 if (!info->attrs[NL80211_ATTR_MAC])
3517 return -EINVAL;
3518
3519 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3520 return -EINVAL;
3521
Jouni Malinen636a5d32009-03-19 13:39:22 +02003522 rtnl_lock();
3523
Johannes Berg463d0182009-07-14 00:33:35 +02003524 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003525 if (err)
3526 goto unlock_rtnl;
3527
Johannes Berg79c97e92009-07-07 03:56:12 +02003528 if (!rdev->ops->deauth) {
Jouni Malinen636a5d32009-03-19 13:39:22 +02003529 err = -EOPNOTSUPP;
3530 goto out;
3531 }
3532
Jouni Malineneec60b02009-03-20 21:21:19 +02003533 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3534 err = -EOPNOTSUPP;
3535 goto out;
3536 }
3537
Jouni Malinen35a8efe2009-03-20 21:21:18 +02003538 if (!netif_running(dev)) {
3539 err = -ENETDOWN;
3540 goto out;
3541 }
3542
Johannes Berg19957bb2009-07-02 17:20:43 +02003543 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003544
Johannes Berg19957bb2009-07-02 17:20:43 +02003545 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3546 if (reason_code == 0) {
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003547 /* Reason Code 0 is reserved */
3548 err = -EINVAL;
3549 goto out;
Jouni Malinen255e7372009-03-20 21:21:17 +02003550 }
Jouni Malinen636a5d32009-03-19 13:39:22 +02003551
3552 if (info->attrs[NL80211_ATTR_IE]) {
Johannes Berg19957bb2009-07-02 17:20:43 +02003553 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3554 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003555 }
3556
Johannes Berg79c97e92009-07-07 03:56:12 +02003557 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003558
3559out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003560 cfg80211_unlock_rdev(rdev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003561 dev_put(dev);
3562unlock_rtnl:
3563 rtnl_unlock();
3564 return err;
3565}
3566
3567static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
3568{
Johannes Berg79c97e92009-07-07 03:56:12 +02003569 struct cfg80211_registered_device *rdev;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003570 struct net_device *dev;
Johannes Berg19957bb2009-07-02 17:20:43 +02003571 const u8 *ie = NULL, *bssid;
3572 int err, ie_len = 0;
3573 u16 reason_code;
Jouni Malinen636a5d32009-03-19 13:39:22 +02003574
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003575 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3576 return -EINVAL;
3577
3578 if (!info->attrs[NL80211_ATTR_MAC])
3579 return -EINVAL;
3580
3581 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3582 return -EINVAL;
3583
Jouni Malinen636a5d32009-03-19 13:39:22 +02003584 rtnl_lock();
3585
Johannes Berg463d0182009-07-14 00:33:35 +02003586 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003587 if (err)
3588 goto unlock_rtnl;
3589
Johannes Berg79c97e92009-07-07 03:56:12 +02003590 if (!rdev->ops->disassoc) {
Jouni Malinen636a5d32009-03-19 13:39:22 +02003591 err = -EOPNOTSUPP;
3592 goto out;
3593 }
3594
Jouni Malineneec60b02009-03-20 21:21:19 +02003595 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3596 err = -EOPNOTSUPP;
3597 goto out;
3598 }
3599
Jouni Malinen35a8efe2009-03-20 21:21:18 +02003600 if (!netif_running(dev)) {
3601 err = -ENETDOWN;
3602 goto out;
3603 }
3604
Johannes Berg19957bb2009-07-02 17:20:43 +02003605 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003606
Johannes Berg19957bb2009-07-02 17:20:43 +02003607 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3608 if (reason_code == 0) {
Johannes Bergf4a11bb2009-03-27 12:40:28 +01003609 /* Reason Code 0 is reserved */
3610 err = -EINVAL;
3611 goto out;
Jouni Malinen255e7372009-03-20 21:21:17 +02003612 }
Jouni Malinen636a5d32009-03-19 13:39:22 +02003613
3614 if (info->attrs[NL80211_ATTR_IE]) {
Johannes Berg19957bb2009-07-02 17:20:43 +02003615 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3616 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003617 }
3618
Johannes Berg79c97e92009-07-07 03:56:12 +02003619 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003620
3621out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003622 cfg80211_unlock_rdev(rdev);
Jouni Malinen636a5d32009-03-19 13:39:22 +02003623 dev_put(dev);
3624unlock_rtnl:
3625 rtnl_unlock();
3626 return err;
3627}
3628
Johannes Berg04a773a2009-04-19 21:24:32 +02003629static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
3630{
Johannes Berg79c97e92009-07-07 03:56:12 +02003631 struct cfg80211_registered_device *rdev;
Johannes Berg04a773a2009-04-19 21:24:32 +02003632 struct net_device *dev;
3633 struct cfg80211_ibss_params ibss;
3634 struct wiphy *wiphy;
Johannes Bergfffd0932009-07-08 14:22:54 +02003635 struct cfg80211_cached_keys *connkeys = NULL;
Johannes Berg04a773a2009-04-19 21:24:32 +02003636 int err;
3637
Johannes Berg8e30bc52009-04-22 17:45:38 +02003638 memset(&ibss, 0, sizeof(ibss));
3639
Johannes Berg04a773a2009-04-19 21:24:32 +02003640 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3641 return -EINVAL;
3642
3643 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
3644 !info->attrs[NL80211_ATTR_SSID] ||
3645 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3646 return -EINVAL;
3647
Johannes Berg8e30bc52009-04-22 17:45:38 +02003648 ibss.beacon_interval = 100;
3649
3650 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
3651 ibss.beacon_interval =
3652 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3653 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
3654 return -EINVAL;
3655 }
3656
Johannes Berg04a773a2009-04-19 21:24:32 +02003657 rtnl_lock();
3658
Johannes Berg463d0182009-07-14 00:33:35 +02003659 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg04a773a2009-04-19 21:24:32 +02003660 if (err)
3661 goto unlock_rtnl;
3662
Johannes Berg79c97e92009-07-07 03:56:12 +02003663 if (!rdev->ops->join_ibss) {
Johannes Berg04a773a2009-04-19 21:24:32 +02003664 err = -EOPNOTSUPP;
3665 goto out;
3666 }
3667
3668 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3669 err = -EOPNOTSUPP;
3670 goto out;
3671 }
3672
3673 if (!netif_running(dev)) {
3674 err = -ENETDOWN;
3675 goto out;
3676 }
3677
Johannes Berg79c97e92009-07-07 03:56:12 +02003678 wiphy = &rdev->wiphy;
Johannes Berg04a773a2009-04-19 21:24:32 +02003679
3680 if (info->attrs[NL80211_ATTR_MAC])
3681 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3682 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3683 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3684
3685 if (info->attrs[NL80211_ATTR_IE]) {
3686 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3687 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3688 }
3689
3690 ibss.channel = ieee80211_get_channel(wiphy,
3691 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3692 if (!ibss.channel ||
3693 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
3694 ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
3695 err = -EINVAL;
3696 goto out;
3697 }
3698
3699 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
Johannes Bergfffd0932009-07-08 14:22:54 +02003700 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
Johannes Berg04a773a2009-04-19 21:24:32 +02003701
Johannes Bergfffd0932009-07-08 14:22:54 +02003702 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
3703 connkeys = nl80211_parse_connkeys(rdev,
3704 info->attrs[NL80211_ATTR_KEYS]);
3705 if (IS_ERR(connkeys)) {
3706 err = PTR_ERR(connkeys);
3707 connkeys = NULL;
3708 goto out;
3709 }
3710 }
3711
3712 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
Johannes Berg04a773a2009-04-19 21:24:32 +02003713
3714out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003715 cfg80211_unlock_rdev(rdev);
Johannes Berg04a773a2009-04-19 21:24:32 +02003716 dev_put(dev);
3717unlock_rtnl:
Johannes Bergfffd0932009-07-08 14:22:54 +02003718 if (err)
3719 kfree(connkeys);
Johannes Berg04a773a2009-04-19 21:24:32 +02003720 rtnl_unlock();
3721 return err;
3722}
3723
3724static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
3725{
Johannes Berg79c97e92009-07-07 03:56:12 +02003726 struct cfg80211_registered_device *rdev;
Johannes Berg04a773a2009-04-19 21:24:32 +02003727 struct net_device *dev;
3728 int err;
3729
3730 rtnl_lock();
3731
Johannes Berg463d0182009-07-14 00:33:35 +02003732 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Johannes Berg04a773a2009-04-19 21:24:32 +02003733 if (err)
3734 goto unlock_rtnl;
3735
Johannes Berg79c97e92009-07-07 03:56:12 +02003736 if (!rdev->ops->leave_ibss) {
Johannes Berg04a773a2009-04-19 21:24:32 +02003737 err = -EOPNOTSUPP;
3738 goto out;
3739 }
3740
3741 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3742 err = -EOPNOTSUPP;
3743 goto out;
3744 }
3745
3746 if (!netif_running(dev)) {
3747 err = -ENETDOWN;
3748 goto out;
3749 }
3750
Johannes Berg79c97e92009-07-07 03:56:12 +02003751 err = cfg80211_leave_ibss(rdev, dev, false);
Johannes Berg04a773a2009-04-19 21:24:32 +02003752
3753out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003754 cfg80211_unlock_rdev(rdev);
Johannes Berg04a773a2009-04-19 21:24:32 +02003755 dev_put(dev);
3756unlock_rtnl:
3757 rtnl_unlock();
3758 return err;
3759}
3760
Johannes Bergaff89a92009-07-01 21:26:51 +02003761#ifdef CONFIG_NL80211_TESTMODE
3762static struct genl_multicast_group nl80211_testmode_mcgrp = {
3763 .name = "testmode",
3764};
3765
3766static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
3767{
3768 struct cfg80211_registered_device *rdev;
3769 int err;
3770
3771 if (!info->attrs[NL80211_ATTR_TESTDATA])
3772 return -EINVAL;
3773
3774 rtnl_lock();
3775
3776 rdev = cfg80211_get_dev_from_info(info);
3777 if (IS_ERR(rdev)) {
3778 err = PTR_ERR(rdev);
3779 goto unlock_rtnl;
3780 }
3781
3782 err = -EOPNOTSUPP;
3783 if (rdev->ops->testmode_cmd) {
3784 rdev->testmode_info = info;
3785 err = rdev->ops->testmode_cmd(&rdev->wiphy,
3786 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
3787 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
3788 rdev->testmode_info = NULL;
3789 }
3790
Johannes Berg4d0c8ae2009-07-07 03:56:09 +02003791 cfg80211_unlock_rdev(rdev);
Johannes Bergaff89a92009-07-01 21:26:51 +02003792
3793 unlock_rtnl:
3794 rtnl_unlock();
3795 return err;
3796}
3797
3798static struct sk_buff *
3799__cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
3800 int approxlen, u32 pid, u32 seq, gfp_t gfp)
3801{
3802 struct sk_buff *skb;
3803 void *hdr;
3804 struct nlattr *data;
3805
3806 skb = nlmsg_new(approxlen + 100, gfp);
3807 if (!skb)
3808 return NULL;
3809
3810 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
3811 if (!hdr) {
3812 kfree_skb(skb);
3813 return NULL;
3814 }
3815
3816 NLA_PUT_U32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3817 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
3818
3819 ((void **)skb->cb)[0] = rdev;
3820 ((void **)skb->cb)[1] = hdr;
3821 ((void **)skb->cb)[2] = data;
3822
3823 return skb;
3824
3825 nla_put_failure:
3826 kfree_skb(skb);
3827 return NULL;
3828}
3829
3830struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
3831 int approxlen)
3832{
3833 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3834
3835 if (WARN_ON(!rdev->testmode_info))
3836 return NULL;
3837
3838 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
3839 rdev->testmode_info->snd_pid,
3840 rdev->testmode_info->snd_seq,
3841 GFP_KERNEL);
3842}
3843EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
3844
3845int cfg80211_testmode_reply(struct sk_buff *skb)
3846{
3847 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
3848 void *hdr = ((void **)skb->cb)[1];
3849 struct nlattr *data = ((void **)skb->cb)[2];
3850
3851 if (WARN_ON(!rdev->testmode_info)) {
3852 kfree_skb(skb);
3853 return -EINVAL;
3854 }
3855
3856 nla_nest_end(skb, data);
3857 genlmsg_end(skb, hdr);
3858 return genlmsg_reply(skb, rdev->testmode_info);
3859}
3860EXPORT_SYMBOL(cfg80211_testmode_reply);
3861
3862struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
3863 int approxlen, gfp_t gfp)
3864{
3865 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3866
3867 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
3868}
3869EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
3870
3871void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
3872{
3873 void *hdr = ((void **)skb->cb)[1];
3874 struct nlattr *data = ((void **)skb->cb)[2];
3875
3876 nla_nest_end(skb, data);
3877 genlmsg_end(skb, hdr);
3878 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
3879}
3880EXPORT_SYMBOL(cfg80211_testmode_event);
3881#endif
3882
Samuel Ortizb23aa672009-07-01 21:26:54 +02003883static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
3884{
Johannes Berg79c97e92009-07-07 03:56:12 +02003885 struct cfg80211_registered_device *rdev;
Samuel Ortizb23aa672009-07-01 21:26:54 +02003886 struct net_device *dev;
3887 struct cfg80211_connect_params connect;
3888 struct wiphy *wiphy;
Johannes Bergfffd0932009-07-08 14:22:54 +02003889 struct cfg80211_cached_keys *connkeys = NULL;
Samuel Ortizb23aa672009-07-01 21:26:54 +02003890 int err;
3891
3892 memset(&connect, 0, sizeof(connect));
3893
3894 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3895 return -EINVAL;
3896
3897 if (!info->attrs[NL80211_ATTR_SSID] ||
3898 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3899 return -EINVAL;
3900
3901 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3902 connect.auth_type =
3903 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3904 if (!nl80211_valid_auth_type(connect.auth_type))
3905 return -EINVAL;
3906 } else
3907 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3908
3909 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
3910
Johannes Berg3dc27d22009-07-02 21:36:37 +02003911 err = nl80211_crypto_settings(info, &connect.crypto,
3912 NL80211_MAX_NR_CIPHER_SUITES);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003913 if (err)
3914 return err;
3915 rtnl_lock();
3916
Johannes Berg463d0182009-07-14 00:33:35 +02003917 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003918 if (err)
3919 goto unlock_rtnl;
3920
3921 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3922 err = -EOPNOTSUPP;
3923 goto out;
3924 }
3925
3926 if (!netif_running(dev)) {
3927 err = -ENETDOWN;
3928 goto out;
3929 }
3930
Johannes Berg79c97e92009-07-07 03:56:12 +02003931 wiphy = &rdev->wiphy;
Samuel Ortizb23aa672009-07-01 21:26:54 +02003932
Samuel Ortizb23aa672009-07-01 21:26:54 +02003933 if (info->attrs[NL80211_ATTR_MAC])
3934 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3935 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3936 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3937
3938 if (info->attrs[NL80211_ATTR_IE]) {
3939 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3940 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3941 }
3942
3943 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3944 connect.channel =
3945 ieee80211_get_channel(wiphy,
3946 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3947 if (!connect.channel ||
3948 connect.channel->flags & IEEE80211_CHAN_DISABLED) {
3949 err = -EINVAL;
3950 goto out;
3951 }
3952 }
3953
Johannes Bergfffd0932009-07-08 14:22:54 +02003954 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
3955 connkeys = nl80211_parse_connkeys(rdev,
3956 info->attrs[NL80211_ATTR_KEYS]);
3957 if (IS_ERR(connkeys)) {
3958 err = PTR_ERR(connkeys);
3959 connkeys = NULL;
3960 goto out;
3961 }
3962 }
3963
3964 err = cfg80211_connect(rdev, dev, &connect, connkeys);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003965
3966out:
Johannes Berg79c97e92009-07-07 03:56:12 +02003967 cfg80211_unlock_rdev(rdev);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003968 dev_put(dev);
3969unlock_rtnl:
Johannes Bergfffd0932009-07-08 14:22:54 +02003970 if (err)
3971 kfree(connkeys);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003972 rtnl_unlock();
3973 return err;
3974}
3975
3976static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
3977{
Johannes Berg79c97e92009-07-07 03:56:12 +02003978 struct cfg80211_registered_device *rdev;
Samuel Ortizb23aa672009-07-01 21:26:54 +02003979 struct net_device *dev;
3980 int err;
3981 u16 reason;
3982
3983 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3984 reason = WLAN_REASON_DEAUTH_LEAVING;
3985 else
3986 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3987
3988 if (reason == 0)
3989 return -EINVAL;
3990
3991 rtnl_lock();
3992
Johannes Berg463d0182009-07-14 00:33:35 +02003993 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
Samuel Ortizb23aa672009-07-01 21:26:54 +02003994 if (err)
3995 goto unlock_rtnl;
3996
3997 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3998 err = -EOPNOTSUPP;
3999 goto out;
4000 }
4001
4002 if (!netif_running(dev)) {
4003 err = -ENETDOWN;
4004 goto out;
4005 }
4006
Johannes Berg79c97e92009-07-07 03:56:12 +02004007 err = cfg80211_disconnect(rdev, dev, reason, true);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004008
4009out:
Johannes Berg79c97e92009-07-07 03:56:12 +02004010 cfg80211_unlock_rdev(rdev);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004011 dev_put(dev);
4012unlock_rtnl:
4013 rtnl_unlock();
4014 return err;
4015}
4016
Johannes Berg463d0182009-07-14 00:33:35 +02004017static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
4018{
4019 struct cfg80211_registered_device *rdev;
4020 struct net *net;
4021 int err;
4022 u32 pid;
4023
4024 if (!info->attrs[NL80211_ATTR_PID])
4025 return -EINVAL;
4026
4027 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
4028
4029 rtnl_lock();
4030
4031 rdev = cfg80211_get_dev_from_info(info);
4032 if (IS_ERR(rdev)) {
4033 err = PTR_ERR(rdev);
4034 goto out;
4035 }
4036
4037 net = get_net_ns_by_pid(pid);
4038 if (IS_ERR(net)) {
4039 err = PTR_ERR(net);
4040 goto out;
4041 }
4042
4043 err = 0;
4044
4045 /* check if anything to do */
4046 if (net_eq(wiphy_net(&rdev->wiphy), net))
4047 goto out_put_net;
4048
4049 err = cfg80211_switch_netns(rdev, net);
4050 out_put_net:
4051 put_net(net);
4052 out:
4053 cfg80211_unlock_rdev(rdev);
4054 rtnl_unlock();
4055 return err;
4056}
4057
Johannes Berg55682962007-09-20 13:09:35 -04004058static struct genl_ops nl80211_ops[] = {
4059 {
4060 .cmd = NL80211_CMD_GET_WIPHY,
4061 .doit = nl80211_get_wiphy,
4062 .dumpit = nl80211_dump_wiphy,
4063 .policy = nl80211_policy,
4064 /* can be retrieved by unprivileged users */
4065 },
4066 {
4067 .cmd = NL80211_CMD_SET_WIPHY,
4068 .doit = nl80211_set_wiphy,
4069 .policy = nl80211_policy,
4070 .flags = GENL_ADMIN_PERM,
4071 },
4072 {
4073 .cmd = NL80211_CMD_GET_INTERFACE,
4074 .doit = nl80211_get_interface,
4075 .dumpit = nl80211_dump_interface,
4076 .policy = nl80211_policy,
4077 /* can be retrieved by unprivileged users */
4078 },
4079 {
4080 .cmd = NL80211_CMD_SET_INTERFACE,
4081 .doit = nl80211_set_interface,
4082 .policy = nl80211_policy,
4083 .flags = GENL_ADMIN_PERM,
4084 },
4085 {
4086 .cmd = NL80211_CMD_NEW_INTERFACE,
4087 .doit = nl80211_new_interface,
4088 .policy = nl80211_policy,
4089 .flags = GENL_ADMIN_PERM,
4090 },
4091 {
4092 .cmd = NL80211_CMD_DEL_INTERFACE,
4093 .doit = nl80211_del_interface,
4094 .policy = nl80211_policy,
4095 .flags = GENL_ADMIN_PERM,
4096 },
Johannes Berg41ade002007-12-19 02:03:29 +01004097 {
4098 .cmd = NL80211_CMD_GET_KEY,
4099 .doit = nl80211_get_key,
4100 .policy = nl80211_policy,
4101 .flags = GENL_ADMIN_PERM,
4102 },
4103 {
4104 .cmd = NL80211_CMD_SET_KEY,
4105 .doit = nl80211_set_key,
4106 .policy = nl80211_policy,
4107 .flags = GENL_ADMIN_PERM,
4108 },
4109 {
4110 .cmd = NL80211_CMD_NEW_KEY,
4111 .doit = nl80211_new_key,
4112 .policy = nl80211_policy,
4113 .flags = GENL_ADMIN_PERM,
4114 },
4115 {
4116 .cmd = NL80211_CMD_DEL_KEY,
4117 .doit = nl80211_del_key,
4118 .policy = nl80211_policy,
4119 .flags = GENL_ADMIN_PERM,
4120 },
Johannes Berged1b6cc2007-12-19 02:03:32 +01004121 {
4122 .cmd = NL80211_CMD_SET_BEACON,
4123 .policy = nl80211_policy,
4124 .flags = GENL_ADMIN_PERM,
4125 .doit = nl80211_addset_beacon,
4126 },
4127 {
4128 .cmd = NL80211_CMD_NEW_BEACON,
4129 .policy = nl80211_policy,
4130 .flags = GENL_ADMIN_PERM,
4131 .doit = nl80211_addset_beacon,
4132 },
4133 {
4134 .cmd = NL80211_CMD_DEL_BEACON,
4135 .policy = nl80211_policy,
4136 .flags = GENL_ADMIN_PERM,
4137 .doit = nl80211_del_beacon,
4138 },
Johannes Berg5727ef12007-12-19 02:03:34 +01004139 {
4140 .cmd = NL80211_CMD_GET_STATION,
4141 .doit = nl80211_get_station,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01004142 .dumpit = nl80211_dump_station,
Johannes Berg5727ef12007-12-19 02:03:34 +01004143 .policy = nl80211_policy,
Johannes Berg5727ef12007-12-19 02:03:34 +01004144 },
4145 {
4146 .cmd = NL80211_CMD_SET_STATION,
4147 .doit = nl80211_set_station,
4148 .policy = nl80211_policy,
4149 .flags = GENL_ADMIN_PERM,
4150 },
4151 {
4152 .cmd = NL80211_CMD_NEW_STATION,
4153 .doit = nl80211_new_station,
4154 .policy = nl80211_policy,
4155 .flags = GENL_ADMIN_PERM,
4156 },
4157 {
4158 .cmd = NL80211_CMD_DEL_STATION,
4159 .doit = nl80211_del_station,
4160 .policy = nl80211_policy,
4161 .flags = GENL_ADMIN_PERM,
4162 },
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +01004163 {
4164 .cmd = NL80211_CMD_GET_MPATH,
4165 .doit = nl80211_get_mpath,
4166 .dumpit = nl80211_dump_mpath,
4167 .policy = nl80211_policy,
4168 .flags = GENL_ADMIN_PERM,
4169 },
4170 {
4171 .cmd = NL80211_CMD_SET_MPATH,
4172 .doit = nl80211_set_mpath,
4173 .policy = nl80211_policy,
4174 .flags = GENL_ADMIN_PERM,
4175 },
4176 {
4177 .cmd = NL80211_CMD_NEW_MPATH,
4178 .doit = nl80211_new_mpath,
4179 .policy = nl80211_policy,
4180 .flags = GENL_ADMIN_PERM,
4181 },
4182 {
4183 .cmd = NL80211_CMD_DEL_MPATH,
4184 .doit = nl80211_del_mpath,
4185 .policy = nl80211_policy,
4186 .flags = GENL_ADMIN_PERM,
4187 },
Jouni Malinen9f1ba902008-08-07 20:07:01 +03004188 {
4189 .cmd = NL80211_CMD_SET_BSS,
4190 .doit = nl80211_set_bss,
4191 .policy = nl80211_policy,
4192 .flags = GENL_ADMIN_PERM,
4193 },
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07004194 {
Luis R. Rodriguezf1303472009-01-30 09:26:42 -08004195 .cmd = NL80211_CMD_GET_REG,
4196 .doit = nl80211_get_reg,
4197 .policy = nl80211_policy,
4198 /* can be retrieved by unprivileged users */
4199 },
4200 {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07004201 .cmd = NL80211_CMD_SET_REG,
4202 .doit = nl80211_set_reg,
4203 .policy = nl80211_policy,
4204 .flags = GENL_ADMIN_PERM,
4205 },
4206 {
4207 .cmd = NL80211_CMD_REQ_SET_REG,
4208 .doit = nl80211_req_set_reg,
4209 .policy = nl80211_policy,
4210 .flags = GENL_ADMIN_PERM,
4211 },
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07004212 {
4213 .cmd = NL80211_CMD_GET_MESH_PARAMS,
4214 .doit = nl80211_get_mesh_params,
4215 .policy = nl80211_policy,
4216 /* can be retrieved by unprivileged users */
4217 },
4218 {
4219 .cmd = NL80211_CMD_SET_MESH_PARAMS,
4220 .doit = nl80211_set_mesh_params,
4221 .policy = nl80211_policy,
4222 .flags = GENL_ADMIN_PERM,
4223 },
Jouni Malinen9aed3cc2009-01-13 16:03:29 +02004224 {
Johannes Berg2a519312009-02-10 21:25:55 +01004225 .cmd = NL80211_CMD_TRIGGER_SCAN,
4226 .doit = nl80211_trigger_scan,
4227 .policy = nl80211_policy,
4228 .flags = GENL_ADMIN_PERM,
4229 },
4230 {
4231 .cmd = NL80211_CMD_GET_SCAN,
4232 .policy = nl80211_policy,
4233 .dumpit = nl80211_dump_scan,
4234 },
Jouni Malinen636a5d32009-03-19 13:39:22 +02004235 {
4236 .cmd = NL80211_CMD_AUTHENTICATE,
4237 .doit = nl80211_authenticate,
4238 .policy = nl80211_policy,
4239 .flags = GENL_ADMIN_PERM,
4240 },
4241 {
4242 .cmd = NL80211_CMD_ASSOCIATE,
4243 .doit = nl80211_associate,
4244 .policy = nl80211_policy,
4245 .flags = GENL_ADMIN_PERM,
4246 },
4247 {
4248 .cmd = NL80211_CMD_DEAUTHENTICATE,
4249 .doit = nl80211_deauthenticate,
4250 .policy = nl80211_policy,
4251 .flags = GENL_ADMIN_PERM,
4252 },
4253 {
4254 .cmd = NL80211_CMD_DISASSOCIATE,
4255 .doit = nl80211_disassociate,
4256 .policy = nl80211_policy,
4257 .flags = GENL_ADMIN_PERM,
4258 },
Johannes Berg04a773a2009-04-19 21:24:32 +02004259 {
4260 .cmd = NL80211_CMD_JOIN_IBSS,
4261 .doit = nl80211_join_ibss,
4262 .policy = nl80211_policy,
4263 .flags = GENL_ADMIN_PERM,
4264 },
4265 {
4266 .cmd = NL80211_CMD_LEAVE_IBSS,
4267 .doit = nl80211_leave_ibss,
4268 .policy = nl80211_policy,
4269 .flags = GENL_ADMIN_PERM,
4270 },
Johannes Bergaff89a92009-07-01 21:26:51 +02004271#ifdef CONFIG_NL80211_TESTMODE
4272 {
4273 .cmd = NL80211_CMD_TESTMODE,
4274 .doit = nl80211_testmode_do,
4275 .policy = nl80211_policy,
4276 .flags = GENL_ADMIN_PERM,
4277 },
4278#endif
Samuel Ortizb23aa672009-07-01 21:26:54 +02004279 {
4280 .cmd = NL80211_CMD_CONNECT,
4281 .doit = nl80211_connect,
4282 .policy = nl80211_policy,
4283 .flags = GENL_ADMIN_PERM,
4284 },
4285 {
4286 .cmd = NL80211_CMD_DISCONNECT,
4287 .doit = nl80211_disconnect,
4288 .policy = nl80211_policy,
4289 .flags = GENL_ADMIN_PERM,
4290 },
Johannes Berg463d0182009-07-14 00:33:35 +02004291 {
4292 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
4293 .doit = nl80211_wiphy_netns,
4294 .policy = nl80211_policy,
4295 .flags = GENL_ADMIN_PERM,
4296 },
Johannes Berg55682962007-09-20 13:09:35 -04004297};
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004298static struct genl_multicast_group nl80211_mlme_mcgrp = {
4299 .name = "mlme",
4300};
Johannes Berg55682962007-09-20 13:09:35 -04004301
4302/* multicast groups */
4303static struct genl_multicast_group nl80211_config_mcgrp = {
4304 .name = "config",
4305};
Johannes Berg2a519312009-02-10 21:25:55 +01004306static struct genl_multicast_group nl80211_scan_mcgrp = {
4307 .name = "scan",
4308};
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04004309static struct genl_multicast_group nl80211_regulatory_mcgrp = {
4310 .name = "regulatory",
4311};
Johannes Berg55682962007-09-20 13:09:35 -04004312
4313/* notification functions */
4314
4315void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
4316{
4317 struct sk_buff *msg;
4318
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004319 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg55682962007-09-20 13:09:35 -04004320 if (!msg)
4321 return;
4322
4323 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
4324 nlmsg_free(msg);
4325 return;
4326 }
4327
Johannes Berg463d0182009-07-14 00:33:35 +02004328 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4329 nl80211_config_mcgrp.id, GFP_KERNEL);
Johannes Berg55682962007-09-20 13:09:35 -04004330}
4331
Johannes Berg362a4152009-05-24 16:43:15 +02004332static int nl80211_add_scan_req(struct sk_buff *msg,
4333 struct cfg80211_registered_device *rdev)
4334{
4335 struct cfg80211_scan_request *req = rdev->scan_req;
4336 struct nlattr *nest;
4337 int i;
4338
Johannes Berg667503dd2009-07-07 03:56:11 +02004339 ASSERT_RDEV_LOCK(rdev);
4340
Johannes Berg362a4152009-05-24 16:43:15 +02004341 if (WARN_ON(!req))
4342 return 0;
4343
4344 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
4345 if (!nest)
4346 goto nla_put_failure;
4347 for (i = 0; i < req->n_ssids; i++)
4348 NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid);
4349 nla_nest_end(msg, nest);
4350
4351 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
4352 if (!nest)
4353 goto nla_put_failure;
4354 for (i = 0; i < req->n_channels; i++)
4355 NLA_PUT_U32(msg, i, req->channels[i]->center_freq);
4356 nla_nest_end(msg, nest);
4357
4358 if (req->ie)
4359 NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie);
4360
4361 return 0;
4362 nla_put_failure:
4363 return -ENOBUFS;
4364}
4365
Johannes Berga538e2d2009-06-16 19:56:42 +02004366static int nl80211_send_scan_msg(struct sk_buff *msg,
4367 struct cfg80211_registered_device *rdev,
4368 struct net_device *netdev,
4369 u32 pid, u32 seq, int flags,
4370 u32 cmd)
Johannes Berg2a519312009-02-10 21:25:55 +01004371{
4372 void *hdr;
4373
4374 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
4375 if (!hdr)
4376 return -1;
4377
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -05004378 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
Johannes Berg2a519312009-02-10 21:25:55 +01004379 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4380
Johannes Berg362a4152009-05-24 16:43:15 +02004381 /* ignore errors and send incomplete event anyway */
4382 nl80211_add_scan_req(msg, rdev);
Johannes Berg2a519312009-02-10 21:25:55 +01004383
4384 return genlmsg_end(msg, hdr);
4385
4386 nla_put_failure:
4387 genlmsg_cancel(msg, hdr);
4388 return -EMSGSIZE;
4389}
4390
Johannes Berga538e2d2009-06-16 19:56:42 +02004391void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
4392 struct net_device *netdev)
4393{
4394 struct sk_buff *msg;
4395
4396 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4397 if (!msg)
4398 return;
4399
4400 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4401 NL80211_CMD_TRIGGER_SCAN) < 0) {
4402 nlmsg_free(msg);
4403 return;
4404 }
4405
Johannes Berg463d0182009-07-14 00:33:35 +02004406 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4407 nl80211_scan_mcgrp.id, GFP_KERNEL);
Johannes Berga538e2d2009-06-16 19:56:42 +02004408}
4409
Johannes Berg2a519312009-02-10 21:25:55 +01004410void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
4411 struct net_device *netdev)
4412{
4413 struct sk_buff *msg;
4414
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004415 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg2a519312009-02-10 21:25:55 +01004416 if (!msg)
4417 return;
4418
Johannes Berga538e2d2009-06-16 19:56:42 +02004419 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4420 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
Johannes Berg2a519312009-02-10 21:25:55 +01004421 nlmsg_free(msg);
4422 return;
4423 }
4424
Johannes Berg463d0182009-07-14 00:33:35 +02004425 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4426 nl80211_scan_mcgrp.id, GFP_KERNEL);
Johannes Berg2a519312009-02-10 21:25:55 +01004427}
4428
4429void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
4430 struct net_device *netdev)
4431{
4432 struct sk_buff *msg;
4433
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004434 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Johannes Berg2a519312009-02-10 21:25:55 +01004435 if (!msg)
4436 return;
4437
Johannes Berga538e2d2009-06-16 19:56:42 +02004438 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4439 NL80211_CMD_SCAN_ABORTED) < 0) {
Johannes Berg2a519312009-02-10 21:25:55 +01004440 nlmsg_free(msg);
4441 return;
4442 }
4443
Johannes Berg463d0182009-07-14 00:33:35 +02004444 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4445 nl80211_scan_mcgrp.id, GFP_KERNEL);
Johannes Berg2a519312009-02-10 21:25:55 +01004446}
4447
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04004448/*
4449 * This can happen on global regulatory changes or device specific settings
4450 * based on custom world regulatory domains.
4451 */
4452void nl80211_send_reg_change_event(struct regulatory_request *request)
4453{
4454 struct sk_buff *msg;
4455 void *hdr;
4456
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004457 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04004458 if (!msg)
4459 return;
4460
4461 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
4462 if (!hdr) {
4463 nlmsg_free(msg);
4464 return;
4465 }
4466
4467 /* Userspace can always count this one always being set */
4468 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
4469
4470 if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
4471 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4472 NL80211_REGDOM_TYPE_WORLD);
4473 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
4474 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4475 NL80211_REGDOM_TYPE_CUSTOM_WORLD);
4476 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
4477 request->intersect)
4478 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4479 NL80211_REGDOM_TYPE_INTERSECTION);
4480 else {
4481 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4482 NL80211_REGDOM_TYPE_COUNTRY);
4483 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
4484 }
4485
4486 if (wiphy_idx_valid(request->wiphy_idx))
4487 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
4488
4489 if (genlmsg_end(msg, hdr) < 0) {
4490 nlmsg_free(msg);
4491 return;
4492 }
4493
Johannes Bergbc43b282009-07-25 10:54:13 +02004494 rcu_read_lock();
Johannes Berg463d0182009-07-14 00:33:35 +02004495 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
Johannes Bergbc43b282009-07-25 10:54:13 +02004496 GFP_ATOMIC);
4497 rcu_read_unlock();
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04004498
4499 return;
4500
4501nla_put_failure:
4502 genlmsg_cancel(msg, hdr);
4503 nlmsg_free(msg);
4504}
4505
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004506static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
4507 struct net_device *netdev,
4508 const u8 *buf, size_t len,
Johannes Berge6d6e342009-07-01 21:26:47 +02004509 enum nl80211_commands cmd, gfp_t gfp)
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004510{
4511 struct sk_buff *msg;
4512 void *hdr;
4513
Johannes Berge6d6e342009-07-01 21:26:47 +02004514 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004515 if (!msg)
4516 return;
4517
4518 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4519 if (!hdr) {
4520 nlmsg_free(msg);
4521 return;
4522 }
4523
4524 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4525 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4526 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
4527
4528 if (genlmsg_end(msg, hdr) < 0) {
4529 nlmsg_free(msg);
4530 return;
4531 }
4532
Johannes Berg463d0182009-07-14 00:33:35 +02004533 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4534 nl80211_mlme_mcgrp.id, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004535 return;
4536
4537 nla_put_failure:
4538 genlmsg_cancel(msg, hdr);
4539 nlmsg_free(msg);
4540}
4541
4542void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
Johannes Berge6d6e342009-07-01 21:26:47 +02004543 struct net_device *netdev, const u8 *buf,
4544 size_t len, gfp_t gfp)
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004545{
4546 nl80211_send_mlme_event(rdev, netdev, buf, len,
Johannes Berge6d6e342009-07-01 21:26:47 +02004547 NL80211_CMD_AUTHENTICATE, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004548}
4549
4550void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
4551 struct net_device *netdev, const u8 *buf,
Johannes Berge6d6e342009-07-01 21:26:47 +02004552 size_t len, gfp_t gfp)
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004553{
Johannes Berge6d6e342009-07-01 21:26:47 +02004554 nl80211_send_mlme_event(rdev, netdev, buf, len,
4555 NL80211_CMD_ASSOCIATE, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004556}
4557
Jouni Malinen53b46b82009-03-27 20:53:56 +02004558void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
Johannes Berge6d6e342009-07-01 21:26:47 +02004559 struct net_device *netdev, const u8 *buf,
4560 size_t len, gfp_t gfp)
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004561{
4562 nl80211_send_mlme_event(rdev, netdev, buf, len,
Johannes Berge6d6e342009-07-01 21:26:47 +02004563 NL80211_CMD_DEAUTHENTICATE, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004564}
4565
Jouni Malinen53b46b82009-03-27 20:53:56 +02004566void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
4567 struct net_device *netdev, const u8 *buf,
Johannes Berge6d6e342009-07-01 21:26:47 +02004568 size_t len, gfp_t gfp)
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004569{
4570 nl80211_send_mlme_event(rdev, netdev, buf, len,
Johannes Berge6d6e342009-07-01 21:26:47 +02004571 NL80211_CMD_DISASSOCIATE, gfp);
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004572}
4573
Luis R. Rodriguez1b06bb42009-05-02 00:34:48 -04004574static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
4575 struct net_device *netdev, int cmd,
Johannes Berge6d6e342009-07-01 21:26:47 +02004576 const u8 *addr, gfp_t gfp)
Jouni Malinen1965c852009-04-22 21:38:25 +03004577{
4578 struct sk_buff *msg;
4579 void *hdr;
4580
Johannes Berge6d6e342009-07-01 21:26:47 +02004581 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
Jouni Malinen1965c852009-04-22 21:38:25 +03004582 if (!msg)
4583 return;
4584
4585 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4586 if (!hdr) {
4587 nlmsg_free(msg);
4588 return;
4589 }
4590
4591 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4592 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4593 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
4594 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4595
4596 if (genlmsg_end(msg, hdr) < 0) {
4597 nlmsg_free(msg);
4598 return;
4599 }
4600
Johannes Berg463d0182009-07-14 00:33:35 +02004601 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4602 nl80211_mlme_mcgrp.id, gfp);
Jouni Malinen1965c852009-04-22 21:38:25 +03004603 return;
4604
4605 nla_put_failure:
4606 genlmsg_cancel(msg, hdr);
4607 nlmsg_free(msg);
4608}
4609
4610void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
Johannes Berge6d6e342009-07-01 21:26:47 +02004611 struct net_device *netdev, const u8 *addr,
4612 gfp_t gfp)
Jouni Malinen1965c852009-04-22 21:38:25 +03004613{
4614 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
Johannes Berge6d6e342009-07-01 21:26:47 +02004615 addr, gfp);
Jouni Malinen1965c852009-04-22 21:38:25 +03004616}
4617
4618void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
Johannes Berge6d6e342009-07-01 21:26:47 +02004619 struct net_device *netdev, const u8 *addr,
4620 gfp_t gfp)
Jouni Malinen1965c852009-04-22 21:38:25 +03004621{
Johannes Berge6d6e342009-07-01 21:26:47 +02004622 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
4623 addr, gfp);
Jouni Malinen1965c852009-04-22 21:38:25 +03004624}
4625
Samuel Ortizb23aa672009-07-01 21:26:54 +02004626void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
4627 struct net_device *netdev, const u8 *bssid,
4628 const u8 *req_ie, size_t req_ie_len,
4629 const u8 *resp_ie, size_t resp_ie_len,
4630 u16 status, gfp_t gfp)
4631{
4632 struct sk_buff *msg;
4633 void *hdr;
4634
4635 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4636 if (!msg)
4637 return;
4638
4639 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
4640 if (!hdr) {
4641 nlmsg_free(msg);
4642 return;
4643 }
4644
4645 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4646 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4647 if (bssid)
4648 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4649 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status);
4650 if (req_ie)
4651 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4652 if (resp_ie)
4653 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4654
4655 if (genlmsg_end(msg, hdr) < 0) {
4656 nlmsg_free(msg);
4657 return;
4658 }
4659
Johannes Berg463d0182009-07-14 00:33:35 +02004660 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4661 nl80211_mlme_mcgrp.id, gfp);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004662 return;
4663
4664 nla_put_failure:
4665 genlmsg_cancel(msg, hdr);
4666 nlmsg_free(msg);
4667
4668}
4669
4670void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
4671 struct net_device *netdev, const u8 *bssid,
4672 const u8 *req_ie, size_t req_ie_len,
4673 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
4674{
4675 struct sk_buff *msg;
4676 void *hdr;
4677
4678 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4679 if (!msg)
4680 return;
4681
4682 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
4683 if (!hdr) {
4684 nlmsg_free(msg);
4685 return;
4686 }
4687
4688 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4689 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4690 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4691 if (req_ie)
4692 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4693 if (resp_ie)
4694 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4695
4696 if (genlmsg_end(msg, hdr) < 0) {
4697 nlmsg_free(msg);
4698 return;
4699 }
4700
Johannes Berg463d0182009-07-14 00:33:35 +02004701 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4702 nl80211_mlme_mcgrp.id, gfp);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004703 return;
4704
4705 nla_put_failure:
4706 genlmsg_cancel(msg, hdr);
4707 nlmsg_free(msg);
4708
4709}
4710
4711void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
4712 struct net_device *netdev, u16 reason,
Johannes Berg667503dd2009-07-07 03:56:11 +02004713 const u8 *ie, size_t ie_len, bool from_ap)
Samuel Ortizb23aa672009-07-01 21:26:54 +02004714{
4715 struct sk_buff *msg;
4716 void *hdr;
4717
Johannes Berg667503dd2009-07-07 03:56:11 +02004718 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004719 if (!msg)
4720 return;
4721
4722 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
4723 if (!hdr) {
4724 nlmsg_free(msg);
4725 return;
4726 }
4727
4728 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4729 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4730 if (from_ap && reason)
4731 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason);
4732 if (from_ap)
4733 NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP);
4734 if (ie)
4735 NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie);
4736
4737 if (genlmsg_end(msg, hdr) < 0) {
4738 nlmsg_free(msg);
4739 return;
4740 }
4741
Johannes Berg463d0182009-07-14 00:33:35 +02004742 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4743 nl80211_mlme_mcgrp.id, GFP_KERNEL);
Samuel Ortizb23aa672009-07-01 21:26:54 +02004744 return;
4745
4746 nla_put_failure:
4747 genlmsg_cancel(msg, hdr);
4748 nlmsg_free(msg);
4749
4750}
4751
Johannes Berg04a773a2009-04-19 21:24:32 +02004752void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
4753 struct net_device *netdev, const u8 *bssid,
4754 gfp_t gfp)
4755{
4756 struct sk_buff *msg;
4757 void *hdr;
4758
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004759 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
Johannes Berg04a773a2009-04-19 21:24:32 +02004760 if (!msg)
4761 return;
4762
4763 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
4764 if (!hdr) {
4765 nlmsg_free(msg);
4766 return;
4767 }
4768
4769 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4770 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4771 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4772
4773 if (genlmsg_end(msg, hdr) < 0) {
4774 nlmsg_free(msg);
4775 return;
4776 }
4777
Johannes Berg463d0182009-07-14 00:33:35 +02004778 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4779 nl80211_mlme_mcgrp.id, gfp);
Johannes Berg04a773a2009-04-19 21:24:32 +02004780 return;
4781
4782 nla_put_failure:
4783 genlmsg_cancel(msg, hdr);
4784 nlmsg_free(msg);
4785}
4786
Jouni Malinena3b8b052009-03-27 21:59:49 +02004787void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
4788 struct net_device *netdev, const u8 *addr,
4789 enum nl80211_key_type key_type, int key_id,
Johannes Berge6d6e342009-07-01 21:26:47 +02004790 const u8 *tsc, gfp_t gfp)
Jouni Malinena3b8b052009-03-27 21:59:49 +02004791{
4792 struct sk_buff *msg;
4793 void *hdr;
4794
Johannes Berge6d6e342009-07-01 21:26:47 +02004795 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +02004796 if (!msg)
4797 return;
4798
4799 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
4800 if (!hdr) {
4801 nlmsg_free(msg);
4802 return;
4803 }
4804
4805 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4806 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4807 if (addr)
4808 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4809 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
4810 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
4811 if (tsc)
4812 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
4813
4814 if (genlmsg_end(msg, hdr) < 0) {
4815 nlmsg_free(msg);
4816 return;
4817 }
4818
Johannes Berg463d0182009-07-14 00:33:35 +02004819 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4820 nl80211_mlme_mcgrp.id, gfp);
Jouni Malinena3b8b052009-03-27 21:59:49 +02004821 return;
4822
4823 nla_put_failure:
4824 genlmsg_cancel(msg, hdr);
4825 nlmsg_free(msg);
4826}
4827
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04004828void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
4829 struct ieee80211_channel *channel_before,
4830 struct ieee80211_channel *channel_after)
4831{
4832 struct sk_buff *msg;
4833 void *hdr;
4834 struct nlattr *nl_freq;
4835
Pablo Neira Ayusofd2120c2009-05-19 15:27:55 -07004836 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04004837 if (!msg)
4838 return;
4839
4840 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
4841 if (!hdr) {
4842 nlmsg_free(msg);
4843 return;
4844 }
4845
4846 /*
4847 * Since we are applying the beacon hint to a wiphy we know its
4848 * wiphy_idx is valid
4849 */
4850 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
4851
4852 /* Before */
4853 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
4854 if (!nl_freq)
4855 goto nla_put_failure;
4856 if (nl80211_msg_put_channel(msg, channel_before))
4857 goto nla_put_failure;
4858 nla_nest_end(msg, nl_freq);
4859
4860 /* After */
4861 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
4862 if (!nl_freq)
4863 goto nla_put_failure;
4864 if (nl80211_msg_put_channel(msg, channel_after))
4865 goto nla_put_failure;
4866 nla_nest_end(msg, nl_freq);
4867
4868 if (genlmsg_end(msg, hdr) < 0) {
4869 nlmsg_free(msg);
4870 return;
4871 }
4872
Johannes Berg463d0182009-07-14 00:33:35 +02004873 rcu_read_lock();
4874 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
4875 GFP_ATOMIC);
4876 rcu_read_unlock();
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04004877
4878 return;
4879
4880nla_put_failure:
4881 genlmsg_cancel(msg, hdr);
4882 nlmsg_free(msg);
4883}
4884
Johannes Berg55682962007-09-20 13:09:35 -04004885/* initialisation/exit functions */
4886
4887int nl80211_init(void)
4888{
Michał Mirosław0d63cbb2009-05-21 10:34:06 +00004889 int err;
Johannes Berg55682962007-09-20 13:09:35 -04004890
Michał Mirosław0d63cbb2009-05-21 10:34:06 +00004891 err = genl_register_family_with_ops(&nl80211_fam,
4892 nl80211_ops, ARRAY_SIZE(nl80211_ops));
Johannes Berg55682962007-09-20 13:09:35 -04004893 if (err)
4894 return err;
4895
Johannes Berg55682962007-09-20 13:09:35 -04004896 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
4897 if (err)
4898 goto err_out;
4899
Johannes Berg2a519312009-02-10 21:25:55 +01004900 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
4901 if (err)
4902 goto err_out;
4903
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04004904 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
4905 if (err)
4906 goto err_out;
4907
Jouni Malinen6039f6d2009-03-19 13:39:21 +02004908 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
4909 if (err)
4910 goto err_out;
4911
Johannes Bergaff89a92009-07-01 21:26:51 +02004912#ifdef CONFIG_NL80211_TESTMODE
4913 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
4914 if (err)
4915 goto err_out;
4916#endif
4917
Johannes Berg55682962007-09-20 13:09:35 -04004918 return 0;
4919 err_out:
4920 genl_unregister_family(&nl80211_fam);
4921 return err;
4922}
4923
4924void nl80211_exit(void)
4925{
4926 genl_unregister_family(&nl80211_fam);
4927}