simplify and fix adm5120 image building, fix broken FEATURES handling
[openwrt.git] / package / mac80211 / src / wireless / nl80211.c
1 /*
2 * This is the new netlink-based wireless configuration interface.
3 *
4 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5 */
6
7 #include <linux/if.h>
8 #include <linux/module.h>
9 #include <linux/err.h>
10 #include <linux/mutex.h>
11 #include <linux/list.h>
12 #include <linux/if_ether.h>
13 #include <linux/ieee80211.h>
14 #include <linux/nl80211.h>
15 #include <linux/rtnetlink.h>
16 #include <net/genetlink.h>
17 #include <net/cfg80211.h>
18 #include "core.h"
19 #include "nl80211.h"
20
21 /* the netlink family */
22 static struct genl_family nl80211_fam = {
23 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
24 .name = "nl80211", /* have users key off the name instead */
25 .hdrsize = 0, /* no private header */
26 .version = 1, /* no particular meaning now */
27 .maxattr = NL80211_ATTR_MAX,
28 };
29
30 /* internal helper: validate an information element attribute */
31 static int check_information_element(struct nlattr *nla)
32 {
33 int len = nla_len(nla);
34 u8 *data = nla_data(nla);
35 int elementlen;
36
37 while (len >= 2) {
38 /* 1 byte ID, 1 byte len, `len' bytes data */
39 elementlen = *(data+1) + 2;
40 data += elementlen;
41 len -= elementlen;
42 }
43 return len ? -EINVAL : 0;
44 }
45
46 /* internal helper: get drv and dev */
47 static int get_drv_dev_by_info_ifindex(struct genl_info *info,
48 struct cfg80211_registered_device **drv,
49 struct net_device **dev)
50 {
51 int ifindex;
52
53 if (!info->attrs[NL80211_ATTR_IFINDEX])
54 return -EINVAL;
55
56 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
57 *dev = dev_get_by_index(ifindex);
58 if (!dev)
59 return -ENODEV;
60
61 *drv = cfg80211_get_dev_from_ifindex(ifindex);
62 if (IS_ERR(*drv)) {
63 dev_put(*dev);
64 return PTR_ERR(*drv);
65 }
66
67 return 0;
68 }
69
70 /* policy for the attributes */
71 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
72 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
73 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
74 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
75 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
76 .len = BUS_ID_SIZE-1 },
77 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
78 [NL80211_ATTR_BSSID] = { .len = ETH_ALEN },
79 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
80 .len = IEEE80211_MAX_SSID_LEN },
81 [NL80211_ATTR_CHANNEL] = { .type = NLA_U32 },
82 [NL80211_ATTR_PHYMODE] = { .type = NLA_U32 },
83 [NL80211_ATTR_CHANNEL_LIST] = { .type = NLA_NESTED },
84 [NL80211_ATTR_BSS_LIST] = { .type = NLA_NESTED },
85 [NL80211_ATTR_BSSTYPE] = { .type = NLA_U32 },
86 [NL80211_ATTR_BEACON_PERIOD] = { .type = NLA_U32 },
87 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
88 [NL80211_ATTR_TIMESTAMP] = { .type = NLA_U64 },
89 [NL80211_ATTR_IE] = { .type = NLA_BINARY, .len = NL80211_MAX_IE_LEN },
90 [NL80211_ATTR_AUTH_ALGORITHM] = { .type = NLA_U32 },
91 [NL80211_ATTR_TIMEOUT_TU] = { .type = NLA_U32 },
92 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U32 },
93 [NL80211_ATTR_ASSOCIATION_ID] = { .type = NLA_U16 },
94 [NL80211_ATTR_DEAUTHENTICATED] = { .type = NLA_FLAG },
95 [NL80211_ATTR_RX_SENSITIVITY] = { .type = NLA_U32 },
96 [NL80211_ATTR_TRANSMIT_POWER] = { .type = NLA_U32 },
97 [NL80211_ATTR_FRAG_THRESHOLD] = { .type = NLA_U32 },
98 [NL80211_ATTR_FLAG_SCAN_ACTIVE] = { .type = NLA_FLAG },
99 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY },
100 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY },
101 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
102 .len = WLAN_MAX_KEY_LEN },
103 [NL80211_ATTR_KEY_ID] = { .type = NLA_U32 },
104 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
105 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
106 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
107 };
108
109 /* netlink command implementations */
110
111 #define CHECK_CMD(ptr, cmd) \
112 if (drv->ops->ptr) \
113 NLA_PUT_FLAG(msg, NL80211_CMD_##cmd);
114
115 static int nl80211_get_cmdlist(struct sk_buff *skb, struct genl_info *info)
116 {
117 struct cfg80211_registered_device *drv;
118 struct sk_buff *msg;
119 void *hdr;
120 int err;
121 struct nlattr *start;
122
123 drv = cfg80211_get_dev_from_info(info);
124 if (IS_ERR(drv))
125 return PTR_ERR(drv);
126
127 hdr = nl80211msg_new(&msg, info->snd_pid, info->snd_seq, 0,
128 NL80211_CMD_NEW_CMDLIST);
129 if (IS_ERR(hdr)) {
130 err = PTR_ERR(hdr);
131 goto put_drv;
132 }
133
134 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, drv->idx);
135
136 start = nla_nest_start(msg, NL80211_ATTR_CMDS);
137 if (!start)
138 goto nla_put_failure;
139
140 /* unconditionally allow some common commands we handle centrally
141 * or where we require the implementation */
142 NLA_PUT_FLAG(msg, NL80211_CMD_GET_CMDLIST);
143 NLA_PUT_FLAG(msg, NL80211_CMD_GET_WIPHYS);
144 NLA_PUT_FLAG(msg, NL80211_CMD_GET_INTERFACES);
145 NLA_PUT_FLAG(msg, NL80211_CMD_RENAME_WIPHY);
146
147 CHECK_CMD(add_virtual_intf, ADD_VIRTUAL_INTERFACE);
148 CHECK_CMD(del_virtual_intf, DEL_VIRTUAL_INTERFACE);
149 CHECK_CMD(associate, ASSOCIATE);
150 CHECK_CMD(disassociate, DISASSOCIATE);
151 CHECK_CMD(deauth, DEAUTH);
152 CHECK_CMD(initiate_scan, INITIATE_SCAN);
153 CHECK_CMD(get_association, GET_ASSOCIATION);
154 CHECK_CMD(get_auth_list, GET_AUTH_LIST);
155 CHECK_CMD(add_key, ADD_KEY);
156 CHECK_CMD(del_key, DEL_KEY);
157
158 nla_nest_end(msg, start);
159
160 genlmsg_end(msg, hdr);
161
162 err = genlmsg_unicast(msg, info->snd_pid);
163 goto put_drv;
164
165 nla_put_failure:
166 err = -ENOBUFS;
167 nlmsg_free(msg);
168 put_drv:
169 cfg80211_put_dev(drv);
170 return err;
171 }
172 #undef CHECK_CMD
173
174 static int nl80211_get_wiphys(struct sk_buff *skb, struct genl_info *info)
175 {
176 struct sk_buff *msg;
177 void *hdr;
178 struct nlattr *start, *indexstart;
179 struct cfg80211_registered_device *drv;
180 int idx = 1;
181
182 hdr = nl80211msg_new(&msg, info->snd_pid, info->snd_seq, 0,
183 NL80211_CMD_NEW_WIPHYS);
184 if (IS_ERR(hdr))
185 return PTR_ERR(hdr);
186
187 start = nla_nest_start(msg, NL80211_ATTR_WIPHY_LIST);
188 if (!start)
189 goto nla_outer_nest_failure;
190
191 mutex_lock(&cfg80211_drv_mutex);
192 list_for_each_entry(drv, &cfg80211_drv_list, list) {
193 indexstart = nla_nest_start(msg, idx++);
194 if (!indexstart)
195 goto nla_put_failure;
196 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, drv->idx);
197 nla_nest_end(msg, indexstart);
198 }
199 mutex_unlock(&cfg80211_drv_mutex);
200
201 nla_nest_end(msg, start);
202
203 genlmsg_end(msg, hdr);
204
205 return genlmsg_unicast(msg, info->snd_pid);
206
207 nla_put_failure:
208 mutex_unlock(&cfg80211_drv_mutex);
209 nla_outer_nest_failure:
210 nlmsg_free(msg);
211 return -ENOBUFS;
212 }
213
214 static int addifidx(struct net_device *dev, struct sk_buff *skb, int *idx)
215 {
216 int err = -ENOBUFS;
217 struct nlattr *start;
218
219 dev_hold(dev);
220
221 start = nla_nest_start(skb, *idx++);
222 if (!start)
223 goto nla_put_failure;
224
225 NLA_PUT_U32(skb, NL80211_ATTR_IFINDEX, dev->ifindex);
226 NLA_PUT_STRING(skb, NL80211_ATTR_IFNAME, dev->name);
227
228 nla_nest_end(skb, start);
229 err = 0;
230
231 nla_put_failure:
232 dev_put(dev);
233 return err;
234 }
235
236 static int nl80211_get_intfs(struct sk_buff *skb, struct genl_info *info)
237 {
238 struct cfg80211_registered_device *drv;
239 struct sk_buff *msg;
240 void *hdr;
241 int err, array_idx;
242 struct nlattr *start;
243 struct wireless_dev *wdev;
244
245 drv = cfg80211_get_dev_from_info(info);
246 if (IS_ERR(drv))
247 return PTR_ERR(drv);
248
249 hdr = nl80211msg_new(&msg, info->snd_pid, info->snd_seq, 0,
250 NL80211_CMD_NEW_INTERFACES);
251 if (IS_ERR(hdr)) {
252 err = PTR_ERR(hdr);
253 goto put_drv;
254 }
255
256 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, drv->idx);
257
258 start = nla_nest_start(msg, NL80211_ATTR_INTERFACE_LIST);
259 if (!start) {
260 err = -ENOBUFS;
261 goto msg_free;
262 }
263
264 array_idx = 1;
265 err = 0;
266 mutex_lock(&drv->devlist_mtx);
267 list_for_each_entry(wdev, &drv->netdev_list, list) {
268 err = addifidx(wdev->netdev, msg, &array_idx);
269 if (err)
270 break;
271 }
272 mutex_unlock(&drv->devlist_mtx);
273 if (err)
274 goto msg_free;
275
276 nla_nest_end(msg, start);
277
278 genlmsg_end(msg, hdr);
279
280 err = genlmsg_unicast(msg, info->snd_pid);
281 goto put_drv;
282
283 nla_put_failure:
284 err = -ENOBUFS;
285 msg_free:
286 nlmsg_free(msg);
287 put_drv:
288 cfg80211_put_dev(drv);
289 return err;
290 }
291
292 static int nl80211_add_virt_intf(struct sk_buff *skb, struct genl_info *info)
293 {
294 struct cfg80211_registered_device *drv;
295 int err;
296 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
297
298 if (!info->attrs[NL80211_ATTR_IFNAME])
299 return -EINVAL;
300
301 if (info->attrs[NL80211_ATTR_IFTYPE]) {
302 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
303 if (type > NL80211_IFTYPE_MAX)
304 return -EINVAL;
305 }
306
307 drv = cfg80211_get_dev_from_info(info);
308 if (IS_ERR(drv))
309 return PTR_ERR(drv);
310
311 if (!drv->ops->add_virtual_intf) {
312 err = -EOPNOTSUPP;
313 goto unlock;
314 }
315
316 rtnl_lock();
317 err = drv->ops->add_virtual_intf(&drv->wiphy,
318 nla_data(info->attrs[NL80211_ATTR_IFNAME]), type);
319 rtnl_unlock();
320
321 unlock:
322 cfg80211_put_dev(drv);
323 return err;
324 }
325
326 static int nl80211_del_virt_intf(struct sk_buff *skb, struct genl_info *info)
327 {
328 struct cfg80211_registered_device *drv;
329 int ifindex, err;
330 struct net_device *dev;
331
332 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
333 if (err)
334 return err;
335 ifindex = dev->ifindex;
336 dev_put(dev);
337
338 if (!drv->ops->del_virtual_intf) {
339 err = -EOPNOTSUPP;
340 goto out;
341 }
342
343 rtnl_lock();
344 err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
345 rtnl_unlock();
346
347 out:
348 cfg80211_put_dev(drv);
349 return err;
350 }
351
352 static int nl80211_change_virt_intf(struct sk_buff *skb, struct genl_info *info)
353 {
354 struct cfg80211_registered_device *drv;
355 int err, ifindex;
356 enum nl80211_iftype type;
357 struct net_device *dev;
358
359 if (info->attrs[NL80211_ATTR_IFTYPE]) {
360 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
361 if (type > NL80211_IFTYPE_MAX)
362 return -EINVAL;
363 } else
364 return -EINVAL;
365
366 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
367 if (err)
368 return err;
369 ifindex = dev->ifindex;
370 dev_put(dev);
371
372 if (!drv->ops->change_virtual_intf) {
373 err = -EOPNOTSUPP;
374 goto unlock;
375 }
376
377 rtnl_lock();
378 err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex, type);
379 rtnl_unlock();
380
381 unlock:
382 cfg80211_put_dev(drv);
383 return err;
384 }
385
386 static int nl80211_get_association(struct sk_buff *skb, struct genl_info *info)
387 {
388 struct cfg80211_registered_device *drv;
389 int err;
390 struct net_device *dev;
391 struct sk_buff *msg;
392 void *hdr;
393 u8 bssid[ETH_ALEN];
394
395 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
396 if (err)
397 return err;
398
399 if (!drv->ops->get_association) {
400 err = -EOPNOTSUPP;
401 goto out_put_drv;
402 }
403
404 rtnl_lock();
405 err = drv->ops->get_association(&drv->wiphy, dev, bssid);
406 rtnl_unlock();
407 if (err < 0)
408 goto out_put_drv;
409
410 hdr = nl80211msg_new(&msg, info->snd_pid, info->snd_seq, 0,
411 NL80211_CMD_ASSOCIATION_CHANGED);
412
413 if (IS_ERR(hdr)) {
414 err = PTR_ERR(hdr);
415 goto out_put_drv;
416 }
417
418 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
419 if (err == 1)
420 NLA_PUT(msg, NL80211_ATTR_BSSID, ETH_ALEN, bssid);
421
422 genlmsg_end(msg, hdr);
423 err = genlmsg_unicast(msg, info->snd_pid);
424 goto out_put_drv;
425
426 nla_put_failure:
427 err = -ENOBUFS;
428 nlmsg_free(msg);
429 out_put_drv:
430 cfg80211_put_dev(drv);
431 dev_put(dev);
432 return err;
433 }
434
435 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
436 {
437 struct cfg80211_registered_device *drv;
438 int err;
439 struct net_device *dev;
440 struct association_params assoc_params;
441
442 memset(&assoc_params, 0, sizeof(assoc_params));
443
444 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
445 if (err)
446 return err;
447
448 if (!drv->ops->associate) {
449 err = -EOPNOTSUPP;
450 goto out;
451 }
452
453 if (!info->attrs[NL80211_ATTR_SSID])
454 return -EINVAL;
455
456 assoc_params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
457 assoc_params.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
458
459 if (info->attrs[NL80211_ATTR_BSSID])
460 assoc_params.bssid = nla_data(info->attrs[NL80211_ATTR_BSSID]);
461
462 if (info->attrs[NL80211_ATTR_IE]) {
463 err = check_information_element(info->attrs[NL80211_ATTR_IE]);
464 if (err)
465 goto out;
466 assoc_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
467 assoc_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
468 }
469
470 if (info->attrs[NL80211_ATTR_TIMEOUT_TU]) {
471 assoc_params.timeout =
472 nla_get_u32(info->attrs[NL80211_ATTR_TIMEOUT_TU]);
473 assoc_params.valid |= ASSOC_PARAMS_TIMEOUT;
474 }
475
476 rtnl_lock();
477 err = drv->ops->associate(&drv->wiphy, dev, &assoc_params);
478 rtnl_unlock();
479
480 out:
481 cfg80211_put_dev(drv);
482 dev_put(dev);
483 return err;
484 }
485
486 static int nl80211_disassoc_deauth(struct sk_buff *skb, struct genl_info *info)
487 {
488 struct cfg80211_registered_device *drv;
489 int err;
490 struct net_device *dev;
491 int (*act)(struct wiphy *wiphy, struct net_device *dev);
492
493 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
494 if (err)
495 return err;
496
497 switch (info->genlhdr->cmd) {
498 case NL80211_CMD_DISASSOCIATE:
499 act = drv->ops->disassociate;
500 break;
501 case NL80211_CMD_DEAUTH:
502 act = drv->ops->deauth;
503 break;
504 default:
505 act = NULL;
506 }
507
508 if (!act) {
509 err = -EOPNOTSUPP;
510 goto out;
511 }
512
513 rtnl_lock();
514 err = act(&drv->wiphy, dev);
515 rtnl_unlock();
516 out:
517 cfg80211_put_dev(drv);
518 dev_put(dev);
519 return err;
520 }
521
522 struct add_cb_data {
523 int idx;
524 struct sk_buff *skb;
525 };
526
527 static int add_bssid(void *data, u8 *bssid)
528 {
529 struct add_cb_data *cb = data;
530 int err = -ENOBUFS;
531 struct nlattr *start;
532
533 start = nla_nest_start(cb->skb, cb->idx++);
534 if (!start)
535 goto nla_put_failure;
536
537 NLA_PUT(cb->skb, NL80211_ATTR_BSSID, ETH_ALEN, bssid);
538
539 nla_nest_end(cb->skb, start);
540 err = 0;
541
542 nla_put_failure:
543 return err;
544 }
545
546 static int nl80211_get_auth_list(struct sk_buff *skb, struct genl_info *info)
547 {
548 struct cfg80211_registered_device *drv;
549 struct net_device *dev;
550 struct sk_buff *msg;
551 void *hdr;
552 int err;
553 struct nlattr *start;
554 struct add_cb_data cb;
555
556 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
557 if (err)
558 return err;
559
560 if (!drv->ops->get_auth_list) {
561 err = -EOPNOTSUPP;
562 goto put_drv;
563 }
564
565 hdr = nl80211msg_new(&msg, info->snd_pid, info->snd_seq, 0,
566 NL80211_CMD_NEW_AUTH_LIST);
567 if (IS_ERR(hdr)) {
568 err = PTR_ERR(hdr);
569 goto put_drv;
570 }
571
572 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
573
574 start = nla_nest_start(msg, NL80211_ATTR_BSS_LIST);
575 if (!start) {
576 err = -ENOBUFS;
577 goto msg_free;
578 }
579
580 cb.skb = msg;
581 cb.idx = 1;
582 rtnl_lock();
583 err = drv->ops->get_auth_list(&drv->wiphy, dev, &cb, add_bssid);
584 rtnl_unlock();
585 if (err)
586 goto msg_free;
587
588 nla_nest_end(msg, start);
589
590 genlmsg_end(msg, hdr);
591
592 err = genlmsg_unicast(msg, info->snd_pid);
593 goto put_drv;
594
595 nla_put_failure:
596 err = -ENOBUFS;
597 msg_free:
598 nlmsg_free(msg);
599 put_drv:
600 cfg80211_put_dev(drv);
601 dev_put(dev);
602 return err;
603 }
604
605 static int nl80211_initiate_scan(struct sk_buff *skb, struct genl_info *info)
606 {
607 struct cfg80211_registered_device *drv;
608 int err;
609 struct net_device *dev;
610 struct scan_params params;
611 struct scan_channel *channels = NULL;
612 int count = -1;
613
614 if (info->attrs[NL80211_ATTR_PHYMODE])
615 params.phymode = nla_get_u32(info->attrs[NL80211_ATTR_PHYMODE]);
616
617 if (params.phymode > NL80211_PHYMODE_MAX)
618 return -EINVAL;
619
620 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
621 if (err)
622 return err;
623
624 if (!drv->ops->initiate_scan) {
625 err = -EOPNOTSUPP;
626 goto out;
627 }
628
629 params.active = nla_get_flag(info->attrs[NL80211_ATTR_FLAG_SCAN_ACTIVE]);
630
631 if (info->attrs[NL80211_ATTR_CHANNEL_LIST]) {
632 struct nlattr *attr = info->attrs[NL80211_ATTR_CHANNEL_LIST];
633 struct nlattr *nla;
634 int rem;
635 struct nlattr **tb;
636
637 /* let's count first */
638 count = 0;
639 nla_for_each_attr(nla, nla_data(attr), nla_len(attr), rem)
640 count++;
641
642 if (count == 0) {
643 /* assume we should actually scan all channels,
644 * scanning no channels make no sense */
645 count = -1;
646 goto done_channels;
647 }
648
649 if (count > NL80211_MAX_CHANNEL_LIST_ITEM) {
650 err = -EINVAL;
651 goto out;
652 }
653
654 channels = kmalloc(count * sizeof(struct scan_channel),
655 GFP_KERNEL);
656 tb = kmalloc((NL80211_ATTR_MAX+1) * sizeof(struct nlattr),
657 GFP_KERNEL);
658
659 count = 0;
660 nla_for_each_attr(nla, nla_data(attr), nla_len(attr), rem) {
661 err = nla_parse(tb, NL80211_ATTR_MAX, nla_data(nla),
662 nla_len(nla), nl80211_policy);
663
664 if (err || !tb[NL80211_ATTR_CHANNEL]) {
665 err = -EINVAL;
666 kfree(tb);
667 kfree(channels);
668 goto out;
669 }
670
671 channels[count].phymode = params.phymode;
672
673 if (tb[NL80211_ATTR_PHYMODE])
674 channels[count].phymode =
675 nla_get_u32(tb[NL80211_ATTR_PHYMODE]);
676
677 if (channels[count].phymode > NL80211_PHYMODE_MAX) {
678 err = -EINVAL;
679 kfree(tb);
680 kfree(channels);
681 goto out;
682 }
683
684 channels[count].channel =
685 nla_get_u32(tb[NL80211_ATTR_CHANNEL]);
686
687 channels[count].active =
688 nla_get_flag(tb[NL80211_ATTR_FLAG_SCAN_ACTIVE]);
689 count++;
690 }
691 kfree(tb);
692 }
693
694 done_channels:
695 params.channels = channels;
696 params.n_channels = count;
697
698 rtnl_lock();
699 err = drv->ops->initiate_scan(&drv->wiphy, dev, &params);
700 rtnl_unlock();
701
702 kfree(channels);
703 out:
704 cfg80211_put_dev(drv);
705 dev_put(dev);
706 return err;
707 }
708
709 static int nl80211_rename_wiphy(struct sk_buff *skb, struct genl_info *info)
710 {
711 struct cfg80211_registered_device *rdev;
712 int result;
713
714 if (!info->attrs[NL80211_ATTR_WIPHY_NAME])
715 return -EINVAL;
716
717 rdev = cfg80211_get_dev_from_info(info);
718 if (IS_ERR(rdev))
719 return PTR_ERR(rdev);
720
721 result = cfg80211_dev_rename(rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
722
723 cfg80211_put_dev(rdev);
724 return result;
725 }
726
727 static int nl80211_key_cmd(struct sk_buff *skb, struct genl_info *info)
728 {
729 struct cfg80211_registered_device *drv;
730 int err, del;
731 struct net_device *dev;
732 struct key_params params;
733 int (*act)(struct wiphy *wiphy, struct net_device *dev,
734 struct key_params *params);
735
736 memset(&params, 0, sizeof(params));
737
738 if (!info->attrs[NL80211_ATTR_KEY_TYPE])
739 return -EINVAL;
740
741 if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
742 return -EINVAL;
743
744 params.key_type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
745 if (params.key_type > NL80211_KEYTYPE_MAX)
746 return -EINVAL;
747
748 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
749 if (err)
750 return err;
751
752 switch (info->genlhdr->cmd) {
753 case NL80211_CMD_ADD_KEY:
754 act = drv->ops->add_key;
755 del = 0;
756 break;
757 case NL80211_CMD_DEL_KEY:
758 act = drv->ops->del_key;
759 del = 1;
760 break;
761 default:
762 act = NULL;
763 }
764
765 if (!act) {
766 err = -EOPNOTSUPP;
767 goto out;
768 }
769
770 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
771 params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
772 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
773 }
774
775 if (info->attrs[NL80211_ATTR_KEY_ID]) {
776 params.key_id = nla_get_u32(info->attrs[NL80211_ATTR_KEY_ID]);
777 } else {
778 params.key_id = -1;
779 }
780
781 params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
782
783 if (info->attrs[NL80211_ATTR_MAC]) {
784 params.macaddress = nla_data(info->attrs[NL80211_ATTR_MAC]);
785 } else {
786 params.macaddress = NULL;
787 }
788
789 rtnl_lock();
790 err = act(&drv->wiphy, dev, &params);
791 rtnl_unlock();
792
793 out:
794 cfg80211_put_dev(drv);
795 dev_put(dev);
796 return err;
797 }
798
799 static struct genl_ops nl80211_ops[] = {
800 {
801 .cmd = NL80211_CMD_RENAME_WIPHY,
802 .doit = nl80211_rename_wiphy,
803 .policy = nl80211_policy,
804 .flags = GENL_ADMIN_PERM,
805 },
806 {
807 .cmd = NL80211_CMD_GET_CMDLIST,
808 .doit = nl80211_get_cmdlist,
809 .policy = nl80211_policy,
810 /* can be retrieved by unprivileged users */
811 },
812 {
813 .cmd = NL80211_CMD_ADD_VIRTUAL_INTERFACE,
814 .doit = nl80211_add_virt_intf,
815 .policy = nl80211_policy,
816 .flags = GENL_ADMIN_PERM,
817 },
818 {
819 .cmd = NL80211_CMD_DEL_VIRTUAL_INTERFACE,
820 .doit = nl80211_del_virt_intf,
821 .policy = nl80211_policy,
822 .flags = GENL_ADMIN_PERM,
823 },
824 {
825 .cmd = NL80211_CMD_CHANGE_VIRTUAL_INTERFACE,
826 .doit = nl80211_change_virt_intf,
827 .policy = nl80211_policy,
828 .flags = GENL_ADMIN_PERM,
829 },
830 {
831 .cmd = NL80211_CMD_GET_WIPHYS,
832 .doit = nl80211_get_wiphys,
833 .policy = nl80211_policy,
834 /* can be retrieved by unprivileged users */
835 },
836 {
837 .cmd = NL80211_CMD_GET_INTERFACES,
838 .doit = nl80211_get_intfs,
839 .policy = nl80211_policy,
840 /* can be retrieved by unprivileged users */
841 },
842 {
843 .cmd = NL80211_CMD_INITIATE_SCAN,
844 .doit = nl80211_initiate_scan,
845 .policy = nl80211_policy,
846 .flags = GENL_ADMIN_PERM,
847 },
848 {
849 .cmd = NL80211_CMD_GET_ASSOCIATION,
850 .doit = nl80211_get_association,
851 .policy = nl80211_policy,
852 /* can be retrieved by unprivileged users */
853 },
854 {
855 .cmd = NL80211_CMD_ASSOCIATE,
856 .doit = nl80211_associate,
857 .policy = nl80211_policy,
858 .flags = GENL_ADMIN_PERM,
859 },
860 {
861 .cmd = NL80211_CMD_DISASSOCIATE,
862 .doit = nl80211_disassoc_deauth,
863 .policy = nl80211_policy,
864 .flags = GENL_ADMIN_PERM,
865 },
866 {
867 .cmd = NL80211_CMD_DEAUTH,
868 .doit = nl80211_disassoc_deauth,
869 .policy = nl80211_policy,
870 .flags = GENL_ADMIN_PERM,
871 },
872 {
873 .cmd = NL80211_CMD_GET_AUTH_LIST,
874 .doit = nl80211_get_auth_list,
875 .policy = nl80211_policy,
876 /* can be retrieved by unprivileged users */
877 },
878 /*
879 {
880 .cmd = NL80211_CMD_AP_SET_BEACON,
881 .policy = nl80211_policy,
882 .flags = GENL_ADMIN_PERM,
883 },
884 {
885 .cmd = NL80211_CMD_AP_ADD_STA,
886 .policy = nl80211_policy,
887 .flags = GENL_ADMIN_PERM,
888 },
889 {
890 .cmd = NL80211_CMD_AP_UPDATE_STA,
891 .policy = nl80211_policy,
892 .flags = GENL_ADMIN_PERM,
893 },
894 {
895 .cmd = NL80211_CMD_AP_GET_STA_INFO,
896 .policy = nl80211_policy,
897 .flags = GENL_ADMIN_PERM,
898 },
899 {
900 .cmd = NL80211_CMD_AP_SET_RATESETS,
901 .policy = nl80211_policy,
902 .flags = GENL_ADMIN_PERM,
903 },
904 */
905 {
906 .cmd = NL80211_CMD_ADD_KEY,
907 .doit = nl80211_key_cmd,
908 .policy = nl80211_policy,
909 .flags = GENL_ADMIN_PERM,
910 },
911 {
912 .cmd = NL80211_CMD_DEL_KEY,
913 .doit = nl80211_key_cmd,
914 .policy = nl80211_policy,
915 .flags = GENL_ADMIN_PERM,
916 },
917 };
918
919
920 /* exported functions */
921
922 void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq, int flags, u8 cmd)
923 {
924 /* since there is no private header just add the generic one */
925 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
926 }
927 EXPORT_SYMBOL_GPL(nl80211hdr_put);
928
929 void *nl80211msg_new(struct sk_buff **skb, u32 pid, u32 seq, int flags, u8 cmd)
930 {
931 void *hdr;
932
933 *skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
934 if (!*skb)
935 return ERR_PTR(-ENOBUFS);
936
937 hdr = nl80211hdr_put(*skb, pid, seq, flags, cmd);
938 if (!hdr) {
939 nlmsg_free(*skb);
940 return ERR_PTR(-ENOBUFS);
941 }
942
943 return hdr;
944 }
945 EXPORT_SYMBOL_GPL(nl80211msg_new);
946
947 /* notification functions */
948
949 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
950 {
951 struct sk_buff *msg;
952 void *hdr;
953
954 hdr = nl80211msg_new(&msg, 0, 0, 0, NL80211_CMD_WIPHY_NEWNAME);
955 if (IS_ERR(hdr))
956 return;
957
958 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->idx);
959 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&rdev->wiphy));
960
961 genlmsg_end(msg, hdr);
962 genlmsg_multicast(msg, 0, NL80211_GROUP_CONFIG, GFP_KERNEL);
963
964 return;
965
966 nla_put_failure:
967 nlmsg_free(msg);
968 }
969
970 /* initialisation/exit functions */
971
972 int nl80211_init(void)
973 {
974 int err, i;
975
976 err = genl_register_family(&nl80211_fam);
977 if (err)
978 return err;
979
980 for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
981 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
982 if (err)
983 goto err_out;
984 }
985 return 0;
986 err_out:
987 genl_unregister_family(&nl80211_fam);
988 return err;
989 }
990
991 void nl80211_exit(void)
992 {
993 genl_unregister_family(&nl80211_fam);
994 }
This page took 0.149863 seconds and 5 git commands to generate.