blob: 431835126e883d04cba7be13ad44d8339082fec7 [file] [log] [blame]
Johannes Berg55682962007-09-20 13:09:35 -04001/*
2 * This is the new netlink-based wireless configuration interface.
3 *
4 * Copyright 2006, 2007 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 <linux/netlink.h>
17#include <net/genetlink.h>
18#include <net/cfg80211.h>
19#include "core.h"
20#include "nl80211.h"
21
22/* the netlink family */
23static struct genl_family nl80211_fam = {
24 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
25 .name = "nl80211", /* have users key off the name instead */
26 .hdrsize = 0, /* no private header */
27 .version = 1, /* no particular meaning now */
28 .maxattr = NL80211_ATTR_MAX,
29};
30
31/* internal helper: get drv and dev */
32static int get_drv_dev_by_info_ifindex(struct genl_info *info,
33 struct cfg80211_registered_device **drv,
34 struct net_device **dev)
35{
36 int ifindex;
37
38 if (!info->attrs[NL80211_ATTR_IFINDEX])
39 return -EINVAL;
40
41 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
42 *dev = dev_get_by_index(&init_net, ifindex);
43 if (!*dev)
44 return -ENODEV;
45
46 *drv = cfg80211_get_dev_from_ifindex(ifindex);
47 if (IS_ERR(*drv)) {
48 dev_put(*dev);
49 return PTR_ERR(*drv);
50 }
51
52 return 0;
53}
54
55/* policy for the attributes */
56static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
57 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
58 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
59 .len = BUS_ID_SIZE-1 },
60
61 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
62 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
63 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
Johannes Berg41ade002007-12-19 02:03:29 +010064
65 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
66
67 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
68 .len = WLAN_MAX_KEY_LEN },
69 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
70 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
71 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
Johannes Berged1b6cc2007-12-19 02:03:32 +010072
73 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
74 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
75 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
76 .len = IEEE80211_MAX_DATA_LEN },
77 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
78 .len = IEEE80211_MAX_DATA_LEN },
Johannes Berg5727ef12007-12-19 02:03:34 +010079 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
80 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
81 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
82 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
83 .len = NL80211_MAX_SUPP_RATES },
84 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
Johannes Berg55682962007-09-20 13:09:35 -040085};
86
87/* message building helper */
88static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
89 int flags, u8 cmd)
90{
91 /* since there is no private header just add the generic one */
92 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
93}
94
95/* netlink command implementations */
96
97static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
98 struct cfg80211_registered_device *dev)
99{
100 void *hdr;
101
102 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
103 if (!hdr)
104 return -1;
105
106 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->idx);
107 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
108 return genlmsg_end(msg, hdr);
109
110 nla_put_failure:
111 return genlmsg_cancel(msg, hdr);
112}
113
114static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
115{
116 int idx = 0;
117 int start = cb->args[0];
118 struct cfg80211_registered_device *dev;
119
120 mutex_lock(&cfg80211_drv_mutex);
121 list_for_each_entry(dev, &cfg80211_drv_list, list) {
122 if (++idx < start)
123 continue;
124 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
125 cb->nlh->nlmsg_seq, NLM_F_MULTI,
126 dev) < 0)
127 break;
128 }
129 mutex_unlock(&cfg80211_drv_mutex);
130
131 cb->args[0] = idx;
132
133 return skb->len;
134}
135
136static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
137{
138 struct sk_buff *msg;
139 struct cfg80211_registered_device *dev;
140
141 dev = cfg80211_get_dev_from_info(info);
142 if (IS_ERR(dev))
143 return PTR_ERR(dev);
144
145 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
146 if (!msg)
147 goto out_err;
148
149 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
150 goto out_free;
151
152 cfg80211_put_dev(dev);
153
154 return genlmsg_unicast(msg, info->snd_pid);
155
156 out_free:
157 nlmsg_free(msg);
158 out_err:
159 cfg80211_put_dev(dev);
160 return -ENOBUFS;
161}
162
163static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
164{
165 struct cfg80211_registered_device *rdev;
166 int result;
167
168 if (!info->attrs[NL80211_ATTR_WIPHY_NAME])
169 return -EINVAL;
170
171 rdev = cfg80211_get_dev_from_info(info);
172 if (IS_ERR(rdev))
173 return PTR_ERR(rdev);
174
175 result = cfg80211_dev_rename(rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
176
177 cfg80211_put_dev(rdev);
178 return result;
179}
180
181
182static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
183 struct net_device *dev)
184{
185 void *hdr;
186
187 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
188 if (!hdr)
189 return -1;
190
191 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
192 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
193 /* TODO: interface type */
194 return genlmsg_end(msg, hdr);
195
196 nla_put_failure:
197 return genlmsg_cancel(msg, hdr);
198}
199
200static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
201{
202 int wp_idx = 0;
203 int if_idx = 0;
204 int wp_start = cb->args[0];
205 int if_start = cb->args[1];
206 struct cfg80211_registered_device *dev;
207 struct wireless_dev *wdev;
208
209 mutex_lock(&cfg80211_drv_mutex);
210 list_for_each_entry(dev, &cfg80211_drv_list, list) {
211 if (++wp_idx < wp_start)
212 continue;
213 if_idx = 0;
214
215 mutex_lock(&dev->devlist_mtx);
216 list_for_each_entry(wdev, &dev->netdev_list, list) {
217 if (++if_idx < if_start)
218 continue;
219 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
220 cb->nlh->nlmsg_seq, NLM_F_MULTI,
221 wdev->netdev) < 0)
222 break;
223 }
224 mutex_unlock(&dev->devlist_mtx);
225 }
226 mutex_unlock(&cfg80211_drv_mutex);
227
228 cb->args[0] = wp_idx;
229 cb->args[1] = if_idx;
230
231 return skb->len;
232}
233
234static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
235{
236 struct sk_buff *msg;
237 struct cfg80211_registered_device *dev;
238 struct net_device *netdev;
239 int err;
240
241 err = get_drv_dev_by_info_ifindex(info, &dev, &netdev);
242 if (err)
243 return err;
244
245 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
246 if (!msg)
247 goto out_err;
248
249 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, netdev) < 0)
250 goto out_free;
251
252 dev_put(netdev);
253 cfg80211_put_dev(dev);
254
255 return genlmsg_unicast(msg, info->snd_pid);
256
257 out_free:
258 nlmsg_free(msg);
259 out_err:
260 dev_put(netdev);
261 cfg80211_put_dev(dev);
262 return -ENOBUFS;
263}
264
265static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
266{
267 struct cfg80211_registered_device *drv;
268 int err, ifindex;
269 enum nl80211_iftype type;
270 struct net_device *dev;
271
272 if (info->attrs[NL80211_ATTR_IFTYPE]) {
273 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
274 if (type > NL80211_IFTYPE_MAX)
275 return -EINVAL;
276 } else
277 return -EINVAL;
278
279 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
280 if (err)
281 return err;
282 ifindex = dev->ifindex;
283 dev_put(dev);
284
285 if (!drv->ops->change_virtual_intf) {
286 err = -EOPNOTSUPP;
287 goto unlock;
288 }
289
290 rtnl_lock();
291 err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex, type);
292 rtnl_unlock();
293
294 unlock:
295 cfg80211_put_dev(drv);
296 return err;
297}
298
299static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
300{
301 struct cfg80211_registered_device *drv;
302 int err;
303 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
304
305 if (!info->attrs[NL80211_ATTR_IFNAME])
306 return -EINVAL;
307
308 if (info->attrs[NL80211_ATTR_IFTYPE]) {
309 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
310 if (type > NL80211_IFTYPE_MAX)
311 return -EINVAL;
312 }
313
314 drv = cfg80211_get_dev_from_info(info);
315 if (IS_ERR(drv))
316 return PTR_ERR(drv);
317
318 if (!drv->ops->add_virtual_intf) {
319 err = -EOPNOTSUPP;
320 goto unlock;
321 }
322
323 rtnl_lock();
324 err = drv->ops->add_virtual_intf(&drv->wiphy,
325 nla_data(info->attrs[NL80211_ATTR_IFNAME]), type);
326 rtnl_unlock();
327
328 unlock:
329 cfg80211_put_dev(drv);
330 return err;
331}
332
333static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
334{
335 struct cfg80211_registered_device *drv;
336 int ifindex, err;
337 struct net_device *dev;
338
339 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
340 if (err)
341 return err;
342 ifindex = dev->ifindex;
343 dev_put(dev);
344
345 if (!drv->ops->del_virtual_intf) {
346 err = -EOPNOTSUPP;
347 goto out;
348 }
349
350 rtnl_lock();
351 err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
352 rtnl_unlock();
353
354 out:
355 cfg80211_put_dev(drv);
356 return err;
357}
358
Johannes Berg41ade002007-12-19 02:03:29 +0100359struct get_key_cookie {
360 struct sk_buff *msg;
361 int error;
362};
363
364static void get_key_callback(void *c, struct key_params *params)
365{
366 struct get_key_cookie *cookie = c;
367
368 if (params->key)
369 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
370 params->key_len, params->key);
371
372 if (params->seq)
373 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
374 params->seq_len, params->seq);
375
376 if (params->cipher)
377 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
378 params->cipher);
379
380 return;
381 nla_put_failure:
382 cookie->error = 1;
383}
384
385static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
386{
387 struct cfg80211_registered_device *drv;
388 int err;
389 struct net_device *dev;
390 u8 key_idx = 0;
391 u8 *mac_addr = NULL;
392 struct get_key_cookie cookie = {
393 .error = 0,
394 };
395 void *hdr;
396 struct sk_buff *msg;
397
398 if (info->attrs[NL80211_ATTR_KEY_IDX])
399 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
400
401 if (key_idx > 3)
402 return -EINVAL;
403
404 if (info->attrs[NL80211_ATTR_MAC])
405 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
406
407 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
408 if (err)
409 return err;
410
411 if (!drv->ops->get_key) {
412 err = -EOPNOTSUPP;
413 goto out;
414 }
415
416 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
417 if (!msg) {
418 err = -ENOMEM;
419 goto out;
420 }
421
422 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
423 NL80211_CMD_NEW_KEY);
424
425 if (IS_ERR(hdr)) {
426 err = PTR_ERR(hdr);
427 goto out;
428 }
429
430 cookie.msg = msg;
431
432 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
433 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
434 if (mac_addr)
435 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
436
437 rtnl_lock();
438 err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
439 &cookie, get_key_callback);
440 rtnl_unlock();
441
442 if (err)
443 goto out;
444
445 if (cookie.error)
446 goto nla_put_failure;
447
448 genlmsg_end(msg, hdr);
449 err = genlmsg_unicast(msg, info->snd_pid);
450 goto out;
451
452 nla_put_failure:
453 err = -ENOBUFS;
454 nlmsg_free(msg);
455 out:
456 cfg80211_put_dev(drv);
457 dev_put(dev);
458 return err;
459}
460
461static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
462{
463 struct cfg80211_registered_device *drv;
464 int err;
465 struct net_device *dev;
466 u8 key_idx;
467
468 if (!info->attrs[NL80211_ATTR_KEY_IDX])
469 return -EINVAL;
470
471 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
472
473 if (key_idx > 3)
474 return -EINVAL;
475
476 /* currently only support setting default key */
477 if (!info->attrs[NL80211_ATTR_KEY_DEFAULT])
478 return -EINVAL;
479
480 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
481 if (err)
482 return err;
483
484 if (!drv->ops->set_default_key) {
485 err = -EOPNOTSUPP;
486 goto out;
487 }
488
489 rtnl_lock();
490 err = drv->ops->set_default_key(&drv->wiphy, dev, key_idx);
491 rtnl_unlock();
492
493 out:
494 cfg80211_put_dev(drv);
495 dev_put(dev);
496 return err;
497}
498
499static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
500{
501 struct cfg80211_registered_device *drv;
502 int err;
503 struct net_device *dev;
504 struct key_params params;
505 u8 key_idx = 0;
506 u8 *mac_addr = NULL;
507
508 memset(&params, 0, sizeof(params));
509
510 if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
511 return -EINVAL;
512
513 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
514 params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
515 params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
516 }
517
518 if (info->attrs[NL80211_ATTR_KEY_IDX])
519 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
520
521 params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
522
523 if (info->attrs[NL80211_ATTR_MAC])
524 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
525
526 if (key_idx > 3)
527 return -EINVAL;
528
529 /*
530 * Disallow pairwise keys with non-zero index unless it's WEP
531 * (because current deployments use pairwise WEP keys with
532 * non-zero indizes but 802.11i clearly specifies to use zero)
533 */
534 if (mac_addr && key_idx &&
535 params.cipher != WLAN_CIPHER_SUITE_WEP40 &&
536 params.cipher != WLAN_CIPHER_SUITE_WEP104)
537 return -EINVAL;
538
539 /* TODO: add definitions for the lengths to linux/ieee80211.h */
540 switch (params.cipher) {
541 case WLAN_CIPHER_SUITE_WEP40:
542 if (params.key_len != 5)
543 return -EINVAL;
544 break;
545 case WLAN_CIPHER_SUITE_TKIP:
546 if (params.key_len != 32)
547 return -EINVAL;
548 break;
549 case WLAN_CIPHER_SUITE_CCMP:
550 if (params.key_len != 16)
551 return -EINVAL;
552 break;
553 case WLAN_CIPHER_SUITE_WEP104:
554 if (params.key_len != 13)
555 return -EINVAL;
556 break;
557 default:
558 return -EINVAL;
559 }
560
561 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
562 if (err)
563 return err;
564
565 if (!drv->ops->add_key) {
566 err = -EOPNOTSUPP;
567 goto out;
568 }
569
570 rtnl_lock();
571 err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
572 rtnl_unlock();
573
574 out:
575 cfg80211_put_dev(drv);
576 dev_put(dev);
577 return err;
578}
579
580static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
581{
582 struct cfg80211_registered_device *drv;
583 int err;
584 struct net_device *dev;
585 u8 key_idx = 0;
586 u8 *mac_addr = NULL;
587
588 if (info->attrs[NL80211_ATTR_KEY_IDX])
589 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
590
591 if (key_idx > 3)
592 return -EINVAL;
593
594 if (info->attrs[NL80211_ATTR_MAC])
595 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
596
597 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
598 if (err)
599 return err;
600
601 if (!drv->ops->del_key) {
602 err = -EOPNOTSUPP;
603 goto out;
604 }
605
606 rtnl_lock();
607 err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
608 rtnl_unlock();
609
610 out:
611 cfg80211_put_dev(drv);
612 dev_put(dev);
613 return err;
614}
615
Johannes Berged1b6cc2007-12-19 02:03:32 +0100616static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
617{
618 int (*call)(struct wiphy *wiphy, struct net_device *dev,
619 struct beacon_parameters *info);
620 struct cfg80211_registered_device *drv;
621 int err;
622 struct net_device *dev;
623 struct beacon_parameters params;
624 int haveinfo = 0;
625
626 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
627 if (err)
628 return err;
629
630 switch (info->genlhdr->cmd) {
631 case NL80211_CMD_NEW_BEACON:
632 /* these are required for NEW_BEACON */
633 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
634 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
635 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
636 err = -EINVAL;
637 goto out;
638 }
639
640 call = drv->ops->add_beacon;
641 break;
642 case NL80211_CMD_SET_BEACON:
643 call = drv->ops->set_beacon;
644 break;
645 default:
646 WARN_ON(1);
647 err = -EOPNOTSUPP;
648 goto out;
649 }
650
651 if (!call) {
652 err = -EOPNOTSUPP;
653 goto out;
654 }
655
656 memset(&params, 0, sizeof(params));
657
658 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
659 params.interval =
660 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
661 haveinfo = 1;
662 }
663
664 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
665 params.dtim_period =
666 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
667 haveinfo = 1;
668 }
669
670 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
671 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
672 params.head_len =
673 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
674 haveinfo = 1;
675 }
676
677 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
678 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
679 params.tail_len =
680 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
681 haveinfo = 1;
682 }
683
684 if (!haveinfo) {
685 err = -EINVAL;
686 goto out;
687 }
688
689 rtnl_lock();
690 err = call(&drv->wiphy, dev, &params);
691 rtnl_unlock();
692
693 out:
694 cfg80211_put_dev(drv);
695 dev_put(dev);
696 return err;
697}
698
699static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
700{
701 struct cfg80211_registered_device *drv;
702 int err;
703 struct net_device *dev;
704
705 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
706 if (err)
707 return err;
708
709 if (!drv->ops->del_beacon) {
710 err = -EOPNOTSUPP;
711 goto out;
712 }
713
714 rtnl_lock();
715 err = drv->ops->del_beacon(&drv->wiphy, dev);
716 rtnl_unlock();
717
718 out:
719 cfg80211_put_dev(drv);
720 dev_put(dev);
721 return err;
722}
723
Johannes Berg5727ef12007-12-19 02:03:34 +0100724static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
725 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
726 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
727 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
728};
729
730static int parse_station_flags(struct nlattr *nla, u32 *staflags)
731{
732 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
733 int flag;
734
735 *staflags = 0;
736
737 if (!nla)
738 return 0;
739
740 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
741 nla, sta_flags_policy))
742 return -EINVAL;
743
744 *staflags = STATION_FLAG_CHANGED;
745
746 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
747 if (flags[flag])
748 *staflags |= (1<<flag);
749
750 return 0;
751}
752
753static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
754{
755 return -EOPNOTSUPP;
756}
757
758/*
759 * Get vlan interface making sure it is on the right wiphy.
760 */
761static int get_vlan(struct nlattr *vlanattr,
762 struct cfg80211_registered_device *rdev,
763 struct net_device **vlan)
764{
765 *vlan = NULL;
766
767 if (vlanattr) {
768 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
769 if (!*vlan)
770 return -ENODEV;
771 if (!(*vlan)->ieee80211_ptr)
772 return -EINVAL;
773 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
774 return -EINVAL;
775 }
776 return 0;
777}
778
779static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
780{
781 struct cfg80211_registered_device *drv;
782 int err;
783 struct net_device *dev;
784 struct station_parameters params;
785 u8 *mac_addr = NULL;
786
787 memset(&params, 0, sizeof(params));
788
789 params.listen_interval = -1;
790
791 if (info->attrs[NL80211_ATTR_STA_AID])
792 return -EINVAL;
793
794 if (!info->attrs[NL80211_ATTR_MAC])
795 return -EINVAL;
796
797 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
798
799 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
800 params.supported_rates =
801 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
802 params.supported_rates_len =
803 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
804 }
805
806 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
807 params.listen_interval =
808 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
809
810 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
811 &params.station_flags))
812 return -EINVAL;
813
814 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
815 if (err)
816 return err;
817
818 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
819 if (err)
820 goto out;
821
822 if (!drv->ops->change_station) {
823 err = -EOPNOTSUPP;
824 goto out;
825 }
826
827 rtnl_lock();
828 err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
829 rtnl_unlock();
830
831 out:
832 if (params.vlan)
833 dev_put(params.vlan);
834 cfg80211_put_dev(drv);
835 dev_put(dev);
836 return err;
837}
838
839static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
840{
841 struct cfg80211_registered_device *drv;
842 int err;
843 struct net_device *dev;
844 struct station_parameters params;
845 u8 *mac_addr = NULL;
846
847 memset(&params, 0, sizeof(params));
848
849 if (!info->attrs[NL80211_ATTR_MAC])
850 return -EINVAL;
851
852 if (!info->attrs[NL80211_ATTR_STA_AID])
853 return -EINVAL;
854
855 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
856 return -EINVAL;
857
858 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
859 return -EINVAL;
860
861 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
862 params.supported_rates =
863 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
864 params.supported_rates_len =
865 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
866 params.listen_interval =
867 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
868 params.listen_interval = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
869
870 if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
871 &params.station_flags))
872 return -EINVAL;
873
874 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
875 if (err)
876 return err;
877
878 err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
879 if (err)
880 goto out;
881
882 if (!drv->ops->add_station) {
883 err = -EOPNOTSUPP;
884 goto out;
885 }
886
887 rtnl_lock();
888 err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
889 rtnl_unlock();
890
891 out:
892 if (params.vlan)
893 dev_put(params.vlan);
894 cfg80211_put_dev(drv);
895 dev_put(dev);
896 return err;
897}
898
899static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
900{
901 struct cfg80211_registered_device *drv;
902 int err;
903 struct net_device *dev;
904 u8 *mac_addr = NULL;
905
906 if (info->attrs[NL80211_ATTR_MAC])
907 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
908
909 err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
910 if (err)
911 return err;
912
913 if (!drv->ops->del_station) {
914 err = -EOPNOTSUPP;
915 goto out;
916 }
917
918 rtnl_lock();
919 err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
920 rtnl_unlock();
921
922 out:
923 cfg80211_put_dev(drv);
924 dev_put(dev);
925 return err;
926}
927
Johannes Berg55682962007-09-20 13:09:35 -0400928static struct genl_ops nl80211_ops[] = {
929 {
930 .cmd = NL80211_CMD_GET_WIPHY,
931 .doit = nl80211_get_wiphy,
932 .dumpit = nl80211_dump_wiphy,
933 .policy = nl80211_policy,
934 /* can be retrieved by unprivileged users */
935 },
936 {
937 .cmd = NL80211_CMD_SET_WIPHY,
938 .doit = nl80211_set_wiphy,
939 .policy = nl80211_policy,
940 .flags = GENL_ADMIN_PERM,
941 },
942 {
943 .cmd = NL80211_CMD_GET_INTERFACE,
944 .doit = nl80211_get_interface,
945 .dumpit = nl80211_dump_interface,
946 .policy = nl80211_policy,
947 /* can be retrieved by unprivileged users */
948 },
949 {
950 .cmd = NL80211_CMD_SET_INTERFACE,
951 .doit = nl80211_set_interface,
952 .policy = nl80211_policy,
953 .flags = GENL_ADMIN_PERM,
954 },
955 {
956 .cmd = NL80211_CMD_NEW_INTERFACE,
957 .doit = nl80211_new_interface,
958 .policy = nl80211_policy,
959 .flags = GENL_ADMIN_PERM,
960 },
961 {
962 .cmd = NL80211_CMD_DEL_INTERFACE,
963 .doit = nl80211_del_interface,
964 .policy = nl80211_policy,
965 .flags = GENL_ADMIN_PERM,
966 },
Johannes Berg41ade002007-12-19 02:03:29 +0100967 {
968 .cmd = NL80211_CMD_GET_KEY,
969 .doit = nl80211_get_key,
970 .policy = nl80211_policy,
971 .flags = GENL_ADMIN_PERM,
972 },
973 {
974 .cmd = NL80211_CMD_SET_KEY,
975 .doit = nl80211_set_key,
976 .policy = nl80211_policy,
977 .flags = GENL_ADMIN_PERM,
978 },
979 {
980 .cmd = NL80211_CMD_NEW_KEY,
981 .doit = nl80211_new_key,
982 .policy = nl80211_policy,
983 .flags = GENL_ADMIN_PERM,
984 },
985 {
986 .cmd = NL80211_CMD_DEL_KEY,
987 .doit = nl80211_del_key,
988 .policy = nl80211_policy,
989 .flags = GENL_ADMIN_PERM,
990 },
Johannes Berged1b6cc2007-12-19 02:03:32 +0100991 {
992 .cmd = NL80211_CMD_SET_BEACON,
993 .policy = nl80211_policy,
994 .flags = GENL_ADMIN_PERM,
995 .doit = nl80211_addset_beacon,
996 },
997 {
998 .cmd = NL80211_CMD_NEW_BEACON,
999 .policy = nl80211_policy,
1000 .flags = GENL_ADMIN_PERM,
1001 .doit = nl80211_addset_beacon,
1002 },
1003 {
1004 .cmd = NL80211_CMD_DEL_BEACON,
1005 .policy = nl80211_policy,
1006 .flags = GENL_ADMIN_PERM,
1007 .doit = nl80211_del_beacon,
1008 },
Johannes Berg5727ef12007-12-19 02:03:34 +01001009 {
1010 .cmd = NL80211_CMD_GET_STATION,
1011 .doit = nl80211_get_station,
1012 /* TODO: implement dumpit */
1013 .policy = nl80211_policy,
1014 .flags = GENL_ADMIN_PERM,
1015 },
1016 {
1017 .cmd = NL80211_CMD_SET_STATION,
1018 .doit = nl80211_set_station,
1019 .policy = nl80211_policy,
1020 .flags = GENL_ADMIN_PERM,
1021 },
1022 {
1023 .cmd = NL80211_CMD_NEW_STATION,
1024 .doit = nl80211_new_station,
1025 .policy = nl80211_policy,
1026 .flags = GENL_ADMIN_PERM,
1027 },
1028 {
1029 .cmd = NL80211_CMD_DEL_STATION,
1030 .doit = nl80211_del_station,
1031 .policy = nl80211_policy,
1032 .flags = GENL_ADMIN_PERM,
1033 },
Johannes Berg55682962007-09-20 13:09:35 -04001034};
1035
1036/* multicast groups */
1037static struct genl_multicast_group nl80211_config_mcgrp = {
1038 .name = "config",
1039};
1040
1041/* notification functions */
1042
1043void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
1044{
1045 struct sk_buff *msg;
1046
1047 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1048 if (!msg)
1049 return;
1050
1051 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
1052 nlmsg_free(msg);
1053 return;
1054 }
1055
1056 genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
1057}
1058
1059/* initialisation/exit functions */
1060
1061int nl80211_init(void)
1062{
1063 int err, i;
1064
1065 err = genl_register_family(&nl80211_fam);
1066 if (err)
1067 return err;
1068
1069 for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
1070 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
1071 if (err)
1072 goto err_out;
1073 }
1074
1075 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
1076 if (err)
1077 goto err_out;
1078
1079 return 0;
1080 err_out:
1081 genl_unregister_family(&nl80211_fam);
1082 return err;
1083}
1084
1085void nl80211_exit(void)
1086{
1087 genl_unregister_family(&nl80211_fam);
1088}