Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6] / net / mac80211 / cfg.c
1 /*
2  * mac80211 configuration hooks for cfg80211
3  *
4  * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * This file is GPLv2 as found in COPYING.
7  */
8
9 #include <linux/ieee80211.h>
10 #include <linux/nl80211.h>
11 #include <linux/rtnetlink.h>
12 #include <net/net_namespace.h>
13 #include <linux/rcupdate.h>
14 #include <net/cfg80211.h>
15 #include "ieee80211_i.h"
16 #include "cfg.h"
17 #include "rate.h"
18 #include "mesh.h"
19
20 static enum ieee80211_if_types
21 nl80211_type_to_mac80211_type(enum nl80211_iftype type)
22 {
23         switch (type) {
24         case NL80211_IFTYPE_UNSPECIFIED:
25                 return IEEE80211_IF_TYPE_STA;
26         case NL80211_IFTYPE_ADHOC:
27                 return IEEE80211_IF_TYPE_IBSS;
28         case NL80211_IFTYPE_STATION:
29                 return IEEE80211_IF_TYPE_STA;
30         case NL80211_IFTYPE_MONITOR:
31                 return IEEE80211_IF_TYPE_MNTR;
32 #ifdef CONFIG_MAC80211_MESH
33         case NL80211_IFTYPE_MESH_POINT:
34                 return IEEE80211_IF_TYPE_MESH_POINT;
35 #endif
36         case NL80211_IFTYPE_WDS:
37                 return IEEE80211_IF_TYPE_WDS;
38         default:
39                 return IEEE80211_IF_TYPE_INVALID;
40         }
41 }
42
43 static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
44                                enum nl80211_iftype type, u32 *flags,
45                                struct vif_params *params)
46 {
47         struct ieee80211_local *local = wiphy_priv(wiphy);
48         enum ieee80211_if_types itype;
49         struct net_device *dev;
50         struct ieee80211_sub_if_data *sdata;
51         int err;
52
53         itype = nl80211_type_to_mac80211_type(type);
54         if (itype == IEEE80211_IF_TYPE_INVALID)
55                 return -EINVAL;
56
57         err = ieee80211_if_add(local, name, &dev, itype, params);
58         if (err || itype != IEEE80211_IF_TYPE_MNTR || !flags)
59                 return err;
60
61         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
62         sdata->u.mntr_flags = *flags;
63         return 0;
64 }
65
66 static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex)
67 {
68         struct net_device *dev;
69
70         /* we're under RTNL */
71         dev = __dev_get_by_index(&init_net, ifindex);
72         if (!dev)
73                 return -ENODEV;
74
75         ieee80211_if_remove(dev);
76
77         return 0;
78 }
79
80 static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex,
81                                   enum nl80211_iftype type, u32 *flags,
82                                   struct vif_params *params)
83 {
84         struct net_device *dev;
85         enum ieee80211_if_types itype;
86         struct ieee80211_sub_if_data *sdata;
87         int ret;
88
89         /* we're under RTNL */
90         dev = __dev_get_by_index(&init_net, ifindex);
91         if (!dev)
92                 return -ENODEV;
93
94         itype = nl80211_type_to_mac80211_type(type);
95         if (itype == IEEE80211_IF_TYPE_INVALID)
96                 return -EINVAL;
97
98         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
99
100         ret = ieee80211_if_change_type(sdata, itype);
101         if (ret)
102                 return ret;
103
104         if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)
105                 ieee80211_if_sta_set_mesh_id(&sdata->u.sta,
106                                              params->mesh_id_len,
107                                              params->mesh_id);
108
109         if (sdata->vif.type != IEEE80211_IF_TYPE_MNTR || !flags)
110                 return 0;
111
112         sdata->u.mntr_flags = *flags;
113         return 0;
114 }
115
116 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
117                              u8 key_idx, u8 *mac_addr,
118                              struct key_params *params)
119 {
120         struct ieee80211_sub_if_data *sdata;
121         struct sta_info *sta = NULL;
122         enum ieee80211_key_alg alg;
123         struct ieee80211_key *key;
124         int err;
125
126         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
127
128         switch (params->cipher) {
129         case WLAN_CIPHER_SUITE_WEP40:
130         case WLAN_CIPHER_SUITE_WEP104:
131                 alg = ALG_WEP;
132                 break;
133         case WLAN_CIPHER_SUITE_TKIP:
134                 alg = ALG_TKIP;
135                 break;
136         case WLAN_CIPHER_SUITE_CCMP:
137                 alg = ALG_CCMP;
138                 break;
139         default:
140                 return -EINVAL;
141         }
142
143         key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key);
144         if (!key)
145                 return -ENOMEM;
146
147         rcu_read_lock();
148
149         if (mac_addr) {
150                 sta = sta_info_get(sdata->local, mac_addr);
151                 if (!sta) {
152                         ieee80211_key_free(key);
153                         err = -ENOENT;
154                         goto out_unlock;
155                 }
156         }
157
158         ieee80211_key_link(key, sdata, sta);
159
160         err = 0;
161  out_unlock:
162         rcu_read_unlock();
163
164         return err;
165 }
166
167 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
168                              u8 key_idx, u8 *mac_addr)
169 {
170         struct ieee80211_sub_if_data *sdata;
171         struct sta_info *sta;
172         int ret;
173
174         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
175
176         rcu_read_lock();
177
178         if (mac_addr) {
179                 ret = -ENOENT;
180
181                 sta = sta_info_get(sdata->local, mac_addr);
182                 if (!sta)
183                         goto out_unlock;
184
185                 if (sta->key) {
186                         ieee80211_key_free(sta->key);
187                         WARN_ON(sta->key);
188                         ret = 0;
189                 }
190
191                 goto out_unlock;
192         }
193
194         if (!sdata->keys[key_idx]) {
195                 ret = -ENOENT;
196                 goto out_unlock;
197         }
198
199         ieee80211_key_free(sdata->keys[key_idx]);
200         WARN_ON(sdata->keys[key_idx]);
201
202         ret = 0;
203  out_unlock:
204         rcu_read_unlock();
205
206         return ret;
207 }
208
209 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
210                              u8 key_idx, u8 *mac_addr, void *cookie,
211                              void (*callback)(void *cookie,
212                                               struct key_params *params))
213 {
214         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
215         struct sta_info *sta = NULL;
216         u8 seq[6] = {0};
217         struct key_params params;
218         struct ieee80211_key *key;
219         u32 iv32;
220         u16 iv16;
221         int err = -ENOENT;
222
223         rcu_read_lock();
224
225         if (mac_addr) {
226                 sta = sta_info_get(sdata->local, mac_addr);
227                 if (!sta)
228                         goto out;
229
230                 key = sta->key;
231         } else
232                 key = sdata->keys[key_idx];
233
234         if (!key)
235                 goto out;
236
237         memset(&params, 0, sizeof(params));
238
239         switch (key->conf.alg) {
240         case ALG_TKIP:
241                 params.cipher = WLAN_CIPHER_SUITE_TKIP;
242
243                 iv32 = key->u.tkip.tx.iv32;
244                 iv16 = key->u.tkip.tx.iv16;
245
246                 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
247                     sdata->local->ops->get_tkip_seq)
248                         sdata->local->ops->get_tkip_seq(
249                                 local_to_hw(sdata->local),
250                                 key->conf.hw_key_idx,
251                                 &iv32, &iv16);
252
253                 seq[0] = iv16 & 0xff;
254                 seq[1] = (iv16 >> 8) & 0xff;
255                 seq[2] = iv32 & 0xff;
256                 seq[3] = (iv32 >> 8) & 0xff;
257                 seq[4] = (iv32 >> 16) & 0xff;
258                 seq[5] = (iv32 >> 24) & 0xff;
259                 params.seq = seq;
260                 params.seq_len = 6;
261                 break;
262         case ALG_CCMP:
263                 params.cipher = WLAN_CIPHER_SUITE_CCMP;
264                 seq[0] = key->u.ccmp.tx_pn[5];
265                 seq[1] = key->u.ccmp.tx_pn[4];
266                 seq[2] = key->u.ccmp.tx_pn[3];
267                 seq[3] = key->u.ccmp.tx_pn[2];
268                 seq[4] = key->u.ccmp.tx_pn[1];
269                 seq[5] = key->u.ccmp.tx_pn[0];
270                 params.seq = seq;
271                 params.seq_len = 6;
272                 break;
273         case ALG_WEP:
274                 if (key->conf.keylen == 5)
275                         params.cipher = WLAN_CIPHER_SUITE_WEP40;
276                 else
277                         params.cipher = WLAN_CIPHER_SUITE_WEP104;
278                 break;
279         }
280
281         params.key = key->conf.key;
282         params.key_len = key->conf.keylen;
283
284         callback(cookie, &params);
285         err = 0;
286
287  out:
288         rcu_read_unlock();
289         return err;
290 }
291
292 static int ieee80211_config_default_key(struct wiphy *wiphy,
293                                         struct net_device *dev,
294                                         u8 key_idx)
295 {
296         struct ieee80211_sub_if_data *sdata;
297
298         rcu_read_lock();
299
300         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
301         ieee80211_set_default_key(sdata, key_idx);
302
303         rcu_read_unlock();
304
305         return 0;
306 }
307
308 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
309 {
310         struct ieee80211_sub_if_data *sdata = sta->sdata;
311
312         sinfo->filled = STATION_INFO_INACTIVE_TIME |
313                         STATION_INFO_RX_BYTES |
314                         STATION_INFO_TX_BYTES;
315
316         sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
317         sinfo->rx_bytes = sta->rx_bytes;
318         sinfo->tx_bytes = sta->tx_bytes;
319
320         if (ieee80211_vif_is_mesh(&sdata->vif)) {
321 #ifdef CONFIG_MAC80211_MESH
322                 sinfo->filled |= STATION_INFO_LLID |
323                                  STATION_INFO_PLID |
324                                  STATION_INFO_PLINK_STATE;
325
326                 sinfo->llid = le16_to_cpu(sta->llid);
327                 sinfo->plid = le16_to_cpu(sta->plid);
328                 sinfo->plink_state = sta->plink_state;
329 #endif
330         }
331 }
332
333
334 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
335                                  int idx, u8 *mac, struct station_info *sinfo)
336 {
337         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
338         struct sta_info *sta;
339         int ret = -ENOENT;
340
341         rcu_read_lock();
342
343         sta = sta_info_get_by_idx(local, idx, dev);
344         if (sta) {
345                 ret = 0;
346                 memcpy(mac, sta->addr, ETH_ALEN);
347                 sta_set_sinfo(sta, sinfo);
348         }
349
350         rcu_read_unlock();
351
352         return ret;
353 }
354
355 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
356                                  u8 *mac, struct station_info *sinfo)
357 {
358         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
359         struct sta_info *sta;
360         int ret = -ENOENT;
361
362         rcu_read_lock();
363
364         /* XXX: verify sta->dev == dev */
365
366         sta = sta_info_get(local, mac);
367         if (sta) {
368                 ret = 0;
369                 sta_set_sinfo(sta, sinfo);
370         }
371
372         rcu_read_unlock();
373
374         return ret;
375 }
376
377 /*
378  * This handles both adding a beacon and setting new beacon info
379  */
380 static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
381                                    struct beacon_parameters *params)
382 {
383         struct beacon_data *new, *old;
384         int new_head_len, new_tail_len;
385         int size;
386         int err = -EINVAL;
387
388         old = sdata->u.ap.beacon;
389
390         /* head must not be zero-length */
391         if (params->head && !params->head_len)
392                 return -EINVAL;
393
394         /*
395          * This is a kludge. beacon interval should really be part
396          * of the beacon information.
397          */
398         if (params->interval) {
399                 sdata->local->hw.conf.beacon_int = params->interval;
400                 if (ieee80211_hw_config(sdata->local))
401                         return -EINVAL;
402                 /*
403                  * We updated some parameter so if below bails out
404                  * it's not an error.
405                  */
406                 err = 0;
407         }
408
409         /* Need to have a beacon head if we don't have one yet */
410         if (!params->head && !old)
411                 return err;
412
413         /* sorry, no way to start beaconing without dtim period */
414         if (!params->dtim_period && !old)
415                 return err;
416
417         /* new or old head? */
418         if (params->head)
419                 new_head_len = params->head_len;
420         else
421                 new_head_len = old->head_len;
422
423         /* new or old tail? */
424         if (params->tail || !old)
425                 /* params->tail_len will be zero for !params->tail */
426                 new_tail_len = params->tail_len;
427         else
428                 new_tail_len = old->tail_len;
429
430         size = sizeof(*new) + new_head_len + new_tail_len;
431
432         new = kzalloc(size, GFP_KERNEL);
433         if (!new)
434                 return -ENOMEM;
435
436         /* start filling the new info now */
437
438         /* new or old dtim period? */
439         if (params->dtim_period)
440                 new->dtim_period = params->dtim_period;
441         else
442                 new->dtim_period = old->dtim_period;
443
444         /*
445          * pointers go into the block we allocated,
446          * memory is | beacon_data | head | tail |
447          */
448         new->head = ((u8 *) new) + sizeof(*new);
449         new->tail = new->head + new_head_len;
450         new->head_len = new_head_len;
451         new->tail_len = new_tail_len;
452
453         /* copy in head */
454         if (params->head)
455                 memcpy(new->head, params->head, new_head_len);
456         else
457                 memcpy(new->head, old->head, new_head_len);
458
459         /* copy in optional tail */
460         if (params->tail)
461                 memcpy(new->tail, params->tail, new_tail_len);
462         else
463                 if (old)
464                         memcpy(new->tail, old->tail, new_tail_len);
465
466         rcu_assign_pointer(sdata->u.ap.beacon, new);
467
468         synchronize_rcu();
469
470         kfree(old);
471
472         return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
473 }
474
475 static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev,
476                                 struct beacon_parameters *params)
477 {
478         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
479         struct beacon_data *old;
480
481         if (sdata->vif.type != IEEE80211_IF_TYPE_AP)
482                 return -EINVAL;
483
484         old = sdata->u.ap.beacon;
485
486         if (old)
487                 return -EALREADY;
488
489         return ieee80211_config_beacon(sdata, params);
490 }
491
492 static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev,
493                                 struct beacon_parameters *params)
494 {
495         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
496         struct beacon_data *old;
497
498         if (sdata->vif.type != IEEE80211_IF_TYPE_AP)
499                 return -EINVAL;
500
501         old = sdata->u.ap.beacon;
502
503         if (!old)
504                 return -ENOENT;
505
506         return ieee80211_config_beacon(sdata, params);
507 }
508
509 static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev)
510 {
511         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
512         struct beacon_data *old;
513
514         if (sdata->vif.type != IEEE80211_IF_TYPE_AP)
515                 return -EINVAL;
516
517         old = sdata->u.ap.beacon;
518
519         if (!old)
520                 return -ENOENT;
521
522         rcu_assign_pointer(sdata->u.ap.beacon, NULL);
523         synchronize_rcu();
524         kfree(old);
525
526         return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
527 }
528
529 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
530 struct iapp_layer2_update {
531         u8 da[ETH_ALEN];        /* broadcast */
532         u8 sa[ETH_ALEN];        /* STA addr */
533         __be16 len;             /* 6 */
534         u8 dsap;                /* 0 */
535         u8 ssap;                /* 0 */
536         u8 control;
537         u8 xid_info[3];
538 } __attribute__ ((packed));
539
540 static void ieee80211_send_layer2_update(struct sta_info *sta)
541 {
542         struct iapp_layer2_update *msg;
543         struct sk_buff *skb;
544
545         /* Send Level 2 Update Frame to update forwarding tables in layer 2
546          * bridge devices */
547
548         skb = dev_alloc_skb(sizeof(*msg));
549         if (!skb)
550                 return;
551         msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));
552
553         /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
554          * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
555
556         memset(msg->da, 0xff, ETH_ALEN);
557         memcpy(msg->sa, sta->addr, ETH_ALEN);
558         msg->len = htons(6);
559         msg->dsap = 0;
560         msg->ssap = 0x01;       /* NULL LSAP, CR Bit: Response */
561         msg->control = 0xaf;    /* XID response lsb.1111F101.
562                                  * F=0 (no poll command; unsolicited frame) */
563         msg->xid_info[0] = 0x81;        /* XID format identifier */
564         msg->xid_info[1] = 1;   /* LLC types/classes: Type 1 LLC */
565         msg->xid_info[2] = 0;   /* XID sender's receive window size (RW) */
566
567         skb->dev = sta->sdata->dev;
568         skb->protocol = eth_type_trans(skb, sta->sdata->dev);
569         memset(skb->cb, 0, sizeof(skb->cb));
570         netif_rx(skb);
571 }
572
573 static void sta_apply_parameters(struct ieee80211_local *local,
574                                  struct sta_info *sta,
575                                  struct station_parameters *params)
576 {
577         u32 rates;
578         int i, j;
579         struct ieee80211_supported_band *sband;
580         struct ieee80211_sub_if_data *sdata = sta->sdata;
581
582         /*
583          * FIXME: updating the flags is racy when this function is
584          *        called from ieee80211_change_station(), this will
585          *        be resolved in a future patch.
586          */
587
588         if (params->station_flags & STATION_FLAG_CHANGED) {
589                 spin_lock_bh(&sta->lock);
590                 sta->flags &= ~WLAN_STA_AUTHORIZED;
591                 if (params->station_flags & STATION_FLAG_AUTHORIZED)
592                         sta->flags |= WLAN_STA_AUTHORIZED;
593
594                 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
595                 if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE)
596                         sta->flags |= WLAN_STA_SHORT_PREAMBLE;
597
598                 sta->flags &= ~WLAN_STA_WME;
599                 if (params->station_flags & STATION_FLAG_WME)
600                         sta->flags |= WLAN_STA_WME;
601                 spin_unlock_bh(&sta->lock);
602         }
603
604         /*
605          * FIXME: updating the following information is racy when this
606          *        function is called from ieee80211_change_station().
607          *        However, all this information should be static so
608          *        maybe we should just reject attemps to change it.
609          */
610
611         if (params->aid) {
612                 sta->aid = params->aid;
613                 if (sta->aid > IEEE80211_MAX_AID)
614                         sta->aid = 0; /* XXX: should this be an error? */
615         }
616
617         if (params->listen_interval >= 0)
618                 sta->listen_interval = params->listen_interval;
619
620         if (params->supported_rates) {
621                 rates = 0;
622                 sband = local->hw.wiphy->bands[local->oper_channel->band];
623
624                 for (i = 0; i < params->supported_rates_len; i++) {
625                         int rate = (params->supported_rates[i] & 0x7f) * 5;
626                         for (j = 0; j < sband->n_bitrates; j++) {
627                                 if (sband->bitrates[j].bitrate == rate)
628                                         rates |= BIT(j);
629                         }
630                 }
631                 sta->supp_rates[local->oper_channel->band] = rates;
632         }
633
634         if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {
635                 switch (params->plink_action) {
636                 case PLINK_ACTION_OPEN:
637                         mesh_plink_open(sta);
638                         break;
639                 case PLINK_ACTION_BLOCK:
640                         mesh_plink_block(sta);
641                         break;
642                 }
643         }
644 }
645
646 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
647                                  u8 *mac, struct station_parameters *params)
648 {
649         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
650         struct sta_info *sta;
651         struct ieee80211_sub_if_data *sdata;
652         int err;
653
654         /* Prevent a race with changing the rate control algorithm */
655         if (!netif_running(dev))
656                 return -ENETDOWN;
657
658         if (params->vlan) {
659                 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
660
661                 if (sdata->vif.type != IEEE80211_IF_TYPE_VLAN &&
662                     sdata->vif.type != IEEE80211_IF_TYPE_AP)
663                         return -EINVAL;
664         } else
665                 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
666
667         if (compare_ether_addr(mac, dev->dev_addr) == 0)
668                 return -EINVAL;
669
670         if (is_multicast_ether_addr(mac))
671                 return -EINVAL;
672
673         sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
674         if (!sta)
675                 return -ENOMEM;
676
677         sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;
678
679         sta_apply_parameters(local, sta, params);
680
681         rate_control_rate_init(sta, local);
682
683         rcu_read_lock();
684
685         err = sta_info_insert(sta);
686         if (err) {
687                 /* STA has been freed */
688                 rcu_read_unlock();
689                 return err;
690         }
691
692         if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN ||
693             sdata->vif.type == IEEE80211_IF_TYPE_AP)
694                 ieee80211_send_layer2_update(sta);
695
696         rcu_read_unlock();
697
698         return 0;
699 }
700
701 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
702                                  u8 *mac)
703 {
704         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
705         struct ieee80211_local *local = sdata->local;
706         struct sta_info *sta;
707
708         if (mac) {
709                 rcu_read_lock();
710
711                 /* XXX: get sta belonging to dev */
712                 sta = sta_info_get(local, mac);
713                 if (!sta) {
714                         rcu_read_unlock();
715                         return -ENOENT;
716                 }
717
718                 sta_info_unlink(&sta);
719                 rcu_read_unlock();
720
721                 sta_info_destroy(sta);
722         } else
723                 sta_info_flush(local, sdata);
724
725         return 0;
726 }
727
728 static int ieee80211_change_station(struct wiphy *wiphy,
729                                     struct net_device *dev,
730                                     u8 *mac,
731                                     struct station_parameters *params)
732 {
733         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
734         struct sta_info *sta;
735         struct ieee80211_sub_if_data *vlansdata;
736
737         rcu_read_lock();
738
739         /* XXX: get sta belonging to dev */
740         sta = sta_info_get(local, mac);
741         if (!sta) {
742                 rcu_read_unlock();
743                 return -ENOENT;
744         }
745
746         if (params->vlan && params->vlan != sta->sdata->dev) {
747                 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
748
749                 if (vlansdata->vif.type != IEEE80211_IF_TYPE_VLAN &&
750                     vlansdata->vif.type != IEEE80211_IF_TYPE_AP) {
751                         rcu_read_unlock();
752                         return -EINVAL;
753                 }
754
755                 sta->sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
756                 ieee80211_send_layer2_update(sta);
757         }
758
759         sta_apply_parameters(local, sta, params);
760
761         rcu_read_unlock();
762
763         return 0;
764 }
765
766 #ifdef CONFIG_MAC80211_MESH
767 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
768                                  u8 *dst, u8 *next_hop)
769 {
770         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
771         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
772         struct mesh_path *mpath;
773         struct sta_info *sta;
774         int err;
775
776         if (!netif_running(dev))
777                 return -ENETDOWN;
778
779         if (sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT)
780                 return -ENOTSUPP;
781
782         rcu_read_lock();
783         sta = sta_info_get(local, next_hop);
784         if (!sta) {
785                 rcu_read_unlock();
786                 return -ENOENT;
787         }
788
789         err = mesh_path_add(dst, dev);
790         if (err) {
791                 rcu_read_unlock();
792                 return err;
793         }
794
795         mpath = mesh_path_lookup(dst, dev);
796         if (!mpath) {
797                 rcu_read_unlock();
798                 return -ENXIO;
799         }
800         mesh_path_fix_nexthop(mpath, sta);
801
802         rcu_read_unlock();
803         return 0;
804 }
805
806 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
807                                  u8 *dst)
808 {
809         if (dst)
810                 return mesh_path_del(dst, dev);
811
812         mesh_path_flush(dev);
813         return 0;
814 }
815
816 static int ieee80211_change_mpath(struct wiphy *wiphy,
817                                     struct net_device *dev,
818                                     u8 *dst, u8 *next_hop)
819 {
820         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
821         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
822         struct mesh_path *mpath;
823         struct sta_info *sta;
824
825         if (!netif_running(dev))
826                 return -ENETDOWN;
827
828         if (sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT)
829                 return -ENOTSUPP;
830
831         rcu_read_lock();
832
833         sta = sta_info_get(local, next_hop);
834         if (!sta) {
835                 rcu_read_unlock();
836                 return -ENOENT;
837         }
838
839         mpath = mesh_path_lookup(dst, dev);
840         if (!mpath) {
841                 rcu_read_unlock();
842                 return -ENOENT;
843         }
844
845         mesh_path_fix_nexthop(mpath, sta);
846
847         rcu_read_unlock();
848         return 0;
849 }
850
851 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
852                             struct mpath_info *pinfo)
853 {
854         if (mpath->next_hop)
855                 memcpy(next_hop, mpath->next_hop->addr, ETH_ALEN);
856         else
857                 memset(next_hop, 0, ETH_ALEN);
858
859         pinfo->filled = MPATH_INFO_FRAME_QLEN |
860                         MPATH_INFO_DSN |
861                         MPATH_INFO_METRIC |
862                         MPATH_INFO_EXPTIME |
863                         MPATH_INFO_DISCOVERY_TIMEOUT |
864                         MPATH_INFO_DISCOVERY_RETRIES |
865                         MPATH_INFO_FLAGS;
866
867         pinfo->frame_qlen = mpath->frame_queue.qlen;
868         pinfo->dsn = mpath->dsn;
869         pinfo->metric = mpath->metric;
870         if (time_before(jiffies, mpath->exp_time))
871                 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
872         pinfo->discovery_timeout =
873                         jiffies_to_msecs(mpath->discovery_timeout);
874         pinfo->discovery_retries = mpath->discovery_retries;
875         pinfo->flags = 0;
876         if (mpath->flags & MESH_PATH_ACTIVE)
877                 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
878         if (mpath->flags & MESH_PATH_RESOLVING)
879                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
880         if (mpath->flags & MESH_PATH_DSN_VALID)
881                 pinfo->flags |= NL80211_MPATH_FLAG_DSN_VALID;
882         if (mpath->flags & MESH_PATH_FIXED)
883                 pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
884         if (mpath->flags & MESH_PATH_RESOLVING)
885                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
886
887         pinfo->flags = mpath->flags;
888 }
889
890 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
891                                u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
892
893 {
894         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
895         struct mesh_path *mpath;
896
897         if (sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT)
898                 return -ENOTSUPP;
899
900         rcu_read_lock();
901         mpath = mesh_path_lookup(dst, dev);
902         if (!mpath) {
903                 rcu_read_unlock();
904                 return -ENOENT;
905         }
906         memcpy(dst, mpath->dst, ETH_ALEN);
907         mpath_set_pinfo(mpath, next_hop, pinfo);
908         rcu_read_unlock();
909         return 0;
910 }
911
912 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
913                                  int idx, u8 *dst, u8 *next_hop,
914                                  struct mpath_info *pinfo)
915 {
916         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
917         struct mesh_path *mpath;
918
919         if (sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT)
920                 return -ENOTSUPP;
921
922         rcu_read_lock();
923         mpath = mesh_path_lookup_by_idx(idx, dev);
924         if (!mpath) {
925                 rcu_read_unlock();
926                 return -ENOENT;
927         }
928         memcpy(dst, mpath->dst, ETH_ALEN);
929         mpath_set_pinfo(mpath, next_hop, pinfo);
930         rcu_read_unlock();
931         return 0;
932 }
933 #endif
934
935 struct cfg80211_ops mac80211_config_ops = {
936         .add_virtual_intf = ieee80211_add_iface,
937         .del_virtual_intf = ieee80211_del_iface,
938         .change_virtual_intf = ieee80211_change_iface,
939         .add_key = ieee80211_add_key,
940         .del_key = ieee80211_del_key,
941         .get_key = ieee80211_get_key,
942         .set_default_key = ieee80211_config_default_key,
943         .add_beacon = ieee80211_add_beacon,
944         .set_beacon = ieee80211_set_beacon,
945         .del_beacon = ieee80211_del_beacon,
946         .add_station = ieee80211_add_station,
947         .del_station = ieee80211_del_station,
948         .change_station = ieee80211_change_station,
949         .get_station = ieee80211_get_station,
950         .dump_station = ieee80211_dump_station,
951 #ifdef CONFIG_MAC80211_MESH
952         .add_mpath = ieee80211_add_mpath,
953         .del_mpath = ieee80211_del_mpath,
954         .change_mpath = ieee80211_change_mpath,
955         .get_mpath = ieee80211_get_mpath,
956         .dump_mpath = ieee80211_dump_mpath,
957 #endif
958 };