Merge branch 'dmapool' of git://git.kernel.org/pub/scm/linux/kernel/git/willy/misc
[linux-2.6] / net / wireless / nl80211.c
1 /*
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 */
23 static 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 */
32 static 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 */
56 static 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 },
64
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 },
72
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 },
79         [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 },
85 };
86
87 /* message building helper */
88 static 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
97 static 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
114 static 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
136 static 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
163 static 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
182 static 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
200 static 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
234 static 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
265 static 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
299 static 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
333 static 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
359 struct get_key_cookie {
360         struct sk_buff *msg;
361         int error;
362 };
363
364 static 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
385 static 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
461 static 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
499 static 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
580 static 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
616 static 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
699 static 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
724 static 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
730 static 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
753 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
754                                 int flags, struct net_device *dev,
755                                 u8 *mac_addr, struct station_stats *stats)
756 {
757         void *hdr;
758         struct nlattr *statsattr;
759
760         hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
761         if (!hdr)
762                 return -1;
763
764         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
765         NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
766
767         statsattr = nla_nest_start(msg, NL80211_ATTR_STA_STATS);
768         if (!statsattr)
769                 goto nla_put_failure;
770         if (stats->filled & STATION_STAT_INACTIVE_TIME)
771                 NLA_PUT_U32(msg, NL80211_STA_STAT_INACTIVE_TIME,
772                             stats->inactive_time);
773         if (stats->filled & STATION_STAT_RX_BYTES)
774                 NLA_PUT_U32(msg, NL80211_STA_STAT_RX_BYTES,
775                             stats->rx_bytes);
776         if (stats->filled & STATION_STAT_TX_BYTES)
777                 NLA_PUT_U32(msg, NL80211_STA_STAT_TX_BYTES,
778                             stats->tx_bytes);
779
780         nla_nest_end(msg, statsattr);
781
782         return genlmsg_end(msg, hdr);
783
784  nla_put_failure:
785         return genlmsg_cancel(msg, hdr);
786 }
787
788
789 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
790 {
791         struct cfg80211_registered_device *drv;
792         int err;
793         struct net_device *dev;
794         struct station_stats stats;
795         struct sk_buff *msg;
796         u8 *mac_addr = NULL;
797
798         memset(&stats, 0, sizeof(stats));
799
800         if (!info->attrs[NL80211_ATTR_MAC])
801                 return -EINVAL;
802
803         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
804
805         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
806         if (err)
807                 return err;
808
809         if (!drv->ops->get_station) {
810                 err = -EOPNOTSUPP;
811                 goto out;
812         }
813
814         rtnl_lock();
815         err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &stats);
816         rtnl_unlock();
817
818         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
819         if (!msg)
820                 goto out;
821
822         if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
823                                  dev, mac_addr, &stats) < 0)
824                 goto out_free;
825
826         err = genlmsg_unicast(msg, info->snd_pid);
827         goto out;
828
829  out_free:
830         nlmsg_free(msg);
831
832  out:
833         cfg80211_put_dev(drv);
834         dev_put(dev);
835         return err;
836 }
837
838 /*
839  * Get vlan interface making sure it is on the right wiphy.
840  */
841 static int get_vlan(struct nlattr *vlanattr,
842                     struct cfg80211_registered_device *rdev,
843                     struct net_device **vlan)
844 {
845         *vlan = NULL;
846
847         if (vlanattr) {
848                 *vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
849                 if (!*vlan)
850                         return -ENODEV;
851                 if (!(*vlan)->ieee80211_ptr)
852                         return -EINVAL;
853                 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
854                         return -EINVAL;
855         }
856         return 0;
857 }
858
859 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
860 {
861         struct cfg80211_registered_device *drv;
862         int err;
863         struct net_device *dev;
864         struct station_parameters params;
865         u8 *mac_addr = NULL;
866
867         memset(&params, 0, sizeof(params));
868
869         params.listen_interval = -1;
870
871         if (info->attrs[NL80211_ATTR_STA_AID])
872                 return -EINVAL;
873
874         if (!info->attrs[NL80211_ATTR_MAC])
875                 return -EINVAL;
876
877         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
878
879         if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
880                 params.supported_rates =
881                         nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
882                 params.supported_rates_len =
883                         nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
884         }
885
886         if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
887                 params.listen_interval =
888                     nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
889
890         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
891                                 &params.station_flags))
892                 return -EINVAL;
893
894         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
895         if (err)
896                 return err;
897
898         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
899         if (err)
900                 goto out;
901
902         if (!drv->ops->change_station) {
903                 err = -EOPNOTSUPP;
904                 goto out;
905         }
906
907         rtnl_lock();
908         err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
909         rtnl_unlock();
910
911  out:
912         if (params.vlan)
913                 dev_put(params.vlan);
914         cfg80211_put_dev(drv);
915         dev_put(dev);
916         return err;
917 }
918
919 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
920 {
921         struct cfg80211_registered_device *drv;
922         int err;
923         struct net_device *dev;
924         struct station_parameters params;
925         u8 *mac_addr = NULL;
926
927         memset(&params, 0, sizeof(params));
928
929         if (!info->attrs[NL80211_ATTR_MAC])
930                 return -EINVAL;
931
932         if (!info->attrs[NL80211_ATTR_STA_AID])
933                 return -EINVAL;
934
935         if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
936                 return -EINVAL;
937
938         if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
939                 return -EINVAL;
940
941         mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
942         params.supported_rates =
943                 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
944         params.supported_rates_len =
945                 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
946         params.listen_interval =
947                 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
948         params.listen_interval = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
949
950         if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
951                                 &params.station_flags))
952                 return -EINVAL;
953
954         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
955         if (err)
956                 return err;
957
958         err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
959         if (err)
960                 goto out;
961
962         if (!drv->ops->add_station) {
963                 err = -EOPNOTSUPP;
964                 goto out;
965         }
966
967         rtnl_lock();
968         err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
969         rtnl_unlock();
970
971  out:
972         if (params.vlan)
973                 dev_put(params.vlan);
974         cfg80211_put_dev(drv);
975         dev_put(dev);
976         return err;
977 }
978
979 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
980 {
981         struct cfg80211_registered_device *drv;
982         int err;
983         struct net_device *dev;
984         u8 *mac_addr = NULL;
985
986         if (info->attrs[NL80211_ATTR_MAC])
987                 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
988
989         err = get_drv_dev_by_info_ifindex(info, &drv, &dev);
990         if (err)
991                 return err;
992
993         if (!drv->ops->del_station) {
994                 err = -EOPNOTSUPP;
995                 goto out;
996         }
997
998         rtnl_lock();
999         err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
1000         rtnl_unlock();
1001
1002  out:
1003         cfg80211_put_dev(drv);
1004         dev_put(dev);
1005         return err;
1006 }
1007
1008 static struct genl_ops nl80211_ops[] = {
1009         {
1010                 .cmd = NL80211_CMD_GET_WIPHY,
1011                 .doit = nl80211_get_wiphy,
1012                 .dumpit = nl80211_dump_wiphy,
1013                 .policy = nl80211_policy,
1014                 /* can be retrieved by unprivileged users */
1015         },
1016         {
1017                 .cmd = NL80211_CMD_SET_WIPHY,
1018                 .doit = nl80211_set_wiphy,
1019                 .policy = nl80211_policy,
1020                 .flags = GENL_ADMIN_PERM,
1021         },
1022         {
1023                 .cmd = NL80211_CMD_GET_INTERFACE,
1024                 .doit = nl80211_get_interface,
1025                 .dumpit = nl80211_dump_interface,
1026                 .policy = nl80211_policy,
1027                 /* can be retrieved by unprivileged users */
1028         },
1029         {
1030                 .cmd = NL80211_CMD_SET_INTERFACE,
1031                 .doit = nl80211_set_interface,
1032                 .policy = nl80211_policy,
1033                 .flags = GENL_ADMIN_PERM,
1034         },
1035         {
1036                 .cmd = NL80211_CMD_NEW_INTERFACE,
1037                 .doit = nl80211_new_interface,
1038                 .policy = nl80211_policy,
1039                 .flags = GENL_ADMIN_PERM,
1040         },
1041         {
1042                 .cmd = NL80211_CMD_DEL_INTERFACE,
1043                 .doit = nl80211_del_interface,
1044                 .policy = nl80211_policy,
1045                 .flags = GENL_ADMIN_PERM,
1046         },
1047         {
1048                 .cmd = NL80211_CMD_GET_KEY,
1049                 .doit = nl80211_get_key,
1050                 .policy = nl80211_policy,
1051                 .flags = GENL_ADMIN_PERM,
1052         },
1053         {
1054                 .cmd = NL80211_CMD_SET_KEY,
1055                 .doit = nl80211_set_key,
1056                 .policy = nl80211_policy,
1057                 .flags = GENL_ADMIN_PERM,
1058         },
1059         {
1060                 .cmd = NL80211_CMD_NEW_KEY,
1061                 .doit = nl80211_new_key,
1062                 .policy = nl80211_policy,
1063                 .flags = GENL_ADMIN_PERM,
1064         },
1065         {
1066                 .cmd = NL80211_CMD_DEL_KEY,
1067                 .doit = nl80211_del_key,
1068                 .policy = nl80211_policy,
1069                 .flags = GENL_ADMIN_PERM,
1070         },
1071         {
1072                 .cmd = NL80211_CMD_SET_BEACON,
1073                 .policy = nl80211_policy,
1074                 .flags = GENL_ADMIN_PERM,
1075                 .doit = nl80211_addset_beacon,
1076         },
1077         {
1078                 .cmd = NL80211_CMD_NEW_BEACON,
1079                 .policy = nl80211_policy,
1080                 .flags = GENL_ADMIN_PERM,
1081                 .doit = nl80211_addset_beacon,
1082         },
1083         {
1084                 .cmd = NL80211_CMD_DEL_BEACON,
1085                 .policy = nl80211_policy,
1086                 .flags = GENL_ADMIN_PERM,
1087                 .doit = nl80211_del_beacon,
1088         },
1089         {
1090                 .cmd = NL80211_CMD_GET_STATION,
1091                 .doit = nl80211_get_station,
1092                 /* TODO: implement dumpit */
1093                 .policy = nl80211_policy,
1094                 .flags = GENL_ADMIN_PERM,
1095         },
1096         {
1097                 .cmd = NL80211_CMD_SET_STATION,
1098                 .doit = nl80211_set_station,
1099                 .policy = nl80211_policy,
1100                 .flags = GENL_ADMIN_PERM,
1101         },
1102         {
1103                 .cmd = NL80211_CMD_NEW_STATION,
1104                 .doit = nl80211_new_station,
1105                 .policy = nl80211_policy,
1106                 .flags = GENL_ADMIN_PERM,
1107         },
1108         {
1109                 .cmd = NL80211_CMD_DEL_STATION,
1110                 .doit = nl80211_del_station,
1111                 .policy = nl80211_policy,
1112                 .flags = GENL_ADMIN_PERM,
1113         },
1114 };
1115
1116 /* multicast groups */
1117 static struct genl_multicast_group nl80211_config_mcgrp = {
1118         .name = "config",
1119 };
1120
1121 /* notification functions */
1122
1123 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
1124 {
1125         struct sk_buff *msg;
1126
1127         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1128         if (!msg)
1129                 return;
1130
1131         if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
1132                 nlmsg_free(msg);
1133                 return;
1134         }
1135
1136         genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
1137 }
1138
1139 /* initialisation/exit functions */
1140
1141 int nl80211_init(void)
1142 {
1143         int err, i;
1144
1145         err = genl_register_family(&nl80211_fam);
1146         if (err)
1147                 return err;
1148
1149         for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
1150                 err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
1151                 if (err)
1152                         goto err_out;
1153         }
1154
1155         err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
1156         if (err)
1157                 goto err_out;
1158
1159         return 0;
1160  err_out:
1161         genl_unregister_family(&nl80211_fam);
1162         return err;
1163 }
1164
1165 void nl80211_exit(void)
1166 {
1167         genl_unregister_family(&nl80211_fam);
1168 }